axiom 0.1.1 → 0.2.0

data/lib/axiom/relation/index.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+module Axiom
+  class Relation
+
+    # Tuples keyed by a tuple
+    class Index
+
+      # Initialize an index
+      #
+      # @param [Header] key
+      # @param [Header] header
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(key, header)
+        @key    = key
+        @header = header
+        @index  = Hash.new { |hash, tuple| hash[tuple] = Set.new }
+      end
+
+      # Add a set of tuples to the index
+      #
+      # @example
+      #   index.merge(tuples)
+      #
+      # @param [Enumerable<Tuple>] tuples
+      #
+      # @return [Index]
+      #
+      # @api public
+      def merge(tuples)
+        tuples.each(&method(:<<))
+        self
+      end
+
+      # Add a tuple to the index
+      #
+      # @example
+      #   index << tuple
+      #
+      # @param [Tuple]
+      #
+      # @return [Index]
+      #
+      # @api public
+      def <<(tuple)
+        self[tuple] << tuple.project(@header)
+        self
+      end
+
+      # Iterate over each entry in the index
+      #
+      # @example
+      #   index = Index.new(key_header, tuple_header)
+      #   index.each { |key, tuples| ... }
+      #
+      # @yield [key, tuples]
+      #
+      # @yieldparam [Tuple] key
+      #   the key for the tuples
+      # @yieldparam [Set<Tuple>] tuples
+      #   the indexed tuples
+      #
+      # @return [Index]
+      #
+      # @api public
+      def each(&block)
+        return to_enum unless block_given?
+        @index.each(&block)
+        self
+      end
+
+      # Return the tuples in the index based on the tuple key
+      #
+      # @example
+      #   index[tuple]  # => tuples
+      #
+      # @param [Tuple] tuple
+      #
+      # @return [Set<Tuple>]
+      #
+      # @api public
+      def [](tuple)
+        @index[tuple.project(@key)]
+      end
+
+    end # class Index
+  end # class Relation
+end # module Axiom

data/lib/axiom/relation/keys.rb

@@ -31,7 +31,7 @@ module Axiom
         if object.kind_of?(self)
           object
         else
-          block ||= ->(attributes) { coerce_attributes(attributes) }
+          block ||= method(:coerce_attributes)
           new(object.map(&block))
         end
       end
@@ -80,7 +80,7 @@ module Axiom
       def self.assert_irreducible_keys(keys)
         reducible_keys = reducible_keys(keys)
         if reducible_keys
-          raise ReducibleKeyError, "reducible keys: #{reducible_keys.inspect}"
+          fail ReducibleKeyError, "reducible keys: #{reducible_keys}"
         end
       end
 
@@ -109,7 +109,7 @@ module Axiom
       #
       # @api public
       def initialize(keys)
-        @keys = freeze_object(keys)
+        @keys = self.class.freezer.call(keys)
       end
 
       # Iterate over each key in the Keys

data/lib/axiom/relation/materialized.rb

@@ -9,26 +9,70 @@ module Axiom
 
       # The relation sort order
       #
-      # @return [Operation::Order::DirectionSet]
+      # @return [Operation::Sorted::DirectionSet]
       #
       # @api private
       attr_reader :directions
 
+      # Instantiate a materialized Relation
+      #
+      # @example of a materialized Array based relation
+      #   array    = [[1], [2], [3]]
+      #   relation = Relation::Materialized.new([[:id, Integer]], array)
+      #
+      # @example of a materialized Set based relation
+      #   set      = Set[[1], [2], [3]]
+      #   relation = Relation::Materialized.new([[:id, Integer]], set)
+      #
+      # @example of a materialized empty relation
+      #   relation = Relation::Materialized.new([[:id, Integer]])
+      #
+      # @param [Array(Header, Enumerable)] args
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def self.new(*args)
+        if equal?(Materialized) && empty?(args[1])
+          Empty.new(args.first)
+        else
+          super
+        end
+      end
+
+      # Test if the tuples are empty
+      #
+      # When tuples are nil, it means there are no tuples so it is the equivalent
+      # of specifying [] for the tuples.
+      #
+      # @param [nil, #size] tuples
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def self.empty?(tuples)
+        tuples.nil? || begin
+          size = tuples.size
+          size && size.zero?
+        end
+      end
+      private_class_method :empty?
+
       # Initialize a materialized Relation
       #
       # @param [Header, #to_ary] header
       #   the relation header
       # @param [Enumerable] tuples
       #   the relation tuples
