axiom 0.1.0

data/lib/axiom/algebra/product.rb

@@ -0,0 +1,124 @@
+# encoding: utf-8
+
+module Axiom
+  module Algebra
+
+    # The cartesian product between relations
+    class Product < Relation
+      include Relation::Operation::Combination
+
+      # Instantiate a new Product
+      #
+      # @example
+      #   product = Product.new(left, right)
+      #
+      # @param [Relation] left
+      # @param [Relation] right
+      #
+      # @return [Join]
+      #
+      # @api public
+      def self.new(left, right)
+        assert_disjointed_headers(left, right)
+        super
+      end
+
+      # Assert the headers do not have common attributes
+      #
+      # @param [Relation] left
+      # @param [Relation] right
+      #
+      # @return [undefined]
+      #
+      # @raise [InvalidHeaderError]
+      #   raised if there are common attributes between the headers
+      #
+      # @api private
+      def self.assert_disjointed_headers(left, right)
+        if (left.header & right.header).any?
+          raise InvalidHeaderError, 'the headers must be disjointed'
+        end
+      end
+
+      private_class_method :assert_disjointed_headers
+
+      # Iterate over each tuple in the set
+      #
+      # @example
+      #   product = Product.new(left, right)
+      #   product.each { |tuple| ... }
+      #
+      # @yield [tuple]
+      #
+      # @yieldparam [Tuple] tuple
+      #   each tuple in the set
+      #
+      # @return [self]
+      #
+      # @api public
+      def each(&block)
+        return to_enum unless block_given?
+        util = Relation::Operation::Combination
+        left.each do |left_tuple|
+          util.combine_tuples(header, left_tuple, right, &block)
+        end
+        self
+      end
+
+      # Raise an exception when inserting into the Product
+      #
+      # @example
+      #   product.insert(other)  # => ImmutableRelationError raised
+      #
+      # @return [undefined]
+      #
+      # @raise [ImmutableRelationError]
+      #   raised when inserting into the product
+      #
+      # @api public
+      def insert(*)
+        raise ImmutableRelationError, 'inserting into a product is impossible'
+      end
+
+      # Raise an exception when deleting from the Product
+      #
+      # @example
+      #   product.delete(other)  # => ImmutableRelationError raised
+      #
+      # @return [undefined]
+      #
+      # @raise [ImmutableRelationError]
+      #   raised when deleting from the product
+      #
+      # @api public
+      def delete(*)
+        raise ImmutableRelationError, 'deleting from a product is impossible'
+      end
+
+      module Methods
+        extend Aliasable
+
+        inheritable_alias(:* => :product)
+
+        # Return a relation that is the cartesian product of two relations
+        #
+        # @example
+        #   product = relation.product(other)
+        #
+        # @param [Relation] other
+        #   the other relation to find the product with
+        #
+        # @return [Product]
+        #
+        # @api public
+        def product(other)
+          Product.new(self, other)
+        end
+
+      end # module Methods
+
+      Relation.class_eval { include Methods }
+
+    end # class Product
+  end # module Algebra
+end # module Axiom

data/lib/axiom/algebra/projection.rb

