wildcard_matchers 0.0.4 → 0.1.0

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 0.1.0
+* big refactoring
+
+## 0.0.4
+* BUGFIX
+ * renamed all to for_all
+
+## 0.0.3
+* ENHANCEMENT
+ * add helper nil_or
+
 ## 0.0.2
 * BUGFIX
  * bug fix comparing Hash with Array

data/README.md

@@ -1,11 +1,11 @@
-# wildcard_matchers [![Build Status](https://secure.travis-ci.org/okitan/wildcard_matchers.png?branch=master)](http://travis-ci.org/okitan/wildcard_matchers)
+# wildcard_matchers [![Build Status](https://secure.travis-ci.org/okitan/wildcard_matchers.png?branch=master)](http://travis-ci.org/okitan/wildcard_matchers) [![Dependency Status](https://gemnasium.com/okitan/capybara-json.png)](https://gemnasium.com/okitan/capybara-json)
 
 ## General Usage
 
 ```ruby
 require "wildcard_matchers"
 
-WildcardMatchers.wild_card_match("string", /str/) #=> true
+WildcardMatchers.wildcard_match?("string", /str/) #=> true
 
 require "wildcard_matchers/rspec"
 

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.1.0

data/lib/wildcard_matchers/helpers/for_all.rb

@@ -0,0 +1,18 @@
+module WildcardMatchers
+  module Helpers
+    def for_all(expectation, &block)
+      expectation = block_given? ? block : expectation
+
+      ForAll.new(expectation)
+    end
+
+    class ForAll < ::WildcardMatchers::WildcardMatcher
+      protected
+      def wildcard_match(actual)
+        actual.each.with_index do |e, i|
+          errors.push(*self.class.superclass.check_errors(e, expectation, position + "[#{i}]"))
+        end
+      end
+    end
+  end
+end

data/lib/wildcard_matchers/helpers/nil_or.rb

@@ -0,0 +1,18 @@
+module WildcardMatchers
+  module Helpers
+    def nil_or(expectation, &block)
+      expectation = block_given? ? block : expectation
+
+      NilOr.new(expectation)
+    end
+
+    class NilOr < ::WildcardMatchers::WildcardMatcher
+      protected
+      def wildcard_match(actual)
+        unless actual.nil?
+          errors.push(*self.class.superclass.check_errors(actual, expectation, position))
+        end
+      end
+    end
+  end
+end

data/lib/wildcard_matchers/helpers.rb

@@ -1,20 +1,7 @@
-module WildcardMatchers
+module WildcardMathcers
   module Helpers
-    def nil_or(expected, &on_failure)
-      lambda do |actual|
-        nil === actual or wildcard_match?(actual, expected, &on_failure)
-      end
-    end
-
-    def for_all(expected = nil, &on_failure)
-      raise "expected or block is mandatory" unless expected or block_given?
-
-      expected ||= block
-      lambda do |actual|
-        actual.all? do |item|
-          wildcard_match?(item, expected, &on_failure)
-        end
-      end
-    end
   end
 end
+
+require "wildcard_matchers/helpers/for_all"
+require "wildcard_matchers/helpers/nil_or"

data/lib/wildcard_matchers/matchers/hash_includes.rb

@@ -0,0 +1,28 @@
+module WildcardMatchers
+  module Matchers
+    # RSpeck::Mocks has hash_including
+    def hash_includes(*args)
+      HashIncludes.new(args)
+    end
+
+    class HashIncludes < ::WildcardMatchers::WildcardMatcher
+      protected
+      def wildcard_match(actual)
+        unless actual.is_a?(Hash)
+          erros.push "#{position}: expect #{actual} to Hash"
+        end
+
+        hash_to_match = {}
+        hash_to_match = expectation.pop if expectation.last.is_a?(Hash)
+
+        expectation.each do |key|
+          errors << "#{position}: expect #{actual} to have key #{key}" unless actual.has_key?(key)
+        end
+
+        hash_to_match.each do |key, value|
+          errors.push(*self.class.superclass.check_errors(actual[key], value, position + "[#{key.inspect}]"))
+        end
+      end
+    end
+  end
+end

data/lib/wildcard_matchers/matchers.rb

@@ -23,17 +23,6 @@ module WildcardMatchers
       end
     end
 
-    # RSpeck::Mocks has hash_including
-    def hash_includes(*args)
-      hash_to_match = {}
-      hash_to_match = args.pop if args.last.is_a?(Hash)
-
-      lambda do |hash|
-        (args - hash.keys).size == 0 &&
-          hash_to_match.all? {|key, value| value === hash[key] }
-      end
-    end
-
     def is_a_member_of(*args)
       lambda do |item|
         args.flatten.any? {|expected| expected === item }
@@ -41,3 +30,5 @@ module WildcardMatchers
     end
   end
 end
+
+require "wildcard_matchers/matchers/hash_includes.rb"

data/lib/wildcard_matchers/rspec.rb

@@ -7,15 +7,11 @@ end
 
 RSpec::Matchers.define :wildcard_match do |expected|
   match do |actual|
-    WildcardMatchers.wildcard_match?(actual, expected)
+    @matcher = WildcardMatchers::WildcardMatcher.new(expected)
+    @matcher === actual
   end
 
   failure_message_for_should do |actual|
-    failures = [ default_failure_message_for_should ]
-    on_failure = proc {|message| failures << message }
-
-    WildcardMatchers.wildcard_match?(actual, expected, &on_failure)
-
-    failures.join("\n")
+    @matcher.errors.join("\n")
   end
 end

data/lib/wildcard_matchers/wildcard_matcher.rb

@@ -0,0 +1,90 @@
+module WildcardMatchers
+  class WildcardMatcher
+    attr_reader :expectation, :errors
+    attr_accessor :position
+
+    def initialize(expectation = nil, position = ".", &block)
+      @expectation = (block_given? ? block : expectation)
+      @position    = position
+    end
+
+    def ===(actual)
+      @errors = []
+      wildcard_match(actual)
+      errors.empty?
+    end
+
+    def self.check_errors(actual, expectation = nil, position = ".", &block)
+      expectation = (block_given? ? block : expectation)
+      matcher = self.new(expectation, position)
+      matcher === actual
+      matcher.errors
+    end
+
+    protected
+    def wildcard_match(actual)
+      case expectation
+      when self.class
+        expectation.position = position
+        expectation === actual
+        errors.push(*expectation.errors)
+      when Class
+        # fo Array or Hash Class
+        single_match(actual)
+      when Proc
+        # TODO: use sexp
+        single_match(actual)
+      when Array
+        errors.push(*ArrayMatcher.check_errors(actual, expectation, position))
+      when Hash
+        errors.push(*HashMatcher.check_errors(actual, expectation, position))
+      else
+        single_match(actual)
+      end
+    end
+
+    def single_match(actual)
+      unless expectation === actual
+        errors << "#{position}: expect #{actual.inspect} to #{expectation.inspect}"
+      end
+    end
+  end
+
+  class ArrayMatcher < WildcardMatcher
+    protected
+    def wildcard_match(actual)
+      unless actual.is_a?(Array)
+        errors << "#{position}: expect #{actual.inspect} to #{expectation.inspect}"
+        return
+      end
+
+      if expectation.size === actual.size
+        expectation.zip(actual).each.with_index do |(e, a), i|
+          errors.push(*self.class.superclass.check_errors(a, e, position + "[#{i}]"))
+        end
+      else
+        errors << "#{position}: expect Array size #{actual.size} to #{expectation.size}"
+        # TODO: diff-lcs
+      end
+    end
+  end
+
+  class HashMatcher < WildcardMatcher
+    protected
+    def wildcard_match(actual)
+      unless actual.is_a?(Hash)
+        errors << "#{position}: expect #{actual.inspect} to #{expectation.inspect}"
+        return
+      end
+
+      if (actual.keys - expectation.keys).size == 0 && (expectation.keys - actual.keys).size == 0
+        expectation.each do |key, value|
+          errors.push(*self.class.superclass.check_errors(actual[key], value, position + "[#{key.inspect}]"))
+        end
+      else
+        errors << "#{position}: expect Hash keys #{actual.keys} to #{expectation.keys}"
+        #TODO: diff-lcs
+      end
+    end
+  end
+end

data/lib/wildcard_matchers.rb

@@ -1,72 +1,20 @@
-require "wildcard_matchers/helpers"
-require "wildcard_matchers/matchers"
-
 module WildcardMatchers
+  autoload :Helpers,  "wildcard_matchers/helpers"
+  autoload :Matchers, "wildcard_matchers/matchers"
+  autoload :WildcardMatcher, "wildcard_matchers/wildcard_matcher"
+
   include Helpers
   include Matchers
 
   def wildcard_match?(actual, expected, &on_failure)
-    on_failure = proc { return false } unless block_given?
-
-    recursive_match(actual, expected, &on_failure)
-  end
-
-  protected
-  def recursive_match(actual, expected, position = ".", &on_failure)
-    # "case expected" should omit Array or Hash
-    # "case actual" should omit Proc
-    case expected
-    when Class
-      # when expected is Array or Hash (Class) comes here and do nothing
-    when Array
-      return check_array(actual, expected, position, &on_failure)
-    when Hash
-      return check_hash(actual, expected, position, &on_failure)
-    end
+    errors = WildcardMatcher.check_errors(actual, expected)
 
-    unless expected === actual
-      yield("#{position}: expect #{actual.inspect} to #{expected.inspect}")
-      false
-    else
+    if errors.empty? #matcher.errors.empty?
       true
-    end
-  end
-
-  # TODO: class ArrayMatcher ?
-  def check_array(actual, expected, position, &on_failure)
-    return false unless actual.is_a?(Array)
-
-    if expected.size == actual.size
-      actual.zip(expected).map.with_index do |(a, e), index|
-        recursive_match(a, e, position + "[#{index}]", &on_failure)
-      end.all?
     else
-      yield <<_MESSAGE_
-#{position}: expect Array size #{actual.size} to #{expected.size}
-  actual: #{actual.inspect}
-  expect: #{expected.inspect}
-_MESSAGE_
+      on_failure.call(errors) if block_given?
       false
     end
   end
-
-  # TODO: class HashMatcher ?
-  def check_hash(actual, expected, position, &on_failure)
-    return false unless actual.is_a?(Hash)
-
-    if (actual.keys - expected.keys).size == 0 && (expected.keys - actual.keys).size == 0
-      expected.map do |key, value|
-        recursive_match(actual[key], value, position + "[#{key.inspect}]", &on_failure)
-      end.all?
-    else
-      yield <<_MESSAGE_
-#{position}: expect Hash keys #{actual.size} to #{expected.size}
-  +keys: #{actual.keys   - expected.keys}
-  -keys: #{expected.keys - actual.keys }
-_MESSAGE_
-      false
-    end
-  end
-
   module_function *self.instance_methods
 end

data/spec/spec_helper.rb

@@ -5,6 +5,7 @@ require "wildcard_matchers/rspec"
 Dir[File.expand_path("support/**/*.rb", File.dirname(__FILE__))].each {|f| require f }
 
 require "pry"
+require "tapp"
 
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
@@ -14,4 +15,4 @@ end
 # global debug function
 # usage:
 #   wildcard_match?(actual, expected, &$debug)
-$debug = proc {|message| puts message }
+$debug = proc {|errors| puts errors }

data/spec/wildcard_matchers/helpers/for_all_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+describe WildcardMatchers::Helpers::ForAll do
+  [ [ %w[ a b c ], :for_all, String ],
+    [ %w[ a b c ], :for_all, :is_a_string ],
+    [ %w[ a b c ], :for_all, :is_a, String ],
+  ].each do |actual, helper, matcher, *args|
+    it_behaves_like "wildcard match with helper", actual, helper, matcher, *args
+  end
+
+  it "should match using lambda with helper" do
+    [ 2, 4, 6].should wildcard_match(for_all ->(item) { item % 2 == 0 })
+  end
+end

data/spec/wildcard_matchers/helpers/nil_or_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe WildcardMatchers::Helpers::NilOr do
+  [ [ nil,   :nil_or, String ],
+    [ "aaa", :nil_or, String ],
+    [ nil,   :nil_or, :is_a_string ],
+    [ "aaa", :nil_or, :is_a_string ],
+  ].each do |actual, helper, matcher, *args|
+    it_behaves_like "wildcard match with helper", actual, helper, matcher, *args
+  end
+end

data/spec/wildcard_matchers/matchers/hash_includes_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe WildcardMatchers::Matchers::HashIncludes do
+  [ [ { :a => 1, :b => 1, :c => 1 }, :hash_includes, :a, :b ],
+    [ { :a => 1, :b => 1, :c => 1 }, :hash_includes, :a, :b => 1 ],
+    [ { :a => 1, :b => 1, :c => 1 }, :hash_includes, :a, :b => Integer ],
+  ].each do |actual, matcher, *args|
+    it_behaves_like "wildcard match", actual, matcher, *args
+  end
+
+  [ [ { :a => 1, :b => 1, :c => 1 }, :hash_includes, :a, :d ],
+    [ { :a => 1, :b => 1, :c => 1 }, :hash_includes, :a, :b => 2 ],
+    [ { :a => 1, :b => 1, :c => 1 }, :hash_includes, :a, :b => String ],
+  ].each do |actual, matcher, *args|
+    it_behaves_like "not wildcard match", actual, matcher, *args
+  end
+end

data/spec/wildcard_matchers/matchers_spec.rb

@@ -8,7 +8,7 @@ describe WildcardMatchers::Matchers do
     [ { :some => :hash },  Hash  ],
     [ [ 1, 2, 3 ],         Array ],
   ].each do |actual, expected|
-    it_should_behave_like "wildcard match", actual, :is_a, expected
+    it_behaves_like "wildcard match", actual, :is_a, expected
   end
 
   [ [ "string",           :is_a_string ],
@@ -27,29 +27,23 @@ describe WildcardMatchers::Matchers do
     [ "2012-05-10",  :is_time ],
 
   ].each do |actual, matcher|
-    it_should_behave_like "wildcard match", actual, matcher
+    it_behaves_like "wildcard match", actual, matcher
   end
 
   [ [ 0, :is_bool ],
   ].each do |actual, matcher|
-    it_should_behave_like "not wildcard match", actual, matcher
+    it_behaves_like "not wildcard match", actual, matcher
   end
 
-  [ [ { :a => 1, :b => 1, :c => 1 }, :hash_includes, :a, :b ],
-    [ { :a => 1, :b => 1, :c => 1 }, :hash_includes, :a, :b => 1 ],
-    [ { :a => 1, :b => 1, :c => 1 }, :hash_includes, :a, :b => Integer ],
-    [ "a", :is_a_member_of, %w[ a b ] ],
+  [ [ "a", :is_a_member_of, %w[ a b ] ],
     [ "a", :is_a_member_of, [ String ] ],
   ].each do |actual, matcher, *args|
-    it_should_behave_like "wildcard match", actual, matcher, *args
+    it_behaves_like "wildcard match", actual, matcher, *args
   end
 
-  [ [ { :a => 1, :b => 1, :c => 1 }, :hash_includes, :a, :d ],
-    [ { :a => 1, :b => 1, :c => 1 }, :hash_includes, :a, :b => 2 ],
-    [ { :a => 1, :b => 1, :c => 1 }, :hash_includes, :a, :b => String ],
-    [ "a", :is_a_member_of, %w[ b c ] ],
+  [ [ "a", :is_a_member_of, %w[ b c ] ],
     [ "a", :is_a_member_of, [ Integer ] ],
   ].each do |actual, matcher, *args|
-    it_should_behave_like "not wildcard match", actual, matcher, *args
+    it_behaves_like "not wildcard match", actual, matcher, *args
   end
 end

data/spec/wildcard_matchers/rspec_spec.rb

@@ -18,8 +18,8 @@ describe "matcher wildcard_match" do
   [ [ 1,           String,     ".: expect 1 to String" ],
     [ [ 1 ],       [ String ], ".[0]: expect 1 to String" ],
     [ [ 1 ],       [],         ".: expect Array size 1 to 0" ],
-    [ { :a => 1 }, {},         "+keys: [:a]" ],
-    [ {},          {:a => 1},  "-keys: [:a]" ],
+#    [ { :a => 1 }, {},         "+keys: [:a]" ],
+#    [ {},          {:a => 1},  "-keys: [:a]" ],
     [ { :a => 1},  {:a => 0},  ".[:a]: expect 1 to 0" ],
   ].each do |actual, expected, failure_message|
     it "not match #{actual.inspect} with #{expected} and return #{failure_message.inspect} as failure_message" do

data/spec/wildcard_matchers_spec.rb

@@ -15,20 +15,20 @@ describe target do
       [ { :some => :hash },  Hash  ],
       [ [ 1, 2, 3 ],         Array ],
     ].each do |actual, expected|
-      it_should_behave_like "wildcard match", actual, expected
+      it_behaves_like "wildcard match", actual, expected
     end
 
     [ [ {}, [] ],
       [ [], {} ],
     ].each do |actual, expected|
-      it_should_behave_like "not wildcard match", actual, expected
+      it_behaves_like "not wildcard match", actual, expected
     end
 
     context "matches recursively in Array" do
       [ [ [ 1, 2, "3"],    [ Integer, Integer, String ] ],
         [ [ 1, 2, [ 1 ] ], [ Integer, Integer, [ Integer ] ] ],
       ].each do |actual, expected|
-        it_should_behave_like "wildcard match", actual, expected
+        it_behaves_like "wildcard match", actual, expected
       end
     end
 
@@ -37,7 +37,7 @@ describe target do
         [ [ 1, 2, 3 ],    [ Integer, String,  Integer ] ],
         [ [ 1, 2, [ 1 ] ], [ Integer, Integer, [ String ] ] ],
       ].each do |actual, expected|
-        it_should_behave_like "not wildcard match", actual, expected
+        it_behaves_like "not wildcard match", actual, expected
       end
     end
 
@@ -45,7 +45,7 @@ describe target do
       [ [ { :hoge => "fuga", :fuga => "ugu" }, { :hoge => String, :fuga => String } ],
         [ { :hoge => "fuga", :fuga => { :ugu => "piyo" } }, { :hoge => String, :fuga => { :ugu => String } } ],
       ].each do |actual, expected|
-        it_should_behave_like "wildcard match", actual, expected
+        it_behaves_like "wildcard match", actual, expected
       end
     end
 
@@ -56,7 +56,7 @@ describe target do
         [ { :hoge => "fuga", :fuga => { :ugu => "piyo" } }, { :hoge => String, :fuga => { :ugu => Integer } } ],
         [ { :hoge => "fuga", :fuga => { :ugu => "piyo" } }, { :hoge => String, :fuga => { :fuga => String } } ],
       ].each do |actual, expected|
-        it_should_behave_like "not wildcard match", actual, expected
+        it_behaves_like "not wildcard match", actual, expected
       end
     end
 
@@ -69,7 +69,7 @@ describe target do
           { :first => Integer, :second => [ Integer ], :third => { :one => Integer } }
         ]
       ].each do |actual, expected|
-        it_should_behave_like "wildcard match", actual, expected
+        it_behaves_like "wildcard match", actual, expected
       end
     end
   end
@@ -80,21 +80,20 @@ describe target do
       expected = false
 
       failure = nil
-      wildcard_match?(actual, expected) {|message| failure = message }
-      failure.should =~ /#{actual.inspect} .+ #{expected.inspect}/
+      wildcard_match?(actual, expected) {|errors| failure = errors }
+      failure.should wildcard_match([/#{actual.inspect} .+ #{expected.inspect}/])
     end
 
     it "can get several failure messages" do
       actual   = [ 1, 0, 2 ]
       expected = [ 3, 0, 4 ]
 
-      failures = []
-      wildcard_match?(actual, expected) {|message| failures << message }
+      failure = nil
+      wildcard_match?(actual, expected) {|errors| failure = errors }
 
-      # TODO: dog fooding of rspec-matcher
       expect_failures = [ /#{actual.first}.+#{expected.first}/,
                           /#{actual.last}.+#{expected.last}/ ]
-      wildcard_match?(failures, expect_failures, &$debug).should be_true
+      failure.should wildcard_match(expect_failures)
     end
 
     # TODO: more failure message

data/wildcard_matchers.gemspec

@@ -20,4 +20,5 @@ Gem::Specification.new do |gem|
 
   # for debug
   gem.add_development_dependency "pry"
+  gem.add_development_dependency "tapp"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wildcard_matchers
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-30 00:00:00.000000000 Z
+date: 2012-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -75,6 +75,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: tapp
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: wildcard matchers
 email:
 - okitakunio@gmail.com
@@ -94,12 +110,18 @@ files:
 - VERSION
 - lib/wildcard_matchers.rb
 - lib/wildcard_matchers/helpers.rb
+- lib/wildcard_matchers/helpers/for_all.rb
+- lib/wildcard_matchers/helpers/nil_or.rb
 - lib/wildcard_matchers/matchers.rb
+- lib/wildcard_matchers/matchers/hash_includes.rb
 - lib/wildcard_matchers/rspec.rb
+- lib/wildcard_matchers/wildcard_matcher.rb
 - spec/spec.watchr
 - spec/spec_helper.rb
 - spec/support/shared_examples.rb
-- spec/wildcard_matchers/helpers_spec.rb
+- spec/wildcard_matchers/helpers/for_all_spec.rb
+- spec/wildcard_matchers/helpers/nil_or_spec.rb
+- spec/wildcard_matchers/matchers/hash_includes_spec.rb
 - spec/wildcard_matchers/matchers_spec.rb
 - spec/wildcard_matchers/rspec_spec.rb
 - spec/wildcard_matchers_spec.rb
@@ -132,7 +154,9 @@ test_files:
 - spec/spec.watchr
 - spec/spec_helper.rb
 - spec/support/shared_examples.rb
-- spec/wildcard_matchers/helpers_spec.rb
+- spec/wildcard_matchers/helpers/for_all_spec.rb
+- spec/wildcard_matchers/helpers/nil_or_spec.rb
+- spec/wildcard_matchers/matchers/hash_includes_spec.rb
 - spec/wildcard_matchers/matchers_spec.rb
 - spec/wildcard_matchers/rspec_spec.rb
 - spec/wildcard_matchers_spec.rb

data/spec/wildcard_matchers/helpers_spec.rb

@@ -1,18 +0,0 @@
-require "spec_helper"
-
-describe WildcardMatchers::Helpers do
-  [ [ nil,   :nil_or, String ],
-    [ "aaa", :nil_or, String ],
-    [ nil,   :nil_or, :is_a_string ],
-    [ "aaa", :nil_or, :is_a_string ],
-    [ %w[ a b c ], :for_all, String ],
-    [ %w[ a b c ], :for_all, :is_a_string ],
-    [ %w[ a b c ], :for_all, :is_a, String ],
-  ].each do |actual, helper, matcher, *args|
-    it_should_behave_like "wildcard match with helper", actual, helper, matcher, *args
-  end
-
-  it "should match using lambda with helper" do
-    [ 2, 4, 6].should wildcard_match(for_all ->(item) { item % 2 == 0 })
-  end
-end