-      # @param [Operation::Order::DirectionSet] directions
+      # @param [Operation::Sorted::DirectionSet] directions
       #   optional directions to sort the relation by
       #
       # @return [undefined]
       #
       # @api private
-      def initialize(header, tuples = ZERO_TUPLE, directions = Operation::Order::DirectionSet::EMPTY)
+      def initialize(header, tuples, directions = Operation::Sorted::DirectionSet::EMPTY)
         super(header, tuples)
-        @directions = Operation::Order::DirectionSet.coerce(directions)
+        @directions = Operation::Sorted::DirectionSet.coerce(directions)
       end
 
       # A noop for Materialized relations

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

@@ -47,13 +47,13 @@ module Axiom
           #
           # @api public
           def new(left, right)
-            assert_ordered_match(left, right)
+            assert_sorted_match(left, right)
             super
           end
 
         private
 
-          # Assert that ordered and unordered relations are not mixed
+          # Assert that sorted and unsorted relations are not mixed
           #
           # @param [Relation] left
           # @param [Relation] right
@@ -61,12 +61,12 @@ module Axiom
           # @return [undefined]
           #
           # @raise [RelationMismatchError]
-          #   raised if one relation is ordered and the other is not
+          #   raised if one relation is sorted and the other is not
           #
           # @api private
-          def assert_ordered_match(left, right)
+          def assert_sorted_match(left, right)
             if left.directions.empty? != right.directions.empty?
-              raise RelationMismatchError, 'both relations must be ordered or neither may be ordered'
+              fail RelationMismatchError, 'both relations must be sorted or neither may be sorted'
             end
           end
 

data/lib/axiom/relation/operation/group.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+
+module Axiom
+  class Relation
+    module Operation
+
+      # A class representing a grouped relation
+      class Group < Relation
+        include Unary
+        include Equalizer.new(:operand, :attribute)
+
+        # The grouped attribute
+        #
+        # @return [Attribute::Relation]
+        #
+        # @api private
+        attr_reader :attribute
+
+        # Initialize a grouped relation
+        #
+        # @param [Relation] operand
+        # @param [#to_sym] name
+        # @param [Enumerable<Axiom::Attribute>] attributes
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(operand, name, attributes)
+          super(operand)
+          inner      = header.project(attributes)
+          @outer     = header - inner
+          @attribute = Attribute::Relation.new(name, header: inner)
+          @header    = @outer.extend(attribute)
+        end
+
+        # Iterate over each tuple in the set
+        #
+        # @example
+        #   grouped = Group.new(operand, name, attributes)
+        #   grouped.each { |tuple| ... }
+        #
+        # @yield [tuple]
+        #
+        # @yieldparam [Tuple] tuple
+        #   each tuple in the set
+        #
+        # @return [self]
+        #
+        # @api public
+        def each
+          return to_enum unless block_given?
+          build_index.each do |outer_tuple, inner_tuples|
+            inner_relation = attribute.new_relation(inner_tuples)
+            yield outer_tuple.extend(header, [inner_relation])
+          end
+          self
+        end
+
+      private
+
+        # Build an index using every tuple in the operand
+        #
+        # @return [Index]
+        #
+        # @api private
+        def build_index
+          Index.new(@outer, @attribute.header).merge(operand)
+        end
+
+        module Methods
+
+          # Return a grouped relation
+          #
+          # @example
+          #   grouped = relation.group(location: [:latitude, :longitude])
+          #
+          # @param [Hash{#to_sym => Enumerable<Axiom::Attribute>] grouping
+          #
+          # @return [Group]
+          #
+          # @api public
+          def group(grouping)
+            grouping.reduce(self) do |operation, pair|
+              Group.new(operation, *pair)
+            end
+          end
+
+        end # module Methods
+
+        Relation.class_eval { include Methods }
+
+      end # class Group
+    end # module Operation
+  end # class Relation
+end # module Axiom

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

@@ -21,7 +21,7 @@ module Axiom
 
         # The relation sort order
         #
-        # @return [Operation::Order::DirectionSet]
+        # @return [Operation::Sorted::DirectionSet]
         #
         # @api private
         attr_reader :directions
@@ -40,24 +40,24 @@ module Axiom
         #
         # @api public
         def self.new(operand, limit)
-          assert_ordered_operand(operand)
+          assert_sorted_operand(operand)
           assert_valid_limit(limit)
           super
         end
 
-        # Assert the operand is ordered
+        # Assert the operand is sorted
         #
         # @param [Relation] operand
         #
         # @return [undefined]
         #
