predicate 2.7.1 → 2.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 54c6504038763935a1edd5cad47538b4f1d60617
-  data.tar.gz: 897b77cb9b664155976a0c816e5525e7ac6a53e0
+SHA256:
+  metadata.gz: 571d712e35bc8c4144014e76e3827614fdf78191f944a10ce7a1f8f5595886de
+  data.tar.gz: c7919717e71c0a23a4c0869e8e0fa384c5e6b8e0db9af5d87ef7c9c89fa8f006
 SHA512:
-  metadata.gz: a2ea154bb6d8ba3207002db0302ba021038b9f952effc68d89bead03a9e1da6601f272eff0d0e4263d0ae701c15069942ab7fd3a91d17ccac4ff6ebafba58495
-  data.tar.gz: 0ec3739cbd3b6ee4e5e61f97e85a8db546e531dbf8936581cc5a5b7e2ac026113eda6f65628cfc6d000453dfdb943ad80eab5c654f1871cc683930eeae6c9186
+  metadata.gz: d511b557d1b8d05cd4f56064977ba7189faaf37ab33562962a75027ab57454eae11063f9d5444c4a938b804cc5ec3316fe2e5aa39cad7ae33dafcfdd91dc6e4d
+  data.tar.gz: cd1ddf3e4e99abb752c940db00a0627f8be5a6e39556b5c37022f884a8457bcfd75cf27d053639887f8cd5da4125ca86926670f6bc3579a38c3563a6e4e5e02c

data/README.md

@@ -16,6 +16,9 @@ p.evaluate(:x => 2, :y => 6)
 
 p.evaluate(:x => 2, :y => 3)
 # => false
+
+p.assert!(:x => 2, :y => 3)
+# => Minitest::Assertion("Expected false to be truthy")
 ```
 
 When building complex expressions, you can use the `dsl` method.
@@ -226,6 +229,20 @@ p.evaluate(:x => 2, :y => 6)
 # => true
 ```
 
+### Assert
+
+`Predicate#assert!` takes a takes a Hash mapping each free variable to a value,
+and raises a Minitest::AssertionError if the predicate evaluates to false.
+A best effort is made to provide readable error messages on the assertion error.
+
+```ruby
+# Let's build a simple predicate for 'x = 2 and not(y <= 3)'
+p = Predicate.eq(:x, 2) & !Predicate.lte(:y, 3)
+
+p.evaluate(:x => 2, :y => 8)
+# => Expected false to be truthy (Minitest::Assertion)
+```
+
 ### Rename
 
 `Predicate#rename` allows renaming variables.

data/lib/predicate/asserter.rb

@@ -0,0 +1,12 @@
+require 'minitest'
+class Predicate
+  class Asserter
+    include Minitest::Assertions
+
+    def initialize
+      @assertions = 0
+    end
+    attr_accessor :assertions
+
+  end # class Asserter
+end # class Predicate

data/lib/predicate/nodes/and.rb

@@ -53,14 +53,32 @@ class Predicate
       sexpr_body.all?{|operand| operand.evaluate(tuple) }
     end
 
+    def assert!(tuple, asserter = Asserter.new)
+      sexpr_body.all?{|operand| operand.assert!(tuple, asserter) }
+    end
+
     def to_hash
       sexpr_body.inject({}) do |p,term|
-        p.merge(term.to_hash){|k,v1,v2|
-          super unless v1 == v2
-          v1
-        }
+        _hash_merge(p, term.to_hash)
       end
     end
 
+    def to_hashes
+      sexpr_body.inject([{},{}]) do |(pos,neg),term|
+        t_pos, t_neg = term.to_hashes
+        [
+          _hash_merge(pos, t_pos),
+          _hash_merge(neg, t_neg)
+        ]
+      end
+    end
+
+    def _hash_merge(h1, h2)
+      h1.merge(h2){|k,v1,v2|
+        raise ArgumentError, "Unable to represent #{self} to a Hash" unless v1 == v2
+        v1
+      }
+    end
+
   end
 end

