veritas-optimizer 0.0.3 → 0.0.4

data/lib/veritas/optimizer/logic/connective/negation.rb

@@ -1,71 +0,0 @@
-# encoding: utf-8
-
-module Veritas
-  class Optimizer
-    module Logic
-      module Connective
-
-        # Abstract base class representing Negation optimizations
-        class Negation < Optimizer
-
-          # The optimized operand
-          #
-          # @return [Expression]
-          #
-          # @api private
-          attr_reader :operand
-
-          # Initialize a Unary optimizer
-          #
-          # @return [undefined]
-          #
-          # @api private
-          def initialize(*)
-            super
-            @operand = optimize_operand
-          end
-
-        private
-
-          # Optimize the operand
-          #
-          # @return [Expression]
-          #
-          # @api private
-          def optimize_operand
-            # TODO: move Predicate.optimize_operand to a better location
-            Predicate.optimize_operand(operation.operand)
-          end
-
-          # Optimize when the operand can be inverted
-          class InvertibleOperand < self
-
-            # Test if the operand can be inverted
-            #
-            # @return [Boolean]
-            #
-            # @api private
-            def optimizable?
-              operand.respond_to?(:inverse)
-            end
-
-            # A Negation of an Expression is equivalent to the inverted Expression
-            #
-            # @return [Expression]
-            #
-            # @api private
-            def optimize
-              operand.inverse
-            end
-
-          end # class InvertibleOperand
-
-          Veritas::Logic::Connective::Negation.optimizer = chain(
-            InvertibleOperand
-          )
-
-        end # class Negation
-      end # module Connective
-    end # module Logic
-  end # class Optimizer
-end # module Veritas

data/lib/veritas/optimizer/logic/predicate.rb

@@ -1,177 +0,0 @@
-# encoding: utf-8
-
-module Veritas
-  class Optimizer
-    module Logic
-
-      # Abstract base class representing Predicate optimizations
-      class Predicate < Optimizer
-
-        # The optimized left operand
-        #
-        # @return [Object]
-        #
-        # @api private
-        attr_reader :left
-
-        # The optimized right operand
-        #
-        # @return [Object]
-        #
-        # @api private
-        attr_reader :right
-
-        # Initialize an Predicate optimizer
-        #
-        # @return [undefined]
-        #
-        # @api private
-        def initialize(*)
-          super
-          @left  = optimize_left
-          @right = optimize_right
-        end
-
-      private
-
-        # Optimize the left operand
-        #
-        # @return [Object]
-        #
-        # @api private
-        def optimize_left
-          self.class.optimize_operand(operation.left)
-        end
-
-        # Optimize the right operand
-        #
-        # @return [Object]
-        #
-        # @api private
-        def optimize_right
-          self.class.optimize_operand(operation.right)
-        end
-
-        # Optimize the operand if possible
-        #
-        # @param [#optimize, Object] operand
-        #
-        # @return [Object]
-        #
-        # @api private
-        def self.optimize_operand(operand)
-          operand.respond_to?(:optimize) ? operand.optimize : operand
-        end
-
-        # Optimize when the operands are constants
-        class ConstantOperands < self
-
-          # Test if the operands are constants
-          #
-          # @return [Boolean]
-          #
-          # @api private
-          def optimizable?
-            util = Util
-            util.constant?(left) && util.constant?(right)
-          end
-
-          # A Predicate with constant values is equivalent to a Proposition
-          #
-          # @return [Proposition]
-          #
-          # @api private
-          def optimize
-            Veritas::Logic::Proposition.new(operation.class.call(left, right))
-          end
-
-        end # class ConstantOperands
-
-        # Optimize when the operands are a contradiction
-        module Contradiction
-
-          # Return a contradiction
-          #
-          # @return [Contradiction]
-          #
-          # @api private
-          def optimize
-            Veritas::Logic::Proposition::Contradiction.instance
-          end
-
-        end # module Contradiction
-
-        # Optimize when the operands are a tautology
-        module Tautology
-
-          # Return a tautology
-          #
-          # @return [Tautology]
-          #
-          # @api private
-          def optimize
-            Veritas::Logic::Proposition::Tautology.instance
-          end
-
-        end # module Tautology
-
-        # Utility methods for Predicate optimization
-        module Util
-
-          # Test if the operand is a constant
-          #
-          # @return [Boolean]
-          #
-          # @api private
-          def self.constant?(operand)
-            !operand.respond_to?(:call)
-          end
-
-          # Test if the operand is an attribute
-          #
-          # @return [Boolean]
-          #
-          # @api private
-          def self.attribute?(operand)
-            operand.kind_of?(Attribute)
-          end
-
-          # Return the minimum value for the operand
-          #
-          # @return [Object]
-          #
-          # @api private
-          def self.min(operand)
-            range_or_operand(operand, :first)
-          end
-
-          # Return the maximum value for the operand
-          #
-          # @return [Object]
-          #
-          # @api private
-          def self.max(operand)
-            range_or_operand(operand, :last)
-          end
-
-          # Return the minimum/maximum of the operand range, or the operand
-          #
-          # @param [Object] operand
-          #   the object to extract the minimum/maximum value from
-          # @param [Symbol] method
-          #   the method to execute on the operand range, if any
-          #
-          # @return [Object]
-          #
-          # @api private
-          def self.range_or_operand(operand, method)
-            operand.respond_to?(:range) ? operand.range.send(method) : operand
-          end
-
-          private_class_method :range_or_operand
-
-        end # module Util
-      end # class Predicate
-    end # module Logic
-  end # class Optimizer
-end # module Veritas

