veritas 0.0.1

data/lib/veritas/attribute/string.rb

@@ -0,0 +1,88 @@
+module Veritas
+  class Attribute
+
+    # Represents a String value in a relation tuple
+    class String < Object
+      extend Aliasable
+      include Orderable,
+              Logic::Predicate::Match::Methods,
+              Logic::Predicate::NoMatch::Methods
+
+      DEFAULT_LENGTH = (0..50).freeze
+
+      inheritable_alias(:range => :length)
+
+      # The String length for a valid value
+      #
+      # @example
+      #   string.length  # => 0..50
+      #
+      # @return [Range<::Integer>]
+      #
+      # @api public
+      attr_reader :length
+
+      # The String primitive
+      #
+      # @example
+      #   String.primitive  # => ::String
+      #
+      # @return [Class<::String>]
+      #
+      # @api public
+      def self.primitive
+        ::String
+      end
+
+      # Initialize a String Attribute
+      #
+      # @param [#to_sym] name
+      #   the attribute name
+      # @param [#to_hash] options
+      #   the options for the attribute
+      # @option options [Boolean] :required (true)
+      #   if true, then the value cannot be nil
+      # @option options [Range<::Integer>] :length (0..50)
+      #   The string length for a valid value
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(*)
+        super
+        @length = @options.fetch(:length, DEFAULT_LENGTH).to_inclusive
+      end
+
+      # Test if the value matches the attribute constraints
+      #
+      # @example
+      #   string.valid_value?(value)  # => true or false
+      #
+      # @param [Object] value
+      #   the value to test
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def valid_value?(value)
+        valid_or_optional?(value) { super && length.include?(value.length) }
+      end
+
+      # Test if the attribute can be joined with the other attribute
+      #
+      # @example
+      #   string.joinable?(other)  # => true or false
+      #
+      # @param [Attribute] other
+      #   the other attribute to test
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def joinable?(other)
+        super && length.eql?(other.length)
+      end
+
+    end # class String
+  end # class Attribute
+end # module Veritas

data/lib/veritas/attribute/time.rb

@@ -0,0 +1,36 @@
+module Veritas
+  class Attribute
+
+    # Represents a Time value in a relation tuple
+    class Time < Object
+      include Comparable
+
+      DEFAULT_RANGE = (::Time.at(0)..::Time.at(2**31-1)).freeze
+
+      # The Time primitive
+      #
+      # @example
+      #   Time.primitive  # => ::Time
+      #
+      # @return [Class<::Time>]
+      #
+      # @api public
+      def self.primitive
+        ::Time
+      end
+
+      # The Time range for a valid value
+      #
+      # @example
+      #   Time.range  # => ::Time.utc(*from)..::Time.utc(*to)
+      #
+      # @return [Range<::Time>]
+      #
+      # @api public
+      def range
+        DEFAULT_RANGE
+      end
+
+    end # class Time
+  end # class Attribute
+end # module Veritas

data/lib/veritas/attribute.rb

