axiom 0.1.0

data/lib/axiom/relation/operation/order/direction_set.rb

@@ -0,0 +1,107 @@
+# encoding: utf-8
+
+module Axiom
+  class Relation
+    module Operation
+      class Order
+
+        # A class that represents a tuple sort order for a set of attributes
+        class DirectionSet < Header
+          include Equalizer.new(:to_ary)
+
+          # Coerce the attribute into a Direction
+          #
+          # @param [Object] attribute
+          #
+          # @return [Direction]
+          #
+          # @api private
+          def self.coerce_attribute(attribute)
+            Ascending.coerce(attribute)
+          end
+
+          private_class_method :coerce_attribute
+
+          # Rename the contained attributes with the provided aliases
+          #
+          # @example
+          #   renamed = directions.rename(aliases)
+          #
+          # @param [Algebra::Rename::Aliases] aliases
+          #   the old and new attributes
+          #
+          # @return [DirectionSet]
+          #
+          # @api public
+          def rename(aliases)
+            new(map { |direction| direction.rename(aliases) })
+          end
+
+          # Reverse the directions for each attribute
+          #
+          # @example
+          #   reversed = directions.reverse
+          #
+          # @return [DirectionSet]
+          #
+          # @api public
+          def reverse
+            new(map(&:reverse))
+          end
+
+          # Return each attribute in an Array
+          #
+          # @return [Array]
+          #
+          # @api private
+          def attributes
+            map(&:attribute)
+          end
+
+          # Sort the supplied tuples in the correct direction
+          #
+          # @param [Array] tuples
+          #   the list of tuples to sort
+          #
+          # @return [Array]
+          #   the sorted tuples
+          #
+          # @api private
+          def sort_tuples(tuples)
+            tuples.sort { |left, right| cmp_tuples(left, right) }
+          end
+
+        private
+
+          # Compare the attributes for each Tuple
+          #
+          # @param [Tuple] left
+          # @param [Tuple] right
+          #
+          # @return [-1]
+          #   returned if the left should be sorted before the right
+          #
+          # @return [0]
+          #   returned if the left and right are equal
+          #
+          # @return [1]
+          #   returned if the left should be sorted after the right
+          #
+          # @api private
+          def cmp_tuples(left, right)
+            reduce(0) do |cmp, direction|
+              break cmp if cmp.nonzero?
+              direction.call(left, right)
+            end
+          end
+
+          memoize :reverse, :attributes
+
+          # Represent an empty set of directions
+          EMPTY = new
+
+        end # class DirectionSet
+      end # class Order
+    end # module Operation
+  end # class Relation
+end # module Axiom

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

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+module Axiom
+  class Relation
+    module Operation
+
+      # A class representing a reverse sorted relation
+      class Reverse < Order
+
+        # Instantiate a new Reverse relation
+        #
+        # @example
+        #   reverse = Reverse.new(operand)
+        #
+        # @param [Relation] operand
+        #
+        # @return [Reverse]
+        #
+        # @api public
+        def self.new(operand)
+          assert_ordered_operand(operand)
+          super(operand, operand.directions.reverse)
+        end
+
+        # Assert the operand is ordered
+        #
+        # @param [Relation] operand
+        #
+        # @return [undefined]
+        #
+        # @raise [OrderedRelationRequiredError]
+        #   raise if the operand is unordered
+        #
+        # @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'
+          end
+        end
+
+        private_class_method :assert_ordered_operand
+
+        # Iterate over each tuple in the set
+        #
+        # @example
+        #   reverse = Reverse.new(operand)
+        #   reverse.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.reverse_each { |tuple| yield tuple }
+          self
+        end
+
+        module Methods
+
+          # Return the reversed relation
+          #
+          # @example
+          #   reverse = relation.reverse
+          #
+          # @param [Relation] other
+          #
+          # @return [Reverse]
+          #
+          # @api public
+          def reverse
+            Reverse.new(self)
+          end
+
+        end # module Methods
+
+        Relation.class_eval { include Methods }
+
+      end # class Limit
+    end # module Operation
+  end # class Relation
+end # module Axiom

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

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+module Axiom
+  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 [undefined]
+        #
+        # @api private
+        def self.included(descendant)
+          super
+          descendant.extend(ClassMethods)
+        end
+
+        private_class_method :included
+
+        # 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 [Array(Relation, Relation)] args
+          #
+          # @return [Set]
+          #
+          # @api public
+          def new(*args)
+            assert_equivalent_headers(*args)
+            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'
+            end
+          end
+
+        end # module ClassMethods
+      end # module Set
+    end # module Operation
+  end # class Relation
+end # module Axiom

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

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module Axiom
+  class Relation
+    module Operation
+
+      # A mixin for Unary relations
+      module Unary
+        include Axiom::Operation::Unary
+
+        # Initialize a Unary relation
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(*)
+          super
+          @header = operand.header
+        end
+
+      end # module Unary
+    end # module Operation
+  end # class Relation
+end # module Axiom

data/lib/axiom/relation/proxy.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+module Axiom
+  class Relation
+
+    # Allow relations to proxy to other relations
+    module Proxy
+      include Equalizer.new(:relation)
+
+      # Relation methods to proxy
+      ENUMERABLE_METHODS = Enumerable.public_instance_methods.map(&:to_s).freeze
+      PROXY_METHODS      = %w[ header each empty? ].freeze
+      RELATION_METHODS   = %w[ take drop sort_by join ].freeze  # TODO: remove join when Enumerable#join removed from JRuby 1.7+
+
+      # Hook called when module is included
+      #
+      # @param [Module] descendant
+      #   the module or class including RelationProxy
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def self.included(descendant)
+        descendant.class_eval do
+          undef_method(*PROXY_METHODS | ENUMERABLE_METHODS - RELATION_METHODS)
+        end
+      end
+
+      private_class_method :included
+
+      # The relation that is proxied to
+      #
+      # @return [Relation]
+      #
+      # @api private
+      attr_reader :relation
+      protected :relation
+
+      # Test if the method is supported on this object
+      #
+      # @param [Symbol] method
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def respond_to?(method, *)
+        super || forwardable?(method)
+      end
+
+    private
+
+      # Forward the message to the relation
+      #
+      # @param [Array] args
+      #
+      # @return [self]
+      #   return self for all command methods
+      # @return [Object]
+      #   return response from all query methods
+      #
+      # @api private
+      def method_missing(*args, &block)
+        response = relation.public_send(*args, &block)
+        if response.equal?(relation)
+          self
+        else
+          response
+        end
+      end
+
+      # Test if the method can be forwarded to the relation
+      #
+      # @param [Symbol] method
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def forwardable?(method)
+        relation.respond_to?(method)
+      end
+
+    end # module Proxy
+  end # class Relation
+end # module Axiom

data/lib/axiom/support/aliasable.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+module Axiom
+
+  # 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 { |methods| define_inheritable_alias_method(*methods) }
+      self
+    end
+
+  private
+
+    # Create a new method alias for the original method
+    #
+    # @param [Symbol] new_method
+    #
+    # @param [Symbol] original_method
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def define_inheritable_alias_method(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
+
+  end # module Aliasable
+end # module Axiom

data/lib/axiom/support/equalizer.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Axiom
+
+  # Define equality, equivalence and inspection methods
+  class Equalizer < ::Equalizer
+
+    # Include the #eql? and #== methods
+    #
+    # @return [undefined]
+    #
+    # @api private
+    def initialize(*)
+      super
+      module_eval do
+        include Adamantium
+        memoize :hash
+      end
+    end
+
+  end # class Equalizer
+end # module Axiom