data/spec/unit/veritas/optimizer/algebra/projection/header_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-describe Optimizer::Algebra::Projection, '#header' do
-  subject { object.header }
-
-  let(:header)   { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ]) }
-  let(:operand)  { Relation.new(header, [ [ 1, 'Dan Kubb' ] ])                   }
-  let(:relation) { operand.project([ :id ])                                      }
-  let(:object)   { described_class.new(relation)                                 }
-
-  before do
-    object.operation.should be_kind_of(Algebra::Projection)
-  end
-
-  it { should equal(relation.header) }
-end

data/spec/unit/veritas/optimizer/algebra/projection/unchanged_header/optimizable_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe Optimizer::Algebra::Projection::UnchangedHeader, '#optimizable?' do
-  subject { object.optimizable? }
-
-  let(:header)   { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ]) }
-  let(:base)     { Relation.new(header, [ [ 1, 'Dan Kubb' ] ].each)              }
-  let(:relation) { base.project(new_header)                                      }
-  let(:object)   { described_class.new(relation)                                 }
-
-  before do
-    object.operation.should be_kind_of(Algebra::Projection)
-  end
-
-  context 'when the header is not changed' do
-    let(:new_header) { header }
-
-    it { should be(true) }
-  end
-
-  context 'when the header is changed' do
-    let(:new_header) { [ :id ] }
-
-    it { should be(false) }
-  end
-end

data/spec/unit/veritas/optimizer/algebra/projection/unchanged_header/optimize_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-describe Optimizer::Algebra::Projection::UnchangedHeader, '#optimize' do
-  subject { object.optimize }
-
-  let(:header)   { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ]) }
-  let(:base)     { Relation.new(header, [ [ 1, 'Dan Kubb' ] ].each)              }
-  let(:relation) { base.project(header)                                          }
-  let(:object)   { described_class.new(relation)                                 }
-
-  before do
-    object.should be_optimizable
-  end
-
-  it { should equal(base) }
-end

