veritas 0.0.1

data/lib/veritas/relation/materialized.rb

@@ -0,0 +1,62 @@
+module Veritas
+  class Relation
+
+    # A materialized relation
+    class Materialized < Relation
+
+      # Initialize a materialized Relation
+      #
+      # @param [Header, #to_ary] header
+      #   the relation header
+      # @param [Enumerable] tuples
+      #   the relation tuples
+      # @param [Operation::Order::DirectionSet] directions
+      #   optional directions to sort the relation by
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(header, tuples, directions = Operation::Order::DirectionSet::EMPTY)
+        super(header, tuples)
+        @directions = Operation::Order::DirectionSet.coerce(directions)
+      end
+
+      # A noop for Materialized relations
+      #
+      # @example
+      #   materialized.materialize  # (Always returns self)
+      #
+      # @return [self]
+      #
+      # @api public
+      def materialize
+        self
+      end
+
+      # Test if there are no tuples
+      #
+      # @example
+      #   materialized.empty?  # => true or false
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def empty?
+        tuples.empty?
+      end
+
+      # Return the number of tuples
+      #
+      # @example
+      #   materialized.size  # => 10
+      #
+      # @return [Integer]
+      #
+      # @api public
+      def size
+        tuples.size
+      end
+
+    end # class Materialized
+  end # class Relation
+end # module Veritas

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

@@ -0,0 +1,77 @@
+module Veritas
+  class Relation
+    module Operation
+
+      # A mixin for Binary relations
+      module Binary
+        include Veritas::Operation::Binary
+
+        # Hook called when module is included
+        #
+        # @param [Module] descendant
+        #   the module or class including Binary
+        #
+        # @return [self]
+        #
+        # @api private
+        def self.included(descendant)
+          descendant.extend ClassMethods
+          self
+        end
+
+        # Initialize a Binary relation
+        #
+        # @param [Relation] left
+        # @param [Relation] right
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(left, right)
+          super
+          @header     = left.header     | right.header
+          @directions = left.directions | right.directions
+        end
+
+        module ClassMethods
+
+          # Instantiate a new Binary relation
+          #
+          # @example
+          #   binary = BinaryRelation.new(left, right)
+          #
+          # @param [Relation] left
+          # @param [Relation] right
+          #
+          # @return [Binary]
+          #
+          # @api public
+          def new(left, right)
+            assert_ordered_match(left, right)
+            super
+          end
+
+        private
+
+          # Assert that ordered and unordered relations are not mixed
+          #
+          # @param [Relation] left
+          # @param [Relation] right
+          #
+          # @return [undefined]
+          #
+          # @raise [RelationMismatchError]
+          #   raised if one relation is ordered and the other is not
+          #
+          # @api private
+          def assert_ordered_match(left, right)
+            if left.directions.empty? != right.directions.empty?
+              raise RelationMismatchError, 'both relations must be ordered or neither may be ordered'
+            end
+          end
+
+        end # module ClassMethods
+      end # module Binary
+    end # module Operation
+  end # class Relation
+end # module Veritas

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

@@ -0,0 +1,35 @@
+module Veritas
+  class Relation
+    module Operation
+
+      # A mixin for relations that combine their operands
+      module Combine
+        include Binary
+
+        # Combine tuples together and yield the joined tuple
+        #
+        # @param [Header] header
+        #   the header to use for the resulting tuples
+        # @param [Tuple] left_tuple
+        #   the left tuple to join with
+        # @param [Enumerable<Tuple>] right_tuples
+        #   the tuples to join to the left tuple
+        #
+        # @yield [tuple]
+        #
+        # @yieldparam [Tuple] tuple
+        #   each joined tuple
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def self.combine_tuples(header, left_tuple, right_tuples)
+          right_tuples.each do |right_tuple|
+            yield left_tuple.join(header, right_tuple)
+          end
+        end
+
+      end # module Combine
+    end # module Operation
+  end # class Relation
+end # module Veritas

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

