rudelo 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

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

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rudelo.gemspec
+gemspec
+
+gem 'rufus-decision', git: 'https://github.com/jmettraux/rufus-decision.git'
+group :development do
+  gem "guard-rspec"
+end

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Michael Johnston
+
+MIT License
+
+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.md

@@ -0,0 +1,60 @@
+# Rudelo
+
+Provides Rufus::Decision::Matchers::SetLogic, for use with [rufus-decision][1]
+
+## Installation
+
+    In Gemfile:
+
+    # until 1.4.0 is published
+    gem 'rufus-decision', git: 'https://github.com/jmettraux/rufus-decision.git'
+
+    gem 'rudelo', git: "git://github.com/lastobelus/rudelo.git"
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+    TABLE = Rufus::Decision::Table.new(%{
+        in:group, out:situation
+        $(bob jeff mary alice ralph) & $in #= 2, company
+        $(bob jeff mary alice ralph) & $in same-as $in #= 3, crowd
+        $(bob jeff mary alice ralph) >= $in #> 3, exclusive-party
+        $(bob jeff mary alice ralph) & $in < $in #> 5, PARTY!
+        $(bob jeff mary alice ralph) & $in < $in #> 3, party
+      })
+    TABLE.matchers.unshift Rudelo::Matchers::SetLogic.new
+
+    table.transform({'group' =>  "bob alice"})
+    #=> {'group' => "bob alice", 'situation' => "company"}
+
+    table.transform({'group' => "bob alice jeff"})
+    #=> {'group' => "bob alice jeff", 'situation' => "crowd"})
+
+    table.transform({'group' => "bob alice jeff ralph"})
+    #=> {'group' => "bob alice jeff ralph", 'situation' => "exclusive-party"}
+
+    table.transform({'group' => "bob alice jeff don"})
+    #=> {'group' => "bob alice jeff don", 'situation' => "party"}
+
+    table.transform({'group' => "bob alice jeff mary ralph don"})
+    #=> {'group' => "bob alice jeff mary ralph don", 'situation' => "PARTY!"}
+
+    table.transform({'group' => "bob alice jeff mary don bev"})
+    #=> {'group' => "bob alice jeff mary don bev", 'situation' => "PARTY!"}
+
+
+
+## Contributing
+
+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
+
+[1]: https://github.com/jmettraux/rufus-decision
+[2]: https://github.com/lastobelus/rufus-decision/tree/pluggable_matchers
+[3]: https://github.com/lastobelus/rufus-decision

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/SET_LOGIC_MATCHER.md

@@ -0,0 +1,100 @@
+# Set Logic Matcher
+
+The SetLogic matcher allows a decision table cell to match based on set logic between the decision table and the corresponding entry in the hash being transformed.
+
+
+## Set Conversion on input hash
+
+When a decision table cell contains a set expression, the corresponding value in the input is first converted to a set according to the following rules:
+
+        $(bob, mary)       => Set["bob", "mary"]
+        $(bob mary, jeff)  => Set["bob mary", "jeff"]
+        $('bob rob', jeff) => Set["bob rob", "jeff"]
+        ${r: ruby_code}    => eval ruby code, ignoring unless it returns a set
+        ${other_column}    => apply set conversion to other_column
+        $(${c1}, ${c2})    => Set["c1 contents", "c2 contents"]
+        bob, mary          => Set["bob", "mary"]
+        bob mary           => Set["bob mary"]
+        'bob, mary', jeff  => Set["bob, mary", "jeff"]
+
+## Decision Table Cell Syntax
+
+1. The SetLogic matcher applies to any cell matching the regex:
+
+  ```ruby
+  /^\$\((.*)\)/
+  ```
+
+### Set Values
+
+set logic expressions can contain Sets expressed in the following ways:
+
+        $in                => the hash element with this column name, with set conversion applied
+        $(${c1})           => the hash element named c1, with set conversion applied
+        $(${in:c1})        => the row element named in:c1, assumed to be Decision Table Cell Syntax
+        $(${out:c1})       => the row element named out:c1, with set conversion applied
+        $()                => empty set
+        $(bob, mary)       => Set["bob", "mary"]
+        $(bob mary, jeff)  => Set["bob mary", "jeff"]
+        $('bob rob', jeff) => Set["bob rob", "jeff"]
+        $(*)               => The universal set
+        $(r: ruby_code)    => eval ruby code, ignoring unless it returns a set
+
+### Set Expressions
+Set expressions can use the following operators:
+
+#### Cardinality Operators
+
+        #=
+        cardinality-equals       => size of set ==
+        #<
+        cardinality-less-than    => size of set is less than X
+        #>
+        cardinality-greater-than => cardinality >
+
+#### Set Construction Operators
+
+        &|intersection     => intersection of sets
+        +|union            => union of sets
+        -|difference       => difference of sets
+        ^|exclusive        => (set1 + set2) - (set1 & set2)
+
+#### Set Logic Operators
+
+        <|proper_subset    => proper_subset of sets
+        >|proper_superset  => proper_superset of sets
+        <=|subset          => subset of sets
+        >=|superset        => superset of sets
+        =|same-as         => equivalent sets
+
+        special case: if the cell contains only a set, it is equivalent to
+        $in <= $(cell)
+
+#### Set Expression Rules
+
+* set expressions are evaluated left to right. There is no grouping; multiple columns in the decision table can be used to accomplish precedence
+* cardinality operators must always be the last operator if present
+* a cell can contain only one cardinality operator; use multiple cells for logic
+* set construction operators may not follow set logic operators
+* when a cardinality operator follows a logic operator, the sense is (set expression) && (cardinality expression applied to rightmost set in set expression).
+* when a cardinality operator follows a (series of) set construction operator(s) it applies to the final constructed set
+* if a cell contains a cardinality operator it matches the input if the cardinality expression is true
+* if a cell contains a set logic operator it matches the input if the set logic expression is true
+* if a cell contains set construction operators only it matches the input if the set expression results in a non-empty set
+* if a cell contains no operators it matches the input if it is a superset of the corresponding input value, ie, it is equivalent to
+
+        $in <= $(cell)
+
+## Examples
+
+        $(bob jeff mary) & $in #= 2
+        => does not match (bob, jeff, mary)
+        => matches (bob, mary) or (jeff, mary) etc.
+        => does not match (bob) or (jeff) or (mary)
+
+        $(bob, jeff, mary)
+        => matches (bob)
+        => matches (jeff, mary)
+        => matches (bob, jeff, mary)
+        => does not match (ralph, bob)
+

