veritas 0.0.1

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

@@ -0,0 +1,78 @@
+module Veritas
+  module Logic
+    class Connective
+
+      # A logical negation of an expression
+      class Negation < Unary
+
+        # Evaluate the operands using a logical NOT
+        #
+        # @example with true operand
+        #   Negation.call(true)  # => false
+        #
+        # @example with false operand
+        #   Negation.call(false)  # => true
+        #
+        # @param [Boolean] operand
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def self.call(operand)
+          !operand
+        end
+
+        # Return the operand
+        #
+        # @example
+        #   operand = negation.inverse
+        #
+        # @return [Expression]
+        #
+        # @api public
+        def inverse
+          operand
+        end
+
+        # Return a string representing the negation
+        #
+        # @example
+        #   negation.inspect  # not(<Expression>)
+        #
+        # @return [String]
+        #
+        # @api public
+        def inspect
+          "not(#{operand.inspect})"
+        end
+
+        module Methods
+          extend Aliasable
+
+          # alias #! to #inverse when available
+          inheritable_alias('!' => :inverse) if Object.method_defined?('!')
+
+          inheritable_alias(:- => :not)
+
+          # Logically negate then AND the expression
+          #
+          # @example
+          #   conjunction = expression.not(other)
+          #
+          # @param [Expression] other
+          #
+          # @return [Conjunction]
+          #
+          # @api public
+          def not(other)
+            self.and(Negation.new(other))
+          end
+
+        end # module Methods
+
+        Expression.class_eval { include Methods }
+
+      end # class Negation
+    end # class Connective
+  end # module Logic
+end # module Veritas

data/lib/veritas/logic/connective/unary.rb

@@ -0,0 +1,52 @@
+module Veritas
+  module Logic
+    class Connective
+
+      # Abstract base class for unary connectives
+      class Unary < Connective
+        include AbstractClass, Operation::Unary
+
+        # Evaluate the unary connective using the tuple
+        #
+        # @example
+        #   unary.call(tuple)  # => true or false
+        #
+        # @param [Tuple] tuple
+        #   the tuple to pass to operand#call
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def call(tuple)
+          self.class.call(operand.call(tuple))
+        end
+
+        # Rename the contained attributes with the provided aliases
+        #
+        # @example
+        #   renamed = unary.rename(aliases)
+        #
+        # @param [Algebra::Rename::Aliases] aliases
+        #   the old and new attributes
+        #
+        # @return [self]
+        #   if the operand is not renamed
+        # @return [Unary]
+        #   if the operand is renamed
+        #
+        # @api public
+        def rename(aliases)
+          operand         = self.operand
+          renamed_operand = operand.rename(aliases)
+
+          if operand.equal?(renamed_operand)
+            self
+          else
+            self.class.new(renamed_operand)
+          end
+        end
+
+      end # class Unary
+    end # class Connective
+  end # module Logic
+end # module Veritas

data/lib/veritas/logic/connective.rb

@@ -0,0 +1,31 @@
+module Veritas
+  module Logic
+
+    # Abstract base class for logical connectives
+    class Connective < Expression
+      include AbstractClass
+
+      # Return the inverse connective
+      #
+      # @example
+      #   negation = connective.inverse
+      #
+      # @return [Negation]
+      #
+      # @api public
+      def inverse
+        Negation.new(self)
+      end
+
+      memoize :inverse
+
+    end # class Connective
+  end # module Logic
+end # module Veritas
+
+require 'veritas/logic/connective/binary'
+require 'veritas/logic/connective/unary'
+
+require 'veritas/logic/connective/conjunction'
+require 'veritas/logic/connective/disjunction'
+require 'veritas/logic/connective/negation'

data/lib/veritas/logic/expression.rb

@@ -0,0 +1,99 @@
+module Veritas
+  module Logic
+
+    # Abstract base class for logical expressions
+    class Expression
+      extend Aliasable
+      include AbstractClass, Optimizable, Immutable
+
+      # Evaluate the expression using the operands
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def self.call(*)
+        raise NotImplementedError, "#{name}.call must be implemented"
+      end
+
+      # Rename the contained attributes with the provided aliases
+      #
+      # @example
+      #   renamed = expression.rename(aliases)
+      #
+      # @param [Algebra::Rename::Aliases] aliases
+      #   the old and new attributes
+      #
+      # @return [self]
+      #
+      # @api public
+      def rename(aliases)
+        self
+      end
+
+      # Return the inverse expression
+      #
+      # @example
+      #   inverse = expression.inverse
+      #
+      # @return [Expression]
+      #
+      # @api public
+      def inverse
+        raise NotImplementedError, "#{self.class}#inverse must be implemented"
+      end
+
+      # Compare the expression with other expression for equivalency
+      #
+      # @example
+      #   expression == other  # => true or false
+      #
+      # @param [Expression] other
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def ==(other)
+        optimize.eql?(other.optimize)
+      end
+
+      # Compare the expression with other expression for equality
+      #
+      # @example
+      #   expression.eql?(other)  # => true or false
+      #
+      # @param [Expression] other
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def eql?(other)
+        raise NotImplementedError, "#{self.class}#eql? must be implemented"
+      end
+
+      # Return the hash of the expression
+      #
+      # @example
+      #   numeric_hash = expression.hash
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def hash
+        raise NotImplementedError, "#{self.class}#hash must be implemented"
+      end
+
+      # Return a string representing the expression
+      #
+      # @example
+      #   expression.inspect  # (String representation of Expression)
+      #
+      # @return [String]
+      #
+      # @api public
+      def inspect
+        raise NotImplementedError, "#{self.class}#inspect must be implemented"
+      end
+
+    end # class Expression
+  end # module Logic
+end # module Veritas

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