@@ -0,0 +1,256 @@
+require 'veritas/attribute/orderable'
+
+require 'veritas/attribute/comparable'
+
+require 'veritas/attribute/object'
+require 'veritas/attribute/numeric'
+
+require 'veritas/attribute/boolean'
+require 'veritas/attribute/class'
+require 'veritas/attribute/date'
+require 'veritas/attribute/date_time'
+require 'veritas/attribute/decimal'
+require 'veritas/attribute/float'
+require 'veritas/attribute/integer'
+require 'veritas/attribute/time'
+require 'veritas/attribute/string'
+
+module Veritas
+
+  # Abstract base class representing a type of data in a relation tuple
+  class Attribute
+    include AbstractClass, Immutable, ::Comparable
+
+    # The attribute name
+    #
+    # @return [Symbol]
+    #
+    # @api private
+    attr_reader :name
+
+    # The attribute options
+    #
+    # @return [Hash]
+    #
+    # @api private
+    attr_reader :options
+
+    # Initialize an Attribute
+    #
+    # @param [#to_sym] name
+    #   the attribute name
+    # @param [#to_hash] options
+    #   the options for the attribute
+    # @option options [Boolean] :required (true)
+    #   if true, then the value cannot be nil
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(name, options = {})
+      @name     = name.to_sym
+      @options  = Immutable.freeze_object(options.to_hash)
+      @required = @options.fetch(:required, true)
+    end
+
+    # Extract the value corresponding to this attribute from a tuple
+    #
+    # @example
+    #   value = attribute.call(tuple)
+    #
+    # @param [Tuple] tuple
+    #   the tuple to extract the value from
+    #
+    # @return [Object]
+    #
+    # @api public
+    def call(tuple)
+      tuple[self]
+    end
+
+    # Rename an attribute
+    #
+    # @example
+    #   new_attribute = attribute.rename(new_name)
+    #
+    # @param [Symbol] new_name
+    #   the new name to rename the attribute to
+    #
+    # @return [Attribute]
+    #
+    # @api public
+    def rename(new_name)
+      name.equal?(new_name) ? self : self.class.new(new_name, options)
+    end
+
+    # Test if the attribute is required
+    #
+    # @example
+    #   attribute.required?  # => true or false
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def required?
+      @required
+    end
+
+    # Test if a value is the correct primitive type
+    #
+    # @example
+    #   attribute.valid_primitive?(value)  # => true or false
+    #
+    # @param [Object] value
+    #   the value to test
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def valid_primitive?(value)
+      value.kind_of?(self.class.primitive)
+    end
+
+    # Test if the value matches the attribute constraints
+    #
+    # @example
+    #   attribute.valid_value?(value)  # => true or false
+    #
+    # @param [Object] value
+    #   the value to test
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def valid_value?(value)
+      valid_or_optional?(value) { valid_primitive?(value) }
+    end
+
+    # Test if the attribute can be joined with the other attribute
+    #
+    # @example
+    #   attribute.joinable?(other)  # => true or false
+    #
+    # @param [Attribute] other
+    #   the other attribute to test
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def joinable?(other)
+      kind_of?(other.class) || other.kind_of?(self.class)
+    end
+
+    # Compare the attribute with other attribute for equivalency
+    #
+    # @example
+    #   attribute == other  # => true or false
+    #
+    # @param [Attribute] other
+    #   the other attribute to compare with
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def ==(other)
+      other = Attribute.coerce(other)
+      name.equal?(other.name) &&
+      options == other.options
+    end
+
+    # Compare the attribute with other attribute for equality
+    #
+    # @example
+    #   attribute.eql?(other)  # => true or false
+    #
+    # @param [Attribute] other
+    #   the other attribute to compare with
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def eql?(other)
+      instance_of?(other.class) &&
+      name.equal?(other.name)   &&
+      options.eql?(other.options)
+    end
+
+    # Return the hash of the attribute
+    #
+    # @example
+    #   numeric_hash = attribute.hash
+    #
+    # @return [Integer]
+    #
+    # @api public
+    def hash
+      name.hash ^ options.hash
+    end
+
+    # Return a string representing the attribute
+    #
+    # @example
+    #   attribute.inspect  # => "<Attribute::Integer name: id>"
+    #
+    # @return [String]
+    #
+    # @api public
+    def inspect
+      "<#{self.class.name.sub(/\AVeritas::/, '')} name: #{name}>"
+    end
+
+    # Coerce an object into an Attribute
+    #
+    # @param [Attribute, #to_ary, #to_sym] object
+    #   the object to coerce
+    #
+    # @return [Attribute]
+    #
+    # @api private
+    def self.coerce(object)
+      if object.kind_of?(self)
+        object
+      else
+        name, type = object
+        klass = type.nil? ? Object : const_get(type.name)
+        klass.new(name)
+      end
+    end
+
+    # Extract the attribute name from the object
+    #
+    # @param [#name, #to_ary, #to_sym] object
+    #   the object to extract a name from
+    #
+    # @return [Symbol]
+    #
+    # @api private
+    def self.name_from(object)
+      if object.respond_to?(:name)
+        object.name
+      elsif object.respond_to?(:to_ary)
+        object.to_ary.first
+      else
+        object.to_sym
+      end
+    end
+
+  private
+
+    # Test that the value is either valid or optional
+    #
+    # @param [Object] value
+    #   the value to test
+    #
+    # @yield [] block representing attribute constraint
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    def valid_or_optional?(value)
+      value.nil? ? !required? : yield
+    end
+
+    memoize :hash
+
+  end # class Attribute
+end # module Veritas

data/lib/veritas/core_ext/date.rb

@@ -0,0 +1,16 @@
+# Extend Date with methods to find the previous Date
+class Date
+
+  # Decrement the Date by one day
+  #
+  # @example
+  #   previous_day = date.pred
+  #
+  # @return [Date]
+  #
+  # @api public
+  def pred
+    self - 1
+  end unless method_defined? :pred
+
+end # class Date

