veritas 0.0.1

data/lib/veritas/support/immutable.rb

@@ -0,0 +1,299 @@
+module Veritas
+
+  # Allows objects to be made immutable
+  module Immutable
+
+    # Hook called when module is included
+    #
+    # @param [Module] descendant
+    #   the module or class including Immutable
+    #
+    # @return [self]
+    #
+    # @api private
+    def self.included(descendant)
+      descendant.extend ModuleMethods if descendant.kind_of?(Module)
+      descendant.extend ClassMethods  if descendant.kind_of?(Class)
+      self
+    end
+
+    # A noop when there are no memoized methods
+    #
+    # @example
+    #   object.memoize(:hash, 12345)  # => self
+    #
+    # @param [#to_s] name
+    # @param [Object] value
+    #
+    # @return [self]
+    #
+    # @api public
+    def memoize(name, value)
+      self
+    end
+
+    # A noop #dup for immutable objects
+    #
+    # @example
+    #   object.dup  # => self
+    #
+    # @return [self]
+    #
+    # @api public
+    def dup
+      self
+    end
+
+    # Attempt to freeze an object
+    #
+    # @example using a value object
+    #   Immutable.freeze_object(12345)  # => noop
+    #
+    # @example using a normal object
+    #   Immutable.freeze_object({})  # => duplicate & freeze object
+    #
+    # @param [Object] object
+    #   the object to freeze
+    #
+    # @return [Object]
+    #   if supported, the frozen object, otherwise the object directly
+    #
+    # @api public
+    def self.freeze_object(object)
+      case object
+        when Numeric, TrueClass, FalseClass, NilClass
+          object
+        else
+          freeze_value(object)
+      end
+    end
+
+    # Returns a frozen value
+    #
+    # @param [Object] value
+    #   a value to freeze
+    #
+    # @return [Object]
+    #   if frozen, the value directly, otherwise a frozen copy of the value
+    #
+    # @api private
+    def self.freeze_value(value)
+      value.frozen? ? value : value.dup.freeze
+    end
+
+    private_class_method :freeze_value
+
+    # Methods mixed in to immutable modules
+    module ModuleMethods
+
+      # Hook called when module is included
+      #
+      # @param [Module] mod
+      #   the module including ModuleMethods
+      #
+      # @return [self]
+      #
+      # @api private
+      def included(mod)
+        Immutable.included(mod)
+        self
+      end
+
+      # Memoize a list of methods
+      #
+      # @example
+      #   memoize :hash
+      #
+      # @param [Array<#to_s>] *methods
+      #   a list of methods to memoize
+      #
+      # @return [self]
+      #
+      # @api public
+      def memoize(*methods)
+        include_memoize_methods
+        methods.each { |method| memoize_method(method) }
+        self
+      end
+
+    private
+
+      # Mixin MemoizeMethods if it's not already
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def include_memoize_methods
+        include MemoizeMethods unless include?(MemoizeMethods)
+      end
+
+      # Memoize the named method
+      #
+      # @param [#to_s] method
+      #   a method to memoize
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def memoize_method(method)
+        alias_name = "__memoized_#{method}"
+        create_alias_for(method, alias_name)
+        create_memoize_method_for(method, alias_name)
+      end
+
+      # Create an alias to a method
+      #
+      # @param [String, Symbol] original_method
+      #   the name of the original method
+      # @param [String, Symbol] alias_name
+      #   the name of the new alias to create
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def create_alias_for(original_method, alias_name)
+        alias_method alias_name, original_method
+        private alias_name
+      end
+
+      # Create a memoized method that delegates to the original method
+      #
+      # @param [String, Symbol] new_method
+      #   the name of the new method
+      # @param [String, Symbol] alias_name
+      #   the name of the alias to the original method
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def create_memoize_method_for(new_method, alias_name)
+        visibility = method_visibility(new_method)
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{new_method}(*args)                                # def name(*args)
+            @__memory['@#{new_method}'] ||= #{alias_name}(*args)  #   @__memory['@name'] ||= __memoized_name(*args)
+          end                                                     # end
+        RUBY
+        send(visibility, new_method)
+      end
+
+      # Return the method visibility of a method
+      #
+      # @param [String, Symbol] method
+      #   the name of the method
+      #
+      # @return [String]
+      #
+      # @api private
+      def method_visibility(method)
+        if    private_method_defined?(method)   then 'private'
+        elsif protected_method_defined?(method) then 'protected'
+        else                                         'public'
+        end
+      end
+
+    end # module ModuleMethods
+
+    # Methods mixed in to immutable classes
+    module ClassMethods
+
+      # Instantiate a new frozen object
+      #
+      # @example
+      #   object = ImmutableClass.new  # object is frozen
+      #
+      # @return [Object]
+      #
+      # @api public
+      def new(*)
+        super.freeze
+      end
+
+    end # module ClassMethods
+
+    # Methods mixed in to memoizable immutable instances
+    module MemoizeMethods
+
+      # Freeze the object
+      #
+      # @example
+      #   object.freeze  # object is now frozen
+      #
+      # @return [Object]
+      #
+      # @api public
+      def freeze
+        @__memory = Memory.new unless frozen?
+        super
+      end
+
+      # Get the memoized value for a method
+      #
+      # @example
+      #   hash = object.memoized(:hash)
+      #
+      # @param [#to_s] name
+      #   the method name
+      #
+      # @return [Object]
+      #
+      # @api public
+      def memoized(name)
+        @__memory["@#{name}"]
+      end
+
+      # Sets a memoized value for a method
+      #
+      # @example
+      #   object.memoize(:hash, 12345)
+      #
+      # @param [#to_s] name
+      #   the method name
+      # @param [Object] value
+      #   the value to memoize
+      #
+      # @return [self]
+      #
+      # @api public
+      def memoize(name, value)
+        @__memory["@#{name}"] = value
+        self
+      end
+
+    end # module MemoizeMethods
+
+    # Tracks the values for memoized methods
+    class Memory
+
+      # Get a frozen value from memory
+      #
+      # @example
+      #   value = memory[ivar]
+      #
+      # @param [#to_s] ivar
+      #   the name of the ivar to get the value for
+      #
+      # @return [Object]
+      #
+      # @api public
+      alias [] instance_variable_get
+
+      # Set a frozen value in memory
+      #
+      # @example
+      #   memory[ivar] = value
+      #
+      # @param [#to_s] ivar
+      #   the name of the ivar to set
+      # @param [Object] value
+      #   the value to set
+      #
+      # @return [undefined]
+      #
+      # @api public
+      def []=(ivar, value)
+        instance_variable_set(ivar, Immutable.freeze_object(value))
+      end
+
+    end # class Memory
+  end # module Immutable
+end # module Veritas

