array_logic 0.1.0 → 0.1.1

data/README.rdoc

@@ -29,6 +29,12 @@ The *match* and *matches* methods allow arrays to be tested against these rules:
     rule_two.match([a1, a2])            --> false
     rule_two.matches([a1, a2], [a1])    --> [[a1]]
 
+You can also test for arrays that do not match the rule by using *block* 
+and *blockers*:
+
+    rule_two.block([a1, a2])            --> true
+    rule_two.blockers([a1, a2], [a1])    --> [[a1, a2]]
+
 See test/array_logic/rule_test for more examples
 
 === Combinations that match
@@ -37,11 +43,12 @@ Two methods allow you to determine sample combinations that match the current
 rule.  
 
     rule = ArrayLogic::Rule.new 'a1 and a2'
-    rule.matching_combinations        -->  [[1,2]]
-    rule.blocking_combinations -->  [[1],[2]]
+
+    rule.matching_combinations   -->  [[1,2]]
+    rule.blocking_combinations   -->  [[1],[2]]
 
 To limit the number of samples presented, both only use ids used within
-the rule. For the example about, an array that includes [1,2] would match, 
+the rule. For the example above, an array that includes [1,2] would match, 
 and so would [1,2,3]. However, arrays that only contain 1 or 2 would not match 
 (for example [1,3])
 

data/lib/array_logic/rule.rb

@@ -8,7 +8,11 @@ module ArrayLogic
     end
 
     def matches(*array_of_things)
-      array_of_things.delete_if{|things| !match(things)}
+      array_of_things.delete_if{|things| block(things)}
+    end
+    
+    def blockers(*array_of_things)
+      array_of_things.delete_if{|things| match(things)}
     end
 
     def match(things)
@@ -17,6 +21,10 @@ module ArrayLogic
       @thing_ids = things.collect(&:id)
       logic
     end
+    
+    def block(things)
+      ! match(things)
+    end
 
     def logic
       eval(expression)  
@@ -45,7 +53,12 @@ module ArrayLogic
     def blocking_combinations
       combinations_of_identifiers_in_rule_that_pass {|c| ! match_ids(c)}
     end
-
+    
+    def check_rule
+      check_rule_entered
+      check_allowed_characters
+    end
+    
     private
     def match_ids(ids)
       @thing_ids = ids
@@ -64,13 +77,6 @@ module ArrayLogic
       object_ids_used.length
     end
         
-    def combinations_of_identifiers_in_rule
-      ids = object_ids_used
-      combinations = Array.new
-      (1..ids.length).each{|n| ids.combination(n).each{|c| combinations << c}}
-      return combinations
-    end
-    
     def objects_identifiers_in_rule
       rule_without_punctuation.split.delete_if{|x| !(thing_id_pattern =~ x)}
     end
@@ -88,6 +94,7 @@ module ArrayLogic
       replace_item(number_in_set_pattern, comparison_of_number_with_true_count)
     end
 
+    # for example: 2 in t1, t2, t3
     def number_in_set_pattern
       /\d+\s+in\s+((true|false)[\,\s]*)+/
     end
@@ -142,40 +149,39 @@ module ArrayLogic
     def rule_without_punctuation
       rule.gsub(/[[:punct:]]/, '')
     end
-    
-    def check_rule
-      check_rule_entered
-      check_allowed_characters
-    end
 
     def check_rule_entered
       raise "You must define a rule before trying to match" unless rule.kind_of? String
     end
 
     def check_allowed_characters
-      raise_invalid_charachers unless allowed_charachers_pattern =~ rule
+      raise_invalid_characters unless allowed_characters_pattern =~ rule
     end
+    
+    def raise_invalid_characters
+      invalid = rule.split.collect{|s| (allowed_characters_pattern =~ s) ? nil : s }.compact
+      raise "The rule '#{rule}' is not valid. The problem is within '#{invalid.join(' ')}'"
+    end    
 
-    def allowed_charachers_pattern
+    def allowed_characters_pattern
       case_insensitive = true
-      Regexp.new("^(#{allowed_characters.join('|')})*$", case_insensitive)
+      Regexp.new("^(#{array_of_allowed_patterns.join('|')})*$", case_insensitive)
     end
 
     def allowed_characters
-      brackets = ['\(', '\)']
-      in_pattern = ['\d+\s+in']
-      ids = ['\w\d+']
-      logic_words = %w{and or not}
-      logic_chrs = ['&&', '\|\|', '!']
-      commas = ['\,']
-      white_space = ['\s']
-
-      [brackets, in_pattern, ids, logic_words, logic_chrs, commas, white_space].flatten
+      {
+        :brackets => ['\(', '\)'],
+        :in_pattern => ['\d+\s+in'],
+        :ids => ['\w\d+'],
+        :logic_words => %w{and or not},
+        :logic_chrs => ['&&', '\|\|', '!'],
+        :commas => ['\,'],
+        :white_space => ['\s'],
+      }
     end
-
-    def raise_invalid_charachers
-      invalid = rule.split.collect{|s| (allowed_charachers_pattern =~ s) ? nil : s }.compact
-      raise "The rule '#{rule}' is not valid. The problem is within '#{invalid.join(' ')}'"
+    
+    def array_of_allowed_patterns
+      allowed_characters.values.flatten
     end
 
   end

data/lib/array_logic/version.rb

@@ -1,3 +1,3 @@
 module ArrayLogic
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/test/array_logic/rule_test.rb

@@ -158,6 +158,31 @@ module ArrayLogic
         @rule.match([1, 2])
       end
     end
