wrong 0.1.0 → 0.2.0

data/lib/predicated/lib/predicated/simple_templated_predicate.rb

@@ -0,0 +1,79 @@
+require "predicated/predicate"
+require "predicated/evaluate"
+
+module Predicated
+  def SimpleTemplatedPredicate(&block)
+    result = nil
+    Module.new do
+      extend SimpleTemplatedShorthand
+      result = instance_eval(&block)
+    end
+    result
+  end
+  
+  class And
+    def fill_in(placeholder_replacement)
+      And.new(left.fill_in(placeholder_replacement), right.fill_in(placeholder_replacement))
+    end
+  end
+  
+  class Or
+    def fill_in(placeholder_replacement)
+      Or.new(left.fill_in(placeholder_replacement), right.fill_in(placeholder_replacement))
+    end
+  end
+  
+  class Not
+    def fill_in(placeholder_replacement)
+      Not.new(inner.fill_in(placeholder_replacement))
+    end
+  end
+  
+  class Operation
+    def fill_in(placeholder_replacement)
+      self.class.new(placeholder_replacement, right)
+    end
+  end
+  
+  class Call
+    def fill_in(placeholder_replacement)
+      self.class.new(placeholder_replacement, method_sym, right)
+    end
+  end
+  
+  class Placeholder; end
+  
+  module SimpleTemplatedShorthand
+    include Shorthand
+    
+    def Eq(right) ::Predicated::Equal.new(Placeholder, right) end
+    def Lt(right) ::Predicated::LessThan.new(Placeholder, right) end
+    def Gt(right) ::Predicated::GreaterThan.new(Placeholder, right) end
+    def Lte(right) ::Predicated::LessThanOrEqualTo.new(Placeholder, right) end
+    def Gte(right) ::Predicated::GreaterThanOrEqualTo.new(Placeholder, right) end    
+
+    def Call(method_sym, right=[]) ::Predicated::Call.new(Placeholder, method_sym, right) end    
+  end
+  
+  class Operation < Binary
+    def to_s
+      if left == Placeholder
+        "#{self.class.shorthand}(#{part_to_s(right)})"
+      else
+        super
+      end
+    end
+  end
+
+  class Call < Operation
+    def to_s
+      if left == Placeholder
+        "Call(#{method_sym.to_s}(#{part_to_s(right)}))"
+      else
+        super
+      end
+    end
+  end
+  
+  
+end

data/lib/predicated/lib/predicated/string_utils.rb

@@ -0,0 +1,20 @@
+module Predicated
+  module StringUtils
+    
+    #Ripped from activesupport.  
+    #If I start using a bunch of code from that project I'll create a dependency.
+    #I hope this is not bad form.
+    def self.underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+     
+    def self.uppercamelize(lower_case_and_underscored_word)
+      lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    end
+    
+  end
+end

data/lib/predicated/lib/predicated/to/arel.rb

@@ -0,0 +1,41 @@
+raise "this doesn't work in 1.8.6 because the arel gem is 1.8.7-only" if RUBY_VERSION=="1.8.6"
+
+require "predicated/predicate"
+
+module Predicated
+  
+  require_gem_version("arel", "0.4.0")
+  
+  class And
+    def to_arel(arel_table)
+      Arel::Predicates::And.new(left.to_arel(arel_table), right.to_arel(arel_table))
+    end
+  end
+  
+  class Or
+    def to_arel(arel_table)
+      Arel::Predicates::Or.new(left.to_arel(arel_table), right.to_arel(arel_table))
+    end
+  end
+  
+  class Not
+    def to_arel(arel_table)
+      Arel::Predicates::Not.new(inner.to_arel(arel_table))
+    end
+  end
+  
+  
+  class Operation
+    def to_arel(arel_table)
+      arel_class.new(arel_table.attributes[left], right)
+    end
+  end
+  
+  class Equal; def arel_class; Arel::Predicates::Equality end end
+  class LessThan; def arel_class; Arel::Predicates::LessThan end end
+  class GreaterThan; def arel_class; Arel::Predicates::GreaterThan end end
+  class LessThanOrEqualTo; def arel_class; Arel::Predicates::LessThanOrEqualTo end end
+  class GreaterThanOrEqualTo; def arel_class; Arel::Predicates::GreaterThanOrEqualTo end end
+  
+  
+end