@@ -0,0 +1,190 @@
+module Veritas
+  class Relation
+    module Operation
+
+      # A class representing a limited relation
+      class Limit < Relation
+        include Unary
+
+        # Instantiate a new Limit
+        #
+        # @example
+        #   limited_relation = Limit.new(operand, limit)
+        #
+        # @param [Relation] operand
+        #   the relation to limit
+        # @param [Integer] limit
+        #   the maximum number of tuples in the limited relation
+        #
+        # @return [Limit]
+        #
+        # @api public
+        def self.new(operand, limit)
+          assert_ordered_operand(operand)
+          assert_valid_limit(limit)
+          super
+        end
+
+        # Assert the operand is ordered
+        #
+        # @param [Relation] operand
+        #
+        # @return [undefined]
+        #
+        # @raise [OrderedRelationRequiredError]
+        #   raised if the operand is unordered
+        #
+        # @api private
+        def self.assert_ordered_operand(operand)
+          if operand.directions.empty?
+            raise OrderedRelationRequiredError, 'can only limit an ordered operand'
+          end
+        end
+
+        # Assert the limit is valid
+        #
+        # @param [Integer] limit
+        #
+        # @return [undefined]
+        #
+        # @raise [InvalidLimitError]
+        #   raised if the limit is less than 0
+        #
+        # @api private
+        def self.assert_valid_limit(limit)
+          if limit < 0
+            raise InvalidLimitError, "limit must be greater than or equal to 0, but was #{limit.inspect}"
+          end
+        end
+
+        private_class_method :assert_ordered_operand, :assert_valid_limit
+
+        # Initialize a Limit
+        #
+        # @param [Relation] operand
+        #   the relation to limit
+        # @param [Integer] limit
+        #   the maximum number of tuples in the limited relation
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(operand, limit)
+          super(operand)
+          @limit = limit.to_int
+        end
+
+        # Iterate over each tuple in the set
+        #
+        # @example
+        #   limited_relation = Limit.new(operand, limit)
+        #   limited_relation.each { |tuple| ... }
+        #
+        # @yield [tuple]
+        #
+        # @yieldparam [Tuple] tuple
+        #   each tuple in the set
+        #
+        # @return [self]
+        #
+        # @api public
+        def each
+          operand.each_with_index do |tuple, index|
+            break if @limit == index
+            yield tuple
+          end
+          self
+        end
+
+        # Return the limit
+        #
+        # @example
+        #   limit = limited_relation.to_i
+        #
+        # @return [Integer]
+        #
+        # @api public
+        def to_i
+          @limit
+        end
+
+        # Compare the Limit with other relation for equality
+        #
+        # @example
+        #   limited_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) &&
+          to_i.eql?(other.to_i)     &&
+          operand.eql?(other.operand)
+        end
+
+      private
+
+        module Methods
+
+          # Return a relation with n tuples
+          #
+          # @example
+          #   limited_relation = relation.take(5)
+          #
+          # @param [Integer] limit
+          #   the maximum number of tuples in the limited relation
+          #
+          # @return [Limit]
+          #
+          # @api public
+          def take(limit)
+            Limit.new(self, limit)
+          end
+
+          # Return a relation with the first n tuples
+          #
+          # @example with no limit
+          #   limited_relation = relation.first
+          #
+          # @example with a limit
+          #   limited_relation = relation.first(5)
+          #
+          # @param [Integer] limit
+          #   optional number of tuples from the beginning of the relation
+          #
+          # @return [Limit]
+          #
+          # @api public
+          def first(limit = 1)
+            take(limit)
+          end
+
+          # Return a relation with the last n tuples
+          #
+          # @example with no limit
+          #   limited_relation = relation.last
+          #
+          # @example with a limit
+          #   limited_relation = relation.last(5)
+          #
+          # @param [Integer] limit
+          #   optional number of tuples from the end of the relation
+          #
+          # @return [Limit]
+          #
+          # @api public
+          def last(limit = 1)
+            reverse.take(limit).reverse
+          end
+
+        end # module Methods
+
+        Relation.class_eval { include Methods }
+
+      end # class Limit
+    end # module Operation
+  end # class Relation
+end # module Veritas

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

@@ -0,0 +1,153 @@
+module Veritas
+  class Relation
+    module Operation
+
+      # A class representing an offset relation
+      class Offset < Relation
+        include Unary
+
+        # Instantiate a new Offset
+        #
+        # @example
+        #   offset_relation = Offset.new(operand, offset)
+        #
+        # @param [Relation] operand
+        #   the relation to offset
+        # @param [Integer] offset
+        #   the offset of the operand to drop
+        #
+        # @return [Offset]
+        #
+        # @api public
+        def self.new(operand, offset)
+          assert_ordered_operand(operand)
+          assert_valid_offset(offset)
+          super
+        end
+
+        # Assert the operand is ordered
+        #
+        # @param [Relation] operand
+        #
+        # @return [undefined]
+        #
+        # @raise [OrderedRelationRequiredError]
+        #   raised if the operand is unordered
+        #
+        # @api private
+        def self.assert_ordered_operand(operand)
+          if operand.directions.empty?
+            raise OrderedRelationRequiredError, 'can only offset an ordered operand'
+          end
+        end
+
+        # Assert the offset is valid
+        #
+        # @param [Integer] offset
+        #
+        # @return [undefined]
+        #
+        # @raise [InvalidOffsetError]
+        #   raised if the offset is less than 0
+        #
+        # @api private
+        def self.assert_valid_offset(offset)
+          if offset < 0
+            raise InvalidOffsetError, "offset must be greater than or equal to 0, but was #{offset.inspect}"
+          end
+        end
+
+        private_class_method :assert_ordered_operand, :assert_valid_offset
+
+        # Initialize an Offset
+        #
+        # @param [Relation] operand
+        #   the relation to offset
+        # @param [Integer] offset
+        #   the offset of the operand to drop
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(operand, offset)
+          super(operand)
+          @offset = offset.to_int
+        end
+
+        # Iterate over each tuple in the set
+        #
+        # @example
+        #   offset_relation = Offset.new(operand, offset)
+        #   offset_relation.each { |tuple| ... }
+        #
+        # @yield [tuple]
+        #
+        # @yieldparam [Tuple] tuple
+        #   each tuple in the set
+        #
+        # @return [self]
+        #
+        # @api public
+        def each
+          operand.each_with_index do |tuple, index|
+            yield tuple if index >= @offset
+          end
+          self
+        end
+
+        # Return the offset
+        #
+        # @example
+        #   offset = offset_relation.to_i
+        #
+        # @return [Integer]
+        #
+        # @api public
+        def to_i
+          @offset
+        end
+
+        # Compare the Offset with other relation for equality
+        #
+        # @example
+        #   offset_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) &&
+          to_i.eql?(other.to_i)     &&
+          operand.eql?(other.operand)
+        end
+
+      private
+
+        module Methods
+
+          # Return a relation with n tuples
+          #
+          # @example
+          #   offset_relation = relation.drop(5)
+          #
+          # @param [Integer] offset
+          #   the offset of the relation to drop
+          #
+          # @return [Offset]
+          #
+          # @api public
+          def drop(offset)
+            Offset.new(self, offset)
+          end
+
+        end # module Methods
+
+        Relation.class_eval { include Methods }
+
+      end # class Offset
+    end # module Operation
+  end # class Relation
+end # module Veritas