predicate 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: '07778e150b98d73bf35ce337d9874395f1f58e1c'
-  data.tar.gz: 9d0e523c2f41b8b5c530e67a14a69f3dbdf31914
+  metadata.gz: 359d07688b84bc53009ffef594bbb47724840af8
+  data.tar.gz: 263848ef20f69b555afa46f851f9ceec8673c72b
 SHA512:
-  metadata.gz: 84111b7fe5dc17da15f9cb3afb1cee966cedb9a29ed2e420348071c348d6f7c0cd94265c116afc7cae987ca7a96f6f29e52035c9540db85b817ee219da958c59
-  data.tar.gz: cb5d7863db1db730e22b7fd6fe1b7023b89a8a2ef442333d8762ff1fe0b585805d10a2dd832ab07fc98453d7186daeac793c8963e4e38da2ea94fdb94c73db3a
+  metadata.gz: 9b5fe1cc99457949357f9af96860d6686426efdfdd7d7ec8e71ea2011c896bab05e6660bf8b417f5e58882f4221f955c3d52edd600e90e1ac046bd9ad4aea9df
+  data.tar.gz: 98255f1cdc9c13de67466d8028a030d650e5aa66c4c7a6e14bb34016035669e1cdf90302b41623791335c4c73dc35d9b7215eb66168ee8d0ed6bdc567358f954

data/lib/predicate.rb

@@ -25,7 +25,7 @@ class Predicate
       when FalseClass  then contradiction
       when Symbol      then identifier(arg)
       when Proc        then native(arg)
-      when Hash        then eq(arg)
+      when Hash        then from_hash(arg)
       else
         raise ArgumentError, "Unable to coerce `#{arg}` to a predicate"
       end

data/lib/predicate/factory.rb

@@ -29,21 +29,6 @@ class Predicate
       _factor_predicate([:not, sexpr(operand)])
     end
 
-    def relation(r)
-      tuples = r.to_a
-      case tuples.size
-      when 0 then contradiction
-      when 1 then eq(tuples.first)
-      else
-        if tuples.first.size==1
-          k = tuples.first.keys.first
-          self.in(k, tuples.map{|t| t[k]})
-        else
-          tuples.inject(contradiction){|p,t| p | eq(t) }
-        end
-      end
-    end
-
     def in(identifier, values)
       identifier = sexpr(identifier) if identifier.is_a?(Symbol)
       _factor_predicate([:in, identifier, values])
@@ -51,17 +36,7 @@ class Predicate
     alias :among :in
 
     def comp(op, h)
-      h = h.to_hash
-      if h.empty?
-        return tautology
-      elsif h.size==1
-        _factor_predicate [op, sexpr(h.keys.first), sexpr(h.values.last)]
-      else
-        terms = h.to_a.inject([:and]) do |anded,pair|
-          anded << ([op] << sexpr(pair.first) << sexpr(pair.last))
-        end
-        _factor_predicate terms
-      end
+      from_hash(h, op)
     end
 
     [ :eq, :neq, :lt, :lte, :gt, :gte ].each do |m|
@@ -76,6 +51,22 @@ class Predicate
                                [:lte, sexpr(middle), sexpr(upper_bound)]]
     end
 
+    def from_hash(h, op = :eq)
+      if h.empty?
+        tautology
+      else
+        terms = h.to_a.map{|(k,v)|
+          if v.is_a?(Array)
+            [:in, sexpr(k), v]
+          else
+            [op, sexpr(k), sexpr(v)]
+          end
+        }
+        terms = terms.size == 1 ? terms.first : terms.unshift(:and)
+        _factor_predicate terms
+      end
+    end
+
     def literal(literal)
       _factor_predicate([:literal, literal])
     end
@@ -84,6 +75,8 @@ class Predicate
       _factor_predicate([:native, arg])
     end
 
+  protected
+
     def sexpr(expr)
       case expr
       when Expr       then expr

