array_logic 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 Rob Nichols
+
+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.

data/README.rdoc

@@ -0,0 +1,32 @@
+== array_logic
+
+A system that allows me to define the logic for comparing arrays.
+
+The logic for an active record model Answer, looks like this:
+
+
+    a1 = Answer.find(1)
+    a2 = Answer.find(2)
+      ....
+    a5 = Answer.find(5)
+
+    rule_one.rule = "(a1 and a2) or (a3 and a4)"
+
+    rule_two.rule = "a1 and not a2"
+
+    rule_three.rule = "2 in a1 a2 a3"
+
+    rule_four.rule = "(2 in a1 a2 a3) and (1 in a4 a5)"
+
+
+                  rule_one      rule_two      rule_three      rule_four
+    [a1, a2]      true          false         true            false
+    [a3, a4]      true          false         false           false
+    [a1, a3, a5]  false         true          true            true
+
+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]]
+
+See test/array_logic/rule_test for more examples

data/Rakefile

@@ -0,0 +1,19 @@
+
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rdoc/task'
+require 'rake/testtask'
+
+Rake::RDocTask.new do |rdoc|
+  files =['README.rdoc', 'MIT-LICENSE', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README.rdoc" # page to start on
+  rdoc.title = "Dibber Docs"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*.rb']
+end

data/lib/array_logic.rb

@@ -0,0 +1,5 @@
+require_relative('array_logic/thing')
+require_relative('array_logic/rule')
+module ArrayLogic
+    
+end

data/lib/array_logic/rule.rb

@@ -0,0 +1,134 @@
+
+class Rule
+  attr_accessor :rule
+  attr_reader :things
+  
+  def initialize
+    
+  end
+  
+  def matches(*array_of_things)
+    array_of_things.delete_if{|things| !match(things)}
+  end
+  
+  def match(things)
+    rule_valid?
+    @things = things
+    logic
+  end
+  
+  def logic
+    eval(expression)  
+  end
+  
+  def rule_valid?
+    check_rule_entered
+    check_allowed_characters
+  end
+  
+  def replace_item(pattern, processor)
+    @processed_rule = processed_rule.gsub(pattern) {|x| processor.call(x)}
+  end
+  
+  private
+  def thing_ids
+    things.collect(&:id)
+  end
+  
+  def expression
+    rule_processing_steps
+    return final_processed_rule
+  end
+  
+
+  
+  def rule_processing_steps
+    add_space_around_puctuation_characters
+    make_everything_lower_case
+    replace_logic_words_with_operators
+    replace_item(thing_id_pattern, true_or_false_for_thing_id_in_thing_ids)
+    replace_item(number_in_set_pattern, comparison_of_number_with_true_count)
+  end
+  
+  def number_in_set_pattern
+    /\d+\s+in\s+((true|false)[\,\s]*)+/
+  end
+  
+  def comparison_of_number_with_true_count
+    lambda do |string|
+      before_in, after_in = string.split(/\s+in\s+/)
+      true_count = after_in.split.count('true')
+      " ( #{before_in} <= #{true_count} ) "
+    end
+  end
+  
+  # examples: a1, a2, a33, t1
+  def thing_id_pattern
+    /\w\d+/
+  end
+  
+  def true_or_false_for_thing_id_in_thing_ids
+    lambda {|s| thing_ids.include?(s[/\d+/].to_i)}
+  end
+  
+  def processed_rule
+    @processed_rule ||= rule.clone
+  end
+
+  def add_space_around_puctuation_characters
+    @processed_rule = processed_rule.gsub(/(\)|\)|\,)/, ' \1 ')
+  end
+  
+  def make_everything_lower_case
+    @processed_rule = processed_rule.downcase
+  end
+
+  def replace_logic_words_with_operators
+    {
+      'and' => '&&',
+      'or' => '||',
+      'not' => '!'
+    }.each{|word, operator| @processed_rule = processed_rule.gsub(Regexp.new(word), operator)}
+  end  
+  
+  def final_processed_rule
+    result = processed_rule.clone
+    reset_processed_rule_ready_for_next_comparison
+    return result
+  end
+  
+  def reset_processed_rule_ready_for_next_comparison
+    @processed_rule = nil
+  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
+  end
+  
+  def allowed_charachers_pattern
+    case_insensitive = true
+    Regexp.new("^(#{allowed_characters.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
+  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(' ')}'"
+  end
+  
+end

data/lib/array_logic/thing.rb

@@ -0,0 +1,17 @@
+module ArrayLogic
+  
+  # Basic object used in testing 
+  class Thing
+    attr_accessor :id
+    
+    def initialize(number)
+      @id = number
+    end
+    
+    def self.make(number)
+      things = Hash.new
+      (1..number).each{|n| things[n] = new(n)}
+      return things
+    end
+  end
+end

