axiom 0.1.1 → 0.2.0

data/lib/axiom/relation/proxy.rb

@@ -7,10 +7,10 @@ module Axiom
     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? materialized?].freeze
-      RELATION_METHODS   = %w[take drop sort_by].freeze
+      ENUMERABLE_METHODS = Enumerable.public_instance_methods.map(&:to_s).freeze
+      RELATION_METHODS   = Relation.public_instance_methods.map(&:to_s).freeze
+      REMOVE_METHODS     = PROXY_METHODS | (ENUMERABLE_METHODS - RELATION_METHODS)
 
       # Hook called when module is included
       #
@@ -21,9 +21,8 @@ module Axiom
       #
       # @api private
       def self.included(descendant)
-        descendant.class_eval do
-          undef_method(*PROXY_METHODS | ENUMERABLE_METHODS - RELATION_METHODS)
-        end
+        super
+        descendant.class_eval { undef_method(*REMOVE_METHODS) }
       end
 
       private_class_method :included

data/lib/axiom/relation/variable.rb

@@ -99,8 +99,6 @@ module Axiom
       # A materialized relation variable
       class Materialized < self
 
-      private
-
         # Mutate and materialize the relation variable
         #
         # @return [undefined]
@@ -110,6 +108,7 @@ module Axiom
           super
           @relation = relation.materialize
         end
+        private :mutate_relation
 
       end # class Materialized
     end # class Variable

data/lib/axiom/support/aliasable.rb

@@ -33,11 +33,9 @@ module Axiom
     #
     # @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
+      define_method(new_method) do |*args, &block|
+        public_send(original_method, *args, &block)
+      end
     end
 
   end # module Aliasable

data/lib/axiom/support/equalizer.rb

@@ -5,25 +5,23 @@ module Axiom
   # Define equality, equivalence and inspection methods
   class Equalizer < ::Equalizer
 
-    # Include the #eql? and #== methods
+    # Hook called when module is included
     #
-    # @return [undefined]
+    # @param [Module] descendant
+    #   the module or class including Equalizer
     #
-    # @api private
+    # @return [self]
     #
-    # TODO: this monkey-patches equalizer and should be removed
-    def initialize(*keys)
-      @keys = keys
-      define_methods
-      include_comparison_methods
-
-      module_eval do
+    # @api private
+    def included(descendant)
+      super
+      descendant.module_eval do
         include Adamantium
         memoize :hash
       end
-
-      freeze
     end
 
+    private :included
+
   end # class Equalizer
 end # module Axiom

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

@@ -36,8 +36,9 @@ module Axiom
       #
       # @api private
       def initialize(left, right)
-        @left  = freeze_object(left)
-        @right = freeze_object(right)
+        freezer = self.class.freezer
+        @left   = freezer.call(left)
+        @right  = freezer.call(right)
       end
 
     end # module Binary

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

@@ -24,7 +24,7 @@ module Axiom
       #
       # @api private
       def initialize(operand)
-        @operand = freeze_object(operand)
+        @operand = self.class.freezer.call(operand)
       end
 
     end # module Unary

data/lib/axiom/tuple.rb

@@ -7,7 +7,7 @@ module Axiom
     extend Aliasable
     include Equalizer.new(:data)
 
-    inheritable_alias(:[] => :call)
+    inheritable_alias(:[] => :fetch)
 
     # The tuple header
     #
@@ -23,6 +23,16 @@ module Axiom
     # @api private
     attr_reader :data
 
+    # Convert the Tuple into an Array
+    #
+    # @example
+    #   array = tuple.to_ary
+    #
+    # @return [Array]
+    #
+    # @api public
+    attr_reader :to_ary
+
     # Initialize a Tuple
     #
     # @param [Header] header
@@ -35,7 +45,8 @@ module Axiom
     # @api private
     def initialize(header, data)
       @header = header
-      @data   = Hash[header.zip(data)]
+      @to_ary = self.class.freezer.call(data)
+      @data   = Hash[header.zip(@to_ary)]
     end
 
     # Lookup a value in the tuple given an attribute
@@ -48,8 +59,8 @@ module Axiom
     # @return [Object]
     #
     # @api public
-    def call(attribute)
-      data.fetch(header.call(attribute))
+    def fetch(attribute)
+      data.fetch(header.fetch(attribute))
     end
 
     # Return a tuple with only the specified attributes
@@ -67,41 +78,55 @@ module Axiom
       self.class.new(header, data.values_at(*header))
     end
 
-    # Append values to the tuple and return a new tuple
+    # Extend a tuple with function results
     #
     # @example
-    #   new_tuple = tuple.join(header, [1, 2, 3])
+    #   new_tuple = tuple.extend(header, [func1, func2])
     #
     # @param [Header] header
     #   the attributes to include in the tuple
-    # @param [Array] values
-    #   the values to append
+    # @param [Array<Object>] extensions
+    #   the functions to extend the tuple with
     #
     # @return [Tuple]
     #
     # @api public