data/lib/predicate/sequel.rb

@@ -0,0 +1,16 @@
+class Predicate
+
+  module Expr
+
+    def to_sequel
+      ToSequel.call(self)
+    end
+
+  end # module Expr
+
+  def to_sequel
+    expr.to_sequel
+  end
+
+end # class Predicate
+require_relative 'sequel/to_sequel'

data/lib/predicate/sequel/to_sequel.rb

@@ -0,0 +1,69 @@
+class Predicate
+  class ToSequel < Sexpr::Processor
+
+    def on_identifier(sexpr)
+      ::Sequel.identifier(sexpr.last)
+    end
+
+    def on_qualified_identifier(sexpr)
+      ::Sequel.as(sexpr.qualifier, sexpr.name)
+    end
+
+    def on_literal(sexpr)
+      sexpr.last.nil? ? nil : ::Sequel.expr(sexpr.last)
+    end
+
+    ###
+
+    def on_tautology(sexpr)
+      ::Sequel::SQL::BooleanConstant.new(true)
+    end
+
+    def on_contradiction(sexpr)
+      ::Sequel::SQL::BooleanConstant.new(false)
+    end
+
+    def on_eq(sexpr)
+      left, right = apply(sexpr.left), apply(sexpr.right)
+      ::Sequel.expr(left => right)
+    end
+
+    def on_neq(sexpr)
+      left, right = apply(sexpr.left), apply(sexpr.right)
+      ~::Sequel.expr(left => right)
+    end
+
+    def on_dyadic_comp(sexpr)
+      left, right = apply(sexpr.left), apply(sexpr.right)
+      left.send(sexpr.operator_symbol, right)
+    end
+    alias :on_lt  :on_dyadic_comp
+    alias :on_lte :on_dyadic_comp
+    alias :on_gt  :on_dyadic_comp
+    alias :on_gte :on_dyadic_comp
+
+    def on_in(sexpr)
+      left, right = apply(sexpr.identifier), sexpr.last
+      ::Sequel.expr(left => right)
+    end
+
+    def on_not(sexpr)
+      ~apply(sexpr.last)
+    end
+
+    def on_and(sexpr)
+      body = sexpr.sexpr_body
+      body[1..-1].inject(apply(body.first)){|f,t| f & apply(t) }
+    end
+
+    def on_or(sexpr)
+      body = sexpr.sexpr_body
+      body[1..-1].inject(apply(body.first)){|f,t| f | apply(t) }
+    end
+
+    def on_native(sexpr)
+      raise NotImplementedError
+    end
+
+  end # class ToSequel
+end # class Predicate

data/lib/predicate/version.rb

@@ -1,7 +1,7 @@
 class Predicate
   module Version
     MAJOR = 1
-    MINOR = 0
+    MINOR = 1
     TINY  = 0
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"

data/spec/factory/test_factor_predicate.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 class Predicate
   describe Factory, "_factor_predicate" do
 
-    subject{ Factory._factor_predicate(arg) }
+    subject{ Factory.send(:_factor_predicate, arg) }
 
     context "on Expr" do
       let(:arg){ Grammar.sexpr([:literal, 12]) }

data/spec/factory/test_from_hash.rb

