diff options
Diffstat (limited to 'vendor/plugins/rspec')
190 files changed, 12147 insertions, 0 deletions
diff --git a/vendor/plugins/rspec/.document b/vendor/plugins/rspec/.document new file mode 100644 index 000000000..c845fd37d --- /dev/null +++ b/vendor/plugins/rspec/.document @@ -0,0 +1,7 @@ +features/**/*.feature +lib/**/*.rb +History.rdoc +License.txt +README.rdoc +Ruby1.9.rdoc +Upgrade.rdoc diff --git a/vendor/plugins/rspec/History.rdoc b/vendor/plugins/rspec/History.rdoc new file mode 100644 index 000000000..9e4e146f1 --- /dev/null +++ b/vendor/plugins/rspec/History.rdoc @@ -0,0 +1,1496 @@ +=== Version 1.2.9 / 2009-10-05 + +* enhancements + * manage backtrace-ignore patterns with Spec::Runner.configure (Martin + Emde). Closes #870. + * friendly mock argument expectation failure message (Tim Harper). Closes + #868. + * added double() as alias for stub() and mock() + * failure messages for doubles, mocks and stubs use the right name + * add let() method to assign memoized attributes (suggestion from Stuart + Halloway). Closes #857. + * add its method so you can say: + describe Array do + its(:length) { should == 0 } + (Stephen Touset). Closes #833 + * spec command automatically uses spec/spec.opts if it is present + (suggestion from Yehuda Katz) + * rspec now adds PROJECT_ROOT/lib and PROJECT_ROOT/spec to the load path + * determines PROJECT_ROOT by recursing up until it finds a directory + that has a ./spec directory (thanks to Scott Taylor) + * supports require 'spec_helper' + * supports running specs from the PROJECT_ROOT or any directory + below it + * closes #733 + * better handling of determining test names in test/unit/interop mode + * Joe Ferris + * closes #854 + +* bug fixes + + * Fixed problem with colorized output when writing to a file + * Corey Ehmke + * closes #777 + +* not really a bug fix or enhancement + * temporarily moved heckle feature to features-pending (waiting to see what + happens with + http://rubyforge.org/tracker/index.php?func=detail&aid=26786&group_id=1513&atid=5921) + +=== Version 1.2.8 / 2009-07-16 + +* enhancements + * better messages for should[_not] be_nil (Chad Humphries and Rob Sanheim) + * should and should_not accept optional custom message + (suggestion from Rob Sanheim) + * result.should be_nil, "expected result to be nil" + * added 'spec/stubs/cucumber' to plug RSpec's stubbing framework into + Cucumber scenarios. + * added unstub method to remove a stub mid-example (Scott Taylor). Closes + #853. + * add more readable diff when expected and actual are hashes (Ryan Bigg). + Closes #848. + +* bug fixes + * fixed --line option for ruby 1.9.1 + * fix stub_chain conflict between two chains starting with the same message + (Mike Rohland). Closes #846. + +=== Version 1.2.7 / 2009-06-22 + +* enhancments + * added support for fakes using obj.stub(:method) { # implementation } + * allow subject { self } (Jarmo Pertman). Closes #816. + * friendly error message when a matcher returns nil on a failure message + * add ruby_cmd option to SpecTask (Rick DeNatale). Closes #823. + * also added missing specs for SpecTask - thanks Rick! + * add support for generating matchers with fluent interfaces with the + Matcher DSL + +* bug fixes + * NegativeOperatorMatcher now returns false (Wesley Beary). Closes #812. + * derive MockExpectationError from Exception rather than StandardError + (Kerry Buckley). Closes #830. + * fix bug where multi-line failure messages weren't getting picked up by + autotest (Jarmo Pertman). Closes #832. + * --line_number now works for it { should xxx } format (assist from Fred + Lee) + * warn instead of raise when there is no description supplied for an + example. Closes #840. + +=== Version 1.2.6 / 2009-04-30 + +* bug fixes + * gem actually built with spec executable + +=== Version 1.2.5 / 2009-04-29 + +* enhancements + + * name argument to mock/stub is now optional (closes #782) + * you can do mock(:foo => "woo", :bar => "car") + * expect { this_block }.to change{this.expression}.from(old_value).to(new_value) + * expect { this_block }.to raise_error + * better failiure messages for equal matcher (James Byrne). Closes #804. + * add stub_chain method + * also alias_method :stub, :stub!, so you can stub with less bang + * added options to example_group_proxy + +* bug fixes + + * ensure correct handling of ordered message expectations with duplicate + expectations (NigelThorne). Closes #793. + * get matcher backwards compat working w/ ruby 19 + * don't define instance_exec unless it is not defined + * was doing a version check, but turns out that didn't cover alternative + implementations like JRuby + * fix bug where in some circumstances, loading lib/spec/interop/test.rb + raised an error (tsechingho). Closes #803. + * make sure specs only run against spec server when using drb (patch from Chuck Grindel). Closes #797. + * remove deprecation warning in example_pending when using FailingExamplesFormatter. Closes #794. + * Access explicit subject from nested groups of arbitrary depth. Closes #756. + +=== Version 1.2.4 / 2009-04-13 + +* bug fix + + * just one - update the manifest + +=== Version 1.2.3 / 2009-04-13 + +* deprecations + + * BaseFormatter#add_example_group (use #example_group_started instead) + * ExampleGroupProxy#backtrace (use #location instead) + * ExampleProxy#backtrace (use #location instead) + * BaseFormatter#example_pending now expects two arguments. The third + argument is deprecated. + * ExampleGroupProxy#filtered_description. This was only used in one place + internally, and was a confusing solution to the problem. If you've got a + custom formatter that uses it, you can just use + ExampleGroupProxy#description and modify it directly. + * predicate_matchers (use the new Matcher DSL instead) + * Spec::Matchers.create (use Spec::Matchers.define instead) + +* enhancements + + * support for specifying single examples with colon syntax. Closes #712. + (Ben Mabey) + * you can now say "spec some_spec.rb:12" in addition to "spec some_spec.rb + --line 12" + * run specs locally with --drb if no drb server is running. Closes #780. + * still prints "No server running" to stderr + +* bug fixes + + * support expectations on DelegateClass (Clifford T. Matthews). Closes #48. + * Fixed match_array blows up if elements can't be sorted (Jeff Dean). Closes #779. + +=== Version 1.2.2 / 2009-03-22 + +Bug-fix release (fixes regression introduced in 1.2.1) + +* bug fixes + + * fixed bug in which spec_parser raised an error for custom example group + base classes + +=== Version 1.2.1 / 2009-03-22 + +This is a bug-fix release, recommended for anybody who has already upgraded to +rspec-1.2.0. + +See Upgrade.rdoc for information about upgrading to rspec-1.2.1 + +* enhancements + + * matchers, including the new DSL, easily added to your test/unit tests + * added support for 0 to n args in matcher DSL + * restored loading rubygems when necessary + * if you really don't want to use rubygems, you + can set an NO_RUBYGEMS environment + variable, and RSpec won't force it on you. + * added -u/--debugger option (Rick DeNatale) #262. + * just add "debugger" anywhere in your code and run spec path/to/code --debugger + * rename ExampleDescription to ExampleProxy + * pass ExampleProxy to example_started(). Closes #738, #743 + * thanks to Tobias Grimm (Eclipse) fort the patch and Roman Chernyatchik + (JetBrains, RubyMine) for the assist + +* bug fixes + + * subject (implicit or explicit) is now properly inherited by nested groups. Closes #744. + +=== Version 1.2.0 / 2009-03-15 + +* warnings: + + * If you use the ruby command to run specs instead of the spec command, you'll + need to require 'spec/autorun' or they won't run. This won't affect you if + you use the spec command or the Spec::Rake::SpecTask that ships with RSpec. + + * require 'spec/test/unit' to invoke test/unit interop if you're using + RSpec's core (this is handled implicitly with spec-rails) + + * setup and teardown are gone - use before and after instead + + * you can still use setup and teardown if you're using + Test::Unit::TestCase as the base ExampleGroup class (which is implicit + in rspec-rails) + + * The matcher protocol has been improved. The old protocol is still + supported, so as long as you're not monkey patching rspec's built-in + matchers, or using extension libraries that do, this should not affect + you. If you run into trouble, you'll just need to change: + + failure_message => failure_message_for_should + negative_failure_message => failure_message_for_should_not + + * All references to rubygems have been removed from within rspec's code. + + * NOTE that they have been restored in 1.2.1, above + + * See http://gist.github.com/54177 for rationale and suggestions on + alternative approaches to loading rubygems + +* deprecations + + * BaseTextFormatter#colourize - use colorize_failure instead. + * BaseTextFormatter#magenta - use red instead. + +* enhancements + + * cleaner integration with with heckle-1.4.2 + * allow registering example groups with a path-like key (Pat Maddox) + * start DRb service at "druby://localhost:0" (Hongli Lai) - See http://redmine.ruby-lang.org/issues/show/496 + * consistent reporting of errors as failures + * added spec/test/unit as more intuitive path to loading test/unit interop lib + * added explicit autorun feature for running specs with ruby command + * added handling for does_not_match? for matchers that want to know the context in which they were called + * lots of ruby 1.9.1 compatibility fixes from Chad Humprhies + * improved feedback from be_kind_of/be_a_kind_of/be_instance_of/be_an_instance_of (Jakub Šťastný) + * added --format silent (l) option, which is now the default when running --heckle (Bob Aman) + * sexy new custom matcher creation (Corey Haines & David Chelimsky - initial concept by Yehuda Katz) + * improved matcher protocol - old one is still supported, but new one is cleaner and prefered + +* bug fixes + + * support delegating operator matchers to subject with should_not + * all arguments are included if --drb is specified in spec.opts (Neil Buckley). Closes #671. + * added --autospec option hack (used internally) to get --color to work when using --drb and autospec. + * Fixed mock framework failure message bug in which similar calls were excluded from the output + * cryptic error message on change.rb when the from value is wrong (Michael Murray). Closes #706. + +=== Version 1.1.12 / 2009-01-11 + +WARNING: there was a stub/mock bug in 1.1.11 that allowed a structure that was +not intended: + + obj.stub!(:msg) + obj.msg + obj.should_receive(:msg) + +That would pass in 1.1.11, but should not have been allowed to, since the +message is received before the expectation is set. This was reported (#637) +and fixed for release 1.1.12, but may cause unexpected failures if you had +examples set up as above. + +WARNING: mock.should_receive(:msg).with(an_instance_of(klass)) now correctly uses instance_of? instead of kind_of?. This may break some existing code examples, but the fix is to just use kind_of instead of an_instance_of + +* 3 deprecations + + * deprecated ExampleMethods#implementation_backtrace - use ExampleMethods#backtrace instead + * deprecated ExampleGroupMethods#example_group_backtrace - use ExampleGroupMethods#backtrace instead + * deprecated Spec::Example::BehaviourRunner class (likely that nobody is using this) + +* 6 major enhancements + + * it { should matcher } - support for implicit receiver of #should (Joe Ferris of thoughtbot) + * subject { ... } - works in conjunction with implicit receiver of #should + * wrap_expectation (for wrapping multiple expectations and/or t/u assertions) + * added array.should =~ [1,2,3] # passes if array contains exactly the same elements in any order (Jeff Dean and Pat Maddox) + * hash_including mock argument matcher can now accept just keys, key/value pairs, or both (David Krmpotic) + * added hash_not_including mock argument matcher (David Krmpotic). Closes #634. + +* 9 minor enhancements + + * should throw_symbol accepts an optional argument: should throw_symbol(:sym, arg) + * fixed --line for jruby (Zach Moazeni) + * assorted small changes to support Ruby 1.9 (got a way to go) + * removed all instances of class << self - I do know who I am + * SpecParser can't handle backtrace paths with colons (John-Mason P. Shackelford). Closes #505. + * html formatter (and subsequently the textmate formatter) header fills in completely when running a single example + * config.include now accepts an array of types (config.include(Helpers, :type => [:view, :controller])) + * added be_a and be_an expectation matchers + * added instance_of and kind_of mock argument matchers + +* 9 bug fixes + + * fixed bug where {:a => 1, :b => 2}.should include(:a, :b) failed (Yossef Mendelssohn) + * only try to load Test::Unit if Test::Unit is defined (not just Test) + * Allow stubs on parent and child classes simultaneously (Jim Lindley). Fixes #600. + * BaseTextFormatter will now create the directory in a WHERE string (Adam Anderson). Fixes #616. + * Removed incorrect -S flag on autospec commands. Added explicit spec command for ruby to run, guarantee running rspec (raggi). Closes #507. + * Check whether test/unit has really been loaded before calling a method it defines (Brian Donovan). Closes #503. + * Fix spec_path for shared groups (Zach Dennis). Closes #615. + * stubbed message expectation not verified if it has been called *before* the expectation (Matthias Hennemeyer). Closes #637. + * stubs calculate return value by executing block passed to #and_return (hint from Aisha Fenton). Closes #642. + +=== Version 1.1.11 / 2008-10-24 + +* 1 major enhancement + + * eliminate ALL gem dependencies (as they were causing trouble for people on different platforms/environments) + +=== Version 1.1.10 / 2008-10-24 + +* 1 minor enhancement + + * hash.should include(:key => 'value') #when you don't care about the whole hash + +* 2 bug fixes + + * fix --help output (had inaccurate info about 'nested' formatter) + * eliminate spicycode-rcov dev dependency for rubygems < 1.3 + +=== Version 1.1.9 / 2008-10-20 + +WARNING: This release removes implicit inclusion of modules in example groups. +This means that if you have 'describe MyModule do', MyModule will not be +included in the group. + +* 2 major enhancements + + * Add extend to configuration (thanks to advice from Chad Fowler) + * Modules are no longer implicitly included in example groups + +* 4 minor enhancements + + * mingw indicates windows too (thanks to Luis Lavena for the tip) + * improved output for partial mock expecation failures + * it_should_behave_like now accepts n names of shared groups + * eliminated redundant inclusion/extension of ExampleGroupMethods + +* 6 bug fixes + + * spec command with no arguments prints help + * fixed typo in help. Fixes #73. + * fixed bug where should_receive..and_yield after similar stub added the args_to_yield to the stub's original args_to_yield (Pat Maddox) + * fixed bug where rspec-autotest (autospec) was loading non-spec files in spec directory. Fixes #559. + * fixed bug where should_not_receive was reporting twice + * fixed bug where rspec tries to run examples just because it is required (even if there are no examples loaded). Fixes #575. + +=== Version 1.1.8 / 2008-10-03 + +* 2 bug fixes + + * restore colorized output in linux and windows w/ autotest (Tim Pope). Fixes #413. + * autospec no longer hangs on windows. Fixes #554. + +=== Version 1.1.7 / 2008-10-02 + +* no changes since 1.1.6, but releasing rspec-1.1.7 to align versions with rspec-rails-1.1.7 + +=== Version 1.1.6 / 2008-10-02 + +* 2 bug fixes + + * fixed bug where negative message expectations following stubs resulted in false (negative) positives (Mathias Meyer). Closes #548. + * fixed bug where Not Yet Implemented examples report incorrect caller (Scott Taylor). Closes #547. + +* 1 minor enhancement + + * removed deprecated mock argument constraint symbols + +=== Version 1.1.5 / 2008-09-28 + +IMPORTANT: use the new 'autospec' command instead of 'autotest'. We changed +the way autotest discovers rspec so the autotest executable won't +automatically load rspec anymore. This allows rspec to live side by side other +spec frameworks without always co-opting autotest through autotest's discovery +mechanism. + +ALSO IMPORTANT: $rspec_options is gone. If you were using this for anything +(like your own runners), use Spec::Runner.options instead. + +ADDITIONALLY IMPORTANT: If you have any custom formatters, you'll need to +modify #example_pending to accept three arguments instead of just two. See the +rdoc for Spec::Runner::Formatter::BaseFormatter#example_pending for more +information. + +* Consider MinGW as valid RUBY_PLATFORM for --colour option. (patch from Luis Lavena). Closes #406. +* Added additional characters to be escaped in step strings (patch from Jake Cahoon). Closes #417. +* Disable color codes on STDOUT when STDOUT.tty? is false (patch from Tim Pope). Closes #413. +* mock(:null_object=>true) plays nice with HTML (patch from Gerrit Kaiser). Closes #230. +* a step definition with no block is treated as pending +* make sure consolidate_failures only grabs _spec files. Closes #369 +* Simplifying ExampleGroupMethods#registration_backtrace. (From Wilson Bilkovich - http://metaclass.org/2008/6/7/calling-in-the-dark) +* Use 127.0.0.1 instead of localhost for drb (thanks Ola Bini) +* html story formatter correctly colors story/scenario red if step fails (Patch from Joseph Wilk). Closes #300 +* plain text story formatter correctly colors story/scenario red if step fails (Patch from Joseph Wilk). Closes #439 +* quiet deprecation warning on inflector - patch from RSL. Closes #430 +* added autospec executable +* added configurable messages to simple_matcher +* should and should_not return true on success +* use hoe for build/release +* bye, bye translator +* autotest/rspec uses ruby command instead of spec command (no need for spec command unless loading directories) +* Avoid 'invalid option -O' in autotest (patch from Jonathan del Strother). Closes #486. +* Fix: Unimplemented step with new line throws error (patch from Ben Mabey). Closes #494. +* Only use color codes on tty; override for autospec (patch from Tim Pope). Closes #413. +* Warn when setting mock expectations on nil (patch from Ben Mabey). Closes #521. +* Support argument constraints as values in the hash_including contstraint. Thanks to Pirkka Hartikainen for failing code examples and the fix. Buttons up #501. +* mock(:null_object=>true) plays nice with HTML (patch from Gerrit Kaiser) +* Consider MinGW as valid RUBY_PLATFORM for --colour option. (patch from Luis Lavena). Closes #406. +* Add 2nd arg to respond_to? to align w/ core Ruby rdoc: http://www.ruby-doc.org/core/classes/Object.html#M000604 +* quiet backtrace tweaker filters individual lines out of multiline (ala Rails) error messages (Pat Maddox) +* added ability to stub multiple methods in one stub! call (Pat Maddox) +* story progress bar formatter and more colourful summaries from the plain text story formatter (Joseph Wilk) +* Avoid ruby invocation errors when autotesting (Jonathan del Strother) +* added mock('foo').as_null_object +* add file and line number to pending_example for formatters (Scott Taylor) +* return last stubbed value for mock expectation with no explicit return (Pat Maddox) +* Fixed bug when should_receive(:foo).any_number_of_times is called after similar stub (Pat Maddox) +* Warning messages now issued when expectations are set on nil (Ben Mabey) + +=== Version 1.1.4 + +Maintenance release. + +Note: we've removed the metaclass method from Object. There were some +generated specs that used it, and they will now break. Just replace the +metaclass call with (class << self; self; end) and all will be well. + +* added hash_including mock argument matcher. Closes #332 (patch from Rick DeNatale) +* pending steps print out yellow in stories (patch from Kyle Hargraves) +* Deprecation warnings for specs that assume auto-inclusion of modules. Closes #326 (patch from Scott Taylor) +* mock.should_not_receive(:anything) fails fast (once again) +* Patch from Antti Tarvainen to stop files from being loaded repeatedly when running heckle. Closes #333. +* Fixed bug in which session object in example was not the same instance used in the controller. Closes #331. +* Applied patch from Antti Tarvainen to fix bug where heckle runs rspec runs heckle runs rspec etc. Closes #280. +* Applied patch from Zach Dennis to merge :steps functionality to :steps_for. Closes #324. +* Applied patch from Ryan Davis to add eval of block passed to raise_error matcher. Closes #321. +* alias :context :describe in example_group_methods. Closes #312. +* Applied patch from Ben Mabey to make the Story runner exit with a non-0 exit code on failing stories. Closes #228. +* Applied patch from Coda Hale to get the :red hook called in autotest. Closes #279. +* Applied patch from Patrick Ritchie to support --drb in spec.opts. Closes #274, #293. +* Moved metaclass method from Object to an internal module which gets included where it is needed. +* Applied patch from Dayo Esho: and_yield clobbers return value from block. Closes #217. +* Applied patch from Bob Cotton: ExampleGroupFactory.default resets previously registered types. Closes #222. +* Applied patch from Mike Williams to support the lib directory in rails apps with the Textmate Alternate File command. Closes #276. +* ExampleGroupMethods#xspecify aliases #xit +* A SharedExampleGroup can be created within another ExampleGroup. +* Applied patch from Bob Cotton: Nested ExampleGroups do not have a spec_path. Closes #224. +* Add before_suite and after_suite callbacks to ExampleGroupMethods and Options. Closes #210. +* The after(:suite) callback lambda is passed a boolean representing whether the suite passed or failed +* Added NestedTextFormatter. Closes #366. +* decoupled mock framework from global extensions used by rspec - supports use of flexmock or mocha w/ rails +* Applied patch from Roman Chernyatchik to allow the user to pass in the ruby version into spectask. Closes #325, #370 + +=== Version 1.1.3 + +Maintenance release. +Notice to autotest users: you must also upgrade to ZenTest-3.9.0. + +* Tightened up exceptions list in autotest/rails_spec. Closes #264. +* Applied patch from Ryan Davis for ZenTest-3.9.0 compatibility +* Applied patch from Kero to add step_upcoming to story listeners. Closes #253. +* Fixed bug where the wrong named error was not always caught by "should raise_error" +* Applied patch from Luis Lavena: No coloured output on Windows due missing RUBYOPT. Closes #244. +* Applied patch from Craig Demyanovich to add support for "should_not render_template" to rspec_on_rails. Closes #241. +* Added --pattern (-p for short) option to control what files get loaded. Defaults to '**/*_spec.rb' +* Exit with non-0 exit code if examples *or tests* (in test/unit interop mode) fail. Closes #203. +* Moved at_exit hook to a method in Spec::Runner which only runs if specs get loaded. Closes #242. +* Applied patch from kakutani ensuring that base_view_path gets cleared after each view example. Closes #235. +* More tweaks to regexp step names +* Fixed focused specs in nested ExampleGroups. Closes #225. + +=== Version 1.1.2 + +Minor bug fixes/enhancements. +Notice to autotest users: you must also upgrade to ZenTest-3.8.0. + +* RSpec's Autotest subclasses compatible with ZenTest-3.8.0 (thanks to Ryan Davis for making it easier on Autotest subs). +* Applied patch from idl to add spec/lib to rake stats. Closes #226. +* calling setup_fixtures and teardown_fixtures for Rails >= r8570. Closes #219. +* Applied patch from Josh Knowles using ActiveSupport's Inflector (when available) to make 'should have' read a bit better. Closes #197. +* Fixed regression in 1.1 that caused failing examples to fail to generate their own names. Closes #209. +* Applied doc patch from Jens Krämer for capturing content_for +* Applied patch from Alexander Lang to clean up story steps after each story. Closes #198. +* Applied patch from Josh Knowles to support 'string_or_response.should have_text(...)'. Closes #193. +* Applied patch from Ian Dees to quiet the Story Runner backtrace. Closes #183. +* Complete support for defining steps with regexp 'names'. + +=== Version 1.1.1 + +Bug fix release. + +* Fix regression in 1.1.0 that caused transactions to not get rolled back between examples. +* Applied patch from Bob Cotton to reintroduce ExampleGroup.description_options. Closes LH[#186] + +=== Version 1.1.0 + +The "tell me a story and go nest yourself" release. + +* Applied patch from Mike Vincent to handle generators rails > 2.0.1. Closes LH[#181] +* Formatter.pending signature changed so it gets passed an ExampleGroup instance instead of the name ( LH[#180]) +* Fixed LH[#180] Spec::Rails::Example::ModelExampleGroup and friends show up in rspec/rails output +* Spec::Rails no longer loads ActiveRecord extensions if it's disabled in config/boot.rb +* Applied LH[#178] small annoyances running specs with warnings enabled (Patch from Mikko Lehtonen) +* Tighter integration with Rails fixtures. Take advantage of fixture caching to get performance improvements (Thanks to Pat Maddox, Nick Kallen, Jonathan Barnes, and Curtis) + +=== Version 1.1.0-RC1 + +Textmate Bundle users - this release adds a new RSpec bundle that highlights describe, it, before and after and +provides navigation to descriptions and examples (rather than classes and methods). When you first install this, +it is going to try to hijack all of your .rb files. All you need to do is open a .rb file that does not end with +'spec.rb' and change the bundle selection from RSpec to Ruby. TextMate will do the right thing from then on. + +Shortcuts for tab-activated snippets all follow the TextMate convention of 2 or 3 letters of the first word, followed by the first letter of each subsequent word. So "should have_at_least" would be triggered by shhal. + +We reduced the scope for running spec directories, files, a single file or individual spec in TextMate to source.ruby.rspec. This allowed us to restore the standard Ruby shortcuts: + +CMD-R runs all the specs in one file +CMD-SHIFT-R runs an individual spec +CMD-OPT-R runs any files or directories selected in the TextMate drawer + +rspec_on_rails users - don't forget to run script/generate rspec + +* Added shared_examples_for method, which you can (should) use instead of describe Foo, :shared => true +* Applied LH[#168] Fix describe Object, "description contains a # in it" (Patch from Martin Emde) +* Applied LH[#15] Reverse loading of ActionView::Base helper modules (Patch from Mark Van Holstyn) +* Applied LH[#149] Update contribute page to point towards lighthouse (Patch from Josh Knowles) +* Applied LH[#142] verify_rcov fails with latest rcov (Patch from Kyle Hargraves) +* Applied LH[#10] Allow stubs to yield and return values (Patch from Pat Maddox) +* Fixed LH[#139] version.rb in trunk missing svn last changed number +* Applied LH[#14] Adding support for by_at_least/by_at_most in Change matcher (Patch from Saimon Moore) +* Applied LH[#12] Fix for TM when switching to alternate file (Patch from Trevor Squires) +* Applied LH[#133] ExampleMatcher should match against before(:all) (Patch from Bob Cotton) +* Applied LH[#134] Only load spec inside spec_helper.rb (Patch from Mark Van Holstyn) +* RSpec now bails immediately if there are examples with identical names. +* Applied LH[#132] Plain Text stories should support Given and Given: (Patch from Jarkko Laine) +* Applied patch from Pat Maddox: Story Mediator - the glue that binds the plain text story parser with the rest of the system +* Applied LH[#16] Have SimpleMatchers expose their description for specdocs (Patch from Bryan Helmkamp) +* Stories now support --colour +* Changed the DSL modules to Example (i.e. Spec::Example instead of Spec::DSL) +* Applied [#15608] Story problem if parenthesis used in Given, When, Then or And (Patch from Sinclair Bain) +* Applied [#15659] GivenScenario fails when it is a RailsStory (Patch from Nathan Sutton) +* Fixed [#15639] rcov exclusion configuration. (Spec::Rails projects can configure rcov with spec/rcov.opts) +* The rdoc formatter (--format rdoc) is gone. It was buggy and noone was using it. +* Changed Spec::DSL::Behaviour to Spec::DSL::ExampleGroup +* Changed Spec::DSL::SharedBehaviour to Spec::DSL::SharedExampleGroup +* Applied [#14023] Small optimization for heavily proxied objects. (Patch from Ian Leitch) +* Applied [#13943] ProfileFormatter (Top 10 slowest examples) (Patch from Ian Leitch) +* Fixed [#15232] heckle is not working correctly in trunk (as of r2801) +* Applied [#14399] Show pending reasons in HTML report (Patch from Bryan Helmkamp) +* Discovered fixed: [#10263] mock "leak" when setting an expectation in a block passed to mock#should_receive +* Fixed [#14671] Spec::DSL::ExampleRunner gives "NO NAME because of --dry-run" for every example for 'rake spec:doc' +* Fixed [#14543] rspec_scaffold broken with Rails 2.0 +* Removed Patch [#10577] Rails with Oracle breaks 0.9.2 - was no longer necessary since we moved describe to the Main object (instead of Object) +* Fixed [#14527] specs run twice on rails 1.2.4 and rspec/rspec_on_rails trunk +* Applied [#14043] Change output ordering to show pending before errors (Patch from Mike Mangino) +* Applied [#14095] Don't have ./script/generate rspec create previous_failures.txt (Patch from Bryan Helmkamp) +* Applied [#14254] Improved error handling for Object#should and Object#should_not (Patch from Antti Tarvainen) +* Applied [#14186] Remove dead code from message_expecation.rb (Patch from Antti Tarvainen) +* Applied [#14183] Tiny improvement on mock_spec.rb (Patch from Antti Tarvainen) +* Applied [#14208] Fix to Mock#method_missing raising NameErrors instead of MockExpectationErrors (Patch from Antti Tarvainen) +* Applied [#14255] Fixed examples in mock_spec.rb and shared_behaviour_spec.rb (Patch from Antti Tarvainen) +* Applied [#14362] partially mocking objects that define == can blow up (Patch from Pat Maddox) +* test_ methods with an arity of 0 defined in a describe block or Example object will be run as an Example, providing a seamless transition from Test::Unit +* Removed BehaviourRunner +* Fixed [#13969] Spec Failures on Trunk w/ Autotest +* Applied [#14156] False positives with should_not (Patch from Antti Tarvainen) +* Applied [#14170] route_for and params_from internal specs fixed (Patch from Antti Tarvainen) +* Fixed [#14166] Cannot build trunk +* Applied [#14142] Fix for bug #11602: Nested #have_tag specifications fails on the wrong line number (Patch from Antti Tarvainen) +* Removed warn_if_no_files argument and feature +* Steps (Given/When/Then) with no blocks are treated as pending +* Applied [#13913] Scenario should treat no code block as pending (Patch from Evan Light) +* Fixed [#13370] Weird mock expectation error (Patch from Mike Mangino) +* Applied [#13952] Fix for performance regression introduced in r2096 (Patch from Ian Leitch) +* Applied [#13881] Dynamically include Helpers that are included on ActionView::Base (Patch from Brandon Keepers) +* Applied [#13833] ActionView::Helpers::JavaScriptMacrosHelper removed after 1.2.3 (Patch from Yurii Rashkovskii) +* Applied [#13814] RSpec on Rails w/ fixture-scenarios (Patch from Shintaro Kakutani) +* Add ability to define Example subclass instead of using describe +* Applied Patch from James Edward Gray II to improve syntax highlighting in TextMate +* Fixed [#13579] NoMethodError not raised for missing helper methods +* Fixed [#13713] form helper method 'select' can not be called when calling custom helper methods from specs +* Example subclasses Test::Unit::TestCase +* Added stub_everything method to create a stub that will return itself for any message it doesn't understand +* Added stories directory with stories/all.rb and stories/helper.rb when you script/generate rspec +* Applied [#13554] Add "And" so you can say Given... And... When... Then... And... +* Applied [#11254] RSpec syntax coloring and function pop-up integration in TextMate (Patch from Wincent Colaiuta) +* Applied [#13143] ActionView::Helpers::RecordIdentificationHelper should be included if present (Patch from Jay Levitt) +* Applied [#13567] patch to allow stubs to yield consecutive values (Patch from Rupert Voelcker) +* Applied [#13559] reverse version of route_for (Patch from Rupert Voelcker) +* Added [#13532] /lib specs should get base EvalContext +* Applied [#13451] Add a null_object option to mock_model (Patch from James Deville) +* Applied [#11919] Making non-implemented specs easy in textmate (Patch from Scott Taylor) +* Applied [#13274] ThrowSymbol recognized a NameError triggered by Kernel#method_missing as a thrown Symbol +* Applied [#12722] the alternate file command does not work in rails views due to scope (Patch from Carl Porth) +* Behaviour is now a Module that is used by Example class methods and SharedBehaviour +* Added ExampleDefinition +* Added story runner framework based on rbehave [#12628] +* Applied [#13336] Helper directory incorrect for rake stats in statsetup task (Patch from Curtis Miller) +* Applied [#13339] Add the ability for spec_parser to parse describes with :behaviour_type set (Patch from Will Leinweber and Dav Yaginuma) +* Fixed [#13271] incorrect behaviour with expect_render and stub_render +* Applied [#13129] Fix failing specs in spec_distributed (Patch from Bob Cotton) +* Applied [#13118] Rinda support for Spec::Distributed (Patch from Bob Cotton) +* Removed BehaviourEval +* Removed Behaviour#inherit +* Moved implementation of install_dependencies to example_rails_app +* Renamed RSPEC_DEPS to VENDOR_DEPS +* Added Example#not_implemented? +* You can now stub!(:msg).with(specific args) +* describe("A", Hash, "with one element") will generate description "A Hash with one element" (Tip from Ola Bini) +* Applied [#13016] [DOC] Point out that view specs render, well, a view (Patch from Jay Levitt) +* Applied [#13078] Develop rspec with autotest (Patch from Scott Taylor) +* Fixed [#13065] Named routes throw a NoMethodError in Helper specs (Patches from James Deville and Mike Mangino) +* Added (back) the verbose attribute in Spec::Rake::SpecTask +* Changed documentation to point at the new http svn URL, which is more accessible. + +=== Version 1.0.8 + +Another bugfix release - this time to resolve the version mismatch + +=== Version 1.0.7 + +Quick bugfix release to ensure that you don't have to have the rspec gem installed +in order to use autotest with rspec_on_rails. + +* Fixed [#13015] autotest gives failure in 'spec_command' after upgrade 1.0.5 to 1.0.6 + +=== Version 1.0.6 + +The "holy cow, batman, it's been a long time since we released and there are a ton of bug +fixes, patches and even new features" release. + +Warning: Spec::Rails users: In fixing 11508, we've removed the raise_controller_errors method. As long as you +follow the upgrade instructions and run 'script/generate rspec' you'll be fine, but if you skip this +step you need to manually go into spec_helper.rb and remove the call to that method (if present - it +might not be if you haven't upgraded in a while). + +Warning: Implementors of custom formatters. Formatters will now be sent an Example object instead of just a +String for #example_started, #example_passed and #example_failed. In certain scenarios +(Spec::Ui with Spec::Distributed), the formatter must ask the Example for its sequence number instead of +keeping track of a sequence number internal to the formatter. Most of you shouldn't need to upgrade +your formatters though - the Example#to_s method returns the example name/description, so you should be +able to use the passed Example instance as if it were a String. + +* Applied [#12986] Autotest Specs + Refactoring (Patch from Scott Tayler) +* Added a #close method to formatters, which allows them to gracefully close streams. +* Applied [#12935] Remove requirement that mocha must be installed as a gem when used as mocking framework. (Patch from Ryan Kinderman). +* Fixed [#12893] RSpec's Autotest should work with rspec's trunk +* Fixed [#12865] Partial mock error when object has an @options instance var +* Applied [#12701] Allow checking of content captured with content_for in view specs (Patch from Jens Kr�mer) +* Applied [#12817] Cannot include same shared behaviour when required with absolute paths (Patch from Ian Leitch) +* Applied [#12719] rspec_on_rails should not include pagination helper (Patch from Matthijs Langenberg) +* Fixed [#12714] helper spec not finding rails core helpers +* Applied [#12611] should_not redirect_to implementation (Patch from Yurii Rashkovskii) +* Applied [#12682] Not correctly aliasing original 'stub!' and 'should_receive' methods for ApplicationController (Patch from Matthijs Langenberg) +* Disabled controller.should_receive(:render) and controller.stub!(:render). Use expect_render or stub_render instead. +* Applied [#12484] Allow a Behaviour's Description to flow through to the Formatter (Patch from Bob Cotton) +* Fixed [#12448] The spec:plugins rake task from rspec_on_rails should ignore specs from the rspec_on_rails plugin +* Applied [#12300] rr integration (patch from Kyle Hargraves) +* Implemented [#12284] mock_with :rr (integration with RR mock framework: http://rubyforge.org/projects/pivotalrb/) +* Applied [#12237] (tiny) added full path to mate in switch_command (Patch from Carl Porth) +* Formatters will now be sent an Example object instead of just a String for certain methods +* All Spec::Rake::SpecTask attributes can now be procs, which allows for lazy evaluation. +* Changed the Spec::Ui interfaces slightly. See examples. +* Applied [#12174] mishandling of paths with spaces in spec_mate switch_command (Patch from Carl Porth) +* Implemented [#8315] File "Go to..." functionality +* Applied [#11917] Cleaner Spec::Ui error for failed Selenium connection (Patch from Ian Dees) +* Applied [#11888] rspec_on_rails spews out warnings when assert_select is used with an XML response (Patch from Ian Leitch) +* Applied [#12010] Nicer failure message formatting (Patch from Wincent Colaiuta) +* Applied [#12156] smooth open mate patch (Patch from Ienaga Eiji) +* Applied [#10577] Rails with Oracle breaks 0.9.2. (Patch from Sinclair Bain) +* Fixed [#12079] auto-generated example name incomplete: should have 1 error on ....] +* Applied [#12066] Docfix for mocks/mocks.page (Patch from Kyle Hargraves) +* Fixed [#11891] script/generate rspec_controller fails to create appropriate views (from templates) on edge rails +* Applied [#11921] Adds the correct controller_name from derived_controller_name() to the ViewExampleGroupController (Patch from Eloy Duran) +* Fixed [#11903] config.include with behaviour_type 'hash' does not work +* Examples without blocks and pending is now reported with a P instead of a * +* Pending blocks that now pass are rendered blue +* New behaviour for after: If an after block raises an error, the other ones will still run instead of bailing at the first. +* Made it possible to run spec from RSpec.tmbundle with --drb against a Rails spec_server. +* Applied [#11868] Add ability for pending to optionally hold a failing block and to fail when it passes (Patch from Bob Cotton) +* Fixed [#11843] watir_behaviour missing from spec_ui gem +* Added 'switch between source and spec file' command in Spec::Mate (based on code from Ruy Asan) +* Applied [#11509] Documentation - RSpec requires hpricot +* Applied [#11807] Daemonize spec_server and rake tasks to manage them. (patch from Kyosuke MOROHASHI) +* Added pending(message) method +* Fixed [#11777] should render_template doesn't check paths correctly +* Fixed [#11749] Use of 'rescue => e' does not catch all exceptions +* Fixed [#11793] should raise_error('with a message') does not work correctly +* Fixed [#11774] Mocks should respond to :kind_of? in the same way they respond to :is_a? +* Fixed [#11508] Exceptions are not raised for Controller Specs (removed experimental raise_controller_errors) +* Applied [#11615] Partial mock methods give ambiguous failures when given a method name as a String (Patch from Jay Phillips) +* Fixed [#11545] Rspec doesn't handle should_receive on ActiveRecord associations (Patch from Ian White) +* Fixed [#11514] configuration.use_transactional_fixtures is ALWAYS true, regardless of assignment +* Improved generated RESTful controller examples to cover both successful and unsuccessful POST and PUT +* Changed TextMate snippets for controllers to pass controller class names to #describe rather than controller_name. +* Changed TextMate snippets for mocks to use no_args() and any_args() instead of the deprecated Symbols. +* Applied [#11500] Documentation: no rails integration specs in 1.0 +* Renamed SpecMate's shortcuts for running all examples and focused examples to avoid conflicts (CMD-d and CMD-i) +* Added a TextMate snippet for custom matchers, lifted from Geoffrey Grosenbach's RSpec peepcode show. +* The translator translates mock constraints to the new matchers that were introduced in 1.0.4 +* Documented environment variables for Spec::Rake::SpecTask. Renamed SPECOPTS and RCOVOPTS to SPEC_OPTS and RCOV_OPTS. +* Fixed [#10534] Windows: undefined method 'controller_name' + +=== Version 1.0.5 +Bug fixes. Autotest plugin tweaks. + +* Fixed [#11378] fix to 10814 broke drb (re-opened #10814) +* Fixed [#11223] Unable to access flash from rails helper specs +* Fixed [#11337] autotest runs specs redundantly +* Fixed [#11258] windows: autotest won't run +* Applied [#11253] Tweaks to autotest file mappings (Patch from Wincent Colaiuta) +* Applied [#11252] Should be able to re-load file containing shared behaviours without raising an exception (Patch from Wincent Colaiuta) +* Fixed [#11247] standalone autotest doesn't work because of unneeded autotest.rb +* Applied [#11221] Autotest support does not work w/o Rails Gem installed (Patch from Josh Knowles) + +=== Version 1.0.4 +The getting ready for JRuby release. + +* Fixed [#11181] behaviour_type scoping of config.before(:each) is not working +* added mock argument constraint matchers (anything(), boolean(), an_instance_of(Type)) which work with rspec or mocha +* added mock argument constraint matchers (any_args(), no_args()) which only work with rspec +* deprecated rspec's symbol mock argument constraint matchers (:any_args, :no_args, :anything, :boolean, :numeric, :string) +* Added tarball of rspec_on_rails to the release build to support folks working behind a firewall that blocks svn access. +* Fixed [#11137] rspec incorrectly handles flash after resetting the session +* Fixed [#11143] Views code for ActionController::Base#render broke between 1.0.0 and 1.0.3 on Rails Edge r6731 +* Added raise_controller_errors for controller examples in Spec::Rails + +=== Version 1.0.3 +Bug fixes. + +* Fixed [#11104] Website uses old specify notation +* Applied [#11101] StringHelpers.starts_with?(prefix) assumes a string parameter for _prefix_ +* Removed 'rescue nil' which was hiding errors in controller examples. +* Fixed [#11075] controller specs fail when using mocha without integrated_views +* Fixed problem with redirect_to failing incorrectly against edge rails. +* Fixed [#11082] RspecResourceGenerator should be RspecScaffoldGenerator +* Fixed [#10959] Focused Examples do not work for Behaviour defined with constant with modules + +=== Version 1.0.2 +This is just to align the version numbers in rspec and rspec_on_rails. + +=== Version 1.0.1 +This is a maintenance release with mostly cleaning up, and one minor enhancement - +Modules are automatically included when described directly. + +* Renamed Spec::Rails' rspec_resource generator to rspec_scaffold. +* Removed Spec::Rails' be_feed matcher since it's based on assert_select_feed which is not part of Rails (despite that docs for assert_select_encoded says it is). +* describe(SomeModule) will include that module in the examples. Like for Spec::Rails helpers, but now also in core. +* Header in HTML report will be yellow instead of red if there is one failed example +* Applied [#10951] Odd instance variable name in rspec_model template (patch from Kyle Hargraves) +* Improved integration with autotest (Patches from Ryan Davis and David Goodland) +* Some small fixes to make all specs run on JRuby. + +=== Version 1.0.0 +The stake in the ground release. This represents a commitment to the API as it is. No significant +backwards compatibility changes in the API are expected after this release. + +* Fixed [#10923] have_text matcher does not support should_not +* Fixed [#10673] should > and should >= broken +* Applied [#10921] Allow verify_rcov to accept greater than threshold coverage %'s via configuration +* Applied [#10920] Added support for not implemented examples (Patch from Chad Humphries and Ken Barker) +* Patch to allow not implemented examples. This works by not providing a block to the example. (Patch from Chad Humphries, Ken Barker) +* Yanked support for Rails 1.1.6 in Spec::Rails +* RSpec.tmbundle uses CMD-SHIFT-R to run focused examples now. +* Spec::Rails now bundles a spec:rcov task by default (suggestion from Kurt Schrader) +* Fixed [#10814] Runner loads shared code, test cases require them again +* Fixed [#10753] Global before and after +* Fixed [#10774] Allow before and after to be specified in config II +* Refactored Spec::Ui examples to use new global before and after blocks. +* Added instructions about how to get Selenium working with Spec::Ui (spec_ui/examples/selenium/README.txt) +* Fixed [#10805] selenium.rb missing from gem? +* Added rdocs explaining how to deal with errors in Rails' controller actions +* Applied [#10770] Finer grained includes. +* Fixed [#10747] Helper methods defined in shared specs are not visible when shared spec is used +* Fixed [#10748] Shared descriptions in separate files causes 'already exists' error +* Applied [#10698] Running with --drb executes specs twice (patch from Ruy Asan) +* Fixed [#10871] 0.9.4 - Focussed spec runner fails to run specs in descriptions with type and string when there is no leading space in the string + +=== Version 0.9.4 +This release introduces massive improvements to Spec::Ui - the user interface functional testing +extension to RSpec. There are also some minor bug fixes to the RSpec core. + +* Massive improvements to Spec::Ui. Complete support for all Watir's ie.xxx(how, what) methods. Inline screenshots and HTML. +* Reactivated --timeout, which had mysteriously been deactivated in a recent release. +* Fixed [#10669] Kernel#describe override does not cover Kernel#context +* Applied [#10636] Added spec for OptionParser in Runner (Patch from Scott Taylor) +* Added [#10516] should_include should be able to accept multiple items +* Applied [#10631] redirect_to matcher doesn't respect request.host (Patch from Tim Lucas) +* Each formatter now flushes their own IO. This is to avoid buffering of output. +* Fixed [#10670] IVarProxy#delete raises exception when instance variable does not exist + +=== Version 0.9.3 +This is a bugfix release. + +* Fixed [#10594] Failing Custom Matcher show NAME NOT GENERATED description +* describe(SomeType, "#message") will not add a space: "SomeType#message" (likewise for '.') +* describe(SomeType, "message") will have a decription with a space: "SomeType message" +* Applied [#10566] prepend_before and prepend_after callbacks +* Applied [#10567] Call setup and teardown using before and after callbacks + +=== Version 0.9.2 +This is a quick maintenance release. + +* Added some website love +* Fixed [#10542] reverse predicate matcher syntax +* Added a spec:translate Rake task to make 0.9 translation easier with Spec:Rails +* Better translation of should_redirect_to +* Fixed --colour support for Windows. This is a regression that was introduced in 0.9.1 +* Applied [#10460] Make SpecRunner easier to instantiate without using commandline args + +=== Version 0.9.1 + +This release introduces #describe and #it (aliased as #context and #specify for +backwards compatibility). This allows you to express specs like this: + + describe SomeClass do # Creates a Behaviour + it "should do something" do # Creates an Example + end + end + +The command line features four new options that give you more control over what specs +are being run and in what order. This can be used to verify that your specs are +independent (by running in opposite order with --reverse). It can also be used to cut +down feedback time by running the most recently modified specs first (--loadby mtime --reverse). + +Further, --example replaces the old --spec option, and it can now take a file name of +spec names as an alternative to just a spec name. The --format failing_examples:file.txt +option allows you to output an --example compatible file, which makes it possible to only +rerun the specs that failed in the last run. Spec::Rails uses all of these four options +by default to optimise your RSpec experience. + +There is now a simple configuration model. For Spec::Rails, you do something like this: + + Spec::Runner.configure do |config| + config.use_transactional_fixtures = true + config.use_instantiated_fixtures = false + config.fixture_path = RAILS_ROOT + '/spec/fixtures' + end + +You can now use mocha or flexmock with RSpec if you prefer either to +RSpec's own mock framework. Just put this: + + Spec::Runner.configure do |config| + config.mock_with :mocha + end + +or this: + + Spec::Runner.configure do |config| + config.mock_with :flexmock + end + +in a file that is loaded before your specs. You can also +configure included modules and predicate_matchers: + + Spec::Runner.configure do |config| + config.include SomeModule + config.predicate_matchers[:does_something?] = :do_something + end + +See Spec::DSL::Behaviour for more on predicate_matchers + +* Sugar FREE! +* Added [10434 ] Please Make -s synonymous with -e for autotest compat. This is temporary until autotest uses -e instead of -s. +* Fixed [#10133] custom predicate matchers +* Applied [#10473] Add should exist (new matcher) - Patch from Bret Pettichord +* Added another formatter: failing_behaviours. Writes the names of the failing behaviours for use with --example. +* Applied [#10315] Patch to fix pre_commit bug 10313 - pre_commit_rails: doesn't always build correctly (Patch from Antii Tarvainen) +* Applied [#10245] Patch to HTML escape the behavior name when using HTML Formatter (Patch from Josh Knowles) +* Applied [#10410] redirect_to does not behave consistently with regards to query string parameter ordering (Patch from Nicholas Evans) +* Applied [#9605] Patch for ER 9472, shared behaviour (Patch by Bob Cotton) +* The '--format rdoc' option no longer causes a dry-run by default. --dry-run must be used explicitly. +* It's possible to specify the output file in the --format option (See explanation in --help) +* Several --format options may be specified to output several formats in one run. +* The --out option is gone. Use --format html:path/to/my.html instead (or similar). +* Spec::Runner::Formatter::BaseTextFormatter#initialize only takes one argument - an IO. dry_run and color are setters. +* Made Spec::Ui *much* easier to install. It will be released separately. Check out trunk/spec_ui/examples +* HTML reports now include a syntax highlighted snippet of the source code where the spec failed (needs the syntax gem) +* Added [#10262] Better Helper testing of Erb evaluation block helpers +* Added [#9735] support flexmock (thanks to Jim Weirich for his modifications to flexmock to support this) +* Spec::Rails controller specs will no longer let mock exception ripple through to the response. +* Fixed [#9260] IvarProxy does not act like a hash. +* Applied [#9458] The rspec_scaffold generator does not take into account class nesting (Patch from Steve Tendon) +* Applied [#9132] Rakefile spec:doc can fail without preparing database (Patch from Steve Ross) +* Applied [#9678] Custom runner command line switch, and multi-threaded runner (Patch from Bob Cotton) +* Applied [#9926] Rakefile - RSPEC_DEPS constant as an Array of Hashes instead of an Array of Arrays (Patch from Scott Taylor) +* Applied [#9925] Changed ".rhtml" to "template" in REST spec generator (Patch from Scott Taylor) +* Applied [#9852] Patch for RSpec's Website using Webgen 0.4.2 (Patch from Scott Taylor) +* Fixed [#6523] Run rspec on rails without a db +* Fixed [#9295] rake spec should run anything in the spec directory (not just rspec's standard dirs) +* Added [#9786] infer controller and helper names from the described type +* Fixed [#7795] form_tag renders action='/view_spec' in view specs +* Fixed [#9767] rspec_on_rails should not define rescue_action on controllers +* Fixed [#9421] --line doesn't work with behaviours that use class names +* Fixed [#9760] rspec generators incompatible with changes to edge rails +* Added [#9786] infer controller and helper names from the described type +* Applied a simplified version of [#9282] Change to allow running specs from textmate with rspec installed as a rails plugin (and no rspec gem installed) +* Applied [#9700] Make Spec::DSL::Example#name public / Add a --timeout switch. A great way to prevent specs from getting slow. +* In Rails, script/generate rspec will generate a spec.opts file that optimises faster/more efficient running of specs. +* Added [#9522] support using rspec's expectations with test/unit +* Moved rspec_on_rails up to the project root, simplifying the download url +* Fixed [#8103] RSpec not installing spec script correctly. +* The --spec option is replaced by the --example option. +* The --loadby option no longer supports a file argument. Use --example file_name instead. +* The --example option can now take a file name as an argument. The file should contain example names. +* Internal classes are named Behaviour/Example (rather than Context/Specification). +* You can now use mocha by saying config.mock_with :mocha in a spec_helper +* before_context_eval is replaced by before_eval. +* Applied [#9509] allow spaced options in spec.opts +* Applied [#9510] Added File for Ruby 1.8.6 +* Applied [#9511] Clarification to README file in spec/ +* Moved all of the Spec::Rails specs down to the plugins directory - now you can run the specs after you install. +* Updated RSpec.tmbundle to the 0.9 syntax and replaced context/specify with describe/it. +* Applied [#9232] ActionController::Base#render is sometimes protected (patch from Dan Manges) +* Added --reverse option, allowing contexts/specs to be run in reverse order. +* Added --loadby option, allowing better control over load order for spec files. mtime and file.txt supported. +* Implemented [#8696] --order option (see --reverse and --loadby) +* Added describe/it as aliases for context/specify - suggestion from Dan North. +* Applied [#7637] [PATCH] add skip-migration option to rspec_scaffold generator +* Added [#9167] string.should have_tag +* Changed script/rails_spec_server to script/spec_server and added script/spec (w/ path to vendor/plugins/rspec) +* Fixed [#8897] Error when mixing controller spec with/without integrated views and using template system other than rhtml +* Updated sample app specs to 0.9 syntax +* Updated generated specs to 0.9 syntax +* Applied [#8994] trunk: generated names for be_ specs (Multiple patches from Yurii Rashkovskii) +* Applied [#9983]: Allow before and after to be called in BehaviourEval. This is useful for shared examples. + +=== Version 0.8.2 + +Replaced assert_select fork with an assert_select wrapper for have_tag. This means that "should have_rjs" no longer supports :hide or :effect, but you can still use should_have_rjs for those. + +=== Version 0.8.1 + +Quick "in house" bug-fix + +=== Version 0.8.0 + +This release introduces a new approach to handling expectations using Expression Matchers. + +See Upgrade[http://rspec.rubyforge.org/upgrade.html], Spec::Expectations, Spec::Matchers and RELEASE-PLAN for more info. + +This release also improves the spec command line by adding DRb support and making it possible to +store command line options in a file. This means a more flexible RSpec experience with Rails, +Rake and editor plugins like TextMate. + +It also sports myriad new features, bug fixes, patches and general goodness: + +* Fixed [#8928] rspec_on_rails 0.8.0-RC1 controller tests make double call to setup_with_fixtures +* Fixed [#8925] Documentation bug in 0.8.0RC1 rspec website +* Applied [#8132] [PATCH] RSpec breaks "rake db:sessions:create" in a rails project that has the rspec_on_rails plugin (Patch from Erik Kastner) +* Fixed [#8789] --line and --spec not working when the context has parenhesis in the name +* Added [#8783] auto generate spec names from last expectation +* --heckle now fails if the heckled class or module is not found. +* Fixed [#8771] Spec::Mocks::BaseExpectation#with converts hash params to array of arrays with #collect +* Fixed [#8750] should[_not]_include backwards compatibility between 0.8.0-RC1 and 0.7.5.1 broken +* Fixed [#8646] Context Runner does not report on Non standard exceptions and return a 0 return code +* RSpec on Rails' spec_helper.rb will only force RAILS_ENV to test if it was not specified on the command line. +* Fixed [#5485] proc#should_raise and proc#should_not_raise output +* Added [#8484] should_receive with blocks +* Applied [#8218] heckle_runner.rb doesn't work with heckle >= 1.2.0 (Patch from Michal Kwiatkowski) +* Fixed [#8240] Cryptic error message when no controller_name +* Applied [#7461] [PATCH] Contexts don't call Module::included when they include a module +* Removed unintended block of test/unit assertions in rspec_on_rails - they should all, in theory, now be accessible +* Added mock_model method to RSpec on Rails, which stubs common methods. Based on http://metaclass.org/2006/12/22/making-a-mockery-of-activerecord +* Fixed [#8165] Partial Mock Errors when respond_to? is true but the method is not in the object +* Fixed [#7611] Partial Mocks override Subclass methods +* Fixed [#8302] Strange side effect when mocking a class method +* Applied [#8316] to_param should return a stringified key in resource generator's controller spec (Patch from Chris Anderson) +* Applied [#8216] shortcut for creating object stub +* Applied [#8008] Correct generated specs for view when calling resource generator (Patch from Jonathan Tron) +* Fixed [#7754] Command-R fails to run spec in TextMate (added instruction from Luke Redpath to the website) +* Fixed [#7826] RSpect.tmbundle web page out of date. +* RSpec on Rails specs are now running against RoR 1.2.1 and 1.2.2 +* rspec_scaffold now generates specs for views +* In a Rails app, RSpec core is only loaded when RAILS_ENV==test (init.rb) +* Added support for target.should arbitrary_expectation_handler and target.should_not arbitrary_expectation_handler +* Fixed [#7533] Spec suite fails and the process exits with a code 0 +* Fixed [#7565] Subsequent stub! calls for method fail to override the first call to method +* Applied [#7524] Incorrect Documentation for 'pattern' in Rake task (patch from Stephen Duncan) +* Fixed [#7409] default fixtures do not appear to run. +* Fixed [#7507] "render..and return" doesn't return +* Fixed [#7509] rcov/rspec incorrectly includes boot.rb (Patch from Courtenay) +* Fixed [#7506] unnecessary complex output on failure of response.should be_redirect +* Applied [#6098] Make scaffold_resource generator. Based on code from Pat Maddox. +* The drbspec command is gone. Use spec --drb instead. +* The drb option is gone from the Rake task. Pass --drb to spec_opts instead. +* New -X/--drb option for running specs against a server like spec/rails' script/rails_spec_server +* New -O/--options and -G/--generate flags for file-based options (handy for spec/rails) +* Applied [#7339] Turn off caching in HTML reports +* Applied [#7419] "c option for colorizing output does not work with rails_spec" (Patch from Shintaro Kakutani) +* Applied [#7406] [PATCH] 0.7.5 rspec_on_rails loads fixtures into development database (Patch from Wilson Bilkovich) +* Applied [#7387] Allow stubs to return consecutive values (Patch from Pat Maddox) +* Applied [#7393] Fix for rake task (Patch from Pat Maddox) +* Reinstated support for response.should_render (in addition to controller.should_render) + +=== Version 0.7.5.1 + +Bug fix release to allow downloads of rspec gem using rubygems 0.9.1. + +=== Version 0.7.5 +This release adds support for Heckle - Seattle'rb's code mutation tool. +There are also several bug fixes to the RSpec core and the RSpec on Rails plugin. + +* Removed svn:externals on rails versions and plugins +* Applied [#7345] Adding context_setup and context_teardown, with specs and 100% rcov +* Applied [#7320] [PATCH] Allow XHR requests in controller specs to render RJS templates +* Applied [#7319] Migration code uses drop_column when it should use remove_column (patch from Pat Maddox) +* Added support for Heckle +* Applied [#7282] dump results even if spec is interrupted (patch from Kouhei Sutou) +* Applied [#7277] model.should_have(n).errors_on(:attribute) (patch from Wilson Bilkovich) +* Applied [#7270] RSpec render_partial colliding with simply_helpful (patch from David Goodlad) +* Added [#7250] stubs should support throwing +* Added [#7249] stubs should support yielding +* Fixed [#6760] fatal error when accessing nested finders in rspec +* Fixed [#7179] script/generate rspec_scaffold generates incorrect helper name +* Added preliminary support for assert_select (response.should_have) +* Fixed [#6971] and_yield does not work when the arity is -1 +* Fixed [#6898] Can we separate rspec from the plugins? +* Added [#7025] should_change should accept a block +* Applied [#6989] partials with locals (patch from Micah Martin) +* Applied [#7023] Typo in team.page + +=== Version 0.7.4 + +This release features a complete redesign of the reports generated with --format html. +As usual there are many bug fixes - mostly related to spec/rails. + +* Applied [#7010] Fixes :spacer_template does not work w/ view spec (patch from Shintaro Kakutani) +* Applied [#6798] ensure two ':' in the first backtrace line for Emacs's 'next-error' command (patch from Kouhei Sutou) +* Added Much nicer reports to generated website +* Much nicer reports with --format --html (patch from Luke Redpath) +* Applied [#6959] Calls to render and redirect in controllers should return true +* Fixed [#6981] helper method is not available in partial template. +* Added [#6978] mock should tell you the expected and actual args when receiving the right message with the wrong args +* Added the possibility to tweak the output of the HtmlFormatter (by overriding extra_failure_content). +* Fixed [#6936] View specs don't include ApplicationHelper by default +* Fixed [#6903] Rendering a partial in a view makes the view spec blow up +* Added callback library from Brian Takita +* Added [#6925] support controller.should_render :action_name +* Fixed [#6884] intermittent errors related to method binding +* Fixed [#6870] rspec on edge rails spec:controller fixture loading fails +* Using obj.inspect for all messages +* Improved performance by getting rid of instance_exec (instance_eval is good enough because we never need to pass it args) + +=== Version 0.7.3 + +Almost normal bug fix/new feature release. + +A couple of things you need to change in your rails specs: +# spec_helper.rb is a little different (see http://rspec.rubyforge.org/upgrade.html) +# use controller.should_render before OR after the action (controller.should_have_rendered is deprecated) + +* Applied [#6577] messy mock backtrace when frozen to edge rails (patch from Jay Levitt) +* Fixed [#6674] rspec_on_rails fails on @session deprecation warning +* Fixed [#6780] routing() was failing...fix included - works for 1.1.6 and edge (1.2) +* Fixed [#6835] bad message with arbitrary predicate +* Added [#6731] Partial templates rendered +* Fixed [#6713] helper methods not rendered in view tests? +* Fixed [#6707] cannot run controller / helper tests via rails_spec or spec only works with rake +* Applied [#6417] lambda {...}.should_change(receiver, :message) (patch from Wilson Bilkovich) +* Eliminated dependency on ZenTest +* Fixed [#6650] Reserved characters in the TextMate bundle break svn on Win32 +* Fixed [#6643] script/generate rspec_controller: invalid symbol generation for 'controller_name' for *modularized* controllers +* The script/rails_spec command has been moved to bin/drbspec in RSpec core (installed by the gem) + +=== Version 0.7.2 + +This release introduces a brand new RSpec bundle for TextMate, plus some small bugfixes. + +* Packaged RSpec.tmbundle.tgz as part of the distro +* Fixed [#6593] Add moving progress bar to HtmlFormatter using Javascript +* Applied [#6265] should_raise should accept an Exception object +* Fixed [#6616] Can't run Rails specs with RSpec.tmbundle +* Fixed [#6411] Can't run Rails specs with ruby +* Added [#6589] New -l --line option. This is useful for IDE/editor runners/extensions. +* Fixed [#6615] controller.should_render_rjs should support :partial => 'path/to/template' + +=== Version 0.7.1 + +Bug fixes and a couple o' new features. + +* Fixed [#6575] Parse error in aliasing the partial mock original method (patch by Brian Takita) +* Fixed [#6277] debris left by stubbing (trunk) [submitted by dastels] (fixed by fix to [#6575]) +* Fixed [#6575] Parse error in aliasing the partial mock original method +* Fixed [#6555] should_have_tag does not match documentation +* Fixed [#6567] SyntaxError should not stop entire run +* Fixed [#6558] integrated views look for template even when redirected +* Fixed [#6547] response.should be_redirect broken in 0.7.0 +* Applied [#6471] Easy way to spec routes +* Applied [#6587] Rspec on Rails displays "Spec::Rails::ContextFactory" as context name +* Applied [#6514] Document has trivial typos. +* Added [#6560] controller.session should be available before the action +* Added support for should_have_rjs :visual_effect +* Different printing and colours for unmet expectations (red) and other exceptions (magenta) +* Simplified method_missing on mock_methods to make it less invasive on partial mocks. + +=== Version 0.7.0 + +This is the "Grow up and eat your own dog food release". RSpec is now used on itself and +we're no longer using Test::Unit to test it. Although, we are still extending Test::Unit +for the rails plugin (indirectly - through ZenTest) + +IMPORTANT NOTE: THIS RELEASE IS NOT 100% BACKWARDS COMPATIBLE TO 0.6.x + +There are a few changes that will require that you change your existing specs. + +RSpec now handles equality exactly like ruby does: + +# actual.should_equal(expected) will pass if actual.equal?(expected) returns true +# actual.should eql(expected) will pass if actual.eql?(expected) returns true +# actual.should == expected will pass if actual == expected) returns true + +At the high level, eql? implies equivalence, while equal? implies object identity. For more +information on how ruby deals w/ equality, you should do this: + +ri equal? + +or look at this: + +http://www.ruby-doc.org/core/classes/Object.html#M001057 + +Also, we left in should_be as a synonym for should_equal, so the only specs that should break are the +ones using should_equal (which used to use <code>==</code> instead of <code>.equal?</code>). + +Lastly, should_be used to handle true and false differently from any other values. We've removed +this special handling, so now actual.should_be true will fail for any value other than true (it +used to pass for any non-nil, non-false value), and actual.should_be false will fail for any +value other than false (it used to pass for nil or false). + +Here's what you'll need to do to update your specs: +# search for "should_equal" and replace with "should_eql" +# run specs + +If any specs still fail, they are probably related to should be_true or should_be_false using +non-boolean values. Those you'll just have to inspect manually and adjust appropriately (sorry!). + +-------------------------------------------------- +Specifying multiple return values in mocks now works like this: + +mock.should_receive(:message).and_return(1,2,3) + +It used to work like this: + +mock.should_receive(:message).and_return([1,2,3]) + +but we decided that was counter intuitive and otherwise lame. + +Here's what you'll need to do to update your specs: +# search for "and_return([" +# get rid of the "[" and "]" + +-------------------------------------------------- +RSpec on Rails now supports the following (thanks to ZenTest upon which it is built): + +# Separate specs for models, views, controllers and helpers +# Controller specs are completely decoupled from the views by default (though you can tell them to couple themselves if you prefer) +# View specs are completely decoupled from app-specific controllers + +See http://rspec.rubyforge.org/documentation/rails/index.html for more information +-------------------------------------------------- +As usual, there are also other new features and bug fixes: + +* Added lots of documentation on mocks/stubs and the rails plugin. +* Added support for assigns[key] syntax for controller specs (to align w/ pre-existing syntax for view specs) +* Added support for controller.should_redirect_to +* RSpec on Rails automatically checks whether it's compatible with the installed RSpec +* Applied [#6393] rspec_on_rails uses deprecated '@response' instead of the accessor +* RSpec now has 100% spec coverage(!) +* Added support for stubbing and partial mocking +* Progress (....F..F.) is now coloured. Tweaked patch from KAKUTANI Shintaro. +* Backtrace now excludes the rcov runner (/usr/local/bin/rcov) +* Fixed [#5539] predicates do not work w/ rails +* Added [#6091] support for Regexp matching messages sent to should_raise +* Added [#6333] support for Regexp matching in mock arguments +* Applied [#6283] refactoring of diff support to allow selectable formats and custom differs +* Fixed [#5564] "ruby spec_file.rb" doesn't work the same way as "spec spec_file.rb" +* Fixed [#6056] Multiple output of failing-spec notice +* Fixed [#6233] Colours in specdoc +* Applied [#6207] Allows --diff option to diff target and expected's #inspect output (Patch by Lachie Cox) +* Fixed [#6203] Failure messages are misleading - consider using inspect. +* Added [#6334] subject.should_have_xyz will try to call subject.has_xyz? - use this for hash.should_have_key(key) +* Fixed [#6017] Rake task should ignore empty or non-existent spec-dirs + +=== Version 0.6.4 + +In addition to a number of bug fixes and patches, this release begins to formalize the support for +RSpec on Rails. + +* Added Christopher Petrilli's TextMate bundle to vendor/textmate/RSpec.tmbundle +* Fixed [#5909], once again supporting multi_word_predicates +* Applied [#5873] - response.should_have_rjs (initial patch from Jake Howerton, based on ARTS by Kevin Clark) +* Added generation of view specs for rspec_on_rails +* Applied [#5815] active_record_subclass.should_have(3).records +* Added support in "rake stats" for view specs (in spec/views) +* Applied [#5801] QuickRef.pdf should say RSpec, not rSpec +* Applied [#5728] rails_spec_runner fails on Windows (Patch from Lindsay Evans). +* Applied [#5708] RSpec Rails plugin rspec_controller generator makes specs that do not parse. +* Cleaned up RSpec on Rails so it doesn't pollute as much during bootstrapping. +* Added support for response.should_have_tag and response.should_not_have_tag (works just like assert_tag in rails) +* Added new -c, --colour, --color option for colourful (red/green) output. Inspired from Pat Eyler's Redgreen gem. +* Added examples for Watir and Selenium under the gem's vendor directory. +* Renamed rails_spec_runner to rails_spec_server (as referred to in the docs) +* Added support for trying a plural for arbitrary predicates. E.g. Album.should_exist(:name => "Hey Jude") will call Album.exists?(:name => "Hey Jude") +* Added support for should_have to work with methods taking args returning a collection. E.g. @dave.should_have(3).albums_i_have_that_this_guy_doesnt(@aslak) +* Added [#5570] should_not_receive(:msg).with(:specific, "args") +* Applied [#5065] to support using define_method rather than method_missing to capture expected messages on mocks. Thanks to Eero Saynatkari for the tip that made it work. +* Restructured directories and Modules in order to separate rspec into three distinct Modules: Spec::Expectations, Spec::Runner and Spec::Mocks. This will allow us to more easily integrate other mock frameworks and/or allow test/unit users to take advantage of the expectation API. +* Applied [#5620] support any boolean method and arbitrary comparisons (5.should_be < 6) (Patch from Mike Williams) + +=== Version 0.6.3 + +This release fixes some minor bugs related to RSpec on Rails +Note that if you upgrade a rails app with this version of the rspec_on_rails plugin +you should remove your lib/tasks/rspec.rake if it exists. + +* Backtraces from drb (and other standard ruby libraries) are now stripped from backtraces. +* Applied [#5557] Put rspec.rake into the task directory of the RSpec on Rails plugin (Patch from Daniel Siemssen) +* Applied [#5556] rails_spec_server loads environment.rb twice (Patch from Daniel Siemssen) + +=== Version 0.6.2 +This release fixes a couple of regressions with the rake task that were introduced in the previous version (0.6.1) + +* Fixed [#5518] ruby -w: warnings in 0.6.1 +* Applied [#5525] fix rake task path to spec tool for gem-installed rspec (patch from Riley Lynch) +* Fixed a teensey regression with the rake task - introduced in 0.6.1. The spec command is now quoted so it works on windows. + +=== Version 0.6.1 +This is the "fix the most annoying bugs release" of RSpec. There are 9 bugfixes this time. +Things that may break backwards compatibility: +1) Spec::Rake::SpecTask no longer has the options attribute. Use ruby_opts, spec_opts and rcov_opts instead. + +* Fixed [#4891] RCOV task failing on windows +* Fixed [#4896] Shouldn't modify user's $LOAD_PATH (Tip from Gavin Sinclair) +* Fixed [#5369] ruby -w: warnings in RSpec 0.5.16 (Tip from Suraj Kurapati) +* Applied [#5141] ExampleMatcher doesn't escape strings before matching (Patch from Nikolai Weibull). +* Fixed [#5224] Move 'require diff-lcs' from test_helper.rb to diff_test.rb (Tip from Chris Roos) +* Applied [#5449] Rake stats for specs (Patch from Nick Sieger) +* Applied [#5468, #5058] Fix spec runner to correctly run controller specs (Patch from Daniel Siemssen) +* Applied fixes to rails_spec_server to improve its ability to run several times. (Patch from Daniel Siemssen) +* Changed RCov::VerifyTask to fail if the coverage is above the threshold. This is to ensure it gets bumped when coverage improves. + +=== Version 0.6.0 +This release makes an official commitment to underscore_syntax (with no more support for dot.syntax) + +* Fixed bug (5292) that caused mock argument matching to fail +* Converted ALL tests to use underscore syntax +* Fixed all remaining problems with underscores revealed by converting all the tests to underscores +* Enhanced sugar to support combinations of methods (i.e. once.and_return) +* Simplified helper structure taking advantage of dot/underscore combos (i.e. should.be.an_instance_of, which can be expressed as should be_an_instance_of) +* Added support for at_most in mocks +* Added support for should_not_receive(:msg) (will be removing should_receive(:msg).never some time soon) +* Added support for should_have_exactly(5).items_in_collection + +=== Version 0.5.16 +This release improves Rails support and test2spec translation. + +* Fixed underscore problems that occurred when RSpec was used in Rails +* Simplified the Rails support by packaging it as a plugin instead of a generator gem. +* Fixed [#5063] 'rspec_on_rails' require line in spec_helper.rb +* Added pre_commit rake task to reduce risk of regressions. Useful for RSpec developers and patchers. +* Added failure_message to RSpec Rake task +* test2spec now defines converted helper methods outside of the setup block (bug #5057). + +=== Version 0.5.15 +This release removes a prematurely added feature that shouldn't have been added. + +* Removed support for differences that was added in 0.5.14. The functionality is not aligned with RSpec's vision. + +=== Version 0.5.14 +This release introduces better ways to extend specs, improves some of the core API and +a experimental support for faster rails specs. + +* Added proc methods for specifying differences (increments and decrements). See difference_test.rb +* Methods can now be defined alongside specs. This obsoletes the need for defining methods in setup. (Patch #5002 from Brian Takita) +* Sugar (underscores) now works correctly with should be_a_kind_of and should be_an_instance_of +* Added support for include and inherit in contexts. (Patch #4971 from Brian Takita) +* Added rails_spec and rails_spec_server for faster specs on rails (still buggy - help needed) +* Fixed bug that caused should_render to break if given a :symbol (in Rails) +* Added support for comparing exception message in should_raise and should_not_raise + +=== Version 0.5.13 +This release fixes some subtle bugs in the mock API. + +* Use fully-qualified class name of Exceptions in failure message. Easier to debug that way. +* Fixed a bug that caused mocks to yield a one-element array (rather than the element) when one yield arg specified. +* Mocks not raise AmbiguousReturnError if an explicit return is used at the same time as an expectation block. +* Blocks passed to yielding mocks can now raise without causing mock verification to fail. + +=== Version 0.5.12 +This release adds diff support for failure messages, a HTML formatter plus some other +minor enhancements. + +* Added HTML formatter. +* Added fail_on_error option to spectask. +* Added support for diffing, using the diff-lcs Rubygem (#2648). +* Remove RSpec on Rails files from backtrace (#4694). +* All of RSpec's own tests run successfully after translation with test2spec. +* Added --verbose mode for test2spec - useful for debugging when classes fail to translate. +* Output of various formatters is now flushed - to get more continuous output. + +=== Version 0.5.11 +This release makes test2spec usable with Rails (with some manual steps). +See http://rspec.rubyforge.org/tools/rails.html for more details + +* test2spec now correctly translates bodies of helper methods (non- test_*, setup and teardown ones). +* Added more documentation about how to get test2spec to work with Rails. + +=== Version 0.5.10 +This version features a second rewrite of test2spec - hopefully better than the previous one. + +* Improved test2spec's internals. It now transforms the syntax tree before writing out the code. + +=== Version 0.5.9 +This release improves test2spec by allowing more control over the output + +* Added --template option to test2spec, which allows for custom output driven by ERB +* Added --quiet option to test2spec +* Removed unnecessary dependency on RubyToC + +=== Version 0.5.8 +This release features a new Test::Unit to RSpec translation tool. +Also note that the RubyGem of the previous release (0.5.7) was corrupt. +We're close to being able to translate all of RSpec's own Test::Unit +tests and have them run successfully! + +* Updated test2spec documentation. +* Replaced old test2rspec with a new test2spec, which is based on ParseTree and RubyInline. + +=== Version 0.5.7 +This release changes examples and documentation to recommend underscores rather than dots, +and addresses some bugfixes and changes to the spec commandline. + +* spec DIR now works correctly, recursing down and slurping all *.rb files +* All documentation and examples are now using '_' instead of '.' +* Custom external formatters can now be specified via --require and --format. + +=== Version 0.5.6 +This release fixes a bug in the Rails controller generator + +* The controller generator did not write correct source code (missing 'do'). Fixed. + +=== Version 0.5.5 +This release adds initial support for Ruby on Rails in the rspec_generator gem. + +* [Rails] Reorganised Lachie's original code to be a generator packaged as a gem rather than a plugin. +* [Rails] Imported code from http://lachie.info/svn/projects/rails_plugins/rspec_on_rails (Written by Lachie Cox) +* Remove stack trace lines from TextMate's Ruby bundle +* Better error message from spectask when no spec files are found. + +=== Version 0.5.4 +The "the tutorial is ahead of the gem" release + +* Support for running a single spec with --spec +* Exitcode is now 1 unless all specs pass, in which case it's 0. +* -v, --version now both mean the same thing +* For what was verbose output (-v), use --format specdoc or -f s +* --format rdoc always runs in dry-run mode +* Removed --doc and added --format and --dry-run +* Refactored towards more pluggable formatters +* Use webgen's execute tag when generating website (more accurate) +* Fixed incorrect quoting of spec_opts in SpecTask +* Added patch to enable underscored shoulds like 1.should_equal(1) - patch from Rich Kilmer +* Removed most inherited instance method from Mock, making more methods mockable. +* Made the RCovVerify task part of the standard toolset. +* Documented Rake task and how to use it with Rcov +* Implemented <ruby></ruby> tags for website (hooking into ERB, RedCloth and syntax) +* RSpec Rake task now takes spec_opts and out params so it can be used for doc generation +* RCov integration for RSpec Rake task (#4058) +* Group all results instead of printing them several times (#4057) +* Mocks can now yield +* Various improvements to error reporting (including #4191) +* backtrace excludes rspec code - use -b to include it +* split examples into examples (passing) and failing_examples + +=== Version 0.5.3 +The "hurry up, CoR is in two days" release. + +* Don't run rcov by default +* Make separate task for running tests with RCov +* Added Rake task to fail build if coverage drops below a certain threshold +* Even more failure output cleanup (simplification) +* Added duck_type constraint for mocks + +=== Version 0.5.2 +This release has minor improvements to the commandline and fixes some gem warnings + +* Readded README to avoid RDoc warnings +* Added --version switch to commandline +* More changes to the mock API + +=== Version 0.5.1 +This release is the first release of RSpec with a new website. It will look better soon. + +* Added initial documentation for API +* Added website based on webgen +* Modified test task to use rcov +* Deleted unused code (thanks, rcov!) +* Various changes to the mock API, +* Various improvements to failure reporting + +=== Version 0.5.0 +This release introduces a new API and obsolesces previous versions. + +* Moved source code to separate subfolders +* Added new DSL runner based on instance_exec +* Added spike for testdox/rdoc generation +* merge Astels' and Chelimsky's work on ShouldHelper +* this would be 0.5.0 if I updated the documentation +* it breaks all of your existing specifications. We're not sorry. + +=== Version 0.3.2 + +The "srbaker is an idiot" release. + +* also forgot to update the path to the actual Subversion repository +* this should be it + +=== Version 0.3.1 + +This is just 0.3.0, but with the TUTORIAL added to the documentation list. + +* forgot to include TUTORIAL in the documentation + +=== Version 0.3.0 + +It's been a while since last release, lots of new stuff is available. For instance: + +* improvements to the runners +* addition of should_raise expectation (thanks to Brian Takita) +* some documentation improvements +* RSpec usable as a DSL + +=== Version 0.2.0 + +This release provides a tutorial for new users wishing to get started with +RSpec, and many improvements. + +* improved reporting in the spec runner output +* update the examples to the new mock api +* added TUTORIAL, a getting started document for new users of RSpec + +=== Version 0.1.7 + +This release improves installation and documentation, mock integration and error reporting. + +* Comparison errors now print the class name too. +* Mocks now take an optional +options+ parameter to specify behaviour. +* Removed __expects in favour of should_receive +* Added line number reporting in mock error messages for unreceived message expectations. +* Added should_match and should_not_match. +* Added a +mock+ method to Spec::Context which will create mocks that autoverify (no need to call __verify). +* Mocks now require names in the constructor to ensure sensible error messages. +* Made 'spec' executable and updated usage instructions in README accordingly. +* Made more parts of the Spec::Context API private to avoid accidental usage. +* Added more RDoc to Spec::Context. + +=== Version 0.1.6 + +More should methods. + +* Added should_match and should_not_match. + +=== Version 0.1.5 + +Included examples and tests in gem. + +=== Version 0.1.4 + +More tests on block based Mock expectations. + +=== Version 0.1.3 + +Improved mocking: + +* block based Mock expectations. + +=== Version 0.1.2 + +This release adds some improvements to the mock API and minor syntax improvements + +* Added Mock.should_expect for a more consistent DSL. +* Added MockExpectation.and_returns for a better DSL. +* Made Mock behave as a null object after a call to Mock.ignore_missing +* Internal syntax improvements. +* Improved exception trace by adding exception class name to error message. +* Renamed some tests for better consistency. + +=== Version 0.1.1 + +This release adds some shoulds and improves error reporting + +* Added should be_same_as and should_not be_same_as. +* Improved error reporting for comparison expectations. + +=== Version 0.1.0 + +This is the first preview release of RSpec, a Behaviour-Driven Development library for Ruby + +* Added Rake script with tasks for gems, rdoc etc. +* Added an XForge task to make release go easier. diff --git a/vendor/plugins/rspec/License.txt b/vendor/plugins/rspec/License.txt new file mode 100644 index 000000000..52c061f8e --- /dev/null +++ b/vendor/plugins/rspec/License.txt @@ -0,0 +1,22 @@ +(The MIT License) + +Copyright (c) 2005-2009 The RSpec Development Team + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/vendor/plugins/rspec/Manifest.txt b/vendor/plugins/rspec/Manifest.txt new file mode 100644 index 000000000..4329b39d2 --- /dev/null +++ b/vendor/plugins/rspec/Manifest.txt @@ -0,0 +1,377 @@ +.document +History.rdoc +License.txt +Manifest.txt +README.rdoc +Rakefile +Ruby1.9.rdoc +TODO.txt +Upgrade.rdoc +bin/autospec +bin/spec +cucumber.yml +examples/failing/README.txt +examples/failing/diffing_spec.rb +examples/failing/failing_implicit_docstrings_example.rb +examples/failing/failure_in_after.rb +examples/failing/failure_in_before.rb +examples/failing/mocking_example.rb +examples/failing/mocking_with_flexmock.rb +examples/failing/mocking_with_mocha.rb +examples/failing/mocking_with_rr.rb +examples/failing/partial_mock_example.rb +examples/failing/pending_example.rb +examples/failing/predicate_example.rb +examples/failing/raising_example.rb +examples/failing/syntax_error_example.rb +examples/failing/team_spec.rb +examples/failing/timeout_behaviour.rb +examples/passing/custom_formatter.rb +examples/passing/custom_matchers.rb +examples/passing/dynamic_spec.rb +examples/passing/file_accessor.rb +examples/passing/file_accessor_spec.rb +examples/passing/filtered_formatter.rb +examples/passing/filtered_formatter_example.rb +examples/passing/greeter_spec.rb +examples/passing/helper_method_example.rb +examples/passing/implicit_docstrings_example.rb +examples/passing/io_processor.rb +examples/passing/io_processor_spec.rb +examples/passing/mocking_example.rb +examples/passing/multi_threaded_example_group_runner.rb +examples/passing/nested_classes_example.rb +examples/passing/options_example.rb +examples/passing/options_formatter.rb +examples/passing/partial_mock_example.rb +examples/passing/pending_example.rb +examples/passing/predicate_example.rb +examples/passing/shared_example_group_example.rb +examples/passing/shared_stack_examples.rb +examples/passing/simple_matcher_example.rb +examples/passing/stack.rb +examples/passing/stack_spec.rb +examples/passing/stack_spec_with_nested_example_groups.rb +examples/passing/stubbing_example.rb +examples/passing/yielding_example.rb +examples/ruby1.9.compatibility/access_to_constants_spec.rb +features/before_and_after_blocks/before_and_after_blocks.feature +features/command_line/line_number_option.feature +features/command_line/line_number_option_with_example_with_no_name.feature +features/example_groups/define_example_attribute.feature +features/example_groups/example_group_with_should_methods.feature +features/example_groups/implicit_docstrings.feature +features/example_groups/nested_groups.feature +features/expectations/customized_message.feature +features/expectations/expect_change.feature +features/expectations/expect_error.feature +features/extensions/custom_example_group.feature +features/formatters/custom_formatter.feature +features/interop/examples_and_tests_together.feature +features/interop/rspec_output.feature +features/interop/test_but_not_test_unit.feature +features/interop/test_case_with_should_methods.feature +features/load_paths/add_lib_to_load_path.feature +features/load_paths/add_spec_to_load_path.feature +features/matchers/define_diffable_matcher.feature +features/matchers/define_matcher.feature +features/matchers/define_matcher_outside_rspec.feature +features/matchers/define_matcher_with_fluent_interface.feature +features/matchers/define_wrapped_matcher.feature +features/mock_framework_integration/use_flexmock.feature +features/mock_framework_integration/use_mocha.feature +features/mock_framework_integration/use_rr.feature +features/mocks/mix_stubs_and_mocks.feature +features/mocks/stub_implementation.feature +features/pending/pending_examples.feature +features/runner/specify_line_number.feature +features/spec_helper/spec_helper.feature +features/step_definitions/running_rspec_steps.rb +features/subject/explicit_subject.feature +features/subject/implicit_subject.feature +features/support/env.rb +features/support/matchers/smart_match.rb +init.rb +lib/autotest/discover.rb +lib/autotest/rspec.rb +lib/spec.rb +lib/spec/adapters/mock_frameworks/flexmock.rb +lib/spec/adapters/mock_frameworks/mocha.rb +lib/spec/adapters/mock_frameworks/rr.rb +lib/spec/adapters/mock_frameworks/rspec.rb +lib/spec/autorun.rb +lib/spec/deprecation.rb +lib/spec/dsl.rb +lib/spec/dsl/main.rb +lib/spec/example.rb +lib/spec/example/args_and_options.rb +lib/spec/example/before_and_after_hooks.rb +lib/spec/example/errors.rb +lib/spec/example/example_group.rb +lib/spec/example/example_group_factory.rb +lib/spec/example/example_group_hierarchy.rb +lib/spec/example/example_group_methods.rb +lib/spec/example/example_group_proxy.rb +lib/spec/example/example_matcher.rb +lib/spec/example/example_methods.rb +lib/spec/example/example_proxy.rb +lib/spec/example/module_reopening_fix.rb +lib/spec/example/pending.rb +lib/spec/example/predicate_matchers.rb +lib/spec/example/shared_example_group.rb +lib/spec/example/subject.rb +lib/spec/expectations.rb +lib/spec/expectations/errors.rb +lib/spec/expectations/extensions.rb +lib/spec/expectations/extensions/kernel.rb +lib/spec/expectations/fail_with.rb +lib/spec/expectations/handler.rb +lib/spec/interop/test.rb +lib/spec/interop/test/unit/autorunner.rb +lib/spec/interop/test/unit/testcase.rb +lib/spec/interop/test/unit/testresult.rb +lib/spec/interop/test/unit/testsuite_adapter.rb +lib/spec/interop/test/unit/ui/console/testrunner.rb +lib/spec/matchers.rb +lib/spec/matchers/be.rb +lib/spec/matchers/be_close.rb +lib/spec/matchers/be_instance_of.rb +lib/spec/matchers/be_kind_of.rb +lib/spec/matchers/change.rb +lib/spec/matchers/compatibility.rb +lib/spec/matchers/dsl.rb +lib/spec/matchers/eql.rb +lib/spec/matchers/equal.rb +lib/spec/matchers/errors.rb +lib/spec/matchers/exist.rb +lib/spec/matchers/extensions/instance_exec.rb +lib/spec/matchers/generated_descriptions.rb +lib/spec/matchers/has.rb +lib/spec/matchers/have.rb +lib/spec/matchers/include.rb +lib/spec/matchers/match.rb +lib/spec/matchers/match_array.rb +lib/spec/matchers/matcher.rb +lib/spec/matchers/method_missing.rb +lib/spec/matchers/operator_matcher.rb +lib/spec/matchers/pretty.rb +lib/spec/matchers/raise_error.rb +lib/spec/matchers/respond_to.rb +lib/spec/matchers/satisfy.rb +lib/spec/matchers/simple_matcher.rb +lib/spec/matchers/throw_symbol.rb +lib/spec/matchers/wrap_expectation.rb +lib/spec/mocks.rb +lib/spec/mocks/argument_expectation.rb +lib/spec/mocks/argument_matchers.rb +lib/spec/mocks/error_generator.rb +lib/spec/mocks/errors.rb +lib/spec/mocks/example_methods.rb +lib/spec/mocks/extensions.rb +lib/spec/mocks/extensions/object.rb +lib/spec/mocks/framework.rb +lib/spec/mocks/message_expectation.rb +lib/spec/mocks/methods.rb +lib/spec/mocks/mock.rb +lib/spec/mocks/order_group.rb +lib/spec/mocks/proxy.rb +lib/spec/mocks/space.rb +lib/spec/rake/spectask.rb +lib/spec/rake/verify_rcov.rb +lib/spec/ruby.rb +lib/spec/runner.rb +lib/spec/runner/backtrace_tweaker.rb +lib/spec/runner/class_and_arguments_parser.rb +lib/spec/runner/command_line.rb +lib/spec/runner/configuration.rb +lib/spec/runner/differs/default.rb +lib/spec/runner/differs/load-diff-lcs.rb +lib/spec/runner/drb_command_line.rb +lib/spec/runner/example_group_runner.rb +lib/spec/runner/extensions/kernel.rb +lib/spec/runner/formatter/base_formatter.rb +lib/spec/runner/formatter/base_text_formatter.rb +lib/spec/runner/formatter/failing_example_groups_formatter.rb +lib/spec/runner/formatter/failing_examples_formatter.rb +lib/spec/runner/formatter/html_formatter.rb +lib/spec/runner/formatter/nested_text_formatter.rb +lib/spec/runner/formatter/no_op_method_missing.rb +lib/spec/runner/formatter/profile_formatter.rb +lib/spec/runner/formatter/progress_bar_formatter.rb +lib/spec/runner/formatter/silent_formatter.rb +lib/spec/runner/formatter/snippet_extractor.rb +lib/spec/runner/formatter/specdoc_formatter.rb +lib/spec/runner/formatter/text_mate_formatter.rb +lib/spec/runner/heckle_runner.rb +lib/spec/runner/heckle_runner_unsupported.rb +lib/spec/runner/line_number_query.rb +lib/spec/runner/option_parser.rb +lib/spec/runner/options.rb +lib/spec/runner/reporter.rb +lib/spec/stubs/cucumber.rb +lib/spec/test/unit.rb +lib/spec/version.rb +resources/helpers/cmdline.rb +resources/rake/examples.rake +resources/rake/examples_with_rcov.rake +resources/rake/failing_examples_with_html.rake +resources/rake/verify_rcov.rake +spec/README.jruby +spec/autotest/autotest_helper.rb +spec/autotest/autotest_matchers.rb +spec/autotest/discover_spec.rb +spec/autotest/failed_results_re_spec.rb +spec/autotest/rspec_spec.rb +spec/ruby_forker.rb +spec/spec.opts +spec/spec/dsl/main_spec.rb +spec/spec/example/example_group_class_definition_spec.rb +spec/spec/example/example_group_factory_spec.rb +spec/spec/example/example_group_methods_spec.rb +spec/spec/example/example_group_proxy_spec.rb +spec/spec/example/example_group_spec.rb +spec/spec/example/example_matcher_spec.rb +spec/spec/example/example_methods_spec.rb +spec/spec/example/example_proxy_spec.rb +spec/spec/example/helper_method_spec.rb +spec/spec/example/nested_example_group_spec.rb +spec/spec/example/pending_module_spec.rb +spec/spec/example/predicate_matcher_spec.rb +spec/spec/example/shared_example_group_spec.rb +spec/spec/example/subclassing_example_group_spec.rb +spec/spec/example/subject_spec.rb +spec/spec/expectations/differs/default_spec.rb +spec/spec/expectations/extensions/kernel_spec.rb +spec/spec/expectations/fail_with_spec.rb +spec/spec/expectations/handler_spec.rb +spec/spec/expectations/wrap_expectation_spec.rb +spec/spec/interop/test/unit/resources/spec_that_fails.rb +spec/spec/interop/test/unit/resources/spec_that_passes.rb +spec/spec/interop/test/unit/resources/spec_with_errors.rb +spec/spec/interop/test/unit/resources/spec_with_options_hash.rb +spec/spec/interop/test/unit/resources/test_case_that_fails.rb +spec/spec/interop/test/unit/resources/test_case_that_passes.rb +spec/spec/interop/test/unit/resources/test_case_with_errors.rb +spec/spec/interop/test/unit/resources/test_case_with_various_names.rb +spec/spec/interop/test/unit/resources/testsuite_adapter_spec_with_test_unit.rb +spec/spec/interop/test/unit/spec_spec.rb +spec/spec/interop/test/unit/test_unit_spec_helper.rb +spec/spec/interop/test/unit/testcase_spec.rb +spec/spec/interop/test/unit/testsuite_adapter_spec.rb +spec/spec/matchers/be_close_spec.rb +spec/spec/matchers/be_instance_of_spec.rb +spec/spec/matchers/be_kind_of_spec.rb +spec/spec/matchers/be_spec.rb +spec/spec/matchers/change_spec.rb +spec/spec/matchers/compatibility_spec.rb +spec/spec/matchers/description_generation_spec.rb +spec/spec/matchers/dsl_spec.rb +spec/spec/matchers/eql_spec.rb +spec/spec/matchers/equal_spec.rb +spec/spec/matchers/exist_spec.rb +spec/spec/matchers/has_spec.rb +spec/spec/matchers/have_spec.rb +spec/spec/matchers/include_spec.rb +spec/spec/matchers/match_array_spec.rb +spec/spec/matchers/match_spec.rb +spec/spec/matchers/matcher_methods_spec.rb +spec/spec/matchers/matcher_spec.rb +spec/spec/matchers/matchers_spec.rb +spec/spec/matchers/operator_matcher_spec.rb +spec/spec/matchers/raise_error_spec.rb +spec/spec/matchers/respond_to_spec.rb +spec/spec/matchers/satisfy_spec.rb +spec/spec/matchers/simple_matcher_spec.rb +spec/spec/matchers/throw_symbol_spec.rb +spec/spec/mocks/any_number_of_times_spec.rb +spec/spec/mocks/argument_expectation_spec.rb +spec/spec/mocks/argument_matchers_spec.rb +spec/spec/mocks/at_least_spec.rb +spec/spec/mocks/at_most_spec.rb +spec/spec/mocks/bug_report_10260_spec.rb +spec/spec/mocks/bug_report_10263_spec.rb +spec/spec/mocks/bug_report_11545_spec.rb +spec/spec/mocks/bug_report_15719_spec.rb +spec/spec/mocks/bug_report_496_spec.rb +spec/spec/mocks/bug_report_600_spec.rb +spec/spec/mocks/bug_report_7611_spec.rb +spec/spec/mocks/bug_report_7805_spec.rb +spec/spec/mocks/bug_report_8165_spec.rb +spec/spec/mocks/bug_report_8302_spec.rb +spec/spec/mocks/bug_report_830_spec.rb +spec/spec/mocks/double_spec.rb +spec/spec/mocks/failing_argument_matchers_spec.rb +spec/spec/mocks/hash_including_matcher_spec.rb +spec/spec/mocks/hash_not_including_matcher_spec.rb +spec/spec/mocks/mock_ordering_spec.rb +spec/spec/mocks/mock_space_spec.rb +spec/spec/mocks/mock_spec.rb +spec/spec/mocks/multiple_return_value_spec.rb +spec/spec/mocks/nil_expectation_warning_spec.rb +spec/spec/mocks/null_object_mock_spec.rb +spec/spec/mocks/once_counts_spec.rb +spec/spec/mocks/options_hash_spec.rb +spec/spec/mocks/partial_mock_spec.rb +spec/spec/mocks/partial_mock_using_mocks_directly_spec.rb +spec/spec/mocks/passing_argument_matchers_spec.rb +spec/spec/mocks/precise_counts_spec.rb +spec/spec/mocks/record_messages_spec.rb +spec/spec/mocks/stub_chain_spec.rb +spec/spec/mocks/stub_implementation_spec.rb +spec/spec/mocks/stub_spec.rb +spec/spec/mocks/stubbed_message_expectations_spec.rb +spec/spec/mocks/twice_counts_spec.rb +spec/spec/mocks/unstub_spec.rb +spec/spec/package/bin_spec_spec.rb +spec/spec/rake/spectask_spec.rb +spec/spec/runner/class_and_argument_parser_spec.rb +spec/spec/runner/command_line_spec.rb +spec/spec/runner/configuration_spec.rb +spec/spec/runner/drb_command_line_spec.rb +spec/spec/runner/empty_file.txt +spec/spec/runner/example_group_runner_spec.rb +spec/spec/runner/examples.txt +spec/spec/runner/failed.txt +spec/spec/runner/formatter/base_formatter_spec.rb +spec/spec/runner/formatter/base_text_formatter_spec.rb +spec/spec/runner/formatter/failing_example_groups_formatter_spec.rb +spec/spec/runner/formatter/failing_examples_formatter_spec.rb +spec/spec/runner/formatter/html_formatted-1.8.6-jruby.html +spec/spec/runner/formatter/html_formatted-1.8.6.html +spec/spec/runner/formatter/html_formatted-1.8.7.html +spec/spec/runner/formatter/html_formatted-1.9.1.html +spec/spec/runner/formatter/html_formatter_spec.rb +spec/spec/runner/formatter/nested_text_formatter_spec.rb +spec/spec/runner/formatter/profile_formatter_spec.rb +spec/spec/runner/formatter/progress_bar_formatter_spec.rb +spec/spec/runner/formatter/snippet_extractor_spec.rb +spec/spec/runner/formatter/specdoc_formatter_spec.rb +spec/spec/runner/formatter/text_mate_formatted-1.8.6-jruby.html +spec/spec/runner/formatter/text_mate_formatted-1.8.6.html +spec/spec/runner/formatter/text_mate_formatted-1.8.7.html +spec/spec/runner/formatter/text_mate_formatted-1.9.1.html +spec/spec/runner/formatter/text_mate_formatter_spec.rb +spec/spec/runner/heckle_runner_spec.rb +spec/spec/runner/heckler_spec.rb +spec/spec/runner/line_number_query/line_number_query_fixture.rb +spec/spec/runner/line_number_query_spec.rb +spec/spec/runner/noisy_backtrace_tweaker_spec.rb +spec/spec/runner/option_parser_spec.rb +spec/spec/runner/options_spec.rb +spec/spec/runner/output_one_time_fixture.rb +spec/spec/runner/output_one_time_fixture_runner.rb +spec/spec/runner/output_one_time_spec.rb +spec/spec/runner/quiet_backtrace_tweaker_spec.rb +spec/spec/runner/reporter_spec.rb +spec/spec/runner/resources/a_bar.rb +spec/spec/runner/resources/a_foo.rb +spec/spec/runner/resources/a_spec.rb +spec/spec/runner/resources/custom_example_group_runner.rb +spec/spec/runner/resources/utf8_encoded.rb +spec/spec/runner/spec.opts +spec/spec/runner/spec_drb.opts +spec/spec/runner/spec_spaced.opts +spec/spec/runner_spec.rb +spec/spec_helper.rb +spec/support/macros.rb +spec/support/spec_classes.rb diff --git a/vendor/plugins/rspec/README.rdoc b/vendor/plugins/rspec/README.rdoc new file mode 100644 index 000000000..3174497a3 --- /dev/null +++ b/vendor/plugins/rspec/README.rdoc @@ -0,0 +1,55 @@ += RSpec + +* http://rspec.info +* http://rubyforge.org/projects/rspec +* http://github.com/dchelimsky/rspec/wikis +* mailto:rspec-users@rubyforge.org +* mailto:rspec-devel@rubyforge.org + +== DESCRIPTION: + +RSpec is a Behaviour Driven Development framework for writing executable code +examples. + +== FEATURES: + +* Spec::Example provides a framework for organizing executable code examples +* Spec::Expectations adds #should and #should_not to every object +* Spec::Matchers provides Expression Matchers for use with #should and #should_not +* Spec::Mocks is a full featured mock object/stubbing library + +== SYNOPSIS: + + describe Account do + context "transfering money" do + it "deposits transfer amount to the other account" do + source = Account.new(50, :USD) + target = mock('target account') + target.should_receive(:deposit).with(Money.new(5, :USD)) + source.transfer(5, :USD).to(target) + end + + it "reduces its balance by the transfer amount" do + source = Account.new(50, :USD) + target = stub('target account') + source.transfer(5, :USD).to(target) + source.balance.should == Money.new(45, :USD) + end + end + end + + $ spec spec/account_spec.rb --format nested + Account + transfering money + deposits transfer amount to the other account + reduces its balance by the transfer amount + + 2 examples, 0 failures + +== INSTALL: + + [sudo] gem install rspec + + or + + clone, build, install - See http://wiki.github.com/dchelimsky/rspec
\ No newline at end of file diff --git a/vendor/plugins/rspec/Ruby1.9.rdoc b/vendor/plugins/rspec/Ruby1.9.rdoc new file mode 100644 index 000000000..e42cc85e4 --- /dev/null +++ b/vendor/plugins/rspec/Ruby1.9.rdoc @@ -0,0 +1,31 @@ += RSpec and Ruby 1.9 + +RSpec runs on Ruby 1.9.1 with the following caveats. + +== Test::Unit + +RSpec/Test::Unit interop will run with the test-unit-1.2.3 gem, but you must install it. + +== Class Variables + +Due to changes in scoping rules, class variables within example groups are not +supported in Ruby 1.9. + + describe "a class variable" do + @@class_variable = "a class variable" + + it "can access class variables in examples in Ruby 1.8" do + with_ruby 1.8 do + @@class_variable.should == "a class variable" + end + end + + it "can NOT access class variables in examples in Ruby 1.9" do + with_ruby 1.9 do + lambda do + @@class_variable.should == "a class variable" + end.should raise_error(NameError) + end + end + end + diff --git a/vendor/plugins/rspec/TODO.txt b/vendor/plugins/rspec/TODO.txt new file mode 100644 index 000000000..fc59a25bb --- /dev/null +++ b/vendor/plugins/rspec/TODO.txt @@ -0,0 +1,17 @@ +== Refactoring + +** global predictate matchers should be stored in run_options +* eliminate dependency on global options and configuration +** the only place they should exist is in the Runner, which should manage them + +== Future + +* do SOMETHING with the website +* separate the underlying framework from the DSL + * be able to do everything with classes and methods +* tweak raise_error rdoc to show only one arg + +== rspec-2.0 + +* rename top level namespace to Rspec and commands to 'rspec' and 'autorspec' + * continue to support Spec 'spec' and 'autospec' as aliases for a reasonable time diff --git a/vendor/plugins/rspec/Upgrade.rdoc b/vendor/plugins/rspec/Upgrade.rdoc new file mode 100644 index 000000000..126177f33 --- /dev/null +++ b/vendor/plugins/rspec/Upgrade.rdoc @@ -0,0 +1,199 @@ += Upgrade to rspec-1.2.9 + +== What's new + +=== spec/spec.opts + +If you have a spec/spec.opts file, the spec command will now use that +automatically as long as you don't include any options on the command line. + +=== let() + +Writing specs tends to follow a regular pattern of using local variables, discovering duplication, and then having to convert to local variables to instance variables by adding an "@" symbol. The let() method assigns the result of a lazy eval'd block as the return value of an instance method using +the same name. This way you can go from this: + + describe Subscription do + it "does something" do + subscription = Subscription.create :limit => 1 + subscription... + end + + it "does something else" do + subscription = Subscription.create :limit => 1 + subscription... + end + end + +to this: + + describe Subscription do + let(:subscription) { Subscription.create :limit => 1 } + + it "does something" do + subscription... + end + + it "does something else" do + subscription... + end + end + +=== its() + +If you're in the habit of writing one-liners using implicit subject, this new +its() feature is for you. Here's the basic idea: + + describe Array do + its(:length) { should == 0 } + end + += Upgrade to rspec-1.2.3-1.2.7 + +== What's Changed + +=== Matcher DSL + +Use Spec::Matchers.define instead of Spec::Matchers.create (which is now +deprecated). + +=== Explicit Predicate Matchers are deprecated + +With the addition of the new Matcher DSL the old, confusing, and +almost-nobody-uses-it explicit predicate matcher functionality's days are now +numbered. + +If you're not familiar with this feature, don't worry about it. If you have anything +that looks like this: + + predicate_matchers[:swim] = :can_swim? + +Or this + + config.predicate_matchers[:swim] = :can_swim? + +Change it to this: + + Spec::Matchers.define :swim do + match do |potential_swimmer| + potential_swimmer.can_swim? + end + end + +== Custom Formatters + +If you have an custom formatter, the <tt>add_example_group</tt> method has +been changed to <tt>example_group_started</tt>, and kept as an alias so your +formatters will still work. Though not yet, <tt>add_example_group</tt> will be +deprecated in a future minor release, and removed in a future major release, +so we recommend you make this change now. + += Upgrade to rspec-1.2.2 + +== What's Changed + +=== <tt>require 'rubygems' unless ENV['NO_RUBYGEMS']</tt> + +After minor public outcry and confusion, we restored necessary references to +rubygems in rspec. If you use a different mechanism for managing gems, just +set a <tt>NO_RUBYGEMS</tt> environment variable (to any non-nil value). + +=== Proxies and locations + +This is probably only interesting to you if you use custom formatters. + +Formatters now receive Spec::Example::ExampleGroupProxy and +Spec::Example::ExampleGroup objects with cohesive APIs for reporting. See the +RDoc for those classes and Spec::Runner::Formatter::BaseFormatter for more +information. + +== What's new + +=== The new matcher DSL works with test/unit (without the rest of rspec) + +We'll be separating this out to its own gem for rspec 2.0, but for now, just install +rspec >= 1.2.1 and add the following to your <tt>test_helper</tt> file: + + require 'spec/expectations' + class Test::Unit::TestCase + include Spec::Matchers + end + +This will add <tt>should()</tt> and <tt>should_not()</tt> to your objects, make all of +rspec's built-in matchers available to your tests, INCLUDING rspec's DSL for +creating matchers (see below, under Upgrade to rspec-1.2.0) + +=== debugger + +If you have ruby-debug installed, you can set a breakpoint by adding <tt>debugger()</tt> +in your code: + + # some code ..... + debugger + # some more code .... + +... and using the <tt>--debugger</tt> or <tt>-u</tt> command line option. + + spec path/to/file.rb --debugger + += Upgrade to rspec-1.2.0 + +== What's Changed + +=== WARNINGS + +* If you use the ruby command to run specs instead of the spec command, you'll + need to require 'spec/autorun' or they won't run. This won't affect you if + you use the spec command or the Spec::Rake::SpecTask that ships with RSpec. + +* require 'spec/test/unit' to invoke test/unit interop if you're using + RSpec's core (this is handled implicitly with spec-rails) + +* setup and teardown are gone - use before and after instead + + * you can still use setup and teardown if you're using + Test::Unit::TestCase as the base ExampleGroup class (which is implicit + in rspec-rails) + +* The matcher protocol has been improved. The old protocol is still supported, + but we added support for two new methods that speak a bit more clearly: + + failure_message => failure_message_for_should + negative_failure_message => failure_message_for_should_not + +* All references to rubygems have been removed from within rspec's code. + + * See http://gist.github.com/54177 for rationale and suggestions on + alternative approaches to loading rubygems + +== What's New + +=== Ruby 1.9 + +RSpec now works with Ruby 1.9.1. See http://wiki.github.com/dchelimsky/rspec/ruby-191 +for useful information. + +=== Improved heckle integration + +RSpec works with heckle again! Gotta use heckle >= 1.4.2 for this to work +though, and it only works with ruby-1.8.6 and 1.8.7 (heckle doesn't support +1.9.1 yet). + + [sudo] gem install heckle --version ">=1.4.2" + spec spec/game/mastermind.rb --heckle Game::Mastermind + +=== New Matcher DSL + +We've added a new DSL for generating custom matchers very simply and cleanly. +We'll still support the simple_matcher method, so never fear if you're using +that, but we recommend that you start developing your new matchers with this +new syntax. + + Spec::Matchers.create :be_a_multiple_of do |smaller| + match do |bigger| + bigger % smaller == 0 + end + end + + 9.should be_a_multiple_of(3) + +See <tt>features/matchers/define_matcher.feature</tt> for more examples diff --git a/vendor/plugins/rspec/bin/autospec b/vendor/plugins/rspec/bin/autospec new file mode 100755 index 000000000..82a314f15 --- /dev/null +++ b/vendor/plugins/rspec/bin/autospec @@ -0,0 +1,4 @@ +#!/usr/bin/env ruby +ENV['RSPEC'] = 'true' # allows autotest to discover rspec +ENV['AUTOTEST'] = 'true' # allows autotest to run w/ color on linux +system (RUBY_PLATFORM =~ /mswin|mingw/ ? 'autotest.bat' : 'autotest'), *ARGV
\ No newline at end of file diff --git a/vendor/plugins/rspec/cucumber.yml b/vendor/plugins/rspec/cucumber.yml new file mode 100644 index 000000000..31733b5d8 --- /dev/null +++ b/vendor/plugins/rspec/cucumber.yml @@ -0,0 +1,5 @@ +default: --require features features -t ~@wip +pending: --require features features-pending +no_heckle: --require features features --exclude heckle +focus: --require features features -t focus +wip: --require features features -t @wip diff --git a/vendor/plugins/rspec/examples/failing/README.txt b/vendor/plugins/rspec/examples/failing/README.txt new file mode 100644 index 000000000..7e9f49236 --- /dev/null +++ b/vendor/plugins/rspec/examples/failing/README.txt @@ -0,0 +1,11 @@ +"Why have failing examples?", you might ask. + +They allow us to see failure messages. RSpec wants to provide meaningful and +helpful failure messages. The failures in this directory not only provide you +a way of seeing the failure messages, but they provide RSpec's own specs a way +of describing what they should look like and ensuring they stay correct. + +To see the types of messages you can expect, stand in the root directory and +run: + +bin/spec examples/failing/*.rb
\ No newline at end of file diff --git a/vendor/plugins/rspec/examples/failing/diffing_spec.rb b/vendor/plugins/rspec/examples/failing/diffing_spec.rb new file mode 100644 index 000000000..85e13e8c0 --- /dev/null +++ b/vendor/plugins/rspec/examples/failing/diffing_spec.rb @@ -0,0 +1,36 @@ +describe "Running specs with --diff" do + it "should print diff of different strings" do + uk = <<-EOF +RSpec is a +behaviour driven development +framework for Ruby +EOF + usa = <<-EOF +RSpec is a +behavior driven development +framework for Ruby +EOF + usa.should == uk + end + + class Animal + def initialize(name,species) + @name,@species = name,species + end + + def inspect + <<-EOA +<Animal +name=#{@name}, +species=#{@species} +> + EOA + end + end + + it "should print diff of different objects' pretty representation" do + expected = Animal.new "bob", "giraffe" + actual = Animal.new "bob", "tortoise" + expected.should eql(actual) + end +end diff --git a/vendor/plugins/rspec/examples/failing/failing_implicit_docstrings_example.rb b/vendor/plugins/rspec/examples/failing/failing_implicit_docstrings_example.rb new file mode 100644 index 000000000..7b0b86614 --- /dev/null +++ b/vendor/plugins/rspec/examples/failing/failing_implicit_docstrings_example.rb @@ -0,0 +1,17 @@ +# Run spec w/ -fs to see the output of this file + +describe "Failing examples with no descriptions" do + + # description is auto-generated as "should equal(5)" based on the last #should + it do + 3.should equal(2) + 5.should equal(5) + end + + it { 3.should be > 5 } + + it { ["a"].should include("b") } + + it { [1,2,3].should_not respond_to(:size) } + +end diff --git a/vendor/plugins/rspec/examples/failing/failure_in_after.rb b/vendor/plugins/rspec/examples/failing/failure_in_after.rb new file mode 100644 index 000000000..a47338aee --- /dev/null +++ b/vendor/plugins/rspec/examples/failing/failure_in_after.rb @@ -0,0 +1,10 @@ +describe "This example" do + + it "should be listed as failing in after" do + end + + after(:each) do + NonExistentClass.new + end + +end diff --git a/vendor/plugins/rspec/examples/failing/failure_in_before.rb b/vendor/plugins/rspec/examples/failing/failure_in_before.rb new file mode 100644 index 000000000..b0826604e --- /dev/null +++ b/vendor/plugins/rspec/examples/failing/failure_in_before.rb @@ -0,0 +1,10 @@ +describe "This example" do + + before(:each) do + NonExistentClass.new + end + + it "should be listed as failing in each" do + end + +end diff --git a/vendor/plugins/rspec/examples/failing/mocking_example.rb b/vendor/plugins/rspec/examples/failing/mocking_example.rb new file mode 100644 index 000000000..9c735e00b --- /dev/null +++ b/vendor/plugins/rspec/examples/failing/mocking_example.rb @@ -0,0 +1,38 @@ +describe "Mocker" do + + it "should be able to call mock()" do + mock = mock("poke me") + mock.should_receive(:poke) + mock.poke + end + + it "should fail when expected message not received" do + mock = mock("poke me") + mock.should_receive(:poke) + end + + it "should fail when messages are received out of order" do + mock = mock("one two three") + mock.should_receive(:one).ordered + mock.should_receive(:two).ordered + mock.should_receive(:three).ordered + mock.one + mock.three + mock.two + end + + it "should get yelled at when sending unexpected messages" do + mock = mock("don't talk to me") + mock.should_not_receive(:any_message_at_all) + mock.any_message_at_all + end + + it "has a bug we need to fix" do + pending "here is the bug" do + # Actually, no. It's fixed. This will fail because it passes :-) + mock = mock("Bug") + mock.should_receive(:hello) + mock.hello + end + end +end diff --git a/vendor/plugins/rspec/examples/failing/mocking_with_flexmock.rb b/vendor/plugins/rspec/examples/failing/mocking_with_flexmock.rb new file mode 100644 index 000000000..6e79ece0e --- /dev/null +++ b/vendor/plugins/rspec/examples/failing/mocking_with_flexmock.rb @@ -0,0 +1,26 @@ +# stub frameworks like to gum up Object, so this is deliberately +# set NOT to run so that you don't accidentally run it when you +# run this dir. + +# To run it, stand in this directory and say: +# +# RUN_FLEXMOCK_EXAMPLE=true ruby ../bin/spec mocking_with_flexmock.rb + +if ENV['RUN_FLEXMOCK_EXAMPLE'] + Spec::Runner.configure do |config| + config.mock_with :flexmock + end + + describe "Flexmocks" do + it "should fail when the expected message is received with wrong arguments" do + m = flexmock("now flex!") + m.should_receive(:msg).with("arg").once + m.msg("other arg") + end + + it "should fail when the expected message is not received at all" do + m = flexmock("now flex!") + m.should_receive(:msg).with("arg").once + end + end +end diff --git a/vendor/plugins/rspec/examples/failing/mocking_with_mocha.rb b/vendor/plugins/rspec/examples/failing/mocking_with_mocha.rb new file mode 100644 index 000000000..f14a1a3e5 --- /dev/null +++ b/vendor/plugins/rspec/examples/failing/mocking_with_mocha.rb @@ -0,0 +1,25 @@ +# stub frameworks like to gum up Object, so this is deliberately +# set NOT to run so that you don't accidentally run it when you +# run this dir. + +# To run it, stand in this directory and say: +# +# RUN_MOCHA_EXAMPLE=true ruby ../bin/spec mocking_with_mocha.rb + +if ENV['RUN_MOCHA_EXAMPLE'] + Spec::Runner.configure do |config| + config.mock_with :mocha + end + describe "Mocha framework" do + it "should should be made available by saying config.mock_with :mocha" do + m = mock() + m.expects(:msg).with("arg") + m.msg + end + it "should should be made available by saying config.mock_with :mocha" do + o = Object.new + o.expects(:msg).with("arg") + o.msg + end + end +end diff --git a/vendor/plugins/rspec/examples/failing/mocking_with_rr.rb b/vendor/plugins/rspec/examples/failing/mocking_with_rr.rb new file mode 100644 index 000000000..0d2b4fe04 --- /dev/null +++ b/vendor/plugins/rspec/examples/failing/mocking_with_rr.rb @@ -0,0 +1,27 @@ +# stub frameworks like to gum up Object, so this is deliberately +# set NOT to run so that you don't accidentally run it when you +# run this dir. + +# To run it, stand in this directory and say: +# +# RUN_RR_EXAMPLE=true ruby ../bin/spec mocking_with_rr.rb + +if ENV['RUN_RR_EXAMPLE'] + Spec::Runner.configure do |config| + config.mock_with :rr + end + describe "RR framework" do + it "should should be made available by saying config.mock_with :rr" do + o = Object.new + mock(o).msg("arg") + o.msg + end + it "should should be made available by saying config.mock_with :rr" do + o = Object.new + mock(o) do |m| + m.msg("arg") + end + o.msg + end + end +end diff --git a/vendor/plugins/rspec/examples/failing/partial_mock_example.rb b/vendor/plugins/rspec/examples/failing/partial_mock_example.rb new file mode 100644 index 000000000..7f8d081b1 --- /dev/null +++ b/vendor/plugins/rspec/examples/failing/partial_mock_example.rb @@ -0,0 +1,18 @@ +class MockableClass + def self.find id + return :original_return + end +end + +describe "A partial mock" do + + it "should work at the class level (but fail here due to the type mismatch)" do + MockableClass.should_receive(:find).with(1).and_return {:stub_return} + MockableClass.find("1").should equal(:stub_return) + end + + it "should revert to the original after each spec" do + MockableClass.find(1).should equal(:original_return) + end + +end diff --git a/vendor/plugins/rspec/examples/failing/pending_example.rb b/vendor/plugins/rspec/examples/failing/pending_example.rb new file mode 100644 index 000000000..825af2ed1 --- /dev/null +++ b/vendor/plugins/rspec/examples/failing/pending_example.rb @@ -0,0 +1,7 @@ +describe "pending example (which is fixed)" do + it %Q|reports "FIXED ... Expected ... to fail. No Error was raised."| do + pending("for some reason") do + # success + end + end +end diff --git a/vendor/plugins/rspec/examples/failing/predicate_example.rb b/vendor/plugins/rspec/examples/failing/predicate_example.rb new file mode 100644 index 000000000..aed8b14bd --- /dev/null +++ b/vendor/plugins/rspec/examples/failing/predicate_example.rb @@ -0,0 +1,32 @@ +class BddFramework + def intuitive? + true + end + + def adopted_quickly? + #this will cause failures because it reallly SHOULD be adopted quickly + false + end +end + +describe "BDD framework" do + + before(:each) do + @bdd_framework = BddFramework.new + end + + it "should be adopted quickly" do + #this will fail because it reallly SHOULD be adopted quickly + @bdd_framework.should be_adopted_quickly + end + + it "should be intuitive" do + @bdd_framework.should be_intuitive + end + + it "should not respond to test" do + #this will fail + @bdd_framework.test + end + +end diff --git a/vendor/plugins/rspec/examples/failing/raising_example.rb b/vendor/plugins/rspec/examples/failing/raising_example.rb new file mode 100644 index 000000000..e40b51ec8 --- /dev/null +++ b/vendor/plugins/rspec/examples/failing/raising_example.rb @@ -0,0 +1,47 @@ +describe "This example" do + + it "should show that a NoMethodError is raised but an Exception was expected" do + proc { ''.nonexistent_method }.should raise_error + end + + it "should pass" do + proc { ''.nonexistent_method }.should raise_error(NoMethodError) + end + + it "should show that a NoMethodError is raised but a SyntaxError was expected" do + proc { ''.nonexistent_method }.should raise_error(SyntaxError) + end + + it "should show that nothing is raised when SyntaxError was expected" do + proc { }.should raise_error(SyntaxError) + end + + it "should show that a NoMethodError is raised but a Exception was expected" do + proc { ''.nonexistent_method }.should_not raise_error + end + + it "should show that a NoMethodError is raised" do + proc { ''.nonexistent_method }.should_not raise_error(NoMethodError) + end + + it "should also pass" do + proc { ''.nonexistent_method }.should_not raise_error(SyntaxError) + end + + it "should show that a NoMethodError is raised when nothing expected" do + proc { ''.nonexistent_method }.should_not raise_error(Exception) + end + + it "should show that the wrong message was received" do + proc { raise StandardError.new("what is an enterprise?") }.should raise_error(StandardError, "not this") + end + + it "should show that the unexpected error/message was thrown" do + proc { raise StandardError.new("abc") }.should_not raise_error(StandardError, "abc") + end + + it "should pass too" do + proc { raise StandardError.new("abc") }.should_not raise_error(StandardError, "xyz") + end + +end diff --git a/vendor/plugins/rspec/examples/failing/syntax_error_example.rb b/vendor/plugins/rspec/examples/failing/syntax_error_example.rb new file mode 100644 index 000000000..c9bb90774 --- /dev/null +++ b/vendor/plugins/rspec/examples/failing/syntax_error_example.rb @@ -0,0 +1,7 @@ +describe "when passing a block to a matcher" do + it "you should use {} instead of do/end" do + Object.new.should satisfy do + "this block is being passed to #should instead of #satisfy - use {} instead" + end + end +end diff --git a/vendor/plugins/rspec/examples/failing/team_spec.rb b/vendor/plugins/rspec/examples/failing/team_spec.rb new file mode 100644 index 000000000..ab35b5274 --- /dev/null +++ b/vendor/plugins/rspec/examples/failing/team_spec.rb @@ -0,0 +1,41 @@ +class Team + attr_reader :players + def initialize + @players = Players.new + end +end + +class Players + def initialize + @players = [] + end + def size + @players.size + end + def include? player + raise "player must be a string" unless player.is_a?(String) + @players.include? player + end +end + +describe "A new team" do + + before(:each) do + @team = Team.new + end + + it "should have 3 players (failing example)" do + @team.should have(3).players + end + + it "should include some player (failing example)" do + @team.players.should include("Some Player") + end + + it "should include 5 (failing example)" do + @team.players.should include(5) + end + + it "should have no players" + +end diff --git a/vendor/plugins/rspec/examples/failing/timeout_behaviour.rb b/vendor/plugins/rspec/examples/failing/timeout_behaviour.rb new file mode 100644 index 000000000..1a3615ff0 --- /dev/null +++ b/vendor/plugins/rspec/examples/failing/timeout_behaviour.rb @@ -0,0 +1,5 @@ +describe "Something really slow" do + it "should be failed by RSpec when it takes longer than --timeout" do + sleep(2) + end +end diff --git a/vendor/plugins/rspec/examples/passing/custom_formatter.rb b/vendor/plugins/rspec/examples/passing/custom_formatter.rb new file mode 100644 index 000000000..4c7482190 --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/custom_formatter.rb @@ -0,0 +1,11 @@ +require 'spec/runner/formatter/progress_bar_formatter' + +# Example of a formatter with custom bactrace printing. Run me with: +# ruby bin/spec examples/failing -r examples/passing/custom_formatter.rb -f CustomFormatter +class CustomFormatter < Spec::Runner::Formatter::ProgressBarFormatter + def backtrace_line(line) + line.gsub(/([^:]*\.rb):(\d*)/) do + "<a href=\"file://#{File.expand_path($1)}\">#{$1}:#{$2}</a> " + end + end +end diff --git a/vendor/plugins/rspec/examples/passing/custom_matchers.rb b/vendor/plugins/rspec/examples/passing/custom_matchers.rb new file mode 100644 index 000000000..075bb542d --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/custom_matchers.rb @@ -0,0 +1,54 @@ +module AnimalSpecHelper + class Eat + def initialize(food) + @food = food + end + + def matches?(animal) + @animal = animal + @animal.eats?(@food) + end + + def failure_message + "expected #{@animal} to eat #{@food}, but it does not" + end + + def negative_failure_message + "expected #{@animal} not to eat #{@food}, but it does" + end + end + + def eat(food) + Eat.new(food) + end +end + +module Animals + class Animal + def eats?(food) + return foods_i_eat.include?(food) + end + end + + class Mouse < Animal + def foods_i_eat + [:cheese] + end + end + + describe Mouse do + include AnimalSpecHelper + before(:each) do + @mouse = Animals::Mouse.new + end + + it "should eat cheese" do + @mouse.should eat(:cheese) + end + + it "should not eat cat" do + @mouse.should_not eat(:cat) + end + end + +end diff --git a/vendor/plugins/rspec/examples/passing/dynamic_spec.rb b/vendor/plugins/rspec/examples/passing/dynamic_spec.rb new file mode 100644 index 000000000..7c0372631 --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/dynamic_spec.rb @@ -0,0 +1,7 @@ +describe "The square root" do + (1..10).each do |n| + it "of #{n*n} should be #{n}" do + Math.sqrt(n*n).should == n + end + end +end diff --git a/vendor/plugins/rspec/examples/passing/file_accessor.rb b/vendor/plugins/rspec/examples/passing/file_accessor.rb new file mode 100644 index 000000000..e67f44735 --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/file_accessor.rb @@ -0,0 +1,18 @@ +class FileAccessor + def open_and_handle_with(pathname, processor) + pathname.open do |io| + processor.process(io) + end + end +end + +if __FILE__ == $0 + require 'examples/passing/io_processor' + require 'pathname' + + accessor = FileAccessor.new + io_processor = IoProcessor.new + file = Pathname.new ARGV[0] + + accessor.open_and_handle_with(file, io_processor) +end diff --git a/vendor/plugins/rspec/examples/passing/file_accessor_spec.rb b/vendor/plugins/rspec/examples/passing/file_accessor_spec.rb new file mode 100644 index 000000000..84428b6fc --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/file_accessor_spec.rb @@ -0,0 +1,37 @@ +require 'examples/passing/file_accessor' +require 'stringio' + +describe "A FileAccessor" do + # This sequence diagram illustrates what this spec specifies. + # + # +--------------+ +----------+ +-------------+ + # | FileAccessor | | Pathname | | IoProcessor | + # +--------------+ +----------+ +-------------+ + # | | | + # open_and_handle_with | | | + # -------------------->| | open | | + # | |--------------->| | | + # | | io | | | + # | |<...............| | | + # | | | process(io) | + # | |---------------------------------->| | + # | | | | | + # | |<..................................| | + # | | | + # + it "should open a file and pass it to the processor's process method" do + # This is the primary actor + accessor = FileAccessor.new + + # These are the primary actor's neighbours, which we mock. + file = mock "Pathname" + io_processor = mock "IoProcessor" + + io = StringIO.new "whatever" + file.should_receive(:open).and_yield io + io_processor.should_receive(:process).with(io) + + accessor.open_and_handle_with(file, io_processor) + end + +end diff --git a/vendor/plugins/rspec/examples/passing/filtered_formatter.rb b/vendor/plugins/rspec/examples/passing/filtered_formatter.rb new file mode 100644 index 000000000..eaeabbcfa --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/filtered_formatter.rb @@ -0,0 +1,17 @@ +require 'spec/runner/formatter/nested_text_formatter' + +class FilteredFormatter < Spec::Runner::Formatter::NestedTextFormatter + def add_example_group(example_group) + if example_group.options[:show] == false + @showing = false + else + @showing = true + puts example_group.description + end + end + + def example_passed(example) + puts " " << example.description if @showing unless example.options[:show] == false + end +end + diff --git a/vendor/plugins/rspec/examples/passing/filtered_formatter_example.rb b/vendor/plugins/rspec/examples/passing/filtered_formatter_example.rb new file mode 100644 index 000000000..3c9d067f1 --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/filtered_formatter_example.rb @@ -0,0 +1,31 @@ +# This demonstrates how you can write custom formatters to handle arbitrary +# options passed to the +describe+ and +it+ methods. To see it in action, stand +# in the project root and say: +# +# bin/spec -r examples/passing/filtered_formatter.rb examples/passing/filtered_formatter_example.rb -f FilteredFormatter +# +# You should only see the examples and groups below that are not explicitly +# marked :show => false +# +# group 1 +# example 1 a +# group 3 +# example 3 + + +describe "group 1", :show => true do + it "example 1 a", :show => true do + end + it "example 1 b", :show => false do + end +end + +describe "group 2", :show => false do + it "example 2" do + end +end + +describe "group 3" do + it "example 3" do + end +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/examples/passing/greeter_spec.rb b/vendor/plugins/rspec/examples/passing/greeter_spec.rb new file mode 100644 index 000000000..7d67e3187 --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/greeter_spec.rb @@ -0,0 +1,30 @@ +# greeter.rb +# +# Based on http://glu.ttono.us/articles/2006/12/19/tormenting-your-tests-with-heckle +# +# Run with: +# +# spec greeter_spec.rb --heckle Greeter +# +class Greeter + def initialize(person = nil) + @person = person + end + + def greet + @person.nil? ? "Hi there!" : "Hi #{@person}!" + end +end + +describe "Greeter" do + it "should say Hi to person" do + greeter = Greeter.new("Kevin") + greeter.greet.should == "Hi Kevin!" + end + + it "should say Hi to nobody" do + greeter = Greeter.new + # Uncomment the next line to make Heckle happy + #greeter.greet.should == "Hi there!" + end +end diff --git a/vendor/plugins/rspec/examples/passing/helper_method_example.rb b/vendor/plugins/rspec/examples/passing/helper_method_example.rb new file mode 100644 index 000000000..eb3dca92f --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/helper_method_example.rb @@ -0,0 +1,12 @@ +module HelperMethodExample + describe "an example group with helper a method" do + def helper_method + "received call" + end + + it "should make that method available to specs" do + helper_method.should == "received call" + end + end +end + diff --git a/vendor/plugins/rspec/examples/passing/implicit_docstrings_example.rb b/vendor/plugins/rspec/examples/passing/implicit_docstrings_example.rb new file mode 100644 index 000000000..889cef425 --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/implicit_docstrings_example.rb @@ -0,0 +1,16 @@ +# Run "spec implicit_docstrings_example.rb --format specdoc" to see the output of this file + +describe "Examples with no docstrings generate their own:" do + + specify { 3.should be < 5 } + + specify { ["a"].should include("a") } + + specify { [1,2,3].should respond_to(:size) } + +end + +describe 1 do + it { should == 1 } + it { should be < 2} +end diff --git a/vendor/plugins/rspec/examples/passing/io_processor.rb b/vendor/plugins/rspec/examples/passing/io_processor.rb new file mode 100644 index 000000000..6b15147b6 --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/io_processor.rb @@ -0,0 +1,8 @@ +class DataTooShort < StandardError; end + +class IoProcessor + # Does some fancy stuff unless the length of +io+ is shorter than 32 + def process(io) + raise DataTooShort if io.read.length < 32 + end +end diff --git a/vendor/plugins/rspec/examples/passing/io_processor_spec.rb b/vendor/plugins/rspec/examples/passing/io_processor_spec.rb new file mode 100644 index 000000000..1f5020e76 --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/io_processor_spec.rb @@ -0,0 +1,20 @@ +require 'examples/passing/io_processor' +require 'stringio' + +describe "An IoProcessor" do + before(:each) do + @processor = IoProcessor.new + end + + it "should raise nothing when the file is exactly 32 bytes" do + lambda { + @processor.process(StringIO.new("z"*32)) + }.should_not raise_error + end + + it "should raise an exception when the file length is less than 32 bytes" do + lambda { + @processor.process(StringIO.new("z"*31)) + }.should raise_error(DataTooShort) + end +end diff --git a/vendor/plugins/rspec/examples/passing/mocking_example.rb b/vendor/plugins/rspec/examples/passing/mocking_example.rb new file mode 100644 index 000000000..1d342c735 --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/mocking_example.rb @@ -0,0 +1,25 @@ +describe "A consumer of a mock" do + it "should be able to send messages to the mock" do + mock = mock("poke me") + mock.should_receive(:poke) + mock.poke + end +end + +describe "a mock" do + it "should be able to mock the same message twice w/ different args" do + mock = mock("mock") + mock.should_receive(:msg).with(:arg1).and_return(:val1) + mock.should_receive(:msg).with(:arg2).and_return(:val2) + mock.msg(:arg1).should eql(:val1) + mock.msg(:arg2).should eql(:val2) + end + + it "should be able to mock the same message twice w/ different args in reverse order" do + mock = mock("mock") + mock.should_receive(:msg).with(:arg1).and_return(:val1) + mock.should_receive(:msg).with(:arg2).and_return(:val2) + mock.msg(:arg2).should eql(:val2) + mock.msg(:arg1).should eql(:val1) + end +end diff --git a/vendor/plugins/rspec/examples/passing/multi_threaded_example_group_runner.rb b/vendor/plugins/rspec/examples/passing/multi_threaded_example_group_runner.rb new file mode 100644 index 000000000..d5458ddf8 --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/multi_threaded_example_group_runner.rb @@ -0,0 +1,26 @@ +class MultiThreadedExampleGroupRunner < Spec::Runner::ExampleGroupRunner + def initialize(options, arg) + super(options) + # configure these + @thread_count = 4 + @thread_wait = 0 + end + + def run + @threads = [] + q = Queue.new + example_groups.each { |b| q << b} + success = true + @thread_count.times do + @threads << Thread.new(q) do |queue| + while not queue.empty? + example_group = queue.pop + success &= example_group.suite.run(nil) + end + end + sleep @thread_wait + end + @threads.each {|t| t.join} + success + end +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/examples/passing/nested_classes_example.rb b/vendor/plugins/rspec/examples/passing/nested_classes_example.rb new file mode 100644 index 000000000..ce5499591 --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/nested_classes_example.rb @@ -0,0 +1,35 @@ +require 'examples/passing/stack' + +class StackExamples < Spec::ExampleGroup + describe(Stack) + before(:each) do + @stack = Stack.new + end +end + +class EmptyStackExamples < StackExamples + describe("when empty") + it "should be empty" do + @stack.should be_empty + end +end + +class AlmostFullStackExamples < StackExamples + describe("when almost full") + before(:each) do + (1..9).each {|n| @stack.push n} + end + it "should be full" do + @stack.should_not be_full + end +end + +class FullStackExamples < StackExamples + describe("when full") + before(:each) do + (1..10).each {|n| @stack.push n} + end + it "should be full" do + @stack.should be_full + end +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/examples/passing/options_example.rb b/vendor/plugins/rspec/examples/passing/options_example.rb new file mode 100644 index 000000000..bed3077eb --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/options_example.rb @@ -0,0 +1,29 @@ +# This demonstrates the use of the options hash to support custom reporting. +# To see the result, run this command from the project root: +# +# bin/spec --require examples/passing/options_formatter.rb examples/passing/options_example.rb \ +# --format OptionsFormatter + +describe "this group will be reported", :report => true do + it "this example will be reported", :report => true do + # no-op + end + + it "this example will not be reported", :report => false do + # no-op + end + + it "this example will also not be reported", :foo => 'bar' do + # no-op + end + + it "this example will also also not be reported" do + # no-op + end +end + +describe "this group will not be reported", :report => false do + it "though this example will", :report => true do + # no-op + end +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/examples/passing/options_formatter.rb b/vendor/plugins/rspec/examples/passing/options_formatter.rb new file mode 100644 index 000000000..b88bebbc5 --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/options_formatter.rb @@ -0,0 +1,20 @@ +# This is an example of how you can use a custom formatter to do custom +# reporting. This formatter will only report example groups and examples that +# have :report => true (or anything truthy) in the declaration. See +# options_example.rb in this directory. + +require 'spec/runner/formatter/base_text_formatter' + +class OptionsFormatter < Spec::Runner::Formatter::BaseTextFormatter + def example_started(proxy) + if proxy.options[:report] + puts proxy.description + end + end + + def example_group_started(proxy) + if proxy.options[:report] + puts proxy.description + end + end +end diff --git a/vendor/plugins/rspec/examples/passing/partial_mock_example.rb b/vendor/plugins/rspec/examples/passing/partial_mock_example.rb new file mode 100644 index 000000000..38aafa149 --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/partial_mock_example.rb @@ -0,0 +1,27 @@ +class MockableClass + def self.find id + return :original_return + end +end + +describe "A partial mock" do + + it "should work at the class level" do + MockableClass.should_receive(:find).with(1).and_return {:stub_return} + MockableClass.find(1).should equal(:stub_return) + end + + it "should revert to the original after each spec" do + MockableClass.find(1).should equal(:original_return) + end + + it "can be mocked w/ ordering" do + MockableClass.should_receive(:msg_1).ordered + MockableClass.should_receive(:msg_2).ordered + MockableClass.should_receive(:msg_3).ordered + MockableClass.msg_1 + MockableClass.msg_2 + MockableClass.msg_3 + end + +end diff --git a/vendor/plugins/rspec/examples/passing/pending_example.rb b/vendor/plugins/rspec/examples/passing/pending_example.rb new file mode 100644 index 000000000..7ce382742 --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/pending_example.rb @@ -0,0 +1,18 @@ +describe "pending example (using pending method)" do + it %Q|should be reported as "PENDING: for some reason"| do + pending("for some reason") + end +end + +describe "pending example (with no block)" do + it %Q|should be reported as "PENDING: Not Yet Implemented"| +end + +describe "pending example (with block for pending)" do + it %Q|should have a failing block, passed to pending, reported as "PENDING: for some reason"| do + pending("for some reason") do + raise "some reason" + end + end +end + diff --git a/vendor/plugins/rspec/examples/passing/predicate_example.rb b/vendor/plugins/rspec/examples/passing/predicate_example.rb new file mode 100644 index 000000000..f10c386f3 --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/predicate_example.rb @@ -0,0 +1,25 @@ +class BddFramework + def intuitive? + true + end + + def adopted_quickly? + true + end +end + +describe "BDD framework" do + + before(:each) do + @bdd_framework = BddFramework.new + end + + it "should be adopted quickly" do + @bdd_framework.should be_adopted_quickly + end + + it "should be intuitive" do + @bdd_framework.should be_intuitive + end + +end diff --git a/vendor/plugins/rspec/examples/passing/shared_example_group_example.rb b/vendor/plugins/rspec/examples/passing/shared_example_group_example.rb new file mode 100644 index 000000000..f034a11b5 --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/shared_example_group_example.rb @@ -0,0 +1,79 @@ +module SharedExampleGroupExample + class OneThing + def what_things_do + "stuff" + end + end + + class AnotherThing + def what_things_do + "stuff" + end + end + + class YetAnotherThing + def what_things_do + "stuff" + end + end + + # A SharedExampleGroup is an example group that doesn't get run. + # You can create one like this: + share_examples_for "most things" do + def helper_method + "helper method" + end + + it "should do what things do" do + @thing.what_things_do.should == "stuff" + end + end + + # A SharedExampleGroup is also a module. If you create one like this it gets + # assigned to the constant MostThings + share_as :MostThings do + def helper_method + "helper method" + end + + it "should do what things do" do + @thing.what_things_do.should == "stuff" + end + end + + describe OneThing do + # Now you can include the shared example group like this, which + # feels more like what you might say ... + it_should_behave_like "most things" + + before(:each) { @thing = OneThing.new } + + it "should have access to helper methods defined in the shared example group" do + helper_method.should == "helper method" + end + end + + describe AnotherThing do + # ... or you can include the example group like this, which + # feels more like the programming language we love. + it_should_behave_like MostThings + + before(:each) { @thing = AnotherThing.new } + + it "should have access to helper methods defined in the shared example group" do + helper_method.should == "helper method" + end + end + + describe YetAnotherThing do + # ... or you can include the example group like this, which + # feels more like the programming language we love. + include MostThings + + before(:each) { @thing = AnotherThing.new } + + it "should have access to helper methods defined in the shared example group" do + helper_method.should == "helper method" + end + end +end diff --git a/vendor/plugins/rspec/examples/passing/shared_stack_examples.rb b/vendor/plugins/rspec/examples/passing/shared_stack_examples.rb new file mode 100644 index 000000000..e14fd146d --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/shared_stack_examples.rb @@ -0,0 +1,36 @@ +shared_examples_for "non-empty Stack" do + + it { @stack.should_not be_empty } + + it "should return the top item when sent #peek" do + @stack.peek.should == @last_item_added + end + + it "should NOT remove the top item when sent #peek" do + @stack.peek.should == @last_item_added + @stack.peek.should == @last_item_added + end + + it "should return the top item when sent #pop" do + @stack.pop.should == @last_item_added + end + + it "should remove the top item when sent #pop" do + @stack.pop.should == @last_item_added + unless @stack.empty? + @stack.pop.should_not == @last_item_added + end + end + +end + +shared_examples_for "non-full Stack" do + + it { @stack.should_not be_full } + + it "should add to the top when sent #push" do + @stack.push "newly added top item" + @stack.peek.should == "newly added top item" + end + +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/examples/passing/simple_matcher_example.rb b/vendor/plugins/rspec/examples/passing/simple_matcher_example.rb new file mode 100644 index 000000000..5a0fc0fa5 --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/simple_matcher_example.rb @@ -0,0 +1,29 @@ +describe "arrays" do + def contain_same_elements_as(expected) + simple_matcher "array with same elements in any order as #{expected.inspect}" do |actual| + if actual.size == expected.size + a, e = actual.dup, expected.dup + until e.empty? do + if i = a.index(e.pop) then a.delete_at(i) end + end + a.empty? + else + false + end + end + end + + describe "can be matched by their contents disregarding order" do + subject { [1,2,2,3] } + it { should contain_same_elements_as([1,2,2,3]) } + it { should contain_same_elements_as([2,3,2,1]) } + it { should_not contain_same_elements_as([3,3,2,1]) } + end + + describe "fail the match with different contents" do + subject { [1,2,3] } + it { should_not contain_same_elements_as([2,3,4])} + it { should_not contain_same_elements_as([1,2,2,3])} + it { should_not contain_same_elements_as([1,2])} + end +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/examples/passing/stack.rb b/vendor/plugins/rspec/examples/passing/stack.rb new file mode 100644 index 000000000..407173f7b --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/stack.rb @@ -0,0 +1,36 @@ +class StackUnderflowError < RuntimeError +end + +class StackOverflowError < RuntimeError +end + +class Stack + + def initialize + @items = [] + end + + def push object + raise StackOverflowError if @items.length == 10 + @items.push object + end + + def pop + raise StackUnderflowError if @items.empty? + @items.delete @items.last + end + + def peek + raise StackUnderflowError if @items.empty? + @items.last + end + + def empty? + @items.empty? + end + + def full? + @items.length == 10 + end + +end diff --git a/vendor/plugins/rspec/examples/passing/stack_spec.rb b/vendor/plugins/rspec/examples/passing/stack_spec.rb new file mode 100644 index 000000000..6d0d06366 --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/stack_spec.rb @@ -0,0 +1,63 @@ +require 'examples/passing/stack' +require 'examples/passing/shared_stack_examples' + +describe Stack, " (empty)" do + before(:each) do + @stack = Stack.new + end + + # This uses @stack (because the described class is Stack) auto-generates the + # description "should be empty" + it { should be_empty } + + it_should_behave_like "non-full Stack" + + it "should complain when sent #peek" do + lambda { @stack.peek }.should raise_error(StackUnderflowError) + end + + it "should complain when sent #pop" do + lambda { @stack.pop }.should raise_error(StackUnderflowError) + end +end + +describe Stack, " (with one item)" do + before(:each) do + @stack = Stack.new + @stack.push 3 + @last_item_added = 3 + end + + it_should_behave_like "non-empty Stack" + it_should_behave_like "non-full Stack" + +end + +describe Stack, " (with one item less than capacity)" do + before(:each) do + @stack = Stack.new + (1..9).each { |i| @stack.push i } + @last_item_added = 9 + end + + it_should_behave_like "non-empty Stack" + it_should_behave_like "non-full Stack" +end + +describe Stack, " (full)" do + before(:each) do + @stack = Stack.new + (1..10).each { |i| @stack.push i } + @last_item_added = 10 + end + + # NOTE that this one auto-generates the description "should be full" + it { @stack.should be_full } + + it_should_behave_like "non-empty Stack" + + it "should complain on #push" do + lambda { @stack.push Object.new }.should raise_error(StackOverflowError) + end + +end diff --git a/vendor/plugins/rspec/examples/passing/stack_spec_with_nested_example_groups.rb b/vendor/plugins/rspec/examples/passing/stack_spec_with_nested_example_groups.rb new file mode 100644 index 000000000..6e36df789 --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/stack_spec_with_nested_example_groups.rb @@ -0,0 +1,66 @@ +require 'examples/passing/stack' +require 'examples/passing/shared_stack_examples' + +describe Stack do + + before(:each) do + @stack = Stack.new + end + + describe "(empty)" do + + it { @stack.should be_empty } + + it_should_behave_like "non-full Stack" + + it "should complain when sent #peek" do + lambda { @stack.peek }.should raise_error(StackUnderflowError) + end + + it "should complain when sent #pop" do + lambda { @stack.pop }.should raise_error(StackUnderflowError) + end + + end + + describe "(with one item)" do + + before(:each) do + @stack.push 3 + @last_item_added = 3 + end + + it_should_behave_like "non-empty Stack" + it_should_behave_like "non-full Stack" + + end + + describe "(with one item less than capacity)" do + + before(:each) do + (1..9).each { |i| @stack.push i } + @last_item_added = 9 + end + + it_should_behave_like "non-empty Stack" + it_should_behave_like "non-full Stack" + end + + describe "(full)" do + + before(:each) do + (1..10).each { |i| @stack.push i } + @last_item_added = 10 + end + + it { @stack.should be_full } + + it_should_behave_like "non-empty Stack" + + it "should complain on #push" do + lambda { @stack.push Object.new }.should raise_error(StackOverflowError) + end + + end + +end diff --git a/vendor/plugins/rspec/examples/passing/stubbing_example.rb b/vendor/plugins/rspec/examples/passing/stubbing_example.rb new file mode 100644 index 000000000..dab8982ee --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/stubbing_example.rb @@ -0,0 +1,67 @@ +describe "A consumer of a stub" do + it "should be able to stub methods on any Object" do + obj = Object.new + obj.stub!(:foobar).and_return {:return_value} + obj.foobar.should equal(:return_value) + end +end + +class StubbableClass + def self.find id + return :original_return + end +end + +describe "A stubbed method on a class" do + it "should return the stubbed value" do + StubbableClass.stub!(:find).and_return(:stub_return) + StubbableClass.find(1).should equal(:stub_return) + end + + it "should revert to the original method after each spec" do + StubbableClass.find(1).should equal(:original_return) + end + + it "can stub! and mock the same message" do + StubbableClass.stub!(:msg).and_return(:stub_value) + StubbableClass.should_receive(:msg).with(:arg).and_return(:mock_value) + + StubbableClass.msg.should equal(:stub_value) + StubbableClass.msg(:other_arg).should equal(:stub_value) + StubbableClass.msg(:arg).should equal(:mock_value) + StubbableClass.msg(:another_arg).should equal(:stub_value) + StubbableClass.msg(:yet_another_arg).should equal(:stub_value) + StubbableClass.msg.should equal(:stub_value) + end +end + +describe "A mock" do + it "can stub!" do + mock = mock("stubbing mock") + mock.stub!(:msg).and_return(:value) + (1..10).each {mock.msg.should equal(:value)} + end + + it "can stub! and mock" do + mock = mock("stubbing mock") + mock.stub!(:stub_message).and_return(:stub_value) + mock.should_receive(:mock_message).once.and_return(:mock_value) + (1..10).each {mock.stub_message.should equal(:stub_value)} + mock.mock_message.should equal(:mock_value) + (1..10).each {mock.stub_message.should equal(:stub_value)} + end + + it "can stub! and mock the same message" do + mock = mock("stubbing mock") + mock.stub!(:msg).and_return(:stub_value) + mock.should_receive(:msg).with(:arg).and_return(:mock_value) + mock.msg.should equal(:stub_value) + mock.msg(:other_arg).should equal(:stub_value) + mock.msg(:arg).should equal(:mock_value) + mock.msg(:another_arg).should equal(:stub_value) + mock.msg(:yet_another_arg).should equal(:stub_value) + mock.msg.should equal(:stub_value) + end +end + + diff --git a/vendor/plugins/rspec/examples/passing/yielding_example.rb b/vendor/plugins/rspec/examples/passing/yielding_example.rb new file mode 100644 index 000000000..e7b43fffa --- /dev/null +++ b/vendor/plugins/rspec/examples/passing/yielding_example.rb @@ -0,0 +1,31 @@ +class MessageAppender + + def initialize(appendage) + @appendage = appendage + end + + def append_to(message) + if_told_to_yield do + message << @appendage + end + end + +end + +describe "a message expectation yielding to a block" do + it "should yield if told to" do + appender = MessageAppender.new("appended to") + appender.should_receive(:if_told_to_yield).and_yield + message = "" + appender.append_to(message) + message.should == "appended to" + end + + it "should not yield if not told to" do + appender = MessageAppender.new("appended to") + appender.should_receive(:if_told_to_yield) + message = "" + appender.append_to(message) + message.should == "" + end +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/examples/ruby1.9.compatibility/access_to_constants_spec.rb b/vendor/plugins/rspec/examples/ruby1.9.compatibility/access_to_constants_spec.rb new file mode 100644 index 000000000..b34b8ba6d --- /dev/null +++ b/vendor/plugins/rspec/examples/ruby1.9.compatibility/access_to_constants_spec.rb @@ -0,0 +1,85 @@ +# courtesy of Matthias Hennemeyer +# +# The following should pass against ruby 1.8 and 1.9. It currently only passes +# 1.8 (as of 1/2/2009) +# +# Once cucumber supports ruby 1.9, this should be moved to cucumber scenarios instead. +module Foo + module Bar + + module ModuleInEnclosingModule;end + class ClassInEnclosingModule;end + def method_in_enclosing_module;end + CONSTANT_IN_ENCLOSING_MODULE = 0 + + describe "Examples trying to access constants defined in an enclosing module" do + + it "can access Modules" do + ModuleInEnclosingModule + end + it "can access Classes" do + ClassInEnclosingModule.new + end + it "can access CONSTANTS" do + CONSTANT_IN_ENCLOSING_MODULE + end + it "can NOT access methods" do + lambda {method_in_enclosing_module}.should raise_error(/undefined/) + end + + describe "from a nested example group" do + + it "can access Modules" do + ModuleInEnclosingModule + end + it "can access Classes" do + ClassInEnclosingModule.new + end + it "can access CONSTANTS" do + CONSTANT_IN_ENCLOSING_MODULE + end + it "can NOT access methods" do + lambda {method_in_enclosing_module}.should raise_error(/undefined/) + end + + end + + end + + describe "Examples trying to access constants defined in the example group" do + + module ModuleDefinedInGroup;end + class ClassDefinedInGroup; end + def method_defined_in_group; end + CONSTANT_DEFINED_IN_GROUP = 0 + + it "can access Modules" do + ModuleDefinedInGroup + end + it "can access Classes" do + ClassDefinedInGroup.new + end + it "can access CONSTANTS" do + CONSTANT_DEFINED_IN_GROUP + end + it "can access methods" do + method_defined_in_group + end + + describe "that live inside a nested group" do + it "can access Modules" do + ModuleDefinedInGroup + end + it "can access Classes" do + ClassDefinedInGroup.new + end + it "can access CONSTANTS" do + CONSTANT_DEFINED_IN_GROUP + end + it "can access methods" do + method_defined_in_group + end + end + end + end +end diff --git a/vendor/plugins/rspec/features-pending/cli/conditional_exclusion.feature b/vendor/plugins/rspec/features-pending/cli/conditional_exclusion.feature new file mode 100644 index 000000000..6cf36f7d6 --- /dev/null +++ b/vendor/plugins/rspec/features-pending/cli/conditional_exclusion.feature @@ -0,0 +1,39 @@ +Feature: conditional exclusion of example groups + + Example groups can be excluded from a run by matching the value of the + --exclude argument against options passed to an example group. The value + can be a key or a key:value pair (separated by a ":"). + + Scenario: exclusion using explicit value + Given the following spec: + """ + describe "This should run" do + it { 5.should == 5 } + end + + describe "This should not run", :slow => true do + it { 1_000_000.times { 5.should == 5 } } + end + """ + When I run it with the spec command --format specdoc --exclude slow:true + Then the exit code should be 0 + And the stdout should match "1 example, 0 failures" + And the stdout should match /This should run$/m + But the stdout should not match "This should not run" + + Scenario: exclusion using default value (true) + Given the following spec: + """ + describe "This should run" do + it { 5.should == 5 } + end + + describe "This should not run", :slow => true do + it { 1_000_000.times { 5.should == 5 } } + end + """ + When I run it with the spec command --format specdoc --exclude slow + Then the exit code should be 0 + And the stdout should match "1 example, 0 failures" + And the stdout should match /This should run$/m + But the stdout should not match "This should not run" diff --git a/vendor/plugins/rspec/features-pending/heckle/heckle.feature b/vendor/plugins/rspec/features-pending/heckle/heckle.feature new file mode 100644 index 000000000..11794e777 --- /dev/null +++ b/vendor/plugins/rspec/features-pending/heckle/heckle.feature @@ -0,0 +1,56 @@ +Feature: heckle a class + + As an RSpec user who wants to verify that + my specs cover what I think it covers + I want to heckle a class + + Scenario: Heckle finds problems + Given a file named "heckle_fail_spec.rb" with: + """ + class Thing + def a_or_b + if true + "a" + else + "b" + end + end + end + + describe Thing do + it "returns a for true" do + Thing.new.a_or_b.should == "a" + end + end + """ + When I run "spec heckle_fail_spec.rb --heckle Thing" + Then the stdout should match "The following mutations didn't cause test failures:" + But the stdout should not match "FAILED" + + Scenario: Heckle does not find a problem + Given a file named "heckle_success_spec.rb" with: + """ + class Thing + def a_or_b(key) + if key + "a" + else + "b" + end + end + end + + describe Thing do + it "returns a for true" do + Thing.new.a_or_b(true).should == "a" + end + + it "returns b for false" do + Thing.new.a_or_b(false).should == "b" + end + end + """ + When I run "spec heckle_success_spec.rb --heckle Thing" + Then the stdout should match "No mutants survived" + But the stdout should not match "FAILED" + diff --git a/vendor/plugins/rspec/features/before_and_after_blocks/before_and_after_blocks.feature b/vendor/plugins/rspec/features/before_and_after_blocks/before_and_after_blocks.feature new file mode 100644 index 000000000..c1446bbb5 --- /dev/null +++ b/vendor/plugins/rspec/features/before_and_after_blocks/before_and_after_blocks.feature @@ -0,0 +1,167 @@ +Feature: before and after blocks + + As a developer using RSpec + I want to execute arbitrary code before and after each example + So that I can control the environment in which it is run + + This is supported by the before and after methods which each take a symbol + indicating the scope, and a block of code to execute. + + before(:each) blocks are run before each example + before(:all) blocks are run once before all of the examples in a group + before(:suite) blocks are run once before the entire suite + + after(:each) blocks are run after each example + after(:all) blocks are run once after all of the examples in a group + after(:suite) blocks are run once after the entire suite + + Before and after blocks are called in the following order: + before suite + before all + before each + after each + after all + after suite + + Before and after blocks can be defined in the example groups to which they + apply or in a configuration. When defined in a configuration, they can be + applied to all groups or subsets of all groups defined by example group + types. + + Scenario: define before(:each) block in example group + Given a file named "before_each_in_example_group_spec.rb" with: + """ + class Thing + def widgets + @widgets ||= [] + end + end + + describe Thing do + before(:each) do + @thing = Thing.new + end + + context "initialized in before(:each)" do + it "has 0 widgets" do + @thing.should have(0).widgets + end + + it "can get accept new widgets" do + @thing.widgets << Object.new + end + + it "does not share state across examples" do + @thing.should have(0).widgets + end + end + end + """ + When I run "spec before_each_in_example_group_spec.rb" + Then the stdout should include "3 examples, 0 failures" + + Scenario: define before(:all) block in example group + Given a file named "before_all_in_example_group_spec.rb" with: + """ + class Thing + def widgets + @widgets ||= [] + end + end + + describe Thing do + before(:all) do + @thing = Thing.new + end + + context "initialized in before(:all)" do + it "has 0 widgets" do + @thing.should have(0).widgets + end + + it "can get accept new widgets" do + @thing.widgets << Object.new + end + + it "shares state across examples" do + @thing.should have(1).widgets + end + end + end + """ + When I run "spec before_all_in_example_group_spec.rb" + Then the stdout should include "3 examples, 0 failures" + + Scenario: define before and after blocks in configuration + Given a file named "befores_in_configuration_spec.rb" with: + """ + Spec::Runner.configure do |config| + config.before(:suite) do + $before_suite = "before suite" + end + config.before(:each) do + @before_each = "before each" + end + config.before(:all) do + @before_all = "before all" + end + end + + describe "stuff in before blocks" do + describe "with :suite" do + it "should be available in the example" do + $before_suite.should == "before suite" + end + end + describe "with :all" do + it "should be available in the example" do + @before_all.should == "before all" + end + end + describe "with :each" do + it "should be available in the example" do + @before_each.should == "before each" + end + end + end + """ + When I run "spec befores_in_configuration_spec.rb" + Then the stdout should include "3 examples, 0 failures" + + Scenario: before/after blocks are run in order + Given a file named "ensure_block_order_spec.rb" with: + """ + Spec::Runner.configure do |config| + config.before(:suite) do + puts "before suite" + end + config.after(:suite) do + puts "after suite" + end + end + + describe "before and after callbacks" do + before(:all) do + puts "before all" + end + + before(:each) do + puts "before each" + end + + after(:each) do + puts "after each" + end + + after(:all) do + puts "after all" + end + + it "gets run in order" do + + end + end + """ + When I run "spec ensure_block_order_spec.rb" + Then the stdout should include /before suite\nbefore all\nbefore each\nafter each\n\.after all\n.*after suite/m + diff --git a/vendor/plugins/rspec/features/command_line/line_number_option.feature b/vendor/plugins/rspec/features/command_line/line_number_option.feature new file mode 100644 index 000000000..7fc6fc50d --- /dev/null +++ b/vendor/plugins/rspec/features/command_line/line_number_option.feature @@ -0,0 +1,56 @@ +Feature: Spec and test together + + As an RSpec user + I want to run one example identified by the line number + + Background: + Given a file named "example.rb" with: + """ + describe "a group" do + + it "has a first example" do + + end + + it "has a second example" do + + end + + end + """ + + Scenario: two examples - first example on declaration line + When I run "spec example.rb:3 --format nested" + Then the stdout should include "1 example, 0 failures" + And the stdout should include "has a first example" + But the stdout should not match "has a second example" + + Scenario: two examples - first example from line inside declaration + When I run "spec example.rb:4 --format nested" + Then the stdout should include "1 example, 0 failures" + And the stdout should include "has a first example" + But the stdout should not match "has a second example" + + Scenario: two examples - first example from line below declaration + When I run "spec example.rb:6 --format nested" + Then the stdout should include "1 example, 0 failures" + And the stdout should include "has a first example" + But the stdout should not match "has a second example" + + Scenario: two examples - second example from line below declaration + When I run "spec example.rb:7 --format nested" + Then the stdout should include "1 example, 0 failures" + And the stdout should include "has a second example" + But the stdout should not match "has a first example" + + Scenario: two examples - both examples from the group declaration + When I run "spec example.rb:1 --format nested" + Then the stdout should include "2 examples, 0 failures" + And the stdout should include "has a second example" + And the stdout should include "has a first example" + + Scenario: two examples - both examples from above the first example declaration + When I run "spec example.rb:2 --format nested" + Then the stdout should include "2 examples, 0 failures" + And the stdout should include "has a second example" + And the stdout should include "has a first example" diff --git a/vendor/plugins/rspec/features/command_line/line_number_option_with_example_with_no_name.feature b/vendor/plugins/rspec/features/command_line/line_number_option_with_example_with_no_name.feature new file mode 100644 index 000000000..244db51fb --- /dev/null +++ b/vendor/plugins/rspec/features/command_line/line_number_option_with_example_with_no_name.feature @@ -0,0 +1,22 @@ +Feature: Spec and test together + + As an RSpec user + I want to run one example identified by the line number + + Background: + Given a file named "example.rb" with: + """ + describe 9 do + + it { should be > 8 } + + it { should be < 10 } + + end + """ + + Scenario: two examples - first example on declaration line + When I run "spec example.rb:3 --format nested" + Then the stdout should include "1 example, 0 failures" + Then the stdout should include "should be > 8" + But the stdout should not match "should be < 10" diff --git a/vendor/plugins/rspec/features/example_groups/define_example_attribute.feature b/vendor/plugins/rspec/features/example_groups/define_example_attribute.feature new file mode 100644 index 000000000..9fc72ac64 --- /dev/null +++ b/vendor/plugins/rspec/features/example_groups/define_example_attribute.feature @@ -0,0 +1,41 @@ +Feature: Define example attribute + + In order to streamline process + As an RSpec user + I want to easily define helper methods that act as a variable assignment + + It is fairly common to start with a local variable in one example, use the same + local variable in the next, and then extract the declaration of that variable + to before(:each). This requires converting the locals to instance variables. + + This feature streamlines the process by defining a helper method so you can extract + the duplication without having to change other references to the same variables + to @instance_variables. + + Scenario: + Given a file named "counter_spec.rb" with: + """ + require 'spec/autorun' + + class Counter + def initialize + @count = 0 + end + def count + @count += 1 + end + end + + describe Counter do + let(:counter) { Counter.new } + it "returns 1 the first time" do + counter.count.should == 1 + end + it "returns 2 the second time because the counter itself is cached by the 'assign' method" do + counter.count + counter.count.should == 2 + end + end + """ + When I run "spec counter_spec.rb" + Then the stdout should include "2 examples, 0 failures" diff --git a/vendor/plugins/rspec/features/example_groups/example_group_with_should_methods.feature b/vendor/plugins/rspec/features/example_groups/example_group_with_should_methods.feature new file mode 100644 index 000000000..b5f76bf8a --- /dev/null +++ b/vendor/plugins/rspec/features/example_groups/example_group_with_should_methods.feature @@ -0,0 +1,29 @@ +Feature: Spec::ExampleGroup with should methods + + As an RSpec adopter accustomed to classes and methods + I want to use should_* methods in an ExampleGroup + So that I use RSpec with classes and methods that look more like RSpec examples + + Scenario Outline: Example Group class with should methods + Given a file named "example_group_with_should_methods.rb" with: + """ + require 'spec/autorun' + + class MySpec < Spec::ExampleGroup + def should_pass_with_should + 1.should == 1 + end + + def should_fail_with_should + 1.should == 2 + end + end + """ + When I run "<Command> example_group_with_should_methods.rb" + Then the exit code should be 256 + And the stdout should include "2 examples, 1 failure" + + Scenarios: Run with ruby and spec + | Command | + | ruby | + | spec | diff --git a/vendor/plugins/rspec/features/example_groups/implicit_docstrings.feature b/vendor/plugins/rspec/features/example_groups/implicit_docstrings.feature new file mode 100644 index 000000000..b83a3470c --- /dev/null +++ b/vendor/plugins/rspec/features/example_groups/implicit_docstrings.feature @@ -0,0 +1,59 @@ +Feature: implicit docstrings + + As an RSpec user + I want examples to generate their own names + So that I can reduce duplication between example names and example code + + Scenario Outline: run passing examples + Given a file named "implicit_docstrings_example.rb" with: + """ + require 'spec/autorun' + describe "Examples with no docstrings generate their own:" do + + specify { 3.should be < 5 } + + specify { ["a"].should include("a") } + + specify { [1,2,3].should respond_to(:size) } + + end + """ + + When I run "<Command> implicit_docstrings_example.rb -fs" + + Then the stdout should include /should be < 5/ + And the stdout should include /should include "a"/ + And the stdout should include /should respond to #size/ + + Scenarios: Run with ruby and spec + | Command | + | ruby | + | spec | + + Scenario Outline: run failing examples + Given a file named "failing_implicit_docstrings_example.rb" with: + """ + require 'spec/autorun' + describe "Failing examples with no descriptions" do + + # description is auto-generated as "should equal(5)" based on the last #should + it do + 3.should equal(2) + 5.should equal(5) + end + + it { 3.should be > 5 } + + it { ["a"].should include("b") } + + it { [1,2,3].should_not respond_to(:size) } + + end + """ + + When I run "<Command> failing_implicit_docstrings_example.rb -fs" + + Then the stdout should include /should equal 2/ + And the stdout should include /should be > 5/ + And the stdout should include /should include "b"/ + And the stdout should include /should not respond to #size/ diff --git a/vendor/plugins/rspec/features/example_groups/nested_groups.feature b/vendor/plugins/rspec/features/example_groups/nested_groups.feature new file mode 100644 index 000000000..6d8c7aadf --- /dev/null +++ b/vendor/plugins/rspec/features/example_groups/nested_groups.feature @@ -0,0 +1,32 @@ +Feature: Nested example groups + + As an RSpec user + I want to nest examples groups + So that I can better organize my examples + + Scenario Outline: Nested example groups + Given a file named "nested_example_groups.rb" with: + """ + require 'spec/autorun' + + describe "Some Object" do + describe "with some more context" do + it "should do this" do + true.should be_true + end + end + describe "with some other context" do + it "should do that" do + false.should be_false + end + end + end + """ + When I run "<Command> nested_example_groups.rb -fs" + Then the stdout should include /Some Object with some more context/ + And the stdout should include /Some Object with some other context/ + + Scenarios: Run with ruby and spec + | Command | + | ruby | + | spec | diff --git a/vendor/plugins/rspec/features/expectations/customized_message.feature b/vendor/plugins/rspec/features/expectations/customized_message.feature new file mode 100644 index 000000000..c19490c7a --- /dev/null +++ b/vendor/plugins/rspec/features/expectations/customized_message.feature @@ -0,0 +1,54 @@ +Feature: customized message + + In order to get the feedback I want + As an RSpec user + I want to customize the failure message per example + + Scenario: one additional method + Given a file named "node_spec.rb.rb" with: + """ + class Node + def initialize(state=:waiting) + @state = state + end + def state + @state + end + def waiting? + @state == :waiting + end + def started? + @state == :started + end + def start + @state = :started + end + end + + describe "a new Node" do + it "should be waiting" do + node = Node.new(:started) #start w/ started to trigger failure + node.should be_waiting, "node.state: #{node.state} (first example)" + end + + it "should not be started" do + node = Node.new(:started) #start w/ started to trigger failure + node.should_not be_started, "node.state: #{node.state} (second example)" + end + end + + describe "node.start" do + it "should change the state" do + node = Node.new(:started) #start w/ started to trigger failure + lambda {node.start}.should change{node.state}, "expected a change" + end + end + + """ + When I run "spec node_spec.rb.rb --format specdoc" + Then the stdout should include "3 examples, 3 failures" + And the stdout should not match "to return true, got false" + And the stdout should not match "to return false, got true" + And the stdout should include "node.state: started (first example)" + And the stdout should include "node.state: started (second example)" + And the stdout should include "expected a change" diff --git a/vendor/plugins/rspec/features/expectations/expect_change.feature b/vendor/plugins/rspec/features/expectations/expect_change.feature new file mode 100644 index 000000000..f644b52e7 --- /dev/null +++ b/vendor/plugins/rspec/features/expectations/expect_change.feature @@ -0,0 +1,65 @@ +Feature: expect change + + Expect some code (wrapped in a proc) to change the state of some object. + + Scenario: expecting change + Given a file named "expect_change.rb" with: + """ + class Counter + class << self + def increment + @count ||= 0 + @count += 1 + end + + def count + @count ||= 0 + end + end + end + + describe Counter, "#increment" do + it "should increment the count" do + expect{Counter.increment}.to change{Counter.count}.from(0).to(1) + end + + # deliberate failure + it "should increment the count by 2" do + expect{Counter.increment}.to change{Counter.count}.by(2) + end + end + """ + When I run "spec expect_change.rb" + Then the stdout should include "2 examples, 1 failure" + Then the stdout should include "should have been changed by 2, but was changed by 1" + + Scenario: expecting no change + Given a file named "expect_no_change.rb" with: + """ + class Counter + class << self + def increment + @count ||= 0 + @count += 1 + end + + def count + @count ||= 0 + end + end + end + + describe Counter, "#increment" do + it "should not increment the count by 2" do + expect{Counter.increment}.to_not change{Counter.count}.from(0).to(2) + end + + # deliberate failure + it "should not increment the count by 1" do + expect{Counter.increment}.to_not change{Counter.count}.by(1) + end + end + """ + When I run "spec expect_no_change.rb" + Then the stdout should include "2 examples, 1 failure" + Then the stdout should include "should not have changed, but did change from 1 to 2" diff --git a/vendor/plugins/rspec/features/expectations/expect_error.feature b/vendor/plugins/rspec/features/expectations/expect_error.feature new file mode 100644 index 000000000..7c48e7cef --- /dev/null +++ b/vendor/plugins/rspec/features/expectations/expect_error.feature @@ -0,0 +1,44 @@ +Feature: expect error + + Expect a proc to change the state of some object. + + Scenario: expect error + Given a file named "expect_error.rb" with: + """ + describe Object, "#non_existent_message" do + it "should raise" do + expect{Object.non_existent_message}.to raise_error(NameError) + end + end + + #deliberate failure + describe Object, "#public_instance_methods" do + it "should raise" do + expect{Object.public_instance_methods}.to raise_error(NameError) + end + end + """ + When I run "spec expect_error.rb" + Then the stdout should include "2 examples, 1 failure" + Then the stdout should include "expected NameError but nothing was raised" + + Scenario: expect no error + Given a file named "expect_no_error.rb" with: + """ + describe Object, "#public_instance_methods" do + it "should not raise" do + expect{Object.public_instance_methods}.to_not raise_error(NameError) + end + end + + #deliberate failure + describe Object, "#non_existent_message" do + it "should not raise" do + expect{Object.non_existent_message}.to_not raise_error(NameError) + end + end + """ + When I run "spec expect_no_error.rb" + Then the stdout should include "2 examples, 1 failure" + Then the stdout should include "undefined method `non_existent_message'" + diff --git a/vendor/plugins/rspec/features/extensions/custom_example_group.feature b/vendor/plugins/rspec/features/extensions/custom_example_group.feature new file mode 100644 index 000000000..70974dba7 --- /dev/null +++ b/vendor/plugins/rspec/features/extensions/custom_example_group.feature @@ -0,0 +1,19 @@ +Feature: custom example group + + Scenario: simple custom example group + Given a file named "custom_example_group_spec.rb" with: + """ + class CustomGroup < Spec::ExampleGroup + end + + Spec::Example::ExampleGroupFactory.default(CustomGroup) + + describe "a custom group set as the default" do + it "becomes the default base class for example groups" do + CustomGroup.should === self + end + end + """ + When I run "spec custom_example_group_spec.rb" + Then the stdout should include "1 example, 0 failures" + diff --git a/vendor/plugins/rspec/features/formatters/custom_formatter.feature b/vendor/plugins/rspec/features/formatters/custom_formatter.feature new file mode 100644 index 000000000..191ac369b --- /dev/null +++ b/vendor/plugins/rspec/features/formatters/custom_formatter.feature @@ -0,0 +1,30 @@ +Feature: custom formatters + + In order to format output/reporting to my particular needs + As an RSpec user + I want to create my own custom output formatters + + Scenario: specdoc format + Given a file named "custom_formatter.rb" with: + """ + require 'spec/runner/formatter/base_formatter' + class CustomFormatter < Spec::Runner::Formatter::BaseFormatter + def initialize(options, output) + @output = output + end + def example_started(proxy) + @output << "example: " << proxy.description + end + end + """ + And a file named "simple_example_spec.rb" with: + """ + describe "my group" do + specify "my example" do + end + end + """ + + When I run "spec simple_example_spec.rb --require custom_formatter.rb --format CustomFormatter" + Then the exit code should be 0 + And the stdout should include "example: my example" diff --git a/vendor/plugins/rspec/features/interop/examples_and_tests_together.feature b/vendor/plugins/rspec/features/interop/examples_and_tests_together.feature new file mode 100644 index 000000000..dda11af2f --- /dev/null +++ b/vendor/plugins/rspec/features/interop/examples_and_tests_together.feature @@ -0,0 +1,84 @@ +Feature: Spec and test together + + As an RSpec adopter with existing Test::Unit tests + I want to run a few specs alongside my existing Test::Unit tests + So that I can experience a smooth, gradual migration path + + Scenario Outline: Run specs and tests together + Given a file named "spec_and_test_together.rb" with: + """ + require 'spec/autorun' + require 'spec/test/unit' + + describe "An Example" do + it "should pass with assert" do + assert true + end + + it "should fail with assert" do + assert false + end + + it "should pass with should" do + 1.should == 1 + end + + it "should fail with should" do + 1.should == 2 + end + end + + class ATest < Test::Unit::TestCase + def test_should_pass_with_assert + assert true + end + + def test_should_fail_with_assert + assert false + end + + def test_should_pass_with_should + 1.should == 1 + end + + def test_should_fail_with_should + 1.should == 2 + end + + def setup + @from_setup ||= 3 + @from_setup += 1 + end + + def test_should_fail_with_setup_method_variable + @from_setup.should == 40 + end + + before do + @from_before = @from_setup + 1 + end + + def test_should_fail_with_before_block_variable + @from_before.should == 50 + end + + define_method :"test: should run with strange name" do + assert true + end + end + """ + + When I run "<Command> spec_and_test_together.rb -fs" + + Then the exit code should be 256 + And the stdout should include "ATest" + And the stdout should include "Test::Unit::AssertionFailedError in 'An Example should fail with assert'" + And the stdout should include "'An Example should fail with should' FAILED" + And the stdout should include "11 examples, 6 failures" + And the stdout should include /expected: 40,\s*got: 4/m + And the stdout should include /expected: 50,\s*got: 5/m + + Scenarios: run with ruby and spec + | Command | + | ruby | + | spec | diff --git a/vendor/plugins/rspec/features/interop/rspec_output.feature b/vendor/plugins/rspec/features/interop/rspec_output.feature new file mode 100644 index 000000000..3a34d21f7 --- /dev/null +++ b/vendor/plugins/rspec/features/interop/rspec_output.feature @@ -0,0 +1,25 @@ +Feature: spec output + + When running in interop mode with test/unit, RSpec will output + the RSpec summary, but not the test/unit summary. + + Scenario Outline: Interop mode with test/unit + Given a file named "simple_spec.rb" with: + """ + require 'spec/autorun' + + describe "Running an Example" do + it "should not output twice" do + true.should be_true + end + end + """ + When I run "<Command> simple_spec.rb" + Then the exit code should be 0 + And the stdout should not match /\d+ tests, \d+ assertions, \d+ failures, \d+ errors/m + And the stdout should include "1 example, 0 failures" + + Scenarios: Run with ruby and CommandLine object + | Command | + | ruby | + | cmdline.rb | diff --git a/vendor/plugins/rspec/features/interop/test_but_not_test_unit.feature b/vendor/plugins/rspec/features/interop/test_but_not_test_unit.feature new file mode 100644 index 000000000..a14b9c5d2 --- /dev/null +++ b/vendor/plugins/rspec/features/interop/test_but_not_test_unit.feature @@ -0,0 +1,26 @@ +Story: Test is defined, but not Test::Unit + + As an RSpec user who has my own library named Test (but not Test::Unit) + I want to run examples without getting Test::Unit NameErrors + + Scenario Outline: Spec including Test const but not Test::Unit + Given a file named "spec_including_test_but_not_unit.rb" with: + """ + require 'spec/autorun' + + module Test + end + + describe "description" do + it "should description" do + 1.should == 1 + end + end + """ + When I run "<Command> spec_including_test_but_not_unit.rb" + Then the stderr should not match "Test::Unit" + + Scenarios: Run with ruby and spec + | Command | + | ruby | + | spec | diff --git a/vendor/plugins/rspec/features/interop/test_case_with_should_methods.feature b/vendor/plugins/rspec/features/interop/test_case_with_should_methods.feature new file mode 100644 index 000000000..07091a05b --- /dev/null +++ b/vendor/plugins/rspec/features/interop/test_case_with_should_methods.feature @@ -0,0 +1,46 @@ +Story: Test::Unit::TestCase extended by rspec with should methods + + As an RSpec adopter with existing Test::Unit tests + I want to use should_* methods in a Test::Unit::TestCase + So that I use RSpec with classes and methods that look more like RSpec examples + + Scenario Outline: TestCase with should methods + Given a file named "test_case_with_should_methods.rb" with: + """ + require 'spec/autorun' + require 'spec/test/unit' + + class MyTest < Test::Unit::TestCase + def should_pass_with_should + 1.should == 1 + end + + def should_fail_with_should + 1.should == 2 + end + + def should_pass_with_assert + assert true + end + + def should_fail_with_assert + assert false + end + + def test + raise "This is not a real test" + end + + def test_ify + raise "This is a real test" + end + end + """ + When I run "<Command> test_case_with_should_methods.rb" + Then the exit code should be 256 + And the stdout should include "5 examples, 3 failures" + + Scenarios: Run with ruby and spec + | Command | + | ruby | + | spec | diff --git a/vendor/plugins/rspec/features/load_paths/add_lib_to_load_path.feature b/vendor/plugins/rspec/features/load_paths/add_lib_to_load_path.feature new file mode 100644 index 000000000..81513ec75 --- /dev/null +++ b/vendor/plugins/rspec/features/load_paths/add_lib_to_load_path.feature @@ -0,0 +1,20 @@ +Feature: add ./lib to load path + In order to ... + As a spec author + I want rspec to add ./lib to the load path + + Scenario: spec helper + Given a directory named "spec" + And a file named "example.rb" with: + """ + describe $LOAD_PATH do + it "begins with 'lib' in the current directory in the load path" do + libdir = File.expand_path(File.join(File.dirname(__FILE__), 'lib')) + $LOAD_PATH.should include(libdir) + end + end + """ + When I run "spec example.rb" + Then the stdout should include "1 example, 0 failures" + And the exit code should be 0 + diff --git a/vendor/plugins/rspec/features/load_paths/add_spec_to_load_path.feature b/vendor/plugins/rspec/features/load_paths/add_spec_to_load_path.feature new file mode 100644 index 000000000..b216ebedd --- /dev/null +++ b/vendor/plugins/rspec/features/load_paths/add_spec_to_load_path.feature @@ -0,0 +1,20 @@ +Feature: add 'spec' to load path + In order to ... + As a spec author + I want rspec to add 'spec to the load path + + Scenario: add 'spec' to load path + Given a directory named "spec" + And a file named "example.rb" with: + """ + describe $LOAD_PATH do + it "includes with 'spec' in the current directory in the load path" do + specdir = File.expand_path(File.join(File.dirname(__FILE__), 'spec')) + $LOAD_PATH.should include(specdir) + end + end + """ + When I run "spec example.rb" + Then the stdout should include "1 example, 0 failures" + And the exit code should be 0 + diff --git a/vendor/plugins/rspec/features/matchers/define_diffable_matcher.feature b/vendor/plugins/rspec/features/matchers/define_diffable_matcher.feature new file mode 100644 index 000000000..8715641ec --- /dev/null +++ b/vendor/plugins/rspec/features/matchers/define_diffable_matcher.feature @@ -0,0 +1,26 @@ +Feature: define diffable matcher + + When a matcher is defined as diffable, and the --diff + flag is set, the output will include a diff of the submitted + objects. + + Scenario: define a diffable matcher + Given a file named "diffable_matcher_spec.rb" with: + """ + Spec::Matchers.define :be_just_like do |expected| + match do |actual| + actual == expected + end + + diffable + end + + describe "this" do + it {should be_just_like("that")} + end + """ + When I run "spec diffable_matcher_spec.rb --diff" + Then the exit code should be 256 + + And the stdout should include "should be just like \"that\"" + And the stdout should include "Diff:\n@@ -1,2 +1,2 @@\n-that\n+this" diff --git a/vendor/plugins/rspec/features/matchers/define_matcher.feature b/vendor/plugins/rspec/features/matchers/define_matcher.feature new file mode 100644 index 000000000..79edae73f --- /dev/null +++ b/vendor/plugins/rspec/features/matchers/define_matcher.feature @@ -0,0 +1,179 @@ +Feature: define matcher + + In order to express my domain clearly in my code examples + As an RSpec user + I want a shortcut to define custom matchers + + Scenario: define a matcher with default messages + Given a file named "matcher_with_default_message_spec.rb" with: + """ + Spec::Matchers.define :be_a_multiple_of do |expected| + match do |actual| + actual % expected == 0 + end + end + + describe 9 do + it {should be_a_multiple_of(3)} + end + + describe 9 do + it {should_not be_a_multiple_of(4)} + end + + # fail intentionally to generate expected output + describe 9 do + it {should be_a_multiple_of(4)} + end + + # fail intentionally to generate expected output + describe 9 do + it {should_not be_a_multiple_of(3)} + end + + """ + When I run "spec matcher_with_default_message_spec.rb --format specdoc" + Then the exit code should be 256 + + And the stdout should include "should be a multiple of 3" + And the stdout should include "should not be a multiple of 4" + And the stdout should include "should be a multiple of 4 (FAILED - 1)" + And the stdout should include "should not be a multiple of 3 (FAILED - 2)" + + And the stdout should include "4 examples, 2 failures" + And the stdout should include "expected 9 to be a multiple of 4" + And the stdout should include "expected 9 not to be a multiple of 3" + + Scenario: overriding the failure_message_for_should + Given a file named "matcher_with_failure_message_spec.rb" with: + """ + Spec::Matchers.define :be_a_multiple_of do |expected| + match do |actual| + actual % expected == 0 + end + failure_message_for_should do |actual| + "expected that #{actual} would be a multiple of #{expected}" + end + end + + # fail intentionally to generate expected output + describe 9 do + it {should be_a_multiple_of(4)} + end + """ + When I run "spec matcher_with_failure_message_spec.rb" + Then the exit code should be 256 + And the stdout should include "1 example, 1 failure" + And the stdout should include "expected that 9 would be a multiple of 4" + + Scenario: overriding the failure_message_for_should_not + Given a file named "matcher_with_failure_for_message_spec.rb" with: + """ + Spec::Matchers.define :be_a_multiple_of do |expected| + match do |actual| + actual % expected == 0 + end + failure_message_for_should_not do |actual| + "expected that #{actual} would not be a multiple of #{expected}" + end + end + + # fail intentionally to generate expected output + describe 9 do + it {should_not be_a_multiple_of(3)} + end + """ + When I run "spec matcher_with_failure_for_message_spec.rb" + Then the exit code should be 256 + And the stdout should include "1 example, 1 failure" + And the stdout should include "expected that 9 would not be a multiple of 3" + + Scenario: overriding the description + Given a file named "matcher_overriding_description_spec.rb" with: + """ + Spec::Matchers.define :be_a_multiple_of do |expected| + match do |actual| + actual % expected == 0 + end + description do + "be multiple of #{expected}" + end + end + + describe 9 do + it {should be_a_multiple_of(3)} + end + + describe 9 do + it {should_not be_a_multiple_of(4)} + end + """ + When I run "spec matcher_overriding_description_spec.rb --format specdoc" + Then the exit code should be 0 + And the stdout should include "2 examples, 0 failures" + And the stdout should include "should be multiple of 3" + And the stdout should include "should not be multiple of 4" + + Scenario: with no args + Given a file named "matcher_with_no_args_spec.rb" with: + """ + Spec::Matchers.define :have_7_fingers do + match do |thing| + thing.fingers.length == 7 + end + end + + class Thing + def fingers; (1..7).collect {"finger"}; end + end + + describe Thing do + it {should have_7_fingers} + end + """ + When I run "spec matcher_with_no_args_spec.rb --format specdoc" + Then the exit code should be 0 + And the stdout should include "1 example, 0 failures" + And the stdout should include "should have 7 fingers" + + Scenario: with multiple args + Given a file named "matcher_with_multiple_args_spec.rb" with: + """ + Spec::Matchers.define :be_the_sum_of do |a,b,c,d| + match do |sum| + a + b + c + d == sum + end + end + + describe 10 do + it {should be_the_sum_of(1,2,3,4)} + end + """ + When I run "spec matcher_with_multiple_args_spec.rb --format specdoc" + Then the exit code should be 0 + And the stdout should include "1 example, 0 failures" + And the stdout should include "should be the sum of 1, 2, 3, and 4" + + Scenario: with helper methods + Given a file named "matcher_with_internal_helper_spec.rb" with: + """ + Spec::Matchers.define :have_same_elements_as do |sample| + match do |actual| + similar?(sample, actual) + end + + def similar?(a, b) + a.sort == b.sort + end + end + + describe "these two arrays" do + specify "should be similar" do + [1,2,3].should have_same_elements_as([2,3,1]) + end + end + """ + When I run "spec matcher_with_internal_helper_spec.rb" + Then the exit code should be 0 + And the stdout should include "1 example, 0 failures" + diff --git a/vendor/plugins/rspec/features/matchers/define_matcher_outside_rspec.feature b/vendor/plugins/rspec/features/matchers/define_matcher_outside_rspec.feature new file mode 100644 index 000000000..5e7d705c2 --- /dev/null +++ b/vendor/plugins/rspec/features/matchers/define_matcher_outside_rspec.feature @@ -0,0 +1,38 @@ +Feature: define matcher outside rspec + + In order to express my domain clearly in my code examples + As a non-rspec user + I want a shortcut to define custom matchers + + Scenario: define a matcher with default messages + Given a file named "test_multiples.rb" with: + """ + require 'test/unit' + require 'spec/expectations' + + Spec::Matchers.define :be_a_multiple_of do |expected| + match do |actual| + actual % expected == 0 + end + end + + class Test::Unit::TestCase + include Spec::Matchers + end + + class TestMultiples < Test::Unit::TestCase + + def test_9_should_be_a_multiple_of_3 + 9.should be_a_multiple_of(3) + end + + def test_9_should_be_a_multiple_of_4 + 9.should be_a_multiple_of(4) + end + + end + """ + When I run "ruby test_multiples.rb" + Then the exit code should be 256 + And the stdout should include "expected 9 to be a multiple of 4" + And the stdout should include "2 tests, 0 assertions, 1 failures, 0 errors" diff --git a/vendor/plugins/rspec/features/matchers/define_matcher_with_fluent_interface.feature b/vendor/plugins/rspec/features/matchers/define_matcher_with_fluent_interface.feature new file mode 100644 index 000000000..01845b216 --- /dev/null +++ b/vendor/plugins/rspec/features/matchers/define_matcher_with_fluent_interface.feature @@ -0,0 +1,27 @@ +Feature: define matcher + + In order to express my domain clearly in my code examples + As an RSpec user + I want to define matchers with fluent interfaces + + Scenario: one additional method + Given a file named "between_spec.rb" with: + """ + Spec::Matchers.define :be_bigger_than do |first| + def but_smaller_than(second) + @second = second + self + end + + match do |actual| + (actual > first) && (actual < @second) + end + end + + describe 5 do + it { should be_bigger_than(4).but_smaller_than(6) } + end + """ + When I run "spec between_spec.rb --format specdoc" + Then the stdout should include "1 example, 0 failures" + And the stdout should include "should be bigger than 4" diff --git a/vendor/plugins/rspec/features/matchers/define_wrapped_matcher.feature b/vendor/plugins/rspec/features/matchers/define_wrapped_matcher.feature new file mode 100644 index 000000000..d19808bae --- /dev/null +++ b/vendor/plugins/rspec/features/matchers/define_wrapped_matcher.feature @@ -0,0 +1,29 @@ +Feature: define wrapped matcher + + In order to reuse existing matchers + As an RSpec user + I want to define matchers that wrap other matchers + + Scenario: one additional method + Given a file named "new_model_spec.rb" with: + """ + Spec::Matchers.define :have_tag do |tag| + match do |markup| + markup =~ /<#{tag}>.*<\/#{tag}>/ + end + end + + Spec::Matchers.define :have_button do + match do |markup| + markup.should have_tag('button') + end + end + + describe "some markup" do + it "has a button" do + "<button>Label</button>".should have_button + end + end + """ + When I run "spec new_model_spec.rb --format specdoc" + Then the stdout should include "1 example, 0 failures" diff --git a/vendor/plugins/rspec/features/mock_framework_integration/use_flexmock.feature b/vendor/plugins/rspec/features/mock_framework_integration/use_flexmock.feature new file mode 100644 index 000000000..0a204dfc6 --- /dev/null +++ b/vendor/plugins/rspec/features/mock_framework_integration/use_flexmock.feature @@ -0,0 +1,27 @@ +Feature: mock with flexmock + + As an RSpec user who prefers flexmock + I want to be able to use flexmock without rspec mocks interfering + + Scenario: Mock with flexmock + Given a file named "flexmock_example_spec.rb" with: + """ + Spec::Runner.configure do |config| + config.mock_with :flexmock + end + + describe "plugging in flexmock" do + it "allows flexmock to be used" do + target = Object.new + flexmock(target).should_receive(:foo).once + target.foo + end + + it "does not include rspec mocks" do + Spec.const_defined?(:Mocks).should be_false + end + end + """ + When I run "spec flexmock_example_spec.rb" + Then the exit code should be 0 + And the stdout should include "2 examples, 0 failures" diff --git a/vendor/plugins/rspec/features/mock_framework_integration/use_mocha.feature b/vendor/plugins/rspec/features/mock_framework_integration/use_mocha.feature new file mode 100644 index 000000000..d53b967cd --- /dev/null +++ b/vendor/plugins/rspec/features/mock_framework_integration/use_mocha.feature @@ -0,0 +1,27 @@ +Feature: mock with mocha + + As an RSpec user who prefers mocha + I want to be able to use mocha without rspec mocks interfering + + Scenario: Mock with mocha + Given a file named "mocha_example_spec.rb" with: + """ + Spec::Runner.configure do |config| + config.mock_with :mocha + end + + describe "plugging in mocha" do + it "allows mocha to be used" do + target = Object.new + target.expects(:foo).once + target.foo + end + + it "does not include rspec mocks" do + Spec.const_defined?(:Mocks).should be_false + end + end + """ + When I run "spec mocha_example_spec.rb" + Then the exit code should be 0 + And the stdout should include "2 examples, 0 failures" diff --git a/vendor/plugins/rspec/features/mock_framework_integration/use_rr.feature b/vendor/plugins/rspec/features/mock_framework_integration/use_rr.feature new file mode 100644 index 000000000..aa30882aa --- /dev/null +++ b/vendor/plugins/rspec/features/mock_framework_integration/use_rr.feature @@ -0,0 +1,27 @@ +Feature: mock with rr + + As an RSpec user who prefers rr + I want to be able to use rr without rspec mocks interfering + + Scenario: Mock with rr + Given a file named "rr_example_spec.rb" with: + """ + Spec::Runner.configure do |config| + config.mock_with :rr + end + + describe "plugging in rr" do + it "allows rr to be used" do + target = Object.new + mock(target).foo + target.foo + end + + it "does not include rspec mocks" do + Spec.const_defined?(:Mocks).should be_false + end + end + """ + When I run "spec rr_example_spec.rb" + Then the exit code should be 0 + And the stdout should include "2 examples, 0 failures" diff --git a/vendor/plugins/rspec/features/mocks/mix_stubs_and_mocks.feature b/vendor/plugins/rspec/features/mocks/mix_stubs_and_mocks.feature new file mode 100644 index 000000000..deaf84ecf --- /dev/null +++ b/vendor/plugins/rspec/features/mocks/mix_stubs_and_mocks.feature @@ -0,0 +1,22 @@ +Feature: stub and mock together + + As an RSpec user + I want to use stubs and mocks together + + Scenario: stub in before + Given a file named "stub_and_mocks_spec.rb" with: + """ + describe "a stub in before" do + before(:each) do + @messenger = mock('messenger').as_null_object + end + + it "a" do + @messenger.should_receive(:foo).with('first') + @messenger.foo('second') + @messenger.foo('third') + end + end + """ + When I run "spec stub_and_mocks_spec.rb --format nested" + Then the stdout should include "received :foo with unexpected arguments\n expected: (\"first\")\n got: ([\"second\"], [\"third\"])" diff --git a/vendor/plugins/rspec/features/mocks/stub_implementation.feature b/vendor/plugins/rspec/features/mocks/stub_implementation.feature new file mode 100644 index 000000000..269de4742 --- /dev/null +++ b/vendor/plugins/rspec/features/mocks/stub_implementation.feature @@ -0,0 +1,26 @@ +Feature: stub implementation + + As an rspec user, I want to stub a complete implementation, not just a + return value. + + Scenario: stub implementation + Given a file named "stub_implementation.rb" with: + """ + describe "a stubbed implementation" do + it "works" do + object = Object.new + object.stub(:foo) do |arg| + if arg == :this + "got this" + elsif arg == :that + "got that" + end + end + + object.foo(:this).should == "got this" + object.foo(:that).should == "got that" + end + end + """ + When I run "spec stub_implementation.rb" + Then the stdout should include "1 example, 0 failures" diff --git a/vendor/plugins/rspec/features/pending/pending_examples.feature b/vendor/plugins/rspec/features/pending/pending_examples.feature new file mode 100644 index 000000000..582739563 --- /dev/null +++ b/vendor/plugins/rspec/features/pending/pending_examples.feature @@ -0,0 +1,81 @@ +Feature: pending examples + + RSpec offers three ways to indicate that an example is disabled pending + some action. + + Scenario: pending implementation + Given a file named "example_without_block_spec.rb" with: + """ + describe "an example" do + it "has not yet been implemented" + end + """ + When I run "spec example_without_block_spec.rb" + Then the exit code should be 0 + And the stdout should include "1 example, 0 failures, 1 pending" + And the stdout should include "Not Yet Implemented" + And the stdout should include "example_without_block_spec.rb:2" + + Scenario: pending implementation with spec/test/unit + Given a file named "example_without_block_spec.rb" with: + """ + require 'spec/test/unit' + describe "an example" do + it "has not yet been implemented" + end + """ + When I run "spec example_without_block_spec.rb" + Then the exit code should be 0 + And the stdout should include "1 example, 0 failures, 1 pending" + And the stdout should include "Not Yet Implemented" + And the stdout should include "example_without_block_spec.rb:3" + + Scenario: pending any arbitary reason, with no block + Given a file named "pending_without_block_spec.rb" with: + """ + describe "an example" do + it "is implemented but waiting" do + pending("something else getting finished") + end + end + """ + When I run "spec pending_without_block_spec.rb" + Then the exit code should be 0 + And the stdout should include "1 example, 0 failures, 1 pending" + And the stdout should include "(something else getting finished)" + And the stdout should include "pending_without_block_spec.rb:2" + + Scenario: pending any arbitary reason, with a block that fails + Given a file named "pending_with_failing_block_spec.rb" with: + """ + describe "an example" do + it "is implemented but waiting" do + pending("something else getting finished") do + raise "this is the failure" + end + end + end + """ + When I run "spec pending_with_failing_block_spec.rb" + Then the exit code should be 0 + And the stdout should include "1 example, 0 failures, 1 pending" + And the stdout should include "(something else getting finished)" + And the stdout should include "pending_with_failing_block_spec.rb:2" + + Scenario: pending any arbitary reason, with a block that passes + Given a file named "pending_with_passing_block_spec.rb" with: + """ + describe "an example" do + it "is implemented but waiting" do + pending("something else getting finished") do + true.should be(true) + end + end + end + """ + When I run "spec pending_with_passing_block_spec.rb" + Then the exit code should be 256 + And the stdout should include "1 example, 1 failure" + And the stdout should include "FIXED" + And the stdout should include "Expected pending 'something else getting finished' to fail. No Error was raised." + And the stdout should include "pending_with_passing_block_spec.rb:3" diff --git a/vendor/plugins/rspec/features/runner/specify_line_number.feature b/vendor/plugins/rspec/features/runner/specify_line_number.feature new file mode 100644 index 000000000..bf44f2c09 --- /dev/null +++ b/vendor/plugins/rspec/features/runner/specify_line_number.feature @@ -0,0 +1,32 @@ +Feature: run specific examples by line number + + In order to run a single example from command line + RSpec allows you to specify the line number of the example(s) to run + + Scenario: --line syntax on single example + Given a file named "example_spec.rb" with: + """ + describe "an example" do + it "has not yet been implemented" + it "has been implemented" do + true + end + end + """ + When I run "spec example_spec.rb --line 2" + Then the stdout should include "1 example, 0 failures, 1 pending" + And the stdout should include "example_spec.rb:2" + + Scenario: colon line syntax on single example + Given a file named "example_spec.rb" with: + """ + describe "an example" do + it "has not yet been implemented" + it "has been implemented" do + true + end + end + """ + When I run "spec example_spec.rb:2" + Then the stdout should include "1 example, 0 failures, 1 pending" + And the stdout should include "example_spec.rb:2" diff --git a/vendor/plugins/rspec/features/spec_helper/spec_helper.feature b/vendor/plugins/rspec/features/spec_helper/spec_helper.feature new file mode 100644 index 000000000..2711e1a58 --- /dev/null +++ b/vendor/plugins/rspec/features/spec_helper/spec_helper.feature @@ -0,0 +1,25 @@ +Feature: spec helper + In order to centralize code needed across most specs + As a spec author + I want to require 'spec_helper' + + Because rspec adds the PROJECT_ROOT/spec directory to the load path, we can + just require 'spec_helper' and it will be found. + + Scenario: spec helper + Given a directory named "spec" + And a file named "spec/spec_helper.rb" with: + """ + SOME_CONSTANT = 'some value' + """ + And a file named "example.rb" with: + """ + require 'spec_helper' + describe SOME_CONSTANT do + it { should == 'some value' } + end + """ + When I run "spec example.rb" + And the stdout should include "1 example, 0 failures" + And the exit code should be 0 + diff --git a/vendor/plugins/rspec/features/step_definitions/running_rspec_steps.rb b/vendor/plugins/rspec/features/step_definitions/running_rspec_steps.rb new file mode 100644 index 000000000..60f27fa80 --- /dev/null +++ b/vendor/plugins/rspec/features/step_definitions/running_rspec_steps.rb @@ -0,0 +1,43 @@ +Given %r{^a file named "([^"]+)" with:$} do |file_name, code| + create_file(file_name, code) +end + +Given /^a directory named "([^\"]*)"$/ do |dirname| + create_directory(dirname) +end + +When %r{^I run "spec ([^"]+)"$} do |file_and_args| + spec(file_and_args) +end + +When %r{^I run "ruby ([^"]+)"$} do |file_and_args| + ruby(file_and_args) +end + +When %r{^I run "cmdline.rb ([^"]+)"$} do |file_and_args| + cmdline(file_and_args) +end + +Then /^the (.*) should include (.*)$/ do |stream, string_or_regex| + written = case(stream) + when 'stdout' then last_stdout + when 'stderr' then last_stderr + else raise "Unknown stream: #{stream}" + end + written.should smart_match(string_or_regex) +end + +Then /^the (.*) should not match (.*)$/ do |stream, string_or_regex| + written = case(stream) + when 'stdout' then last_stdout + when 'stderr' then last_stderr + else raise "Unknown stream: #{stream}" + end + written.should_not smart_match(string_or_regex) +end + +Then /^the exit code should be (\d+)$/ do |exit_code| + if last_exit_code != exit_code.to_i + raise "Did not exit with #{exit_code}, but with #{last_exit_code}. Standard error:\n#{last_stderr}" + end +end diff --git a/vendor/plugins/rspec/features/subject/explicit_subject.feature b/vendor/plugins/rspec/features/subject/explicit_subject.feature new file mode 100644 index 000000000..9fb68ad43 --- /dev/null +++ b/vendor/plugins/rspec/features/subject/explicit_subject.feature @@ -0,0 +1,31 @@ +Feature: explicit subject + + You can override the implicit subject using the subject() method. + + Scenario: subject in top level group + Given a file named "top_level_subject_spec.rb" with: + """ + describe Array, "with some elements" do + subject { [1,2,3] } + it "should have the prescribed elements" do + subject.should == [1,2,3] + end + end + """ + When I run "spec top_level_subject_spec.rb" + Then the stdout should include "1 example, 0 failures" + + Scenario: subject in a nested group + Given a file named "nested_subject_spec.rb" with: + """ + describe Array do + subject { [1,2,3] } + describe "with some elements" do + it "should have the prescribed elements" do + subject.should == [1,2,3] + end + end + end + """ + When I run "spec nested_subject_spec.rb" + Then the stdout should include "1 example, 0 failures" diff --git a/vendor/plugins/rspec/features/subject/implicit_subject.feature b/vendor/plugins/rspec/features/subject/implicit_subject.feature new file mode 100644 index 000000000..bc57d2ba4 --- /dev/null +++ b/vendor/plugins/rspec/features/subject/implicit_subject.feature @@ -0,0 +1,43 @@ +Feature: implicit subject + + The first argument to the outermost example group block is + made available to each example as an implicit subject of + that example. + + Scenario: subject in top level group + Given a file named "top_level_subject_spec.rb" with: + """ + describe Array, "when first created" do + it "should be empty" do + subject.should == [] + end + end + """ + When I run "spec top_level_subject_spec.rb" + Then the stdout should include "1 example, 0 failures" + + Scenario: subject in a nested group + Given a file named "nested_subject_spec.rb" with: + """ + describe Array do + describe "when first created" do + it "should be empty" do + subject.should == [] + end + end + end + """ + When I run "spec nested_subject_spec.rb" + Then the stdout should include "1 example, 0 failures" + + Scenario: subject with getters + Given a file named "subject_with_getter_spec.rb" with: + """ + describe Array do + describe "when first created" do + its(:length) { should == 0 } + end + end + """ + When I run "spec subject_with_getter_spec.rb" + Then the stdout should include "1 example, 0 failures" diff --git a/vendor/plugins/rspec/features/support/env.rb b/vendor/plugins/rspec/features/support/env.rb new file mode 100644 index 000000000..e11b3db25 --- /dev/null +++ b/vendor/plugins/rspec/features/support/env.rb @@ -0,0 +1,82 @@ +$:.unshift File.join(File.dirname(__FILE__), "/../../lib") + +require 'spec/expectations' +require 'forwardable' +require 'tempfile' +require 'spec/ruby_forker' +require 'features/support/matchers/smart_match' + +class RspecWorld + include Spec::Expectations + include Spec::Matchers + include RubyForker + + extend Forwardable + def_delegators RspecWorld, :working_dir, :spec_command, :cmdline_file, :rspec_lib + + def self.working_dir + @working_dir ||= File.expand_path(File.join(File.dirname(__FILE__), "/../../tmp/cucumber-generated-files")) + end + + def self.spec_command + @spec_command ||= File.expand_path(File.join(File.dirname(__FILE__), "/../../bin/spec")) + end + + def self.cmdline_file + @cmdline_file ||= File.expand_path(File.join(File.dirname(__FILE__), "/../../resources/helpers/cmdline.rb")) + end + + def self.rspec_lib + @rspec_lib ||= File.join(working_dir, "/../../lib") + end + + def spec(args) + ruby("#{spec_command} #{args}") + end + + def cmdline(args) + ruby("#{cmdline_file} #{args}") + end + + def create_file(file_name, contents) + file_path = File.join(working_dir, file_name) + File.open(file_path, "w") { |f| f << contents } + end + + def create_directory(dirname) + FileUtils.mkdir_p File.join(working_dir, dirname) + end + + def last_stdout + @stdout + end + + def last_stderr + @stderr + end + + def last_exit_code + @exit_code + end + + # it seems like this, and the last_* methods, could be moved into RubyForker-- is that being used anywhere but the features? + def ruby(args) + stderr_file = Tempfile.new('rspec') + stderr_file.close + Dir.chdir(working_dir) do + @stdout = super("-I #{rspec_lib} #{args}", stderr_file.path) + end + @stderr = IO.read(stderr_file.path) + @exit_code = $?.to_i + end + +end + +Before do + FileUtils.rm_rf RspecWorld.working_dir if test ?d, RspecWorld.working_dir + FileUtils.mkdir_p RspecWorld.working_dir +end + +World do + RspecWorld.new +end diff --git a/vendor/plugins/rspec/features/support/matchers/smart_match.rb b/vendor/plugins/rspec/features/support/matchers/smart_match.rb new file mode 100644 index 000000000..74c508987 --- /dev/null +++ b/vendor/plugins/rspec/features/support/matchers/smart_match.rb @@ -0,0 +1,12 @@ +Spec::Matchers.define :smart_match do |expected| + match do |actual| + case expected + when /^\/.*\/?$/ + actual =~ eval(expected) + when /^".*"$/ + actual.index(eval(expected)) + else + false + end + end +end diff --git a/vendor/plugins/rspec/geminstaller.yml b/vendor/plugins/rspec/geminstaller.yml new file mode 100644 index 000000000..9bfc3133b --- /dev/null +++ b/vendor/plugins/rspec/geminstaller.yml @@ -0,0 +1,28 @@ +# Basics needed to run 'rake' from this directory +gems: +- name: cucumber + version: '>= 0.3.101' +- name: diff-lcs + version: '>= 1.1.2' +- name: bmabey-fakefs + version: '>= 0' +- name: flexmock + version: '>= 0.8.6' +- name: heckle + version: '>= 1.4.2' +- name: hoe + version: '>= 2.0' +- name: nokogiri + version: '>= 1.2.3' +- name: mocha + version: '>= 0.9.5' +- name: rake + version: '>= 0.8.4' +- name: spicycode-rcov + version: '>= 0.8.2.1' +- name: syntax + version: '>= 1.0.0' +- name: rr + version: '>= 0.10.0' +- name: ruby-debug + version: '>= 0.10.3' diff --git a/vendor/plugins/rspec/lib/spec/adapters/mock_frameworks/flexmock.rb b/vendor/plugins/rspec/lib/spec/adapters/mock_frameworks/flexmock.rb new file mode 100644 index 000000000..18dd453dd --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/adapters/mock_frameworks/flexmock.rb @@ -0,0 +1,24 @@ +#!/usr/bin/env ruby +# +# Created by Jim Weirich on 2007-04-10. +# Copyright (c) 2007. All rights reserved. + +require 'rubygems' unless ENV['NO_RUBYGEMS'] +require 'flexmock/rspec' + +module Spec + module Adapters + module MockFramework + include FlexMock::MockContainer + def setup_mocks_for_rspec + # No setup required + end + def verify_mocks_for_rspec + flexmock_verify + end + def teardown_mocks_for_rspec + flexmock_close + end + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/adapters/mock_frameworks/mocha.rb b/vendor/plugins/rspec/lib/spec/adapters/mock_frameworks/mocha.rb new file mode 100644 index 000000000..4c97c139a --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/adapters/mock_frameworks/mocha.rb @@ -0,0 +1,25 @@ +require 'rubygems' unless ENV['NO_RUBYGEMS'] +require 'mocha/standalone' +require 'mocha/object' + +module Spec + module Adapters + module MockFramework + # Mocha::Standalone was deprecated as of Mocha 0.9.7. + begin + include Mocha::API + rescue NameError + include Mocha::Standalone + end + def setup_mocks_for_rspec + mocha_setup + end + def verify_mocks_for_rspec + mocha_verify + end + def teardown_mocks_for_rspec + mocha_teardown + end + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/adapters/mock_frameworks/rr.rb b/vendor/plugins/rspec/lib/spec/adapters/mock_frameworks/rr.rb new file mode 100644 index 000000000..758ddf611 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/adapters/mock_frameworks/rr.rb @@ -0,0 +1,22 @@ +require 'rubygems' unless ENV['NO_RUBYGEMS'] +require 'rr' + +patterns = ::Spec::Runner::QuietBacktraceTweaker::IGNORE_PATTERNS +patterns.push(RR::Errors::BACKTRACE_IDENTIFIER) + +module Spec + module Adapters + module MockFramework + include RR::Extensions::InstanceMethods + def setup_mocks_for_rspec + RR::Space.instance.reset + end + def verify_mocks_for_rspec + RR::Space.instance.verify_doubles + end + def teardown_mocks_for_rspec + RR::Space.instance.reset + end + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/adapters/mock_frameworks/rspec.rb b/vendor/plugins/rspec/lib/spec/adapters/mock_frameworks/rspec.rb new file mode 100644 index 000000000..b159f8bfe --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/adapters/mock_frameworks/rspec.rb @@ -0,0 +1,21 @@ +require 'spec/mocks/framework' +require 'spec/mocks/extensions' + +module Spec + module Adapters + unless defined?(MockFramework) + module MockFramework + include Spec::Mocks::ExampleMethods + def setup_mocks_for_rspec + $rspec_mocks ||= Spec::Mocks::Space.new + end + def verify_mocks_for_rspec + $rspec_mocks.verify_all + end + def teardown_mocks_for_rspec + $rspec_mocks.reset_all + end + end + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/autorun.rb b/vendor/plugins/rspec/lib/spec/autorun.rb new file mode 100644 index 000000000..f29b81966 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/autorun.rb @@ -0,0 +1,3 @@ +require 'spec' + +Spec::Runner.autorun diff --git a/vendor/plugins/rspec/lib/spec/deprecation.rb b/vendor/plugins/rspec/lib/spec/deprecation.rb new file mode 100644 index 000000000..ebab78942 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/deprecation.rb @@ -0,0 +1,40 @@ +module Spec + class << self + def deprecate(method, alternate_method=nil) + message = <<-NOTICE + +***************************************************************** +DEPRECATION WARNING: you are using deprecated behaviour that will +be removed from a future version of RSpec. + +#{caller(0)[2]} + +* #{method} is deprecated. +NOTICE + if alternate_method + message << <<-ADDITIONAL +* please use #{alternate_method} instead. +ADDITIONAL + end + + message << "*****************************************************************" + warn(message) + end + + def warn(message) + Kernel.warn(message) + end + + end + + class HashWithDeprecationNotice < Hash + def initialize(method, alternate_method=nil, &block) + @method, @alternate_method = method, alternate_method + end + def []=(k,v) + Spec.deprecate(@method, @alternate_method) + super + end + end +end + diff --git a/vendor/plugins/rspec/lib/spec/dsl.rb b/vendor/plugins/rspec/lib/spec/dsl.rb new file mode 100644 index 000000000..d93e90d84 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/dsl.rb @@ -0,0 +1 @@ +require 'spec/dsl/main' diff --git a/vendor/plugins/rspec/lib/spec/dsl/main.rb b/vendor/plugins/rspec/lib/spec/dsl/main.rb new file mode 100644 index 000000000..3459275b4 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/dsl/main.rb @@ -0,0 +1,92 @@ +module Spec + module DSL + module Main + include Spec::Example::ArgsAndOptions + + # Creates and returns a class that includes the ExampleGroupMethods + # module. Which ExampleGroup type is created depends on the directory of the file + # calling this method. For example, Spec::Rails will use different + # classes for specs living in <tt>spec/models</tt>, + # <tt>spec/helpers</tt>, <tt>spec/views</tt> and + # <tt>spec/controllers</tt>. + # + # It is also possible to override autodiscovery of the example group + # type with an options Hash as the last argument: + # + # describe "name", :type => :something_special do ... + # + # The reason for using different example group classes is to have different + # matcher methods available from within the <tt>describe</tt> block. + # + # See Spec::Example::ExampleGroupFactory#register for details about how to + # register special implementations. + # + def describe(*args, &block) + raise Spec::Example::NoDescriptionError.new("example group", caller(0)[1]) if args.empty? + add_options(args, :scope => self) + set_location(args.options, caller(0)[1]) + Spec::Example::ExampleGroupFactory.create_example_group(*args, &block) + end + alias :context :describe + + # Creates an example group that can be shared by other example groups + # + # == Examples + # + # share_examples_for "All Editions" do + # it "all editions behaviour" ... + # end + # + # describe SmallEdition do + # it_should_behave_like "All Editions" + # + # it "should do small edition stuff" do + # ... + # end + # end + def share_examples_for(*args, &block) + add_options(args) + set_location(args.options, caller(0)[1]) + Spec::Example::ExampleGroupFactory.create_shared_example_group(*args, &block) + end + alias :shared_examples_for :share_examples_for + + # Creates a Shared Example Group and assigns it to a constant + # + # share_as :AllEditions do + # it "should do all editions stuff" ... + # end + # + # describe SmallEdition do + # it_should_behave_like AllEditions + # + # it "should do small edition stuff" do + # ... + # end + # end + # + # And, for those of you who prefer to use something more like Ruby, you + # can just include the module directly + # + # describe SmallEdition do + # include AllEditions + # + # it "should do small edition stuff" do + # ... + # end + # end + def share_as(name, &block) + begin + args = [name] + add_options(args) + set_location(args.options, caller(0)[1]) + Object.const_set(name, Spec::Example::ExampleGroupFactory.create_shared_example_group(*args, &block)) + rescue NameError => e + raise NameError.new(e.message + "\nThe first argument to share_as must be a legal name for a constant\n") + end + end + end + end +end + +include Spec::DSL::Main diff --git a/vendor/plugins/rspec/lib/spec/example/args_and_options.rb b/vendor/plugins/rspec/lib/spec/example/args_and_options.rb new file mode 100644 index 000000000..b74fddd8e --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/example/args_and_options.rb @@ -0,0 +1,27 @@ +module Spec + module Example + module ArgsAndOptions + def args_and_options(*args) # :nodoc: + options = Hash === args.last ? args.pop : {} + return args, options + end + + def add_options(args, options={}) # :nodoc: + args << {} unless Hash === args.last + args.extend WithOptions + args.options.merge!(options) + args.options + end + + def set_location(options, location) # :nodoc: + options[:location] ||= location + end + + module WithOptions # :nodoc: + def options + last + end + end + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/example/before_and_after_hooks.rb b/vendor/plugins/rspec/lib/spec/example/before_and_after_hooks.rb new file mode 100644 index 000000000..9f5039d1e --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/example/before_and_after_hooks.rb @@ -0,0 +1,93 @@ +module Spec + module Example + module BeforeAndAfterHooks + class << self + def before_suite_parts # :nodoc: + @before_suite_parts ||= [] + end + + def after_suite_parts # :nodoc: + @after_suite_parts ||= [] + end + end + + # Registers a block to be executed before examples. <tt>scope</tt> can be + # <tt>:each</tt> (default), <tt>:all</tt>, or <tt>:suite</tt>. When + # <tt>:each</tt>, the block is executed before each example. When + # <tt>:all</tt>, the block is executed only once before any examples are + # run. + def append_before(scope = :each, &block) + before_parts(scope) << block + end + alias_method :before, :append_before + + # Registers a block to be executed before each example. + # This method prepends +block+ to existing before blocks. + # + # See <tt>append_before</tt> for scoping semantics. + def prepend_before(scope = :each, &block) + before_parts(scope).unshift(block) + end + + # Registers a block to be executed after each example. + # This method prepends +block+ to existing after blocks. + # + # See <tt>append_before</tt> for scoping semantics. + def prepend_after(scope = :each, &block) + after_parts(scope).unshift(block) + end + alias_method :after, :prepend_after + + # Registers a block to be executed after each example. + # This method appends +block+ to existing after blocks. + # + # See <tt>append_before</tt> for scoping semantics. + def append_after(scope = :each, &block) + after_parts(scope) << block + end + + def before_each_parts # :nodoc: + @before_each_parts ||= [] + end + + def after_each_parts # :nodoc: + @after_each_parts ||= [] + end + + def before_all_parts # :nodoc: + @before_all_parts ||= [] + end + + def after_all_parts # :nodoc: + @after_all_parts ||= [] + end + + def before_suite_parts # :nodoc: + BeforeAndAfterHooks.before_suite_parts + end + + def after_suite_parts # :nodoc: + BeforeAndAfterHooks.after_suite_parts + end + + private + + def before_parts(scope) + case scope + when :each; before_each_parts + when :all; before_all_parts + when :suite; before_suite_parts + end + end + + def after_parts(scope) + case scope + when :each; after_each_parts + when :all; after_all_parts + when :suite; after_suite_parts + end + end + + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/example/example_group_hierarchy.rb b/vendor/plugins/rspec/lib/spec/example/example_group_hierarchy.rb new file mode 100644 index 000000000..f2c9fb5cd --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/example/example_group_hierarchy.rb @@ -0,0 +1,53 @@ +module Spec + module Example + class ExampleGroupHierarchy < Array + def initialize(example_group_class) + push example_group_class + if example_group_class.respond_to?(:superclass) && example_group_class.superclass.respond_to?(:example_group_hierarchy) + unshift example_group_class.superclass.example_group_hierarchy + flatten! + end + end + + def run_before_all(example) + example.eval_each_fail_fast(before_all_parts) + end + + def run_before_each(example) + example.eval_each_fail_fast(before_each_parts) + end + + def run_after_each(example) + example.eval_each_fail_slow(after_each_parts) + end + + def run_after_all(example) + example.eval_each_fail_slow(after_all_parts) + end + + def before_all_parts + @before_all_parts ||= collect {|klass| klass.before_all_parts}.flatten + end + + def before_each_parts + @before_each_parts ||= collect {|klass| klass.before_each_parts}.flatten + end + + def after_each_parts + @after_each_parts ||= reverse.collect {|klass| klass.after_each_parts}.flatten + end + + def after_all_parts + @after_all_parts ||= reverse.collect {|klass| klass.after_all_parts}.flatten + end + + def nested_descriptions + @nested_descriptions ||= collect {|eg| nested_description_from(eg) == "" ? nil : nested_description_from(eg) }.compact + end + + def nested_description_from(example_group) + example_group.description_args.join + end + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/example/example_group_proxy.rb b/vendor/plugins/rspec/lib/spec/example/example_group_proxy.rb new file mode 100644 index 000000000..3c258d61f --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/example/example_group_proxy.rb @@ -0,0 +1,61 @@ +module Spec + module Example + # Lightweight proxy for an example group. This is the object that is passed + # to Spec::Runner::Formatter::BaseFormatter#example_group_started + class ExampleGroupProxy + + def initialize(example_group) # :nodoc: + @description = example_group.description + @nested_descriptions = example_group.nested_descriptions + @examples = example_group.example_proxies + @location = example_group.location + @backtrace = example_group.location # deprecated - see the backtrace method below + @options = example_group.options.dup + @options.delete(:location) + @options.delete(:scope) + end + + # Optional hash passed to the example group declaration. Note that RSpec uses + # this hash internally and reserves the keys :location and :scope for its own + # use (and removes them from this hash) + attr_reader :options + + # This is the description passed to the <tt>describe()</tt> method or any + # of its aliases + attr_reader :description + + # Used by Spec::Runner::Formatter::NestedTextFormatter to access the + # description of each example group in a nested group separately. + attr_reader :nested_descriptions + + # A collection of ExampleGroupProxy objects, one for each example + # declared in this group. + attr_reader :examples + + # The file and line number at which the proxied example group + # was declared. This is extracted from <tt>caller</tt>, and is therefore + # formatted as an individual line in a backtrace. + attr_reader :location + + # Deprecated - use location() instead + def backtrace + Spec::deprecate("ExampleGroupProxy#backtrace","ExampleGroupProxy#location") + @backtrace + end + + # Deprecated - just use gsub on the description instead. + def filtered_description(regexp) + Spec::deprecate("ExampleGroupProxy#filtered_description","gsub (or similar) to modify ExampleGroupProxy#description") + ExampleGroupMethods.build_description_from( + *nested_descriptions.collect do |description| + description =~ regexp ? description.gsub($1, "") : description + end + ) + end + + def ==(other) # :nodoc: + other.description == description + end + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/example/example_proxy.rb b/vendor/plugins/rspec/lib/spec/example/example_proxy.rb new file mode 100644 index 000000000..f726d0e70 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/example/example_proxy.rb @@ -0,0 +1,41 @@ +module Spec + module Example + # Lightweight proxy for an example. This is the object that is passed to + # example-related methods in Spec::Runner::Formatter::BaseFormatter + class ExampleProxy + + def initialize(description=nil, options={}, location=nil) # :nodoc: + @description, @options, @location = description, options, location + end + + # Optional hash passed to the example declaration + attr_reader :options + + # This is the docstring passed to the <tt>it()</tt> method or any + # of its aliases + attr_reader :description + + # The file and line number at which the represented example + # was declared. This is extracted from <tt>caller</tt>, and is therefore + # formatted as an individual line in a backtrace. + attr_reader :location + + # Deprecated - use location() + def backtrace + Spec.deprecate("ExampleProxy#backtrace","ExampleProxy#location") + location + end + + # Convenience method for example group - updates the value of + # <tt>description</tt> and returns self. + def update(description) # :nodoc: + @description = description + self + end + + def ==(other) # :nodoc: + (other.description == description) & (other.location == location) + end + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/example/predicate_matchers.rb b/vendor/plugins/rspec/lib/spec/example/predicate_matchers.rb new file mode 100644 index 000000000..c3c319519 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/example/predicate_matchers.rb @@ -0,0 +1,46 @@ +module Spec + module Example + module PredicateMatchers + # :call-seq: + # predicate_matchers[matcher_name] = method_on_object + # predicate_matchers[matcher_name] = [method1_on_object, method2_on_object] + # + # Dynamically generates a custom matcher that will match + # a predicate on your class. RSpec provides a couple of these + # out of the box: + # + # exist (for state expectations) + # File.should exist("path/to/file") + # + # an_instance_of (for mock argument matchers) + # mock.should_receive(:message).with(an_instance_of(String)) + # + # == Examples + # + # class Fish + # def can_swim? + # true + # end + # end + # + # describe Fish do + # predicate_matchers[:swim] = :can_swim? + # it "should swim" do + # Fish.new.should swim + # end + # end + def predicate_matchers + @predicate_matchers ||= Spec::HashWithDeprecationNotice.new("predicate_matchers", "the new Matcher DSL") + end + + def define_methods_from_predicate_matchers # :nodoc: + predicate_matchers.each_pair do |matcher_method, method_on_object| + define_method matcher_method do |*args| + eval("be_#{method_on_object.to_s.gsub('?','')}(*args)") + end + end + end + + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/example/subject.rb b/vendor/plugins/rspec/lib/spec/example/subject.rb new file mode 100644 index 000000000..944edca45 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/example/subject.rb @@ -0,0 +1,108 @@ +module Spec + module Example + module Subject + module ExampleGroupMethods + # Defines an explicit subject for an example group which can then be the + # implicit receiver (through delegation) of calls to +should+. + # + # == Examples + # + # describe CheckingAccount, "with $50" do + # subject { CheckingAccount.new(:amount => 50, :currency => :USD) } + # it { should have_a_balance_of(50, :USD) } + # it { should_not be_overdrawn } + # its(:currency) { should == :USD } + # end + # + # See +ExampleMethods#should+ for more information about this approach. + def subject(&block) + block.nil? ? + explicit_subject || implicit_subject : @explicit_subject_block = block + end + + def its(attribute, &block) + describe(attribute) do + define_method(:subject) { super().send(attribute) } + it(&block) + end + end + + attr_reader :explicit_subject_block # :nodoc: + + private + + def explicit_subject + group = self + while group.respond_to?(:explicit_subject_block) + return group.explicit_subject_block if group.explicit_subject_block + group = group.superclass + end + end + + def implicit_subject + (described_class ? lambda {described_class.new} : lambda {description_args.first}) + end + end + + module ExampleMethods + + alias_method :__should_for_example_group__, :should + alias_method :__should_not_for_example_group__, :should_not + + # Returns the subject defined in ExampleGroupMethods#subject. The + # subject block is only executed once per example, the result of which + # is cached and returned by any subsequent calls to +subject+. + # + # If a class is passed to +describe+ and no subject is explicitly + # declared in the example group, then +subject+ will return a new + # instance of that class. + # + # == Examples + # + # # explicit subject defined by the subject method + # describe Person do + # subject { Person.new(:birthdate => 19.years.ago) } + # it "should be eligible to vote" do + # subject.should be_eligible_to_vote + # end + # end + # + # # implicit subject => { Person.new } + # describe Person do + # it "should be eligible to vote" do + # subject.should be_eligible_to_vote + # end + # end + def subject + @subject ||= instance_eval(&self.class.subject) + end + + # When +should+ is called with no explicit receiver, the call is + # delegated to the object returned by +subject+. Combined with + # an implicit subject (see +subject+), this supports very concise + # expressions. + # + # == Examples + # + # describe Person do + # it { should be_eligible_to_vote } + # end + def should(matcher=nil, message=nil) + self == subject ? self.__should_for_example_group__(matcher) : subject.should(matcher,message) + end + + # Just like +should+, +should_not+ delegates to the subject (implicit or + # explicit) of the example group. + # + # == Examples + # + # describe Person do + # it { should_not be_eligible_to_vote } + # end + def should_not(matcher=nil, message=nil) + self == subject ? self.__should_not_for_example_group__(matcher) : subject.should_not(matcher,message) + end + end + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/expectations/extensions/kernel.rb b/vendor/plugins/rspec/lib/spec/expectations/extensions/kernel.rb new file mode 100644 index 000000000..7d8849226 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/expectations/extensions/kernel.rb @@ -0,0 +1,52 @@ +module Kernel + # :call-seq: + # should(matcher) + # should == expected + # should === expected + # should =~ expected + # + # receiver.should(matcher) + # => Passes if matcher.matches?(receiver) + # + # receiver.should == expected #any value + # => Passes if (receiver == expected) + # + # receiver.should === expected #any value + # => Passes if (receiver === expected) + # + # receiver.should =~ regexp + # => Passes if (receiver =~ regexp) + # + # See Spec::Matchers for more information about matchers + # + # == Warning + # + # NOTE that this does NOT support receiver.should != expected. + # Instead, use receiver.should_not == expected + def should(matcher=nil, message=nil, &block) + Spec::Expectations::PositiveExpectationHandler.handle_matcher(self, matcher, message, &block) + end + + # :call-seq: + # should_not(matcher) + # should_not == expected + # should_not === expected + # should_not =~ expected + # + # receiver.should_not(matcher) + # => Passes unless matcher.matches?(receiver) + # + # receiver.should_not == expected + # => Passes unless (receiver == expected) + # + # receiver.should_not === expected + # => Passes unless (receiver === expected) + # + # receiver.should_not =~ regexp + # => Passes unless (receiver =~ regexp) + # + # See Spec::Matchers for more information about matchers + def should_not(matcher=nil, message=nil, &block) + Spec::Expectations::NegativeExpectationHandler.handle_matcher(self, matcher, message, &block) + end +end diff --git a/vendor/plugins/rspec/lib/spec/expectations/fail_with.rb b/vendor/plugins/rspec/lib/spec/expectations/fail_with.rb new file mode 100644 index 000000000..5e01f99df --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/expectations/fail_with.rb @@ -0,0 +1,45 @@ +module Spec + module Expectations + class << self + attr_accessor :differ + + # raises a Spec::Expectations::ExpectationNotMetError with message + # + # When a differ has been assigned and fail_with is passed + # <code>expected</code> and <code>target</code>, passes them + # to the differ to append a diff message to the failure message. + def fail_with(message, expected=nil, target=nil) # :nodoc: + if message.nil? + raise ArgumentError, "Failure message is nil. Does your matcher define the " + + "appropriate failure_message_for_* method to return a string?" + end + if (Array === message) & (message.length == 3) + ::Spec.warn(<<-NOTICE + +***************************************************************** +DEPRECATION WARNING: you are using deprecated behaviour that will +be removed from a future version of RSpec. + +* Support for matchers that return arrays from failure message +methods is deprecated. +* Instead, the matcher should return a string, and expose methods +for the expected() and actual() values. +***************************************************************** +NOTICE + ) + message, expected, target = message[0], message[1], message[2] + end + unless (differ.nil? || expected.nil? || target.nil?) + if expected.is_a?(String) + message << "\n\n Diff:" << self.differ.diff_as_string(target.to_s, expected) + elsif expected.is_a?(Hash) && target.is_a?(Hash) + message << "\n\n Diff:" << self.differ.diff_as_hash(target, expected) + elsif !target.is_a?(Proc) + message << "\n\n Diff:" << self.differ.diff_as_object(target, expected) + end + end + Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message)) + end + end + end +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/lib/spec/matchers/be_instance_of.rb b/vendor/plugins/rspec/lib/spec/matchers/be_instance_of.rb new file mode 100644 index 000000000..ffc238405 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/matchers/be_instance_of.rb @@ -0,0 +1,26 @@ +module Spec + module Matchers + # :call-seq: + # should be_instance_of(expected) + # should be_an_instance_of(expected) + # should_not be_instance_of(expected) + # should_not be_an_instance_of(expected) + # + # Passes if actual.instance_of?(expected) + # + # == Examples + # + # 5.should be_instance_of(Fixnum) + # 5.should_not be_instance_of(Numeric) + # 5.should_not be_instance_of(Float) + def be_an_instance_of(expected) + Matcher.new :be_an_instance_of, expected do |_expected_| + match do |actual| + actual.instance_of?(_expected_) + end + end + end + + alias_method :be_instance_of, :be_an_instance_of + end +end diff --git a/vendor/plugins/rspec/lib/spec/matchers/be_kind_of.rb b/vendor/plugins/rspec/lib/spec/matchers/be_kind_of.rb new file mode 100644 index 000000000..6a1fddc13 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/matchers/be_kind_of.rb @@ -0,0 +1,26 @@ +module Spec + module Matchers + # :call-seq: + # should be_kind_of(expected) + # should be_a_kind_of(expected) + # should_not be_kind_of(expected) + # should_not be_a_kind_of(expected) + # + # Passes if actual.kind_of?(expected) + # + # == Examples + # + # 5.should be_kind_of(Fixnum) + # 5.should be_kind_of(Numeric) + # 5.should_not be_kind_of(Float) + def be_a_kind_of(expected) + Matcher.new :be_a_kind_of, expected do |_expected_| + match do |actual| + actual.kind_of?(_expected_) + end + end + end + + alias_method :be_kind_of, :be_a_kind_of + end +end diff --git a/vendor/plugins/rspec/lib/spec/matchers/compatibility.rb b/vendor/plugins/rspec/lib/spec/matchers/compatibility.rb new file mode 100644 index 000000000..3b3ddb9b6 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/matchers/compatibility.rb @@ -0,0 +1,14 @@ +Spec::Matchers.constants.each do |c| + if Class === (klass = Spec::Matchers.const_get(c)) + if klass.public_instance_methods.any? {|m| ['failure_message_for_should',:failure_message_for_should].include?(m)} + klass.class_eval do + alias_method :failure_message, :failure_message_for_should + end + end + if klass.public_instance_methods.any? {|m| ['failure_message_for_should_not',:failure_message_for_should_not].include?(m)} + klass.class_eval do + alias_method :negative_failure_message, :failure_message_for_should_not + end + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/matchers/dsl.rb b/vendor/plugins/rspec/lib/spec/matchers/dsl.rb new file mode 100644 index 000000000..73f363457 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/matchers/dsl.rb @@ -0,0 +1,20 @@ +module Spec + module Matchers + module DSL + # See Spec::Matchers + def define(name, &declarations) + define_method name do |*expected| + Spec::Matchers::Matcher.new name, *expected, &declarations + end + end + + # Deprecated - use define + def create(name, &declarations) + Spec.deprecate("Spec::Matchers.create","Spec::Matchers.define") + define(name, &declarations) + end + end + end +end + +Spec::Matchers.extend Spec::Matchers::DSL diff --git a/vendor/plugins/rspec/lib/spec/matchers/errors.rb b/vendor/plugins/rspec/lib/spec/matchers/errors.rb new file mode 100644 index 000000000..49c267797 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/matchers/errors.rb @@ -0,0 +1,5 @@ +module Spec + module Matchers + class MatcherError < StandardError; end + end +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/lib/spec/matchers/extensions/instance_exec.rb b/vendor/plugins/rspec/lib/spec/matchers/extensions/instance_exec.rb new file mode 100644 index 000000000..ca7e14ead --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/matchers/extensions/instance_exec.rb @@ -0,0 +1,31 @@ +module Spec + module Matchers + module InstanceExec + unless respond_to?(:instance_exec) + # based on Bounded Spec InstanceExec (Mauricio Fernandez) + # http://eigenclass.org/hiki/bounded+space+instance_exec + # - uses singleton_class of matcher instead of global + # InstanceExecHelper module + # - this keeps it scoped to this class only, which is the + # only place we need it + # - only necessary for ruby 1.8.6 + def instance_exec(*args, &block) + singleton_class = (class << self; self; end) + begin + orig_critical, Thread.critical = Thread.critical, true + n = 0 + n += 1 while respond_to?(method_name="__instance_exec#{n}") + singleton_class.module_eval{ define_method(:__instance_exec, &block) } + ensure + Thread.critical = orig_critical + end + begin + return send(:__instance_exec, *args) + ensure + singleton_class.module_eval{ remove_method(:__instance_exec) } rescue nil + end + end + end + end + end +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/lib/spec/matchers/generated_descriptions.rb b/vendor/plugins/rspec/lib/spec/matchers/generated_descriptions.rb new file mode 100644 index 000000000..2340f57d8 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/matchers/generated_descriptions.rb @@ -0,0 +1,36 @@ +module Spec + module Matchers + class << self + attr_accessor :last_matcher, :last_should # :nodoc: + end + + def self.clear_generated_description + self.last_matcher = nil + self.last_should = nil + end + + def self.generated_description + return nil if last_should.nil? + "#{last_should.to_s.gsub('_',' ')} #{last_description}" + end + + private + + def self.last_description + last_matcher.respond_to?(:description) ? last_matcher.description : <<-MESSAGE +When you call a matcher in an example without a String, like this: + +specify { object.should matcher } + +or this: + +it { should matcher } + +RSpec expects the matcher to have a #description method. You should either +add a String to the example this matcher is being used in, or give it a +description method. Then you won't have to suffer this lengthy warning again. +MESSAGE + end + end +end + diff --git a/vendor/plugins/rspec/lib/spec/matchers/match_array.rb b/vendor/plugins/rspec/lib/spec/matchers/match_array.rb new file mode 100644 index 000000000..51b4f3929 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/matchers/match_array.rb @@ -0,0 +1,71 @@ +module Spec + module Matchers + + class MatchArray #:nodoc: + include Spec::Matchers::Pretty + + def initialize(expected) + @expected = expected + end + + def matches?(actual) + @actual = actual + @extra_items = difference_between_arrays(@actual, @expected) + @missing_items = difference_between_arrays(@expected, @actual) + @extra_items.empty? & @missing_items.empty? + end + + def failure_message_for_should + message = "expected collection contained: #{safe_sort(@expected).inspect}\n" + message += "actual collection contained: #{safe_sort(@actual).inspect}\n" + message += "the missing elements were: #{safe_sort(@missing_items).inspect}\n" unless @missing_items.empty? + message += "the extra elements were: #{safe_sort(@extra_items).inspect}\n" unless @extra_items.empty? + message + end + + def failure_message_for_should_not + "Matcher does not support should_not" + end + + def description + "contain exactly #{_pretty_print(@expected)}" + end + + private + + def safe_sort(array) + array.all?{|item| item.respond_to?(:<=>)} ? array.sort : array + end + + def difference_between_arrays(array_1, array_2) + difference = array_1.dup + array_2.each do |element| + if index = difference.index(element) + difference.delete_at(index) + end + end + difference + end + + + end + + # :call-seq: + # should =~ expected + # + # Passes if actual contains all of the expected regardless of order. + # This works for collections. Pass in multiple args and it will only + # pass if all args are found in collection. + # + # NOTE: there is no should_not version of array.should =~ other_array + # + # == Examples + # + # [1,2,3].should =~ [1,2,3] # => would pass + # [1,2,3].should =~ [2,3,1] # => would pass + # [1,2,3,4].should =~ [1,2,3] # => would fail + # [1,2,2,3].should =~ [1,2,3] # => would fail + # [1,2,3].should =~ [1,2,3,4] # => would fail + OperatorMatcher.register(Array, '=~', Spec::Matchers::MatchArray) + end +end diff --git a/vendor/plugins/rspec/lib/spec/matchers/matcher.rb b/vendor/plugins/rspec/lib/spec/matchers/matcher.rb new file mode 100644 index 000000000..165ddffb5 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/matchers/matcher.rb @@ -0,0 +1,87 @@ +module Spec + module Matchers + class Matcher + include Spec::Matchers::InstanceExec + include Spec::Matchers::Pretty + include Spec::Matchers + + attr_reader :expected, :actual + + def initialize(name, *expected, &declarations) + @name = name + @expected = expected + @actual = nil + @diffable = false + @messages = { + :description => lambda {"#{name_to_sentence}#{expected_to_sentence}"}, + :failure_message_for_should => lambda {|actual| "expected #{actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"}, + :failure_message_for_should_not => lambda {|actual| "expected #{actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"} + } + making_declared_methods_public do + instance_exec(*@expected, &declarations) + end + end + + def matches?(actual) + instance_exec(@actual = actual, &@match_block) + end + + def description(&block) + cache_or_call_cached(:description, &block) + end + + def failure_message_for_should(&block) + cache_or_call_cached(:failure_message_for_should, actual, &block) + end + + def failure_message_for_should_not(&block) + cache_or_call_cached(:failure_message_for_should_not, actual, &block) + end + + def match(&block) + @match_block = block + end + + def diffable? + @diffable + end + + def diffable + @diffable = true + end + + private + + def making_declared_methods_public # :nodoc: + # Our home-grown instance_exec in ruby 1.8.6 results in any methods + # declared in the block eval'd by instance_exec in the block to which we + # are yielding here are scoped private. This is NOT the case for Ruby + # 1.8.7 or 1.9. + # + # Also, due some crazy scoping that I don't understand, these methods + # are actually available in the specs (something about the matcher being + # defined in the scope of Spec::Matchers or within an example), so not + # doing the following will not cause specs to fail, but they *will* + # cause features to fail and that will make users unhappy. So don't. + orig_private_methods = private_methods + yield + st = (class << self; self; end) + (private_methods - orig_private_methods).each {|m| st.__send__ :public, m} + end + + def cache_or_call_cached(key, actual=nil, &block) + block ? @messages[key] = block : + actual.nil? ? @messages[key].call : @messages[key].call(actual) + end + + def name_to_sentence + split_words(@name) + end + + def expected_to_sentence + to_sentence(@expected) + end + + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/matchers/method_missing.rb b/vendor/plugins/rspec/lib/spec/matchers/method_missing.rb new file mode 100644 index 000000000..ae7f39795 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/matchers/method_missing.rb @@ -0,0 +1,9 @@ +module Spec + module Matchers + def method_missing(sym, *args, &block) # :nodoc: + return Matchers::Be.new(sym, *args) if sym.to_s =~ /^be_/ + return Matchers::Has.new(sym, *args) if sym.to_s =~ /^have_/ + super + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/matchers/pretty.rb b/vendor/plugins/rspec/lib/spec/matchers/pretty.rb new file mode 100644 index 000000000..152058373 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/matchers/pretty.rb @@ -0,0 +1,37 @@ +module Spec + module Matchers + module Pretty + def split_words(sym) + sym.to_s.gsub(/_/,' ') + end + + def to_sentence(words) + words = words.map{|w| w.inspect} + case words.length + when 0 + "" + when 1 + " #{words[0]}" + when 2 + " #{words[0]} and #{words[1]}" + else + " #{words[0...-1].join(', ')}, and #{words[-1]}" + end + end + + def _pretty_print(array) + result = "" + array.each_with_index do |item, index| + if index < (array.length - 2) + result << "#{item.inspect}, " + elsif index < (array.length - 1) + result << "#{item.inspect} and " + else + result << "#{item.inspect}" + end + end + result + end + end + end +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/lib/spec/matchers/wrap_expectation.rb b/vendor/plugins/rspec/lib/spec/matchers/wrap_expectation.rb new file mode 100644 index 000000000..95162cae1 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/matchers/wrap_expectation.rb @@ -0,0 +1,55 @@ +module Spec + module Matchers + # wraps an expectation in a block that will return true if the + # expectation passes and false if it fails (without bubbling up + # the failure). + # + # This is intended to be used in the context of a simple matcher, + # and is especially useful for wrapping multiple expectations or + # one or more assertions from test/unit extensions when running + # with test/unit. + # + # == Examples + # + # def eat_cheese(cheese) + # simple_matcher do |mouse, matcher| + # matcher.failure_message = "expected #{mouse} to eat cheese" + # wrap_expectation do |matcher| + # assert_eats_cheese(mouse) + # end + # end + # end + # + # describe Mouse do + # it "eats cheese" do + # Mouse.new.should eat_cheese + # end + # end + # + # You might be wondering "why would I do this if I could just say" + # assert_eats_cheese?", a fair question, indeed. You might prefer + # to replace the word assert with something more aligned with the + # rest of your code examples. You are using rspec, after all. + # + # The other benefit you get is that you can use the negative version + # of the matcher: + # + # describe Cat do + # it "does not eat cheese" do + # Cat.new.should_not eat_cheese + # end + # end + # + # So in the event there is no assert_does_not_eat_cheese available, + # you're all set! + def wrap_expectation(matcher, &block) + begin + block.call(matcher) + return true + rescue Exception => e + matcher.failure_message = e.message + return false + end + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/mocks/argument_matchers.rb b/vendor/plugins/rspec/lib/spec/mocks/argument_matchers.rb new file mode 100644 index 000000000..f56551f21 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/mocks/argument_matchers.rb @@ -0,0 +1,237 @@ +module Spec + module Mocks + + # ArgumentMatchers are messages that you can include in message + # expectations to match arguments against a broader check than simple + # equality. + # + # With the exception of any_args() and no_args(), the matchers + # are all positional - they match against the arg in the given position. + module ArgumentMatchers + + class AnyArgsMatcher + def description + "any args" + end + end + + class NoArgsMatcher + def description + "no args" + end + end + + class AnyArgMatcher + def initialize(ignore) + end + + def ==(other) + true + end + + def description + "anything" + end + end + + class RegexpMatcher + def initialize(regexp) + @regexp = regexp + end + + def ==(value) + return value =~ @regexp unless value.is_a?(Regexp) + value == @regexp + end + end + + class BooleanMatcher + def initialize(ignore) + end + + def ==(value) + TrueClass === value || FalseClass === value + end + end + + class HashIncludingMatcher + def initialize(expected) + @expected = expected + end + + def ==(actual) + @expected.each do | key, value | + return false unless actual.has_key?(key) && value == actual[key] + end + true + rescue NoMethodError => ex + return false + end + + def description + "hash_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})" + end + end + + class HashNotIncludingMatcher + def initialize(expected) + @expected = expected + end + + def ==(actual) + @expected.each do | key, value | + return false if actual.has_key?(key) && value == actual[key] + end + true + rescue NoMethodError => ex + return false + end + + def description + "hash_not_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})" + end + end + + class DuckTypeMatcher + def initialize(*methods_to_respond_to) + @methods_to_respond_to = methods_to_respond_to + end + + def ==(value) + @methods_to_respond_to.all? { |sym| value.respond_to?(sym) } + end + end + + class MatcherMatcher + def initialize(matcher) + @matcher = matcher + end + + def ==(value) + @matcher.matches?(value) + end + end + + class EqualityProxy + def initialize(given) + @given = given + end + + def ==(expected) + @given == expected + end + end + + class InstanceOf + def initialize(klass) + @klass = klass + end + + def ==(actual) + actual.instance_of?(@klass) + end + end + + class KindOf + def initialize(klass) + @klass = klass + end + + def ==(actual) + actual.kind_of?(@klass) + end + end + + # :call-seq: + # object.should_receive(:message).with(no_args()) + # + # Passes if no arguments are passed along with the message + def no_args + NoArgsMatcher.new + end + + # :call-seq: + # object.should_receive(:message).with(any_args()) + # + # Passes if object receives :message with any args at all. This is + # really a more explicit variation of object.should_receive(:message) + def any_args + AnyArgsMatcher.new + end + + # :call-seq: + # object.should_receive(:message).with(anything()) + # + # Passes as long as there is an argument. + def anything + AnyArgMatcher.new(nil) + end + + # :call-seq: + # object.should_receive(:message).with(duck_type(:hello)) + # object.should_receive(:message).with(duck_type(:hello, :goodbye)) + # + # Passes if the argument responds to the specified messages. + # + # == Examples + # + # array = [] + # display = mock('display') + # display.should_receive(:present_names).with(duck_type(:length, :each)) + # => passes + def duck_type(*args) + DuckTypeMatcher.new(*args) + end + + # :call-seq: + # object.should_receive(:message).with(boolean()) + # + # Passes if the argument is boolean. + def boolean + BooleanMatcher.new(nil) + end + + # :call-seq: + # object.should_receive(:message).with(hash_including(:key => val)) + # object.should_receive(:message).with(hash_including(:key)) + # object.should_receive(:message).with(hash_including(:key, :key2 => val2)) + # Passes if the argument is a hash that includes the specified key(s) or key/value + # pairs. If the hash includes other keys, it will still pass. + def hash_including(*args) + HashIncludingMatcher.new(anythingize_lonely_keys(*args)) + end + + # :call-seq: + # object.should_receive(:message).with(hash_not_including(:key => val)) + # object.should_receive(:message).with(hash_not_including(:key)) + # object.should_receive(:message).with(hash_not_including(:key, :key2 => :val2)) + # + # Passes if the argument is a hash that doesn't include the specified key(s) or key/value + def hash_not_including(*args) + HashNotIncludingMatcher.new(anythingize_lonely_keys(*args)) + end + + # Passes if arg.instance_of?(klass) + def instance_of(klass) + InstanceOf.new(klass) + end + + alias_method :an_instance_of, :instance_of + + # Passes if arg.kind_of?(klass) + def kind_of(klass) + KindOf.new(klass) + end + + alias_method :a_kind_of, :kind_of + + private + + def anythingize_lonely_keys(*args) + hash = args.last.class == Hash ? args.delete_at(-1) : {} + args.each { | arg | hash[arg] = anything } + hash + end + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/mocks/example_methods.rb b/vendor/plugins/rspec/lib/spec/mocks/example_methods.rb new file mode 100644 index 000000000..f6c68ab6a --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/mocks/example_methods.rb @@ -0,0 +1,69 @@ +module Spec + module Mocks + module ExampleMethods + include Spec::Mocks::ArgumentMatchers + + # Shortcut for creating an instance of Spec::Mocks::Mock. + # + # +name+ is used for failure reporting, so you should use the + # role that the double is playing in the example. + # + # +stubs_and_options+ lets you assign options and stub values + # at the same time. The only option available is :null_object. + # Anything else is treated as a stub value. + # + # == Examples + # + # thing = double("thing", :a => "A") + # thing.a == "A" => true + # + # person = double("thing", :name => "Joe", :email => "joe@domain.com") + # person.name => "Joe" + # person.email => "joe@domain.com" + def double(*args) + __declare_double('Double', *args) + end + + # Alias for double + def mock(*args) + __declare_double('Mock', *args) + end + + # Alias for double + def stub(*args) + __declare_double('Stub', *args) + end + + def __declare_double(declared_as, *args) # :nodoc: + args << {} unless Hash === args.last + args.last[:__declared_as] = declared_as + Spec::Mocks::Mock.new(*args) + end + + # DEPRECATED - use double('name').as_null_object instead + # + # Shortcut for creating a mock object that will return itself in response + # to any message it receives that it hasn't been explicitly instructed + # to respond to. + def stub_everything(name = 'stub') + Spec.warn(<<-WARNING) + +DEPRECATION: stub_everything('#{name}') is deprecated and will be removed +from a future version of rspec. Please use double('#{name}').as_null_object +(or stub('#{name}').as_null_object or mock('#{name}').as_null_object instead. + +WARNING + mock(name, :null_object => true) + end + + # Disables warning messages about expectations being set on nil. + # + # By default warning messages are issued when expectations are set on nil. This is to + # prevent false-positives and to catch potential bugs early on. + def allow_message_expectations_on_nil + Proxy.allow_message_expectations_on_nil + end + + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/ruby.rb b/vendor/plugins/rspec/lib/spec/ruby.rb new file mode 100644 index 000000000..863877c7f --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/ruby.rb @@ -0,0 +1,9 @@ +module Spec + module Ruby + class << self + def version + RUBY_VERSION + end + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/runner/configuration.rb b/vendor/plugins/rspec/lib/spec/runner/configuration.rb new file mode 100644 index 000000000..d211565df --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/runner/configuration.rb @@ -0,0 +1,194 @@ +module Spec + module Runner + class Configuration + include Spec::Example::ArgsAndOptions + + # Chooses what mock framework to use. Example: + # + # Spec::Runner.configure do |config| + # config.mock_with :rspec, :mocha, :flexmock, or :rr + # end + # + # To use any other mock framework, you'll have to provide your own + # adapter. This is simply a module that responds to the following + # methods: + # + # setup_mocks_for_rspec + # verify_mocks_for_rspec + # teardown_mocks_for_rspec. + # + # These are your hooks into the lifecycle of a given example. RSpec will + # call setup_mocks_for_rspec before running anything else in each + # Example. After executing the #after methods, RSpec will then call + # verify_mocks_for_rspec and teardown_mocks_for_rspec (this is + # guaranteed to run even if there are failures in + # verify_mocks_for_rspec). + # + # Once you've defined this module, you can pass that to mock_with: + # + # Spec::Runner.configure do |config| + # config.mock_with MyMockFrameworkAdapter + # end + # + def mock_with(mock_framework) + @mock_framework = case mock_framework + when Symbol + mock_framework_path(mock_framework.to_s) + else + mock_framework + end + end + + def mock_framework # :nodoc: + @mock_framework ||= mock_framework_path("rspec") + end + + # :call-seq: + # include(Some::Helpers) + # include(Some::Helpers, More::Helpers) + # include(My::Helpers, :type => :key) + # + # Declares modules to be included in multiple example groups + # (<tt>describe</tt> blocks). With no <tt>:type</tt>, the modules listed + # will be included in all example groups. + # + # Use <tt>:type</tt> to restrict + # the inclusion to a subset of example groups. The value assigned to + # <tt>:type</tt> should be a key that maps to a class that is either a + # subclass of Spec::Example::ExampleGroup or extends + # Spec::Example::ExampleGroupMethods and includes + # Spec::Example::ExampleMethods. + # + # For example, the rspec-rails gem/plugin extends Test::Unit::TestCase + # with Spec::Example::ExampleGroupMethods and includes + # Spec::Example::ExampleMethods in it. So if you have a module of helper + # methods for controller examples, you could do this: + # + # config.include(ControllerExampleHelpers, :type => :controller) + # + # Only example groups that have that type will get the modules included: + # + # describe Account, :type => :model do + # # Will *not* include ControllerExampleHelpers + # end + # + # describe AccountsController, :type => :controller do + # # *Will* include ControllerExampleHelpers + # end + # + def include(*modules_and_options) + include_or_extend(:include, *modules_and_options) + end + + # :call-seq: + # extend(Some::Helpers) + # extend(Some::Helpers, More::Helpers) + # extend(My::Helpers, :type => :key) + # + # Works just like #include, but extends the example groups + # with the modules rather than including them. + def extend(*modules_and_options) + include_or_extend(:extend, *modules_and_options) + end + + # Appends a global <tt>before</tt> block to all example groups. + # <tt>scope</tt> can be any of <tt>:each</tt> (default), <tt>:all</tt>, or + # <tt>:suite</tt>. When <tt>:each</tt>, the block is executed before each + # example. When <tt>:all</tt>, the block is executed once per example + # group, before any of its examples are run. When <tt>:suite</tt> the + # block is run once before the entire suite is run. + def append_before(scope = :each, options={}, &proc) + add_callback(:append_before, scope, options, &proc) + end + alias_method :before, :append_before + + # Prepends a global <tt>before</tt> block to all example groups. + # + # See <tt>append_before</tt> for scoping semantics. + def prepend_before(scope = :each, options={}, &proc) + add_callback(:prepend_before, scope, options, &proc) + end + + # Prepends a global <tt>after</tt> block to all example groups. + # + # See <tt>append_before</tt> for scoping semantics. + def prepend_after(scope = :each, options={}, &proc) + add_callback(:prepend_after, scope, options, &proc) + end + alias_method :after, :prepend_after + + # Appends a global <tt>after</tt> block to all example groups. + # + # See <tt>append_before</tt> for scoping semantics. + def append_after(scope = :each, options={}, &proc) + add_callback(:append_after, scope, options, &proc) + end + + # DEPRECATED - use Spec::Matchers::DSL instead + # + # Defines global predicate matchers. Example: + # + # config.predicate_matchers[:swim] = :can_swim? + # + # This makes it possible to say: + # + # person.should swim # passes if person.can_swim? returns true + # + def predicate_matchers + @predicate_matchers ||= Spec::HashWithDeprecationNotice.new("predicate_matchers", "the new Matcher DSL") + end + + # Adds patterns to the list of patterns ignored in the backtrace when a + # failure is output by rspec. Example: + # + # config.ignore_backtrace_patterns /spork/, /shoulda/, "/some/weird/path/" + # + # When quiet backtraces are turned on (default), this will exclude any + # lines that match any of the Regexps and Strings passed. + # + def ignore_backtrace_patterns(*patterns) + @ignored_backtrace_patterns ||= [] + @ignored_backtrace_patterns += patterns + end + + def ignored_backtrace_patterns # :nodoc: + @ignored_backtrace_patterns ||= [] + end + + private + + def include_or_extend(action, *args) + modules, options = args_and_options(*args) + [get_type_from_options(options)].flatten.each do |required_example_group| + required_example_group = required_example_group.to_sym if required_example_group + modules.each do |mod| + Spec::Example::ExampleGroupFactory[required_example_group].__send__(action, mod) + end + end + end + + def add_callback(sym, *args, &proc) + scope, options = scope_and_options(*args) + example_group = Spec::Example::ExampleGroupFactory[get_type_from_options(options)] + example_group.__send__(sym, scope, &proc) + end + + def get_type_from_options(options) + options[:type] || options[:behaviour_type] + end + + def mock_framework_path(framework_name) + "spec/adapters/mock_frameworks/#{framework_name}" + end + + def scope_and_options(*args) # :nodoc: + args, options = args_and_options(*args) + return scope_from(*args), options + end + + def scope_from(*args) # :nodoc: + args[0] || :each + end + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/runner/differs/default.rb b/vendor/plugins/rspec/lib/spec/runner/differs/default.rb new file mode 100644 index 000000000..7f0a7e648 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/runner/differs/default.rb @@ -0,0 +1,93 @@ +require 'spec/runner/differs/load-diff-lcs' +require 'pp' + +module Spec + module Expectations + module Differs + unless defined?(Default) + class Default + def initialize(options) + @options = options + end + + # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool) + def diff_as_string(data_new, data_old) + data_old = data_old.split(/\n/).map! { |e| e.chomp } + data_new = data_new.split(/\n/).map! { |e| e.chomp } + output = "" + diffs = Diff::LCS.diff(data_old, data_new) + return output if diffs.empty? + oldhunk = hunk = nil + file_length_difference = 0 + diffs.each do |piece| + begin + hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, context_lines, + file_length_difference) + file_length_difference = hunk.file_length_difference + next unless oldhunk + # Hunks may overlap, which is why we need to be careful when our + # diff includes lines of context. Otherwise, we might print + # redundant lines. + if (context_lines > 0) and hunk.overlaps?(oldhunk) + hunk.unshift(oldhunk) + else + output << oldhunk.diff(format) + end + ensure + oldhunk = hunk + output << "\n" + end + end + #Handle the last remaining hunk + output << oldhunk.diff(format) << "\n" + end + + def diff_as_object(target,expected) + diff_as_string(PP.pp(target,""), PP.pp(expected,"")) + end + + def diff_as_hash(target, expected) + contains_hash = false + contains_array = false + + extra_expected_keys = expected.keys - target.keys + extra_target_keys = target.keys - expected.keys + + o = "\n" + + o << "Expected hash contains keys that target hash does not: " << extra_expected_keys.inspect << "\n" if !extra_expected_keys.empty? + o << "Target hash contains keys that expected hash does not: " << extra_target_keys.inspect << "\n" if !extra_target_keys.empty? + + expected.delete_if do |key, value| + contains_hash = true if value.is_a?(Hash) + contains_array = true if value.is_a?(Array) + target[key] == value + end + + expected.keys.sort { |a,b| a.to_s <=> b.to_s }.each do |key| + o << "Expected the key #{key.inspect} to be #{expected[key].inspect}, but was #{target[key].inspect}\n" + end + + o << "\n" + + if contains_hash || contains_array + o << diff_as_object(target, expected) + else + o + end + end + + protected + def format + @options.diff_format + end + + def context_lines + @options.context_lines + end + end + + end + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/runner/differs/load-diff-lcs.rb b/vendor/plugins/rspec/lib/spec/runner/differs/load-diff-lcs.rb new file mode 100644 index 000000000..f708bc9b4 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/runner/differs/load-diff-lcs.rb @@ -0,0 +1,12 @@ +begin + require 'diff/lcs' +rescue LoadError + begin + require 'rubygems' unless ENV['NO_RUBYGEMS'] + require 'diff/lcs' + rescue LoadError + raise "You must gem install diff-lcs to use diffing" + end +end + +require 'diff/lcs/hunk' diff --git a/vendor/plugins/rspec/lib/spec/runner/extensions/kernel.rb b/vendor/plugins/rspec/lib/spec/runner/extensions/kernel.rb new file mode 100644 index 000000000..4e23cdf22 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/runner/extensions/kernel.rb @@ -0,0 +1,9 @@ +module Kernel + unless respond_to?(:debugger) + # Start a debugging session if ruby-debug is loaded with the -u/--debugger option + def debugger(steps=1) + # If not then just comment and proceed + $stderr.puts "debugger statement ignored, use -u or --debugger option on rspec to enable debugging" + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/runner/formatter/no_op_method_missing.rb b/vendor/plugins/rspec/lib/spec/runner/formatter/no_op_method_missing.rb new file mode 100644 index 000000000..350e29f73 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/runner/formatter/no_op_method_missing.rb @@ -0,0 +1,21 @@ +module Spec + module Runner + module Formatter + module NOOPMethodMissing + def respond_to?(message, include_private = false) + if include_private + true + else + !private_methods.any? {|m| [message.to_s, message.to_sym].include?(m)} + end + end + + private + + def method_missing(sym, *args) + # a no-op + end + end + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/runner/formatter/silent_formatter.rb b/vendor/plugins/rspec/lib/spec/runner/formatter/silent_formatter.rb new file mode 100644 index 000000000..43cce33bb --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/runner/formatter/silent_formatter.rb @@ -0,0 +1,10 @@ +require 'spec/runner/formatter/base_formatter' + +module Spec + module Runner + module Formatter + class SilentFormatter < BaseFormatter + end + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/runner/line_number_query.rb b/vendor/plugins/rspec/lib/spec/runner/line_number_query.rb new file mode 100644 index 000000000..0a907d3fe --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/runner/line_number_query.rb @@ -0,0 +1,78 @@ +module Spec + module Runner + # Parses a spec file and finds the nearest example for a given line number. + class LineNumberQuery + attr_reader :best_match + + def initialize(run_options) + @best_match = {} + @run_options = run_options + end + + def spec_name_for(file, line_number) + best_match.clear + file = File.expand_path(file) + determine_best_match(file, line_number) + if best_match[:example_group] + if best_match[:example] + "#{best_match[:example_group].description} #{best_match[:example].description}" + else + best_match[:example_group].description + end + else + nil + end + end + + def example_line_for(file, line_number) + determine_best_match(file, line_number) + best_match[:line] + end + + protected + + def determine_best_match(file, line_number) + best_match.clear + file = File.expand_path(file) + @run_options.example_groups.each do |example_group| + next unless example_group.location + consider_example_group_for_best_match(example_group, file, line_number) + + example_group.examples.each do |example| + consider_example_for_best_match(example, example_group, file, line_number) + end + end + end + + def consider_example_group_for_best_match(example_group, file, line_number) + example_group_file, example_group_line = parse_location(example_group.location) + if is_best_match?(file, line_number, example_group_file, example_group_line) + best_match.clear + best_match[:example_group] = example_group + best_match[:line] = example_group_line + end + end + + def consider_example_for_best_match(example, example_group, file, line_number) + example_file, example_line = parse_location(example.location) + if is_best_match?(file, line_number, example_file, example_line) + best_match.clear + best_match[:example_group] = example_group + best_match[:example] = example + best_match[:line] = example_line + end + end + + def is_best_match?(file, line_number, example_file, example_line) + file == File.expand_path(example_file) && + example_line <= line_number && + example_line > best_match[:line].to_i + end + + def parse_location(location) + location =~ /(.*)\:(\d*)(\:|$)/ + return $1, Integer($2) + end + end + end +end diff --git a/vendor/plugins/rspec/lib/spec/stubs/cucumber.rb b/vendor/plugins/rspec/lib/spec/stubs/cucumber.rb new file mode 100644 index 000000000..b801ef442 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/stubs/cucumber.rb @@ -0,0 +1,5 @@ +# This plugs RSpec's mocking/stubbing framework into cucumber +require 'spec/mocks' +Before {$rspec_stubs ||= Spec::Mocks::Space.new} +After {$rspec_stubs.reset_all} +World(Spec::Mocks::ExampleMethods) diff --git a/vendor/plugins/rspec/lib/spec/test/unit.rb b/vendor/plugins/rspec/lib/spec/test/unit.rb new file mode 100644 index 000000000..fb4eb4932 --- /dev/null +++ b/vendor/plugins/rspec/lib/spec/test/unit.rb @@ -0,0 +1,10 @@ +require 'spec/interop/test' + +# Hack to stop active_support/dependencies from complaining about +# 'spec/test/unit' not defining Spec::Test::Unit +module Spec + module Test + module Unit + end + end +end diff --git a/vendor/plugins/rspec/resources/helpers/cmdline.rb b/vendor/plugins/rspec/resources/helpers/cmdline.rb new file mode 100644 index 000000000..0e337579b --- /dev/null +++ b/vendor/plugins/rspec/resources/helpers/cmdline.rb @@ -0,0 +1,8 @@ +require 'spec' + +# Uncommenting next line will break the output feature (no output!!) +# rspec_options +options = Spec::Runner::OptionParser.parse( + ARGV, $stderr, $stdout +) +Spec::Runner::CommandLine.run(options) diff --git a/vendor/plugins/rspec/resources/rake/examples.rake b/vendor/plugins/rspec/resources/rake/examples.rake new file mode 100644 index 000000000..32d0ad0e6 --- /dev/null +++ b/vendor/plugins/rspec/resources/rake/examples.rake @@ -0,0 +1,7 @@ +require 'rake' +require 'spec/rake/spectask' + +desc "Run all examples" +Spec::Rake::SpecTask.new('examples') do |t| + t.spec_files = FileList['examples/**/*.rb'] +end diff --git a/vendor/plugins/rspec/resources/rake/examples_with_rcov.rake b/vendor/plugins/rspec/resources/rake/examples_with_rcov.rake new file mode 100644 index 000000000..4bf35c6b8 --- /dev/null +++ b/vendor/plugins/rspec/resources/rake/examples_with_rcov.rake @@ -0,0 +1,9 @@ +require 'rake' +require 'spec/rake/spectask' + +desc "Run all examples with RCov" +Spec::Rake::SpecTask.new('examples_with_rcov') do |t| + t.spec_files = FileList['examples/**/*.rb'] + t.rcov = true + t.rcov_opts = ['--exclude', 'examples'] +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/resources/rake/failing_examples_with_html.rake b/vendor/plugins/rspec/resources/rake/failing_examples_with_html.rake new file mode 100644 index 000000000..6e53551f3 --- /dev/null +++ b/vendor/plugins/rspec/resources/rake/failing_examples_with_html.rake @@ -0,0 +1,9 @@ +require 'rake' +require 'spec/rake/spectask' + +desc "Generate HTML report for failing examples" +Spec::Rake::SpecTask.new('failing_examples_with_html') do |t| + t.spec_files = FileList['failing_examples/**/*.rb'] + t.spec_opts = ["--format", "html:doc/reports/tools/failing_examples.html", "--diff"] + t.fail_on_error = false +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/resources/rake/verify_rcov.rake b/vendor/plugins/rspec/resources/rake/verify_rcov.rake new file mode 100644 index 000000000..a2fab00bc --- /dev/null +++ b/vendor/plugins/rspec/resources/rake/verify_rcov.rake @@ -0,0 +1,7 @@ +require 'rake' +require 'spec/rake/verify_rcov' + +RCov::VerifyTask.new(:verify_rcov => 'spec:rcov') do |t| + t.threshold = 100.0 + t.index_html = 'coverage/index.html' +end diff --git a/vendor/plugins/rspec/spec/autotest/autotest_helper.rb b/vendor/plugins/rspec/spec/autotest/autotest_helper.rb new file mode 100644 index 000000000..b7b873d9f --- /dev/null +++ b/vendor/plugins/rspec/spec/autotest/autotest_helper.rb @@ -0,0 +1,8 @@ +require 'spec_helper' +begin + require 'autotest' +rescue LoadError + raise "You must install ZenTest to use autotest" +end +require 'autotest/rspec' +require 'spec/autotest/autotest_matchers' diff --git a/vendor/plugins/rspec/spec/autotest/autotest_matchers.rb b/vendor/plugins/rspec/spec/autotest/autotest_matchers.rb new file mode 100644 index 000000000..2bfca4ac3 --- /dev/null +++ b/vendor/plugins/rspec/spec/autotest/autotest_matchers.rb @@ -0,0 +1,38 @@ +module Spec + module Matchers + class AutotestMappingMatcher + def initialize(specs) + @specs = specs + end + + def to(file) + @file = file + self + end + + def matches?(autotest) + @autotest = prepare(autotest) + @actual = autotest.test_files_for(@file) + @actual == @specs + end + + def failure_message + "expected #{@autotest.class} to map #{@specs.inspect} to #{@file.inspect}\ngot #{@actual.inspect}" + end + + private + + def prepare(autotest) + find_order = @specs.dup << @file + autotest.instance_eval { @find_order = find_order } + autotest + end + + end + + def map_specs(specs) + AutotestMappingMatcher.new(specs) + end + + end +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/spec/autotest/failed_results_re_spec.rb b/vendor/plugins/rspec/spec/autotest/failed_results_re_spec.rb new file mode 100644 index 000000000..f4a1488e8 --- /dev/null +++ b/vendor/plugins/rspec/spec/autotest/failed_results_re_spec.rb @@ -0,0 +1,31 @@ +require 'spec/autotest/autotest_helper' + +describe "failed_results_re" do + it "should match a failure" do + re = Autotest::Rspec.new.failed_results_re + re =~ "1)\n'this example' FAILED\nreason\n/path.rb:37:\n\n" + $1.should == "this example" + $2.should == "reason\n/path.rb:37:" + end + + it "should match a failure when matcher outputs multiple lines" do + re = Autotest::Rspec.new.failed_results_re + re =~ "1)\n'other example' FAILED\n\nreason line 1\nreason line 2\n\n(additional info)\n/path.rb:37:\n\n" + $1.should == "other example" + $2.should == "reason line 1\nreason line 2\n\n(additional info)\n/path.rb:37:" + end + + it "should match an Error" do + re = Autotest::Rspec.new.failed_results_re + re =~ "1)\nRuntimeError in 'this example'\nreason\n/path.rb:37:\n\n" + $1.should == "this example" + $2.should == "reason\n/path.rb:37:" + end + + it "should match an Error that doesn't end in Error" do + re = Autotest::Rspec.new.failed_results_re + re =~ "1)\nInvalidArgument in 'this example'\nreason\n/path.rb:37:\n\n" + $1.should == "this example" + $2.should == "reason\n/path.rb:37:" + end +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/spec/spec/dsl/main_spec.rb b/vendor/plugins/rspec/spec/spec/dsl/main_spec.rb new file mode 100644 index 000000000..752b07f88 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/dsl/main_spec.rb @@ -0,0 +1,95 @@ +require 'spec_helper' + +module Spec + module DSL + describe Main do + before(:each) do + @main = Class.new do; include Spec::DSL::Main; end + end + + [:describe, :context].each do |method| + describe "##{method}" do + it "should delegate to Spec::Example::ExampleGroupFactory.create_example_group" do + block = lambda {|a,b|} + Spec::Example::ExampleGroupFactory.should_receive(:create_example_group).with( + "The ExampleGroup", hash_including(:location), &block + ) + @main.__send__ method, "The ExampleGroup", &block + end + + it "raises with no description" do + block = lambda {|a,b|} + lambda do + @main.__send__ method, &block + end.should raise_error(ArgumentError, /No description supplied for example group declared on #{__FILE__}:#{__LINE__ - 1}/) + end + end + end + + [:share_examples_for, :shared_examples_for].each do |method| + describe "##{method}" do + it "should create a shared ExampleGroup" do + block = lambda {|a,b|} + Spec::Example::ExampleGroupFactory.should_receive(:create_shared_example_group).with( + "shared group", hash_including(:location), &block + ) + @main.__send__ method, "shared group", &block + end + end + end + + describe "#describe; with RUBY_VERSION = 1.9" do + it "includes an enclosing module into the block's scope" do + Spec::Ruby.stub!(:version).and_return("1.9") + + module Foo; module Bar; end; end + + Foo::Bar.should_receive(:included).with do |*args| + included_by = args.last + included_by.description.should == "this example group" + end + + module Foo + module Bar + describe("this example group") do; end + end + end + end + end + + + describe "#share_as" do + def self.next_group_name + @group_number ||= 0 + @group_number += 1 + "Group#{@group_number}" + end + + def group_name + @group_name ||= self.class.next_group_name + end + + it "registers a shared ExampleGroup" do + block = lambda {|a,b|} + Spec::Example::ExampleGroupFactory.should_receive(:create_shared_example_group).with( + group_name, hash_including(:location), &block + ) + @main.share_as group_name, &block + end + + it "creates a constant that points to a Module" do + group = @main.share_as group_name do end + Object.const_get(group_name).should equal(group) + end + + it "complains if you pass it a not-constantizable name" do + lambda do + @group = @main.share_as "Non Constant" do end + end.should raise_error(NameError, /The first argument to share_as must be a legal name for a constant/) + end + + end + end + end +end +
\ No newline at end of file diff --git a/vendor/plugins/rspec/spec/spec/example/example_group_proxy_spec.rb b/vendor/plugins/rspec/spec/spec/example/example_group_proxy_spec.rb new file mode 100644 index 000000000..6af4ef181 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/example/example_group_proxy_spec.rb @@ -0,0 +1,107 @@ +require 'spec_helper' + +module Spec + module Example + describe ExampleGroupProxy do + before(:each) do + @group = stub("example group").as_null_object + end + + attr_reader :group + def proxy + @proxy ||= ExampleGroupProxy.new(@group) + end + + describe "#description" do + it "provides the example group's description" do + group.stub!(:description => "the description") + proxy.description.should == "the description" + end + end + + describe "#nested_descriptions" do + it "provides the example group's nested_descriptions" do + group.stub!(:nested_descriptions => ["the description"]) + proxy.nested_descriptions.should == ["the description"] + end + end + + describe "#filtered_description (DEPRECATED)" do + before(:each) do + Spec.stub!(:deprecate) + end + + it "is deprecated" do + Spec.should_receive(:deprecate) + proxy.filtered_description(/(ignore)/) + end + + it "builds the description from the group's nested_descriptions" do + group.stub!(:nested_descriptions => ["ignore","the","description"]) + proxy.filtered_description(/(ignore)/).should == "the description" + end + + it "filters out description parts that match the supplied regexp" do + group.stub!(:nested_descriptions => ["ignore the","description"]) + proxy.filtered_description(/(ignore )/).should == "the description" + end + end + + describe "#examples" do + it "provides a collection of example group proxies" do + group.stub!(:example_proxies => ["array","of","proxies"]) + proxy.examples.should == ["array","of","proxies"] + end + end + + describe "#backtrace (deprecated - use #location)" do + before(:each) do + Spec.stub!(:deprecate) + end + + it "provides the location of the declaration of this group" do + group.stub!(:location => "path/to/location:37") + proxy.backtrace.should == "path/to/location:37" + end + + it "warns deprecation" do + Spec.should_receive(:deprecate) + group.stub!(:location => "path/to/location:37") + proxy.backtrace + end + end + + describe "#location" do + it "provides the location of the declaration of this group" do + group.stub!(:location => "path/to/location:37") + proxy.location.should == "path/to/location:37" + end + end + + describe "#options" do + it "provides the options passed to the example group declaration" do + group.stub!(:options => {:a => 'b'}) + proxy.options.should == {:a => 'b'} + end + + it "excludes :location" do + group.stub!(:options => {:location => 'b'}) + proxy.options.should == {} + end + + it "excludes :scope" do + group.stub!(:options => {:scope => 'b'}) + proxy.options.should == {} + end + + it "preserves the original hash" do + hash = {:a => 'b', :location => 'here', :scope => 'tiny'} + group.stub!(:options => hash) + proxy.options.should == {:a => 'b'} + hash.should == {:a => 'b', :location => 'here', :scope => 'tiny'} + end + end + + end + end +end diff --git a/vendor/plugins/rspec/spec/spec/example/example_proxy_spec.rb b/vendor/plugins/rspec/spec/spec/example/example_proxy_spec.rb new file mode 100644 index 000000000..de845c9e2 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/example/example_proxy_spec.rb @@ -0,0 +1,57 @@ +require 'spec_helper' + +module Spec + module Example + + describe ExampleProxy do + + describe "#description" do + it "provides the submitted description" do + proxy = ExampleProxy.new("the description") + proxy.description.should == "the description" + end + end + + describe "#update" do + it "updates the description" do + proxy = ExampleProxy.new("old description") + proxy.update("new description") + proxy.description.should == "new description" + end + end + + describe "#options" do + it "provides the submitted options" do + proxy = ExampleProxy.new(:ignore, {:these => :options}) + proxy.options.should == {:these => :options} + end + end + + describe "#backtrace (DEPRECATED - use #location)" do + before(:each) do + Spec.stub!(:deprecate) + end + + it "is deprecated" do + Spec.should_receive(:deprecate) + proxy = ExampleProxy.new(:ignore, {}, "path/to/location:37") + proxy.backtrace + end + + it "provides the location of the declaration of this group" do + proxy = ExampleProxy.new(:ignore, {}, "path/to/location:37") + proxy.backtrace.should == "path/to/location:37" + end + end + + describe "#location" do + it "provides the location of the declaration of this group" do + proxy = ExampleProxy.new(:ignore, {}, "path/to/location:37") + proxy.location.should == "path/to/location:37" + end + end + + end + + end +end diff --git a/vendor/plugins/rspec/spec/spec/example/helper_method_spec.rb b/vendor/plugins/rspec/spec/spec/example/helper_method_spec.rb new file mode 100644 index 000000000..3653aec71 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/example/helper_method_spec.rb @@ -0,0 +1,24 @@ +require 'spec_helper' + +# This was added to prove that http://rspec.lighthouseapp.com/projects/5645/tickets/211 +# was fixed in ruby 1.9.1 + +module HelperMethodExample + describe "a helper method" do + def helper_method + "received call" + end + + it "is available to examples in the same group" do + helper_method.should == "received call" + end + + describe "from a nested group" do + it "is available to examples in a nested group" do + helper_method.should == "received call" + end + end + + end +end + diff --git a/vendor/plugins/rspec/spec/spec/example/subject_spec.rb b/vendor/plugins/rspec/spec/spec/example/subject_spec.rb new file mode 100644 index 000000000..c0e4fd800 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/example/subject_spec.rb @@ -0,0 +1,103 @@ +require 'spec_helper' + +module Spec + module Example + describe "implicit subject" do + describe "with a class" do + it "returns an instance of the class" do + group = Class.new(ExampleGroupDouble).describe(Array) + example = group.new(ExampleProxy.new) + example.subject.should == [] + end + end + + describe "with a Module" do + it "returns the Module" do + group = Class.new(ExampleGroupDouble).describe(Enumerable) + example = group.new(ExampleProxy.new) + example.subject.should == Enumerable + end + end + + describe "with a string" do + it "return the string" do + group = Class.new(ExampleGroupDouble).describe('foo') + example = group.new(ExampleProxy.new) + example.subject.should == 'foo' + end + end + + describe "with a number" do + it "returns the number" do + group = Class.new(ExampleGroupDouble).describe(15) + example = group.new(ExampleProxy.new) + example.subject.should == 15 + end + end + + end + + describe "explicit subject" do + describe "defined in a top level group" do + it "replaces the implicit subject in that group" do + group = Class.new(ExampleGroupDouble).describe(Array) + group.subject { [1,2,3] } + example = group.new(ExampleProxy.new) + example.subject.should == [1,2,3] + end + end + + describe "defined in a top level group" do + before(:each) do + @group = Class.new do + extend Spec::Example::Subject::ExampleGroupMethods + include Spec::Example::Subject::ExampleMethods + class << self + def described_class + Array + end + end + def described_class + self.class.described_class + end + + subject { + [1,2,3] + } + end + end + + it "is available in a nested group (subclass)" do + nested_group = Class.new(@group) + + example = nested_group.new + example.subject.should == [1,2,3] + end + + it "is available in a doubly nested group (subclass)" do + nested_group = Class.new(@group) + doubly_nested_group = Class.new(nested_group) + + example = doubly_nested_group.new + example.subject.should == [1,2,3] + end + end + end + + describe ".its (to access subject's attributes)" do + with_sandboxed_options do + it "passes when expectation should pass" do + group = Class.new(ExampleGroupDouble).describe(Array) + child = group.its(:length) { should == 0 } + child.run(options).should == true + end + + it "fails when expectation should fail" do + group = Class.new(ExampleGroupDouble).describe(Array) + child = group.its(:length) { should == 1 } + child.run(options).should == false + end + end + end + end +end diff --git a/vendor/plugins/rspec/spec/spec/expectations/extensions/kernel_spec.rb b/vendor/plugins/rspec/spec/spec/expectations/extensions/kernel_spec.rb new file mode 100644 index 000000000..9a0ed3ce5 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/expectations/extensions/kernel_spec.rb @@ -0,0 +1,45 @@ +require 'spec_helper' + +describe Object, "#should" do + before(:each) do + @target = "target" + @matcher = mock("matcher") + @matcher.stub!(:matches?).and_return(true) + @matcher.stub!(:failure_message_for_should) + end + + it "accepts and interacts with a matcher" do + @matcher.should_receive(:matches?).with(@target).and_return(true) + @target.should @matcher + end + + it "asks for a failure_message_for_should when matches? returns false" do + @matcher.should_receive(:matches?).with(@target).and_return(false) + @matcher.should_receive(:failure_message_for_should).and_return("the failure message") + lambda { + @target.should @matcher + }.should fail_with("the failure message") + end +end + +describe Object, "#should_not" do + before(:each) do + @target = "target" + @matcher = mock("matcher") + end + + it "accepts and interacts with a matcher" do + @matcher.should_receive(:matches?).with(@target).and_return(false) + @matcher.stub!(:failure_message_for_should_not) + + @target.should_not @matcher + end + + it "asks for a failure_message_for_should_not when matches? returns true" do + @matcher.should_receive(:matches?).with(@target).and_return(true) + @matcher.should_receive(:failure_message_for_should_not).and_return("the failure message for should not") + lambda { + @target.should_not @matcher + }.should fail_with("the failure message for should not") + end +end diff --git a/vendor/plugins/rspec/spec/spec/expectations/handler_spec.rb b/vendor/plugins/rspec/spec/spec/expectations/handler_spec.rb new file mode 100644 index 000000000..e7d6a6ed1 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/expectations/handler_spec.rb @@ -0,0 +1,206 @@ +require 'spec_helper' + +module ExampleExpectations + + class ArbitraryMatcher + def initialize(*args, &block) + if args.last.is_a? Hash + @expected = args.last[:expected] + end + @expected = block.call if block + @block = block + end + + def matches?(target) + @target = target + return @expected == target + end + + def with(new_value) + @expected = new_value + self + end + + def failure_message + "expected #{@expected}, got #{@target}" + end + + def negative_failure_message + "expected not #{@expected}, got #{@target}" + end + end + + class PositiveOnlyMatcher < ArbitraryMatcher + undef negative_failure_message rescue nil + end + + def arbitrary_matcher(*args, &block) + ArbitraryMatcher.new(*args, &block) + end + + def positive_only_matcher(*args, &block) + PositiveOnlyMatcher.new(*args, &block) + end + +end + +module Spec + module Expectations + describe PositiveExpectationHandler do + describe "#handle_matcher" do + it "asks the matcher if it matches" do + matcher = mock("matcher") + actual = Object.new + matcher.should_receive(:matches?).with(actual).and_return(true) + Spec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher) + end + + it "returns the match value" do + matcher = mock("matcher") + actual = Object.new + matcher.should_receive(:matches?).with(actual).and_return(:this_value) + Spec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher).should == :this_value + end + + it "calls failure_message_for_should if the matcher implements it" do + matcher = mock("matcher", :failure_message_for_should => "message", :matches? => false) + actual = Object.new + + ::Spec::Expectations.should_receive(:fail_with).with("message") + + Spec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher) + end + + it "calls fail if matcher.diffable?" do + matcher = mock("matcher", + :diffable? => true, + :failure_message_for_should => "message", + :matches? => false, + :expected => [1], + :actual => 2 + ) + actual = Object.new + + ::Spec::Expectations.should_receive(:fail_with).with("message", 1, 2) + + Spec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher) + end + + it "calls failure_message if the matcher does not implement failure_message_for_should" do + matcher = mock("matcher", :failure_message => "message", :matches? => false) + actual = Object.new + + ::Spec::Expectations.should_receive(:fail_with).with("message") + + Spec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher) + + end + + it "appends the :or message in the options hash passed to should" do + matcher = mock("matcher", :failure_message_for_should => "message", :matches? => false) + actual = Object.new + + ::Spec::Expectations.should_receive(:fail_with).with("custom") + + Spec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher, "custom") + end + end + end + + describe NegativeExpectationHandler do + describe "#handle_matcher" do + it "asks the matcher if it doesn't match when the matcher responds to #does_not_match?" do + matcher = mock("matcher", :does_not_match? => true, :negative_failure_message => nil) + actual = Object.new + matcher.should_receive(:does_not_match?).with(actual).and_return(true) + Spec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher) + end + + it "asks the matcher if it matches when the matcher doesn't respond to #does_not_match?" do + matcher = mock("matcher") + actual = Object.new + matcher.stub!(:negative_failure_message) + matcher.should_receive(:matches?).with(actual).and_return(false) + Spec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher) + end + + it "returns the match value" do + matcher = mock("matcher") + actual = Object.new + matcher.should_receive(:matches?).with(actual).and_return(false) + matcher.stub!(:negative_failure_message).and_return("ignore") + Spec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher).should be_false + end + + + it "calls failure_message_for_should_not if the matcher implements it" do + matcher = mock("matcher", :failure_message_for_should_not => "message", :matches? => true) + actual = Object.new + + ::Spec::Expectations.should_receive(:fail_with).with("message") + + Spec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher) + + end + + it "calls negative_failure_message if the matcher does not implement failure_message_for_should_not" do + matcher = mock("matcher", :negative_failure_message => "message", :matches? => true) + actual = Object.new + + ::Spec::Expectations.should_receive(:fail_with).with("message") + + Spec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher) + + end + + + it "calls fail if matcher.diffable?" do + matcher = mock("matcher", + :diffable? => true, + :failure_message_for_should_not => "message", + :matches? => true, + :expected => [1], + :actual => 2 + ) + actual = Object.new + + ::Spec::Expectations.should_receive(:fail_with).with("message", 1, 2) + + Spec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher) + end + + it "appends the :or message in the options hash passed to should" do + matcher = mock("matcher", :failure_message_for_should_not => "message", :matches? => true) + actual = Object.new + + ::Spec::Expectations.should_receive(:fail_with).with("custom") + + Spec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher, "custom") + end + + end + end + + describe PositiveExpectationHandler do + include ExampleExpectations + + it "should handle submitted args" do + 5.should arbitrary_matcher(:expected => 5) + 5.should arbitrary_matcher(:expected => "wrong").with(5) + lambda { 5.should arbitrary_matcher(:expected => 4) }.should fail_with("expected 4, got 5") + lambda { 5.should arbitrary_matcher(:expected => 5).with(4) }.should fail_with("expected 4, got 5") + 5.should_not arbitrary_matcher(:expected => 4) + 5.should_not arbitrary_matcher(:expected => 5).with(4) + lambda { 5.should_not arbitrary_matcher(:expected => 5) }.should fail_with("expected not 5, got 5") + lambda { 5.should_not arbitrary_matcher(:expected => 4).with(5) }.should fail_with("expected not 5, got 5") + end + + it "should handle the submitted block" do + 5.should arbitrary_matcher { 5 } + 5.should arbitrary_matcher(:expected => 4) { 5 } + 5.should arbitrary_matcher(:expected => 4).with(5) { 3 } + end + + end + end +end diff --git a/vendor/plugins/rspec/spec/spec/expectations/wrap_expectation_spec.rb b/vendor/plugins/rspec/spec/spec/expectations/wrap_expectation_spec.rb new file mode 100644 index 000000000..9ef7d0075 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/expectations/wrap_expectation_spec.rb @@ -0,0 +1,30 @@ +require 'spec_helper' + +module Spec + module Matchers + describe "wrap_expectation" do + + def stub_matcher + @_stub_matcher ||= simple_matcher do + end + end + + def failing_matcher + @_failing_matcher ||= simple_matcher do + 1.should == 2 + end + end + + it "should return true if there is no error" do + wrap_expectation stub_matcher do + end.should be_true + end + + it "should return false if there is an error" do + wrap_expectation failing_matcher do + raise "error" + end.should be_false + end + end + end +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/spec/spec/interop/test/unit/resources/spec_with_options_hash.rb b/vendor/plugins/rspec/spec/spec/interop/test/unit/resources/spec_with_options_hash.rb new file mode 100644 index 000000000..7dc344bdd --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/interop/test/unit/resources/spec_with_options_hash.rb @@ -0,0 +1,13 @@ +rspec_lib = File.dirname(__FILE__) + "/../../../../../../lib" +$:.unshift rspec_lib unless $:.include?(rspec_lib) +require 'spec/autorun' +require 'spec/test/unit' + +describe "options hash" do + describe "#options" do + it "should expose the options hash" do + group = describe("group", :this => 'hash') {} + group.options[:this].should == 'hash' + end + end +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/spec/spec/interop/test/unit/resources/test_case_with_various_names.rb b/vendor/plugins/rspec/spec/spec/interop/test/unit/resources/test_case_with_various_names.rb new file mode 100644 index 000000000..186db49d5 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/interop/test/unit/resources/test_case_with_various_names.rb @@ -0,0 +1,22 @@ +rspec_lib = File.dirname(__FILE__) + "/../../../../../../lib" +$:.unshift rspec_lib unless $:.include?(rspec_lib) +require 'spec/autorun' +require 'spec/test/unit' + +class TestCaseThatPasses < Test::Unit::TestCase + def test_should_allow_underscore + assert true + end + + def testShouldAllowUppercaseLetter + assert true + end + + def testshouldallowlowercaseletter + assert true + end + + define_method :"test: should allow punctuation" do + assert true + end +end diff --git a/vendor/plugins/rspec/spec/spec/matchers/be_instance_of_spec.rb b/vendor/plugins/rspec/spec/spec/matchers/be_instance_of_spec.rb new file mode 100644 index 000000000..e6abd0b16 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/matchers/be_instance_of_spec.rb @@ -0,0 +1,36 @@ +require 'spec_helper' + +module Spec + module Matchers + [:be_an_instance_of, :be_instance_of].each do |method| + describe "actual.should #{method}(expected)" do + it "passes if actual is instance of expected class" do + 5.should send(method, Fixnum) + end + + it "fails if actual is instance of subclass of expected class" do + lambda { 5.should send(method, Numeric) }.should fail_with(%Q{expected 5 to be an instance of Numeric}) + end + + it "fails with failure message for should unless actual is instance of expected class" do + lambda { "foo".should send(method, Array) }.should fail_with(%Q{expected "foo" to be an instance of Array}) + end + + it "provides a description" do + matcher = be_an_instance_of(Fixnum) + matcher.matches?(Numeric) + matcher.description.should == "be an instance of Fixnum" + end + end + + describe "actual.should_not #{method}(expected)" do + + it "fails with failure message for should_not if actual is instance of expected class" do + lambda { "foo".should_not send(method, String) }.should fail_with(%Q{expected "foo" not to be an instance of String}) + end + + end + + end + end +end diff --git a/vendor/plugins/rspec/spec/spec/matchers/be_kind_of_spec.rb b/vendor/plugins/rspec/spec/spec/matchers/be_kind_of_spec.rb new file mode 100644 index 000000000..d3f05e806 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/matchers/be_kind_of_spec.rb @@ -0,0 +1,33 @@ +require 'spec_helper' + +module Spec + module Matchers + [:be_a_kind_of, :be_kind_of].each do |method| + describe "actual.should #{method}(expected)" do + it "passes if actual is instance of expected class" do + 5.should send(method, Fixnum) + end + + it "passes if actual is instance of subclass of expected class" do + 5.should send(method, Numeric) + end + + it "fails with failure message for should unless actual is kind of expected class" do + lambda { "foo".should send(method, Array) }.should fail_with(%Q{expected "foo" to be a kind of Array}) + end + + it "provides a description" do + matcher = be_a_kind_of(String) + matcher.matches?("this") + matcher.description.should == "be a kind of String" + end + end + + describe "actual.should_not #{method}(expected)" do + it "fails with failure message for should_not if actual is kind of expected class" do + lambda { "foo".should_not send(method, String) }.should fail_with(%Q{expected "foo" not to be a kind of String}) + end + end + end + end +end diff --git a/vendor/plugins/rspec/spec/spec/matchers/compatibility_spec.rb b/vendor/plugins/rspec/spec/spec/matchers/compatibility_spec.rb new file mode 100644 index 000000000..3987e590f --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/matchers/compatibility_spec.rb @@ -0,0 +1,28 @@ +require 'spec_helper' + +Spec::Matchers.define :have_public_instance_method do |method| + match do |klass| + klass.public_instance_methods.any? {|m| [method, method.to_sym].include?(m)} + end +end + +(Spec::Matchers.constants.sort).each do |c| + if (Class === (klass = Spec::Matchers.const_get(c))) + describe klass do + if klass.public_instance_methods.any? {|m| ['failure_message_for_should',:failure_message_for_should].include?(m)} + describe "called with should" do + subject { klass } + it { should have_public_instance_method('failure_message_for_should')} + it { should have_public_instance_method('failure_message')} + end + end + if klass.public_instance_methods.any? {|m| ['failure_message_for_should_not',:failure_message_for_should_not].include?(m)} + describe "called with should not" do + subject { klass } + it { should have_public_instance_method('failure_message_for_should_not')} + it { should have_public_instance_method('negative_failure_message')} + end + end + end + end +end diff --git a/vendor/plugins/rspec/spec/spec/matchers/dsl_spec.rb b/vendor/plugins/rspec/spec/spec/matchers/dsl_spec.rb new file mode 100644 index 000000000..9c280e5ae --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/matchers/dsl_spec.rb @@ -0,0 +1,34 @@ +require 'spec_helper' + +module Spec + module Matchers + module DSL + describe "#create" do + it "is deprecated" do + Spec.should_receive(:deprecate) + mod = Module.new + mod.extend Spec::Matchers::DSL + mod.create(:foo) + end + end + + describe "#define" do + it "creates a method that initializes a new matcher with the submitted name and expected arg" do + # FIXME - this expects new to be called, but we need something + # more robust - that expects new to be called with a specific + # block (lambda, proc, whatever) + mod = Module.new + mod.extend Spec::Matchers::DSL + mod.define(:foo) + + obj = Object.new + obj.extend mod + + Spec::Matchers::Matcher.should_receive(:new).with(:foo, 3) + + obj.foo(3) + end + end + end + end +end diff --git a/vendor/plugins/rspec/spec/spec/matchers/match_array_spec.rb b/vendor/plugins/rspec/spec/spec/matchers/match_array_spec.rb new file mode 100644 index 000000000..be75ec16d --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/matchers/match_array_spec.rb @@ -0,0 +1,108 @@ +require 'spec_helper' + +class UnsortableObject + def initialize(id) + @id = id + end + + def inspect + @id.to_s + end + + def ==(other) + false + end +end + +describe "array.should =~ other_array" do + it "should pass if target contains all items" do + [1,2,3].should =~ [1,2,3] + end + + it "should pass if target contains all items out of order" do + [1,3,2].should =~ [1,2,3] + end + + it "should fail if target includes extra items" do + lambda { + [1,2,3,4].should =~ [1,2,3] + }.should fail_with(<<-MESSAGE) +expected collection contained: [1, 2, 3] +actual collection contained: [1, 2, 3, 4] +the extra elements were: [4] +MESSAGE + end + + it "should fail if target is missing items" do + lambda { + [1,2].should =~ [1,2,3] + }.should fail_with(<<-MESSAGE) +expected collection contained: [1, 2, 3] +actual collection contained: [1, 2] +the missing elements were: [3] +MESSAGE + end + + it "should fail if target is missing items and has extra items" do + + lambda { + [1,2,4].should =~ [1,2,3] + }.should fail_with(<<-MESSAGE) +expected collection contained: [1, 2, 3] +actual collection contained: [1, 2, 4] +the missing elements were: [3] +the extra elements were: [4] +MESSAGE + end + + it "should sort items in the error message if they all respond to <=>" do + lambda { + [6,2,1,5].should =~ [4,1,2,3] + }.should fail_with(<<-MESSAGE) +expected collection contained: [1, 2, 3, 4] +actual collection contained: [1, 2, 5, 6] +the missing elements were: [3, 4] +the extra elements were: [5, 6] +MESSAGE + end + + it "should not sort items in the error message if they don't all respond to <=>" do + lambda { + [UnsortableObject.new(2), UnsortableObject.new(1)].should =~ [UnsortableObject.new(4), UnsortableObject.new(3)] + }.should fail_with(<<-MESSAGE) +expected collection contained: [4, 3] +actual collection contained: [2, 1] +the missing elements were: [4, 3] +the extra elements were: [2, 1] +MESSAGE + end + + it "should accurately report extra elements when there are duplicates" do + lambda { + [1,1,1,5].should =~ [1,5] + }.should fail_with(<<-MESSAGE) +expected collection contained: [1, 5] +actual collection contained: [1, 1, 1, 5] +the extra elements were: [1, 1] +MESSAGE + end + + it "should accurately report missing elements when there are duplicates" do + lambda { + [1,5].should =~ [1,1,5] + }.should fail_with(<<-MESSAGE) +expected collection contained: [1, 1, 5] +actual collection contained: [1, 5] +the missing elements were: [1] +MESSAGE + end + +end + +describe "should_not =~ [:with, :multiple, :args]" do + it "should not be supported" do + lambda { + [1,2,3].should_not =~ [1,2,3] + }.should fail_with(/Matcher does not support should_not/) + end +end diff --git a/vendor/plugins/rspec/spec/spec/matchers/matcher_spec.rb b/vendor/plugins/rspec/spec/spec/matchers/matcher_spec.rb new file mode 100644 index 000000000..76b2e2602 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/matchers/matcher_spec.rb @@ -0,0 +1,228 @@ +require 'spec_helper' + +module Spec + module Matchers + describe Matcher do + context "without overrides" do + before(:each) do + @matcher = Spec::Matchers::Matcher.new(:be_a_multiple_of, 3) do |multiple| + match do |actual| + actual % multiple == 0 + end + end + end + + it "provides a default description" do + @matcher.description.should == "be a multiple of 3" + end + + it "provides a default failure message for #should" do + @matcher.matches?(8) + @matcher.failure_message_for_should.should == "expected 8 to be a multiple of 3" + end + + it "provides a default failure message for #should_not" do + @matcher.matches?(9) + @matcher.failure_message_for_should_not.should == "expected 9 not to be a multiple of 3" + end + end + + it "is not diffable by default" do + matcher = Spec::Matchers::Matcher.new(:name) {} + matcher.should_not be_diffable + end + + it "is diffable when told to be" do + matcher = Spec::Matchers::Matcher.new(:name) { diffable } + matcher.should be_diffable + end + + it "provides expected" do + matcher = Spec::Matchers::Matcher.new(:name, 'expected string') {} + matcher.expected.should == ['expected string'] + end + + it "provides actual" do + matcher = Spec::Matchers::Matcher.new(:name, 'expected string') do + match {|actual|} + end + + matcher.matches?('actual string') + + matcher.actual.should == 'actual string' + end + + context "with overrides" do + before(:each) do + @matcher = Spec::Matchers::Matcher.new(:be_boolean, true) do |boolean| + match do |actual| + actual + end + description do + "be the boolean #{boolean}" + end + failure_message_for_should do |actual| + "expected #{actual} to be the boolean #{boolean}" + end + failure_message_for_should_not do |actual| + "expected #{actual} not to be the boolean #{boolean}" + end + end + end + + it "does not hide result of match block when true" do + @matcher.matches?(true).should be_true + end + + it "does not hide result of match block when false" do + @matcher.matches?(false).should be_false + end + + it "overrides the description" do + @matcher.description.should == "be the boolean true" + end + + it "overrides the failure message for #should" do + @matcher.matches?(false) + @matcher.failure_message_for_should.should == "expected false to be the boolean true" + end + + it "overrides the failure message for #should_not" do + @matcher.matches?(true) + @matcher.failure_message_for_should_not.should == "expected true not to be the boolean true" + end + end + + context "#new" do + it "passes matches? arg to match block" do + matcher = Spec::Matchers::Matcher.new(:ignore) do + match do |actual| + actual == 5 + end + end + matcher.matches?(5).should be_true + end + + it "exposes arg submitted through #new to matcher block" do + matcher = Spec::Matchers::Matcher.new(:ignore, 4) do |expected| + match do |actual| + actual > expected + end + end + matcher.matches?(5).should be_true + end + end + + context "with no args" do + before(:each) do + @matcher = Spec::Matchers::Matcher.new(:matcher_name) do + match do |actual| + actual == 5 + end + end + end + + it "matches" do + @matcher.matches?(5).should be_true + end + + it "describes" do + @matcher.description.should == "matcher name" + end + end + + context "with 1 arg" do + before(:each) do + @matcher = Spec::Matchers::Matcher.new(:matcher_name, 1) do |expected| + match do |actual| + actual == 5 && expected == 1 + end + end + end + + it "matches" do + @matcher.matches?(5).should be_true + end + + it "describes" do + @matcher.description.should == "matcher name 1" + end + end + + context "with multiple args" do + before(:each) do + @matcher = Spec::Matchers::Matcher.new(:matcher_name, 1, 2, 3, 4) do |a,b,c,d| + match do |sum| + a + b + c + d == sum + end + end + end + + it "matches" do + @matcher.matches?(10).should be_true + end + + it "describes" do + @matcher.description.should == "matcher name 1, 2, 3, and 4" + end + end + + it "supports helper methods" do + matcher = Spec::Matchers::Matcher.new(:be_similar_to, [1,2,3]) do |sample| + match do |actual| + similar?(sample, actual) + end + + def similar?(a, b) + a.sort == b.sort + end + end + + matcher.matches?([2,3,1]).should be_true + end + + it "supports fluent interface" do + matcher = Spec::Matchers::Matcher.new(:first_word) do + def second_word + self + end + end + + matcher.second_word.should == matcher + end + + it "treats method missing normally for undeclared methods" do + matcher = Spec::Matchers::Matcher.new(:ignore) { } + expect { matcher.non_existent_method }.to raise_error(NoMethodError) + end + + it "has access to other matchers" do + matcher = Spec::Matchers::Matcher.new(:ignore, 3) do |expected| + match do |actual| + extend Spec::Matchers + actual.should eql(5 + expected) + end + end + + matcher.matches?(8).should be_true + end + + it "lets you override the actual() in messages" do + matcher = Spec::Matchers::Matcher.new(:be_foo) do + match do |actual| + @submitted = actual + false + end + + def actual + "replaced" + end + end + + matcher.matches?("foo") + matcher.failure_message_for_should.should =~ /replaced/ + end + + end + end +end diff --git a/vendor/plugins/rspec/spec/spec/matchers/matchers_spec.rb b/vendor/plugins/rspec/spec/spec/matchers/matchers_spec.rb new file mode 100644 index 000000000..51f5efc44 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/matchers/matchers_spec.rb @@ -0,0 +1,2 @@ +require 'spec_helper' + diff --git a/vendor/plugins/rspec/spec/spec/mocks/argument_matchers_spec.rb b/vendor/plugins/rspec/spec/spec/mocks/argument_matchers_spec.rb new file mode 100644 index 000000000..fc8165583 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/mocks/argument_matchers_spec.rb @@ -0,0 +1,19 @@ +require 'spec_helper' + +module Spec + module Mocks + module ArgumentMatchers + describe AnyArgsMatcher do + it "represents itself nicely for failure messages" do + AnyArgsMatcher.new.description.should == "any args" + end + end + + describe AnyArgMatcher do + it "represents itself nicely for failure messages" do + AnyArgMatcher.new(nil).description.should == "anything" + end + end + end + end +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/spec/spec/mocks/bug_report_496_spec.rb b/vendor/plugins/rspec/spec/spec/mocks/bug_report_496_spec.rb new file mode 100644 index 000000000..fb172a6b0 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/mocks/bug_report_496_spec.rb @@ -0,0 +1,19 @@ +require 'spec_helper' + +module BugReport496 + class BaseClass + end + + class SubClass < BaseClass + end + + describe "a message expectation on a base class object" do + it "should correctly pick up message sent to it subclass" do + pending("fix for http://rspec.lighthouseapp.com/projects/5645/tickets/496") do + BaseClass.should_receive(:new).once + SubClass.new + end + end + end +end + diff --git a/vendor/plugins/rspec/spec/spec/mocks/bug_report_600_spec.rb b/vendor/plugins/rspec/spec/spec/mocks/bug_report_600_spec.rb new file mode 100644 index 000000000..c5c50d5a4 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/mocks/bug_report_600_spec.rb @@ -0,0 +1,22 @@ +require 'spec_helper' + +module BugReport600 + class ExampleClass + def self.method_that_uses_define_method + define_method "defined_method" do |attributes| + load_address(address, attributes) + end + end + end + + describe "stubbing a class method" do + it "should work" do + ExampleClass.should_receive(:define_method).with("defined_method") + ExampleClass.method_that_uses_define_method + end + + it "should restore the original method" do + ExampleClass.method_that_uses_define_method + end + end +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/spec/spec/mocks/bug_report_830_spec.rb b/vendor/plugins/rspec/spec/spec/mocks/bug_report_830_spec.rb new file mode 100644 index 000000000..ed16f419a --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/mocks/bug_report_830_spec.rb @@ -0,0 +1,21 @@ +require 'spec_helper' + +module Spec + module Mocks + describe 'Calling a method that catches StandardError' do + class Foo + def self.foo + bar + rescue StandardError + end + end + + it 'still reports mock failures' do + Foo.should_not_receive :bar + lambda do + Foo.foo + end.should raise_error(MockExpectationError) + end + end + end +end diff --git a/vendor/plugins/rspec/spec/spec/mocks/double_spec.rb b/vendor/plugins/rspec/spec/spec/mocks/double_spec.rb new file mode 100644 index 000000000..0d6ee982d --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/mocks/double_spec.rb @@ -0,0 +1,12 @@ +require 'spec_helper' + +describe "double" do + it "is an alias for stub and mock" do + double().should be_a(Spec::Mocks::Mock) + end + + it "uses 'Double' in failure messages" do + double = double('name') + expect {double.foo}.to raise_error(/Double "name" received/) + end +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/spec/spec/mocks/failing_argument_matchers_spec.rb b/vendor/plugins/rspec/spec/spec/mocks/failing_argument_matchers_spec.rb new file mode 100644 index 000000000..30742157d --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/mocks/failing_argument_matchers_spec.rb @@ -0,0 +1,95 @@ +require 'spec_helper' + +module Spec + module Mocks + describe "failing MockArgumentMatchers" do + before(:each) do + @mock = mock("test mock") + @reporter = Mock.new("reporter", :null_object => true) + end + + after(:each) do + @mock.rspec_reset + end + + it "should reject non boolean" do + @mock.should_receive(:random_call).with(boolean()) + lambda do + @mock.random_call("false") + end.should raise_error(MockExpectationError) + end + + it "should reject non numeric" do + @mock.should_receive(:random_call).with(an_instance_of(Numeric)) + lambda do + @mock.random_call("1") + end.should raise_error(MockExpectationError) + end + + it "should reject non string" do + @mock.should_receive(:random_call).with(an_instance_of(String)) + lambda do + @mock.random_call(123) + end.should raise_error(MockExpectationError) + end + + it "should reject goose when expecting a duck" do + @mock.should_receive(:random_call).with(duck_type(:abs, :div)) + lambda { @mock.random_call("I don't respond to :abs or :div") }.should raise_error(MockExpectationError) + end + + it "should fail if regexp does not match submitted string" do + @mock.should_receive(:random_call).with(/bcd/) + lambda { @mock.random_call("abc") }.should raise_error(MockExpectationError) + end + + it "should fail if regexp does not match submitted regexp" do + @mock.should_receive(:random_call).with(/bcd/) + lambda { @mock.random_call(/bcde/) }.should raise_error(MockExpectationError) + end + + it "should fail for a hash w/ wrong values" do + @mock.should_receive(:random_call).with(:a => "b", :c => "d") + lambda do + @mock.random_call(:a => "b", :c => "e") + end.should raise_error(MockExpectationError, /Mock "test mock" received :random_call with unexpected arguments\n expected: \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\)\n got: \(\{(:a=>\"b\", :c=>\"e\"|:c=>\"e\", :a=>\"b\")\}\)/) + end + + it "should fail for a hash w/ wrong keys" do + @mock.should_receive(:random_call).with(:a => "b", :c => "d") + lambda do + @mock.random_call("a" => "b", "c" => "d") + end.should raise_error(MockExpectationError, /Mock "test mock" received :random_call with unexpected arguments\n expected: \(\{(:a=>\"b\", :c=>\"d\"|:c=>\"d\", :a=>\"b\")\}\)\n got: \(\{(\"a\"=>\"b\", \"c\"=>\"d\"|\"c\"=>\"d\", \"a\"=>\"b\")\}\)/) + end + + it "should match against a Matcher" do + lambda do + @mock.should_receive(:msg).with(equal(3)) + @mock.msg(37) + end.should raise_error(MockExpectationError, "Mock \"test mock\" received :msg with unexpected arguments\n expected: (equal 3)\n got: (37)") + end + + it "should fail no_args with one arg" do + lambda do + @mock.should_receive(:msg).with(no_args) + @mock.msg(37) + end.should raise_error(MockExpectationError, "Mock \"test mock\" received :msg with unexpected arguments\n expected: (no args)\n got: (37)") + end + + it "should fail hash_including with missing key" do + lambda do + @mock.should_receive(:msg).with(hash_including(:a => 1)) + @mock.msg({}) + end.should raise_error(MockExpectationError, "Mock \"test mock\" received :msg with unexpected arguments\n expected: (hash_including(:a=>1))\n got: ({})") + end + + it "should fail with block matchers" do + lambda do + @mock.should_receive(:msg).with {|arg| arg.should == :received } + @mock.msg :no_msg_for_you + end.should raise_error(Spec::Expectations::ExpectationNotMetError, /expected: :received.*\s*.*got: :no_msg_for_you/) + end + + end + end +end diff --git a/vendor/plugins/rspec/spec/spec/mocks/hash_not_including_matcher_spec.rb b/vendor/plugins/rspec/spec/spec/mocks/hash_not_including_matcher_spec.rb new file mode 100644 index 000000000..9df69fe6c --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/mocks/hash_not_including_matcher_spec.rb @@ -0,0 +1,67 @@ +require 'spec_helper' + +module Spec + module Mocks + module ArgumentMatchers + describe HashNotIncludingMatcher do + + it "should describe itself properly" do + HashNotIncludingMatcher.new(:a => 5).description.should == "hash_not_including(:a=>5)" + end + + describe "passing" do + it "should match a hash without the specified key" do + hash_not_including(:c).should == {:a => 1, :b => 2} + end + + it "should match a hash with the specified key, but different value" do + hash_not_including(:b => 3).should == {:a => 1, :b => 2} + end + + it "should match a hash without the specified key, given as anything()" do + hash_not_including(:c => anything).should == {:a => 1, :b => 2} + end + + it "should match an empty hash" do + hash_not_including(:a).should == {} + end + + it "should match a hash without any of the specified keys" do + hash_not_including(:a, :b, :c).should == { :d => 7} + end + + end + + describe "failing" do + it "should not match a non-hash" do + hash_not_including(:a => 1).should_not == 1 + end + + it "should not match a hash with a specified key" do + hash_not_including(:b).should_not == {:b => 2} + end + + it "should not match a hash with the specified key/value pair" do + hash_not_including(:b => 2).should_not == {:a => 1, :b => 2} + end + + it "should not match a hash with the specified key" do + hash_not_including(:a, :b => 3).should_not == {:a => 1, :b => 2} + end + + it "should not match a hash with one of the specified keys" do + hash_not_including(:a, :b).should_not == {:b => 2} + end + + it "should not match a hash with some of the specified keys" do + hash_not_including(:a, :b, :c).should_not == {:a => 1, :b => 2} + end + + it "should not match a hash with one key/value pair included" do + hash_not_including(:a, :b, :c, :d => 7).should_not == { :d => 7} + end + end + end + end + end +end diff --git a/vendor/plugins/rspec/spec/spec/mocks/nil_expectation_warning_spec.rb b/vendor/plugins/rspec/spec/spec/mocks/nil_expectation_warning_spec.rb new file mode 100644 index 000000000..f8f72baff --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/mocks/nil_expectation_warning_spec.rb @@ -0,0 +1,53 @@ +require 'spec_helper' + +module Spec + module Mocks + + describe "an expectation set on nil" do + + it "should issue a warning with file and line number information" do + expected_warning = %r%An expectation of :foo was set on nil. Called from #{__FILE__}:#{__LINE__+3}(:in `block \(2 levels\) in <module:Mocks>')?. Use allow_message_expectations_on_nil to disable warnings.% + Kernel.should_receive(:warn).with(expected_warning) + + nil.should_receive(:foo) + nil.foo + end + + it "should issue a warning when the expectation is negative" do + Kernel.should_receive(:warn) + + nil.should_not_receive(:foo) + end + + it "should not issue a warning when expectations are set to be allowed" do + allow_message_expectations_on_nil + Kernel.should_not_receive(:warn) + + nil.should_receive(:foo) + nil.should_not_receive(:bar) + nil.foo + end + + end + + describe "#allow_message_expectations_on_nil" do + + it "should not effect subsequent examples" do + example_group = Class.new(::Spec::Example::ExampleGroupDouble) + example_group.it("when called in one example that doesn't end up setting an expectation on nil") do + allow_message_expectations_on_nil + end + example_group.it("should not effect the next exapmle ran") do + Kernel.should_receive(:warn) + nil.should_receive(:foo) + nil.foo + end + + example_group.run(Spec::Runner.options).should be_true + + end + + end + + end +end diff --git a/vendor/plugins/rspec/spec/spec/mocks/passing_argument_matchers_spec.rb b/vendor/plugins/rspec/spec/spec/mocks/passing_argument_matchers_spec.rb new file mode 100644 index 000000000..a364df0ae --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/mocks/passing_argument_matchers_spec.rb @@ -0,0 +1,145 @@ +require 'spec_helper' + +module Spec + module Mocks + describe "mock argument matchers", :shared => true do + before(:each) do + @mock = Mock.new("test mock") + Kernel.stub!(:warn) + end + + after(:each) do + @mock.rspec_verify + end + end + + describe Methods, "handling argument matchers" do + it_should_behave_like "mock argument matchers" + + it "should accept true as boolean()" do + @mock.should_receive(:random_call).with(boolean()) + @mock.random_call(true) + end + + it "should accept false as boolean()" do + @mock.should_receive(:random_call).with(boolean()) + @mock.random_call(false) + end + + it "should accept fixnum as kind_of(Numeric)" do + @mock.should_receive(:random_call).with(kind_of(Numeric)) + @mock.random_call(1) + end + + it "should accept float as an_instance_of(Numeric)" do + @mock.should_receive(:random_call).with(kind_of(Numeric)) + @mock.random_call(1.5) + end + + it "accepts fixnum as instance_of(Fixnum)" do + @mock.should_receive(:random_call).with(instance_of(Fixnum)) + @mock.random_call(1) + end + + it "should NOT accept fixnum as instance_of(Numeric)" do + @mock.should_not_receive(:random_call).with(instance_of(Numeric)) + @mock.random_call(1) + end + + it "should NOT accept float as instance_of(Numeric)" do + @mock.should_not_receive(:random_call).with(instance_of(Numeric)) + @mock.random_call(1.5) + end + + it "should accept string as anything()" do + @mock.should_receive(:random_call).with("a", anything(), "c") + @mock.random_call("a", "whatever", "c") + end + + it "should match duck type with one method" do + @mock.should_receive(:random_call).with(duck_type(:length)) + @mock.random_call([]) + end + + it "should match duck type with two methods" do + @mock.should_receive(:random_call).with(duck_type(:abs, :div)) + @mock.random_call(1) + end + + it "should match no args against any_args()" do + @mock.should_receive(:random_call).with(any_args) + @mock.random_call() + end + + it "should match one arg against any_args()" do + @mock.should_receive(:random_call).with(any_args) + @mock.random_call("a string") + end + + it "should match no args against no_args()" do + @mock.should_receive(:random_call).with(no_args) + @mock.random_call() + end + + it "should match hash with hash_including same hash" do + @mock.should_receive(:random_call).with(hash_including(:a => 1)) + @mock.random_call(:a => 1) + end + + end + + describe Methods, "handling block matchers" do + it_should_behave_like "mock argument matchers" + + it "should match arguments against RSpec expectations" do + @mock.should_receive(:random_call).with {|arg1, arg2, arr, *rest| + arg1.should == 5 + arg2.should have_at_least(3).characters + arg2.should have_at_most(10).characters + arr.map {|i| i * 2}.should == [2,4,6] + rest.should == [:fee, "fi", 4] + } + @mock.random_call 5, "hello", [1,2,3], :fee, "fi", 4 + end + end + + describe Methods, "handling non-matcher arguments" do + + before(:each) do + @mock = Mock.new("test mock") + end + + it "should match non special symbol (can be removed when deprecated symbols are removed)" do + @mock.should_receive(:random_call).with(:some_symbol) + @mock.random_call(:some_symbol) + end + + it "should match string against regexp" do + @mock.should_receive(:random_call).with(/bcd/) + @mock.random_call("abcde") + end + + it "should match regexp against regexp" do + @mock.should_receive(:random_call).with(/bcd/) + @mock.random_call(/bcd/) + end + + it "should match against a hash submitted and received by value" do + @mock.should_receive(:random_call).with(:a => "a", :b => "b") + @mock.random_call(:a => "a", :b => "b") + end + + it "should match against a hash submitted by reference and received by value" do + opts = {:a => "a", :b => "b"} + @mock.should_receive(:random_call).with(opts) + @mock.random_call(:a => "a", :b => "b") + end + + it "should match against a hash submitted by value and received by reference" do + opts = {:a => "a", :b => "b"} + @mock.should_receive(:random_call).with(:a => "a", :b => "b") + @mock.random_call(opts) + end + end + end +end diff --git a/vendor/plugins/rspec/spec/spec/mocks/stub_chain_spec.rb b/vendor/plugins/rspec/spec/spec/mocks/stub_chain_spec.rb new file mode 100644 index 000000000..3536e1761 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/mocks/stub_chain_spec.rb @@ -0,0 +1,42 @@ +require 'spec_helper' + +module Spec + module Mocks + describe "A chained method stub" do + before(:each) do + @subject = Object.new + end + + it "returns expected value from chaining only one method call" do + @subject.stub_chain(:msg1).and_return(:return_value) + @subject.msg1.should equal(:return_value) + end + + it "returns expected value from chaining two method calls" do + @subject.stub_chain(:msg1, :msg2).and_return(:return_value) + @subject.msg1.msg2.should equal(:return_value) + end + + it "returns expected value from chaining four method calls" do + @subject.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:return_value) + @subject.msg1.msg2.msg3.msg4.should equal(:return_value) + end + + it "returns expected value from two chains with shared messages at the end" do + @subject.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:first) + @subject.stub_chain(:msg5, :msg2, :msg3, :msg4).and_return(:second) + + @subject.msg1.msg2.msg3.msg4.should equal(:first) + @subject.msg5.msg2.msg3.msg4.should equal(:second) + end + + it "returns expected value from two chains with shared messages at the beginning" do + @subject.stub_chain(:msg1, :msg2, :msg3, :msg4).and_return(:first) + @subject.stub_chain(:msg1, :msg2, :msg3, :msg5).and_return(:second) + + @subject.msg1.msg2.msg3.msg4.should equal(:first) + @subject.msg1.msg2.msg3.msg5.should equal(:second) + end + end + end +end diff --git a/vendor/plugins/rspec/spec/spec/mocks/stub_implementation_spec.rb b/vendor/plugins/rspec/spec/spec/mocks/stub_implementation_spec.rb new file mode 100644 index 000000000..1487277fc --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/mocks/stub_implementation_spec.rb @@ -0,0 +1,31 @@ +require 'spec_helper' + +module Spec + module Mocks + describe "stub implementation" do + context "with no args" do + it "execs the block when called" do + obj = stub() + obj.stub(:foo) { :bar } + obj.foo.should == :bar + end + end + + context "with one arg" do + it "execs the block with that arg when called" do + obj = stub() + obj.stub(:foo) {|given| given} + obj.foo(:bar).should == :bar + end + end + + context "with variable args" do + it "execs the block when called" do + obj = stub() + obj.stub(:foo) {|*given| given.first} + obj.foo(:bar).should == :bar + end + end + end + end +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/spec/spec/mocks/stubbed_message_expectations_spec.rb b/vendor/plugins/rspec/spec/spec/mocks/stubbed_message_expectations_spec.rb new file mode 100644 index 000000000..03c8fecdc --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/mocks/stubbed_message_expectations_spec.rb @@ -0,0 +1,26 @@ +require 'spec_helper' + +module Spec + module Mocks + describe "Example with stubbed and then called message" do + it "fails if the message is expected and then subsequently not called again" do + mock_obj = mock("mock", :msg => nil) + mock_obj.msg + mock_obj.should_receive(:msg) + lambda { mock_obj.rspec_verify }.should raise_error(Spec::Mocks::MockExpectationError) + end + + it "outputs arguments of all similar calls" do + m = mock('mock', :foo => true) + m.should_receive(:foo).with('first') + m.foo('second') + m.foo('third') + lambda do + m.rspec_verify + end.should raise_error(%Q|Mock "mock" received :foo with unexpected arguments\n expected: ("first")\n got: (["second"], ["third"])|) + m.rspec_reset + end + end + + end +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/spec/spec/mocks/unstub_spec.rb b/vendor/plugins/rspec/spec/spec/mocks/unstub_spec.rb new file mode 100644 index 000000000..89e5ac381 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/mocks/unstub_spec.rb @@ -0,0 +1,127 @@ +require 'spec_helper' + +module Spec + module Mocks + describe Mock do + context "unstubbing a mock object with a stub" do + it "should remove the stub" do + a_mock = mock 'an object', :foo => :bar + + a_mock.unstub! :foo + a_mock.should_not respond_to(:foo) + end + end + + context "unstubbing a real object with a stub" do + before do + @obj = Object.new + end + + it "should raise a NoMethodError if the message is called after unstubbing" do + @obj.stub!(:foo).and_return :bar + @obj.unstub!(:foo) + + lambda { + @obj.foo + }.should raise_error(NoMethodError) + end + + it "should only clear the stub specified" do + @obj.stub!(:foo).and_return :bar + @obj.stub!(:other).and_return :baz + + @obj.unstub!(:foo) + + @obj.other.should == :baz + end + + it "should no longer respond_to? the method" do + @obj.stub!(:foo).and_return :bar + @obj.unstub!(:foo) + + @obj.should_not respond_to(:foo) + end + + it "should unstub using a string (should convert the string to a symbol)" do + @obj.stub!(:foo) + + @obj.unstub!("foo") + + @obj.should_not respond_to(:foo) + end + + it "should restore a previous method definition" do + def @obj.foo + :a_result + end + + @obj.stub!(:foo).and_return :stubbed_result + @obj.unstub!(:foo) + + @obj.foo.should == :a_result + end + + it "should have unstub as an alias of unstub!" do + @obj.stub!(:foo).and_return :bar + + @obj.unstub(:foo) + + lambda { + @obj.foo + }.should raise_error(NoMethodError) + end + + it "should raise a MockExpectationError if it is not stubbed" do + lambda { + @obj.unstub!(:foo) + }.should raise_error(MockExpectationError, "The method `foo` was not stubbed or was already unstubbed") + end + + it "should raise a MockExpectationError if it was already unstubbed" do + @obj.stub!(:foo) + @obj.unstub!(:foo) + + lambda { + @obj.unstub!(:foo) + }.should raise_error(MockExpectationError, "The method `foo` was not stubbed or was already unstubbed") + end + + it "should use the correct message name in the error" do + @obj.stub!(:bar) + @obj.unstub!(:bar) + + lambda { + @obj.unstub!(:bar) + }.should raise_error(MockExpectationError, "The method `bar` was not stubbed or was already unstubbed") + end + + it "should raise a MockExpectationError if the method is defined, but not stubbed" do + def @obj.meth; end + + lambda { + @obj.unstub!(:meth) + }.should raise_error(MockExpectationError) + end + + it "should be able to restub a after unstubbing" do + @obj.stub!(:foo).and_return :bar + + @obj.unstub!(:foo) + + @obj.stub!(:foo).and_return :baz + + @obj.foo.should == :baz + end + + it "should remove only the first stub if multiple stubs have been defined" do + @obj.stub!(:foo).and_return :first + @obj.stub!(:foo).and_return :second + + @obj.unstub!(:foo) + + @obj.foo.should == :first + end + end + end + end +end diff --git a/vendor/plugins/rspec/spec/spec/rake/spectask_spec.rb b/vendor/plugins/rspec/spec/spec/rake/spectask_spec.rb new file mode 100644 index 000000000..ea834bad4 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/rake/spectask_spec.rb @@ -0,0 +1,150 @@ +require 'spec_helper' +require 'spec/rake/spectask' + +module Spec + module Rake + + class MockTask + class << self + attr_accessor :last_instance, :last_cmd + end + + def self.tasks + @tasks ||= {} + end + + def self.reset_tasks + @tasks = {} + end + + def self.task(name) + tasks[name] + end + + def self.register_task(name, block) + tasks[name] = block + end + + def initialize(name, &block) + MockTask.register_task(name, block) + MockTask.last_instance = block + end + + def self.create_task(name, &block) + new(name, &block) + end + end + + class SpecTask + def task(name, &block) + MockTask.create_task(name, &block) + end + + def system(cmd) + MockTask.last_cmd = cmd + true + end + + def default_ruby_path + RUBY + end + end + + describe SpecTask do + + before(:each) do + MockTask.reset_tasks + end + + it "should execute rake's ruby path by default" do + task = SpecTask.new + MockTask.last_instance.call + MockTask.last_cmd.should match(/^#{task.default_ruby_path} /) + end + + it "should execute the command with system if ruby_cmd is specified" do + task = SpecTask.new {|t| t.ruby_cmd = "path_to_multiruby"} + task.should_receive(:system).and_return(true) + MockTask.last_instance.call + end + + it "should execute the ruby_cmd path if specified" do + SpecTask.new {|t| t.ruby_cmd = "path_to_multiruby"} + MockTask.last_instance.call + MockTask.last_cmd.should match(/^path_to_multiruby /) + end + + it "should produce a deprecation warning if the out option is used" do + SpecTask.new {|t| t.out = "somewhere_over_the_rainbow"} + STDERR.should_receive(:puts).with("The Spec::Rake::SpecTask#out attribute is DEPRECATED and will be removed in a future version. Use --format FORMAT:WHERE instead.") + MockTask.last_instance.call + end + + it "should produce an error if failure_message is set and the command fails" do + task = SpecTask.new {|t| t.failure_message = "oops"; t.fail_on_error = false} + STDERR.should_receive(:puts).with("oops") + task.stub(:system).and_return(false) + MockTask.last_instance.call + end + + it "should raise if fail_on_error is set and the command fails" do + task = SpecTask.new + task.stub(:system).and_return(false) + lambda {MockTask.last_instance.call}.should raise_error + end + + it "should not raise if fail_on_error is not set and the command fails" do + task = SpecTask.new {|t| t.fail_on_error = false} + task.stub(:system).and_return(false) + lambda {MockTask.last_instance.call}.should_not raise_error + end + + context "with ENV['SPEC'] set" do + before(:each) do + @orig_env_spec = ENV['SPEC'] + ENV['SPEC'] = 'foo.rb' + end + after(:each) do + ENV['SPEC'] = @orig_env_spec + end + it "should use the provided file list" do + task = SpecTask.new + task.spec_file_list.should == ["foo.rb"] + end + end + + context "with the rcov option" do + + it "should create a clobber_rcov task" do + MockTask.stub!(:create_task) + MockTask.should_receive(:create_task).with(:clobber_rcov) + SpecTask.new(:rcov) {|t| t.rcov = true} + end + + it "should setup the clobber_rcov task to remove the rcov directory" do + task = SpecTask.new(:rcov) {|t| t.rcov = true; t.rcov_dir = "path_to_rcov_directory"} + task.should_receive(:rm_r).with("path_to_rcov_directory") + MockTask.task(:clobber_rcov).call + end + + it "should make the clobber task depend on clobber_rcov" do + MockTask.stub!(:create_task) + MockTask.should_receive(:create_task).with(:clobber => [:clobber_rcov]) + SpecTask.new(:rcov) {|t| t.rcov = true} + end + + it "should make the rcov task depend on clobber_rcov" do + MockTask.stub!(:create_task) + MockTask.should_receive(:create_task).with(:rcov => :clobber_rcov) + SpecTask.new(:rcov) {|t| t.rcov = true} + end + + it "creates an rcov options list" do + MockTask.stub!(:create_task) + task = SpecTask.new(:rcov) {|t| t.rcov = true, t.rcov_opts = ['a','b']} + task.rcov_option_list.should == "a b" + end + end + end + end +end
\ No newline at end of file diff --git a/vendor/plugins/rspec/spec/spec/runner/configuration_spec.rb b/vendor/plugins/rspec/spec/spec/runner/configuration_spec.rb new file mode 100644 index 000000000..ea545d641 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/runner/configuration_spec.rb @@ -0,0 +1,320 @@ +require 'spec_helper' + +module Spec + module Runner + describe Configuration do + with_sandboxed_options do + with_sandboxed_config do + + describe "#mock_with" do + it "should default mock framework to rspec" do + config.mock_framework.should =~ /^spec\/adapters\/mock_frameworks\/rspec$/ + end + + it "should set rspec mocking explicitly" do + config.mock_with(:rspec) + config.mock_framework.should =~ /^spec\/adapters\/mock_frameworks\/rspec$/ + end + + it "should set mocha" do + config.mock_with(:mocha) + config.mock_framework.should =~ /^spec\/adapters\/mock_frameworks\/mocha$/ + end + + it "should set flexmock" do + config.mock_with(:flexmock) + config.mock_framework.should =~ /^spec\/adapters\/mock_frameworks\/flexmock$/ + end + + it "should set rr" do + config.mock_with(:rr) + config.mock_framework.should =~ /^spec\/adapters\/mock_frameworks\/rr$/ + end + + it "should set an arbitrary adapter module" do + adapter = Module.new + config.mock_with(adapter) + config.mock_framework.should == adapter + end + end + + describe "#include" do + + before(:each) do + @example_group_class = Class.new(::Spec::Example::ExampleGroupDouble) {} + Spec::Example::ExampleGroupFactory.register(:foobar, @example_group_class) + end + + it "should include the submitted module in ExampleGroup subclasses" do + mod = Module.new + config.include mod + Class.new(@example_group_class).included_modules.should include(mod) + end + + it "should scope modules to be included for a specific type" do + mod = Module.new + config.include mod, :type => :foobar + Class.new(@example_group_class).included_modules.should include(mod) + end + + it "should not include modules in a type they are not intended for" do + mod = Module.new + @other_example_group_class = Class.new(::Spec::Example::ExampleGroupDouble) + Spec::Example::ExampleGroupFactory.register(:baz, @other_example_group_class) + + config.include mod, :type => :foobar + + Class.new(@other_example_group_class).included_modules.should_not include(mod) + end + + it "accepts an Array of types" do + mod = Module.new + @other_example_group_class = Class.new(::Spec::Example::ExampleGroupDouble) + Spec::Example::ExampleGroupFactory.register(:baz, @other_example_group_class) + + config.include mod, :type => [:foobar, :baz] + + Class.new(@example_group_class).included_modules.should include(mod) + Class.new(@other_example_group_class).included_modules.should include(mod) + end + + end + + describe "#extend" do + + before(:each) do + @example_group_class = Class.new(::Spec::Example::ExampleGroupDouble) {} + Spec::Example::ExampleGroupFactory.register(:foobar, @example_group_class) + end + + it "should extend all groups" do + mod = Module.new + ExampleGroup.should_receive(:extend).with(mod) + Spec::Runner.configuration.extend mod + end + + it "should extend specified groups" do + mod = Module.new + @example_group_class.should_receive(:extend).with(mod) + Spec::Runner.configuration.extend mod, :type => :foobar + end + + it "should not extend non-specified groups" do + @other_example_group_class = Class.new(::Spec::Example::ExampleGroupDouble) + Spec::Example::ExampleGroupFactory.register(:baz, @other_example_group_class) + + mod = Module.new + @other_example_group_class.should_not_receive(:extend) + + Spec::Runner.configuration.extend mod, :type => :foobar + end + + end + end + + describe "ordering methods: " do + + before(:each) do + @special_example_group = Class.new(::Spec::Example::ExampleGroupDouble).describe("special_example_group") + @special_child_example_group = Class.new(@special_example_group).describe("special_child_example_group") + @nonspecial_example_group = Class.new(::Spec::Example::ExampleGroupDouble).describe("nonspecial_example_group") + Spec::Example::ExampleGroupFactory.register(:special, @special_example_group) + Spec::Example::ExampleGroupFactory.register(:special_child, @special_child_example_group) + Spec::Example::ExampleGroupFactory.register(:non_special, @nonspecial_example_group) + @example_group = @special_child_example_group.describe "Special Example Group" + @unselected_example_group = Class.new(@nonspecial_example_group).describe "Non Special Example Group" + end + + describe "#prepend_before" do + it "prepends the before block on all instances of the passed in type" do + order = [] + config.prepend_before(:all) do + order << :prepend__before_all + end + config.prepend_before(:all, :type => :special) do + order << :special_prepend__before_all + end + config.prepend_before(:all, :type => :special_child) do + order << :special_child_prepend__before_all + end + config.prepend_before(:each) do + order << :prepend__before_each + end + config.prepend_before(:each, :type => :special) do + order << :special_prepend__before_each + end + config.prepend_before(:each, :type => :special_child) do + order << :special_child_prepend__before_each + end + config.prepend_before(:all, :type => :non_special) do + order << :special_prepend__before_all + end + config.prepend_before(:each, :type => :non_special) do + order << :special_prepend__before_each + end + @example_group.it "calls prepend_before" do + end + + @example_group.run(options) + order.should == [ + :prepend__before_all, + :special_prepend__before_all, + :special_child_prepend__before_all, + :prepend__before_each, + :special_prepend__before_each, + :special_child_prepend__before_each + ] + end + end + + describe "#append_before" do + + it "calls append_before on the type" do + order = [] + config.append_before(:all) do + order << :append_before_all + end + config.append_before(:all, :type => :special) do + order << :special_append_before_all + end + config.append_before(:all, :type => :special_child) do + order << :special_child_append_before_all + end + config.append_before do # default is :each + order << :append_before_each + end + config.append_before(:each, :type => :special) do + order << :special_append_before_each + end + config.append_before(:each, :type => :special_child) do + order << :special_child_append_before_each + end + config.append_before(:all, :type => :non_special) do + order << :special_append_before_all + end + config.append_before(:each, :type => :non_special) do + order << :special_append_before_each + end + @example_group.it "calls append_before" do + end + + @example_group.run(options) + order.should == [ + :append_before_all, + :special_append_before_all, + :special_child_append_before_all, + :append_before_each, + :special_append_before_each, + :special_child_append_before_each + ] + end + end + + describe "#prepend_after" do + + it "prepends the after block on all instances of the passed in type" do + order = [] + config.prepend_after(:all) do + order << :prepend__after_all + end + config.prepend_after(:all, :type => :special) do + order << :special_prepend__after_all + end + config.prepend_after(:all, :type => :special) do + order << :special_child_prepend__after_all + end + config.prepend_after(:each) do + order << :prepend__after_each + end + config.prepend_after(:each, :type => :special) do + order << :special_prepend__after_each + end + config.prepend_after(:each, :type => :special) do + order << :special_child_prepend__after_each + end + config.prepend_after(:all, :type => :non_special) do + order << :special_prepend__after_all + end + config.prepend_after(:each, :type => :non_special) do + order << :special_prepend__after_each + end + @example_group.it "calls prepend_after" do + end + + @example_group.run(options) + order.should == [ + :special_child_prepend__after_each, + :special_prepend__after_each, + :prepend__after_each, + :special_child_prepend__after_all, + :special_prepend__after_all, + :prepend__after_all + ] + end + end + + describe "#append_after" do + + it "calls append_after on the type" do + order = [] + config.append_after(:all) do + order << :append__after_all + end + config.append_after(:all, :type => :special) do + order << :special_append__after_all + end + config.append_after(:all, :type => :special_child) do + order << :special_child_append__after_all + end + config.append_after(:each) do + order << :append__after_each + end + config.append_after(:each, :type => :special) do + order << :special_append__after_each + end + config.append_after(:each, :type => :special_child) do + order << :special_child_append__after_each + end + config.append_after(:all, :type => :non_special) do + order << :non_special_append_after_all + end + config.append_after(:each, :type => :non_special) do + order << :non_special_append_after_each + end + @example_group.it "calls append_after" do + end + + @example_group.run(options) + order.should == [ + :special_child_append__after_each, + :special_append__after_each, + :append__after_each, + :special_child_append__after_all, + :special_append__after_all, + :append__after_all + ] + end + + end + + describe "#ignore_backtrace_patterns" do + it "adds patterns to ignore in backtrace" do + config.ignore_backtrace_patterns /custom_pattern/, /shoulda/, /spork/ + config.ignored_backtrace_patterns.should include(/custom_pattern/) + config.ignored_backtrace_patterns.should include(/shoulda/) + config.ignored_backtrace_patterns.should include(/spork/) + end + end + + describe "#predicate_matchers (DEPRECATED)" do + it "is deprecated" do + Spec.should_receive(:deprecate) + config.predicate_matchers[:foo] = :bar? + end + end + + end + end + end + end +end diff --git a/vendor/plugins/rspec/spec/spec/runner/example_group_runner_spec.rb b/vendor/plugins/rspec/spec/spec/runner/example_group_runner_spec.rb new file mode 100644 index 000000000..2b1601aca --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/runner/example_group_runner_spec.rb @@ -0,0 +1,26 @@ +require 'spec_helper' + +module Spec + module Runner + describe ExampleGroupRunner do + before(:each) do + err = StringIO.new('') + out = StringIO.new('') + @options = Options.new(err, out) + @runner = Spec::Runner::ExampleGroupRunner.new(@options) + end + + after(:each) do + Spec::Expectations.differ = nil + end + + describe "#load_files" do + it "should load UTF-8 encoded files" do + file = File.expand_path(File.dirname(__FILE__) + "/resources/utf8_encoded.rb") + @options.files << file + @runner.load_files(@options.files_to_load).should == @options.files_to_load + end + end + end + end +end diff --git a/vendor/plugins/rspec/spec/spec/runner/formatter/base_formatter_spec.rb b/vendor/plugins/rspec/spec/spec/runner/formatter/base_formatter_spec.rb new file mode 100644 index 000000000..a904bf380 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/runner/formatter/base_formatter_spec.rb @@ -0,0 +1,30 @@ +require 'spec_helper' + +module Spec + module Runner + module Formatter + describe BaseFormatter do + subject { BaseFormatter.new(nil,nil) } + it {should respond_to(:start ).with(1).argument } + it {should respond_to(:example_group_started).with(1).argument } + it {should respond_to(:example_started ).with(1).argument } + # -3 indicates that one of the arguments is optional, with a default + # value assigned. This is due to deprecated_pending_location. Once + # that is removed, this should be changed to 2. + it {should respond_to(:example_pending ).with(-3).arguments} + it {should respond_to(:example_passed ).with(1).argument } + it {should respond_to(:example_failed ).with(3).arguments} + it {should respond_to(:start_dump ).with(0).arguments} + it {should respond_to(:dump_failure ).with(2).arguments} + it {should respond_to(:dump_summary ).with(4).arguments} + it {should respond_to(:dump_pending ).with(0).arguments} + it {should respond_to(:close ).with(0).arguments} + + it "deprecates add_example_group" do + Spec.should_receive(:deprecate) + subject.add_example_group(stub('example group')) + end + end + end + end +end diff --git a/vendor/plugins/rspec/spec/spec/runner/formatter/base_text_formatter_spec.rb b/vendor/plugins/rspec/spec/spec/runner/formatter/base_text_formatter_spec.rb new file mode 100644 index 000000000..e3677ad47 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/runner/formatter/base_text_formatter_spec.rb @@ -0,0 +1,113 @@ +require 'spec_helper' +require 'spec/runner/formatter/base_text_formatter' + +module Spec + module Runner + module Formatter + describe BaseTextFormatter do + + before :all do + @sandbox = "spec/sandbox" + end + + it "should create the directory contained in WHERE if it does not exist" do + FileUtils.should_receive(:mkdir_p).with(@sandbox) + File.stub!(:open) + BaseTextFormatter.new({},"#{@sandbox}/temp.rb") + end + + context "(deprecations)" do + before(:each) do + Kernel.stub!(:warn) + @io = StringIO.new + @options = mock('options') + @options.stub!(:dry_run).and_return(false) + @options.stub!(:colour).and_return(false) + @options.stub!(:autospec).and_return(false) + @formatter = Class.new(BaseTextFormatter) do + def method_that_class_magenta(message) + magenta(message) + end + def method_that_class_colourise(message, failure) + colourise(message, failure) + end + end.new(@options, @io) + @failure = stub('failure', :pending_fixed? => false) + end + + context "#colourise" do + it "warns when subclasses call colourise" do + Spec.should_receive(:deprecate) + @formatter.method_that_class_colourise('this message', @failure) + end + + it "delegates to colorize_failure" do + @formatter.should_receive(:colorize_failure).with('this message', @failure) + @formatter.colourise('this message', @failure) + end + end + + context "#magenta" do + it "warns when subclasses call magenta" do + Spec.should_receive(:deprecate).with(/#magenta/) + @formatter.method_that_class_magenta('this message') + end + + it "delegates to red" do + @formatter.should_receive(:red).with('this message') + @formatter.method_that_class_magenta('this message') + end + end + + end + + describe "#colour (protected)" do + before(:each) do + @original_RSPEC_COLOR = ENV['RSPEC_COLOR'] + end + + it "does not colorize when output_to_file? returns true" do + out = StringIO.new + options = stub('options', :colour => true, :autospec => false) + formatter = BaseTextFormatter.new(options,out) + formatter.stub!(:output_to_tty?).and_return(true) + formatter.stub!(:output_to_file?).and_return(true) + formatter.__send__(:colour, 'foo', "\e[32m").should == "foo" + end + + it "colorizes when colour? and output_to_tty? return true" do + out = StringIO.new + options = stub('options', :colour => true, :autospec => false) + formatter = BaseTextFormatter.new(options,out) + formatter.stub!(:output_to_tty?).and_return(true) + formatter.__send__(:colour, 'foo', "\e[32m").should == "\e[32mfoo\e[0m" + end + + it "colorizes when ENV['RSPEC_COLOR'] is set even if colour? and output_to_tty? return false" do + out = StringIO.new + options = stub('options', :colour => false) + formatter = BaseTextFormatter.new(options,out) + formatter.stub!(:output_to_tty?).and_return(false) + + ENV['RSPEC_COLOR'] = 'true' + + formatter.__send__(:colour, 'foo', "\e[32m").should == "\e[32mfoo\e[0m" + end + + it "colorizes when autospec? is true even if colour? and output_to_tty? return false" do + out = StringIO.new + options = stub('options', :colour => true, :autospec => true) + formatter = BaseTextFormatter.new(options,out) + formatter.stub!(:output_to_tty?).and_return(false) + + formatter.__send__(:colour, 'foo', "\e[32m").should == "\e[32mfoo\e[0m" + end + + after(:each) do + ENV['RSPEC_COLOR'] = @original_RSPEC_COLOR + end + end + end + end + end +end diff --git a/vendor/plugins/rspec/spec/spec/runner/formatter/html_formatted-1.8.7.html b/vendor/plugins/rspec/spec/spec/runner/formatter/html_formatted-1.8.7.html new file mode 100644 index 000000000..5e489bba5 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/runner/formatter/html_formatted-1.8.7.html @@ -0,0 +1,377 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> +<head> + <title>RSpec results</title> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> + <meta http-equiv="Expires" content="-1" /> + <meta http-equiv="Pragma" content="no-cache" /> + <style type="text/css"> + body { + margin: 0; + padding: 0; + background: #fff; + font-size: 80%; + } + </style> + <script type="text/javascript"> + // <![CDATA[ +function moveProgressBar(percentDone) { + document.getElementById("rspec-header").style.width = percentDone +"%"; +} +function makeRed(element_id) { + document.getElementById(element_id).style.background = '#C40D0D'; + document.getElementById(element_id).style.color = '#FFFFFF'; +} + +function makeYellow(element_id) { + if (element_id == "rspec-header" && document.getElementById(element_id).style.background != '#C40D0D') + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } + else + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } +} + + // ]]> + </script> + <style type="text/css"> +#rspec-header { + background: #65C400; color: #fff; height: 4em; +} + +.rspec-report h1 { + margin: 0px 10px 0px 10px; + padding: 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + font-size: 1.8em; + position: absolute; +} + +#summary { + margin: 0; padding: 5px 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + text-align: right; + top: 0px; + right: 0px; + float:right; +} + +#summary p { + margin: 0 0 0 2px; +} + +#summary #totals { + font-size: 1.2em; +} + +.example_group { + margin: 0 10px 5px; + background: #fff; +} + +dl { + margin: 0; padding: 0 0 5px; + font: normal 11px "Lucida Grande", Helvetica, sans-serif; +} + +dt { + padding: 3px; + background: #65C400; + color: #fff; + font-weight: bold; +} + +dd { + margin: 5px 0 5px 5px; + padding: 3px 3px 3px 18px; +} + +dd.spec.passed { + border-left: 5px solid #65C400; + border-bottom: 1px solid #65C400; + background: #DBFFB4; color: #3D7700; +} + +dd.spec.failed { + border-left: 5px solid #C20000; + border-bottom: 1px solid #C20000; + color: #C20000; background: #FFFBD3; +} + +dd.spec.not_implemented { + border-left: 5px solid #FAF834; + border-bottom: 1px solid #FAF834; + background: #FCFB98; color: #131313; +} + +dd.spec.pending_fixed { + border-left: 5px solid #0000C2; + border-bottom: 1px solid #0000C2; + color: #0000C2; background: #D3FBFF; +} + +.backtrace { + color: #000; + font-size: 12px; +} + +a { + color: #BE5C00; +} + +/* Ruby code, style similar to vibrant ink */ +.ruby { + font-size: 12px; + font-family: monospace; + color: white; + background-color: black; + padding: 0.1em 0 0.2em 0; +} + +.ruby .keyword { color: #FF6600; } +.ruby .constant { color: #339999; } +.ruby .attribute { color: white; } +.ruby .global { color: white; } +.ruby .module { color: white; } +.ruby .class { color: white; } +.ruby .string { color: #66FF00; } +.ruby .ident { color: white; } +.ruby .method { color: #FFCC00; } +.ruby .number { color: white; } +.ruby .char { color: white; } +.ruby .comment { color: #9933CC; } +.ruby .symbol { color: white; } +.ruby .regex { color: #44B4CC; } +.ruby .punct { color: white; } +.ruby .escape { color: white; } +.ruby .interp { color: white; } +.ruby .expr { color: white; } + +.ruby .offending { background-color: gray; } +.ruby .linenum { + width: 75px; + padding: 0.1em 1em 0.2em 0; + color: #000000; + background-color: #FFFBD3; +} + + </style> +</head> +<body> +<div class="rspec-report"> + +<div id="rspec-header"> + <div id="label"> + <h1>RSpec Code Examples</h1> + </div> + + <div id="summary"> + <p id="totals"> </p> + <p id="duration"> </p> + </div> +</div> + +<div class="results"> +<div class="example_group"> + <dl> + <dt id="example_group_1">Mocker</dt> + <script type="text/javascript">moveProgressBar('5.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to call mock()</span></dd> + <script type="text/javascript">makeRed('rspec-header');</script> + <script type="text/javascript">makeRed('example_group_1');</script> + <script type="text/javascript">moveProgressBar('11.7');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when expected message not received</span> + <div class="failure" id="failure_1"> + <div class="message"><pre>Mock "poke me" expected :poke with (any args) once, but received it 0 times</pre></div> + <div class="backtrace"><pre>./examples/failing/mocking_example.rb:11: +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">9</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">should fail when expected message not received</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="linenum">10</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">poke me</span><span class="punct">")</span> +<span class="offending"><span class="linenum">11</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:poke</span><span class="punct">)</span></span> +<span class="linenum">12</span> <span class="keyword">end</span> +<span class="linenum">13</span> </code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('17.6');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when messages are received out of order</span> + <div class="failure" id="failure_2"> + <div class="message"><pre>Mock "one two three" received :three out of order</pre></div> + <div class="backtrace"><pre>./examples/failing/mocking_example.rb:20: +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">18</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:three</span><span class="punct">).</span><span class="ident">ordered</span> +<span class="linenum">19</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">one</span> +<span class="offending"><span class="linenum">20</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">three</span></span> +<span class="linenum">21</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">two</span> +<span class="linenum">22</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('23.5');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should get yelled at when sending unexpected messages</span> + <div class="failure" id="failure_3"> + <div class="message"><pre>Mock "don't talk to me" expected :any_message_at_all with (no args) 0 times, but received it once</pre></div> + <div class="backtrace"><pre>./examples/failing/mocking_example.rb:27: +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">25</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">don't talk to me</span><span class="punct">")</span> +<span class="linenum">26</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_not_receive</span><span class="punct">(</span><span class="symbol">:any_message_at_all</span><span class="punct">)</span> +<span class="offending"><span class="linenum">27</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">any_message_at_all</span></span> +<span class="linenum">28</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('29.4');</script> + <dd class="spec pending_fixed"> + <span class="failed_spec_name">has a bug we need to fix</span> + <div class="failure" id="failure_4"> + <div class="message"><pre>Expected pending 'here is the bug' to fail. No Error was raised.</pre></div> + <div class="backtrace"><pre>./examples/failing/mocking_example.rb:31: +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">29</span> +<span class="linenum">30</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">has a bug we need to fix</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="offending"><span class="linenum">31</span> <span class="ident">pending</span> <span class="punct">"</span><span class="string">here is the bug</span><span class="punct">"</span> <span class="keyword">do</span></span> +<span class="linenum">32</span> <span class="comment"># Actually, no. It's fixed. This will fail because it passes :-)</span> +<span class="linenum">33</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">Bug</span><span class="punct">")</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_2">Running specs with --diff</dt> + <script type="text/javascript">makeRed('example_group_2');</script> + <script type="text/javascript">moveProgressBar('35.2');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different strings</span> + <div class="failure" id="failure_5"> + <div class="message"><pre>expected: "RSpec is a\nbehaviour driven development\nframework for Ruby\n", + got: "RSpec is a\nbehavior driven development\nframework for Ruby\n" (using ==) + + Diff: +@@ -1,4 +1,4 @@ + RSpec is a +-behaviour driven development ++behavior driven development + framework for Ruby +</pre></div> + <div class="backtrace"><pre>./examples/failing/diffing_spec.rb:13: +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">11</span><span class="ident">framework</span> <span class="keyword">for</span> <span class="constant">Ruby</span> +<span class="linenum">12</span><span class="constant">EOF</span> +<span class="offending"><span class="linenum">13</span> <span class="ident">usa</span><span class="punct">.</span><span class="ident">should</span> <span class="punct">==</span> <span class="ident">uk</span></span> +<span class="linenum">14</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('41.1');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different objects' pretty representation</span> + <div class="failure" id="failure_6"> + <div class="message"><pre> +expected <Animal +name=bob, +species=tortoise +> + + got <Animal +name=bob, +species=giraffe +> + + +(compared using eql?) +</pre></div> + <div class="backtrace"><pre>./examples/failing/diffing_spec.rb:34: +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41: +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:</pre></div> + <pre class="ruby"><code><span class="linenum">32</span> <span class="ident">expected</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">giraffe</span><span class="punct">"</span> +<span class="linenum">33</span> <span class="ident">actual</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">tortoise</span><span class="punct">"</span> +<span class="offending"><span class="linenum">34</span> <span class="ident">expected</span><span class="punct">.</span><span class="ident">should</span> <span class="ident">eql</span><span class="punct">(</span><span class="ident">actual</span><span class="punct">)</span></span> +<span class="linenum">35</span> <span class="keyword">end</span> +<span class="linenum">36</span><span class="keyword">end</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_3">A consumer of a stub</dt> + <script type="text/javascript">moveProgressBar('47.0');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to stub methods on any Object</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_4">A stubbed method on a class</dt> + <script type="text/javascript">moveProgressBar('52.9');</script> + <dd class="spec passed"><span class="passed_spec_name">should return the stubbed value</span></dd> + <script type="text/javascript">moveProgressBar('58.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should revert to the original method after each spec</span></dd> + <script type="text/javascript">moveProgressBar('64.7');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_5">A mock</dt> + <script type="text/javascript">moveProgressBar('70.5');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub!</span></dd> + <script type="text/javascript">moveProgressBar('76.4');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock</span></dd> + <script type="text/javascript">moveProgressBar('82.3');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_6">pending example (using pending method)</dt> + <script type="text/javascript">makeYellow('example_group_6');</script> + <script type="text/javascript">moveProgressBar('88.2');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_7">pending example (with no block)</dt> + <script type="text/javascript">makeYellow('example_group_7');</script> + <script type="text/javascript">moveProgressBar('94.1');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: Not Yet Implemented" (PENDING: Not Yet Implemented)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_8">pending example (with block for pending)</dt> + <script type="text/javascript">makeYellow('example_group_8');</script> + <script type="text/javascript">moveProgressBar('100.0');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should have a failing block, passed to pending, reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<script type="text/javascript">document.getElementById('duration').innerHTML = "Finished in <strong>x seconds</strong>";</script> +<script type="text/javascript">document.getElementById('totals').innerHTML = "17 examples, 6 failures, 3 pending";</script> +</div> +</div> +</body> +</html> diff --git a/vendor/plugins/rspec/spec/spec/runner/formatter/html_formatted-1.9.1.html b/vendor/plugins/rspec/spec/spec/runner/formatter/html_formatted-1.9.1.html new file mode 100644 index 000000000..5d0be3bfe --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/runner/formatter/html_formatted-1.9.1.html @@ -0,0 +1,377 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> +<head> + <title>RSpec results</title> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> + <meta http-equiv="Expires" content="-1" /> + <meta http-equiv="Pragma" content="no-cache" /> + <style type="text/css"> + body { + margin: 0; + padding: 0; + background: #fff; + font-size: 80%; + } + </style> + <script type="text/javascript"> + // <![CDATA[ +function moveProgressBar(percentDone) { + document.getElementById("rspec-header").style.width = percentDone +"%"; +} +function makeRed(element_id) { + document.getElementById(element_id).style.background = '#C40D0D'; + document.getElementById(element_id).style.color = '#FFFFFF'; +} + +function makeYellow(element_id) { + if (element_id == "rspec-header" && document.getElementById(element_id).style.background != '#C40D0D') + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } + else + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } +} + + // ]]> + </script> + <style type="text/css"> +#rspec-header { + background: #65C400; color: #fff; height: 4em; +} + +.rspec-report h1 { + margin: 0px 10px 0px 10px; + padding: 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + font-size: 1.8em; + position: absolute; +} + +#summary { + margin: 0; padding: 5px 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + text-align: right; + top: 0px; + right: 0px; + float:right; +} + +#summary p { + margin: 0 0 0 2px; +} + +#summary #totals { + font-size: 1.2em; +} + +.example_group { + margin: 0 10px 5px; + background: #fff; +} + +dl { + margin: 0; padding: 0 0 5px; + font: normal 11px "Lucida Grande", Helvetica, sans-serif; +} + +dt { + padding: 3px; + background: #65C400; + color: #fff; + font-weight: bold; +} + +dd { + margin: 5px 0 5px 5px; + padding: 3px 3px 3px 18px; +} + +dd.spec.passed { + border-left: 5px solid #65C400; + border-bottom: 1px solid #65C400; + background: #DBFFB4; color: #3D7700; +} + +dd.spec.failed { + border-left: 5px solid #C20000; + border-bottom: 1px solid #C20000; + color: #C20000; background: #FFFBD3; +} + +dd.spec.not_implemented { + border-left: 5px solid #FAF834; + border-bottom: 1px solid #FAF834; + background: #FCFB98; color: #131313; +} + +dd.spec.pending_fixed { + border-left: 5px solid #0000C2; + border-bottom: 1px solid #0000C2; + color: #0000C2; background: #D3FBFF; +} + +.backtrace { + color: #000; + font-size: 12px; +} + +a { + color: #BE5C00; +} + +/* Ruby code, style similar to vibrant ink */ +.ruby { + font-size: 12px; + font-family: monospace; + color: white; + background-color: black; + padding: 0.1em 0 0.2em 0; +} + +.ruby .keyword { color: #FF6600; } +.ruby .constant { color: #339999; } +.ruby .attribute { color: white; } +.ruby .global { color: white; } +.ruby .module { color: white; } +.ruby .class { color: white; } +.ruby .string { color: #66FF00; } +.ruby .ident { color: white; } +.ruby .method { color: #FFCC00; } +.ruby .number { color: white; } +.ruby .char { color: white; } +.ruby .comment { color: #9933CC; } +.ruby .symbol { color: white; } +.ruby .regex { color: #44B4CC; } +.ruby .punct { color: white; } +.ruby .escape { color: white; } +.ruby .interp { color: white; } +.ruby .expr { color: white; } + +.ruby .offending { background-color: gray; } +.ruby .linenum { + width: 75px; + padding: 0.1em 1em 0.2em 0; + color: #000000; + background-color: #FFFBD3; +} + + </style> +</head> +<body> +<div class="rspec-report"> + +<div id="rspec-header"> + <div id="label"> + <h1>RSpec Code Examples</h1> + </div> + + <div id="summary"> + <p id="totals"> </p> + <p id="duration"> </p> + </div> +</div> + +<div class="results"> +<div class="example_group"> + <dl> + <dt id="example_group_1">Mocker</dt> + <script type="text/javascript">moveProgressBar('5.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to call mock()</span></dd> + <script type="text/javascript">makeRed('rspec-header');</script> + <script type="text/javascript">makeRed('example_group_1');</script> + <script type="text/javascript">moveProgressBar('11.7');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when expected message not received</span> + <div class="failure" id="failure_1"> + <div class="message"><pre>Mock "poke me" expected :poke with (any args) once, but received it 0 times</pre></div> + <div class="backtrace"><pre>./examples/failing/mocking_example.rb:11:in `block (2 levels) in <top (required)>' +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41:in `block (4 levels) in <module:Formatter>' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">9</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">should fail when expected message not received</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="linenum">10</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">poke me</span><span class="punct">")</span> +<span class="offending"><span class="linenum">11</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:poke</span><span class="punct">)</span></span> +<span class="linenum">12</span> <span class="keyword">end</span> +<span class="linenum">13</span> </code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('17.6');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when messages are received out of order</span> + <div class="failure" id="failure_2"> + <div class="message"><pre>Mock "one two three" received :three out of order</pre></div> + <div class="backtrace"><pre>./examples/failing/mocking_example.rb:20:in `block (2 levels) in <top (required)>' +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41:in `block (4 levels) in <module:Formatter>' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">18</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:three</span><span class="punct">).</span><span class="ident">ordered</span> +<span class="linenum">19</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">one</span> +<span class="offending"><span class="linenum">20</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">three</span></span> +<span class="linenum">21</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">two</span> +<span class="linenum">22</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('23.5');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should get yelled at when sending unexpected messages</span> + <div class="failure" id="failure_3"> + <div class="message"><pre>Mock "don't talk to me" expected :any_message_at_all with (no args) 0 times, but received it once</pre></div> + <div class="backtrace"><pre>./examples/failing/mocking_example.rb:27:in `block (2 levels) in <top (required)>' +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41:in `block (4 levels) in <module:Formatter>' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">25</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">don't talk to me</span><span class="punct">")</span> +<span class="linenum">26</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_not_receive</span><span class="punct">(</span><span class="symbol">:any_message_at_all</span><span class="punct">)</span> +<span class="offending"><span class="linenum">27</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">any_message_at_all</span></span> +<span class="linenum">28</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('29.4');</script> + <dd class="spec pending_fixed"> + <span class="failed_spec_name">has a bug we need to fix</span> + <div class="failure" id="failure_4"> + <div class="message"><pre>Expected pending 'here is the bug' to fail. No Error was raised.</pre></div> + <div class="backtrace"><pre>./examples/failing/mocking_example.rb:31:in `block (2 levels) in <top (required)>' +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41:in `block (4 levels) in <module:Formatter>' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">29</span> +<span class="linenum">30</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">has a bug we need to fix</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="offending"><span class="linenum">31</span> <span class="ident">pending</span> <span class="punct">"</span><span class="string">here is the bug</span><span class="punct">"</span> <span class="keyword">do</span></span> +<span class="linenum">32</span> <span class="comment"># Actually, no. It's fixed. This will fail because it passes :-)</span> +<span class="linenum">33</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">Bug</span><span class="punct">")</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_2">Running specs with --diff</dt> + <script type="text/javascript">makeRed('example_group_2');</script> + <script type="text/javascript">moveProgressBar('35.2');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different strings</span> + <div class="failure" id="failure_5"> + <div class="message"><pre>expected: "RSpec is a\nbehaviour driven development\nframework for Ruby\n", + got: "RSpec is a\nbehavior driven development\nframework for Ruby\n" (using ==) + + Diff: +@@ -1,4 +1,4 @@ + RSpec is a +-behaviour driven development ++behavior driven development + framework for Ruby +</pre></div> + <div class="backtrace"><pre>./examples/failing/diffing_spec.rb:13:in `block (2 levels) in <top (required)>' +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41:in `block (4 levels) in <module:Formatter>' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">11</span><span class="ident">framework</span> <span class="keyword">for</span> <span class="constant">Ruby</span> +<span class="linenum">12</span><span class="constant">EOF</span> +<span class="offending"><span class="linenum">13</span> <span class="ident">usa</span><span class="punct">.</span><span class="ident">should</span> <span class="punct">==</span> <span class="ident">uk</span></span> +<span class="linenum">14</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('41.1');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different objects' pretty representation</span> + <div class="failure" id="failure_6"> + <div class="message"><pre> +expected <Animal +name=bob, +species=tortoise +> + + got <Animal +name=bob, +species=giraffe +> + + +(compared using eql?) +</pre></div> + <div class="backtrace"><pre>./examples/failing/diffing_spec.rb:34:in `block (2 levels) in <top (required)>' +./spec/spec_helper.rb:42:in `run_with' +./spec/spec/runner/formatter/html_formatter_spec.rb:41:in `block (4 levels) in <module:Formatter>' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `chdir' +./spec/spec/runner/formatter/html_formatter_spec.rb:29:in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">32</span> <span class="ident">expected</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">giraffe</span><span class="punct">"</span> +<span class="linenum">33</span> <span class="ident">actual</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">tortoise</span><span class="punct">"</span> +<span class="offending"><span class="linenum">34</span> <span class="ident">expected</span><span class="punct">.</span><span class="ident">should</span> <span class="ident">eql</span><span class="punct">(</span><span class="ident">actual</span><span class="punct">)</span></span> +<span class="linenum">35</span> <span class="keyword">end</span> +<span class="linenum">36</span><span class="keyword">end</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_3">A consumer of a stub</dt> + <script type="text/javascript">moveProgressBar('47.0');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to stub methods on any Object</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_4">A stubbed method on a class</dt> + <script type="text/javascript">moveProgressBar('52.9');</script> + <dd class="spec passed"><span class="passed_spec_name">should return the stubbed value</span></dd> + <script type="text/javascript">moveProgressBar('58.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should revert to the original method after each spec</span></dd> + <script type="text/javascript">moveProgressBar('64.7');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_5">A mock</dt> + <script type="text/javascript">moveProgressBar('70.5');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub!</span></dd> + <script type="text/javascript">moveProgressBar('76.4');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock</span></dd> + <script type="text/javascript">moveProgressBar('82.3');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_6">pending example (using pending method)</dt> + <script type="text/javascript">makeYellow('example_group_6');</script> + <script type="text/javascript">moveProgressBar('88.2');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_7">pending example (with no block)</dt> + <script type="text/javascript">makeYellow('example_group_7');</script> + <script type="text/javascript">moveProgressBar('94.1');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: Not Yet Implemented" (PENDING: Not Yet Implemented)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_8">pending example (with block for pending)</dt> + <script type="text/javascript">makeYellow('example_group_8');</script> + <script type="text/javascript">moveProgressBar('100.0');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should have a failing block, passed to pending, reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<script type="text/javascript">document.getElementById('duration').innerHTML = "Finished in <strong>x seconds</strong>";</script> +<script type="text/javascript">document.getElementById('totals').innerHTML = "17 examples, 6 failures, 3 pending";</script> +</div> +</div> +</body> +</html> diff --git a/vendor/plugins/rspec/spec/spec/runner/formatter/text_mate_formatted-1.8.6-jruby.html b/vendor/plugins/rspec/spec/spec/runner/formatter/text_mate_formatted-1.8.6-jruby.html new file mode 100644 index 000000000..bbef5eb8b --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/runner/formatter/text_mate_formatted-1.8.6-jruby.html @@ -0,0 +1,371 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> +<head> + <title>RSpec results</title> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> + <meta http-equiv="Expires" content="-1" /> + <meta http-equiv="Pragma" content="no-cache" /> + <style type="text/css"> + body { + margin: 0; + padding: 0; + background: #fff; + font-size: 80%; + } + </style> + <script type="text/javascript"> + // <![CDATA[ +function moveProgressBar(percentDone) { + document.getElementById("rspec-header").style.width = percentDone +"%"; +} +function makeRed(element_id) { + document.getElementById(element_id).style.background = '#C40D0D'; + document.getElementById(element_id).style.color = '#FFFFFF'; +} + +function makeYellow(element_id) { + if (element_id == "rspec-header" && document.getElementById(element_id).style.background != '#C40D0D') + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } + else + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } +} + + // ]]> + </script> + <style type="text/css"> +#rspec-header { + background: #65C400; color: #fff; height: 4em; +} + +.rspec-report h1 { + margin: 0px 10px 0px 10px; + padding: 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + font-size: 1.8em; + position: absolute; +} + +#summary { + margin: 0; padding: 5px 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + text-align: right; + top: 0px; + right: 0px; + float:right; +} + +#summary p { + margin: 0 0 0 2px; +} + +#summary #totals { + font-size: 1.2em; +} + +.example_group { + margin: 0 10px 5px; + background: #fff; +} + +dl { + margin: 0; padding: 0 0 5px; + font: normal 11px "Lucida Grande", Helvetica, sans-serif; +} + +dt { + padding: 3px; + background: #65C400; + color: #fff; + font-weight: bold; +} + +dd { + margin: 5px 0 5px 5px; + padding: 3px 3px 3px 18px; +} + +dd.spec.passed { + border-left: 5px solid #65C400; + border-bottom: 1px solid #65C400; + background: #DBFFB4; color: #3D7700; +} + +dd.spec.failed { + border-left: 5px solid #C20000; + border-bottom: 1px solid #C20000; + color: #C20000; background: #FFFBD3; +} + +dd.spec.not_implemented { + border-left: 5px solid #FAF834; + border-bottom: 1px solid #FAF834; + background: #FCFB98; color: #131313; +} + +dd.spec.pending_fixed { + border-left: 5px solid #0000C2; + border-bottom: 1px solid #0000C2; + color: #0000C2; background: #D3FBFF; +} + +.backtrace { + color: #000; + font-size: 12px; +} + +a { + color: #BE5C00; +} + +/* Ruby code, style similar to vibrant ink */ +.ruby { + font-size: 12px; + font-family: monospace; + color: white; + background-color: black; + padding: 0.1em 0 0.2em 0; +} + +.ruby .keyword { color: #FF6600; } +.ruby .constant { color: #339999; } +.ruby .attribute { color: white; } +.ruby .global { color: white; } +.ruby .module { color: white; } +.ruby .class { color: white; } +.ruby .string { color: #66FF00; } +.ruby .ident { color: white; } +.ruby .method { color: #FFCC00; } +.ruby .number { color: white; } +.ruby .char { color: white; } +.ruby .comment { color: #9933CC; } +.ruby .symbol { color: white; } +.ruby .regex { color: #44B4CC; } +.ruby .punct { color: white; } +.ruby .escape { color: white; } +.ruby .interp { color: white; } +.ruby .expr { color: white; } + +.ruby .offending { background-color: gray; } +.ruby .linenum { + width: 75px; + padding: 0.1em 1em 0.2em 0; + color: #000000; + background-color: #FFFBD3; +} + + </style> +</head> +<body> +<div class="rspec-report"> + +<div id="rspec-header"> + <div id="label"> + <h1>RSpec Code Examples</h1> + </div> + + <div id="summary"> + <p id="totals"> </p> + <p id="duration"> </p> + </div> +</div> + +<div class="results"> +<div class="example_group"> + <dl> + <dt id="example_group_1">Mocker</dt> + <script type="text/javascript">moveProgressBar('5.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to call mock()</span></dd> + <script type="text/javascript">makeRed('rspec-header');</script> + <script type="text/javascript">makeRed('example_group_1');</script> + <script type="text/javascript">moveProgressBar('11.7');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when expected message not received</span> + <div class="failure" id="failure_1"> + <div class="message"><pre>Mock "poke me" expected :poke with (any args) once, but received it 0 times</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=11">examples/failing/mocking_example.rb:11</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">9</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">should fail when expected message not received</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="linenum">10</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">poke me</span><span class="punct">")</span> +<span class="offending"><span class="linenum">11</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:poke</span><span class="punct">)</span></span> +<span class="linenum">12</span> <span class="keyword">end</span> +<span class="linenum">13</span> </code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('17.6');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when messages are received out of order</span> + <div class="failure" id="failure_2"> + <div class="message"><pre>Mock "one two three" received :three out of order</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=20">examples/failing/mocking_example.rb:20</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">18</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:three</span><span class="punct">).</span><span class="ident">ordered</span> +<span class="linenum">19</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">one</span> +<span class="offending"><span class="linenum">20</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">three</span></span> +<span class="linenum">21</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">two</span> +<span class="linenum">22</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('23.5');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should get yelled at when sending unexpected messages</span> + <div class="failure" id="failure_3"> + <div class="message"><pre>Mock "don't talk to me" expected :any_message_at_all with (no args) 0 times, but received it once</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=27">examples/failing/mocking_example.rb:27</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">25</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">don't talk to me</span><span class="punct">")</span> +<span class="linenum">26</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_not_receive</span><span class="punct">(</span><span class="symbol">:any_message_at_all</span><span class="punct">)</span> +<span class="offending"><span class="linenum">27</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">any_message_at_all</span></span> +<span class="linenum">28</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('29.4');</script> + <dd class="spec pending_fixed"> + <span class="failed_spec_name">has a bug we need to fix</span> + <div class="failure" id="failure_4"> + <div class="message"><pre>Expected pending 'here is the bug' to fail. No Error was raised.</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=31">examples/failing/mocking_example.rb:31</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">29</span> +<span class="linenum">30</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">has a bug we need to fix</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="offending"><span class="linenum">31</span> <span class="ident">pending</span> <span class="punct">"</span><span class="string">here is the bug</span><span class="punct">"</span> <span class="keyword">do</span></span> +<span class="linenum">32</span> <span class="comment"># Actually, no. It's fixed. This will fail because it passes :-)</span> +<span class="linenum">33</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">Bug</span><span class="punct">")</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_2">Running specs with --diff</dt> + <script type="text/javascript">makeRed('example_group_2');</script> + <script type="text/javascript">moveProgressBar('35.2');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different strings</span> + <div class="failure" id="failure_5"> + <div class="message"><pre>expected: "RSpec is a\nbehaviour driven development\nframework for Ruby\n", + got: "RSpec is a\nbehavior driven development\nframework for Ruby\n" (using ==) + + Diff: +@@ -1,4 +1,4 @@ + RSpec is a +-behaviour driven development ++behavior driven development + framework for Ruby +</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/diffing_spec.rb&line=13">examples/failing/diffing_spec.rb:13</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">11</span><span class="ident">framework</span> <span class="keyword">for</span> <span class="constant">Ruby</span> +<span class="linenum">12</span><span class="constant">EOF</span> +<span class="offending"><span class="linenum">13</span> <span class="ident">usa</span><span class="punct">.</span><span class="ident">should</span> <span class="punct">==</span> <span class="ident">uk</span></span> +<span class="linenum">14</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('41.1');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different objects' pretty representation</span> + <div class="failure" id="failure_6"> + <div class="message"><pre> +expected <Animal +name=bob, +species=tortoise +> + + got <Animal +name=bob, +species=giraffe +> + + +(compared using eql?) +</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/diffing_spec.rb&line=34">examples/failing/diffing_spec.rb:34</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">32</span> <span class="ident">expected</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">giraffe</span><span class="punct">"</span> +<span class="linenum">33</span> <span class="ident">actual</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">tortoise</span><span class="punct">"</span> +<span class="offending"><span class="linenum">34</span> <span class="ident">expected</span><span class="punct">.</span><span class="ident">should</span> <span class="ident">eql</span><span class="punct">(</span><span class="ident">actual</span><span class="punct">)</span></span> +<span class="linenum">35</span> <span class="keyword">end</span> +<span class="linenum">36</span><span class="keyword">end</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_3">A consumer of a stub</dt> + <script type="text/javascript">moveProgressBar('47.0');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to stub methods on any Object</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_4">A stubbed method on a class</dt> + <script type="text/javascript">moveProgressBar('52.9');</script> + <dd class="spec passed"><span class="passed_spec_name">should return the stubbed value</span></dd> + <script type="text/javascript">moveProgressBar('58.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should revert to the original method after each spec</span></dd> + <script type="text/javascript">moveProgressBar('64.7');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_5">A mock</dt> + <script type="text/javascript">moveProgressBar('70.5');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub!</span></dd> + <script type="text/javascript">moveProgressBar('76.4');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock</span></dd> + <script type="text/javascript">moveProgressBar('82.3');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_6">pending example (using pending method)</dt> + <script type="text/javascript">makeYellow('example_group_6');</script> + <script type="text/javascript">moveProgressBar('88.2');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_7">pending example (with no block)</dt> + <script type="text/javascript">makeYellow('example_group_7');</script> + <script type="text/javascript">moveProgressBar('94.1');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: Not Yet Implemented" (PENDING: Not Yet Implemented)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_8">pending example (with block for pending)</dt> + <script type="text/javascript">makeYellow('example_group_8');</script> + <script type="text/javascript">moveProgressBar('100.0');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should have a failing block, passed to pending, reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<script type="text/javascript">document.getElementById('duration').innerHTML = "Finished in <strong>x seconds</strong>";</script> +<script type="text/javascript">document.getElementById('totals').innerHTML = "17 examples, 6 failures, 3 pending";</script> +</div> +</div> +</body> +</html> diff --git a/vendor/plugins/rspec/spec/spec/runner/formatter/text_mate_formatted-1.8.7.html b/vendor/plugins/rspec/spec/spec/runner/formatter/text_mate_formatted-1.8.7.html new file mode 100644 index 000000000..54d761901 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/runner/formatter/text_mate_formatted-1.8.7.html @@ -0,0 +1,371 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> +<head> + <title>RSpec results</title> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> + <meta http-equiv="Expires" content="-1" /> + <meta http-equiv="Pragma" content="no-cache" /> + <style type="text/css"> + body { + margin: 0; + padding: 0; + background: #fff; + font-size: 80%; + } + </style> + <script type="text/javascript"> + // <![CDATA[ +function moveProgressBar(percentDone) { + document.getElementById("rspec-header").style.width = percentDone +"%"; +} +function makeRed(element_id) { + document.getElementById(element_id).style.background = '#C40D0D'; + document.getElementById(element_id).style.color = '#FFFFFF'; +} + +function makeYellow(element_id) { + if (element_id == "rspec-header" && document.getElementById(element_id).style.background != '#C40D0D') + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } + else + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } +} + + // ]]> + </script> + <style type="text/css"> +#rspec-header { + background: #65C400; color: #fff; height: 4em; +} + +.rspec-report h1 { + margin: 0px 10px 0px 10px; + padding: 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + font-size: 1.8em; + position: absolute; +} + +#summary { + margin: 0; padding: 5px 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + text-align: right; + top: 0px; + right: 0px; + float:right; +} + +#summary p { + margin: 0 0 0 2px; +} + +#summary #totals { + font-size: 1.2em; +} + +.example_group { + margin: 0 10px 5px; + background: #fff; +} + +dl { + margin: 0; padding: 0 0 5px; + font: normal 11px "Lucida Grande", Helvetica, sans-serif; +} + +dt { + padding: 3px; + background: #65C400; + color: #fff; + font-weight: bold; +} + +dd { + margin: 5px 0 5px 5px; + padding: 3px 3px 3px 18px; +} + +dd.spec.passed { + border-left: 5px solid #65C400; + border-bottom: 1px solid #65C400; + background: #DBFFB4; color: #3D7700; +} + +dd.spec.failed { + border-left: 5px solid #C20000; + border-bottom: 1px solid #C20000; + color: #C20000; background: #FFFBD3; +} + +dd.spec.not_implemented { + border-left: 5px solid #FAF834; + border-bottom: 1px solid #FAF834; + background: #FCFB98; color: #131313; +} + +dd.spec.pending_fixed { + border-left: 5px solid #0000C2; + border-bottom: 1px solid #0000C2; + color: #0000C2; background: #D3FBFF; +} + +.backtrace { + color: #000; + font-size: 12px; +} + +a { + color: #BE5C00; +} + +/* Ruby code, style similar to vibrant ink */ +.ruby { + font-size: 12px; + font-family: monospace; + color: white; + background-color: black; + padding: 0.1em 0 0.2em 0; +} + +.ruby .keyword { color: #FF6600; } +.ruby .constant { color: #339999; } +.ruby .attribute { color: white; } +.ruby .global { color: white; } +.ruby .module { color: white; } +.ruby .class { color: white; } +.ruby .string { color: #66FF00; } +.ruby .ident { color: white; } +.ruby .method { color: #FFCC00; } +.ruby .number { color: white; } +.ruby .char { color: white; } +.ruby .comment { color: #9933CC; } +.ruby .symbol { color: white; } +.ruby .regex { color: #44B4CC; } +.ruby .punct { color: white; } +.ruby .escape { color: white; } +.ruby .interp { color: white; } +.ruby .expr { color: white; } + +.ruby .offending { background-color: gray; } +.ruby .linenum { + width: 75px; + padding: 0.1em 1em 0.2em 0; + color: #000000; + background-color: #FFFBD3; +} + + </style> +</head> +<body> +<div class="rspec-report"> + +<div id="rspec-header"> + <div id="label"> + <h1>RSpec Code Examples</h1> + </div> + + <div id="summary"> + <p id="totals"> </p> + <p id="duration"> </p> + </div> +</div> + +<div class="results"> +<div class="example_group"> + <dl> + <dt id="example_group_1">Mocker</dt> + <script type="text/javascript">moveProgressBar('5.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to call mock()</span></dd> + <script type="text/javascript">makeRed('rspec-header');</script> + <script type="text/javascript">makeRed('example_group_1');</script> + <script type="text/javascript">moveProgressBar('11.7');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when expected message not received</span> + <div class="failure" id="failure_1"> + <div class="message"><pre>Mock "poke me" expected :poke with (any args) once, but received it 0 times</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=11">./examples/failing/mocking_example.rb:11</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">9</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">should fail when expected message not received</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="linenum">10</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">poke me</span><span class="punct">")</span> +<span class="offending"><span class="linenum">11</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:poke</span><span class="punct">)</span></span> +<span class="linenum">12</span> <span class="keyword">end</span> +<span class="linenum">13</span> </code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('17.6');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when messages are received out of order</span> + <div class="failure" id="failure_2"> + <div class="message"><pre>Mock "one two three" received :three out of order</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=20">./examples/failing/mocking_example.rb:20</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">18</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:three</span><span class="punct">).</span><span class="ident">ordered</span> +<span class="linenum">19</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">one</span> +<span class="offending"><span class="linenum">20</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">three</span></span> +<span class="linenum">21</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">two</span> +<span class="linenum">22</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('23.5');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should get yelled at when sending unexpected messages</span> + <div class="failure" id="failure_3"> + <div class="message"><pre>Mock "don't talk to me" expected :any_message_at_all with (no args) 0 times, but received it once</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=27">./examples/failing/mocking_example.rb:27</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">25</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">don't talk to me</span><span class="punct">")</span> +<span class="linenum">26</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_not_receive</span><span class="punct">(</span><span class="symbol">:any_message_at_all</span><span class="punct">)</span> +<span class="offending"><span class="linenum">27</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">any_message_at_all</span></span> +<span class="linenum">28</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('29.4');</script> + <dd class="spec pending_fixed"> + <span class="failed_spec_name">has a bug we need to fix</span> + <div class="failure" id="failure_4"> + <div class="message"><pre>Expected pending 'here is the bug' to fail. No Error was raised.</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=31">./examples/failing/mocking_example.rb:31</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">29</span> +<span class="linenum">30</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">has a bug we need to fix</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="offending"><span class="linenum">31</span> <span class="ident">pending</span> <span class="punct">"</span><span class="string">here is the bug</span><span class="punct">"</span> <span class="keyword">do</span></span> +<span class="linenum">32</span> <span class="comment"># Actually, no. It's fixed. This will fail because it passes :-)</span> +<span class="linenum">33</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">Bug</span><span class="punct">")</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_2">Running specs with --diff</dt> + <script type="text/javascript">makeRed('example_group_2');</script> + <script type="text/javascript">moveProgressBar('35.2');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different strings</span> + <div class="failure" id="failure_5"> + <div class="message"><pre>expected: "RSpec is a\nbehaviour driven development\nframework for Ruby\n", + got: "RSpec is a\nbehavior driven development\nframework for Ruby\n" (using ==) + + Diff: +@@ -1,4 +1,4 @@ + RSpec is a +-behaviour driven development ++behavior driven development + framework for Ruby +</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/diffing_spec.rb&line=13">./examples/failing/diffing_spec.rb:13</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">11</span><span class="ident">framework</span> <span class="keyword">for</span> <span class="constant">Ruby</span> +<span class="linenum">12</span><span class="constant">EOF</span> +<span class="offending"><span class="linenum">13</span> <span class="ident">usa</span><span class="punct">.</span><span class="ident">should</span> <span class="punct">==</span> <span class="ident">uk</span></span> +<span class="linenum">14</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('41.1');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different objects' pretty representation</span> + <div class="failure" id="failure_6"> + <div class="message"><pre> +expected <Animal +name=bob, +species=tortoise +> + + got <Animal +name=bob, +species=giraffe +> + + +(compared using eql?) +</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/diffing_spec.rb&line=34">./examples/failing/diffing_spec.rb:34</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> </pre></div> + <pre class="ruby"><code><span class="linenum">32</span> <span class="ident">expected</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">giraffe</span><span class="punct">"</span> +<span class="linenum">33</span> <span class="ident">actual</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">tortoise</span><span class="punct">"</span> +<span class="offending"><span class="linenum">34</span> <span class="ident">expected</span><span class="punct">.</span><span class="ident">should</span> <span class="ident">eql</span><span class="punct">(</span><span class="ident">actual</span><span class="punct">)</span></span> +<span class="linenum">35</span> <span class="keyword">end</span> +<span class="linenum">36</span><span class="keyword">end</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_3">A consumer of a stub</dt> + <script type="text/javascript">moveProgressBar('47.0');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to stub methods on any Object</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_4">A stubbed method on a class</dt> + <script type="text/javascript">moveProgressBar('52.9');</script> + <dd class="spec passed"><span class="passed_spec_name">should return the stubbed value</span></dd> + <script type="text/javascript">moveProgressBar('58.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should revert to the original method after each spec</span></dd> + <script type="text/javascript">moveProgressBar('64.7');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_5">A mock</dt> + <script type="text/javascript">moveProgressBar('70.5');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub!</span></dd> + <script type="text/javascript">moveProgressBar('76.4');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock</span></dd> + <script type="text/javascript">moveProgressBar('82.3');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_6">pending example (using pending method)</dt> + <script type="text/javascript">makeYellow('example_group_6');</script> + <script type="text/javascript">moveProgressBar('88.2');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_7">pending example (with no block)</dt> + <script type="text/javascript">makeYellow('example_group_7');</script> + <script type="text/javascript">moveProgressBar('94.1');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: Not Yet Implemented" (PENDING: Not Yet Implemented)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_8">pending example (with block for pending)</dt> + <script type="text/javascript">makeYellow('example_group_8');</script> + <script type="text/javascript">moveProgressBar('100.0');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should have a failing block, passed to pending, reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<script type="text/javascript">document.getElementById('duration').innerHTML = "Finished in <strong>x seconds</strong>";</script> +<script type="text/javascript">document.getElementById('totals').innerHTML = "17 examples, 6 failures, 3 pending";</script> +</div> +</div> +</body> +</html> diff --git a/vendor/plugins/rspec/spec/spec/runner/formatter/text_mate_formatted-1.9.1.html b/vendor/plugins/rspec/spec/spec/runner/formatter/text_mate_formatted-1.9.1.html new file mode 100644 index 000000000..24c98046b --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/runner/formatter/text_mate_formatted-1.9.1.html @@ -0,0 +1,371 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE html + PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" + "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> +<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"> +<head> + <title>RSpec results</title> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> + <meta http-equiv="Expires" content="-1" /> + <meta http-equiv="Pragma" content="no-cache" /> + <style type="text/css"> + body { + margin: 0; + padding: 0; + background: #fff; + font-size: 80%; + } + </style> + <script type="text/javascript"> + // <![CDATA[ +function moveProgressBar(percentDone) { + document.getElementById("rspec-header").style.width = percentDone +"%"; +} +function makeRed(element_id) { + document.getElementById(element_id).style.background = '#C40D0D'; + document.getElementById(element_id).style.color = '#FFFFFF'; +} + +function makeYellow(element_id) { + if (element_id == "rspec-header" && document.getElementById(element_id).style.background != '#C40D0D') + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } + else + { + document.getElementById(element_id).style.background = '#FAF834'; + document.getElementById(element_id).style.color = '#000000'; + } +} + + // ]]> + </script> + <style type="text/css"> +#rspec-header { + background: #65C400; color: #fff; height: 4em; +} + +.rspec-report h1 { + margin: 0px 10px 0px 10px; + padding: 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + font-size: 1.8em; + position: absolute; +} + +#summary { + margin: 0; padding: 5px 10px; + font-family: "Lucida Grande", Helvetica, sans-serif; + text-align: right; + top: 0px; + right: 0px; + float:right; +} + +#summary p { + margin: 0 0 0 2px; +} + +#summary #totals { + font-size: 1.2em; +} + +.example_group { + margin: 0 10px 5px; + background: #fff; +} + +dl { + margin: 0; padding: 0 0 5px; + font: normal 11px "Lucida Grande", Helvetica, sans-serif; +} + +dt { + padding: 3px; + background: #65C400; + color: #fff; + font-weight: bold; +} + +dd { + margin: 5px 0 5px 5px; + padding: 3px 3px 3px 18px; +} + +dd.spec.passed { + border-left: 5px solid #65C400; + border-bottom: 1px solid #65C400; + background: #DBFFB4; color: #3D7700; +} + +dd.spec.failed { + border-left: 5px solid #C20000; + border-bottom: 1px solid #C20000; + color: #C20000; background: #FFFBD3; +} + +dd.spec.not_implemented { + border-left: 5px solid #FAF834; + border-bottom: 1px solid #FAF834; + background: #FCFB98; color: #131313; +} + +dd.spec.pending_fixed { + border-left: 5px solid #0000C2; + border-bottom: 1px solid #0000C2; + color: #0000C2; background: #D3FBFF; +} + +.backtrace { + color: #000; + font-size: 12px; +} + +a { + color: #BE5C00; +} + +/* Ruby code, style similar to vibrant ink */ +.ruby { + font-size: 12px; + font-family: monospace; + color: white; + background-color: black; + padding: 0.1em 0 0.2em 0; +} + +.ruby .keyword { color: #FF6600; } +.ruby .constant { color: #339999; } +.ruby .attribute { color: white; } +.ruby .global { color: white; } +.ruby .module { color: white; } +.ruby .class { color: white; } +.ruby .string { color: #66FF00; } +.ruby .ident { color: white; } +.ruby .method { color: #FFCC00; } +.ruby .number { color: white; } +.ruby .char { color: white; } +.ruby .comment { color: #9933CC; } +.ruby .symbol { color: white; } +.ruby .regex { color: #44B4CC; } +.ruby .punct { color: white; } +.ruby .escape { color: white; } +.ruby .interp { color: white; } +.ruby .expr { color: white; } + +.ruby .offending { background-color: gray; } +.ruby .linenum { + width: 75px; + padding: 0.1em 1em 0.2em 0; + color: #000000; + background-color: #FFFBD3; +} + + </style> +</head> +<body> +<div class="rspec-report"> + +<div id="rspec-header"> + <div id="label"> + <h1>RSpec Code Examples</h1> + </div> + + <div id="summary"> + <p id="totals"> </p> + <p id="duration"> </p> + </div> +</div> + +<div class="results"> +<div class="example_group"> + <dl> + <dt id="example_group_1">Mocker</dt> + <script type="text/javascript">moveProgressBar('5.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to call mock()</span></dd> + <script type="text/javascript">makeRed('rspec-header');</script> + <script type="text/javascript">makeRed('example_group_1');</script> + <script type="text/javascript">moveProgressBar('11.7');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when expected message not received</span> + <div class="failure" id="failure_1"> + <div class="message"><pre>Mock "poke me" expected :poke with (any args) once, but received it 0 times</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=11">./examples/failing/mocking_example.rb:11</a> :in `block (2 levels) in <top (required)>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> :in `block (4 levels) in <module:Formatter>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">9</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">should fail when expected message not received</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="linenum">10</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">poke me</span><span class="punct">")</span> +<span class="offending"><span class="linenum">11</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:poke</span><span class="punct">)</span></span> +<span class="linenum">12</span> <span class="keyword">end</span> +<span class="linenum">13</span> </code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('17.6');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should fail when messages are received out of order</span> + <div class="failure" id="failure_2"> + <div class="message"><pre>Mock "one two three" received :three out of order</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=20">./examples/failing/mocking_example.rb:20</a> :in `block (2 levels) in <top (required)>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> :in `block (4 levels) in <module:Formatter>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">18</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_receive</span><span class="punct">(</span><span class="symbol">:three</span><span class="punct">).</span><span class="ident">ordered</span> +<span class="linenum">19</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">one</span> +<span class="offending"><span class="linenum">20</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">three</span></span> +<span class="linenum">21</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">two</span> +<span class="linenum">22</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('23.5');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should get yelled at when sending unexpected messages</span> + <div class="failure" id="failure_3"> + <div class="message"><pre>Mock "don't talk to me" expected :any_message_at_all with (no args) 0 times, but received it once</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=27">./examples/failing/mocking_example.rb:27</a> :in `block (2 levels) in <top (required)>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> :in `block (4 levels) in <module:Formatter>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">25</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">don't talk to me</span><span class="punct">")</span> +<span class="linenum">26</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">should_not_receive</span><span class="punct">(</span><span class="symbol">:any_message_at_all</span><span class="punct">)</span> +<span class="offending"><span class="linenum">27</span> <span class="ident">mock</span><span class="punct">.</span><span class="ident">any_message_at_all</span></span> +<span class="linenum">28</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('29.4');</script> + <dd class="spec pending_fixed"> + <span class="failed_spec_name">has a bug we need to fix</span> + <div class="failure" id="failure_4"> + <div class="message"><pre>Expected pending 'here is the bug' to fail. No Error was raised.</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/mocking_example.rb&line=31">./examples/failing/mocking_example.rb:31</a> :in `block (2 levels) in <top (required)>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> :in `block (4 levels) in <module:Formatter>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">29</span> +<span class="linenum">30</span> <span class="ident">it</span> <span class="punct">"</span><span class="string">has a bug we need to fix</span><span class="punct">"</span> <span class="keyword">do</span> +<span class="offending"><span class="linenum">31</span> <span class="ident">pending</span> <span class="punct">"</span><span class="string">here is the bug</span><span class="punct">"</span> <span class="keyword">do</span></span> +<span class="linenum">32</span> <span class="comment"># Actually, no. It's fixed. This will fail because it passes :-)</span> +<span class="linenum">33</span> <span class="ident">mock</span> <span class="punct">=</span> <span class="ident">mock</span><span class="punct">("</span><span class="string">Bug</span><span class="punct">")</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_2">Running specs with --diff</dt> + <script type="text/javascript">makeRed('example_group_2');</script> + <script type="text/javascript">moveProgressBar('35.2');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different strings</span> + <div class="failure" id="failure_5"> + <div class="message"><pre>expected: "RSpec is a\nbehaviour driven development\nframework for Ruby\n", + got: "RSpec is a\nbehavior driven development\nframework for Ruby\n" (using ==) + + Diff: +@@ -1,4 +1,4 @@ + RSpec is a +-behaviour driven development ++behavior driven development + framework for Ruby +</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/diffing_spec.rb&line=13">./examples/failing/diffing_spec.rb:13</a> :in `block (2 levels) in <top (required)>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> :in `block (4 levels) in <module:Formatter>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">11</span><span class="ident">framework</span> <span class="keyword">for</span> <span class="constant">Ruby</span> +<span class="linenum">12</span><span class="constant">EOF</span> +<span class="offending"><span class="linenum">13</span> <span class="ident">usa</span><span class="punct">.</span><span class="ident">should</span> <span class="punct">==</span> <span class="ident">uk</span></span> +<span class="linenum">14</span> <span class="keyword">end</span></code></pre> + </div> + </dd> + <script type="text/javascript">moveProgressBar('41.1');</script> + <dd class="spec failed"> + <span class="failed_spec_name">should print diff of different objects' pretty representation</span> + <div class="failure" id="failure_6"> + <div class="message"><pre> +expected <Animal +name=bob, +species=tortoise +> + + got <Animal +name=bob, +species=giraffe +> + + +(compared using eql?) +</pre></div> + <div class="backtrace"><pre><a href="txmt://open?url=file://./examples/failing/diffing_spec.rb&line=34">./examples/failing/diffing_spec.rb:34</a> :in `block (2 levels) in <top (required)>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=49">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:49</a> :in `block (4 levels) in <module:Formatter>' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `chdir' +<a href="txmt://open?url=file://./spec/spec/runner/formatter/text_mate_formatter_spec.rb&line=45">./spec/spec/runner/formatter/text_mate_formatter_spec.rb:45</a> :in `block (3 levels) in <module:Formatter>'</pre></div> + <pre class="ruby"><code><span class="linenum">32</span> <span class="ident">expected</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">giraffe</span><span class="punct">"</span> +<span class="linenum">33</span> <span class="ident">actual</span> <span class="punct">=</span> <span class="constant">Animal</span><span class="punct">.</span><span class="ident">new</span> <span class="punct">"</span><span class="string">bob</span><span class="punct">",</span> <span class="punct">"</span><span class="string">tortoise</span><span class="punct">"</span> +<span class="offending"><span class="linenum">34</span> <span class="ident">expected</span><span class="punct">.</span><span class="ident">should</span> <span class="ident">eql</span><span class="punct">(</span><span class="ident">actual</span><span class="punct">)</span></span> +<span class="linenum">35</span> <span class="keyword">end</span> +<span class="linenum">36</span><span class="keyword">end</span></code></pre> + </div> + </dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_3">A consumer of a stub</dt> + <script type="text/javascript">moveProgressBar('47.0');</script> + <dd class="spec passed"><span class="passed_spec_name">should be able to stub methods on any Object</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_4">A stubbed method on a class</dt> + <script type="text/javascript">moveProgressBar('52.9');</script> + <dd class="spec passed"><span class="passed_spec_name">should return the stubbed value</span></dd> + <script type="text/javascript">moveProgressBar('58.8');</script> + <dd class="spec passed"><span class="passed_spec_name">should revert to the original method after each spec</span></dd> + <script type="text/javascript">moveProgressBar('64.7');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_5">A mock</dt> + <script type="text/javascript">moveProgressBar('70.5');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub!</span></dd> + <script type="text/javascript">moveProgressBar('76.4');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock</span></dd> + <script type="text/javascript">moveProgressBar('82.3');</script> + <dd class="spec passed"><span class="passed_spec_name">can stub! and mock the same message</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_6">pending example (using pending method)</dt> + <script type="text/javascript">makeYellow('example_group_6');</script> + <script type="text/javascript">moveProgressBar('88.2');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_7">pending example (with no block)</dt> + <script type="text/javascript">makeYellow('example_group_7');</script> + <script type="text/javascript">moveProgressBar('94.1');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should be reported as "PENDING: Not Yet Implemented" (PENDING: Not Yet Implemented)</span></dd> + </dl> +</div> +<div class="example_group"> + <dl> + <dt id="example_group_8">pending example (with block for pending)</dt> + <script type="text/javascript">makeYellow('example_group_8');</script> + <script type="text/javascript">moveProgressBar('100.0');</script> + <dd class="spec not_implemented"><span class="not_implemented_spec_name">should have a failing block, passed to pending, reported as "PENDING: for some reason" (PENDING: for some reason)</span></dd> + </dl> +</div> +<script type="text/javascript">document.getElementById('duration').innerHTML = "Finished in <strong>x seconds</strong>";</script> +<script type="text/javascript">document.getElementById('totals').innerHTML = "17 examples, 6 failures, 3 pending";</script> +</div> +</div> +</body> +</html> diff --git a/vendor/plugins/rspec/spec/spec/runner/formatter/text_mate_formatter_spec.rb b/vendor/plugins/rspec/spec/spec/runner/formatter/text_mate_formatter_spec.rb new file mode 100644 index 000000000..a35ad89f5 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/runner/formatter/text_mate_formatter_spec.rb @@ -0,0 +1,106 @@ +require 'spec_helper' + +begin # See rescue all the way at the bottom + +require 'nokogiri' # Needed to compare generated with wanted HTML +require 'spec/runner/formatter/text_mate_formatter' + +module Spec + module Runner + module Formatter + describe TextMateFormatter do + attr_reader :root, :suffix, :expected_file + before do + @root = File.expand_path(File.dirname(__FILE__) + '/../../../..') + @suffix = jruby? ? '-jruby' : '' + @expected_file = File.dirname(__FILE__) + "/text_mate_formatted-#{::RUBY_VERSION}#{suffix}.html" + end + + def produces_html_identical_to_manually_designed_document(opt) + root = File.expand_path(File.dirname(__FILE__) + '/../../../..') + + Dir.chdir(root) do + args = [ + 'examples/failing/mocking_example.rb', + 'examples/failing/diffing_spec.rb', + 'examples/passing/stubbing_example.rb', + 'examples/passing/pending_example.rb', + '--format', + 'textmate', + opt + ] + err = StringIO.new + out = StringIO.new + + run_with ::Spec::Runner::OptionParser.parse(args, err, out) + + yield(out.string) + end + end + + # Uncomment this spec temporarily in order to overwrite the expected with actual. + # Use with care!!! + # describe "functional spec file generator" do + # it "generates a new comparison file" do + # Dir.chdir(root) do + # args = ['examples/failing/mocking_example.rb', 'examples/failing/diffing_spec.rb', 'examples/passing/stubbing_example.rb', 'examples/passing/pending_example.rb', '--format', 'textmate', '--diff'] + # err = StringIO.new + # out = StringIO.new + # Spec::Runner::CommandLine.run( + # ::Spec::Runner::OptionParser.parse(args, err, out) + # ) + # + # seconds = /\d+\.\d+ seconds/ + # html = out.string.gsub seconds, 'x seconds' + # + # File.open(expected_file, 'w') {|io| io.write(html)} + # end + # end + # end + + describe "functional spec using --diff" do + it "should produce HTML identical to the one we designed manually with --diff" do + produces_html_identical_to_manually_designed_document("--diff") do |html| + suffix = jruby? ? '-jruby' : '' + expected_file = File.dirname(__FILE__) + "/text_mate_formatted-#{::RUBY_VERSION}#{suffix}.html" + unless File.file?(expected_file) + raise "There is no HTML file with expected content for this platform: #{expected_file}" + end + expected_html = File.read(expected_file) + + seconds = /\d+\.\d+ seconds/ + html.gsub! seconds, 'x seconds' + expected_html.gsub! seconds, 'x seconds' + + doc = Nokogiri::HTML(html) + backtraces = doc.search("div.backtrace a") + doc.search("div.backtrace").remove + + expected_doc = Nokogiri::HTML(expected_html) + expected_doc.search("div.backtrace").remove + + doc.inner_html.should == expected_doc.inner_html + + backtraces.each do |backtrace_link| + backtrace_link['href'].should include("txmt://open?url=") + end + end + end + + end + + describe "functional spec using --dry-run" do + it "should produce HTML identical to the one we designed manually with --dry-run" do + produces_html_identical_to_manually_designed_document("--dry-run") do |html, expected_html| + html.should =~ /This was a dry-run/m + end + end + end + end + end + end +end + +rescue LoadError + warn "nokogiri not loaded -- skipping TextMateFormatter specs" +end diff --git a/vendor/plugins/rspec/spec/spec/runner/line_number_query/line_number_query_fixture.rb b/vendor/plugins/rspec/spec/spec/runner/line_number_query/line_number_query_fixture.rb new file mode 100644 index 000000000..82a257d3b --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/runner/line_number_query/line_number_query_fixture.rb @@ -0,0 +1,70 @@ +require 'spec_helper' + +describe "c" do + + it "1" do + end + + it "2" do + end + +end + +describe "d" do + + it "3" do + end + + it "4" do + end + +end + +class LineNumberQuerySubject +end + +describe LineNumberQuerySubject do + + it "5" do + end + +end + +describe LineNumberQuerySubject, "described" do + + it "6" do + end + +end + +describe LineNumberQuerySubject, "described", :something => :something_else do + + it "7" do + end + +end + +describe "described", :something => :something_else do + + it "8" do + end + +end + +describe "e" do + + it "9" do + end + + it "10" do + end + + describe "f" do + it "11" do + end + + it "12" do + end + end + +end diff --git a/vendor/plugins/rspec/spec/spec/runner/line_number_query_spec.rb b/vendor/plugins/rspec/spec/spec/runner/line_number_query_spec.rb new file mode 100644 index 000000000..e4e11050d --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/runner/line_number_query_spec.rb @@ -0,0 +1,129 @@ +require 'spec_helper' + +describe "LineNumberQuery" do + with_sandboxed_options do + attr_reader :parser, :file + + before do + @parser = Spec::Runner::LineNumberQuery.new(options) + @file = "#{File.dirname(__FILE__)}/line_number_query/line_number_query_fixture.rb" + load file + end + + it "should find spec name for 'specify' at same line" do + parser.spec_name_for(file, 5).should == "c 1" + end + + it "should find spec name for 'specify' at end of spec line" do + parser.spec_name_for(file, 6).should == "c 1" + end + + it "should find context for 'context' above all specs" do + parser.spec_name_for(file, 4).should == "c" + end + + it "should find spec name for 'it' at same line" do + parser.spec_name_for(file, 15).should == "d 3" + end + + it "should find spec name for 'it' at end of spec line" do + parser.spec_name_for(file, 16).should == "d 3" + end + + it "should find context for 'describe' above all specs" do + parser.spec_name_for(file, 14).should == "d" + end + + it "should find nearest example name between examples" do + parser.spec_name_for(file, 7).should == "c 1" + end + + it "should find nothing outside a context" do + parser.spec_name_for(file, 2).should be_nil + end + + it "should find context name for type" do + parser.spec_name_for(file, 26).should == "LineNumberQuerySubject" + end + + it "should find context and spec name for type" do + parser.spec_name_for(file, 28).should == "LineNumberQuerySubject 5" + end + + it "should find context and description for type" do + parser.spec_name_for(file, 33).should == "LineNumberQuerySubject described" + end + + it "should find context and description and example for type" do + parser.spec_name_for(file, 36).should == "LineNumberQuerySubject described 6" + end + + it "should find context and description for type with modifications" do + parser.spec_name_for(file, 40).should == "LineNumberQuerySubject described" + end + + it "should find context and described and example for type with modifications" do + parser.spec_name_for(file, 43).should == "LineNumberQuerySubject described 7" + end + + it "should find example group" do + parser.spec_name_for(file, 47).should == "described" + end + + it "should find example" do + parser.spec_name_for(file, 50).should == "described 8" + end + + it "should find nested example" do + parser.spec_name_for(file, 63).should == "e f 11" + end + + it "should handle paths which contain colons" do + fixture = + { "c:/somepath/somefile.rb:999:in 'method'" => "c:/somepath/somefile.rb", + "./somepath/somefile:999" => "./somepath/somefile" } + fixture.each_pair do |input, expected| + parser.send(:parse_location, input ).should == [expected, 999] + end + end + + it "should handle paths which contain colons and backslashes" do + fixture = + { "c:\\somepath\\somefile.rb:999:in 'method'" => "c:\\somepath\\somefile.rb", + ".\\somepath\\somefile:999" => ".\\somepath\\somefile" } + fixture.each_pair do |input, expected| + parser.send(:parse_location, input ).should == [expected, 999] + end + end + + it "ignores example group base classes which have no location" do + options = stub('options', :example_groups => [ + stub('example_group', :location => nil) + ]) + parser = Spec::Runner::LineNumberQuery.new(options) + parser.spec_name_for('foo',37).should == nil + end + + describe "#example_line_for" do + it "should find example declared on same line" do + parser.example_line_for(file, 5).should == 5 + end + + it "should find example declared on the line above, while still inside the example" do + parser.example_line_for(file, 6).should == 5 + end + + it "should find example declared from empty line below the example" do + parser.example_line_for(file, 7).should == 5 + end + + it "should find the group declared on the same line" do + parser.example_line_for(file, 3).should == 3 + end + + it "should find the group declared above the first example" do + parser.example_line_for(file, 4).should == 3 + end + end + end +end diff --git a/vendor/plugins/rspec/spec/spec/runner/resources/custom_example_group_runner.rb b/vendor/plugins/rspec/spec/spec/runner/resources/custom_example_group_runner.rb new file mode 100644 index 000000000..edcf54e96 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/runner/resources/custom_example_group_runner.rb @@ -0,0 +1,14 @@ +module Custom + class ExampleGroupRunner + attr_reader :options, :arg + def initialize(options, arg) + @options, @arg = options, arg + end + + def load_files(files) + end + + def run + end + end +end diff --git a/vendor/plugins/rspec/spec/spec/runner/resources/utf8_encoded.rb b/vendor/plugins/rspec/spec/spec/runner/resources/utf8_encoded.rb new file mode 100644 index 000000000..7cbdd6908 --- /dev/null +++ b/vendor/plugins/rspec/spec/spec/runner/resources/utf8_encoded.rb @@ -0,0 +1,8 @@ +# encoding: utf-8 +module Custom + class ExampleUTF8ClassNameVarietà + def self.è + così = :però + end + end +end diff --git a/vendor/plugins/rspec/spec/support/macros.rb b/vendor/plugins/rspec/spec/support/macros.rb new file mode 100644 index 000000000..6322060b0 --- /dev/null +++ b/vendor/plugins/rspec/spec/support/macros.rb @@ -0,0 +1,29 @@ +module Macros + def treats_method_missing_as_private(options = {:noop => true, :subject => nil}) + it "should have method_missing as private" do + with_ruby 1.8 do + described_class.private_instance_methods.should include("method_missing") + end + with_ruby 1.9 do + described_class.private_instance_methods.should include(:method_missing) + end + end + + it "should not respond_to? method_missing (because it's private)" do + formatter = options[:subject] || described_class.new({ }, StringIO.new) + formatter.should_not respond_to(:method_missing) + end + + if options[:noop] + it "should respond_to? all messages" do + formatter = described_class.new({ }, StringIO.new) + formatter.should respond_to(:just_about_anything) + end + + it "should respond_to? anything, when given the private flag" do + formatter = described_class.new({ }, StringIO.new) + formatter.respond_to?(:method_missing, true).should be_true + end + end + end +end diff --git a/vendor/plugins/rspec/spec/support/spec_classes.rb b/vendor/plugins/rspec/spec/support/spec_classes.rb new file mode 100644 index 000000000..c8900a789 --- /dev/null +++ b/vendor/plugins/rspec/spec/support/spec_classes.rb @@ -0,0 +1,133 @@ +# This file contains various classes used by the specs. +module Spec + module Expectations + class Person + attr_reader :name + def initialize name + @name = name + end + def == other + return @name == other.name + end + end + + class ClassWithMultiWordPredicate + def multi_word_predicate? + true + end + end + + module Helper + class CollectionWithSizeMethod + def initialize; @list = []; end + def size; @list.size; end + def push(item); @list.push(item); end + end + + class CollectionWithLengthMethod + def initialize; @list = []; end + def length; @list.size; end + def push(item); @list.push(item); end + end + + class CollectionOwner + attr_reader :items_in_collection_with_size_method, :items_in_collection_with_length_method + + def initialize + @items_in_collection_with_size_method = CollectionWithSizeMethod.new + @items_in_collection_with_length_method = CollectionWithLengthMethod.new + end + + def add_to_collection_with_size_method(item) + @items_in_collection_with_size_method.push(item) + end + + def add_to_collection_with_length_method(item) + @items_in_collection_with_length_method.push(item) + end + + def items_for(arg) + return [1, 2, 3] if arg == 'a' + [1] + end + + def items + @items_in_collection_with_size_method + end + end + + class HandCodedMock + include Spec::Matchers + def initialize(return_val) + @return_val = return_val + @funny_called = false + end + + def funny? + @funny_called = true + @return_val + end + + def hungry?(a, b, c) + a.should equal(1) + b.should equal(2) + c.should equal(3) + @funny_called = true + @return_val + end + + def exists? + @return_val + end + + def multi_word_predicate? + @return_val + end + + def rspec_verify + @funny_called.should be_true + end + end + class ClassWithUnqueriedPredicate + attr_accessor :foo + def initialize(foo) + @foo = foo + end + end + end + end +end + +module Custom + require 'spec/runner/formatter/base_text_formatter' + class Formatter < Spec::Runner::Formatter::BaseTextFormatter + attr_reader :options, :where + + def initialize(options, where) + @options = options + @where = where + end + end + + class BadFormatter < Spec::Runner::Formatter::BaseTextFormatter + attr_reader :where + + def initialize(options, where) + bad_method + end + end + + class Differ + attr_reader :options + def initialize(options) + @options = options + end + + def diff_as_object(target, expected) + "" + end + end +end + +class FakeReporter < Spec::Runner::Reporter +end |