data/lib/veritas/core_ext/range.rb

@@ -0,0 +1,35 @@
+# Extend Range with methods to normalize and find overlapping ranges
+class Range
+
+  # Returns an inclusive Range
+  #
+  # @example
+  #   inclusive = range.to_inclusive
+  #
+  # @return [Range]
+  #
+  # @api public
+  def to_inclusive
+    if exclude_end?
+      self.class.new(first, last.pred)
+    else
+      self
+    end
+  end unless method_defined? :to_inclusive
+
+  # Compare the range with another range to see if they overlap
+  #
+  # @example
+  #   range.overlaps?(other)  # => true or false
+  #
+  # @param [Range] other
+  #   the other Range to compare with
+  #
+  # @return [Boolean]
+  #
+  # @api public
+  def overlaps?(other)
+    include?(other.first) || other.include?(first)
+  end unless method_defined? :overlaps?
+
+end # class Range

data/lib/veritas/core_ext/time.rb

@@ -0,0 +1,16 @@
+# Extend Time with methods to find the previous Time
+class Time
+
+  # Decrement the Time by one second
+  #
+  # @example
+  #   previous_second = time.pred
+  #
+  # @return [Time]
+  #
+  # @api public
+  def pred
+    self - 1
+  end unless method_defined? :pred
+
+end # class Time

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

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

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

@@ -0,0 +1,70 @@
+module Veritas
+  module Logic
+    class Connective
+
+      # A logical AND between expressions
+      class Conjunction < Binary
+
+        # Evaluate the operands using a logical AND
+        #
+        # @example with true operands
+        #   Conjunction.call(true, true)  # => true
+        #
+        # @example with true and false
+        #   Conjunction.call(true, false)  # => false
+        #
+        # @example with false and true
+        #   Conjunction.call(false, true)  # => false
+        #
+        # @example with false and false
+        #   Conjunction.call(false, false)  # => false
+        #
+        # @param [Boolean] left
+        # @param [Boolean] right
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def self.call(left, right)
+          left && right
+        end
+
+        # Return a string representing the conjunction
+        #
+        # @example
+        #   conjunction.inspect  # "<Expression1> AND <Expression2>"
+        #
+        # @return [String]
+        #
+        # @api public
+        def inspect
+          "(#{left.inspect} AND #{right.inspect})"
+        end
+
+        module Methods
+          extend Aliasable
+
+          inheritable_alias(:& => :and)
+
+          # Logically AND the expression with another expression
+          #
+          # @example
+          #   conjunction = expression.and(other)
+          #
+          # @param [Expression] other
+          #
+          # @return [Conjunction]
+          #
+          # @api public
+          def and(other)
+            Conjunction.new(self, other)
+          end
+
+        end # module Methods
+
+        Expression.class_eval { include Methods }
+
+      end # class Conjunction
+    end # class Connective
+  end # module Logic
+end # module Veritas

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

@@ -0,0 +1,70 @@
+module Veritas
+  module Logic
+    class Connective
+
+      # A logical OR between expressions
+      class Disjunction < Binary
+
+        # Evaluate the operands using a logical OR
+        #
+        # @example with true operands
+        #   Disjunction.call(true, true)  # => true
+        #
+        # @example with true and false
+        #   Disjunction.call(true, false)  # => true
+        #
+        # @example with false and true
+        #   Disjunction.call(false, true)  # => true
+        #
+        # @example with false and false
+        #   Disjunction.call(false, false)  # => false
+        #
+        # @param [Boolean] left
+        # @param [Boolean] right
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def self.call(left, right)
+          left || right
+        end
+
+        # Return a string representing the disjunction
+        #
+        # @example
+        #   disjunction.inspect  # "<Expression1> OR <Expression2>"
+        #
+        # @return [String]
+        #
+        # @api public
+        def inspect
+          "(#{left.inspect} OR #{right.inspect})"
+        end
+
+        module Methods
+          extend Aliasable
+
+          inheritable_alias(:| => :or)
+
+          # Logically OR the expression with another expression
+          #
+          # @example
+          #   disjunction = expression.or(other)
+          #
+          # @param [Expression] other
+          #
+          # @return [Disjunction]
+          #
+          # @api public
+          def or(other)
+            Disjunction.new(self, other)
+          end
+
+        end # module Methods
+
+        Expression.class_eval { include Methods }
+
+      end # class Disjunction
+    end # class Connective
+  end # module Logic
+end # module Veritas