@@ -0,0 +1,57 @@
+module Veritas
+  module Logic
+    class Predicate
+
+      # A mixin for predicates with directly compared operands
+      module Comparable
+        include Immutable
+
+        # Hook called when module is included
+        #
+        # @param [Module] descendant
+        #   the module or class including Comparable
+        #
+        # @return [self]
+        #
+        # @api private
+        def self.included(descendant)
+          descendant.extend ClassMethods
+          self
+        end
+
+        # Return a string representing the predicate
+        #
+        # @example
+        #   predicate.inspect  # (String representation of Predicate)
+        #
+        # @return [String]
+        #
+        # @api public
+        def inspect
+          "#{left.inspect} #{self.class.operation} #{right.inspect}"
+        end
+
+        module ClassMethods
+
+          # Evaluate the values using the ruby operation
+          #
+          # @example
+          #   predicate.call(left, right)  # => true or false
+          #
+          # @param [Object] left
+          # @param [Object] right
+          #
+          # @return [Boolean]
+          #
+          # @api public
+          def call(left, right)
+            # methods ending in ? should return true or false only,
+            # force boolean context using !!
+            !!left.send(operation, right)
+          end
+
+        end # module Classmethods
+      end # module Comparable
+    end # class Predicate
+  end # module Logic
+end # module Veritas

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

@@ -0,0 +1,25 @@
+module Veritas
+  module Logic
+    class Predicate
+
+      # A mixin for predicates matching an enumerable
+      module Enumerable
+
+        # Initialize an Enumerable predicate
+        #
+        # @param [Object] left
+        #   the attribute or object to test for in the Enumerable
+        # @param [Enumerable] right
+        #   the enumerable to test
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(left, right)
+          super(left, Immutable.freeze_object(right))
+        end
+
+      end # module Enumerable
+    end # class Predicate
+  end # module Logic
+end # module Veritas

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

@@ -0,0 +1,65 @@
+module Veritas
+  module Logic
+    class Predicate
+
+      # A predicate representing an equality test between operands
+      class Equality < Predicate
+        include Comparable
+
+        # Return the Equality operation
+        #
+        # @example
+        #   Equality.operation  # => :==
+        #
+        # @return [Symbol]
+        #
+        # @api public
+        def self.operation
+          :==
+        end
+
+        # Return the inverse predicate class
+        #
+        # @example
+        #   Equality.inverse  # => Inequality
+        #
+        # @return [Class<Inequality>]
+        #
+        # @api public
+        def self.inverse
+          Inequality
+        end
+
+        # Return the reverse predicate class
+        #
+        # @example
+        #   Equality.reverse  # => Equality
+        #
+        # @return [self]
+        #
+        # @api public
+        def self.reverse
+          self
+        end
+
+        module Methods
+
+          # Compare the left to see if it is equal to the right
+          #
+          # @example
+          #   equality = expression.eq(other)
+          #
+          # @param [Expression] other
+          #
+          # @return [Equality]
+          #
+          # @api public
+          def eq(other)
+            Equality.new(self, other)
+          end
+
+        end # module Methods
+      end # class Equality
+    end # class Predicate
+  end # module Logic
+end # module Veritas

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

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+module Veritas
+  module Logic
+    class Predicate
+
+      # A predicate representing an exclusion test
+      class Exclusion < Predicate
+        include Enumerable
+
+        # Test an enumerable to see if a value is excluded
+        #
+        # @example
+        #   Exclusion.call(1, [ 1, 2, 3 ])  # => false
+        #
+        # @param [Object] left
+        #   the object to test for in the Enumerable
+        # @param [Enumerable] right
+        #   the enumerable to test
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def self.call(left, right)
+          !right.include?(left)
+        end
+
+        # Return the inverse predicate class
+        #
+        # @example
+        #   Exclusion.inverse  # => Inclusion
+        #
+        # @return [Class<Inclusion>]
+        #
+        # @api public
+        def self.inverse
+          Inclusion
+        end
+
+        # Return a string representing the predicate
+        #
+        # @example
+        #   exclusion.inspect  # "<Attribute::Integer name: id> ∉ [1, 2, 3]"
+        #
+        # @return [String]
+        #
+        # @api public
+        def inspect
+          "#{left.inspect} ∉ #{right.inspect}"
+        end
+
+        module Methods
+
+          # Compare the left to see if it is excluded from the right
+          #
+          # @example
+          #   exclusion = attribute.exclude([ 1, 2, 3 ])
+          #
+          # @param [Expression] other
+          #
+          # @return [Exclusion]
+          #
+          # @api public
+          def exclude(other)
+            Exclusion.new(self, other)
+          end
+
+        end # module Methods
+      end # class Exclusion
+    end # class Predicate
+  end # module Logic
+end # module Veritas

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