@@ -0,0 +1,196 @@
+# encoding: utf-8
+
+module Axiom
+  module Algebra
+
+    # Specify only specific attributes to keep in the relation
+    class Projection < Relation
+      include Relation::Operation::Unary
+      include Equalizer.new(:operand, :header)
+
+      # Initialize a Projection
+      #
+      # @param [Relation] operand
+      #   the relation to project
+      # @param [#to_ary] attributes
+      #   the attributes to keep in the header
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(operand, attributes)
+        super(operand)
+        @header = @header.project(attributes)
+      end
+
+      # Iterate over each tuple in the set
+      #
+      # @example
+      #   projection = Projection.new(operand, attributes)
+      #   projection.each { |tuple| ... }
+      #
+      # @yield [tuple]
+      #
+      # @yieldparam [Tuple] tuple
+      #   each tuple in the set
+      #
+      # @return [self]
+      #
+      # @api public
+      def each
+        return to_enum unless block_given?
+        seen = Hash.new
+        operand.each do |tuple|
+          tuple = tuple.project(header)
+          yield seen[tuple] = tuple unless seen.key?(tuple)
+        end
+        self
+      end
+
+      # Insert a relation into the Projection
+      #
+      # @example
+      #   new_relation = projection.insert(other)
+      #
+      # @param [Relation] other
+      #
+      # @return [Projection]
+      #
+      # @raise [RequiredAttributesError]
+      #   raised when inserting into a relation with required attributes removed
+      #
+      # @raise [InvalidHeaderError]
+      #   raised if the headers are not equivalent
+      #
+      # @api public
+      def insert(other)
+        other = coerce(other)
+        assert_removed_attributes_optional
+        assert_equivalent_headers(other)
+        operand.insert(extend_other(other)).project(header)
+      end
+
+      # Delete a relation from the Projection
+      #
+      # @example
+      #   new_relation = projection.delete(other)
+      #
+      # @param [Relation] other
+      #
+      # @return [Projection]
+      #
+      # @raise [InvalidHeaderError]
+      #   raised if the headers are not equivalent
+      #
+      # @api public
+      def delete(other)
+        other = coerce(other)
+        assert_equivalent_headers(other)
+        operand.delete(extend_other(other)).project(header)
+      end
+
+    private
+
+      # Assert that removed attributes are optional
+      #
+      # @return [undefined]
+      #
+      # @raise [RequiredAttributesError]
+      #   raised when inserting into a relation with required attributes removed
+      #
+      # @api private
+      def assert_removed_attributes_optional
+        names = required_attribute_names
+        if names.any?
+          raise RequiredAttributesError, "required attributes #{names.inspect} have been removed"
+        end
+      end
+
+      # Assert that other relation header is equivalent
+      #
+      # @param [Relation] other
+      #
+      # @return [undefined]
+      #
+      # @raise [InvalidHeaderError]
+      #   raised if the headers are not equivalent
+      #
+      # @api private
+      def assert_equivalent_headers(other)
+        if header != other.header
+          raise InvalidHeaderError, 'the headers must be equivalent'
+        end
+      end
+
+      # Names of the required attributes that were removed
+      #
+      # @return [Array<Symbol>]
+      #
+      # @api private
+      def required_attribute_names
+        removed_attributes.each_with_object([]) do |attribute, names|
+          names << attribute.name if attribute.required?
+        end
+      end
+
+      # Attributes that were removed by the projection
+      #
+      # @return [Array<Attribute>]
+      #
+      # @api private
+      def removed_attributes
+        operand.header - header
+      end
+
+      # Extend the other relation with removed attributes
+      #
+      # @param [Relation] other
+      #
+      # @return [Extension]
+      #
+      # @api private
+      def extend_other(other)
+        other.extend(Hash[removed_attributes.zip])
+      end
+
+      module Methods
+
+        # Return a relation with only the attributes specified
+        #
+        # @example
+        #   projection = relation.project([ :a, :b, :c ])
+        #
+        # @param [#to_ary] attributes
+        #   the attributes to keep in the header
+        #
+        # @return [Projection]
+        #
+        # @api public
+        def project(attributes)
+          Projection.new(self, attributes)
+        end
+
+        # Return a relation with attributes not specified
+        #
+        # @example
+        #   projection = relation.remove([ :a, b, c ])
+        #
+        # @param [#to_ary] attributes
+        #   the attributes to remove from the header
+        #
+        # @return [Projection]
+        #
+        # @api public
+        def remove(attributes)
+          project(header - attributes)
+        end
+
+      end # module Methods
+
+      Relation.class_eval { include Methods }
+
+      memoize :removed_attributes
+
+    end # class Projection
+  end # module Algebra
+end # module Axiom

