predicate 1.0.0

data/lib/predicate/processors/qualifier.rb

@@ -0,0 +1,23 @@
+class Predicate
+  class Qualifier < Sexpr::Rewriter
+
+    grammar Grammar
+
+    def initialize(qualifier)
+      @qualifier = qualifier
+    end
+    attr_reader :qualifier
+
+    def on_identifier(sexpr)
+      return sexpr unless q = qualifier[sexpr.name]
+      [:qualified_identifier, q, sexpr.name]
+    end
+
+    def on_native(sexpr)
+      raise NotSupportedError
+    end
+
+    alias :on_missing :copy_and_apply
+
+  end
+end

data/lib/predicate/processors/renamer.rb

@@ -0,0 +1,25 @@
+class Predicate
+  class Renamer < Sexpr::Rewriter
+
+    grammar Grammar
+
+    def on_identifier(sexpr)
+      return sexpr unless new_name = options[:renaming][sexpr.name]
+      return new_name if Sexpr===new_name
+      [:identifier, new_name]
+    end
+
+    def on_qualified_identifier(sexpr)
+      return sexpr unless new_name = options[:renaming][sexpr.name]
+      return new_name if Sexpr===new_name
+      [:qualified_identifier, sexpr.qualifier, new_name]
+    end
+
+    def on_native(sexpr)
+      raise NotSupportedError
+    end
+
+    alias :on_missing :copy_and_apply
+
+  end
+end

data/lib/predicate/processors/to_ruby_code.rb

@@ -0,0 +1,71 @@
+class Predicate
+  class ToRubyCode < Sexpr::Processor
+
+    def on_tautology(sexpr)
+      "true"
+    end
+
+    def on_contradiction(sexpr)
+      "false"
+    end
+
+    def on_qualified_identifier(sexpr)
+      "#{sexpr.qualifier}[:#{sexpr.name}]"
+    end
+
+    def on_identifier(sexpr)
+      if s = options[:scope]
+        "#{s}[:#{sexpr.last.to_s}]"
+      else
+        sexpr.last.to_s
+      end
+    end
+
+    def on_not(sexpr)
+      "#{sexpr.operator_symbol}" << apply(sexpr.last, sexpr)
+    end
+
+    def on_nadic_bool(sexpr)
+      sexpr.sexpr_body.map{|term|
+        apply(term, sexpr)
+      }.join(" #{sexpr.operator_symbol} ")
+    end
+    alias :on_and :on_nadic_bool
+    alias :on_or  :on_nadic_bool
+
+    def on_dyadic(sexpr)
+      sexpr.sexpr_body.map{|term|
+        apply(term, sexpr)
+      }.join(" #{sexpr.operator_symbol} ")
+    end
+    alias :on_eq  :on_dyadic
+    alias :on_neq :on_dyadic
+    alias :on_lt  :on_dyadic
+    alias :on_lte :on_dyadic
+    alias :on_gt  :on_dyadic
+    alias :on_gte :on_dyadic
+
+    def on_in(sexpr)
+      "#{to_ruby_literal(sexpr.values)}.include?(#{apply(sexpr.identifier)})"
+    end
+
+    def on_literal(sexpr)
+      to_ruby_literal(sexpr.last)
+    end
+
+  protected
+
+    def to_ruby_literal(x)
+      x.inspect
+    end
+
+    def apply(sexpr, parent = nil)
+      code = super(sexpr)
+      if parent && (parent.priority >= sexpr.priority)
+        code = "(" << code << ")"
+      end
+      code
+    end
+
+  end
+end

data/lib/predicate/processors.rb

@@ -0,0 +1,3 @@
+require_relative "processors/to_ruby_code"
+require_relative "processors/renamer"
+require_relative "processors/qualifier"

data/lib/predicate/version.rb

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

data/lib/predicate.rb

