axiom 0.1.1 → 0.2.0

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

@@ -5,7 +5,7 @@ module Axiom
     module Operation
 
       # A class representing a reverse sorted relation
-      class Reverse < Order
+      class Reverse < Sorted
 
         # Instantiate a new Reverse relation
         #
@@ -18,27 +18,27 @@ module Axiom
         #
         # @api public
         def self.new(operand)
-          assert_ordered_operand(operand)
+          assert_sorted_operand(operand)
           super(operand, operand.directions.reverse)
         end
 
-        # Assert the operand is ordered
+        # Assert the operand is sorted
         #
         # @param [Relation] operand
         #
         # @return [undefined]
         #
-        # @raise [OrderedRelationRequiredError]
-        #   raise if the operand is unordered
+        # @raise [SortededRelationRequiredError]
+        #   raise 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 reverse an ordered operand'
+        def self.assert_sorted_operand(operand)
+          if operand.header.size != operand.directions.size
+            fail SortededRelationRequiredError, 'can only reverse a sorted operand'
           end
         end
 
-        private_class_method :assert_ordered_operand
+        private_class_method :assert_sorted_operand
 
         # Iterate over each tuple in the set
         #

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

@@ -68,7 +68,7 @@ module Axiom
           # @api private
           def assert_equivalent_headers(left, right)
             if left.header != right.header
-              raise InvalidHeaderError, 'the headers must be equivalent'
+              fail InvalidHeaderError, 'the headers must be equivalent'
             end
           end
 

data/lib/axiom/relation/operation/{order.rb → sorted.rb}

@@ -5,28 +5,28 @@ module Axiom
     module Operation
 
       # A class representing a sorted relation
-      class Order < Relation
+      class Sorted < Relation
         include Unary
         include Equalizer.new(:operand, :directions)
 
         # The relation sort order
         #
-        # @return [Operation::Order::DirectionSet]
+        # @return [Operation::Sorted::DirectionSet]
         #
         # @api private
         attr_reader :directions
 
-        # Instantiate a new Order
+        # Instantiate a new Sorted
         #
         # @example
-        #   order = Order.new(operand, directions)
+        #   sorted = Sorted.new(operand, directions)
         #
         # @param [Relation] operand
         #   the relation to sort
         # @param [DirectionSet, Header, Array<Direction, Attribute>] directions
         #   the directions to sort tuples in
         #
-        # @return [Order]
+        # @return [Sorted]
         #
         # @api public
         def self.new(operand, directions)
@@ -34,11 +34,12 @@ module Axiom
           directions = DirectionSet.coerce(directions) do |direction|
             header[direction] unless direction.kind_of?(Direction)
           end
-          directions |= header - directions.attributes
+          new_directions = directions | header - directions.attributes
+          directions     = new_directions if new_directions != directions
           super
         end
 
-        # Initialize an Order
+        # Initialize an Sorted
         #
         # @param [Relation] operand
         #   the relation to sort
@@ -56,8 +57,8 @@ module Axiom
         # Iterate over each tuple in the set
         #
         # @example
-        #   order = Order.new(operand, directions)
-        #   order.each { |tuple| ... }
+        #   sorted = Sorted.new(operand, directions)
+        #   sorted.each { |tuple| ... }
         #
         # @yield [tuple]
         #
@@ -73,14 +74,14 @@ module Axiom
           self
         end
 
-        # Insert a relation into the Order
+        # Insert a relation into the Sorted
         #
         # @example
-        #   new_relation = order.insert(other)
+        #   new_relation = sorted.insert(other)
         #
         # @param [Relation] other
         #
-        # @return [Order]
+        # @return [Sorted]
         #
         # @api public
         def insert(other)
@@ -88,14 +89,14 @@ module Axiom
           operand.insert(other.operand).sort_by(directions)
         end
 
-        # Delete a relation from the Order
+        # Delete a relation from the Sorted
         #
         # @example
-        #   new_relation = order.delete(other)
+        #   new_relation = sorted.delete(other)
         #
         # @param [Relation] other
         #
-        # @return [Order]
+        # @return [Sorted]
         #
         # @api public
         def delete(other)
@@ -113,25 +114,25 @@ module Axiom
         #
         # @return [undefined]
         #
-        # @raise [OrderMismatchError]
+        # @raise [SortedMismatchError]
         #   raised when inserting a relation does not have matching directions
         #
         # @api private
         def assert_matching_directions(other, event)
