veritas 0.0.1

data/lib/veritas/relation/operation/set.rb

@@ -0,0 +1,76 @@
+module Veritas
+  class Relation
+    module Operation
+
+      # A mixin for Set relations
+      module Set
+        include Binary
+
+        # Hook called when module is included
+        #
+        # @param [Module] descendant
+        #   the module or class including Set
+        #
+        # @return [self]
+        #
+        # @api private
+        def self.included(descendant)
+          descendant.extend ClassMethods
+          self
+        end
+
+        # Initialize a Set
+        #
+        # @param [Relation] left
+        # @param [Relation] right
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(left, right)
+          super
+          @header = left.header
+        end
+
+        module ClassMethods
+
+          # Instantiate a new Set relation
+          #
+          # @example
+          #   set = SetRelation.new(left, right)
+          #
+          # @param [Relation] left
+          # @param [Relation] right
+          #
+          # @return [Set]
+          #
+          # @api public
+          def new(left, right)
+            assert_equivalent_headers(left, right)
+            super
+          end
+
+        private
+
+          # Assert that left and right have equivalent headers
+          #
+          # @param [Relation] left
+          # @param [Relation] right
+          #
+          # @return [undefined]
+          #
+          # @raise [InvalidHeaderError]
+          #   raised if the headers are not equivalent
+          #
+          # @api private
+          def assert_equivalent_headers(left, right)
+            if left.header != right.header
+              raise InvalidHeaderError, "the headers must be equivalent for #{name}.new"
+            end
+          end
+
+        end # module ClassMethods
+      end # module Set
+    end # module Operation
+  end # class Relation
+end # module Veritas

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

@@ -0,0 +1,25 @@
+module Veritas
+  class Relation
+    module Operation
+
+      # A mixin for Unary relations
+      module Unary
+        include Veritas::Operation::Unary
+
+        # Initialize a Unary relation
+        #
+        # @param [Relation] operand
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(operand)
+          super
+          @header     = operand.header
+          @directions = operand.directions
+        end
+
+      end # module Unary
+    end # module Operation
+  end # class Relation
+end # module Veritas

data/lib/veritas/relation/operation.rb

@@ -0,0 +1,10 @@
+require 'veritas/relation/operation/unary'
+require 'veritas/relation/operation/binary'
+
+require 'veritas/relation/operation/combine'
+require 'veritas/relation/operation/set'
+
+require 'veritas/relation/operation/offset'
+require 'veritas/relation/operation/order'
+require 'veritas/relation/operation/limit'
+require 'veritas/relation/operation/reverse'

data/lib/veritas/relation.rb

@@ -0,0 +1,210 @@
+require 'veritas/relation/header'
+
+module Veritas
+
+  # Abstract base class for Relation operations
+  class Relation
+    include Immutable
+  end
+end
+
+require 'veritas/relation/materialized'
+require 'veritas/relation/empty'
+
+module Veritas
+  class Relation
+    include Enumerable, Optimizable
+
+    # The relation header
+    #
+    # @return [Header]
+    #
+    # @api private
+    attr_reader :header
+
+    # The relation sort order
+    #
+    # @return [Operation::Order::DirectionSet]
+    #
+    # @api private
+    attr_reader :directions
+
+    # Instantiate a new Relation
+    #
+    # @example of a materialized Array based relation
+    #   array    = [ [ 1 ], [ 2 ], [ 3 ] ]
+    #   relation = Relation.new([ [ :id, Integer ] ], array)
+    #
+    # @example of a materialized Set based relation
+    #   set      = Set[ [ 1 ], [ 2 ], [ 3 ] ]
+    #   relation = Relation.new([ [ :id, Integer ] ], set)
+    #
+    # @example of a non-materialized Enumerator based relation
+    #   enumerator = [ [ 1 ], [ 2 ], [ 3 ] ].each
+    #   relation   = Relation.new([ [ :id, Integer ] ], enumerator)
+    #
+    # @param [Header, #to_ary] header
+    #   the relation header
+    # @param [Enumerable] tuples
+    #   the relation tuples
+    #
+    # @return [Relation]
+    #
+    # @api public
+    def self.new(*args)
+      if equal?(Relation) && args.last.respond_to?(:size)
+        Materialized.new(*args)
+      else
+        super
+      end
+    end
+
+    # Initialize a Relation
+    #
+    # @param [Header, #to_ary] header
+    #   the relation header
+    # @param [Enumerable] tuples
+    #   the relation tuples
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(header, tuples)
+      @header     = Header.coerce(header)
+      @tuples     = tuples
+      @directions = Operation::Order::DirectionSet::EMPTY
+    end
+
+    # Lookup an Attribute in the header given an attribute name
+    #
+    # @example
+    #   attribute = relation[name]
+    #
+    # @param [#to_sym] name
+    #   the attribute name
+    #
+    # @return [Attribute]
+    #
+    # @api public
+    def [](name)
+      header[name]
+    end
+
+    # Iterate over each tuple in the set
+    #
+    # @example
+    #   relation = Relation.new(header, tuples)
+    #   relation.each { |tuple| ... }
+    #
+    # @yield [tuple]
+    #
+    # @yieldparam [Tuple] tuple
+    #   each tuple in the set
+    #
+    # @return [self]
+    #
+    # @api public
+    def each
+      seen = {}
+      tuples.each do |tuple|
+        tuple = Tuple.coerce(header, tuple)
+        yield(seen[tuple] = tuple) unless seen.key?(tuple)
+      end
+      self
+    end
+
+    # Return a relation with each tuple materialized
+    #
+    # @example
+    #   materialized = relation.materialize
+    #
+    # @return [Materialized]
+    #
+    # @api public
+    def materialize
+      Materialized.new(header, to_a, directions)
+    end
+
+    # Compare the relation with other relation for equivalency
+    #
+    # @example
+    #   relation == other  # => true or false
+    #
+    # @param [Relation] other
+    #   the other relation to compare with
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def ==(other)
+      other = coerce(other)
+      header == other.header &&
+      to_set == project_relation(other).to_set
+    end
+
+    # Compare the relation with other relation for equality
+    #
+    # @example
+    #   relation.eql?(other)  # => true or false
+    #
+    # @param [Relation] other
+    #   the other relation to compare with
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def eql?(other)
+      instance_of?(other.class) &&
+      header.eql?(other.header) &&
+      to_set.eql?(project_relation(other).to_set)
+    end
+
+    # Return the hash of the relation
+    #
+    # @example
+    #   numeric_hash = relation.hash
+    #
+    # @return [Integer]
+    #
+    # @api public
+    def hash
+      header.hash ^ to_set.hash
+    end
+
+    # Test if there are no tuples
+    #
+    # @example
+    #   relation.empty?  # => true or false
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def empty?
+      none? { true }
+    end
+
+  private
+
+    # The relation tuples
+    #
+    # @return [Enumerable]
+    #
+    # @api private
+    attr_reader :tuples
+
+    # Coerce an Enumerable into a Relation
+    #
+    # @param [Relation, Enumerable] tuples
+    #   the tuples to coerce
+    #
+    # @return [Relation]
+    #
+    # @api private
+    def coerce(tuples)
+      tuples.kind_of?(Relation) ? tuples : Relation.new(header, tuples)
+    end
+
+  end # class Relation
+end # module Veritas
+
+require 'veritas/relation/operation'