data/lib/predicate/nodes/empty.rb

@@ -10,5 +10,11 @@ class Predicate
       value.empty?
     end
 
+    def assert!(tuple, asserter = Asserter.new)
+      value = operand.evaluate(tuple)
+      asserter.assert_empty(value)
+      value
+    end
+
   end
 end

data/lib/predicate/nodes/eq.rb

@@ -46,6 +46,12 @@ class Predicate
       left.evaluate(tuple) == right.evaluate(tuple)
     end
 
+    def assert!(tuple, asserter = Asserter.new)
+      l, r = left.evaluate(tuple), right.evaluate(tuple)
+      asserter.assert_equal(l, r)
+      l
+    end
+
     def to_hash
       if left.identifier? && right.literal? && !right.has_placeholder?
         { left.name => right.value }
@@ -56,5 +62,9 @@ class Predicate
       end
     end
 
+    def to_hashes
+      [ to_hash, {} ]
+    end
+
   end
 end

data/lib/predicate/nodes/expr.rb

@@ -50,6 +50,10 @@ class Predicate
       sexpr([:or, self, other])
     end
 
+    def assert!(tuple, asserter = Asserter.new)
+      asserter.assert(evaluate(tuple))
+    end
+
     def and_split(attr_list)
       # If we have no reference to attr_list, then we are P2, else we are P1
       (free_variables & attr_list).empty? ? [ tautology, self ] : [ self, tautology ]
@@ -99,6 +103,10 @@ class Predicate
       raise ArgumentError, "Unable to represent #{self} to a Hash"
     end
 
+    def to_hashes
+      raise ArgumentError, "Unable to represent #{self} to two Hashes"
+    end
+
     def sexpr(arg)
       Factory.sexpr(arg)
     end

data/lib/predicate/nodes/gt.rb

@@ -10,5 +10,11 @@ class Predicate
       left.evaluate(tuple) > right.evaluate(tuple)
     end
 
+    def assert!(tuple, asserter = Asserter.new)
+      l, r = left.evaluate(tuple), right.evaluate(tuple)
+      asserter.assert_operator(l, :>, r)
+      l
+    end
+
   end
 end

data/lib/predicate/nodes/gte.rb

@@ -10,5 +10,11 @@ class Predicate
       left.evaluate(tuple) >= right.evaluate(tuple)
     end
 
+    def assert!(tuple, asserter = Asserter.new)
+      l, r = left.evaluate(tuple), right.evaluate(tuple)
+      asserter.assert_operator(l, :>=, r)
+      l
+    end
+
   end
 end

data/lib/predicate/nodes/in.rb

@@ -67,6 +67,14 @@ class Predicate
       values.include?(identifier.evaluate(tuple))
     end
 
+    def assert!(tuple, asserter = Asserter.new)
+      values = right.evaluate(tuple)
+      raise UnboundError if values.is_a?(Placeholder)
+      value = identifier.evaluate(tuple)
+      asserter.assert_includes(values, value)
+      value
+    end
+
     def var_against_literal_value?
       left.identifier? && right.literal? && !right.has_placeholder?
     end
@@ -76,5 +84,9 @@ class Predicate
       { identifier.name => right.value }
     end
 
+    def to_hashes
+      [ to_hash, {} ]
+    end
+
   end
 end

data/lib/predicate/nodes/lt.rb

@@ -10,5 +10,11 @@ class Predicate
       left.evaluate(tuple) < right.evaluate(tuple)
     end
 
+    def assert!(tuple, asserter = Asserter.new)
+      l, r = left.evaluate(tuple), right.evaluate(tuple)
+      asserter.assert_operator(l, :<, r)
+      l
+    end
+
   end
 end

data/lib/predicate/nodes/lte.rb

@@ -10,5 +10,11 @@ class Predicate
       left.evaluate(tuple) <= right.evaluate(tuple)
     end
 