data/lib/rudelo/matchers/set_logic.rb

@@ -0,0 +1,68 @@
+#--
+# Copyright (c) 2013, Michael Johnston, lastobelus@gmail.com
+#
+# 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.
+#
+#++
+
+require 'rufus/decision/matcher'
+require 'rudelo/parsers/set_logic_parser'
+require 'rudelo/parsers/set_logic_transform'
+
+module Rudelo
+  module Matchers
+    class SetLogic < Rufus::Decision::Matcher
+
+
+      def matches?(cell, value)
+        in_set = value_transform.apply(value_parser.parse(value))
+        ast(cell).eval(in_set)
+      end
+
+      def cell_substitution?
+        true
+      end
+
+      def asts
+        @asts ||= {}
+      end
+
+      def logic_parser
+        @logic_parser ||= Rudelo::Parsers::SetLogicParser.new
+      end
+
+      def logic_transform
+        @logic_transform ||= Rudelo::Parsers::SetLogicTransform.new
+      end
+
+      def value_parser
+        @value_parser ||= Rudelo::Parsers::SetValueParser.new
+      end
+
+      def value_transform
+        @value_transform ||= Rudelo::Parsers::SetLogicTransform.new
+      end
+
+      def ast(cell)
+        asts[cell] ||= logic_transform.apply(logic_parser.parse(cell))
+      end
+
+    end
+  end
+end

data/lib/rudelo/parsers/set_logic_parser.rb

