predicated 0.1.0 → 0.2.0

data/test/xml_conversion_test.rb

@@ -0,0 +1,34 @@
+require "./test/test_helper_with_wrong"
+
+require "predicated/from/xml"
+require "predicated/to/xml"
+include Predicated
+
+regarding "convert xml back and forth" do
+
+  test "string to predicate to string" do
+    assert{ Predicate.from_xml("<equal><left>a</left><right>3</right></equal>").to_xml == 
+              "<equal><left>a</left><right>3</right></equal>" }
+    
+    complex_xml = %{
+       <or>
+        <and>
+          <equal><left>a</left><right>1</right></equal>
+          <equal><left>b</left><right>2</right></equal>
+        </and>
+        <equal><left>c</left><right>3</right></equal>
+      </or>
+    }
+              
+    assert{ Predicate.from_xml(complex_xml).to_xml.gsub(/\s/, "") == 
+              complex_xml.gsub(/\s/, "") }
+  end
+  
+  test "predicate to string to predicate.  note the loss of type fidelity." do
+    assert{ Predicate.from_xml(Predicate{ Eq("a",3) }.to_xml) == Predicate{ Eq("a",'3') } }
+    
+    assert{ Predicate.from_xml(Predicate{ Or(And(Eq("a",1),Eq("b",2)), Eq("c",3)) }.to_xml) ==
+              Predicate{ Or(And(Eq("a",'1'),Eq("b",'2')), Eq("c",'3')) } }
+  end
+
+end

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: predicated
 version: !ruby/object:Gem::Version 
-  hash: 27
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Steve Conover
@@ -31,32 +30,50 @@ files:
 - lib/predicated/constrain.rb
 - lib/predicated/evaluate.rb
 - lib/predicated/from/callable_object.rb
-- lib/predicated/from/ruby_string.rb
-- lib/predicated/from/url_fragment.rb
+- lib/predicated/from/json.rb
+- lib/predicated/from/ruby_code_string.rb
+- lib/predicated/from/url_part.rb
+- lib/predicated/from/xml.rb
 - lib/predicated/gem_check.rb
 - lib/predicated/predicate.rb
 - lib/predicated/print.rb
-- lib/predicated/selector.rb
+- lib/predicated/selectable.rb
+- lib/predicated/simple_templated_predicate.rb
+- lib/predicated/string_utils.rb
 - lib/predicated/to/arel.rb
+- lib/predicated/to/json.rb
 - lib/predicated/to/sentence.rb
+- lib/predicated/to/solr.rb
+- lib/predicated/to/xml.rb
 - lib/predicated/version.rb
 - lib/predicated.rb
 - README.markdown
+- test/canonical_transform_cases.rb
 - test/constrain_test.rb
 - test/enumerable_test.rb
 - test/equality_test.rb
 - test/evaluate_test.rb
+- test/from/callable_object_canonical_test.rb
 - test/from/callable_object_test.rb
-- test/from/ruby_string_test.rb
-- test/from/url_fragment_parser_test.rb
-- test/from/url_fragment_test.rb
+- test/from/json_test.rb
+- test/from/ruby_code_string_canonical_test.rb
+- test/from/ruby_code_string_test.rb
+- test/from/url_part_parser_test.rb
+- test/from/url_part_test.rb
+- test/from/xml_test.rb
+- test/json_conversion_test.rb
 - test/print_test.rb
-- test/selector_test.rb
+- test/selectable_test.rb
+- test/simple_templated_predicate_test.rb
 - test/suite.rb
 - test/test_helper.rb
 - test/test_helper_with_wrong.rb
 - test/to/arel_test.rb
+- test/to/json_test.rb
 - test/to/sentence_test.rb
+- test/to/solr_test.rb
+- test/to/xml_test.rb
+- test/xml_conversion_test.rb
 has_rdoc: true
 homepage: http://github.com/sconover/predicated
 licenses: []
@@ -71,7 +88,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 2382763030672668207
       segments: 
       - 0
       version: "0"
@@ -80,7 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 2382763030672668207
       segments: 
       - 0
       version: "0"
@@ -92,18 +109,29 @@ signing_key:
 specification_version: 3
 summary: Predicated is a simple predicate model for Ruby
 test_files: 
+- test/canonical_transform_cases.rb
 - test/constrain_test.rb
 - test/enumerable_test.rb
 - test/equality_test.rb
 - test/evaluate_test.rb
+- test/from/callable_object_canonical_test.rb
 - test/from/callable_object_test.rb