@@ -0,0 +1,48 @@
+require_relative 'shared/a_predicate_ast_node'
+class Predicate
+  describe Factory, 'from_hash' do
+
+    subject{ Factory.from_hash(h) }
+
+    context "when the hash is empty" do
+      let(:h){ {} }
+
+      it{ should eq(Factory.tautology) }
+    end
+
+    context "when the hash is a singelton" do
+      let(:h){ {:x => 12} }
+
+      it_should_behave_like "a predicate AST node"
+      it{ should be_a(Eq) }
+      it{ should eq([:eq, [:identifier, :x], [:literal, 12]]) }
+    end
+
+    context "when the hash is not a singleton" do
+      let(:h){ {:x => 12, :y => :z} }
+      let(:expected){
+        [:and,
+          [:eq, [:identifier, :x], [:literal, 12]],
+          [:eq, [:identifier, :y], [:identifier, :z]]]
+      }
+
+      it_should_behave_like "a predicate AST node"
+      it{ should be_a(And) }
+      it{ should eq(expected) }
+    end
+
+    context "when the hash has array values" do
+      let(:h){ {:x => [12], :y => :z} }
+      let(:expected){
+        [:and,
+          [:in, [:identifier, :x], [12]],
+          [:eq, [:identifier, :y], [:identifier, :z]]]
+      }
+
+      it_should_behave_like "a predicate AST node"
+      it{ should be_a(And) }
+      it{ should eq(expected) }
+    end
+
+  end
+end

data/spec/predicate/test_coerce.rb

@@ -67,7 +67,15 @@ class Predicate
       let(:arg){ {status: 10, name: "Jones"} }
 
       specify{
-        subject.should eq(Predicate.eq(status: 10) & Predicate.eq(name: "Jones"))
+        expect(subject).to eq(Predicate.eq(status: 10) & Predicate.eq(name: "Jones"))
+      }
+    end
+
+    describe "from Hash (in)" do
+      let(:arg){ {status: [10, 15]} }
+
+      specify{
+        expect(subject).to eq(Predicate.in(:status, [10,15]))
       }
     end
 

data/spec/sequel/test_to_sequel.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+require 'sequel'
+require 'sqlite3'
+require 'predicate/sequel'
+class Predicate
+  describe ToSequel do
+
+    DB = Sequel.sqlite
+
+    before(:all) do
+      DB.create_table :items do
+        primary_key :id
+        String :name
+        String :address
+        Float :price
+      end
+      items = DB[:items]
+    end
+
+    subject do
+      DB[:items].where(predicate.to_sequel).sql
+    end
+
+    context 'tautology' do
+      let(:predicate) { Predicate.tautology }
+
+      it 'works as expected' do
+        expect(subject).to eql("SELECT * FROM `items` WHERE (1 = 1)")
+      end
+    end
+
+    context 'contradiction' do
+      let(:predicate) { Predicate.contradiction }
+
+      it 'works as expected' do
+        expect(subject).to eql("SELECT * FROM `items` WHERE (1 = 0)")
+      end
+    end
+
+    context 'eq(name: "bob")' do
+      let(:predicate) { Predicate.eq(:name, "Bob") }
+
+      it 'works as expected' do
+        expect(subject).to eql("SELECT * FROM `items` WHERE (`name` = 'Bob')")
+      end
+    end
+
+    context 'eq(name: :address)' do
+      let(:predicate) { Predicate.eq(:name, :address) }
+
+      it 'works as expected' do
+        expect(subject).to eql("SELECT * FROM `items` WHERE (`name` = `address`)")
+      end
+    end
+
+    context 'neq(name: "bob")' do
+      let(:predicate) { Predicate.neq(:name, "Bob") }
+
+      it 'works as expected' do
+        expect(subject).to eql("SELECT * FROM `items` WHERE (`name` != 'Bob')")
+      end
+    end
+
+    context 'on_dyadic_comp' do
+      let(:predicate) { Predicate.lt(:price, 10.0) }
+
+      it 'works as expected' do
+        expect(subject).to eql("SELECT * FROM `items` WHERE (`price` < 10.0)")
+      end
+    end
+
+    context 'in' do
+      let(:predicate) { Predicate.in(:price, [10.0, 17.99]) }
+
+      it 'works as expected' do
+        expect(subject).to eql("SELECT * FROM `items` WHERE (`price` IN (10.0, 17.99))")
+      end
+    end
+
+    context 'not' do
+      let(:predicate) { !Predicate.in(:price, [10.0, 17.99]) }
+
+      it 'works as expected' do
+        expect(subject).to eql("SELECT * FROM `items` WHERE (`price` NOT IN (10.0, 17.99))")
+      end
+    end
+
+    context 'and' do
+      let(:predicate) { Predicate.eq(:name, "Bob") & Predicate.lt(:price, 10.0) }
+
+      it 'works as expected' do
+        expect(subject).to eql("SELECT * FROM `items` WHERE ((`name` = 'Bob') AND (`price` < 10.0))")
+      end
+    end
+
+    context 'or' do
+      let(:predicate) { Predicate.eq(:name, "Bob") | Predicate.lt(:price, 10.0) }
+
+      it 'works as expected' do
+        expect(subject).to eql("SELECT * FROM `items` WHERE ((`name` = 'Bob') OR (`price` < 10.0))")
+      end
+    end
+
+    context 'from_hash' do
+      let(:predicate) { Predicate.from_hash(name: "Bob", price: [10.0,17.99]) }
+
+      it 'works as expected' do
+        expect(subject).to eql("SELECT * FROM `items` WHERE ((`name` = 'Bob') AND (`price` IN (10.0, 17.99)))")
+      end
+    end
+
+    context 'native' do
+      let(:predicate) { Predicate.native(->(t){ false }) }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error(NotImplementedError)
+      end
+    end
+
+  end
+end