data/spec/unit/veritas/optimizer/algebra/rename/class_methods/union_aliases_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe Optimizer::Algebra::Rename, '.union_aliases' do
-  subject { object.union_aliases(aliases, operand) }
-
-  let(:attribute) { Attribute::Integer.new(:id)                }
-  let(:header)    { Relation::Header.new([ [ :id, Integer ] ]) }
-  let(:base)      { Relation.new(header, [ [ 1 ] ].each)       }
-  let(:aliases)   { relation.aliases                           }
-  let(:object)    { Optimizer::Algebra::Rename                 }
-
-  context 'when the operand is a rename' do
-    let(:operand)  { base.rename(:id => :other_id)            }
-    let(:relation) { operand.rename(:other_id => :another_id) }
-
-    it { should be_kind_of(Algebra::Rename::Aliases) }
-
-    it { should == { attribute => attribute.rename(:another_id) } }
-  end
-
-  context 'when the operand is not a rename' do
-    let(:operand)  { base                             }
-    let(:relation) { operand.rename(:id => :other_id) }
-
-    it { should equal(aliases) }
-  end
-end

data/spec/unit/veritas/optimizer/algebra/rename/header_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe Optimizer::Algebra::Rename, '#header' do
-  subject { object.header }
-
-  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
-  let(:base)     { Relation.new(header, [ [ 1 ] ].each)       }
-  let(:aliases)  { { :id => :other_id }                       }
-  let(:relation) { base.rename(aliases)                       }
-  let(:object)   { described_class.new(relation)              }
-
-  before do
-    object.operation.should be_kind_of(Algebra::Rename)
-  end
-
-  it { should be_kind_of(Relation::Header) }
-
-  it { should == [ [ :other_id, Integer ] ] }
-end

data/spec/unit/veritas/optimizer/algebra/rename/unchanged_header/optimizable_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe Optimizer::Algebra::Rename::UnchangedHeader, '#optimizable?' do
-  subject { object.optimizable? }
-
-  let(:header)   { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ]) }
-  let(:base)     { Relation.new(header, [ [ 1, 'Dan Kubb' ] ].each)              }
-  let(:relation) { base.rename(new_aliases)                                      }
-  let(:object)   { described_class.new(relation)                                 }
-
-  before do
-    object.operation.should be_kind_of(Algebra::Rename)
-  end
-
-  context 'when the header is not changed' do
-    let(:new_aliases) { {} }
-
-    it { should be(true) }
-  end
-
-  context 'when the header is changed' do
-    let(:new_aliases) { { :id => :other_id } }
-
-    it { should be(false) }
-  end
-end

data/spec/unit/veritas/optimizer/algebra/rename/unchanged_header/optimize_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-describe Optimizer::Algebra::Rename::UnchangedHeader, '#optimize' do
-  subject { object.optimize }
-
-  let(:header)   { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ]) }
-  let(:base)     { Relation.new(header, [ [ 1, 'Dan Kubb' ] ].each)              }
-  let(:relation) { base.rename({})                                               }
-  let(:object)   { described_class.new(relation)                                 }
-
-  before do
-    object.should be_optimizable
-  end
-
-  it { should equal(base) }
-end

data/spec/unit/veritas/optimizer/algebra/restriction/class_methods/optimize_predicate_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe Optimizer::Algebra::Restriction, '.optimize_predicate' do
-  subject { object.optimize_predicate(predicate) }
-
-  let(:attribute) { Attribute::Integer.new(:id)     }
-  let(:predicate) { attribute.eq(1)                 }
-  let(:object)    { Optimizer::Algebra::Restriction }
-
-  context 'when the predicate is optimizable' do
-    let(:predicate) { Logic::Connective::Negation.new(attribute.eq(1)) }
-
-    it { should be_kind_of(Logic::Predicate::Inequality) }
-
-    its(:left) { should equal(attribute) }
-
-    its(:right) { should == 1 }
-  end
-
-  context 'when the predicate is optimizable, but already optimized' do
-    let(:predicate) { attribute.eq(1) }
-
-    it { should equal(predicate) }
-  end
-
-  context 'when the predicate is not optimizable' do
-    let(:predicate) { lambda { |tuple| tuple[:id] == 1 } }
-
-    it { should equal(predicate) }
-  end
-end