+    def assert!(tuple, asserter = Asserter.new)
+      l, r = left.evaluate(tuple), right.evaluate(tuple)
+      asserter.assert_operator(l, :<=, r)
+      l
+    end
+
   end
 end

data/lib/predicate/nodes/neq.rb

@@ -10,5 +10,22 @@ class Predicate
       left.evaluate(tuple) != right.evaluate(tuple)
     end
 
+    def assert!(tuple, asserter = Asserter.new)
+      l, r = left.evaluate(tuple), right.evaluate(tuple)
+      asserter.refute_equal(l, r)
+      l
+    end
+
+    def to_hashes
+      hash = if left.identifier? && right.literal? && !right.has_placeholder?
+        { left.name => right.value }
+      elsif right.identifier? && left.literal? && !left.has_placeholder?
+        { right.name => left.value }
+      else
+        super
+      end
+      [ {}, hash ]
+    end
+
   end
 end

data/lib/predicate/nodes/tautology.rb

@@ -37,5 +37,9 @@ class Predicate
       {}
     end
 
+    def to_hashes
+      [{}, {}]
+    end
+
   end
 end

data/lib/predicate/version.rb

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

data/lib/predicate.rb

@@ -6,6 +6,7 @@ require_relative 'predicate/sugar'
 require_relative 'predicate/grammar'
 require_relative 'predicate/processors'
 require_relative 'predicate/dsl'
+require_relative 'predicate/asserter'
 class Predicate
 
   class Error < StandardError; end
@@ -125,6 +126,10 @@ class Predicate
     expr.evaluate(tuple)
   end
 
+  def assert!(tuple = {})
+    expr.assert!(tuple)
+  end
+
   # Splits this predicate, say P, as too predicates P1 & P2
   # such that `P <=> P1 & P2` and P2 makes no reference to
   # any attribute in `attr_list`.
@@ -160,10 +165,24 @@ class Predicate
   end
 
   # If possible, converts this predicate back to a `{ attr: value, ... }`
-  # hash. Raises an IllegalArgumentError if the predicate cannot be
-  # represented that way.
+  # hash.
+  #
+  # Raises an ArgumentError if the predicate cannot be represented that way.
   def to_hash
     expr.to_hash
   end
 
+  # If possible, converts this predicate back to two `{ attr: value, ... }`
+  # hashes, where the first one is positive (e.g. x IN ...) and the second one
+  # is negative (e.g. x NOT IN ...)
+  #
+  # The result is such that the original predicate is equivalent to a AND
+  # of the two hashes, where the first includes all its values and the second
+  # excludes all its values.
+  #
+  # Raises an ArgumentError if the predicate cannot be represented that way.
+  def to_hashes
+    expr.to_hashes
+  end
+
 end # class Predicate

data/spec/factory/shared/a_comparison_factory_method.rb

@@ -7,8 +7,12 @@ shared_examples_for "a comparison factory method" do
     subject{ self.send(method, true, true) }
 
     it_should_behave_like "a predicate AST node"
-    it{ should be_a(node_class) }
-    it{ should eql([method, tautology, tautology]) }
+    it {
+      expect(subject).to be_a(node_class)
+    }
+    it {
+      expect(subject).to eql([method, tautology, tautology])
+    }
   end
 
   context 'with a Hash operand (singleton)' do
@@ -18,7 +22,9 @@ shared_examples_for "a comparison factory method" do
     }
 
     it_should_behave_like "a predicate AST node"
-    it{ should eql(expected) }
+    it {
+      expect(subject).to eql(expected)
+    }
   end
 
   context 'with a Hash operand' do
@@ -30,7 +36,9 @@ shared_examples_for "a comparison factory method" do
     }
 
     it_should_behave_like "a predicate AST node"
-    it{ should eql(expected) }
+    it {
+      expect(subject).to eql(expected)
+    }
   end
 
 end

data/spec/factory/shared/a_predicate_ast_node.rb