data/lib/veritas/support/abstract_class.rb

@@ -0,0 +1,40 @@
+module Veritas
+  module AbstractClass
+
+    # Hook called when module is included
+    #
+    # @param [Module] descendant
+    #   the module or class including AbstractClass
+    #
+    # @return [self]
+    #
+    # @api private
+    def self.included(descendant)
+      descendant.extend ClassMethods
+      self
+    end
+
+    module ClassMethods
+
+      # Instantiate a new object
+      #
+      # Ensures that the instance cannot be of the abstract class
+      # and must be a descendant.
+      #
+      # @example
+      #   object = AbstractClass.new
+      #
+      # @return [Object]
+      #
+      # @api public
+      def new(*)
+        if superclass.equal?(Object)
+          raise NotImplementedError, "#{self} is an abstract class"
+        else
+          super
+        end
+      end
+
+    end # module ClassMethods
+  end # module AbstractClass
+end # module Veritas

data/lib/veritas/support/aliasable.rb

@@ -0,0 +1,29 @@
+module Veritas
+
+  # A mixin to allow inheritable aliases for methods to be added
+  module Aliasable
+
+    # Create aliases for each specified method
+    #
+    # @example
+    #   inheritable_alias(:- => :difference)
+    #
+    # @param [Hash{Symbol => Symbol}] aliases
+    #   the new and old methods to alias
+    #
+    # @return [self]
+    #
+    # @api public
+    def inheritable_alias(aliases)
+      aliases.each do |new_method, original_method|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{new_method}(*args, &block)          # def |(*args, &block)
+            self.#{original_method}(*args, &block)  #   self.union(*args, &block)
+          end                                       # end
+        RUBY
+      end
+      self
+    end
+
+  end # module Aliasable
+end # module Veritas

data/lib/veritas/support/evaluator.rb

@@ -0,0 +1,52 @@
+module Veritas
+  module Evaluator
+
+    # Provide a context to evaluate a Relation operation block
+    class Expression
+      include Immutable
+
+      # The expressions to evaluate
+      #
+      # @return [Hash]
+      #
+      # @api private
+      attr_reader :expressions
+
+      # Initialize an Expression
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize
+        @expressions = {}
+        yield self
+        @expressions.freeze
+      end
+
+      # Add an expression to be evaluated by the relation operation
+      #
+      # @example of a function
+      #   evaluator.add(:total, evaluator[:unit_price] * evaluator[:quantity])
+      #
+      # @example of a block
+      #   evaluator.add(:total) { |t| t[:unit_price] * t[:quantity] } }
+      #
+      # @param [Attribute, #to_ary, #to_sym] attribute
+      #   the attribute to add to the header
+      # @param [#call] expression
+      #   optional function
+      #
+      # @yield []
+      #   optional block to execute in the relation operation
+      #
+      # @return [self]
+      #
+      # @api public
+      def add(attribute, expression = nil, &block)
+        expressions[Attribute.coerce(attribute)] = expression || block
+        self
+      end
+
+    end # class FunctionExpression
+  end # module Evaluator
+end # module Veritas