veritas 0.0.1

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

@@ -0,0 +1,80 @@
+module Veritas
+  module Logic
+    class Predicate
+
+      # A predicate representing an inequality test between operands
+      class Inequality < Predicate
+        include Comparable
+
+        # Return the Inequality operation
+        #
+        # @example
+        #   Inequality.operation  # => :!=
+        #
+        # @return [Symbol]
+        #
+        # @api public
+        def self.operation
+          :'!='
+        end
+
+        # Return the inverse predicate class
+        #
+        # @example
+        #   Inequality.inverse  # => Equality
+        #
+        # @return [Class<Equality>]
+        #
+        # @api public
+        def self.inverse
+          Equality
+        end
+
+        # Return the reverse predicate class
+        #
+        # @example
+        #   Inequality.reverse  # => Inequality
+        #
+        # @return [self]
+        #
+        # @api public
+        def self.reverse
+          self
+        end
+
+        # Evaluate the values for inequality
+        #
+        # @example
+        #   Inequality.call(left, right)  # => true or false
+        #
+        # @param [Object] left
+        # @param [Object] right
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def self.call(left, right)
+          left != right
+        end unless Object.method_defined?(operation)
+
+        module Methods
+
+          # Compare the left to see if it is not equal to the right
+          #
+          # @example
+          #   inequality = expression.eq(other)
+          #
+          # @param [Expression] other
+          #
+          # @return [Inequality]
+          #
+          # @api public
+          def ne(other)
+            Inequality.new(self, other)
+          end
+
+        end # module Methods
+      end # class Inequality
+    end # class Predicate
+  end # module Algebra
+end # module Veritas

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

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

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

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

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

@@ -0,0 +1,53 @@
+module Veritas
+  module Logic
+    class Predicate
+
+      # A predicate representing a regexp match between operands
+      class Match < Predicate
+        include Comparable
+
+        # Return the Match operation
+        #
+        # @example
+        #   Match.operation  # => :=~
+        #
+        # @return [Symbol]
+        #
+        # @api public
+        def self.operation
+          :=~
+        end
+
+        # Return the inverse predicate class
+        #
+        # @example
+        #   Match.inverse  # => NoMatch
+        #
+        # @return [Class<NoMatch>]
+        #
+        # @api public
+        def self.inverse
+          NoMatch
+        end
+
+        module Methods
+
+          # Compare the left to see if it matches the right
+          #
+          # @example
+          #   match = expression.match(regexp)
+          #
+          # @param [Expression] other
+          #
+          # @return [Match]
+          #
+          # @api public
+          def match(regexp)
+            Match.new(self, regexp)
+          end
+
+        end # module Methods
+      end # class Match
+    end # class Predicate
+  end # module Logic
+end # module Veritas

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

@@ -0,0 +1,68 @@
+module Veritas
+  module Logic
+    class Predicate
+
+      # A predicate representing no regexp match between operands
+      class NoMatch < Predicate
+        include Comparable
+
+        # Return the NoMatch operation
+        #
+        # @example
+        #   NoMatch.operation  # => :!~
+        #
+        # @return [Symbol]
+        #
+        # @api public
+        def self.operation
+          :'!~'
+        end
+
+        # Return the inverse predicate class
+        #
+        # @example
+        #   NoMatch.inverse  # => Match
+        #
+        # @return [Class<Match>]
+        #
+        # @api public
+        def self.inverse
+          Match
+        end
+
+        # Evaluate the values for no match
+        #
+        # @example
+        #   NoMatch.call(left, right)  # => true or false
+        #
+        # @param [Object] left
+        # @param [Object] right
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def self.call(left, right)
+          left !~ right
+        end unless Object.method_defined?(operation)
+
+        module Methods
+
+          # Compare the left to see if does not match the right
+          #
+          # @example
+          #   no_match = expression.no_match(regexp)
+          #
+          # @param [Expression] other
+          #
+          # @return [NoMatch]
+          #
+          # @api public
+          def no_match(regexp)
+            NoMatch.new(self, regexp)
+          end
+
+        end # module Methods
+      end # class NoMatch
+    end # class Predicate
+  end # module Logic
+end # module Veritas