-- test/from/ruby_string_test.rb
-- test/from/url_fragment_parser_test.rb
-- test/from/url_fragment_test.rb
+- test/from/json_test.rb
+- test/from/ruby_code_string_canonical_test.rb
+- test/from/ruby_code_string_test.rb
+- test/from/url_part_parser_test.rb
+- test/from/url_part_test.rb
+- test/from/xml_test.rb
+- test/json_conversion_test.rb
 - test/print_test.rb
-- test/selector_test.rb
+- test/selectable_test.rb
+- test/simple_templated_predicate_test.rb
 - test/suite.rb
 - test/test_helper.rb
 - test/test_helper_with_wrong.rb
 - test/to/arel_test.rb
+- test/to/json_test.rb
 - test/to/sentence_test.rb
+- test/to/solr_test.rb
+- test/to/xml_test.rb
+- test/xml_conversion_test.rb

data/lib/predicated/selector.rb

@@ -1,55 +0,0 @@
-module Predicated
-  module Selector  
-    #this is no doubt totally non-performant with all the extends, and 
-    #could probably be just done better / more elegantly
-    #seek help.
-    
-    def self.SelectorEnumerable(key_to_selecting_proc)
-      Module.new do
-        @key_to_selecting_proc = key_to_selecting_proc
-      
-        def self.extended(base)
-          sym = "@key_to_selecting_proc".to_sym
-          hash = base.instance_variable_get(sym) || {}
-          base.instance_variable_set(sym, hash.merge(@key_to_selecting_proc))
-        end
-      
-        def self.included(base)
-          extended(base)
-        end    
-        
-        #ugh ugh
-        def key_to_selecting_proc
-          @key_to_selecting_proc || self.class.instance_variable_get("@key_to_selecting_proc".to_sym)
-        end
-        
-        def select(*keys, &block)
-          key = keys.shift if keys.length>=1
-          result = 
-            if key
-              selecting_proc = key_to_selecting_proc[key]
-              raise "no selector found for '#{key}'.  current selectors: [#{key_to_selecting_proc.collect{|k,v|k.to_s}.join(",")}]" unless selecting_proc
-              memos_for(:select)[key] ||= super(&selecting_proc)
-            else
-              super(&block)
-            end
-          #ugh
-          result.extend(Predicated::Selector.SelectorEnumerable(key_to_selecting_proc))
-          keys.length>=1 ? result.select(*keys, &block) : result
-        end
-    
-        private
-        def memos_for(group)
-          @memos ||= {}
-          @memos[group] ||= {}
-        end
-      end
-    end
-    
-    #ugh
-    def SelectorEnumerable(key_to_selecting_proc)
-      Predicated::Selector.SelectorEnumerable(key_to_selecting_proc)
-    end
-
-  end  
-end

data/test/from/ruby_string_test.rb