data/lib/predicated/lib/predicated/to/json.rb

@@ -0,0 +1,48 @@
+require "predicated/predicate"
+
+module Predicated
+
+  require_gem_version("json", "1.1.9")
+
+  module JsonStructToJsonStr
+    def to_json_str
+      JSON.pretty_generate(to_json_struct)
+    end
+  end
+  
+  class And
+    include JsonStructToJsonStr
+    def to_json_struct
+      {"and" => [left.to_json_struct, right.to_json_struct]}
+    end
+  end
+
+  class Or
+    include JsonStructToJsonStr
+    def to_json_struct
+      {"or" => [left.to_json_struct, right.to_json_struct]}
+    end
+  end
+
+  class Not
+    include JsonStructToJsonStr
+    def to_json_struct
+      {"not" => inner.to_json_struct}
+    end
+  end
+  
+  class Operation
+    include JsonStructToJsonStr
+    def to_json_struct
+      [left, json_sign, right]
+    end
+  end
+
+  class Equal; private; def json_sign; "==" end end
+  class LessThan; private; def json_sign; "<" end end
+  class GreaterThan; private; def json_sign; ">" end end
+  class LessThanOrEqualTo; private; def json_sign; "<=" end end
+  class GreaterThanOrEqualTo; private; def json_sign; ">=" end end
+  
+
+end

data/lib/predicated/lib/predicated/to/sentence.rb

@@ -0,0 +1,94 @@
+require "predicated/predicate"
+require "predicated/evaluate"
+
+module Predicated
+  
+  module ContainerSentence
+    def to_sentence
+      left.to_sentence + joining_str + right.to_sentence
+    end
+
+    def to_negative_sentence
+      "This is not true: " + to_sentence
+    end
+  end
+  
+  class And; include ContainerSentence; def joining_str; " and " end; end
+  class Or; include ContainerSentence; def joining_str; " or " end;end
+  
+  class Not
+    def to_sentence
+      inner.to_negative_sentence
+    end
+
+    def to_negative_sentence
+      inner.to_sentence
+    end
+  end
+  
+  class Operation
+
+    def self.register_verb_phrase(method_sym, 
+                                  positive_verb_phrase, 
+                                  negative_verb_phrase, 
+                                  accepts_object=true)      
+      @@method_sym_to_phrase_info[method_sym] = {
+        :positive => positive_verb_phrase,
+        :negative => negative_verb_phrase,
+        :accepts_object => accepts_object
+      }
+    end
+    
+    def self.reset_verb_phrases
+      @@method_sym_to_phrase_info = {}
+      
+      register_verb_phrase(:==, "is equal to", "is not equal to")
+      register_verb_phrase(:>, "is greater than", "is not greater than")
+      register_verb_phrase(:<, "is less than", "is not less than")
+      register_verb_phrase(:>=, "is greater than or equal to", "is not greater than or equal to")
+      register_verb_phrase(:<=, "is less than or equal to", "is not less than or equal to")
+
+      register_verb_phrase(:include?, "includes", "does not include")
+      register_verb_phrase(:is_a?, "is a", "is not a")
+      register_verb_phrase(:nil?, "is nil", "is not nil", accepts_object=false)
+      
+      nil
+    end
+    
+    reset_verb_phrases
+    
+    
+    def to_sentence
+      sentence(verb_phrase[:positive])
+    end
+    
+    def to_negative_sentence
+      sentence(verb_phrase[:negative])
+    end
+    
+    private 
+    
+    def sentence(verb_phrase_str)
+      left_str = format_value(left)
+      right_str = format_value(right)
+      
+      str = left_str + " " + verb_phrase_str
+      str << " " + right_str if verb_phrase[:accepts_object]
+      str
+    end
+          
+    def verb_phrase
+      @@method_sym_to_phrase_info[method_sym] || {
+        :positive => "is " + rudimentary=method_sym.to_s.gsub("_", " ").gsub("?", ""),
+        :negative => "is not " + rudimentary,
+        :accepts_object => true
+      } 
+    end
+        
+    def format_value(value)
+      value.inspect
+    end
+
+  end
+  
+end

data/lib/predicated/lib/predicated/to/solr.rb