@@ -1,20 +1,26 @@
 require 'spec_helper'
 shared_examples_for "a predicate AST node" do
 
-  it{ should be_a(Sexpr) }
+  it {
+    expect(subject).to be_a(Sexpr)
+  }
 
-  it{ should be_a(Predicate::Expr) }
+  it {
+    expect(subject).to be_a(Predicate::Expr)
+  }
 
   specify{
-    (subject.tautology? == subject.is_a?(Predicate::Tautology)).should be(true)
+    got = (subject.tautology? == subject.is_a?(Predicate::Tautology))
+    expect(got).to be(true)
   }
 
   specify{
-    (subject.contradiction? == subject.is_a?(Predicate::Contradiction)).should be(true)
+    got = (subject.contradiction? == subject.is_a?(Predicate::Contradiction))
+    expect(got).to be(true)
   }
 
   specify{
-    subject.free_variables.should be_a(Array) unless subject.is_a?(Predicate::Native)
+    expect(subject.free_variables).to be_a(Array) unless subject.is_a?(Predicate::Native)
   }
 
 end

data/spec/factory/test_${op_name}.rb.jeny

@@ -7,6 +7,8 @@ class Predicate
 
     it_should_behave_like "a predicate AST node"
 
-    it{ should be_a(${OpName}) }
+    it {
+      expect(subject).to be_a(${OpName})
+    }
   end
 end

data/spec/factory/test_and.rb

@@ -6,8 +6,12 @@ class Predicate
     subject{ self.and(true, true) }
 
     it_should_behave_like "a predicate AST node"
-    it{ should be_a(And) }
-    it{ should eql([:and, tautology, tautology]) }
+    it {
+      expect(subject).to be_a(And)
+    }
+    it {
+      expect(subject).to eql([:and, tautology, tautology])
+    }
 
   end
 end

data/spec/factory/test_comp.rb

@@ -7,15 +7,21 @@ class Predicate
     context "when the hash is empty" do
       let(:h){ {} }
 
-      it{ should eq(Factory.tautology) }
+      it {
+        expect(subject).to 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]]) }
+      it {
+        expect(subject).to be_a(Eq)
+      }
+      it {
+        expect(subject).to eq([:eq, [:identifier, :x], [:literal, 12]])
+      }
     end
 
     context "when the hash is not singleton" do
@@ -27,8 +33,12 @@ class Predicate
       }
 
       it_should_behave_like "a predicate AST node"
-      it{ should be_a(And) }
-      it{ should eq(expected) }
+      it {
+        expect(subject).to be_a(And)
+      }
+      it {
+        expect(subject).to eq(expected)
+      }
     end
 
     context "when the value is a Regexp" do
@@ -36,8 +46,12 @@ class Predicate
       let(:h){ {:x => /[a-z]+/} }
 
       it_should_behave_like "a predicate AST node"
-      it{ should be_a(Match) }
-      it{ should eq([:match, [:identifier, :x], [:literal, rx]]) }
+      it {
+        expect(subject).to be_a(Match)
+      }
+      it {
+        expect(subject).to eq([:match, [:identifier, :x], [:literal, rx]])
+      }
     end
 
     context "when the hash mixes value types" do
@@ -50,8 +64,12 @@ class Predicate
       }
 
       it_should_behave_like "a predicate AST node"
-      it{ should be_a(And) }
-      it{ should eq(expected) }
+      it {
+        expect(subject).to be_a(And)
+      }
+      it {
+        expect(subject).to eq(expected)
+      }
     end
 
   end

data/spec/factory/test_contradiction.rb

@@ -6,6 +6,8 @@ class Predicate
     subject{ contradiction }
 
     it_should_behave_like "a predicate AST node"
-    it{ should be_a(Contradiction) }
+    it {
+      expect(subject).to be_a(Contradiction)
+    }
   end
 end

data/spec/factory/test_empty.rb

@@ -6,6 +6,8 @@ class Predicate
 
     it_should_behave_like "a predicate AST node"
 