data/tasks/gem.rake

@@ -0,0 +1,39 @@
+require 'rubygems/package_task'
+
+# Dynamically load the gem spec
+gemspec_file = File.expand_path('../../predicate.gemspec', __FILE__)
+gemspec      = Kernel.eval(File.read(gemspec_file))
+
+Gem::PackageTask.new(gemspec) do |t|
+
+  # Name of the package
+  t.name = gemspec.name
+
+  # Version of the package
+  t.version = gemspec.version
+
+  # Directory used to store the package files
+  t.package_dir = "pkg"
+
+  # True if a gzipped tar file (tgz) should be produced
+  t.need_tar = false
+
+  # True if a gzipped tar file (tar.gz) should be produced
+  t.need_tar_gz = false
+
+  # True if a bzip2'd tar file (tar.bz2) should be produced
+  t.need_tar_bz2 = false
+
+  # True if a zip file should be produced (default is false)
+  t.need_zip = false
+
+  # List of files to be included in the package.
+  t.package_files = gemspec.files
+
+  # Tar command for gzipped or bzip2ed archives.
+  t.tar_command = "tar"
+
+  # Zip command for zipped archives.
+  t.zip_command = "zip"
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: predicate
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Bernard Lambeau
@@ -66,6 +66,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Predicate provides a simple class and processors to encode and manipulate
   (tuple) predicates
 email: blambeau@gmail.com
@@ -103,6 +131,8 @@ files:
 - lib/predicate/processors/qualifier.rb
 - lib/predicate/processors/renamer.rb
 - lib/predicate/processors/to_ruby_code.rb
+- lib/predicate/sequel.rb
+- lib/predicate/sequel/to_sequel.rb
 - lib/predicate/version.rb
 - spec/expr/test_to_proc.rb
 - spec/expr/test_to_ruby_code.rb
@@ -114,6 +144,7 @@ files:
 - spec/factory/test_contradiction.rb
 - spec/factory/test_eq.rb
 - spec/factory/test_factor_predicate.rb
+- spec/factory/test_from_hash.rb
 - spec/factory/test_gt.rb
 - spec/factory/test_gte.rb
 - spec/factory/test_identifier.rb
@@ -155,8 +186,10 @@ files:
 - spec/predicate/test_tautology.rb
 - spec/predicate/test_to_proc.rb
 - spec/predicate/test_to_ruby_code.rb
+- spec/sequel/test_to_sequel.rb
 - spec/spec_helper.rb
 - spec/test_predicate.rb
+- tasks/gem.rake
 - tasks/test.rake
 homepage: http://github.com/enspirit/predicate
 licenses: