wrong 0.3.1 → 0.3.2

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

@@ -1,79 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,94 +0,0 @@
-require "predicated/predicate"
-require "predicated/evaluate"
-
-module Predicated
-  
-  module Conjunction
-    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 Conjunction; def joining_str; " and " end; end
-  class Or; include Conjunction; 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

@@ -1,15 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

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

data/lib/predicated/predicated.gemspec

@@ -1,22 +0,0 @@
-# -*- 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

@@ -1,40 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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