-          unless other.kind_of?(self.class) && directions.eql?(other.directions)
-            raise OrderMismatchError, "other relation must have matching directions to be #{event}"
+          unless other.respond_to?(:directions) && directions.eql?(other.directions)
+            fail SortedMismatchError, "other relation must have matching directions to be #{event}"
           end
         end
 
         module Methods
 
-          # Return an ordered relation
+          # Return a sorted relation
           #
           # @example with a block
-          #   order = relation.sort_by { |r| [r.a.desc, r.b] }
+          #   sorted = relation.sort_by { |r| [r.a.desc, r.b] }
           #
           # @example with directions
-          #   order = relation.sort_by(directions)
+          #   sorted = relation.sort_by(directions)
           #
           # @param [Array] args
           #   optional arguments
@@ -143,23 +144,23 @@ module Axiom
           #
           # @yieldreturn [DirectionSet, Array<Direction>, Header]
           #
-          # @return [Order]
+          # @return [Sorted]
           #
           # @api public
           def sort_by(*args, &block)
-            Order.new(self, coerce_to_directions(*args, &block))
+            Sorted.new(self, coerce_to_directions(*args, &block))
           end
 
-          # Return an ordered relation
+          # Return a sorted relation
           #
           # @example
-          #   order = relation.sort
+          #   sorted = relation.sort
           #
-          # @return [Order]
+          # @return [Sorted]
           #
           # @api public
           def sort
-            Order.new(self, EMPTY_ARRAY)
+            Sorted.new(self, nil)
           end
 
         private
@@ -191,7 +192,7 @@ module Axiom
 
         Relation.class_eval { include Methods }
 
-      end # class Order
+      end # class Sorted
     end # module Operation
   end # class Relation
 end # module Axiom

data/lib/axiom/relation/operation/{order → sorted}/direction.rb

@@ -3,7 +3,7 @@
 module Axiom
   class Relation
     module Operation
-      class Order
+      class Sorted
 
         # Abstract base class for attribute sorting
         class Direction
@@ -139,7 +139,7 @@ module Axiom
           #
           # @api private
           def self.call(left, right)
-            left <=> right
+            left <=> right || (1 if left.nil?) || (-1 if right.nil?)
           end
 
         end # class Ascending
@@ -172,11 +172,11 @@ module Axiom
           #
           # @api private
           def self.call(left, right)
-            right <=> left
+            right <=> left || (1 if right.nil?) || (-1 if left.nil?)
           end
 
         end # class Descending
-      end # class Order
+      end # class Sorted
     end # module Operation
   end # class Relation
 end # module Axiom

data/lib/axiom/relation/operation/{order → sorted}/direction_set.rb

@@ -3,7 +3,7 @@
 module Axiom
   class Relation
     module Operation
-      class Order
+      class Sorted
 
         # A class that represents a tuple sort order for a set of attributes
         class DirectionSet < Header
@@ -90,7 +90,7 @@ module Axiom
           # @api private
           def cmp_tuples(left, right)
             reduce(0) do |cmp, direction|
-              break cmp if cmp.nonzero?
+              return cmp if cmp.nonzero?
               direction.call(left, right)
             end
           end
@@ -101,7 +101,7 @@ module Axiom
           EMPTY = new
 
         end # class DirectionSet
-      end # class Order
+      end # class Sorted
     end # module Operation
   end # class Relation
 end # module Axiom

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

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+module Axiom
+  class Relation
+    module Operation
+
+      # A class representing an ungrouped relation
+      class Ungroup < Relation
+        include Unary
+        include Equalizer.new(:operand, :attribute)
+
+        # The grouped attribute
+        #
+        # @return [Attribute::Relation]
+        #
+        # @api private
+        attr_reader :attribute
+
+        # Initialize an ungrouped relation
+        #
+        # @param [Relation] operand
+        # @param [#to_sym] name
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(operand, name)
+          super(operand)
+          @attribute = header[name]
+          @outer     = header - [attribute]
+          @header    = @outer.extend(attribute.header)
+        end
+
+        # Iterate over each tuple in the set
+        #
+        # @example
+        #   ungrouped = Ungroup.new(operand, name)
+        #   ungrouped.each { |tuple| ... }
+        #
+        # @yield [tuple]
+        #
+        # @yieldparam [Tuple] tuple
+        #   each tuple in the set
+        #
+        # @return [self]
+        #
+        # @api public
+        def each
+          return to_enum unless block_given?
+          operand.each do |tuple|
+            outer_tuple = tuple.project(@outer)
+            tuple[attribute].each do |inner_tuple|
+              yield outer_tuple.join(header, inner_tuple)
+            end
+          end
+          self
+        end
+
+        module Methods
+
+          # Return an ungrouped relation
+          #
+          # @example
+          #   ungrouped = relation.ungroup(:location, :names)
+          #
+          # @param [Enumerable<#to_sym>] names
+          #
+          # @return [Ungroup]
+          #
+          # @api public
+          def ungroup(*names)
+            names.reduce(self, &Ungroup.method(:new))
+          end
+
+        end # module Methods
+
+        Relation.class_eval { include Methods }
+
+      end # class Ungroup
+    end # module Operation
+  end # class Relation
+end # module Axiom

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