@@ -0,0 +1,65 @@
+module Veritas
+  module Logic
+    class Predicate
+
+      # A predicate representing a greater than test between operands
+      class GreaterThan < Predicate
+        include Comparable
+
+        # Return the GreaterThan operation
+        #
+        # @example
+        #   GreaterThan.operation  # => :>
+        #
+        # @return [Symbol]
+        #
+        # @api public
+        def self.operation
+          :>
+        end
+
+        # Return the inverse predicate class
+        #
+        # @example
+        #   GreaterThan.inverse  # => LessThanOrEqualTo
+        #
+        # @return [Class<LessThanOrEqualTo>]
+        #
+        # @api public
+        def self.inverse
+          LessThanOrEqualTo
+        end
+
+        # Return the reverse predicate class
+        #
+        # @example
+        #   GreaterThan.reverse  # => LessThan
+        #
+        # @return [Class<LessThan>]
+        #
+        # @api public
+        def self.reverse
+          LessThan
+        end
+
+        module Methods
+
+          # Compare the left to see if it is greater than the right
+          #
+          # @example
+          #   greater_than = expression.gt(other)
+          #
+          # @param [Expression] other
+          #
+          # @return [GreaterThan]
+          #
+          # @api public
+          def gt(other)
+            GreaterThan.new(self, other)
+          end
+
+        end # module Methods
+      end # class GreaterThan
+    end # class Predicate
+  end # module Logic
+end # module Veritas

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

@@ -0,0 +1,65 @@
+module Veritas
+  module Logic
+    class Predicate
+
+      # A predicate representing a greater than or equal to test between operands
+      class GreaterThanOrEqualTo < Predicate
+        include Comparable
+
+        # Return the GreaterThanOrEqualTo operation
+        #
+        # @example
+        #   GreaterThanOrEqualTo.operation  # => :>=
+        #
+        # @return [Symbol]
+        #
+        # @api public
+        def self.operation
+          :>=
+        end
+
+        # Return the inverse predicate class
+        #
+        # @example
+        #   GreaterThanOrEqualTo.inverse  # => LessThan
+        #
+        # @return [Class<LessThan>]
+        #
+        # @api public
+        def self.inverse
+          LessThan
+        end
+
+        # Return the reverse predicate class
+        #
+        # @example
+        #   GreaterThanOrEqualTo.reverse  # => LessThanOrEqualTo
+        #
+        # @return [Class<LessThanOrEqualTo>]
+        #
+        # @api public
+        def self.reverse
+          LessThanOrEqualTo
+        end
+
+        module Methods
+
+          # Compare the left to see if it is greater than or equal to the right
+          #
+          # @example
+          #   greater_than_or_equal_to = expression.gte(other)
+          #
+          # @param [Expression] other
+          #
+          # @return [GreaterThanOrEqualTo]
+          #
+          # @api public
+          def gte(other)
+            GreaterThanOrEqualTo.new(self, other)
+          end
+
+        end # module Methods
+      end # class GreaterThanOrEqualTo
+    end # class Predicate
+  end # module Logic
+end # module Veritas

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

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+module Veritas
+  module Logic
+    class Predicate
+
+      # A predicate representing an inclusion test
+      class Inclusion < Predicate
+        include Enumerable
+
+        # Test an enumerable to see if a value is included
+        #
+        # @example
+        #   Inclusion.call(1, [ 1, 2, 3 ])  # => true
+        #
+        # @param [Object] left
+        #   the object to test for in the Enumerable
+        # @param [Enumerable] right
+        #   the enumerable to test
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def self.call(left, right)
+          right.include?(left)
+        end
+
+        # Return the inverse predicate class
+        #
+        # @example
+        #   Inclusion.inverse  # => Exclusion
+        #
+        # @return [Class<Exclusion>]
+        #
+        # @api public
+        def self.inverse
+          Exclusion
+        end
+
+        # Return a string representing the predicate
+        #
+        # @example
+        #   inclusion.inspect  # "<Attribute::Integer name: id> ∈ [1, 2, 3]"
+        #
+        # @return [String]
+        #
+        # @api public
+        def inspect
+          "#{left.inspect} ∈ #{right.inspect}"
+        end
+
+        module Methods
+
+          # Compare the left to see if it is included in the right
+          #
+          # @example
+          #   exclusion = attribute.exclude([ 1, 2, 3 ])
+          #
+          # @param [Expression] other
+          #
+          # @return [Exclusion]
+          #
+          # @api public
+          def include(other)
+            Inclusion.new(self, other)
+          end
+
+        end # module Methods
+      end # class Inclusion
+    end # class Predicate
+  end # module Logic
+end # module Veritas