data/lib/veritas/logic/predicate.rb

@@ -0,0 +1,97 @@
+module Veritas
+  module Logic
+
+    # Abstract base class for logical predicates
+    class Predicate < Expression
+      include AbstractClass, Operation::Binary
+
+      # Evaluate the predicate using the provided Tuple
+      #
+      # @example
+      #   value = predicate.call(tuple)
+      #
+      # @param [Tuple] tuple
+      #
+      # @return [Object]
+      #
+      # @api public
+      def call(tuple)
+        util = self.class
+        util.call(
+          util.extract_value(left,  tuple),
+          util.extract_value(right, tuple)
+        )
+      end
+
+      # Rename the contained attributes with the provided aliases
+      #
+      # @example
+      #   renamed = predicate.rename(aliases)
+      #
+      # @param [Algebra::Rename::Aliases] aliases
+      #   the old and new attributes
+      #
+      # @return [Predicate]
+      #
+      # @api public
+      def rename(aliases)
+        left  = self.left
+        right = self.right
+        util  = self.class
+
+        renamed_left  = aliases[left]
+        renamed_right = aliases[right]
+
+        if left.equal?(renamed_left) && right.equal?(renamed_right)
+          self
+        else
+          util.new(renamed_left, renamed_right)
+        end
+      end
+
+      # Return the inverse predicate
+      #
+      # @example
+      #   inverse = predicate.inverse
+      #
+      # @return [Predicate]
+      #
+      # @api public
+      def inverse
+        self.class.inverse.new(left, right).
+          memoize(:inverse, self)
+      end
+
+      # Extract the value from the operand or tuple
+      #
+      # @param [Object, #call] operand
+      #   the operand to extract the value from
+      # @param [Tuple] tuple
+      #   the tuple to pass in to the operand if it responds to #call
+      #
+      # @return [Object]
+      #
+      # @api private
+      def self.extract_value(operand, tuple)
+        operand.respond_to?(:call) ? operand.call(tuple) : operand
+      end
+
+      memoize :inverse
+
+    end # class Predicate
+  end # module Logic
+end # module Veritas
+
+require 'veritas/logic/predicate/comparable'
+require 'veritas/logic/predicate/enumerable'
+
+require 'veritas/logic/predicate/equality'
+require 'veritas/logic/predicate/exclusion'
+require 'veritas/logic/predicate/greater_than'
+require 'veritas/logic/predicate/greater_than_or_equal_to'
+require 'veritas/logic/predicate/inclusion'
+require 'veritas/logic/predicate/inequality'
+require 'veritas/logic/predicate/less_than'
+require 'veritas/logic/predicate/less_than_or_equal_to'
+require 'veritas/logic/predicate/no_match'
+require 'veritas/logic/predicate/match'

data/lib/veritas/logic/proposition/false.rb

@@ -0,0 +1,63 @@
+module Veritas
+  module Logic
+    class Proposition
+
+      # A class representing a contradiction
+      class False < Proposition
+
+        # Return the inverse proposition class
+        #
+        # @example
+        #   False.inverse  # => True
+        #
+        # @return [Class<True>]
+        #
+        # @api public
+        def self.inverse
+          True
+        end
+
+        # Evaluate the proposition
+        #
+        # @example
+        #   False.call  # => false
+        #
+        # @return [false]
+        #
+        # @api public
+        def self.call
+          false
+        end
+
+        # Logically AND the proposition with another expression
+        #
+        # @example
+        #   false_proposition.and(other)  # => false_proposition
+        #
+        # @param [Expression] other
+        #
+        # @return [self]
+        #
+        # @api public
+        def and(other)
+          self
+        end
+
+        # Logically OR the proposition with another expression
+        #
+        # @example
+        #   false_proposition.or(other)  # => other
+        #
+        # @param [Expression] other
+        #
+        # @return [Expression]
+        #
+        # @api public
+        def or(other)
+          other
+        end
+
+      end # class False
+    end # class Proposition
+  end # module Algebra
+end # module Veritas

data/lib/veritas/logic/proposition/true.rb

@@ -0,0 +1,63 @@
+module Veritas
+  module Logic
+    class Proposition
+
+      # A class representing a tautology
+      class True < Proposition
+
+        # Return the inverse proposition class
+        #
+        # @example
+        #   True.inverse  # => False
+        #
+        # @return [Class<False>]
+        #
+        # @api public
+        def self.inverse
+          False
+        end
+
+        # Evaluate the proposition
+        #
+        # @example
+        #   True.call  # => true
+        #
+        # @return [true]
+        #
+        # @api public
+        def self.call
+          true
+        end
+
+        # Logically AND the proposition with another expression
+        #
+        # @example
+        #   true_proposition.and(other)  # => other
+        #
+        # @param [Expression] other
+        #
+        # @return [Expression]
+        #
+        # @api public
+        def and(other)
+          other
+        end
+
+        # Logically OR the proposition with another expression
+        #
+        # @example
+        #   true_proposition.or(other)  # => true_proposition
+        #
+        # @param [Expression] other
+        #
+        # @return [self]
+        #
+        # @api public
+        def or(other)
+          self
+        end
+
+      end # class True
+    end # class Proposition
+  end # module Algebra
+end # module Veritas

data/lib/veritas/logic/proposition.rb

@@ -0,0 +1,110 @@
+module Veritas
+  module Logic
+
+    # Abstract base class for logical propositions
+    class Proposition < Expression
+      include Singleton
+
+      # Instantiate a new Proposition
+      #
+      # @example using a true value
+      #   true_proposition = Proposition.new(true)
+      #
+      # @example using a false value
+      #   false_proposition = Proposition.new(false)
+      #
+      # @return [Proposition]
+      #
+      # @overload self.new(true)
+      #   Return the True singleton instance
+      #
+      #   @param [Array(true)] *args
+      #
+      #   @return [True]
+      #
+      # @overload self.new(false)
+      #   Return the False singleton instance
+      #
+      #   @param [Array(false)] *args
+      #
+      #   @return [False]
+      #
+      # @api public
+      def self.new(*args)
+        if args.empty?
+          super
+        else
+          (args.first ? True : False).instance
+        end
+      end
+
+      # Evaluate the proposition
+      #
+      # @example
+      #   proposition.call  # => true or false
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def call(*)
+        self.class.call
+      end
+
+      # Return the inverse proposition
+      #
+      # @example
+      #   inverse = proposition.inverse
+      #
+      # @return [Proposition]
+      #
+      # @api public
+      def inverse
+        self.class.inverse.instance
+      end
+
+      # Compare the proposition with other proposition for equality
+      #
+      # @example
+      #   proposition.eql?(other)  # => true or false
+      #
+      # @param [Proposition] other
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def eql?(other)
+        instance_of?(other.class)
+      end
+
+      # Return the hash of the proposition
+      #
+      # @example
+      #   numeric_hash = proposition.hash
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def hash
+        call.hash
+      end
+
+      # Return a string representing the proposition
+      #
+      # @example
+      #   proposition.inspect  # (String representation of Proposition)
+      #
+      # @return [String]
+      #
+      # @api public
+      def inspect
+        call.inspect
+      end
+
+      memoize :hash
+
+    end # class Proposition
+  end # module Algebra
+end # module Veritas
+
+require 'veritas/logic/proposition/false'
+require 'veritas/logic/proposition/true'

data/lib/veritas/logic.rb

@@ -0,0 +1,5 @@
+require 'veritas/logic/expression'
+
+require 'veritas/logic/connective'
+require 'veritas/logic/predicate'
+require 'veritas/logic/proposition'