-    def join(header, values)
-      self.class.new(header, to_ary + values)
+    def extend(header, extensions)
+      join(
+        header,
+        extensions.map { |extension| Function.extract_value(extension, self) }
+      )
     end
 
-    # Extend a tuple with function results
+    # Rename a tuple to use a new header
     #
     # @example
-    #   new_tuple = tuple.extend(header, [func1, func2])
+    #   new_tuple = tuple.rename(header)
+    #
+    # @param [Header] header
+    #
+    # @return [Tuple]
+    #
+    # @api public
+    def rename(header)
+      self.class.new(header, to_ary)
+    end
+
+    # Append values to the tuple and return a new tuple
+    #
+    # @example
+    #   new_tuple = tuple.join(header, [1, 2, 3])
     #
     # @param [Header] header
     #   the attributes to include in the tuple
-    # @param [Array<Object>] extensions
-    #   the functions to extend the tuple with
+    # @param [Array] values
+    #   the values to append
     #
     # @return [Tuple]
     #
     # @api public
-    def extend(header, extensions)
-      join(
-        header,
-        extensions.map { |extension| Function.extract_value(extension, self) }
-      )
+    def join(header, values)
+      self.class.new(header, to_ary + values)
     end
 
     # Return the predicate matching the tuple
@@ -115,16 +140,37 @@ module Axiom
       end
     end
 
-    # Convert the Tuple into an Array
+    # Coerce the tuple into a Hash
     #
     # @example
-    #   array = tuple.to_ary
+    #   tuple.to_hash  # => data as a Hash
     #
-    # @return [Array]
+    # @return [Hash{Symbol => Object}]
+    #
+    # @api public
+    def to_hash
+      Hash[data.map { |attribute, value| [attribute.name, value] }]
+    end
+
+    # The number of attributes
+    #
+    # @return [Integer]
     #
     # @api public
-    def to_ary
-      data.values_at(*header).freeze
+    def size
+      header.size
+    end
+
+    # Display the tuple data in a human readable form
+    #
+    # @example
+    #   tuple.inspect  # => data as a String
+    #
+    # @return [String]
+    #
+    # @api public
+    def inspect
+      to_hash.inspect
     end
 
   private
@@ -152,10 +198,14 @@ module Axiom
     #
     # @api private
     def self.coerce(header, object)
-      object.kind_of?(Tuple) ? object : new(header, object.to_ary)
+      if object.kind_of?(Tuple) || header.size != object.to_ary.size
+        object
+      else
+        new(header, object)
+      end
     end
 
-    memoize :predicate, :to_ary
+    memoize :predicate, :to_hash, :inspect
 
   end # class Tuple
 end # module Axiom

data/lib/axiom/types/relation.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module Axiom
+  module Types
+
+    # Represents a relation type
+    class Relation < Object
+
+      primitive Axiom::Relation
+
+    end # class Relation
+  end # module Types
+end # module Axiom

data/lib/axiom/types/tuple.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+module Axiom
+  module Types
+
+    # Represents a tuple type
+    class Tuple < Object
+
+      primitive Axiom::Tuple
+
+    end # class Tuple
+  end # module Types
+end # module Axiom

data/lib/axiom/version.rb

@@ -3,6 +3,6 @@
 module Axiom
 
   # Gem version
-  VERSION = '0.1.1'.freeze
+  VERSION = '0.2.0'.freeze
 
 end # module Axiom

data/spec/integration/axiom/relation/efficient_enumerable_spec.rb

@@ -26,17 +26,17 @@ describe Relation do
 
     it '#project should be efficient' do
       projected = relation.project([:id])
-      sample(projected).should == [[0], [1], [2], [3], [4]]
+      expect(sample(projected)).to eq([[0], [1], [2], [3], [4]])
     end
 
     it '#restrict should be efficient' do
       restricted = relation.restrict { |r| r.id.gt(5) }
-      sample(restricted).should == [[6], [7], [8], [9], [10]]
+      expect(sample(restricted)).to eq([[6], [7], [8], [9], [10]])
     end
 
     it '#rename should be efficient' do
       renamed = relation.rename(id: :other_id)
-      sample(renamed).should == [[0], [1], [2], [3], [4]]
+      expect(sample(renamed)).to eq([[0], [1], [2], [3], [4]])
     end
 
     describe '#join should be efficient' do
@@ -45,13 +45,13 @@ describe Relation do
       it 'has an infinite left relation' do
         pending 'Change #join to handle infinite sets'
         join = other.join(relation)
-        sample(join).should == [[1, 'Dan Kubb']]
+        expect(sample(join)).to eq([[1, 'Dan Kubb']])
       end
 
       it 'has an infinite right relation' do
         pending 'Change #join to handle infinite sets'
         join = relation.join(other)
