veritas-optimizer 0.0.3

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

@@ -0,0 +1,122 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Logic
+      module Connective
+
+        # Abstract base class representing Conjunction optimizations
+        class Conjunction < Binary
+
+          # Optimize when the left operand is a tautology
+          class LeftOperandTautology < self
+
+            # Test if the left operand is a tautology
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left_tautology?
+            end
+
+            # A Conjunction with a tautology left operand is equivalent to the right
+            #
+            # @return [Expression]
+            #
+            # @api private
+            def optimize
+              right
+            end
+
+          end # class LeftOperandTautology
+
+          # Optimize when the right operand is a tautology
+          class RightOperandTautology < self
+
+            # Test if the right operand is a tautology
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              right_tautology?
+            end
+
+            # A Conjunction with a tautology right operand is equivalent to the left
+            #
+            # @return [Expression]
+            #
+            # @api private
+            def optimize
+              left
+            end
+
+          end # class RightOperandTautology
+
+          # Optimize when the operands are inequality predicates for the same attribute
+          class OptimizableToExclusion < self
+
+            # Test if the operands are inequality predicates for the same attribute
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              inequality_with_same_attributes?
+            end
+
+            # Return an Exclusion for an attribute against a set of values
+            #
+            # @return [Exclusion]
+            #
+            # @api private
+            def optimize
+              left = self.left
+              Veritas::Logic::Predicate::Exclusion.new(left.left, [ left.right, right.right ]).optimize
+            end
+
+          end # class OptimizableToExclusion
+
+          # Optimize when the operands are a contradiction
+          class Contradiction < self
+
+            # Test if the operands are a contradiction
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left_contradiction?                    ||
+              right_contradiction?                   ||
+              equality_with_same_attributes? ||
+              left.inverse.eql?(right)
+            end
+
+            # Return a contradiction
+            #
+            # @return [Contradiction]
+            #
+            # @api private
+            def optimize
+              Veritas::Logic::Proposition::Contradiction.instance
+            end
+
+          end # class Contradiction
+
+          Veritas::Logic::Connective::Conjunction.optimizer = chain(
+            LeftOperandTautology,
+            RightOperandTautology,
+            OptimizableToExclusion,
+            EqualOperands,
+            RedundantLeftOperand,
+            RedundantRightOperand,
+            Contradiction,
+            UnoptimizedOperand
+          )
+
+        end # class Conjunction
+      end # module Connective
+    end # module Logic
+  end # class Optimizer
+end # module Veritas

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

@@ -0,0 +1,122 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Logic
+      module Connective
+
+        # Abstract base class representing Disjunction optimizations
+        class Disjunction < Binary
+
+          # Optimize when the left operand is a contradiction
+          class ContradictionLeftOperand < self
+
+            # Test if the left operand is a contradiction
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left_contradiction?
+            end
+
+            # A Disjunction with a contradiction left operand is equivalent to the right
+            #
+            # @return [Expression]
+            #
+            # @api private
+            def optimize
+              right
+            end
+
+          end # class ContradictionLeftOperand
+
+          # Optimize when the right operand is a contradiction
+          class ContradictionRightOperand < self
+
+            # Test if the right operand is a contradiction
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              right_contradiction?
+            end
+
+            # A Disjunction with a contradiction right operand is equivalent to the left
+            #
+            # @return [Expression]
+            #
+            # @api private
+            def optimize
+              left
+            end
+
+          end # class ContradictionRightOperand
+
+          # Optimize when the operands are equality predicates for the same attribute
+          class OptimizableToInclusion < self
+
+            # Test if the operands are equality predicates for the same attribute
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              equality_with_same_attributes?
+            end
+
+            # Return an Inclusion for an attribute having a set of values
+            #
+            # @return [Inclusion]
+            #
+            # @api private
+            def optimize
+              left = self.left
+              Veritas::Logic::Predicate::Inclusion.new(left.left, [ left.right, right.right ]).optimize
+            end
+
+          end # class OptimizableToInclusion
+
+          # Optimize when the operands are a tuatology
+          class Tautology < self
+
+            # Test if the operands are a tuatology
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left_tautology?                       ||
+              right_tautology?                      ||
+              inequality_with_same_attributes? ||
+              left.inverse.eql?(right)
+            end
+
+            # Return a tuatology
+            #
+            # @return [Tautology]
+            #
+            # @api private
+            def optimize
+              Veritas::Logic::Proposition::Tautology.instance
+            end
+
+          end # class Tautology
+
+          Veritas::Logic::Connective::Disjunction.optimizer = chain(
+            ContradictionLeftOperand,
+            ContradictionRightOperand,
+            OptimizableToInclusion,
+            EqualOperands,
+            RedundantLeftOperand,
+            RedundantRightOperand,
+            Tautology,
+            UnoptimizedOperand
+          )
+
+        end # class Disjunction
+      end # module Connective
+    end # module Logic
+  end # class Optimizer
+end # module Veritas

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

@@ -0,0 +1,71 @@
+# 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/comparable.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Logic
+      class Predicate
+
+        # Abstract base class representing Comparable predicate optimizations
+        module Comparable
+
+          # Optimize when the operands can be normalized
+          class NormalizableOperands < Predicate
+
+            # Test if the operands can be normalized
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              util = Util
+              util.constant?(left) && util.attribute?(right)
+            end
+
+            # Normalize the predicate by reversing the operands
+            #
+            # @return [Predicate]
+            #
+            # @api private
+            def optimize
+              operation.class.reverse.new(right, left)
+            end
+
+          end # class NormalizableOperands
+
+          # Optimize when the operands will never be equivalent
+          module NeverEquivalent
+
+            # Test if the operands will never be equivalent
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              util = Util
+              if    util.constant?(left)  then left_invalid_constant?
+              elsif util.constant?(right) then right_invalid_constant?
+              else
+                not_joinable?
+              end
+            end
+
+          private
+
+            # Test if the left operand is an invalid constant
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def left_invalid_constant?
+              !right.valid_value?(left)
+            end
+
+            # Test if the right operand is an invalid constant
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def right_invalid_constant?
+              !left.valid_value?(right)
+            end
+
+            # Test if the left and right operand are not joinable
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def not_joinable?
+              !left.joinable?(right)
+            end
+
+          end # module NeverEquivalent
+
+          # Optimize when the operands will never be comparable
+          module NeverComparable
+
+            # Test if the operands will never be comparable
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              util = Util
+              if    util.constant?(left)  then left_invalid_constant?
+              elsif util.constant?(right) then right_invalid_constant?
+              else
+                not_comparable?
+              end
+            end
+
+          private
+
+            # Test if the left operand is an invalid constant
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def left_invalid_constant?
+              !right.valid_primitive?(left)
+            end
+
+            # Test if the right operand is an invalid constant
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def right_invalid_constant?
+              !left.valid_primitive?(right)
+            end
+
+            # Test if the left and right operand are not comparable
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def not_comparable?
+              !left.comparable?(right)
+            end
+
+          end # module NeverComparable
+        end # module Comparable
+      end # class Predicate
+    end # module Logic
+  end # class Optimizer
+end # module Veritas

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

@@ -0,0 +1,141 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Logic
+      class Predicate
+
+        # Abstract base class representing Enumerable predicate optimizations
+        module Enumerable
+
+        private
+
+          # Optimize the right operand
+          #
+          # @return [Object]
+          #
+          # @api private
+          def optimize_right
+            right = operation.right
+
+            if right.respond_to?(:to_inclusive)
+              optimize_right_range
+            elsif right.respond_to?(:select)
+              optimize_right_enumerable
+            else
+              right
+            end
+          end
+
+          # Optimize the right range operand
+          #
+          # @return [Range]
+          #
+          # @api private
+          def optimize_right_range
+            right = operation.right
+            right.to_inclusive if right.overlaps?(left.range)
+          end
+
+          # Optimize the right enumerable operand
+          #
+          # @return [Enumerable]
+          #
+          # @api private
+          def optimize_right_enumerable
+            enumerable = normalized_right_enumerable
+            right      = operation.right
+
+            right.eql?(enumerable) ? right : enumerable
+          end
+
+          # Normalize the right enumerable to only include unique, sorted, valid values
+          #
+          # @return [Enumerable]
+          #
+          # @api private
+          def normalized_right_enumerable
+            enumerable = operation.right.select { |value| left.valid_value?(value) }
+            enumerable.sort!
+            enumerable.uniq!
+            enumerable
+          end
+
+          # Optimize when the right operand is empty
+          module EmptyRightOperand
+            include Enumerable
+
+            # Test if the right operand is empty
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              right_nil? || right_none?
+            end
+
+          private
+
+            # Test if the right operand is nil
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def right_nil?
+              right.nil?
+            end
+
+            # Test if the right operand has no entries
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def right_none?
+              right.none? { true }
+            end
+
+          end # module EmptyRightOperand
+
+          # Optimize when the right operand has one entry
+          module OneRightOperand
+            include Enumerable
+
+            # Test if the right operand has one entry
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              right.one? { true }
+            end
+
+          end # module OneRightOperand
+
+          # Optimize when the operands are unoptimized
+          class UnoptimizedOperand < Predicate
+            include Enumerable
+
+            # Test if the operands are unoptimized
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              !right.equal?(operation.right)
+            end
+
+            # Return a Enumerable predicate with optimized operands
+            #
+            # @return [Binary]
+            #
+            # @api private
+            def optimize
+              operation.class.new(left, right)
+            end
+
+          end # class UnoptimizedOperand
+        end # module Enumerable
+      end # class Predicate
+    end # module Logic
+  end # class Optimizer
+end # module Veritas

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

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Logic
+      class Predicate
+
+        # Abstract base class representing Equality optimizations
+        class Equality < self
+          include Comparable
+
+          # Optimize when the operand are a contradiction
+          class Contradiction < self
+            include Comparable::NeverEquivalent
+            include Predicate::Contradiction
+          end # class Contradiction
+
+          # Optimize when the operand are a tautology
+          class Tautology < self
+            include Predicate::Tautology
+
+            # Test if the operands are a tautology
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left.equal?(right)
+            end
+
+          end # class Tautology
+
+          Veritas::Logic::Predicate::Equality.optimizer = chain(
+            ConstantOperands,
+            Contradiction,
+            Tautology,
+            NormalizableOperands
+          )
+
+        end # class Equality
+      end # class Predicate
+    end # module Logic
+  end # class Optimizer
+end # module Veritas

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

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module Veritas
+  class Optimizer
+    module Logic
+      class Predicate
+
+        # Abstract base class representing Exclusion optimizations
+        class Exclusion < self
+          include Enumerable
+
+          # Optimize when the right operand is empty
+          class EmptyRightOperand < self
+            include Enumerable::EmptyRightOperand
+
+            # An Exclusion with an empty right operand matches everything
+            #
+            # @return [Tautology]
+            #
+            # @api private
+            def optimize
+              Veritas::Logic::Proposition::Tautology.instance
+            end
+
+          end # class EmptyRightOperand
+
+          # Optimize when the right operand has one entry
+          class OneRightOperand < self
+            include Enumerable::OneRightOperand
+
+            # An Exclusion with a single right operand is equivalent to an Inequality
+            #
+            # @return [Inequality]
+            #
+            # @api private
+            def optimize
+              Veritas::Logic::Predicate::Inequality.new(left, right.first)
+            end
+
+          end # class OneRightOperand
+
+          Veritas::Logic::Predicate::Exclusion.optimizer = chain(
+            ConstantOperands,
+            EmptyRightOperand,
+            OneRightOperand,
+            UnoptimizedOperand
+          )
+
+        end # class Exclusion
+      end # class Predicate
+    end # module Logic
+  end # class Optimizer
+end # module Veritas