veritas 0.0.1

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

@@ -0,0 +1,132 @@
+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,139 @@
+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,42 @@
+module Veritas
+  class Optimizer
+    module Logic
+      class Predicate
+
+        # Abstract base class representing Equality optimizations
+        class Equality < self
+          include Comparable
+
+          # Optimize when the operand are always false
+          class AlwaysFalse < self
+            include Comparable::NeverEquivalent
+            include Predicate::AlwaysFalse
+          end # class AlwaysFalse
+
+          # Optimize when the operand are always true
+          class AlwaysTrue < self
+            include Predicate::AlwaysTrue
+
+            # Test if the operands are always true
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left.equal?(right)
+            end
+
+          end # class AlwaysTrue
+
+          Veritas::Logic::Predicate::Equality.optimizer = chain(
+            ConstantOperands,
+            AlwaysFalse,
+            AlwaysTrue,
+            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,51 @@
+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 [True]
+            #
+            # @api private
+            def optimize
+              Veritas::Logic::Proposition::True.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

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

@@ -0,0 +1,52 @@
+module Veritas
+  class Optimizer
+    module Logic
+      class Predicate
+
+        # Abstract base class representing GreaterThan optimizations
+        class GreaterThan < self
+          include Comparable
+
+          # Optimize when the operands are always false
+          class AlwaysFalse < self
+            include Predicate::AlwaysFalse
+
+            # Test if the operands are always false
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left.equal?(right) ||
+              GreaterThanOrEqualTo::AlwaysFalse.new(operation).optimizable?
+            end
+
+          end # class AlwaysFalse
+
+          # Optimize when the operands are always true
+          class AlwaysTrue < self
+            include Predicate::AlwaysTrue
+
+            # Test if the operands are always true
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operation.class.call(Predicate::Util.min(left), Predicate::Util.max(right))
+            end
+
+          end # class AlwaysTrue
+
+          Veritas::Logic::Predicate::GreaterThan.optimizer = chain(
+            ConstantOperands,
+            AlwaysFalse,
+            AlwaysTrue,
+            NormalizableOperands
+          )
+
+        end # class GreaterThan
+      end # class Predicate
+    end # module Logic
+  end # class Optimizer
+end # module Veritas

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

@@ -0,0 +1,54 @@
+module Veritas
+  class Optimizer
+    module Logic
+      class Predicate
+
+        # Abstract base class representing GreaterThanOrEqualTo optimizations
+        class GreaterThanOrEqualTo < self
+          include Comparable
+
+          # Optimize when the operands are always false
+          class AlwaysFalse < self
+            include Comparable::NeverComparable
+            include Predicate::AlwaysFalse
+
+            # Test if the operands are always false
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              super || LessThan::AlwaysTrue.new(operation.inverse).optimizable?
+            end
+
+          end # class AlwaysFalse
+
+          # Optimize when the operands are always true
+          class AlwaysTrue < self
+            include Predicate::AlwaysTrue
+
+            # Test if the operands are always true
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operation = self.operation
+              GreaterThan::AlwaysTrue.new(operation).optimizable? ||
+              Equality::AlwaysTrue.new(operation).optimizable?
+            end
+
+          end # class AlwaysTrue
+
+          Veritas::Logic::Predicate::GreaterThanOrEqualTo.optimizer = chain(
+            ConstantOperands,
+            AlwaysFalse,
+            AlwaysTrue,
+            NormalizableOperands
+          )
+
+        end # class GreaterThanOrEqualTo
+      end # class Predicate
+    end # module Logic
+  end # class Optimizer
+end # module Veritas

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

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

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

@@ -0,0 +1,42 @@
+module Veritas
+  class Optimizer
+    module Logic
+      class Predicate
+
+        # Abstract base class representing Inequality optimizations
+        class Inequality < self
+          include Comparable
+
+          # Optimize when the operand are always false
+          class AlwaysFalse < self
+            include Predicate::AlwaysFalse
+
+            # Test if the operands are always false
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left.equal?(right)
+            end
+
+          end # class AlwaysFalse
+
+          # Optimize when the operand are always true
+          class AlwaysTrue < self
+            include Comparable::NeverEquivalent
+            include Predicate::AlwaysTrue
+          end # class AlwaysTrue
+
+          Veritas::Logic::Predicate::Inequality.optimizer = chain(
+            ConstantOperands,
+            AlwaysFalse,
+            AlwaysTrue,
+            NormalizableOperands
+          )
+
+        end # class Inequality
+      end # class Predicate
+    end # module Logic
+  end # class Optimizer
+end # module Veritas

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

@@ -0,0 +1,52 @@
+module Veritas
+  class Optimizer
+    module Logic
+      class Predicate
+
+        # Abstract base class representing LessThan optimizations
+        class LessThan < self
+          include Comparable
+
+          # Optimize when the operands are always false
+          class AlwaysFalse < self
+            include Predicate::AlwaysFalse
+
+            # Test if the operands are always false
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              left.equal?(right) ||
+              LessThanOrEqualTo::AlwaysFalse.new(operation).optimizable?
+            end
+
+          end # class AlwaysFalse
+
+          # Optimize when the operands are always true
+          class AlwaysTrue < self
+            include Predicate::AlwaysTrue
+
+            # Test if the operands are always true
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operation.class.call(Predicate::Util.max(left), Predicate::Util.min(right))
+            end
+
+          end # class AlwaysTrue
+
+          Veritas::Logic::Predicate::LessThan.optimizer = chain(
+            ConstantOperands,
+            AlwaysFalse,
+            AlwaysTrue,
+            NormalizableOperands
+          )
+
+        end # class LessThan
+      end # class Predicate
+    end # module Logic
+  end # class Optimizer
+end # module Veritas

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

@@ -0,0 +1,54 @@
+module Veritas
+  class Optimizer
+    module Logic
+      class Predicate
+
+        # Abstract base class representing LessThanOrEqualTo optimizations
+        class LessThanOrEqualTo < self
+          include Comparable
+
+          # Optimize when the operands are always false
+          class AlwaysFalse < self
+            include Comparable::NeverComparable
+            include Predicate::AlwaysFalse
+
+            # Test if the operands are always false
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              super || GreaterThan::AlwaysTrue.new(operation.inverse).optimizable?
+            end
+
+          end # class AlwaysFalse
+
+          # Optimize when the operands are always true
+          class AlwaysTrue < self
+            include Predicate::AlwaysTrue
+
+            # Test if the operands are always true
+            #
+            # @return [Boolean]
+            #
+            # @api private
+            def optimizable?
+              operation = self.operation
+              LessThan::AlwaysTrue.new(operation).optimizable? ||
+              Equality::AlwaysTrue.new(operation).optimizable?
+            end
+
+          end # class AlwaysTrue
+
+          Veritas::Logic::Predicate::LessThanOrEqualTo.optimizer = chain(
+            ConstantOperands,
+            AlwaysFalse,
+            AlwaysTrue,
+            NormalizableOperands
+          )
+
+        end # class LessThanOrEqualTo
+      end # class Predicate
+    end # module Logic
+  end # class Optimizer
+end # module Veritas

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

@@ -0,0 +1,17 @@
+module Veritas
+  class Optimizer
+    module Logic
+      class Predicate
+
+        # Abstract base class representing Match optimizations
+        class Match < self
+
+          Veritas::Logic::Predicate::Match.optimizer = chain(
+            ConstantOperands
+          )
+
+        end # class Match
+      end # class Predicate
+    end # module Logic
+  end # class Optimizer
+end # module Veritas