data/lib/axiom/algebra/rename.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+
+module Axiom
+  module Algebra
+
+    # Rename attributes in the header
+    class Rename < Relation
+      include Relation::Operation::Unary
+      include Equalizer.new(:operand, :aliases)
+
+      # The aliases for the relation
+      #
+      # @return [Aliases]
+      #
+      # @api private
+      attr_reader :aliases
+
+      # The relation sort order
+      #
+      # @return [Operation::Order::DirectionSet]
+      #
+      # @api private
+      attr_reader :directions
+
+      # Initialize a Rename
+      #
+      # @param [Relation] operand
+      #   the relation to rename
+      # @param [Hash, Aliases] aliases
+      #   the old and new attribute names
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(operand, aliases)
+        super(operand)
+        @aliases    = Aliases.coerce(@header, aliases)
+        @header     = @header.rename(@aliases)
+        @directions = operand.directions.rename(@aliases)
+      end
+
+      # Iterate over each tuple in the set
+      #
+      # @example
+      #   rename = Rename.new(operand, aliases)
+      #   rename.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 { |operand_tuple| yield Tuple.new(header, operand_tuple.to_ary) }
+        self
+      end
+
+      # Insert a relation into the Rename
+      #
+      # @example
+      #   new_relation = rename.insert(other)
+      #
+      # @param [Relation] other
+      #
+      # @return [Rename]
+      #
+      # @api public
+      def insert(other)
+        other = coerce(other)
+        operand.insert(other.rename(aliases.inverse)).rename(aliases)
+      end
+
+      # Delete a relation from the Rename
+      #
+      # @example
+      #   new_relation = rename.delete(other)
+      #
+      # @param [Relation] other
+      #
+      # @return [Rename]
+      #
+      # @api public
+      def delete(other)
+        other = coerce(other)
+        operand.delete(other.rename(aliases.inverse)).rename(aliases)
+      end
+
+      module Methods
+
+        # Return a relation with the header renamed
+        #
+        # @example
+        #   rename = relation.rename(a: :b, c: :d)
+        #
+        # @param [Hash, Aliases] aliases
+        #   the old and new attribute names
+        #
+        # @return [Rename]
+        #
+        # @api public
+        def rename(aliases)
+          Rename.new(self, aliases)
+        end
+
+      end # module Methods
+
+      Relation.class_eval { include Methods }
+
+    end # class Rename
+  end # module Algebra
+end # module Axiom

data/lib/axiom/algebra/rename/aliases.rb

