array_logic 0.0.5 → 0.0.6

data/README.rdoc

@@ -38,8 +38,8 @@ rule.
 
     rule = ArrayLogic::Rule.new
     rule.rule = 'a1 and a2'
-    rule.combinations_that_match        -->  [[1,2]]
-    rule.combinations_that_do_not_match -->  [[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, 

data/lib/array_logic/rule.rb

@@ -12,7 +12,7 @@ module ArrayLogic
     end
 
     def match(things)
-      rule_valid?
+      check_rule
       @things = things
       @thing_ids = things.collect(&:id)
       logic
@@ -23,8 +23,10 @@ module ArrayLogic
     end
 
     def rule_valid?
-      check_rule_entered
-      check_allowed_characters
+      check_rule
+      !rule.empty?
+    rescue
+      return false
     end
 
     def replace_item(pattern, processor)
@@ -33,24 +35,35 @@ module ArrayLogic
     
     def object_ids_used
       chrs_after_first = 1..-1
-      objects_identifiers_in_rule.collect{|i| i[chrs_after_first].to_i}.uniq
+      @object_ids_used ||= objects_identifiers_in_rule.collect{|i| i[chrs_after_first].to_i}.uniq
     end
     
-    def combinations_that_match
-      combinations_of_identifiers_in_rule.delete_if{|ids| ! match_ids(ids)} if rule and !rule.empty?
+    def matching_combinations
+      combinations_of_identifiers_in_rule_that_pass {|c| match_ids(c)}  
     end
     
-    def combinations_that_do_not_match
-      combinations_of_identifiers_in_rule.delete_if{|ids| match_ids(ids)} if rule and !rule.empty?
+    def blocking_combinations
+      combinations_of_identifiers_in_rule_that_pass {|c| ! match_ids(c)}
     end
 
     private
     def match_ids(ids)
-      rule_valid?
       @thing_ids = ids
       logic
     end
     
+    def combinations_of_identifiers_in_rule_that_pass(&test)
+      if rule_valid?
+        combinations = Array.new
+        (1..id_count).each{|n| object_ids_used.combination(n).each{|c| combinations << c if test.call(c)}}
+        return combinations  
+      end
+    end
+    
+    def id_count
+      object_ids_used.length
+    end
+        
     def combinations_of_identifiers_in_rule
       ids = object_ids_used
       combinations = Array.new
@@ -129,6 +142,11 @@ 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

data/lib/array_logic/version.rb

@@ -1,3 +1,3 @@
 module ArrayLogic
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/lib/example.rb

@@ -15,11 +15,23 @@ rule_sets.each do |rule_set|
   puts "----------------------------\n"
   puts "The rule '#{rule_set}' would match the following:"
   
-  rule.combinations_that_match.each{|c| puts "\t#{c.inspect}"}
+  rule.matching_combinations.each{|c| puts "\t#{c.inspect}"}
   
   puts "\nAnd would not match"
   
-  rule.combinations_that_do_not_match.each{|c| puts "\t#{c.inspect}"}
+  rule.blocking_combinations.each{|c| puts "\t#{c.inspect}"}
   
   puts "\n\n"
 end
+
+or_rule = (1..12).to_a.collect{|n| "t#{n}"}.join(" or ")
+
+rule = ArrayLogic::Rule.new
+rule.rule = or_rule
+
+require 'benchmark'
+
+Benchmark.bm do |x|
+  x.report(:matching_combinations) { rule.matching_combinations }
+  x.report(:blocking_combinations) { rule.blocking_combinations}
+end

data/test/array_logic/rule_test.rb

@@ -232,42 +232,42 @@ module ArrayLogic
       assert_equal([1, 2], @rule.object_ids_used)
     end
     
-    def test_combinations_that_match
+    def test_matching_combinations
       @rule.rule = 't1 or t2'
-      assert_equal([[1], [2], [1,2]], @rule.combinations_that_match)
+      assert_equal([[1], [2], [1,2]], @rule.matching_combinations)
       @rule.rule = 't1 and t2'
-      assert_equal([[1,2]], @rule.combinations_that_match)
+      assert_equal([[1,2]], @rule.matching_combinations)
     end
     
-    def test_combinations_that_match_without_rule
+    def test_matching_combinations_without_rule
       @rule.rule = nil
-      assert_nil(@rule.combinations_that_match, "combinations_that_match should return nil if there is no rule")
+      assert_equal(nil, @rule.matching_combinations)
       @rule.rule = ""
-      assert_nil(@rule.combinations_that_match, "combinations_that_match should return nil if the rule is blank")
+      assert_equal(nil, @rule.matching_combinations)
     end
     
-    def test_combinations_that_match_with_duplicate_ids
+    def test_matching_combinations_with_duplicate_ids
       @rule.rule = 't1 and t2 and (2 in t1 t2)'
-      assert_equal(1, @rule.combinations_that_match.length, "should not identify combinations for both occurancies of each id")
+      assert_equal(1, @rule.matching_combinations.length, "should not identify combinations for both occurancies of each id")
     end
     
-    def test_combinations_that_do_not_match
+    def test_blocking_combinations
       @rule.rule = 't1 or t2'
-      assert_equal([], @rule.combinations_that_do_not_match)
+      assert_equal([], @rule.blocking_combinations)
       @rule.rule = 't1 and t2'
-      assert_equal([[1],[2]], @rule.combinations_that_do_not_match)
+      assert_equal([[1],[2]], @rule.blocking_combinations)
     end
     
-    def test_combinations_that_do_not_match_without_rule
+    def test_blocking_combinations_without_rule
       @rule.rule = nil
-      assert_nil(@rule.combinations_that_do_not_match, "combinations_that_do_not_match should return nil if there is no rule")
+      assert_equal(nil, @rule.blocking_combinations)
       @rule.rule = ""
-      assert_nil(@rule.combinations_that_do_not_match, "combinations_that_do_not_match should return nil if the rule is blank")      
+      assert_equal(nil, @rule.blocking_combinations)      
     end
     
-    def test_combinations_that_do_not_match_when_none_returned
+    def test_blocking_combinations_when_none_returned
       @rule.rule = 't1'
-      assert_equal([], @rule.combinations_that_do_not_match)
+      assert_equal([], @rule.blocking_combinations)
     end
       
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: array_logic
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors: