axiom 0.1.0 → 0.1.1

data/lib/axiom/relation/keys.rb

@@ -31,7 +31,7 @@ module Axiom
         if object.kind_of?(self)
           object
         else
-          block ||= lambda { |attributes| coerce_attributes(attributes) }
+          block ||= ->(attributes) { coerce_attributes(attributes) }
           new(object.map(&block))
         end
       end
@@ -92,8 +92,8 @@ module Axiom
       #
       # @api private
       def self.reducible_keys(keys)
-        keys.permutation(2).select { |key, other| key.proper_superset?(other) }.
-          transpose.first
+        keys.permutation(2).select { |key, other| key.proper_superset?(other) }
+          .transpose.first
       end
 
       private_class_method :coerce_attributes, :assert_irreducible_keys, :reducible_keys
@@ -101,7 +101,7 @@ module Axiom
       # Initialize Keys
       #
       # @example
-      #   keys = Keys.new([ [ :id ] ])
+      #   keys = Keys.new([[:id]])
       #
       # @param [Array<Header>] keys
       #

data/lib/axiom/relation/materialized.rb

@@ -5,6 +5,7 @@ module Axiom
 
     # A materialized relation
     class Materialized < Relation
+      ZERO_TUPLE = EMPTY_ARRAY
 
       # The relation sort order
       #
@@ -25,7 +26,7 @@ module Axiom
       # @return [undefined]
       #
       # @api private
-      def initialize(header, tuples, directions = Operation::Order::DirectionSet::EMPTY)
+      def initialize(header, tuples = ZERO_TUPLE, directions = Operation::Order::DirectionSet::EMPTY)
         super(header, tuples)
         @directions = Operation::Order::DirectionSet.coerce(directions)
       end

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

@@ -150,6 +150,12 @@ module Axiom
 
         module Methods
 
+          # Default block used in #one
+          DEFAULT_ONE_BLOCK = -> { }
+
+          # Maximum number of tuples to take in #one
+          ONE_LIMIT = 2
+
           # Return a relation with n tuples
           #
           # @example
@@ -201,6 +207,51 @@ module Axiom
             reverse.take(limit).reverse
           end
 
+          # Return a tuple if the relation contains exactly one tuple
+          #
+          # @example without a block
+          #   tuple = relation.one
+          #
+          # @example with a block
+          #   tuple = relation.one { ... }
+          #
+          # @yieldreturn [Object]
+          #
+          # @return [Tuple]
+          #
+          # @raise [NoTuplesError]
+          #   raised if no tuples are returned
+          # @raise [ManyTuplesError]
+          #   raised if more than one tuple is returned
+          #
+          # @api public
+          def one(&block)
+            block ||= DEFAULT_ONE_BLOCK
+            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'
+          end
+
+        private
+
+          # Assert no more than one tuple is returned
+          #
+          # @return [undefined]
+          #
+          # @raise [ManyTuplesError]
+          #   raised if more than one tuple is returned
+          #
+          # @api private
+          def assert_no_more_than_one_tuple(size)
+            if size > 1
+              raise(
+                ManyTuplesError,
+                "one tuple expected, but set contained #{count} tuples"
+              )
+            end
+          end
+
         end # module Methods
 
         Relation.class_eval { include Methods }

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

@@ -23,40 +23,21 @@ module Axiom
         #
         # @param [Relation] operand
         #   the relation to sort
-        # @param [DirectionSet, Array<Direction, Attribute>] directions
+        # @param [DirectionSet, Header, Array<Direction, Attribute>] directions
         #   the directions to sort tuples in
         #
         # @return [Order]
         #
         # @api public
         def self.new(operand, directions)
-          directions = DirectionSet.coerce(directions)
-          assert_order_by_full_header(operand, directions)
-          super
-        end
-
-        # Assert the full header is sorted on
-        #
-        # Sorting on the full header ensures deterministic results,
-        # which is necessary for ordering to be useful.
-        #
-        # @param [Relation] operand
-        # @param [#attributes] directions
-        #
-        # @return [undefined]
-        #
-        # @raise [InvalidDirectionsError]
-        #   raised if the full header is not sorted on
-        #
-        # @api private
-        def self.assert_order_by_full_header(operand, directions)
-          if operand.header != directions.attributes
-            raise InvalidDirectionsError, 'directions must include every attribute in the header'
+          header     = operand.header
+          directions = DirectionSet.coerce(directions) do |direction|
+            header[direction] unless direction.kind_of?(Direction)
           end
+          directions |= header - directions.attributes
+          super
         end
 
-        private_class_method :assert_order_by_full_header
-
         # Initialize an Order
         #
         # @param [Relation] operand
@@ -147,7 +128,7 @@ module Axiom
           # Return an ordered relation
           #
           # @example with a block
-          #   order = relation.sort_by { |r| [ r.a.desc, r.b ] }
+          #   order = relation.sort_by { |r| [r.a.desc, r.b] }
           #
           # @example with directions
           #   order = relation.sort_by(directions)
@@ -169,6 +150,18 @@ module Axiom
             Order.new(self, coerce_to_directions(*args, &block))
           end
 
+          # Return an ordered relation
+          #
+          # @example
+          #   order = relation.sort
+          #
+          # @return [Order]
+          #
+          # @api public
+          def sort
+            Order.new(self, EMPTY_ARRAY)
+          end
+
         private
 
           # Coerce the arguments and block into directions
@@ -186,9 +179,9 @@ module Axiom
           # @return [DirectionSet, Array<Direction>, Header]
           #
           # @api private
-          def coerce_to_directions(directions = Undefined)
+          def coerce_to_directions(directions = Undefined, &block)
             if directions.equal?(Undefined)
-              Evaluator::Context.new(header) { |context| yield context }.yield
+              header.context(&block).yield
             else
               directions
             end

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

@@ -68,7 +68,7 @@ module Axiom
           #
           # @api private
           def sort_tuples(tuples)
-            tuples.sort { |left, right| cmp_tuples(left, right) }
+            tuples.to_a.sort { |left, right| cmp_tuples(left, right) }
           end
 
         private

data/lib/axiom/relation/proxy.rb

@@ -9,8 +9,8 @@ module Axiom
 
       # 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+
+      PROXY_METHODS      = %w[header each empty? materialized?].freeze
+      RELATION_METHODS   = %w[take drop sort_by].freeze
 
       # Hook called when module is included
       #

data/lib/axiom/relation/variable.rb

@@ -0,0 +1,117 @@
+# encoding: utf-8
+
+module Axiom
+  class Relation
+
+    # A relation variable
+    class Variable < Relation
+      include Adamantium::Mutable, Proxy
+
+      # Instantiate a new relation variable
+      #
+      # @example
+      #   relvar = Relation::Variable.new(relation)
+      #
+      # @param [Relation] relation
+      #
+      # @return [Relation::Variable]
+      #
+      # @api public
+      def self.new(relation)
+        if equal?(Variable) && relation.materialized?
+          Materialized.new(relation)
+        else
+          super
+        end
+      end
+
+      # Initialize a relation variable
+      #
+      # @param [Relation] relation
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(relation)
+        @relation = relation
+        @mutex    = Mutex.new
+      end
+
+      # Insert tuples into the relation variable
+      #
+      # @example
+      #   relvar.insert(other)
+      #
+      # @param [Enumerable] other
+      #
+      # @return [self]
+      #
+      # @api public
+      def insert(other)
+        @mutex.synchronize { mutate_relation(__method__, other) }
+        self
+      end
+
+      # Delete tuples from the relation variable
+      #
+      # @example
+      #   relvar.delete(other)
+      #
+      # @param [Enumerable] other
+      #
+      # @return [self]
+      #
+      # @api public
+      def delete(other)
+        @mutex.synchronize { mutate_relation(__method__, other) }
+        self
+      end
+
+      # Replace the relation variable with new tuples
+      #
+      # @example
+      #   relvar.replace(other)
+      #
+      # @param [Enumerable] other
+      #
+      # @return [self]
+      #
+      # @api public
+      def replace(other)
+        @mutex.synchronize { mutate_relation(__method__, other) }
+        self
+      end
+
+    private
+
+      # Mutate the relation variable
+      #
+      # @param [Symbol] method
+      # @param [Enumerable] other
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def mutate_relation(*args)
+        @relation = relation.public_send(*args)
+      end
+
+      # A materialized relation variable
+      class Materialized < self
+
+      private
+
+        # Mutate and materialize the relation variable
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def mutate_relation(*)
+          super
+          @relation = relation.materialize
+        end
+
+      end # class Materialized
+    end # class Variable
+  end # class Relation
+end # module Axiom

data/lib/axiom/support/equalizer.rb

@@ -10,12 +10,19 @@ module Axiom
     # @return [undefined]
     #
     # @api private
-    def initialize(*)
-      super
+    #
+    # TODO: this monkey-patches equalizer and should be removed
+    def initialize(*keys)
+      @keys = keys
+      define_methods
+      include_comparison_methods
+
       module_eval do
         include Adamantium
         memoize :hash
       end
+
+      freeze
     end
 
   end # class Equalizer

data/lib/axiom/support/evaluator.rb

@@ -59,7 +59,10 @@ module Axiom
       def add(attribute, object = Undefined, &block)
         object = block if object.equal?(Undefined)
         type   = Attribute.infer_type(object)
-        functions[type.coerce(attribute)] = object
+        klass  = Attribute.descendants.detect do |descendant|
+          descendant.type >= type
+        end
+        functions[klass.coerce(attribute)] = object
         self
       end
 

data/lib/axiom/tuple.rb

@@ -70,7 +70,7 @@ module Axiom
     # Append values to the tuple and return a new tuple
     #
     # @example
-    #   new_tuple = tuple.join(header, [ 1, 2, 3 ])
+    #   new_tuple = tuple.join(header, [1, 2, 3])
     #
     # @param [Header] header
     #   the attributes to include in the tuple
@@ -87,7 +87,7 @@ module Axiom
     # Extend a tuple with function results
     #
     # @example
-    #   new_tuple = tuple.extend(header, [ func1, func2 ])
+    #   new_tuple = tuple.extend(header, [func1, func2])
     #
     # @param [Header] header
     #   the attributes to include in the tuple

data/lib/axiom/version.rb

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

data/spec/integration/axiom/algebra/join_spec.rb

@@ -6,8 +6,8 @@ describe Algebra::Join do
   context 'Commutative property' do
     subject { left.join(right) }
 
-    let(:left)  { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ])                                             }
-    let(:right) { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 1, 'Dan Kubb' ], [ 2, 'Alex Kubb' ] ]) }
+    let(:left)  { Relation.new([[:id, Integer]], [[1], [2]])                                           }
+    let(:right) { Relation.new([[:id, Integer], [:name, String]], [[1, 'Dan Kubb'], [2, 'Alex Kubb']]) }
 
     it 'does not matter which order the relations are joined in' do
       should == right.join(left)

data/spec/integration/axiom/algebra/product_spec.rb

@@ -6,8 +6,8 @@ describe Algebra::Product do
   context 'Commutative property' do
     subject { left.product(right) }
 
-    let(:left)  { Relation.new([ [ :id,   Integer ] ], [ [ 1 ], [ 2 ] ])                    }
-    let(:right) { Relation.new([ [ :name, String  ] ], [ [ 'Dan Kubb' ], [ 'Alex Kubb' ] ]) }
+    let(:left)  { Relation.new([[:id,   Integer]], [[1], [2]])                    }
+    let(:right) { Relation.new([[:name, String]],  [['Dan Kubb'], ['Alex Kubb']]) }
 
     it 'does not matter which order the relations are multiplied in' do
       should == right.product(left)

