decision_table 0.0.1

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.redcar
+vendor/ruby
+bin

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in decision_table.gemspec
+gemspec

data/Rakefile

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

data/decision_table.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "decision_table/version"
+
+Gem::Specification.new do |s|
+  s.name        = "decision_table"
+  s.version     = DecisionTable::VERSION
+  s.authors     = ["Chris Nelson"]
+  s.email       = ["superchrisnelson@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Table driven decision logic in ruby}
+  s.description = %q{If you have decision algorithm that can be easily expressed in a table, this gem can help}
+
+  s.rubyforge_project = "decision_table"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rspec-given"
+  s.add_runtime_dependency "activesupport"
+end

data/lib/decision_table/rule.rb

@@ -0,0 +1,37 @@
+module DecisionTable
+  class Rule
+    
+    attr_accessor :criteria, :result
+    
+    def initialize(criteria, result)
+      @criteria = criteria
+      @result = result
+    end
+    
+    def applies?(candidate)
+      criteria.all? do |k, v|
+        v.blank? || matches?(candidate, k, v)
+      end
+    end
+    
+    def matches?(candidate, key, value)
+      if value.to_s == "true"
+        candidate.send(key)
+      elsif value.to_s == "false"
+        !candidate.send(key)
+      else
+        candidate.send(key) == value
+      end
+    end
+    
+    def self.parse(rule_string)
+      criteria = {}
+      rule_string.split(",").each do |crit|
+        k, v = crit.split(":")
+        criteria[k] = v
+      end
+      Rule.new(criteria, true)
+    end
+    
+  end
+end

data/lib/decision_table/ruleset.rb

@@ -0,0 +1,18 @@
+module DecisionTable
+  class Ruleset
+    attr_accessor :rules
+    def initialize(rules)
+      @rules = rules
+    end
+    
+    def evaluate(candidate)
+      rule = rules.detect { |rule| rule.applies?(candidate) }
+      rule.result if rule
+    end
+    
+    def self.parse_csv(csv)
+      data = FasterCSV.parse(csv)
+      keys = data.shift
+    end
+  end
+end

data/lib/decision_table/version.rb

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

data/lib/decision_table.rb

@@ -0,0 +1,8 @@
+require "active_support/core_ext"
+require "decision_table/version"
+require "decision_table/rule"
+require "decision_table/ruleset"
+
+module DecisionTable
+  # Your code goes here...
+end

data/spec/rule_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe DecisionTable::Rule do
+  Given(:candidate) { double(:candidate, :foo => "bar", :bing => "baz") }
+  
+  describe("applies") do
+    context "when all values match" do
+      Given(:rule) { DecisionTable::Rule.new({:foo => "bar", :bing => "baz"}, true) }
+      Then { rule.applies?(candidate).should be_true}
+    end
+    
+    context "when all specified values match" do
+      Given(:rule ) { DecisionTable::Rule.new({:foo => "bar", :bing => ""}, true) }
+      Then { rule.applies?(candidate).should be_true}
+    end
+      
+    context "when values don't match" do
+      Given(:rule) { DecisionTable::Rule.new({:foo => "not bar", :bing => "baz"}, true) }
+      Then { rule.applies?(candidate).should be_false}
+    end
+    
+  end
+  
+  describe("parsing rule") do
+    Given(:rule_string) { "foo:bar,bing:baz" }
+    When(:rule) { DecisionTable::Rule.parse(rule_string) }
+    Then { rule.applies?(candidate).should be_true }
+    
+    context "with boolean rules" do
+      Given(:candidate) { double(:candidate, foo: true, bar: false) }
+      Given(:non_matching) { double(:candidate, foo: nil, bar: true) }
+      Given(:rule) {DecisionTable::Rule.parse("foo:true,bar:false") }
+      Then { rule.applies?(candidate).should be_true }
+      Then { rule.applies?(non_matching).should be_false }
+    end
+  end
+  
+end

data/spec/rules.csv

@@ -0,0 +1,3 @@
+foo,bar,result
+bork,,false
+bing,baz,true

data/spec/ruleset_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module DecisionTable
+  describe Ruleset do
+    Given(:candidate) { double(:candidate, foo: "bar", baz: "bing")}
+    describe "decide" do
+      context "one applicable rule" do
+        Given(:ruleset) do
+          rule = Rule.new({foo: "bar"}, "result")
+          Ruleset.new([rule])
+        end
+        Then { ruleset.evaluate(candidate).should == "result" }
+      end
+      context "two applicable rules" do
+        Given(:first_rule) { first_rule = Rule.new({baz: "bing"}, "first_result") }
+        Given(:second_rule) { first_rule = Rule.new({foo: "bar"}, "second_result") }
+        Given(:ruleset) { Ruleset.new [first_rule, second_rule] }
+        Then { ruleset.evaluate(candidate).should == "first_result"}
+      end
+      context "no applicable rules" do
+        Given(:rule) { Rule.new({baz: "not bing"}, "first_result") }
+        Then { Ruleset.new([rule]).evaluate(candidate).should be_nil }
+      end
+    end
+    
+    describe "parsing CSV" do
+      pending "maybe later"
+      # Given(:csv_data) { File.read(File.join(File.dirname(__FILE__), "rules.csv")) }
+      # When(:ruleset) { Ruleset.parse_csv(csv_data) }
+      # Then { ruleset.rules.size.should == 2}
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rspec/given'
+require 'decision_table' # and any other gems you need
+
+RSpec.configure do |config|
+  # some (optional) config here
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: decision_table
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Chris Nelson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70177089993400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70177089993400
+- !ruby/object:Gem::Dependency
+  name: rspec-given
+  requirement: &70177089992480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70177089992480
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70177089991940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70177089991940
+description: If you have decision algorithm that can be easily expressed in a table,
+  this gem can help
+email:
+- superchrisnelson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- decision_table.gemspec
+- lib/decision_table.rb
+- lib/decision_table/rule.rb
+- lib/decision_table/ruleset.rb
+- lib/decision_table/version.rb
+- spec/rule_spec.rb
+- spec/rules.csv
+- spec/ruleset_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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: decision_table
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Table driven decision logic in ruby
+test_files:
+- spec/rule_spec.rb
+- spec/rules.csv
+- spec/ruleset_spec.rb
+- spec/spec_helper.rb