@@ -0,0 +1,113 @@
+require 'sexpr'
+require_relative 'predicate/version'
+require_relative 'predicate/factory'
+require_relative 'predicate/grammar'
+require_relative 'predicate/processors'
+class Predicate
+
+  class NotSupportedError < StandardError; end
+
+  TupleLike = ->(t){ t.is_a?(Hash) }
+
+  def initialize(sexpr)
+    @sexpr = sexpr
+  end
+  attr_reader :sexpr
+  alias :expr :sexpr
+
+  class << self
+    include Factory
+
+    def coerce(arg)
+      case arg
+      when Predicate   then arg
+      when TrueClass   then tautology
+      when FalseClass  then contradiction
+      when Symbol      then identifier(arg)
+      when Proc        then native(arg)
+      when Hash        then eq(arg)
+      else
+        raise ArgumentError, "Unable to coerce `#{arg}` to a predicate"
+      end
+    end
+    alias :parse :coerce
+
+  private
+
+    def _factor_predicate(arg)
+      Predicate.new Grammar.sexpr(arg)
+    end
+
+  end
+
+  def native?
+    Native===expr
+  end
+
+  def tautology?
+    expr.tautology?
+  end
+
+  def contradiction?
+    expr.contradiction?
+  end
+
+  def free_variables
+    expr.free_variables
+  end
+
+  def constant_variables
+    expr.constant_variables
+  end
+
+  def &(other)
+    return self  if other.tautology? or other==self
+    return other if tautology?
+    Predicate.new(expr & other.expr)
+  end
+
+  def |(other)
+    return self  if other.contradiction? or other==self
+    return other if contradiction?
+    Predicate.new(expr | other.expr)
+  end
+
+  def !
+    Predicate.new(!expr)
+  end
+
+  def qualify(qualifier)
+    Predicate.new(expr.qualify(qualifier))
+  end
+
+  def rename(renaming)
+    Predicate.new(expr.rename(renaming))
+  end
+
+  def evaluate(tuple)
+    to_proc.call(tuple)
+  end
+
+  def and_split(attr_list)
+    expr.and_split(attr_list).map{|e| Predicate.new(e)}
+  end
+
+  def ==(other)
+    other.is_a?(Predicate) && (other.expr==expr)
+  end
+  alias :eql? :==
+
+  def hash
+    expr.hash
+  end
+
+  def to_ruby_code(scope = "t")
+    expr.to_ruby_code(scope)
+  end
+  alias :to_s :to_ruby_code
+
+  def to_proc
+    @proc ||= expr.to_proc("t")
+  end
+
+end # class Predicate

data/spec/expr/test_to_proc.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+class Predicate
+  describe Expr, "to_proc" do
+
+    let(:expr){ Factory.lte(:x, 2) }
+
+    subject{ expr.to_proc }
+
+    it{ should be_a(Proc) }
+
+    it 'has arity 1' do
+      subject.arity.should eq(1)
+    end
+
+  end
+end