@@ -0,0 +1,80 @@
+# encoding: utf-8
+
+module Axiom
+  class Relation
+    module Operation
+
+      # A class representing a unwrapped relation
+      class Unwrap < Relation
+        include Unary
+        include Equalizer.new(:operand, :attribute)
+
+        # The unwrapped attribute
+        #
+        # @return [Attribute::Relation]
+        #
+        # @api private
+        attr_reader :attribute
+
+        # Initialize a unwrapped relation
+        #
+        # @param [Relation] operand
+        # @param [#to_sym] name
+        # @param [Enumerable<Axiom::Attribute>] attributes
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(operand, name)
+          super(operand)
+          @attribute = header[name]
+          @outer     = header - [attribute]
+          @header    = @outer.extend(attribute.header)
+        end
+
+        # Iterate over each tuple in the set
+        #
+        # @example
+        #   unwrapped = Unwrap.new(left, right)
+        #   unwrapped.each { |tuple| ... }
+        #
+        # @yield [tuple]
+        #
+        # @yieldparam [Tuple] tuple
+        #   each tuple in the set
+        #
+        # @return [self]
+        #
+        # @api public
+        def each
+          return to_enum unless block_given?
+          operand.each do |tuple|
+            yield tuple.project(@outer).join(header, tuple[attribute])
+          end
+          self
+        end
+
+        module Methods
+
+          # Return a unwrapped relation
+          #
+          # @example
+          #   unwrapped = relation.unwrap(:location, :names)
+          #
+          # @param [Enumerable<#to_sym>] names
+          #
+          # @return [Unwrap]
+          #
+          # @api public
+          def unwrap(*names)
+            names.reduce(self, &Unwrap.method(:new))
+          end
+
+        end # module Methods
+
+        Relation.class_eval { include Methods }
+
+      end # class Unwrap
+    end # module Operation
+  end # class Relation
+end # module Axiom

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

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+module Axiom
+  class Relation
+    module Operation
+
+      # A class representing a wrapped relation
+      class Wrap < Relation
+        include Unary
+        include Equalizer.new(:operand, :attribute)
+
+        # The wrapped attribute
+        #
+        # @return [Attribute::Relation]
+        #
+        # @api private
+        attr_reader :attribute
+
+        # Initialize a wrapped 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::Tuple.new(name, header: inner)
+          @header    = @outer.extend(attribute)
+        end
+
+        # Iterate over each tuple in the set
+        #
+        # @example
+        #   wrapped = Wrap.new(operand, name attributes)
+        #   wrapped.each { |tuple| ... }
+        #
+        # @yield [tuple]
+        #
+        # @yieldparam [Tuple] tuple
+        #   each tuple in the set
+        #
+        # @return [self]
+        #
+        # @api public
+        def each
+          return to_enum unless block_given?
+          operand.each do |tuple|
+            outer_tuple = tuple.project(@outer)
+            inner_tuple = tuple.project(attribute.header)
+            yield outer_tuple.extend(header, [inner_tuple])
+          end
+          self
+        end
+
+        module Methods
+
+          # Return a wrapped relation
+          #
+          # @example
+          #   wrapped = relation.wrap(location: [:latitude, :longitude])
+          #
+          # @param [Hash{#to_sym => Enumerable<Axiom::Attribute>] wrapping
+          #
+          # @return [Wrap]
+          #
+          # @api public
+          def wrap(wrapping)
+            wrapping.reduce(self) do |operation, pair|
+              Wrap.new(operation, *pair)
+            end
+          end
+
+        end # module Methods
+
+        Relation.class_eval { include Methods }
+
+      end # class Wrap
+    end # module Operation
+  end # class Relation
+end # module Axiom