+    
+    def test_match_with_empty_rule
+      @rule.rule = ""
+      things = get_things([1, 2])
+      assert(!@rule.match([things.first]), "Should be no match when rule empty")
+    end
+    
+    def test_block_without_rule
+      assert_raise RuntimeError do
+        @rule.block([1, 2])
+      end
+    end
+    
+    def test_block_with_number_rule
+      @rule.rule = 1
+      assert_raise RuntimeError do
+        @rule.block([1, 2])
+      end
+    end
+    
+    def test_block_with_empty_rule
+      @rule.rule = ""
+      things = get_things([1, 2])
+      assert(@rule.block([things.first]), "Should be block when rule empty")
+    end    
 
     def test_replace_item
       @rule.rule = 't1 or ( t2 and t3 )'
@@ -180,46 +205,48 @@ module ArrayLogic
       end
     end
     
-    def test_matches
+    def test_matches_and_blokers
       @rule.rule = 't1 and t2'
-      t1 = Thing.new(1)
-      t2 = Thing.new(2)
-      t3 = Thing.new(3)
-      match_one = [t1, t2]
-      match_two = [t1, t2, t3]
-      no_match_one = [t2, t3]
-      no_match_two = [t3]
+      match_one = get_things [1, 2]
+      match_two = get_things [1, 2, 3]
+      no_match_one = get_things [2, 3]
+      no_match_two = get_things [3]
+      
+      matches = @rule.matches(match_one, match_two, no_match_one, no_match_two)
+      expected_matches = [match_one, match_two]   
+      assert_equal(expected_matches, matches, "Matches should be returned")
       
-      result = @rule.matches(match_one, match_two, no_match_one, no_match_two)
-      expected = [match_one, match_two]
-      assert_equal(expected, result)
+      blockers = @rule.blockers(match_one, match_two, no_match_one, no_match_two)
+      expected_blockers = [no_match_one, no_match_two]
+      assert_equal(expected_blockers, blockers, "Blockers should be returned")
     end
     
-    def test_matches_with_or
+    def test_matches_and_blokers_with_or
       @rule.rule = 't1 or t2'
-      t1 = Thing.new(1)
-      t2 = Thing.new(2)
-      t3 = Thing.new(3)
-      match_one = [t1, t2]
-      match_two = [t1, t2, t3]
-      match_three = [t2, t3]
-      no_match_two = [t3]
+      match_one = get_things [1, 2]
+      match_two = get_things [1, 2, 3]
+      match_three = get_things [2, 3]
+      no_match_one = get_things [3]
+      
+      matches = @rule.matches(match_one, match_two, match_three, no_match_one)
+      expected_matches = [match_one, match_two, match_three]
+      assert_equal(expected_matches, matches, "Matches should be returned")
       
-      result = @rule.matches(match_one, match_two, match_three, no_match_two)
-      expected = [match_one, match_two, match_three]
-      assert_equal(expected, result)
+      blockers = @rule.blockers(match_one, match_two, match_three, no_match_one)
+      expected_blockers = [no_match_one]
+      assert_equal(expected_blockers, blockers, "Blockers should be returned")
     end
     
-    def test_match_with_empty_rule
+    def test_matches_with_empty_rule
       @rule.rule = ""
-      things = get_things([1, 2])
-      assert(!@rule.match([things.first]), "Should be no match when rule empty")
+      things = get_things([1, 2]).collect{|t| [t]}
+      assert_equal([], @rule.matches(*things))
     end
     
-    def test_matches_with_empty_rule
+    def test_blokers_with_empty_rule
       @rule.rule = ""
-      things = get_things([1, 2])
-      assert_equal([], @rule.matches([things.first], [things.last]))
+      things = get_things([1, 2]).collect{|t| [t]}
+      assert_equal(things, @rule.blockers(*things))
     end
     
     def test_object_ids_used

data/test/array_logic/test_case.rb

@@ -15,11 +15,13 @@ module ArrayLogic
     def assert_thing_match(thing_ids, rule)
       get_things(thing_ids)
       assert(rule.match(@things), "#{thing_ids.inspect} should match '#{rule.rule}'")
+      assert(!rule.block(@things), "#{thing_ids.inspect} should not block '#{rule.rule}'")
     end
     
     def assert_no_thing_match(thing_ids, rule)
       get_things(thing_ids)
       assert(!rule.match(@things), "#{thing_ids.inspect} should not match '#{rule.rule}'")
+      assert(rule.block(@things), "#{thing_ids.inspect} should block '#{rule.rule}'")
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: array_logic
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-12 00:00:00.000000000 Z
+date: 2012-12-13 00:00:00.000000000 Z
 dependencies: []
 description: Allow a user to define a set of rules, and then test to see if an array
   of object match those rules.
@@ -19,17 +19,17 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/array_logic.rb
-- lib/array_logic/thing.rb
 - lib/array_logic/version.rb
+- lib/array_logic/thing.rb
 - lib/array_logic/rule.rb
+- lib/array_logic.rb
 - lib/example.rb
 - MIT-LICENSE
 - Rakefile
 - README.rdoc
-- test/array_logic/thing_test.rb
-- test/array_logic/rule_test.rb
 - test/array_logic/test_case.rb
+- test/array_logic/rule_test.rb
+- test/array_logic/thing_test.rb
 homepage: https://github.com/reggieb/array_logic
 licenses: []
 post_install_message: 
@@ -55,6 +55,6 @@ signing_key:
 specification_version: 3
 summary: Matches arrays of objects against logical rules.
 test_files:
-- test/array_logic/thing_test.rb
-- test/array_logic/rule_test.rb
 - test/array_logic/test_case.rb
+- test/array_logic/rule_test.rb
+- test/array_logic/thing_test.rb