data/lib/veritas/support/operation/binary.rb

@@ -0,0 +1,73 @@
+module Veritas
+  module Operation
+    module Binary
+      include Immutable
+
+      # The left operand for the operation
+      #
+      # @example
+      #   left = binary.left
+      #
+      # @return [Object]
+      #
+      # @api public
+      attr_reader :left
+
+      # The right operand for the operation
+      #
+      # @example
+      #   right = binary.right
+      #
+      # @return [Object]
+      #
+      # @api public
+      attr_reader :right
+
+      # Initialize Binary Operation
+      #
+      # @param [Object] left
+      #   the left operand for the operation
+      # @param [Object] right
+      #   the right operand for the operation
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(left, right)
+        @left  = left
+        @right = right
+      end
+
+      # Compare the operation with the other operation for equality
+      #
+      # @example
+      #   binary.eql?(other)  # => true or false
+      #
+      # @param [Object] other
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def eql?(other)
+        instance_of?(other.class) &&
+        left.eql?(other.left)     &&
+        right.eql?(other.right)
+      end
+
+      # Return the hash of the left and right operands
+      #
+      # @example
+      #   numeric_hash = binary.hash
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def hash
+        left.hash ^ right.hash
+      end
+
+      memoize :hash
+
+    end # module Binary
+  end # module Operation
+end # module Veritas

data/lib/veritas/support/operation/unary.rb