data/spec/unit/veritas/optimizer/algebra/restriction/reverse_operand/optimizable_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe Optimizer::Algebra::Restriction::ReverseOperand, '#optimizable?' do
-  subject { object.optimizable? }
-
-  let(:base)      { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
-  let(:predicate) { base[:id].eq(1)                                          }
-  let(:relation)  { operand.restrict(predicate)                              }
-  let(:object)    { described_class.new(relation)                            }
-
-  before do
-    object.operation.should be_kind_of(Algebra::Restriction)
-  end
-
-  context 'when the operand is a reverse operation' do
-    let(:operand) { base.take(2).reverse }
-
-    it { should be(true) }
-  end
-
-  context 'when the operand is not a reverse operation' do
-    let(:operand) { base }
-
-    it { should be(false) }
-  end
-end

data/spec/unit/veritas/optimizer/algebra/restriction/reverse_operand/optimize_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe Optimizer::Algebra::Restriction::ReverseOperand, '#optimize' do
-  subject { object.optimize }
-
-  let(:order)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ].each).order }
-  let(:predicate) { order[:id].eq(1)                                         }
-  let(:relation)  { order.take(2).reverse.restrict(predicate)                }
-  let(:object)    { described_class.new(relation)                            }
-
-  before do
-    object.should be_optimizable
-  end
-
-  it { should be_kind_of(Relation::Operation::Reverse) }
-
-  its(:operand) { should eql(order.take(2).restrict(predicate)) }
-end

data/spec/unit/veritas/optimizer/logic/connective/binary/unoptimized_operand/optimizable_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe Optimizer::Logic::Connective::Binary::UnoptimizedOperand, '#optimizable?' do
-  subject { object.optimizable? }
-
-  let(:attribute)  { Attribute::Integer.new(:id)     }
-  let(:connective) { left.and(right)                 }
-  let(:object)     { described_class.new(connective) }
-
-  before do
-    object.operation.should be_kind_of(Logic::Connective::Binary)
-  end
-
-  context 'when left is optimizable' do
-    let(:left)  { attribute.include([ 1 ]) }
-    let(:right) { attribute.ne(2)          }
-
-    it { should be(true) }
-  end
-
-  context 'when right is optimizable' do
-    let(:left)  { attribute.eq(1)          }
-    let(:right) { attribute.exclude([ 2 ]) }
-
-    it { should be(true) }
-  end
-
-  context 'when left and right are not optimizable' do
-    let(:left)  { attribute.eq(1) }
-    let(:right) { attribute.ne(2) }
-
-    it { should be(false) }
-  end
-end

data/spec/unit/veritas/optimizer/logic/connective/binary/unoptimized_operand/optimize_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-describe Optimizer::Logic::Connective::Binary::UnoptimizedOperand, '#optimize' do
-  subject { object.optimize }
-
-  let(:attribute)  { Attribute::Integer.new(:id)     }
-  let(:left)       { attribute.include([ 1 ])        }
-  let(:right)      { attribute.exclude([ 2 ])        }
-  let(:connective) { left.and(right)                 }
-  let(:object)     { described_class.new(connective) }
-
-  before do
-    object.should be_optimizable
-  end
-
-  it { should be_kind_of(Logic::Connective::Conjunction) }
-
-  its(:left) { should eql(attribute.eq(1)) }
-
-  its(:right) { should eql(attribute.ne(2)) }
-end

data/spec/unit/veritas/optimizer/logic/connective/conjunction/contradiction/optimizable_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-describe Optimizer::Logic::Connective::Conjunction::Contradiction, '#optimizable?' do
-  subject { object.optimizable? }
-
-  let(:attribute)  { Attribute::Integer.new(:id)                     }
-  let(:connective) { Logic::Connective::Conjunction.new(left, right) }
-  let(:object)     { described_class.new(connective)                 }
-
-  before do
-    object.operation.should be_kind_of(Logic::Connective::Conjunction)
-  end
-
-  context 'when left is a contradiction' do
-    let(:left)  { Logic::Proposition::Contradiction.instance }
-    let(:right) { attribute.eq(1)                            }
-
-    it { should be(true) }
-  end
-
-  context 'when right is a contradiction' do
-    let(:left)  { attribute.eq(1)                            }
-    let(:right) { Logic::Proposition::Contradiction.instance }
-
-    it { should be(true) }
-  end
-
-  context 'when left and right are equality predicates with the same attribute and constant values' do
-    let(:left)  { attribute.eq(1) }
-    let(:right) { attribute.eq(2) }
-
-    it { should be(true) }
-  end
-
-  context 'when left and right are inverses' do
-    let(:left)  { attribute.eq(1) }
-    let(:right) { attribute.ne(1) }
-
-    it { should be(true) }
-  end
-end