@@ -1,135 +0,0 @@
-require "test/test_helper"
-
-require "predicated/from/ruby_string"
-include Predicated
-
-apropos "parse a ruby predicate string" do
-  
-  apropos "basic operations" do
-    
-    #'Wrong'-style asserts are specifically avoided here.
-    #the circularity between the two projects will make you crazy if you're not careful
-    
-    test "simple signs" do
-      assert_equal Predicate.from_ruby_string("1==1"), Predicate{ Eq(1,1) }
-      assert_equal Predicate.from_ruby_string(" 1 == 1 "), Predicate{ Eq(1,1) }
-      assert_equal Predicate.from_ruby_string("0<1"), Predicate{ Lt(0,1) }
-      assert_equal Predicate.from_ruby_string("2>1"), Predicate{ Gt(2,1) }
-      assert_equal Predicate.from_ruby_string("1<=1"), Predicate{ Lte(1,1) }
-      assert_equal Predicate.from_ruby_string("1>=1"), Predicate{ Gte(1,1) }
-    end
-    
-    test "primitive types" do
-      assert_equal Predicate.from_ruby_string("false==true"), Predicate{ Eq(false,true) }
-      assert_equal Predicate.from_ruby_string("'yyy'=='zzz'"), Predicate{ Eq("yyy","zzz") }
-    end
-
-    test "simple and + or" do
-      assert_equal Predicate.from_ruby_string("1==1 && 2==2"), Predicate{ And(Eq(1,1),Eq(2,2)) }
-      assert_equal Predicate.from_ruby_string("1==1 and 2==2"), Predicate{ And(Eq(1,1),Eq(2,2)) }
-      assert_equal Predicate.from_ruby_string("1==1 || 2==2"), Predicate{ Or(Eq(1,1),Eq(2,2)) }
-    end
-
-    class Color
-      attr_reader :name
-      def initialize(name)
-        @name = name
-      end
-    
-      def ==(other)
-        other.is_a?(Color) && @name == other.name
-      end
-    end
-
-    test "substitute in from the binding" do
-      a = 1
-      b = "1"
-      c = "c"
-      d = Color.new("purple")
-      
-      assert_equal Predicate.from_ruby_string("a==1", binding()), Predicate{ Eq(1,1) }
-      assert_equal Predicate.from_ruby_string("b==1", binding()), Predicate{ Eq("1",1) }
-      assert_equal Predicate.from_ruby_string("c==b", binding()), Predicate{ Eq("c","1") }
-      assert_equal Predicate.from_ruby_string("d==d", binding()), Predicate{ Eq(Color.new("purple"),
-                                                              Color.new("purple")) }
-      assert_equal Predicate.from_ruby_string("d==d", binding()).left, d
-
-      assert_equal Predicate.from_ruby_string("a==b && b==c", binding()), 
-                Predicate{ And(Eq(1,"1"),Eq("1","c")) }
-    end
-
-
-    test "complex and + or" do
-      assert_equal Predicate.from_ruby_string("1==1 && 2==2 || 3==3"), 
-                   Predicate{ Or( And(Eq(1,1),Eq(2,2)), Eq(3,3) ) }
-    end
-    
-    test "parens change precedence" do
-      assert_equal Predicate.from_ruby_string("1==1 || 2==2 && 3==3"),
-                   Predicate{ Or( Eq(1,1), And(Eq(2,2),Eq(3,3)) ) }
-
-      assert_equal Predicate.from_ruby_string("(1==1 || 2==2) && 3==3"), 
-                   Predicate{ And( Or(Eq(1,1),Eq(2,2)), Eq(3,3) ) }
-    end
-    
-    apropos "only pay attention to the final line" do
-      #might hate myself one day for this.  but what else does it make sense to do?
-      
-      test "simple" do
-        assert_equal Predicate.from_ruby_string("z=2\nb=5\n1==1"), Predicate{ Eq(1,1) }
-      end
-
-      test "can make use of variables defined earlier in the block" do
-        #might hate myself one day for this.  but what else does it make sense to do?
-        assert_equal Predicate.from_ruby_string("z=2\nb=5\nz==1"), Predicate{ Eq(2,1) }
-      end
-    end
-    
-    test "a call that returns a boolean result" do
-      assert_equal Predicate.from_ruby_string("'abc'.include?('bc')"), 
-                   Predicate{ Call("abc", :include?, "bc") }
-      
-      color = Color.new("purple")  
-      assert_equal Predicate.from_ruby_string("color.name.include?('rp')", binding()), 
-                   Predicate{ Call("purple", :include?, "rp") }
-                   
-      assert_equal Predicate.from_ruby_string("'abc'.nil?"), 
-                   Predicate{ Call("abc", :nil?, nil) }
-    end
-    
-    test "use of instance variables" do
-      @a = 1
-      
-      assert_equal Predicate.from_ruby_string("@a==1", binding()), Predicate{ Eq(1,1) }
-    end
-                            
-    test "use of inline assignments" do
-      assert_equal Predicate.from_ruby_string("(a=2)==1 && a==1"), 
-                   Predicate{ And(Eq(2,1), Eq(2,1)) }
-    end
-                            
-    test "use of inline expressions" do
-      assert_equal Predicate.from_ruby_string("(2*1)==1"), 
-                   Predicate{ Eq(2,1) }
-                   
-      assert_equal Predicate.from_ruby_string("[2,1].first==1"), 
-                   Predicate{ Eq(2,1) }
-    end
-
-
-  end
-  
-  apropos "errors" do
-    test "can't parse" do
-      assert_raises(Racc::ParseError) do 
-        Predicate.from_ruby_string("bad ruby @@@@@****()(((")
-      end
-    end  
-    
-    test "predicates only" do
-      assert_raises(Predicated::Predicate::DontKnowWhatToDoWithThisSexpError) do 
-        Predicate.from_ruby_string("a=1")
-      end
-    end
-  end
-end

data/test/from/url_fragment_test.rb

