veritas 0.0.6 → 0.0.7

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

@@ -60,8 +60,6 @@ module Veritas
           self
         end
 
-      private
-
         module Methods
 
           # Return the reversed relation

data/lib/veritas/support/comparator.rb

@@ -38,7 +38,7 @@ module Veritas
     # @api private
     def define_hash_method(methods)
       define_method(:hash) do
-        self.class.hash ^ methods.map { |method| send(method).hash }.inject(:^)
+        self.class.hash ^ methods.map { |method| send(method).hash }.reduce(0, :^)
       end
     end
 

data/lib/veritas/support/evaluator.rb

@@ -5,6 +5,9 @@ module Veritas
 
     # Provide a context to evaluate a Relation operation block
     class Context < BasicObject
+      extend Aliasable
+
+      inheritable_alias(:respond_to_missing? => :respond_to?)
 
       # The functions to evaluate
       #

data/lib/veritas/support/immutable.rb

@@ -29,7 +29,7 @@ module Veritas
     #
     # @api public
     def freeze
-      @__memory = {} unless frozen?
+      memory  # initialize memory
       super
     end
 
@@ -45,7 +45,7 @@ module Veritas
     #
     # @api public
     def memoized(name)
-      @__memory[name]
+      memory[name]
     end
 
     # Sets a memoized value for a method
@@ -62,9 +62,7 @@ module Veritas
     #
     # @api public
     def memoize(name, value)
-      unless @__memory.key?(name)
-        @__memory[name] = Immutable.freeze_object(value)
-      end
+      store_memory(name, value) unless memory.key?(name)
       self
     end
 
@@ -80,6 +78,33 @@ module Veritas
       self
     end
 
+  private
+
+    # The memoized method results
+    #
+    # @return [Hash]
+    #
+    # @api private
+    def memory
+      @__memory ||= {}
+    end
+
+    # Store the value in memory
+    #
+    # @param [Symbol] name
+    #   the method name
+    # @param [Object] value
+    #   the value to memoize
+    #
+    # @return [self]
+    #
+    # @return [value]
+    #
+    # @api private
+    def store_memory(name, value)
+      memory[name] = Immutable.freeze_object(value)
+    end
+
     # Attempt to freeze an object
     #
     # @example using a value object
@@ -179,10 +204,10 @@ module Veritas
         original = instance_method(method)
         undef_method(method)
         define_method(method) do |*args|
-          if @__memory.key?(method)
-            @__memory.fetch(method)
+          if memory.key?(method)
+            memoized(method)
           else
-            @__memory[method] = Immutable.freeze_object(original.bind(self).call(*args))
+            store_memory(method, original.bind(self).call(*args))
           end
         end
       end

data/lib/veritas/tuple.rb

@@ -4,9 +4,11 @@ module Veritas
 
   # A set of objects representing a unique fact in a relation
   class Tuple
-    extend Comparator
+    extend Aliasable, Comparator
     include Immutable
 
+    inheritable_alias(:[] => :call)
+
     compare :data
 
     # The tuple header
@@ -41,15 +43,15 @@ module Veritas
     # Lookup a value in the tuple given an attribute
     #
     # @example
-    #   value = tuple[attribute]
+    #   value = tuple.call(attribute)
     #
     # @param [Attribute] attribute
     #
     # @return [Object]
     #
     # @api public
-    def [](attribute)
-      data.fetch(header[attribute])
+    def call(attribute)
+      data.fetch(header.call(attribute))
     end
 
     # Return a tuple with only the specified attributes
@@ -111,7 +113,7 @@ module Veritas
     # @api private
     def predicate
       header.reduce(Function::Proposition::Tautology.instance) do |predicate, attribute|
-        predicate.and(attribute.eq(self[attribute]))
+        predicate.and(attribute.eq(attribute.call(self)))
       end
     end
 
@@ -184,7 +186,7 @@ module Veritas
       object.kind_of?(Tuple) ? object : new(header, object)
     end
 
-    memoize :hash, :predicate, :to_ary
+    memoize :predicate, :to_ary
 
   end # class Tuple
 end # module Veritas

data/lib/veritas/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Veritas
-  VERSION = '0.0.6'
+  VERSION = '0.0.7'
 end # module Veritas

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

@@ -6,7 +6,7 @@ describe Algebra::Projection do
   context 'remove attributes in predicate' do
     subject { restriction.project([ :name ]) }
 
-    let(:left)        { Relation.new([ [ :id, Integer ] ], (1..100).map { |n| [ n ] })                          }
+    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')) }      }

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

@@ -1,18 +1,15 @@
 # encoding: utf-8
 
 require 'spec_helper'
+require 'timeout'
 
 # use an infinite list to simulate handling a large Array.
 # if any operation is inefficient, then the specs will never exit
 class InfiniteList
   include Enumerable
 
-  def each
-    index = 0
-    loop do
-      yield [ index ]
-      index += 1
-    end
+  def each(&block)
+    0.upto(Float::INFINITY) { |index| yield [ index ] }
     self
   end
 end
@@ -22,7 +19,9 @@ describe Relation do
     let(:relation) { Relation.new([ [ :id, Integer ] ], InfiniteList.new) }
 
     def sample(relation)
-      relation.to_enum.take(5)
+      Timeout.timeout(1) do
+        relation.to_enum.take(5)
+      end
     end
 
     it '#project should be efficient' do
@@ -35,9 +34,40 @@ describe Relation do
       sample(restricted).should == [ [ 6 ], [ 7 ], [ 8 ], [ 9 ], [ 10 ] ]
     end
 
-    it '#product should be efficient' do
-      product = relation.product(Relation.new([ [ :name, String ] ], [ [ 'Dan Kubb' ] ]))
-      sample(product).should == [ [ 0, 'Dan Kubb' ], [ 1, 'Dan Kubb' ], [ 2, 'Dan Kubb' ], [ 3, 'Dan Kubb' ], [ 4, 'Dan Kubb' ] ]
+    it '#rename should be efficient' do
+      renamed = relation.rename(:id => :other_id)
+      sample(renamed).should == [ [ 0 ], [ 1 ], [ 2 ], [ 3 ], [ 4 ] ]
+    end
+
+    describe '#join should be efficient' do
+      let(:other) { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 1, 'Dan Kubb' ] ]) }
+
+      it 'has an infinite left relation' do
+        pending 'Change #join to handle infinite sets'
+        join = other.join(relation)
+        sample(join).should == [ [ 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' ] ]
+      end
+    end
+
+    describe '#product should be efficient' do
+      let(:other) { Relation.new([ [ :name, String ] ], [ [ 'Dan Kubb' ] ]) }
+
+      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' ] ]
+      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' ] ]
+      end
     end
 
     it '#difference should be efficient' do
@@ -49,10 +79,5 @@ describe Relation do
       union = relation.union(Relation.new(relation.header, [ [ 1 ] ]))
       sample(union).should == [ [ 0 ], [ 1 ], [ 2 ], [ 3 ], [ 4 ] ]
     end
-
-    it '#rename should be efficient' do
-      renamed = relation.rename(:id => :other_id)
-      sample(renamed).should == [ [ 0 ], [ 1 ], [ 2 ], [ 3 ], [ 4 ] ]
-    end
   end
 end

data/spec/rcov.opts

@@ -4,3 +4,4 @@
 --xrefs
 --profile
 --text-summary
+--failure-threshold 100

data/spec/shared/hash_method_behavior.rb

@@ -3,11 +3,16 @@
 shared_examples_for 'a hash method' do
   it_should_behave_like 'an idempotent method'
 
-  # TOOD: figure out if #hash under rbx should also always use Fixnum
-  if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
-    it { should be_kind_of(Integer) }
-  else
-    it { should be_instance_of(Fixnum) }
+  specification = proc do
+    should be_instance_of(Fixnum)
+  end
+
+  it 'is a fixnum' do
+    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+      pending('Under rubinius #hash does not always use a Fixnum', &specification)
+    else
+      instance_eval(&specification)
+    end
   end
 
   it 'memoizes the hash code' do

data/spec/spec_helper.rb

@@ -2,7 +2,7 @@
 
 require 'rubygems'
 require 'backports'
-require 'backports/basic_object'
+require 'backports/basic_object' unless RUBY_VERSION >= '1.9.2' && (RUBY_PLATFORM.include?('java') || RUBY_ENGINE == 'rbx')
 require 'veritas'
 require 'spec'
 require 'spec/autorun'

data/spec/unit/veritas/algebra/extension/class_methods/new_spec.rb

@@ -17,6 +17,6 @@ describe Algebra::Extension, '.new' do
   context 'with a duplicate attribute name provided' do
     let(:extensions) { { :id => proc {}, :name => proc {} } }
 
-    specify { expect { subject }.to raise_error(DuplicateAttributeError, 'duplicate attributes: id, name') }
+    specify { expect { subject }.to raise_error(DuplicateNameError, 'duplicate names: id, name') }
   end
 end

data/spec/unit/veritas/algebra/join/class_methods/new_spec.rb

@@ -24,6 +24,6 @@ describe Algebra::Join, '.new' do
   context 'with relations having different headers' do
     let(:right) { Relation.new([ [ :name, String ] ], [ [ 'Dan Kubb' ] ]) }
 
-    specify { expect { subject }.to raise_error(InvalidHeaderError, 'the headers must have common attributes') }
+    it { should be_instance_of(object) }
   end
 end

data/spec/unit/veritas/algebra/join/each_spec.rb

@@ -5,16 +5,43 @@ require 'spec_helper'
 describe Algebra::Join, '#each' do
   subject { object.each { |tuple| yields << tuple } }
 
-  let(:left)   { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ])                         }
-  let(:right)  { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 2, 'Dan Kubb' ] ]) }
-  let(:object) { described_class.new(left, right)                                             }
-  let(:yields) { []                                                                           }
+  let(:left)   { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
+  let(:object) { described_class.new(left, right)                     }
+  let(:yields) { []                                                   }
 
-  it_should_behave_like 'an #each method'
+  context 'when the attributes are joined' do
+    let(:right) { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 2, 'Dan Kubb' ] ]) }
 
-  it 'yields each tuple' do
-    expect { subject }.to change { yields.dup }.
-      from([]).
-      to([ [ 2, 'Dan Kubb' ] ])
+    it_should_behave_like 'an #each method'
+
+    it 'yields each tuple in the join' do
+      expect { subject }.to change { yields.dup }.
+        from([]).
+        to([ [ 2, 'Dan Kubb' ] ])
+    end
+  end
+
+  context 'when the attributes are disjoint' do
+    let(:right) { Relation.new([ [ :name, String ] ], [ [ 'Dan Kubb' ] ]) }
+
+    it_should_behave_like 'an #each method'
+
+    it 'yields each tuple in the product' do
+      expect { subject }.to change { yields.dup }.
+        from([]).
+        to([ [ 1, 'Dan Kubb' ], [ 2, 'Dan Kubb' ] ])
+    end
+  end
+
+  context 'when the attributes are an intersection' do
+    let(:right) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+
+    it_should_behave_like 'an #each method'
+
+    it 'yields each tuple in the intersection' do
+      expect { subject }.to change { yields.dup }.
+        from([]).
+        to([ [ 1 ] ])
+    end
   end
 end

data/spec/unit/veritas/aliasable/inheritable_alias_spec.rb

@@ -41,7 +41,7 @@ describe Aliasable, '#inheritable_alias' do
   end
 
   it 'sets the file and line number properly' do
-    if RUBY_PLATFORM[/java/]
+    if RUBY_PLATFORM.include?('java')
       pending('Kernel#caller returns the incorrect line number in JRuby', &specification)
     else
       instance_eval(&specification)

data/spec/unit/veritas/comparator/compare_spec.rb

@@ -24,8 +24,11 @@ describe Comparator, '#compare' do
   end
 
   it 'defines a #hash method that uses the class and declared methods' do
+    # use Fixnum#eql? instead of Fixnum#equal? because the hash value may not
+    # always be the same object (i.e. on JRuby), and we mostly only care that
+    # the type and value match the expected Fixnum.
     subject
-    instance.hash.should equal(object.hash ^ false.hash ^ instance.to_s.hash)
+    instance.hash.should eql(object.hash ^ false.hash ^ instance.to_s.hash)
   end
 
   it 'memoizes #hash' do

data/spec/unit/veritas/evaluator/context/method_missing_spec.rb

@@ -24,6 +24,12 @@ describe Evaluator::Context, '#method_missing' do
   context 'with an unknown attribute' do
     subject { object.unknown }
 
-    specify { expect { subject }.to raise_error(NoMethodError) }
+    if RUBY_VERSION >= '1.9.2' && RUBY_ENGINE == 'rbx'
+      # Mark this spec as pending until the following rubinius 1.9 mode bug is
+      # resolved: https://github.com/rubinius/rubinius/issues/1194
+      specify { pending 'BasicObject#method_missing does not raise NoMethodError for unknown methods' }
+    else
+      specify { expect { subject }.to raise_error(NoMethodError) }
+    end
   end
 end

data/spec/unit/veritas/function/connective/negation/class_methods/operation_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Connective::Negation, '.operation' do
+  subject { object.operation }
+
+  let(:object) { described_class }
+
+  it { should equal(:'!') }
+end

data/spec/unit/veritas/function/numeric/absolute/class_methods/operation_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Numeric::Absolute, '.operation' do
+  subject { object.operation }
+
+  let(:object) { described_class }
+
+  it { should equal(:abs) }
+end

data/spec/unit/veritas/function/numeric/unary_minus/class_methods/operation_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Numeric::UnaryMinus, '.operation' do
+  subject { object.operation }
+
+  let(:object) { described_class }
+
+  it { should equal(:-@) }
+end