-        # @raise [OrderedRelationRequiredError]
-        #   raised if the operand is unordered
+        # @raise [SortededRelationRequiredError]
+        #   raised if the operand is unsorted
         #
         # @api private
-        def self.assert_ordered_operand(operand)
-          if operand.header.to_ary.size != operand.directions.to_ary.size
-            raise OrderedRelationRequiredError, 'can only limit an ordered operand'
+        def self.assert_sorted_operand(operand)
+          if operand.header.size != operand.directions.size
+            fail SortededRelationRequiredError, 'can only limit a sorted operand'
           end
         end
 
@@ -73,11 +73,11 @@ module Axiom
         # @api private
         def self.assert_valid_limit(limit)
           if limit.nil? || limit < 0
-            raise InvalidLimitError, "limit must be greater than or equal to 0, but was #{limit.inspect}"
+            fail 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
+        private_class_method :assert_sorted_operand, :assert_valid_limit
 
         # Initialize a Limit
         #
@@ -130,7 +130,7 @@ module Axiom
         #
         # @api public
         def insert(*)
-          raise ImmutableRelationError, 'inserting into a limit is impossible'
+          fail ImmutableRelationError, 'inserting into a limit is impossible'
         end
 
         # Raise an exception when deleting from the Limit
@@ -145,13 +145,13 @@ module Axiom
         #
         # @api public
         def delete(*)
-          raise ImmutableRelationError, 'deleting from a limit is impossible'
+          fail ImmutableRelationError, 'deleting from a limit is impossible'
         end
 
         module Methods
 
           # Default block used in #one
-          DEFAULT_ONE_BLOCK = -> { }
+          DEFAULT_ONE_BLOCK = -> {}
 
           # Maximum number of tuples to take in #one
           ONE_LIMIT = 2
@@ -230,7 +230,7 @@ module Axiom
             tuples = take(ONE_LIMIT).to_a
             assert_no_more_than_one_tuple(tuples.size)
             tuples.first or block.yield or
-              raise NoTuplesError, 'one tuple expected, but was an empty set'
+              fail NoTuplesError, 'one tuple expected, but was an empty set'
           end
 
         private
@@ -245,7 +245,7 @@ module Axiom
           # @api private
           def assert_no_more_than_one_tuple(size)
             if size > 1
-              raise(
+              fail(
                 ManyTuplesError,
                 "one tuple expected, but set contained #{count} tuples"
               )

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

@@ -21,7 +21,7 @@ module Axiom
 
         # The relation sort order
         #
-        # @return [Operation::Order::DirectionSet]
+        # @return [Operation::Sorted::DirectionSet]
         #
         # @api private
         attr_reader :directions
@@ -40,24 +40,24 @@ module Axiom
         #
         # @api public
         def self.new(operand, offset)
-          assert_ordered_operand(operand)
+          assert_sorted_operand(operand)
           assert_valid_offset(offset)
           super
         end
 
-        # Assert the operand is ordered
+        # Assert the operand is sorted
         #
         # @param [Relation] operand
         #
         # @return [undefined]
         #
-        # @raise [OrderedRelationRequiredError]
-        #   raised if the operand is unordered
+        # @raise [SortededRelationRequiredError]
+        #   raised if the operand is unsorted
         #
         # @api private
-        def self.assert_ordered_operand(operand)
-          if operand.header.to_ary.size != operand.directions.to_ary.size
-            raise OrderedRelationRequiredError, 'can only offset an ordered operand'
+        def self.assert_sorted_operand(operand)
+          if operand.header.size != operand.directions.size
+            fail SortededRelationRequiredError, 'can only offset a sorted operand'
           end
         end
 
@@ -73,11 +73,11 @@ module Axiom
         # @api private
         def self.assert_valid_offset(offset)
           if offset.nil? || offset < 0
-            raise InvalidOffsetError, "offset must be greater than or equal to 0, but was #{offset.inspect}"
+            fail 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
+        private_class_method :assert_sorted_operand, :assert_valid_offset
 
         # Initialize an Offset
         #
@@ -129,7 +129,7 @@ module Axiom
         #
         # @api public
         def insert(*)
-          raise ImmutableRelationError, 'inserting into an offset is impossible'
+          fail ImmutableRelationError, 'inserting into an offset is impossible'
         end
 
         # Raise an exception when deleting from the Offset
@@ -144,7 +144,7 @@ module Axiom
         #
         # @api public
         def delete(*)
-          raise ImmutableRelationError, 'deleting from an offset is impossible'
+          fail ImmutableRelationError, 'deleting from an offset is impossible'
         end
 
         module Methods