@@ -0,0 +1,221 @@
+# encoding: utf-8
+
+module Axiom
+  module Algebra
+    class Rename
+
+      # Aliases that map old attributes to new renamed attributes
+      class Aliases
+        extend Aliasable
+        include Enumerable
+        include Equalizer.new(:to_hash)
+
+        inheritable_alias(:| => :union)
+
+        # Instantiate new set of Aliases
+        #
+        # @example
+        #   aliases = Aliases.new(aliases)
+        #
+        # @param [Hash{Attribute => Attribute}] aliases
+        #
+        # @return [Aliases]
+        #
+        # @api public
+        def self.new(aliases)
+          assert_unique_aliases(aliases)
+          super
+        end
+
+        # Asset the aliases are unique
+        #
+        # @param [Hash{Attribute => Attribute}] aliases
+        #
+        # @return [undefined]
+        #
+        # @raise [DuplicateAliasError]
+        #   raised when the aliases are duplicates
+        #
+        # @api private
+        def self.assert_unique_aliases(aliases)
+          if aliases.values.uniq!
+            raise DuplicateAliasError, 'the aliases must be unique'
+          end
+        end
+
+        private_class_method :assert_unique_aliases
+
+        # Initialize rename aliases
+        #
+        # @param [Hash] aliases
+        #   the old and new attributes
+        #
+        # @return [undefined]
+        #
+        # @api public
+        def initialize(aliases)
+          @aliases = freeze_object(aliases)
+        end
+
+        # Lookup the new attribute given the old attribute
+        #
+        # @example
+        #   new_attribute = aliases[old_attribute]
+        #
+        # @param [Attribute] attribute
+        #   the old attribute
+        #
+        # @return [Attribute]
+        #
+        # @api public
+        def [](attribute)
+          @aliases.fetch(attribute, attribute)
+        end
+
+        # Union the aliases with another set of aliases
+        #
+        # @example
+        #   new_aliases = aliases.union(other)
+        #
+        # @param [Aliases] other
+        #   the aliases to union with
+        #
+        # @return [Aliases]
+        #
+        # @api public
+        def union(other)
+          other_aliases = other.to_hash.dup
+          inverted      = other_aliases.invert
+
+          each do |old_attribute, new_attribute|
+            old_attribute = inverted.fetch(old_attribute, old_attribute)
+
+            if old_attribute.eql?(new_attribute)
+              other_aliases.delete(new_attribute)
+            else
+              other_aliases[old_attribute] = new_attribute
+            end
+          end
+
+          self.class.new(other_aliases)
+        end
+
+        # Iterate over each old and new attribute
+        #
+        # @example
+        #   aliases = Aliases.new(old => new)
+        #   aliases.each { |old, new| ... }
+        #
+        # @yield [old, new]
+        #
+        # @yieldparam [Attribute] old_attribute
+        #   the old attribute
+        # @yieldparam [Attribute] new_attribute
+        #   the new attribute
+        #
+        # @return [self]
+        #
+        # @api public
+        def each
+          return to_enum unless block_given?
+          @aliases.each { |old_attribute, new_attribute| yield old_attribute, new_attribute }
+          self
+        end
+
+        # Test if there are no aliases
+        #
+        # @example
+        #   aliases.empty?  # => true or false
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def empty?
+          @aliases.empty?
+        end
+
+        # Return the inverse aliases
+        #
+        # @example
+        #   inverse = aliases.inverse
+        #
+        # @return [Aliases]
+        #
+        # @api public
+        def inverse
+          self.class.new(@aliases.invert).
+            memoize(:inverse, self)
+        end
+
+        # Compare the aliases with other aliases for equivalency
+        #
+        # @example
+        #   aliases == other  # => true or false
+        #
+        # @param [Aliases] other
+        #   the other aliases to compare with
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def ==(other)
+          cmp?(__method__, other)
+        end
+
+        # Convert the aliases to a Hash
+        #
+        # @example
+        #   hash = aliases.to_hash
+        #
+        # @return [Hash]
+        #
+        # @api public
+        def to_hash
+          @aliases
+        end
+
+        # Coerce a Hash of old and new attributes into Aliases
+        #
+        # @param [Header] attributes
+        #   the header containing the old attributes
+        # @param [Aliases, #map] aliases
+        #   the aliases to coerce
+        #
+        # @return [Aliases]
+        #
+        # @api private
+        def self.coerce(attributes, aliases)
+          return aliases if aliases.kind_of?(Aliases)
+          header  = Relation::Header.coerce(attributes)
+          renames = aliases.map do |old_attr, new_attr|
+            coerce_alias_pair(header, old_attr, new_attr)
+          end
+          new(Hash[renames])
+        end
+
+        # Coerce old and new attributes into Attribute objects
+        #
+        # @param [Header] attributes
+        #   the header containing the old attributes
+        # @param [Symbol, Attribute] old_attr
+        #   the old attribute name or Attribute object
+        # @param [Symbol, Attribute] new_attr
+        #   the new attribute name or Attribute object
+        #
+        # @return [Array(Attribute, Attribute)]
+        #
+        # @api private
+        def self.coerce_alias_pair(attributes, old_attr, new_attr)
+          old_attr = attributes[old_attr]
+          new_attr = old_attr.rename(new_attr) if new_attr.kind_of?(Symbol)
+          [ old_attr, new_attr ]
+        end
+
+        private_class_method :coerce_alias_pair
+
+        memoize :inverse
+
+      end # class Aliases
+    end # class Rename
+  end # module Algebra
+end # module Axiom