rspec-collection_matchers 0.0.1.pre → 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1bd9e9e6cead5be254467961d97df52cfdae0316
+  data.tar.gz: e36762e51754850cbec1da1f81cc3d0237187dfa
+SHA512:
+  metadata.gz: e32cdb9c067ada99bdf5357a7aab08fe0ab014db5c54821ea53da740ed5764aec7db13ae2bdace551855f7b0854945642240c1f6fbe77cbff6a1853956414187
+  data.tar.gz: 0a0934bac819f8a0b17031de14c0d56e43e77dd25ba77fc0b371f9d053560530d0b5f195115837a3a83151a58557b188aab5a1e4705caaed850d727b44d6cb22

data/.gitignore

@@ -1,17 +1,18 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
+*.sw?
+.DS_Store
+coverage*
 rdoc
-spec/reports
-test/tmp
-test/version_tmp
+pkg
+doc
 tmp
+rerun.txt
+Gemfile.lock
+.bundle
+*.rbc
+.yardoc
+bin
+.rbx
+Gemfile-custom
+bundle
+.rspec-local
+Guardfile

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,17 @@
+language: ruby
+script: "script/test_all"
+bundler_args: "--standalone --binstubs --without documentation"
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - ree
+  - jruby-18mode
+  - jruby-19mode
+  - rbx-18mode
+  - rbx-19mode
+  - 2.0.0
+matrix:
+  allow_failures:
+    - rvm: rbx-19mode
+    - rvm: rbx-18mode

data/Gemfile

@@ -1,4 +1,18 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in rspec-collection_matchers.gemspec
 gemspec
+
+%w[rspec rspec-core rspec-expectations rspec-mocks].each do |lib|
+  library_path = File.expand_path("../../#{lib}", __FILE__)
+  if File.exist?(library_path)
+    gem lib, :path => library_path
+  else
+    gem lib, :git => "git://github.com/rspec/#{lib}.git", :branch => "2-99-maintenance"
+  end
+end
+
+gem "cucumber", "~> 1.1.9"
+gem "aruba",    "~> 0.5"
+gem "rake",     "~> 10.0.0"
+
+eval File.read('Gemfile-custom') if File.exist?('Gemfile-custom')

data/LICENSE.txt

@@ -1,4 +1,9 @@
-Copyright (c) 2013 Myron Marston
+(The MIT License)
+
+Copyright (c) 2013 Hugo Barauna
+Copyright (c) 2012 David Chelimsky, Myron Marston
+Copyright (c) 2006 David Chelimsky, The RSpec Development Team
+Copyright (c) 2005 Steven Baker
 
 MIT License
 
@@ -19,4 +24,4 @@ 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.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,8 +1,11 @@
-# Rspec::CollectionMatchers
+# RSpec::CollectionMatchers [![Build Status](https://secure.travis-ci.org/rspec/rspec-collection_matchers.png?branch=master)](http://travis-ci.org/rspec/rspec-collection_matchers)
 
-TODO: Write a gem description
+RSpec::CollectionMatchers lets you express expected outcomes on collections
+of an object in an example.
 
-## Installation
+    expect(account.shopping_cart).to have_exactly(3).items
+
+## Install
 
 Add this line to your application's Gemfile:
 
@@ -16,14 +19,49 @@ Or install it yourself as:
 
     $ gem install rspec-collection_matchers
 
-## Usage
+## Basic usage
+
+Using `rspec-collection_matchers` you can match the number of items in a
+collection directly, e.g.:
+
+```ruby
+it 'matches number of items in a collection' do
+  expect([1,2,3]).to have_at_least(3).items
+end
+```
+
+You can also match the number of items returned by a method on an object, e.g.:
+
+```ruby
+class Cart
+  def initialize(*products)
+    @products = products
+  end
+  attr_reader :products
+end
+
+it 'matches number of items returned from a method' do
+  cart = Cart.new('product a', 'product b')
+  expect(cart).to have_at_most(2).products
+end
+```
+
+The last line of the example expresses an expected outcome:
+if `cart.products.size <= 2` then the example passes, otherwise it fails with a message like:
+
+    expected at most 2 products, got 3
+
+## Available matchers
 
-TODO: Write usage instructions here
+```ruby
+expect(collection).to have(n).items
+expect(collection).to have_exactly(n).items
+expect(collection).to have_at_most(n).items
+expect(collection).to have_at_least(n).items
+```
 