@@ -0,0 +1,15 @@
+require "predicated/predicate"
+
+module Predicated
+  
+  class And; def to_solr; "(#{left.to_solr} AND #{right.to_solr})" end end
+  class Or;  def to_solr; "(#{left.to_solr} OR #{right.to_solr})" end end
+  class Not; def to_solr; "NOT(#{inner.to_solr})" end end
+  
+  class Equal;                def to_solr; "#{left}:#{right}" end end
+  class GreaterThan;          def to_solr; "#{left}:[#{(right+1)} TO *]" end end
+  class LessThan;             def to_solr; "#{left}:[* TO #{(right-1)}]" end end  
+  class GreaterThanOrEqualTo; def to_solr; "#{left}:[#{right} TO *]" end end
+  class LessThanOrEqualTo;    def to_solr; "#{left}:[* TO #{right}]" end end
+  
+end

data/lib/predicated/lib/predicated/to/xml.rb

@@ -0,0 +1,67 @@
+require "predicated/predicate"
+
+module Predicated
+
+  module ContainerToXml
+    private
+    def to_xml_with_tag_name(indent, tag_name)
+      inner = %{\n#{left.to_xml(indent + "  ")}\n#{right.to_xml(indent + "  ")}}
+      "#{indent}<#{tag_name}>#{inner}\n#{indent}</#{tag_name}>"
+    end
+  end
+  
+  class And
+    include ContainerToXml
+    def to_xml(indent="")
+      to_xml_with_tag_name(indent, "and")
+    end
+  end
+
+  class Or
+    include ContainerToXml
+    def to_xml(indent="")
+      to_xml_with_tag_name(indent, "or")
+    end
+  end
+
+  class Not
+    def to_xml(indent="")
+      "#{indent}<not>\n#{inner.to_xml(indent + "  ")}\n#{indent}</not>"
+    end
+  end
+  
+  class Operation
+    def to_xml(indent="")
+      "#{indent}<#{tag_name}><left>#{escape(left)}</left><right>#{escape(right)}</right></#{tag_name}>"
+    end
+    
+    private 
+    
+    CONVERSION_TABLE = [
+       ['&', '&amp;'],
+       ['<', '&lt;'],
+       ['>', '&gt;'],
+       ["'", '&apos;'],
+       ['"', '&quot;']
+    ]
+    
+    #it's fast.  see http://groups.google.com/group/ruby-talk-google/browse_thread/thread/c0280bab8a037184/9b8ca81c2607189d?hl=en&ie=UTF-8
+    def escape(value)
+      if value.class == String
+        value.gsub(/['"&<>]/) do |match|
+          CONVERSION_TABLE.assoc(match).last
+        end
+      else
+        value
+      end
+    end
+  end
+
+  class Equal; private; def tag_name; "equal" end end
+  class LessThan; private; def tag_name; "lessThan" end end
+  class GreaterThan; private; def tag_name; "greaterThan" end end
+  class LessThanOrEqualTo; private; def tag_name; "lessThanOrEqualTo" end end
+  class GreaterThanOrEqualTo; private; def tag_name; "greaterThanOrEqualTo" end end
+  
+
+end

data/lib/predicated/lib/predicated/version.rb

@@ -0,0 +1,3 @@
+module Predicated
+  VERSION = "0.1.0" unless defined?(Predicated::VERSION)
+end

data/lib/predicated/predicated.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/predicated/version.rb', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name      = "predicated"
+  s.version   = Predicated::VERSION
+  s.authors   = ["Steve Conover"]
+  s.date      = %q{2010-07-06}
+  s.email     = "sconover@gmail.com"
+  s.homepage  = "http://github.com/sconover/predicated"
+  s.summary   = "Predicated is a simple predicate model for Ruby"
+  s.description  = <<-EOS.strip
+Predicated is a simple predicate model for Ruby.
+  EOS
+  s.rubyforge_project = "predicated"
+
+  s.files      = Dir['lib/**/*']
+  s.test_files = Dir['test/**/*.rb']
+
+  s.has_rdoc = true
+  s.extra_rdoc_files = %w[README.markdown]
+end

data/lib/predicated/test/autogen_call_test.rb

@@ -0,0 +1,40 @@
+require "./test/test_helper_with_wrong"
+
+require "predicated/simple_templated_predicate"
+require "predicated/autogen_call"
+
+include Predicated
+
+regarding "if an unknown shorthand method is invoked, assume it's meant to be a Call predicate" do
+
+  test "generate a call predicate.  form is Verb(subject [, object...]) ==> subject.verb_lowercase_underscored([object...])" do
+    assert{ Predicate { Include?("abc", "bc") }.evaluate }
+    deny  { Predicate { Include?("abc", "ZZZ") }.evaluate }
+
+    assert{ Predicate { Include?("abc", "bc") } == Predicate { AutogenCall.new("abc", :include?, ["bc"]) } }
+    assert{ Predicate { Nil?(nil) } == Predicate { AutogenCall.new(nil, :nil?) } }
+  end
+
+  test "existing predicates are unaffected" do
+    assert{ Predicate { Eq(1, 1) } == Predicate { Eq(1, 1) } }
+  end
+  
+  test "works when nested too" do
+    assert{ Predicate { And(Eq(1, 1),Include?("abc", "bc")) } ==  
+              Predicate { And(Eq(1, 1),AutogenCall.new("abc", :include?, ["bc"])) } }
+  end
+  
+  test "looks neato when used with currying" do
+    assert{ SimpleTemplatedPredicate{ Or(Nil?,Include?("bc")) }.fill_in("abc") == 
+      Predicate { Or(AutogenCall.new("abc", :nil?),AutogenCall.new("abc", :include?, ["bc"])) } }
+  end
+  
+  test "to_s, inspect" do
+    assert{ Predicate { Include?("abc", "bc") }.to_s == "Include?('abc',('bc'))" }
+    assert{ Predicate { Nil?(nil) }.to_s == "Nil?(nil)" }
+
+    assert{ Predicate { Include?("abc", "bc") }.inspect == "Include?('abc',('bc'))" }
+    assert{ Predicate { Nil?(nil) }.inspect == "Nil?(nil)" }
+  end
+
+end

data/lib/predicated/test/canonical_transform_cases.rb

@@ -0,0 +1,63 @@
+module CanonicalTransformCases
+  
+  module ClassMethods
+    def create_canonical_tests(expectations, proper_typing=true)
+      val = {
+        :one => 1,
+        :two => 2,
+        :three => 3,
+        :true_value => true,
+        :false_value => false
+      }
+      
+      val.each{|k,v|val[k]=v.to_s} unless proper_typing
+      
+      tests = {
+        "simple operations" => {
+          "eq" => Predicate{ Eq("a",val[:three]) },
+          "gt" => Predicate{ Gt("a",val[:three]) },
+          "lt" => Predicate{ Lt("a",val[:three]) },
+          "gte" => Predicate{ Gte("a",val[:three]) },
+          "lte" => Predicate{ Lte("a",val[:three]) }
+        },
+        "primitive types" => {
+          "true" => Predicate{ Eq("a",val[:true_value]) },
+          "false" => Predicate{ Eq("a",val[:false_value]) },
+          "string" => Predicate{ Eq("a","yyy") },
+        },
+        "not" => {
+          "simple" => Predicate{ Not(Eq("a",val[:true_value])) }
+        },
+        "simple and / or" => {
+          "and" => Predicate{ And(Eq("a", val[:one]),Eq("b", val[:two])) },
+          "or" => Predicate{ Or(Eq("a", val[:one]),Eq("b", val[:two])) }
+        },
+        "complex and / or" => {
+          "or and" => Predicate{ Or(And(Eq("a", val[:one]),Eq("b", val[:two])), Eq("c",val[:three])) } 
+        }
+      }
+  
+      tests.each do |test_name, cases|
+        test test_name do
+          
+          not_found = 
+            cases.keys.sort.select do |case_name|
+              expectations[test_name].nil? || 
+              expectations[test_name][case_name].nil?
+            end
+          
+          raise "no expectation defined for test: '#{test_name}'  cases: [#{not_found.join(", ")}]" unless not_found.empty?
+          
+          cases.each do |case_name, predicate|
+            actual = block_given? ? yield(predicate) : predicate
+            assert { actual == expectations[test_name][case_name] }
+          end
+        end
+      end
+    end
+  end
+  
+  def self.included(other)
+    other.extend(ClassMethods)
+  end
+end