data/spec/unit/veritas/optimizer/logic/connective/conjunction/contradiction/optimize_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe Optimizer::Logic::Connective::Conjunction::Contradiction, '#optimize' do
-  subject { object.optimize }
-
-  let(:attribute)  { Attribute::Integer.new(:id)                     }
-  let(:left)       { Logic::Proposition::Contradiction.instance      }
-  let(:right)      { Logic::Proposition::Contradiction.instance      }
-  let(:connective) { Logic::Connective::Conjunction.new(left, right) }
-  let(:object)     { described_class.new(connective)                 }
-
-  before do
-    object.should be_optimizable
-  end
-
-  it { should equal(Logic::Proposition::Contradiction.instance) }
-end

data/spec/unit/veritas/optimizer/logic/connective/conjunction/right_operand_tautology/optimize_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe Optimizer::Logic::Connective::Conjunction::RightOperandTautology, '#optimize' do
-  subject { object.optimize }
-
-  let(:attribute)  { Attribute::Integer.new(:id)            }
-  let(:left)       { attribute.eq(1)                        }
-  let(:right)      { Logic::Proposition::Tautology.instance }
-  let(:connective) { left.and(right)                        }
-  let(:object)     { described_class.new(connective)        }
-
-  before do
-    object.should be_optimizable
-  end
-
-  it { should equal(left) }
-end

data/spec/unit/veritas/optimizer/logic/connective/disjunction/tautology/optimizable_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-describe Optimizer::Logic::Connective::Disjunction::Tautology, '#optimizable?' do
-  subject { object.optimizable? }
-
-  let(:attribute)  { Attribute::Integer.new(:id)                     }
-  let(:connective) { Logic::Connective::Disjunction.new(left, right) }
-  let(:object)     { described_class.new(connective)                 }
-
-  before do
-    object.operation.should be_kind_of(Logic::Connective::Disjunction)
-  end
-
-  context 'when left is a tautology' do
-    let(:left)  { Logic::Proposition::Tautology.instance }
-    let(:right) { attribute.eq(1)                        }
-
-    it { should be(true) }
-  end
-
-  context 'when right is a tautology' do
-    let(:left)  { attribute.eq(1)                        }
-    let(:right) { Logic::Proposition::Tautology.instance }
-
-    it { should be(true) }
-  end
-
-  context 'when left and right are inequality predicates with the same attribute and constant values' do
-    let(:left)  { attribute.ne(1) }
-    let(:right) { attribute.ne(2) }
-
-    it { should be(true) }
-  end
-
-  context 'when left and right are inverses' do
-    let(:left)  { attribute.eq(1) }
-    let(:right) { attribute.ne(1) }
-
-    it { should be(true) }
-  end
-end

data/spec/unit/veritas/optimizer/logic/connective/disjunction/tautology/optimize_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe Optimizer::Logic::Connective::Disjunction::Tautology, '#optimize' do
-  subject { object.optimize }
-
-  let(:attribute)  { Attribute::Integer.new(:id)                     }
-  let(:left)       { Logic::Proposition::Tautology.instance          }
-  let(:right)      { Logic::Proposition::Tautology.instance          }
-  let(:connective) { Logic::Connective::Disjunction.new(left, right) }
-  let(:object)     { described_class.new(connective)                 }
-
-  before do
-    object.should be_optimizable
-  end
-
-  it { should equal(Logic::Proposition::Tautology.instance) }
-end