@@ -0,0 +1,88 @@
+require 'parslet' 
+require 'rudelo/parsers/set_value_parser'
+
+module Rudelo
+  module Parsers
+
+    module Atom
+      include Parslet
+      rule(:digit)   { match("[0-9]") }
+
+      rule(:integer) do
+        str("-").maybe >> match("[1-9]") >> digit.repeat
+      end
+    end
+
+    class SetLogicParser < Parslet::Parser
+      include Space
+      include Set
+      include Atom
+
+      rule(:in_set)                       { str("$in").as(:in_set)}
+      rule(:set )                           { explicit_set  |  in_set  }
+
+      ########  Cardinality  Expressions ########
+      rule(:cardinality_eq) { str('#=')  |  str('cardinality-equals') }
+      rule(:cardinality_gt) { str('#>')  |  str('cardinality-greater-than') }
+      rule(:cardinality_lt) { str('#<')  |  str('cardinality-less-than') }
+      rule(:cardinality_operator) {
+        cardinality_eq | cardinality_gt | cardinality_lt
+      }
+      rule(:cardinality_expression) {(
+          cardinality_operator.as(:op) >> 
+          space? >> 
+          integer.as(:qty)
+        ).as(:cardinality_expression)
+      }
+
+      ########  Set Construction  Expressions ########
+      
+      rule(:set_construction_operator){
+        spaced_op?('&')  | spaced_op('intersection') |
+        spaced_op?('+') | spaced_op('union') |
+        spaced_op?('-') | spaced_op('difference') |
+        spaced_op?('^') | spaced_op('exclusive')
+      }
+      rule(:set_op){
+        (set_construction_operator.as(:left) >> set.as(:right)).as(:set_op)
+      }
+      rule(:set_construction_expression){
+        (set.as(:left) >> set_op.repeat(1).as(:right)).as(:set_construction_expression)
+      }
+
+
+      ########  Set Logic  Expressions ########
+      rule(:set_expression) { set_construction_expression | set }
+      rule(:set_logic_operator){
+        spaced_op?('<', '=')  | spaced_op('proper-subset') |
+        spaced_op?('>', '=') | spaced_op('proper-superset') |
+        spaced_op?('<=') | spaced_op('subset') |
+        spaced_op?('>=') | spaced_op('superset') |
+        spaced_op?('=') | spaced_op('same-as') 
+       }
+      rule(:set_logic_expression){
+        (set_expression.as(:left) >> set_logic_operator >> set.as(:right)).as(:set_logic_expression)
+      }
+
+
+
+
+      rule(:match_expression) { space? >> (
+
+        set_logic_expression.as(:left) >> 
+          (space >> cardinality_expression.as(:right)).maybe  |
+
+        set_construction_expression.as(:left) >> 
+          (space >> cardinality_expression.as(:right)).maybe  |
+
+        cardinality_expression.as(:right)
+
+        ).as(:match_expression) |
+
+        explicit_set.as(:superset_match_expression) >> space? }
+
+      root(:match_expression)
+
+    end
+  end
+end

data/lib/rudelo/parsers/set_logic_transform.rb

@@ -0,0 +1,160 @@
+require 'rudelo/parsers/set_value_transform'
+
+class Set
+  def eval
+    self
+  end
+end
+
+module Rudelo
+  module Parsers
+
+
+    class SetLogicTransform < Rudelo::Parsers::SetValueTransform
+
+
+      attr_accessor :in_set, :set_value
+      def initialize(in_set=::Set.new, &block)
+        @in_set = in_set.dup # the dup is vital because we are going to be pointery later
+        @set_value = SetValueTransform.new
+        super()
+      end
+
+      def apply(obj, context=nil)
+        super @set_value.apply(obj, context), {in_set: @in_set}
+      end
+
+      SetLogicExpr = Struct.new(:left, :op, :right) {
+        def eval
+          left.eval.send(op, right)
+        end
+        def set
+          right
+        end
+      }
+
+      SetConstructionExpr = Struct.new(:left, :right) {
+        def eval
+          right.reduce(left){|left, set_op| set_op.eval(left) }
+        end
+      }
+
+      SetOp = Struct.new(:op, :right) {
+        def eval(set)
+          set.send(op, right)
+        end
+      }
+
+      CardinalityExpr = Struct.new(:op, :qty) {
+        def eval(set)
+          set.size.send(op, qty)
+        end
+        def empty?
+          false
+        end
+      }
+
+      class EmptyExpr
+        def eval(arg=nil)
+          true
+        end
+        def empty?
+          true
+        end
+      end
+
+      MatchExpr = Struct.new(:left, :right, :in_set) {
+        def eval(in_set_override=nil)
+          # I've always wondered what these replace methods were for
+          # and now I know. To make references more pointery.
+          # The purpose of this is so we can construct a transform
+          # once and use it with different values for in_set.
+          in_set.replace(in_set_override) unless in_set_override.nil?
+          lvalue = left.eval
+          case lvalue
+          when ::Set
+            right.empty? ? (lvalue.size > 0) : right.eval(lvalue)
+          when ::TrueClass, ::FalseClass
+            lvalue && right.eval(left.set)
+          else
+            nil
+          end
+        end
+      }
+
+      rule(cardinality_expression: subtree(:expr)){
+        CardinalityExpr.new(expr[:op], expr[:qty])
+      }
+
+      def self.translate_op(op)
+        case op
+        when '#=', 'cardinality-equals',
+          'same-as', '=';                      :"=="
+        when '#<','cardinality-less-than';     :<
+        when '<','proper-subset';              :proper_subset?
+        when '#>','cardinality-greater-than';  :>
+        when '>', 'proper-superset';           :proper_superset?
+        when '<=', 'subset';                   :subset?
+        when '>=', 'superset';                 :superset?
+        when 'intersection';                   :&
+        when 'union';                          :+
+        when 'difference';                     :-
+        when 'exclusive';                      :'^'
+        else
+          op.to_sym
+        end
+      end
+
+      rule(op: simple(:op)){
+        SetLogicTransform.translate_op(op)
+      }
+
+      rule(qty: simple(:qty)){ qty.to_i }
+
+      rule(op: simple(:op), qty: simple(:qty)){ 
+        {op: SetLogicTransform.translate_op(op), qty: qty.to_i}
+      }
+
+      rule(in_set: simple(:x)){ in_set }
+
+      rule(set_logic_expression: subtree(:expr)){
+        SetLogicExpr.new(
+          expr[:left], 
+          SetLogicTransform.translate_op(expr[:op]),
+          expr[:right]
+        )
+      }
+
+      rule(set_construction_expression: subtree(:expr)){
+        SetConstructionExpr.new(
+          expr[:left], 
+          expr[:right]
+        )
+      }
+
+      rule(set_op: subtree(:expr)){
+        SetOp.new(
+          expr[:left], 
+          expr[:right]
+        )
+      }
+
+      rule(match_expression: subtree(:expr)){
+        MatchExpr.new(
+          expr[:left] || in_set, 
+          expr[:right] || EmptyExpr.new,
+          in_set
+        )
+      }
+
+      rule(superset_match_expression: simple(:set)){
+        MatchExpr.new(
+          SetLogicExpr.new(in_set, :subset?, set),
+          EmptyExpr.new,
+          in_set
+        )
+      }
+
+    end
+  end
+end