data/lib/array_logic/version.rb

@@ -0,0 +1,3 @@
+module ArrayLogic
+  VERSION = "0.0.1"
+end

data/lib/main.rb

@@ -0,0 +1,4 @@
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+
+puts "Hello World"

data/test/array_logic/rule_test.rb

@@ -0,0 +1,214 @@
+require 'test/unit'
+require_relative '../../lib/array_logic'
+require_relative 'test_case'
+
+module ArrayLogic
+  class RuleTest < TestCase
+    
+    def setup
+      @rule = Rule.new
+    end
+    
+    def test_simple_and
+      @rule.rule = 't1 and t2'
+      assert_thing_match([1, 2], @rule)
+      assert_thing_match([1, 2, 3], @rule)
+      assert_no_thing_match([2, 3], @rule)
+      assert_no_thing_match([3], @rule)
+    end
+    
+    def test_simple_or
+      @rule.rule = 't1 or t2'
+      assert_thing_match([1, 2], @rule)
+      assert_thing_match([1, 2, 3], @rule)
+      assert_thing_match([2, 3], @rule)
+      assert_no_thing_match([3], @rule)      
+    end
+    
+    def test_multiple_and
+      @rule.rule = 't1 and t2 and t3'
+      assert_no_thing_match([1, 2], @rule)
+      assert_thing_match([1, 2, 3], @rule)
+      assert_no_thing_match([2, 3], @rule)
+      assert_no_thing_match([3], @rule)
+    end
+    
+    def test_multiple_or
+      @rule.rule = 't1 or t2 or t3'
+      assert_thing_match([1, 2], @rule)
+      assert_thing_match([1, 2, 3], @rule)
+      assert_thing_match([3], @rule)
+      assert_no_thing_match([4], @rule)
+    end
+    
+    def test_one_or_one_and
+      @rule.rule = 't1 or ( t2 and t3 )'
+      assert_thing_match([1, 2], @rule)
+      assert_thing_match([1, 2, 3], @rule)
+      assert_thing_match([2, 3], @rule)
+      assert_no_thing_match([3], @rule)      
+    end
+    
+    def test_one_or_one_and
+      @rule.rule = '( t1 or t2 ) and t3'
+      assert_no_thing_match([1, 2], @rule)
+      assert_thing_match([1, 2, 3], @rule)
+      assert_thing_match([2, 3], @rule)
+      assert_no_thing_match([3], @rule)      
+    end
+
+    def test_one_or_one_and_not
+      @rule.rule = 't1 or ( t2 and not t3 )'
+      assert_thing_match([1, 3], @rule)
+      assert_thing_match([1, 2, 3], @rule)
+      assert_no_thing_match([2, 3], @rule)
+      assert_thing_match([2], @rule) 
+      assert_thing_match([2, 4], @rule) 
+    end 
+    
+    def test_one_or_one_and_with_no_space_between_tn_and_bracket
+      @rule.rule = 't1 or (t2 and t3)'
+      assert_thing_match([1, 2], @rule)
+      assert_thing_match([1, 2, 3], @rule)
+      assert_thing_match([2, 3], @rule)
+      assert_no_thing_match([3], @rule)      
+    end
+    
+    def test_one_in_three
+      @rule.rule = '1 in t1, t2, t3'
+      assert_thing_match([1, 2], @rule)
+      assert_thing_match([1, 2, 3], @rule)
+      assert_thing_match([3], @rule)
+      assert_no_thing_match([4], @rule)       
+    end
+    
+    def test_one_in_three_no_commas
+      @rule.rule = '1 in t1 t2 t3'
+      assert_thing_match([1, 2], @rule)
+      assert_thing_match([1, 2, 3], @rule)
+      assert_thing_match([3], @rule)
+      assert_no_thing_match([4], @rule)       
+    end
+    
+    def test_one_in_three_with_and
+      @rule.rule = '(1 in t1, t2, t3) and t3'
+      assert_no_thing_match([1, 2], @rule)
+      assert_thing_match([1, 2, 3], @rule)
+      assert_thing_match([3], @rule)
+      assert_no_thing_match([4], @rule)       
+    end  
+    
+    def test_one_in_three_with_and_without_brackets
+      @rule.rule = '1 in t1, t2, t3 and t3'
+      assert_no_thing_match([1, 2], @rule)
+      assert_thing_match([1, 2, 3], @rule)
+      assert_thing_match([3], @rule)
+      assert_no_thing_match([4], @rule)       
+    end 
+
+    def test_one_in_three_with_and_without_brackets_and_commas
+      @rule.rule = '1 in t1 t2 t3 and t3'
+      assert_no_thing_match([1, 2], @rule)
+      assert_thing_match([1, 2, 3], @rule)
+      assert_thing_match([3], @rule)
+      assert_no_thing_match([4], @rule)       
+    end
+    
+    def test_2_in_with_and_at_start
+      @rule.rule = 't1 and t2 and 2 in t2 t3 t4'
+      assert_no_thing_match([1, 2], @rule)
+      assert_thing_match([1, 2, 3], @rule)
+      assert_thing_match([1, 2, 4], @rule)
+      assert_no_thing_match([2, 3, 4], @rule)        
+    end
+    
+    def test_in_within_logic_string
+      @rule.rule = '(t1 and 1 in t2 t3) or t4'
+      assert_thing_match([1, 2], @rule)
+      assert_thing_match([1, 2, 3], @rule)
+      assert_no_thing_match([3], @rule)
+      assert_thing_match([4], @rule) 
+    end
+    
+    def test_uppercase_in_within_logic_string
+      @rule.rule = '(t1 AND 1 IN t2 t3) OR t4'
+      assert_thing_match([1, 2], @rule)
+      assert_thing_match([1, 2, 3], @rule)
+      assert_no_thing_match([3], @rule)
+      assert_thing_match([4], @rule) 
+    end
+    
+    def test_operators_in_within_logic_string
+      @rule.rule = '(t1 && 1 in t2 t3) || t4'
+      assert_thing_match([1, 2], @rule)
+      assert_thing_match([1, 2, 3], @rule)
+      assert_no_thing_match([3], @rule)
+      assert_thing_match([4], @rule) 
+    end    
+    
+    def test_match_without_rule
+      assert_raise RuntimeError do
+        @rule.match([1, 2])
+      end
+    end
+    
+    def test_match_with_number_rule
+      @rule.rule = 1
+      assert_raise RuntimeError do
+        @rule.match([1, 2])
+      end
+    end
+
+    def test_replace_item
+      @rule.rule = 't1 or ( t2 and t3 )'
+      process = lambda {|s| [1, 2].include?(s[/\d+/].to_i)}
+      result = @rule.replace_item(/\w\d+/, process)
+      assert_equal('true or ( true and false )', result)
+    end
+    
+    def test_invalid_input
+      @rule.rule = 'invalid'
+      assert_raise RuntimeError do
+        @rule.match([1])
+      end
+    end
+    
+    def test_another_invalid_input
+      @rule.rule = 'a1 and User.delete_all'
+      assert_raise RuntimeError do
+        @rule.match([1])
+      end
+    end
+    
+    def test_matches
+      @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]
+      
+      result = @rule.matches(match_one, match_two, no_match_one, no_match_two)
+      expected = [match_one, match_two]
+      assert_equal(expected, result)
+    end
+    
+    def test_matches_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]
+      
+      result = @rule.matches(match_one, match_two, match_three, no_match_two)
+      expected = [match_one, match_two, match_three]
+      assert_equal(expected, result)
+    end
+    
+  end
+end