data/spec/expr/test_to_ruby_code.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+class Predicate
+  describe Expr, "to_ruby_code" do
+
+    let(:f){ Factory }
+
+    subject{ expr.to_ruby_code }
+
+    after do
+      unless expr.is_a?(Native)
+        lambda{
+          eval(subject)
+        }.should_not raise_error
+      end
+    end
+
+    context 'tautology' do
+      let(:expr){ f.tautology }
+
+      it{ should eq("->(t){ true }") }
+    end
+
+    context 'contradiction' do
+      let(:expr){ f.contradiction }
+
+      it{ should eq("->(t){ false }") }
+    end
+
+    describe "identifier" do
+      let(:expr){ f.identifier(:name) }
+
+      it{ should eq("->(t){ t[:name] }") }
+    end
+
+    describe "and" do
+      let(:expr){ f.and(f.contradiction, f.contradiction) }
+
+      it{ should eq("->(t){ false && false }") }
+    end
+
+    describe "or" do
+      let(:expr){ f.or(f.contradiction, f.contradiction) }
+
+      it{ should eq("->(t){ false || false }") }
+    end
+
+    describe "not" do
+      let(:expr){ f.not(f.contradiction) }
+
+      it{ should eq("->(t){ !false }") }
+    end
+
+    describe "comp" do
+      let(:expr){ f.comp(:lt, {:x => 2}) }
+
+      it{ should eq("->(t){ t[:x] < 2 }") }
+    end
+
+    describe "eq" do
+      let(:expr){ f.eq(:x, 2) }
+
+      it{ should eq("->(t){ t[:x] == 2 }") }
+    end
+
+    describe "eq (parentheses required)" do
+      let(:expr){ f.eq(f.eq(:y, 2), true) }
+
+      it{ should eq("->(t){ (t[:y] == 2) == true }") }
+    end
+
+    describe "comp (multiple)" do
+      let(:expr){ f.comp(:eq, :x => 2, :y => 3) }
+
+      it{ should eq("->(t){ (t[:x] == 2) && (t[:y] == 3) }") }
+    end
+
+    describe "in" do
+      let(:expr){ f.in(:x, [2, 3]) }
+
+      it{ should eq("->(t){ [2, 3].include?(t[:x]) }") }
+    end
+
+    describe "neq" do
+      let(:expr){ f.neq(:x, 2) }
+
+      it{ should eq("->(t){ t[:x] != 2 }") }
+    end
+
+    describe "gt" do
+      let(:expr){ f.gt(:x, 2) }
+
+      it{ should eq("->(t){ t[:x] > 2 }") }
+    end
+
+    describe "gte" do
+      let(:expr){ f.gte(:x, 2) }
+
+      it{ should eq("->(t){ t[:x] >= 2 }") }
+    end
+
+    describe "lt" do
+      let(:expr){ f.lt(:x, 2) }
+
+      it{ should eq("->(t){ t[:x] < 2 }") }
+    end
+
+    describe "lte" do
+      let(:expr){ f.lte(:x, 2) }
+
+      it{ should eq("->(t){ t[:x] <= 2 }") }
+    end
+
+    describe "literal" do
+      let(:expr){ f.literal(12) }
+
+      it{ should eq("->(t){ 12 }") }
+    end
+
+    describe "native" do
+      let(:expr){ f.native(lambda{}) }
+
+      specify{
+        lambda{ subject }.should raise_error(NotSupportedError)
+      }
+    end
+
+    describe "conjunction of two eqs" do
+      let(:expr){
+        f.and(f.eq(:x, 2), f.eq(:y, 3))
+      }
+
+      it{ should eq("->(t){ (t[:x] == 2) && (t[:y] == 3) }") }
+    end
+
+    describe "conjunction of two comps" do
+      let(:expr){
+        f.and(f.comp(:eq, :x => 2), f.comp(:eq, :y => 3))
+      }
+
+      it{ should eq("->(t){ (t[:x] == 2) && (t[:y] == 3) }") }
+    end
+
+    describe "or and and" do
+      let(:expr){
+        f.and(f.eq(:x, 2), f.or(true, false))
+      }
+
+      it{ should eq("->(t){ (t[:x] == 2) && (true || false) }") }
+    end
+
+  end
+end

data/spec/factory/shared/a_comparison_factory_method.rb

@@ -0,0 +1,35 @@
+require_relative 'a_predicate_ast_node'
+shared_examples_for "a comparison factory method" do
+  include Predicate::Factory
+
+  context 'with two operands' 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]) }
+  end
+
+  context 'with a Hash operand (singleton)' do
+    subject{ self.send(method, :x => :y) }
+    let(:expected){
+      [method, [:identifier, :x], [:identifier, :y]]
+    }
+
+    it_should_behave_like "a predicate AST node"
+    it{ should eql(expected) }
+  end
+
+  context 'with a Hash operand' do
+    subject{ self.send(method, :x => :y, :v => 2) }
+    let(:expected){
+      [:and,
+        [method, [:identifier, :x], [:identifier, :y]],
+        [method, [:identifier, :v], [:literal, 2]]]
+    }
+
+    it_should_behave_like "a predicate AST node"
+    it{ should eql(expected) }
+  end
+
+end

data/spec/factory/shared/a_predicate_ast_node.rb

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

data/spec/factory/test_and.rb

@@ -0,0 +1,13 @@
+require_relative 'shared/a_predicate_ast_node'
+class Predicate
+  describe Factory, 'and' do
+    include Factory
+
+    subject{ self.and(true, true) }
+
+    it_should_behave_like "a predicate AST node"
+    it{ should be_a(And) }
+    it{ should eql([:and, tautology, tautology]) }
+
+  end
+end

data/spec/factory/test_between.rb

@@ -0,0 +1,12 @@
+require_relative "shared/a_comparison_factory_method"
+class Predicate
+  describe Factory, 'between' do
+
+    subject{ Factory.between(:x, 2, 3) }
+
+    it{ should be_a(And) }
+
+    it{ should eq([:and, [:gte, [:identifier, :x], [:literal, 2]], [:lte, [:identifier, :x], [:literal, 3]]]) }
+
+  end
+end

data/spec/factory/test_comp.rb

@@ -0,0 +1,35 @@
+require_relative 'shared/a_predicate_ast_node'
+class Predicate
+  describe Factory, 'comp' do
+
+    subject{ Factory.comp(:eq, h) }
+
+    context "when the hash is empty" do
+      let(:h){ {} }
+
+      it{ should eq(Factory.tautology) }
+    end
+
+    context "when the hash is 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 is not 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
+
+  end
+end