@@ -1,37 +0,0 @@
-require "test/test_helper_with_wrong"
-
-require "predicated/from/url_fragment"
-include Predicated
-
-apropos "parse url fragments and convert them into predicates" do
-
-  apropos "basic operations" do
-
-    test "simple signs" do
-      assert { Predicate.from_url_fragment("a=1") == Predicate{ Eq("a","1") } }
-      assert { Predicate.from_url_fragment("a<1") == Predicate{ Lt("a","1") } }
-      assert { Predicate.from_url_fragment("a>1") == Predicate{ Gt("a","1") } }
-      assert { Predicate.from_url_fragment("a<=1") == Predicate{ Lte("a","1") } }
-      assert { Predicate.from_url_fragment("a>=1") == Predicate{ Gte("a","1") } }
-    end
-
-    test "simple and + or" do
-      assert { Predicate.from_url_fragment("a=1&b=2") == Predicate{ And(Eq("a","1"),Eq("b","2")) } }
-      assert { Predicate.from_url_fragment("a=1|b=2") == Predicate{ Or(Eq("a","1"),Eq("b","2")) } }
-    end
-
-    test "complex and + or" do
-      assert { Predicate.from_url_fragment("a=1&b=2|c=3") == 
-        Predicate{ Or( And(Eq("a","1"),Eq("b","2")), Eq("c","3") ) } }
-    end
-    
-    test "parens change precedence" do
-      assert { Predicate.from_url_fragment("a=1|b=2&c=3") == 
-        Predicate{ Or( Eq("a","1"), And(Eq("b","2"),Eq("c","3")) ) } }
-
-      assert { Predicate.from_url_fragment("(a=1|b=2)&c=3") == 
-        Predicate{ And( Or(Eq("a","1"),Eq("b","2")), Eq("c","3") ) } }
-    end
-
-  end
-end

data/test/selector_test.rb

@@ -1,82 +0,0 @@
-require "test/test_helper_with_wrong"
-
-require "predicated/selector"
-include Predicated::Selector
-
-apropos "part one: selectors on an array (simple enumerable).  proving them out more generally." do
-  before do
-    @arr = [1,2,"c",4,"e",6]
-    @arr.extend SelectorEnumerable(
-      :strings => proc{|item|item.is_a?(String)}, 
-      :numbers => proc{|item|item.is_a?(Numeric)}, 
-      :less_than_3 => proc{|item|item < 3} 
-    )
-  end
-  
-  test %{selection basics.  
-         People often remark that this kind of thing is jQuery-like.
-         I keep thinking I got it from Eric Evans.} do
-    assert{ @arr.select(:strings) == ["c","e"] }
-    assert{ @arr.select(:numbers) == [1,2,4,6] }
-    assert{ @arr.select(:numbers).select(:less_than_3) == [1,2] }
-    
-    assert do
-      catch_raise{@arr.select(:less_than_3)}.is_a?(ArgumentError)
-      #because strings don't respond to <
-      #...there's no substitute for knowing what you're doing.
-    end
-    
-    #normal select still works
-    assert{ @arr.select{|item|item.is_a?(String)} == ["c","e"] }
-  end
-
-  test "...selector name can be any object" do
-    arr = [1,2,"c",4,"e",6]
-    arr.extend SelectorEnumerable(
-      String => proc{|item|item.is_a?(String)}, 
-      Numeric => proc{|item|item.is_a?(Numeric)}, 
-      :less_than_3 => proc{|item|item < 3} 
-    )
-
-    assert{ arr.select(String) == ["c","e"] }
-    assert{ arr.select(Numeric) == [1,2,4,6] }
-    assert{ arr.select(Numeric).select(:less_than_3) == [1,2] }
-  end
-    
-  test "chaining.  also works using varargs" do
-    assert{ @arr.select(:numbers).select(:less_than_3) == [1,2] }
-    assert{ @arr.select(:numbers, :less_than_3) == [1,2] }
-  end
-    
-  test "extending twice is additive (not destructive)" do
-    arr = [1,2,"c",4,"e",6]
-    arr.extend SelectorEnumerable(:strings => proc{|item|item.is_a?(String)}) 
-    arr.extend SelectorEnumerable(:numbers => proc{|item|item.is_a?(Numeric)}) 
-    
-    assert{ arr.select(:strings) == ["c","e"] }
-    assert{ arr.select(:numbers) == [1,2,4,6] }
-  end
-    
-  test "works as an include" do    
-    class MyArray < Array
-      include SelectorEnumerable(:strings => proc{|item|item.is_a?(String)}) 
-      include SelectorEnumerable(:numbers => proc{|item|item.is_a?(Numeric)}) 
-    end
-    arr = MyArray.new 
-    arr.replace([1,2,"c",4,"e",6])
-
-    assert{ arr.select(:strings) == ["c","e"] }
-    assert{ arr.select(:numbers) == [1,2,4,6] }
-  end
-    
-  test %{memoizes.  
-         Selector enumerable assumes an immutable collection.
-         I'm going to use that assumption against it, and cleverly prove that memoization works.
-         (Others might choose to mock in similar circumstances.)} do
-    assert{ @arr.select(:strings) == ["c","e"] }
-    
-    @arr << "zzz"
-    
-    assert{ @arr.select(:strings) == ["c","e"] }
-  end
-end