-    it{ should be_a(Empty) }
+    it {
+      expect(subject).to be_a(Empty)
+    }
   end
 end

data/spec/factory/test_factor_predicate.rb

@@ -7,43 +7,57 @@ class Predicate
     context "on Expr" do
       let(:arg){ Grammar.sexpr([:literal, 12]) }
 
-      it{ should be(arg) }
+      it {
+        expect(subject).to be(arg)
+      }
     end
 
     context "on true" do
       let(:arg){ true }
 
-      it{ should be_a(Tautology) }
+      it {
+        expect(subject).to be_a(Tautology)
+      }
     end
 
     context "on false" do
       let(:arg){ false }
 
-      it{ should be_a(Contradiction) }
+      it {
+        expect(subject).to be_a(Contradiction)
+      }
     end
 
     context "on Symbol" do
       let(:arg){ :name }
 
-      it{ should be_a(Identifier) }
+      it {
+        expect(subject).to be_a(Identifier)
+      }
     end
 
     context "on Proc" do
       let(:arg){ lambda{} }
 
-      it{ should be_a(Native) }
+      it {
+        expect(subject).to be_a(Native)
+      }
     end
 
     context "on Array" do
       let(:arg){ [:identifier, :name] }
 
-      it{ should be_a(Identifier) }
+      it {
+        expect(subject).to be_a(Identifier)
+      }
     end
 
     context "on 12" do
       let(:arg){ 12 }
 
-      it{ should be_a(Literal) }
+      it {
+        expect(subject).to be_a(Literal)
+      }
     end
 
   end

data/spec/factory/test_from_hash.rb

@@ -7,15 +7,21 @@ class Predicate
     context "when the hash is empty" do
       let(:h){ {} }
 
-      it{ should eq(Factory.tautology) }
+      it {
+        expect(subject).to 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]]) }
+      it {
+        expect(subject).to be_a(Eq)
+      }
+      it {
+        expect(subject).to eq([:eq, [:identifier, :x], [:literal, 12]])
+      }
     end
 
     context "when the hash is not a singleton" do
@@ -27,8 +33,12 @@ class Predicate
       }
 
       it_should_behave_like "a predicate AST node"
-      it{ should be_a(And) }
-      it{ should eq(expected) }
+      it {
+        expect(subject).to be_a(And)
+      }
+      it {
+        expect(subject).to eq(expected)
+      }
     end
 
     context "when the hash has array values" do
@@ -40,8 +50,12 @@ class Predicate
       }
 
       it_should_behave_like "a predicate AST node"
-      it{ should be_a(And) }
-      it{ should eq(expected) }
+      it {
+        expect(subject).to be_a(And)
+      }
+      it {
+        expect(subject).to eq(expected)
+      }
     end
 
   end

data/spec/factory/test_has_size.rb

@@ -6,6 +6,8 @@ class Predicate
 
     it_should_behave_like "a predicate AST node"
 
-    it{ should be_a(HasSize) }
+    it {
+      expect(subject).to be_a(HasSize)
+    }
   end
 end

data/spec/factory/test_identifier.rb

@@ -6,8 +6,12 @@ class Predicate
     subject{ identifier(:name) }
 
     it_should_behave_like "a predicate AST node"
-    it{ should be_a(Identifier) }
-    it{ should eql([:identifier, :name]) }
+    it {
+      expect(subject).to be_a(Identifier)
+    }
+    it {
+      expect(subject).to eql([:identifier, :name])
+    }
 
   end
 end

data/spec/factory/test_literal.rb

@@ -6,8 +6,12 @@ class Predicate
     subject{ literal(12) }
 
     it_should_behave_like "a predicate AST node"
-    it{ should be_a(Literal) }
-    it{ should eql([:literal, 12]) }
+    it {
+      expect(subject).to be_a(Literal)
+    }
+    it {
+      expect(subject).to eql([:literal, 12])
+    }
 
   end
 end