data/lib/rudelo/parsers/set_value_parser.rb

@@ -0,0 +1,68 @@
+require 'parslet' 
+
+module Rudelo
+  module Parsers
+
+    module Space
+      include Parslet
+      rule(:space)             { match["\t "].repeat(1) }
+      rule(:space?)            { space.maybe }
+      def spaced_op(s)
+        space >> str(s).as(:op)  >> space
+      end      
+      def spaced_op?(s, protect=nil)
+        if protect
+          # this is necessary when some ops are substrings of
+          # other ops. if you have '>' and '>=', use 
+          # spaced_op?('>', '=') for '>'
+          space? >> str(protect).absent? >> str(s).as(:op)  >> space? >> str(protect).absent?
+        else
+          space? >> str(s).as(:op)  >> space?
+        end
+      end
+    end
+
+    module Set
+      include Parslet
+
+      rule(:comma)             { str(',') }
+      rule(:comma?)            { str(',').maybe }
+      rule(:quote)             { match '"' }
+      rule(:open_set)          { str('$(') }
+      rule(:close_set)         { str(')') }
+
+      rule(:unquoted_element)      { 
+         (close_set.absent? >> space.absent? >> comma.absent? >> any).
+        repeat(1).as(:element) }
+      rule(:quoted_element)    { 
+        (quote >> 
+        (quote.absent? >> any).repeat.
+        as(:element) >> 
+        quote)}
+      rule(:element)           { quoted_element | unquoted_element }
+      rule(:element_delimiter)    { (comma | space) >> space? }
+
+
+      rule(:bare_element_list) { 
+        (element >> (element_delimiter >> element).repeat).
+        as(:element_list)
+      }
+
+      rule(:explicit_set)      { 
+        open_set >> space? >>
+        bare_element_list >>
+        space? >>
+        close_set
+      }
+    end
+
+    class SetValueParser < Parslet::Parser
+      include Space
+      include Set
+
+      rule(:set_value)               { explicit_set | bare_element_list }
+      root(:set_value)
+
+    end
+  end
+end

data/lib/rudelo/parsers/set_value_transform.rb

@@ -0,0 +1,10 @@
+module Rudelo
+  module Parsers
+    class SetValueTransform < Parslet::Transform
+      rule(:element => simple(:element)) { element.to_s }
+      rule(:element_list => subtree(:element_list)) do
+        ::Set[*element_list]
+      end
+    end
+  end
+end

data/lib/rudelo/version.rb

@@ -0,0 +1,3 @@
+module Rudelo
+  VERSION = "0.1.0"
+end

data/lib/rudelo.rb

@@ -0,0 +1,6 @@
+require "rudelo/version"
+require "rudelo/matchers/set_logic"
+
+module Rudelo
+  # Your code goes here...
+end

data/rudelo.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rudelo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rudelo"
+  spec.version       = Rudelo::VERSION
+  spec.authors       = ["Michael Johnston"]
+  spec.email         = ["lastobelus@mac.com"]
+  spec.description   = %q{Set Logic Matcher for rufus-decision}
+  spec.summary       = %q{Set Logic Matcher for rufus-decision}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency  "rufus-decision", "~> 1.4"
+  spec.add_dependency  "parslet"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end