data/test/array_logic/test_case.rb

@@ -0,0 +1,25 @@
+require 'test/unit'
+require_relative '../../lib/array_logic'
+
+module ArrayLogic
+  class TestCase < Test::Unit::TestCase
+    
+    def self.things
+      @things ||= Thing.make(10)
+    end
+    
+    def get_things(thing_ids)
+      @things = thing_ids.collect{|id| self.class.things[id]}
+    end
+    
+    def assert_thing_match(thing_ids, rule)
+      get_things(thing_ids)
+      assert(rule.match(@things), "#{thing_ids.inspect} should match '#{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}'")
+    end
+  end
+end

data/test/array_logic/thing_test.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+require_relative '../../lib/array_logic'
+
+module ArrayLogic
+  class ThingTest < Test::Unit::TestCase
+    def test_make
+      number = 10
+      things = Thing.make(number)
+      assert_equal(number, things.length)
+      assert_equal((1..number).to_a, things.values.collect(&:id))
+      assert_equal((1..number).to_a, things.keys)
+    end
+  end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: array_logic
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Rob Nichols
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-26 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.
+email:
+- rob@undervale.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/array_logic.rb
+- lib/main.rb
+- lib/array_logic/thing.rb
+- lib/array_logic/version.rb
+- lib/array_logic/rule.rb
+- MIT-LICENSE
+- Rakefile
+- README.rdoc
+- test/array_logic/thing_test.rb
+- test/array_logic/rule_test.rb
+- test/array_logic/test_case.rb
+homepage: https://github.com/reggieb/array_logic
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+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