@@ -0,0 +1,59 @@
+module Veritas
+  module Operation
+    module Unary
+      include Immutable
+
+      # The operand to the operation
+      #
+      # @example
+      #   operand = unary.operand
+      #
+      # @return [Object]
+      #
+      # @api public
+      attr_reader :operand
+
+      # Initialize Unary Operation
+      #
+      # @param [Object] operand
+      #   the operand for the operation
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(operand)
+        @operand = operand
+      end
+
+      # Compare the operation with the other operation for equality
+      #
+      # @example
+      #   unary.eql?(other)  # => true or false
+      #
+      # @param [Object] other
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def eql?(other)
+        instance_of?(other.class) &&
+        operand.eql?(other.operand)
+      end
+
+      # Return the hash of the operand
+      #
+      # @example
+      #   numeric_hash = unary.hash
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def hash
+        operand.hash
+      end
+
+      memoize :hash
+
+    end # module Unary
+  end # module Operation
+end # module Veritas

data/lib/veritas/support/optimizable.rb

@@ -0,0 +1,51 @@
+module Veritas
+
+  # Allow operations to be optimizable
+  module Optimizable
+    include Immutable
+
+    # Hook called when module is included
+    #
+    # @param [Module] descendant
+    #   the module or class including Optimizable
+    #
+    # @return [self]
+    #
+    # @api private
+    def self.included(descendant)
+      descendant.extend ClassMethods
+      self
+    end
+
+    # Optimize the operation
+    #
+    # @example
+    #   optimized = operation.optimize
+    #
+    # @param [Optimizer] optimizer
+    #   optional optimizer
+    #
+    # @return [Optimizable]
+    #   the optimized operation
+    #
+    # @api public
+    def optimize(optimizer = self.class.optimizer)
+      return self if optimizer.nil?
+      optimized = optimizer.call(self)
+      optimized.memoize(:optimize, optimized)
+    end
+
+    memoize :optimize
+
+    module ClassMethods
+
+      # The Optimizer for the operation
+      #
+      # @return [Optimizable]
+      #
+      # @api private
+      attr_accessor :optimizer
+
+    end # module ClassMethods
+  end # module Optimizable
+end # module Veritas

data/lib/veritas/tuple.rb