-        sample(join).should == [[1, 'Dan Kubb']]
+        expect(sample(join)).to eq([[1, 'Dan Kubb']])
       end
     end
 
@@ -60,24 +60,24 @@ describe Relation do
 
       it 'has an infinite left relation' do
         product = relation.product(other)
-        sample(product).should == [[0, 'Dan Kubb'], [1, 'Dan Kubb'], [2, 'Dan Kubb'], [3, 'Dan Kubb'], [4, 'Dan Kubb']]
+        expect(sample(product)).to eq([[0, 'Dan Kubb'], [1, 'Dan Kubb'], [2, 'Dan Kubb'], [3, 'Dan Kubb'], [4, 'Dan Kubb']])
       end
 
       it 'has an infinite right relation' do
         pending 'Change #product to handle infinite sets'
         product = other.product(relation)
-        sample(product).should == [[0, 'Dan Kubb'], [1, 'Dan Kubb'], [2, 'Dan Kubb'], [3, 'Dan Kubb'], [4, 'Dan Kubb']]
+        expect(sample(product)).to eq([[0, 'Dan Kubb'], [1, 'Dan Kubb'], [2, 'Dan Kubb'], [3, 'Dan Kubb'], [4, 'Dan Kubb']])
       end
     end
 
     it '#difference should be efficient' do
       difference = relation.difference(Relation.new(relation.header, [[1]]))
-      sample(difference).should == [[0], [2], [3], [4], [5]]
+      expect(sample(difference)).to eq([[0], [2], [3], [4], [5]])
     end
 
     it '#union should be efficient' do
       union = relation.union(Relation.new(relation.header, [[1]]))
-      sample(union).should == [[0], [1], [2], [3], [4]]
+      expect(sample(union)).to eq([[0], [1], [2], [3], [4]])
     end
   end
 end

data/spec/integration/axiom/relation/writable_relations_spec.rb

@@ -14,55 +14,55 @@ describe Relation do
     it 'Rename#insert and #delete of a disjoint relation are symmetrical' do
       rename = relation.rename(id: :other_id)
       other  = [[4, 'John Doe']]
-      rename.insert(other).delete(other).should == rename
+      expect(rename.insert(other).delete(other)).to eq(rename)
     end
 
     it 'Projection#insert and #delete of a disjoint relation are symmetrical' do
       projection = relation.project([:id])
       other      = [[4]]
-      projection.insert(other).delete(other).should == projection
+      expect(projection.insert(other).delete(other)).to eq(projection)
     end
 
     it 'Extension#insert and #delete of a disjoint relation are symmetrical' do
       extension = relation.extend { |r| r.add(:age, 30) }
       other     = Relation.new(relation.header, [[4, 'John Doe']]).extend(extension.extensions)
-      extension.insert(other).delete(other).should == extension
+      expect(extension.insert(other).delete(other)).to eq(extension)
     end
 
     it 'Restriction#insert and #delete of a disjoint relation are symmetrical' do
       restriction = relation.restrict { |r| r.id.gte(1) }
       other       = [[4, 'John Doe']]
-      restriction.insert(other).delete(other).should == restriction
+      expect(restriction.insert(other).delete(other)).to eq(restriction)
     end
 
     it 'Join#insert and #delete of a disjoint relation are symmetrical' do
       join  = relation + Relation.new([[:id, Integer]], [[1]])
       other = [[4, 'John Doe']]
-      join.insert(other).delete(other).should == join
+      expect(join.insert(other).delete(other)).to eq(join)
     end
 
     it 'Difference#insert and #delete of a disjoint relation are symmetrical' do
       difference = relation - relation
       other      = [[4, 'John Doe']]
-      difference.insert(other).delete(other).should == difference
+      expect(difference.insert(other).delete(other)).to eq(difference)
     end
 
     it 'Union#insert and #delete of a disjoint relation are symmetrical' do
       union  = relation | relation
       other  = [[4, 'John Doe']]
-      union.insert(other).delete(other).should == union
+      expect(union.insert(other).delete(other)).to eq(union)
     end
 
     it 'Intersection#insert and #delete of a disjoint relation are symmetrical' do
       intersection = relation & relation
       other        = [[4, 'John Doe']]
-      intersection.insert(other).delete(other).should == intersection
+      expect(intersection.insert(other).delete(other)).to eq(intersection)
     end
 
-    it 'Order#insert and #delete of a disjoint relation are symmetrical' do
-      order = relation.sort_by(relation.header)
-      other = Relation.new(relation.header, [[4, 'John Doe']]).sort_by(relation.header)
-      order.insert(other).delete(other).should == order
+    it 'Sorted#insert and #delete of a disjoint relation are symmetrical' do
+      sorted = relation.sort_by(relation.header)
+      other  = Relation.new(relation.header, [[4, 'John Doe']]).sort_by(relation.header)
+      expect(sorted.insert(other).delete(other)).to eq(sorted)
     end
   end
 end