data/spec/integration/axiom/algebra/projection_spec.rb

@@ -4,15 +4,15 @@ require 'spec_helper'
 
 describe Algebra::Projection do
   context 'remove attributes in predicate' do
-    subject { restriction.project([ :name ]) }
+    subject { restriction.project([:name]) }
 
-    let(:left)        { Relation.new([ [ :id, Integer ] ], (0..11).map { |n| [ n ] })                           }
-    let(:right)       { Relation.new([ [ :name, String ] ], [ [ 'Dan Kubb' ], [ 'John Doe' ], [ 'Jane Doe' ] ]) }
-    let(:relation)    { left * right                                                                            }
-    let(:restriction) { relation.restrict { |r| r.id.gte(1).and(r.id.lte(10)).and(r.name.eq('Dan Kubb')) }      }
+    let(:left)        { Relation.new([[:id, Integer]], (0..11).map { |n| [n] })                            }
+    let(:right)       { Relation.new([[:name, String]], [['Dan Kubb'], ['John Doe'], ['Jane Doe']])        }
+    let(:relation)    { left * right                                                                       }
+    let(:restriction) { relation.restrict { |r| r.id.gte(1).and(r.id.lte(10)).and(r.name.eq('Dan Kubb')) } }
 
     it 'returns a relation with a single tuple' do
-      should == [ [ 'Dan Kubb' ] ]
+      should == [['Dan Kubb']]
     end
   end
 end

data/spec/integration/axiom/algebra/summarization_spec.rb

@@ -5,31 +5,31 @@ require 'spec_helper'
 describe Algebra::Summarization do
   subject { relation.summarize(summarize_per) { |r| r.add(:count) { |accumulator, _| accumulator.to_i + 1 } } }
 
-  let(:header)    { [ [ :name, String ], [ :qty, Integer ] ]                       }
-  let(:relation)  { Relation.new(header, [ [ 'Dan Kubb', 1 ], [ 'John Doe', 1 ] ]) }
-  let(:by_header) { header.values_at(0)                                            }
+  let(:header)    { [[:name, String], [:qty, Integer]]                       }
+  let(:relation)  { Relation.new(header, [['Dan Kubb', 1], ['John Doe', 1]]) }
+  let(:by_header) { header.values_at(0)                                      }
 
   context 'summarize on the same set' do
-    let(:summarize_per) { Relation.new(by_header, [ [ 'Dan Kubb' ], [ 'John Doe' ] ]) }
+    let(:summarize_per) { Relation.new(by_header, [['Dan Kubb'], ['John Doe']]) }
 
     it 'returns a relation with a single tuple' do
-      should == [ [ 'Dan Kubb', 1 ], [ 'John Doe', 1 ] ]
+      should == [['Dan Kubb', 1], ['John Doe', 1]]
     end
   end
 
   context 'summarize on a smaller set' do
-    let(:summarize_per) { Relation.new(by_header, [ [ 'Dan Kubb' ] ]) }
+    let(:summarize_per) { Relation.new(by_header, [['Dan Kubb']]) }
 
     it 'returns a relation with a single tuple' do
-      should == [ [ 'Dan Kubb', 1 ] ]
+      should == [['Dan Kubb', 1]]
     end
   end
 
   context 'summarize on a larger set' do
-    let(:summarize_per) { Relation.new(by_header, [ [ 'Dan Kubb' ], [ 'Dane Largy' ] ]) }
+    let(:summarize_per) { Relation.new(by_header, [['Dan Kubb'], ['Dane Largy']]) }
 
     it 'returns a relation with a single tuple' do
-      should == [ [ 'Dan Kubb', 1 ], [ 'Dane Largy', nil ] ]
+      should == [['Dan Kubb', 1], ['Dane Largy', nil]]
     end
   end
 end