@@ -0,0 +1,181 @@
+module Veritas
+
+  # A set of objects representing a unique fact in a relation
+  class Tuple
+    include Immutable
+
+    # The tuple header
+    #
+    # @return [Header]
+    #
+    # @api private
+    attr_reader :header
+
+    # Initialize a Tuple
+    #
+    # @param [Header] header
+    #   the tuple header
+    # @param [#to_ary] data
+    #   the tuple data
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(header, data)
+      @header, @data = header, data.to_ary
+    end
+
+    # Lookup a value in the tuple given an attribute
+    #
+    # @example
+    #   value = tuple[attribute]
+    #
+    # @param [Attribute] attribute
+    #
+    # @return [Object]
+    #
+    # @api public
+    def [](attribute)
+      index = header.index(attribute)
+      to_ary.at(index) if index
+    end
+
+    # Return a tuple with only the specified attributes
+    #
+    # @example
+    #   new_tuple = tuple.project(header)
+    #
+    # @param [Header] header
+    #   the attributes to include in the tuple
+    #
+    # @return [Tuple]
+    #
+    # @api public
+    def project(header)
+      self.class.new(header, header.map { |attribute| self[attribute] })
+    end
+
+    # Append values to the tuple and return a new tuple
+    #
+    # @example
+    #   new_tuple = tuple.join(header, [ 1, 2, 3 ])
+    #
+    # @param [Header] header
+    #   the attributes to include in the tuple
+    # @param [Array] values
+    #   the values to append
+    #
+    # @return [Tuple]
+    #
+    # @api public
+    def join(header, values)
+      self.class.new(header, to_ary + values)
+    end
+
+    # Extend a tuple with function results
+    #
+    # @example
+    #   new_tuple = tuple.extend(header, [ func1, func2 ])
+    #
+    # @param [Header] header
+    #   the attributes to include in the tuple
+    # @param [Array<#call>] extensions
+    #   the functions to extend the tuple with
+    #
+    # @return [Tuple]
+    #
+    # @api public
+    def extend(header, extensions)
+      join(header, extensions.map { |extension| extension.call(self) })
+    end
+
+    # Convert the Tuple into an Array
+    #
+    # @example
+    #   array = tuple.to_ary
+    #
+    # @return [Array]
+    #
+    # @api public
+    def to_ary
+      @data
+    end
+
+    # Compare the tuple with other tuple for equivalency
+    #
+    # @example
+    #   tuple == other  # => true or false
+    #
+    # @param [Tuple] other
+    #   the other tuple to compare with
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def ==(other)
+      header = self.header
+      other  = self.class.coerce(header, other)
+      header == other.header &&
+      to_ary == other.project(header).to_ary
+    end
+
+    # Compare the tuple with other tuple for equality
+    #
+    # @example
+    #   tuple == other  # => true or false
+    #
+    # @param [Tuple] other
+    #   the other tuple to compare with
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def eql?(other)
+      header = self.header
+      instance_of?(other.class) &&
+      header.eql?(other.header) &&
+      to_ary.eql?(other.project(header).to_ary)
+    end
+
+    # Return the hash of the tuple
+    #
+    # @example
+    #   numeric_hash = tuple.hash
+    #
+    # @return [Integer]
+    #
+    # @api public
+    def hash
+      header.hash ^ to_ary.hash
+    end
+
+    # Return a string representing the tuple data
+    #
+    # @example
+    #   tuple.inspect  # => "[1, 2, 3]"
+    #
+    # @return [String]
+    #
+    # @api public
+    def inspect
+      to_ary.inspect
+    end
+
+    # Coerce an Array-like object into a Tuple
+    #
+    # @param [Header] header
+    #   the tuple header
+    # @param [Tuple, #to_ary]
+    #   the tuple or tuple data
+    #
+    # @return [Tuple]
+    #
+    # @api private
+    def self.coerce(header, object)
+      object.kind_of?(Tuple) ? object : new(header, object)
+    end
+
+    memoize :hash
+
+  end # class Tuple
+end # module Veritas

data/lib/veritas/version.rb

@@ -0,0 +1,3 @@
+module Veritas
+  VERSION = '0.0.1'
+end # module Veritas

data/lib/veritas.rb

@@ -0,0 +1,54 @@
+require 'bigdecimal'
+require 'date'
+require 'set'
+require 'singleton'
+
+require 'veritas/core_ext/date'
+require 'veritas/core_ext/range'
+require 'veritas/core_ext/time'
+
+require 'veritas/support/abstract_class'
+require 'veritas/support/aliasable'
+require 'veritas/support/immutable'
+require 'veritas/support/optimizable'
+
+require 'veritas/support/operation/binary'
+require 'veritas/support/operation/unary'
+
+require 'veritas/support/evaluator'
+
+require 'veritas/logic'
+require 'veritas/relation'
+require 'veritas/algebra'
+
+require 'veritas/optimizer'
+require 'veritas/attribute'
+require 'veritas/tuple'
+require 'veritas/version'
+
+module Veritas
+
+  # Raised when the headers are invalid for Join and Product
+  class InvalidHeaderError < ArgumentError; end
+
+  # Raised when the limit is not a positive integer
+  class InvalidLimitError < ArgumentError; end
+
+  # Raised when the offset is not a positive integer
+  class InvalidOffsetError < ArgumentError; end
+
+  # Raised when the order does not include every attribute in the header
+  class InvalidDirectionsError < ArgumentError; end
+
+  # Raised when a method requiring ordering is called on an unordered relation
+  class OrderedRelationRequiredError < StandardError; end
+
+  # Raised when a binary operation mixes ordered and unordered relations
+  class RelationMismatchError < StandardError; end
+
+  # Raised when an attribute is added to a relation that already exists
+  class DuplicateHeaderName < StandardError; end
+
+  TABLE_DUM = Relation.new([], [    ]).optimize
+  TABLE_DEE = Relation.new([], [ [] ]).optimize
+end