-## Contributing
+## See also
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+* [http://github.com/rspec/rspec](http://github.com/rspec/rspec)
+* [http://github.com/rspec/rspec-core](http://github.com/rspec/rspec-core)
+* [http://github.com/rspec/rspec-expectations](http://github.com/rspec/rspec-expectations)

data/Rakefile

@@ -1 +1,18 @@
-require "bundler/gem_tasks"
+require "bundler"
+Bundler.setup
+Bundler::GemHelper.install_tasks
+
+require "rake"
+
+require "rspec/core/rake_task"
+require "rspec/core/version"
+
+require "cucumber/rake/task"
+Cucumber::Rake::Task.new(:cucumber)
+
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.ruby_opts = %w[-w]
+end
+
+task :default => [:spec, :cucumber]

data/features/have.feature

@@ -0,0 +1,113 @@
+Feature: have(n).items matcher
+
+  RSpec provides several matchers that make it easy to set expectations about the
+  size of a collection.  There are three basic forms:
+
+    ```ruby
+    collection.should have(x).items
+    collection.should have_at_least(x).items
+    collection.should have_at_most(x).items
+    ```
+
+  In addition, #have_exactly is provided as an alias to #have.
+
+  These work on any collection-like object--the object just needs to respond to #size
+  or #length (or both).  When the matcher is called directly on a collection object,
+  the #items call is pure syntactic sugar.  You can use anything you want here.  These
+  are equivalent:
+
+    ```ruby
+    collection.should have(x).items
+    collection.should have(x).things
+    ```
+
+  You can also use this matcher on a non-collection object that returns a collection
+  from one of its methods.  For example, Dir#entries returns an array, so you could
+  set an expectation using the following:
+
+    ```ruby
+    Dir.new("my/directory").should have(7).entries
+    ```
+
+  Scenario: have(x).items on a collection
+    Given a file named "have_items_spec.rb" with:
+      """ruby
+      require 'rspec/collection_matchers'
+
+      describe [1, 2, 3] do
+        it { should have(3).items }
+        it { should_not have(2).items }
+        it { should_not have(4).items }
+
+        it { should have_exactly(3).items }
+        it { should_not have_exactly(2).items }
+        it { should_not have_exactly(4).items }
+
+        it { should have_at_least(2).items }
+        it { should have_at_most(4).items }
+
+        # deliberate failures
+        it { should_not have(3).items }
+        it { should have(2).items }
+        it { should have(4).items }
+
+        it { should_not have_exactly(3).items }
+        it { should have_exactly(2).items }
+        it { should have_exactly(4).items }
+
+        it { should have_at_least(4).items }
+        it { should have_at_most(2).items }
+      end
+      """
+     When I run `rspec have_items_spec.rb`
+     Then the output should contain "16 examples, 8 failures"
+      And the output should contain "expected target not to have 3 items, got 3"
+      And the output should contain "expected 2 items, got 3"
+      And the output should contain "expected 4 items, got 3"
+      And the output should contain "expected at least 4 items, got 3"
+      And the output should contain "expected at most 2 items, got 3"
+
+  Scenario: have(x).words on a String when String#words is defined
+    Given a file named "have_words_spec.rb" with:
+      """ruby
+      require 'rspec/collection_matchers'
+
+      class String
+        def words
+          split(' ')
+        end
+      end
+
+      describe "a sentence with some words" do
+        it { should have(5).words }
+        it { should_not have(4).words }
+        it { should_not have(6).words }
+
+        it { should have_exactly(5).words }
+        it { should_not have_exactly(4).words }
+        it { should_not have_exactly(6).words }
+
+        it { should have_at_least(4).words }
+        it { should have_at_most(6).words }
+
+        # deliberate failures
+        it { should_not have(5).words }
+        it { should have(4).words }
+        it { should have(6).words }
+
+        it { should_not have_exactly(5).words }
+        it { should have_exactly(4).words }
+        it { should have_exactly(6).words }
+
+        it { should have_at_least(6).words }
+        it { should have_at_most(4).words }
+      end
+      """
+     When I run `rspec have_words_spec.rb`
+     Then the output should contain "16 examples, 8 failures"
+      And the output should contain "expected target not to have 5 words, got 5"
+      And the output should contain "expected 4 words, got 5"
+      And the output should contain "expected 6 words, got 5"
+      And the output should contain "expected at least 6 words, got 5"
+      And the output should contain "expected at most 4 words, got 5"
+

data/features/support/env.rb

@@ -0,0 +1,21 @@
+require 'aruba/cucumber'
+
+Before do
+  if RUBY_PLATFORM =~ /java/
+    @aruba_timeout_seconds = 30
+  else
+    @aruba_timeout_seconds = 10
+  end
+end
+
+Aruba.configure do |config|
+  config.before_cmd do |cmd|
+    set_env('JRUBY_OPTS', "-X-C #{ENV['JRUBY_OPTS']}") # disable JIT since these processes are so short lived
+  end
+end if RUBY_PLATFORM == 'java'
+
+Aruba.configure do |config|
+  config.before_cmd do |cmd|
+    set_env('RBXOPT', "-Xint=true #{ENV['RBXOPT']}") # disable JIT since these processes are so short lived
+  end
+end if defined?(Rubinius)

data/lib/rspec/collection_matchers.rb

@@ -0,0 +1,3 @@
+require 'rspec/collection_matchers/version'
+require 'rspec/collection_matchers/matchers'
+require 'rspec/collection_matchers/have'

data/lib/rspec/collection_matchers/have.rb

@@ -0,0 +1,122 @@
+module RSpec
+  module CollectionMatchers
+    class Have
+      QUERY_METHODS = [:size, :length, :count].freeze
+
+      def initialize(expected, relativity=:exactly)
+        @expected = case expected
+                    when :no then 0
+                    when String then expected.to_i
+                    else expected
+                    end
+        @relativity = relativity
+        @actual = @collection_name = @plural_collection_name = nil
+      end
+
+      def relativities
+        @relativities ||= {
+          :exactly => "",
+          :at_least => "at least ",
+          :at_most => "at most "
+        }
+      end
+
+      def matches?(collection_or_owner)
+        collection = determine_collection(collection_or_owner)
+        case collection
+        when enumerator_class
+          for query_method in QUERY_METHODS
+            next unless collection.respond_to?(query_method)
+            @actual = collection.__send__(query_method)
+            break unless @actual.nil?
+          end
+          raise not_a_collection if @actual.nil?
+        else
+          query_method = determine_query_method(collection)
+          raise not_a_collection unless query_method
+          @actual = collection.__send__(query_method)
+        end
+        case @relativity
+        when :at_least then @actual >= @expected
+        when :at_most  then @actual <= @expected
+        else                @actual == @expected
+        end
+      end
+      alias == matches?
+
+      def determine_collection(collection_or_owner)
+        if collection_or_owner.respond_to?(@collection_name)
+          collection_or_owner.__send__(@collection_name, *@args, &@block)
+        elsif (@plural_collection_name && collection_or_owner.respond_to?(@plural_collection_name))
+          collection_or_owner.__send__(@plural_collection_name, *@args, &@block)
+        elsif determine_query_method(collection_or_owner)
+          collection_or_owner
+        else
+          collection_or_owner.__send__(@collection_name, *@args, &@block)
+        end
+      end
+
+      def determine_query_method(collection)
+        QUERY_METHODS.detect {|m| collection.respond_to?(m)}
+      end
+
+      def not_a_collection
+        "expected #{@collection_name} to be a collection but it does not respond to #length, #size or #count"
+      end
+
+      def failure_message_for_should
+        "expected #{relative_expectation} #{@collection_name}, got #{@actual}"
+      end
+
+      def failure_message_for_should_not
+        if @relativity == :exactly
+          return "expected target not to have #{@expected} #{@collection_name}, got #{@actual}"
+        elsif @relativity == :at_most
+          return <<-EOF
+Isn't life confusing enough?
+Instead of having to figure out the meaning of this:
+  #{Expectations::Syntax.negative_expression("actual", "have_at_most(#{@expected}).#{@collection_name}")}
+We recommend that you use this instead:
+  #{Expectations::Syntax.positive_expression("actual", "have_at_least(#{@expected + 1}).#{@collection_name}")}
+EOF
+        elsif @relativity == :at_least
+          return <<-EOF
+Isn't life confusing enough?
+Instead of having to figure out the meaning of this:
+  #{Expectations::Syntax.negative_expression("actual", "have_at_least(#{@expected}).#{@collection_name}")}
+We recommend that you use this instead:
+  #{Expectations::Syntax.positive_expression("actual", "have_at_most(#{@expected - 1}).#{@collection_name}")}
+EOF
+        end
+      end
+
+      def description
+        "have #{relative_expectation} #{@collection_name}"
+      end
+
+      def respond_to?(m)
+        @expected.respond_to?(m) || super
+      end
+
+      private
+
+      def method_missing(method, *args, &block)
+        @collection_name = method
+        if inflector = (defined?(ActiveSupport::Inflector) && ActiveSupport::Inflector.respond_to?(:pluralize) ? ActiveSupport::Inflector : (defined?(Inflector) ? Inflector : nil))
+          @plural_collection_name = inflector.pluralize(method.to_s)
+        end
+        @args = args
+        @block = block
+        self
+      end
+
+      def relative_expectation
+        "#{relativities[@relativity]}#{@expected}"
+      end
+
+      def enumerator_class
+        RUBY_VERSION < '1.9' ? Enumerable::Enumerator : Enumerator
+      end
+    end
+  end
+end