data/spec/factory/test_contradiction.rb

@@ -0,0 +1,11 @@
+require_relative 'shared/a_predicate_ast_node'
+class Predicate
+  describe Factory, 'contradiction' do
+    include Factory
+
+    subject{ contradiction }
+
+    it_should_behave_like "a predicate AST node"
+    it{ should be_a(Contradiction) }
+  end
+end

data/spec/factory/test_eq.rb

@@ -0,0 +1,9 @@
+require_relative "shared/a_comparison_factory_method"
+class Predicate
+  describe Factory, 'eq' do
+    let(:method){ :eq }
+    let(:node_class){ Eq }
+
+    it_should_behave_like "a comparison factory method"
+  end
+end

data/spec/factory/test_factor_predicate.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+class Predicate
+  describe Factory, "_factor_predicate" do
+
+    subject{ Factory._factor_predicate(arg) }
+
+    context "on Expr" do
+      let(:arg){ Grammar.sexpr([:literal, 12]) }
+
+      it{ should be(arg) }
+    end
+
+    context "on true" do
+      let(:arg){ true }
+
+      it{ should be_a(Tautology) }
+    end
+
+    context "on false" do
+      let(:arg){ false }
+
+      it{ should be_a(Contradiction) }
+    end
+
+    context "on Symbol" do
+      let(:arg){ :name }
+
+      it{ should be_a(Identifier) }
+    end
+
+    context "on Proc" do
+      let(:arg){ lambda{} }
+
+      it{ should be_a(Native) }
+    end
+
+    context "on Array" do
+      let(:arg){ [:identifier, :name] }
+
+      it{ should be_a(Identifier) }
+    end
+
+    context "on 12" do
+      let(:arg){ 12 }
+
+      it{ should be_a(Literal) }
+    end
+
+  end
+end

data/spec/factory/test_gt.rb

@@ -0,0 +1,9 @@
+require_relative "shared/a_comparison_factory_method"
+class Predicate
+  describe Factory, 'gt' do
+    let(:method){ :gt }
+    let(:node_class){ Gt }
+
+    it_should_behave_like "a comparison factory method"
+  end
+end

data/spec/factory/test_gte.rb

@@ -0,0 +1,9 @@
+require_relative "shared/a_comparison_factory_method"
+class Predicate
+  describe Factory, 'gte' do
+    let(:method){ :gte }
+    let(:node_class){ Gte }
+
+    it_should_behave_like "a comparison factory method"
+  end
+end

data/spec/factory/test_identifier.rb

@@ -0,0 +1,13 @@
+require_relative 'shared/a_predicate_ast_node'
+class Predicate
+  describe Factory, 'identifier' do
+    include Factory
+
+    subject{ identifier(:name) }
+
+    it_should_behave_like "a predicate AST node"
+    it{ should be_a(Identifier) }
+    it{ should eql([:identifier, :name]) }
+
+  end
+end

data/spec/factory/test_in.rb

@@ -0,0 +1,12 @@
+require_relative "shared/a_comparison_factory_method"
+class Predicate
+  describe Factory, 'in' do
+
+    subject{ Factory.in(:x, [2, 3]) }
+
+    it{ should be_a(In) }
+
+    it{ should eq([:in, [:identifier, :x], [2, 3]]) }
+
+  end
+end

data/spec/factory/test_literal.rb

@@ -0,0 +1,13 @@
+require_relative 'shared/a_predicate_ast_node'
+class Predicate
+  describe Factory, 'literal' do
+    include Factory
+
+    subject{ literal(12) }
+
+    it_should_behave_like "a predicate AST node"
+    it{ should be_a(Literal) }
+    it{ should eql([:literal, 12]) }
+
+  end
+end

data/spec/factory/test_lt.rb

@@ -0,0 +1,9 @@
+require_relative "shared/a_comparison_factory_method"
+class Predicate
+  describe Factory, 'lt' do
+    let(:method){ :lt }
+    let(:node_class){ Lt }
+
+    it_should_behave_like "a comparison factory method"
+  end
+end

data/spec/factory/test_lte.rb

@@ -0,0 +1,9 @@
+require_relative "shared/a_comparison_factory_method"
+class Predicate
+  describe Factory, 'lte' do
+    let(:method){ :lte }
+    let(:node_class){ Lte }
+
+    it_should_behave_like "a comparison factory method"
+  end
+end