alf-core 0.14.0 → 0.15.0

data/lib/{alf-viewpoint/alf → alf}/viewpoint.rb

@@ -23,7 +23,7 @@ module Alf
       alias :[] :build
 
       def parser(connection = nil)
-        Lang::Lispy.new([ self ], connection)
+        Lang::Parser::Lispy.new([ self ], connection)
       end
 
       def parse(*args, &bl)
@@ -32,7 +32,7 @@ module Alf
 
       def native(as, native_name = as)
         define_method(as) do
-          Algebra.named_operand(native_name)
+          Algebra.named_operand(native_name, connection)
         end
       end
 
@@ -41,9 +41,11 @@ module Alf
       end
 
       def method_added(m)
-        super.tap{
-          metadata.add_members([m]) if public_method_defined?(m)
-        }
+        res = super
+        if public_method_defined?(m) && (m.to_s != 'contextual_params')
+          metadata.add_members([m])
+        end
+        res
       end
     end
     extend ClassMethods
@@ -54,9 +56,9 @@ module Alf
 
     NATIVE = Module.new{
       include ::Alf::Viewpoint
-
       def method_missing(name, *args, &bl)
-        (!args.empty? || bl) ? super : ::Alf::Algebra.named_operand(name)
+        return super unless args.empty? and bl.nil?
+        ::Alf::Algebra.named_operand(name, connection)
       end
     }
 

data/lib/{alf-viewpoint/alf → alf}/viewpoint/metadata.rb

@@ -17,7 +17,10 @@ module Alf
 
       def depends(pairs)
         @dependencies.merge!(pairs) do |k,v1,v2|
-          v1 == v2 ? v1 : raise("Composition conflict on `#{k}`: #{v1.inspect} vs. #{v2.inspect}")
+          unless v1 == v2
+            raise("Composition conflict on `#{k}`: #{v1} vs. #{v2}")
+          end
+          v1
         end
         self
       end
@@ -61,7 +64,7 @@ module Alf
           expanded.dependencies.each_pair do |as, vps|
             provider = Metadata.new(vps).to_module(context)
             define_method(as) do
-              Lang::Lispy.new([provider], connection)
+              Lang::Parser::Lispy.new([provider], connection)
             end
           end
           instance_exec(&bl) if bl

data/spec/compiler_helper.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+require_relative 'unit/alf-compiler/shared/compiled_examples'
+
+module CompilerHelper
+
+  def compiler
+    @compiler ||= Alf::Compiler::Default.new
+  end
+
+  def leaf
+    @leaf ||= Alf::Engine::Leaf.new([{a: 2}, {a: 1}], Alf::Algebra::Operand::Named.new(:leaf))
+  end
+
+end
+
+RSpec.configure do |c|
+  c.include Alf::Lang::Functional
+  c.include CompilerHelper
+end

data/spec/integration/relation/test_to_array.rb

@@ -9,9 +9,9 @@ describe Alf::Relation, 'to_array' do
 
   let(:expected){
     [
-      Tuple(:city => 'Athens', :incity => [ Tuple(:name => 'Adams') ] ),
-      Tuple(:city => 'London', :incity => [ Tuple(:name => 'Clark'), Tuple(:name => 'Smith') ]),
-      Tuple(:city => 'Paris',  :incity => [ Tuple(:name => 'Blake'), Tuple(:name => 'Jones') ]),
+      {:city => 'Athens', :incity => [ {:name => 'Adams'} ]},
+      {:city => 'London', :incity => [ {:name => 'Clark'}, {:name => 'Smith'} ]},
+      {:city => 'Paris',  :incity => [ {:name => 'Blake'}, {:name => 'Jones'} ]},
     ]
   }
 
@@ -21,8 +21,8 @@ describe Alf::Relation, 'to_array' do
     rel.to_array(:sort => ordering).should eq(expected)
   end
 
-  # it 'is aliased as to_a' do
-  #   rel.to_a(:sort => ordering).should eq(expected)
-  # end
+  it 'is aliased as to_a' do
+    rel.to_a(:sort => ordering).should eq(expected)
+  end
 
 end

data/spec/integration/test_examples.rb

@@ -1,16 +1,24 @@
 require 'spec_helper'
-Dir["#{File.expand_path('../../../examples', __FILE__)}/**/*.alf"].each do |file|
+Path.backfind("examples").glob("**/*.alf").each do |file|
 
   describe "Alf example: #{file}" do
     let(:example_path){ file }
-    let(:example_dir) { File.dirname(file) }
-    let(:example_db) { Alf.connect(example_dir) }
+    let(:example_dir) { file.parent }
+    let(:example_db)  { Alf.connect(example_dir) }
 
-    let(:source){ File.read(example_path) }
+    let(:source){ example_path.read }
 
-    context 'when compiled' do
+    context 'when optimized through relvar' do
       subject{
-        example_db.compile(example_db.parse(source))
+        example_db.relvar(example_db.parse(source)).to_cog
+      }
+
+      it_should_behave_like "a traceable cog"
+    end
+
+    context 'when compiled through #to_cog' do
+      subject{
+        example_db.parse(source).to_cog
       }
 
       it_should_behave_like "a traceable cog"

data/spec/shared/a_cog.rb

@@ -13,15 +13,13 @@ shared_examples_for 'a traceable cog' do
   it_should_behave_like "a cog"
 
   def has_tracking!(compiled)
+    compiled.expr.should_not be_nil
     case compiled
     when Alf::Engine::Leaf
       compiled.expr.should be_a(Alf::Algebra::Operand)
     when Alf::Engine::Cog
       compiled.expr.should be_a(Alf::Algebra::Operand)
-      operands = compiled.respond_to?(:operands) ?
-                 compiled.operands :
-                 [ compiled.operand ]
-      operands.each do |op|
+      extract_operands(compiled).each do |op|
         has_tracking!(op)
       end
     else
@@ -29,6 +27,12 @@ shared_examples_for 'a traceable cog' do
     end
   end
 
+  def extract_operands(compiled)
+    return compiled.operands if compiled.respond_to?(:operands)
+    return [compiled.operand] if compiled.respond_to?(:operand)
+    []
+  end
+
   it 'should have traceability all way down expression' do
     has_tracking!(subject)
   end

data/spec/shared/a_valid_type_implementation.rb

@@ -34,13 +34,10 @@ shared_examples_for "A valid type implementation" do
 
   it 'should define values respecting the :to_ruby_literal spec' do
     type.exemplars.each do |ex|
-      Kernel.eval(ex.to_ruby_literal).should eq(ex)
-    end
-  end
-
-  it 'should define values respecting the :inspect spec' do
-    type.exemplars.each do |ex|
-      Kernel.eval(ex.inspect).should eq(ex)
+      begin
+        Kernel.eval(ex.to_ruby_literal).should eq(ex)
+      rescue NotImplementedError
+      end
     end
   end
 

data/spec/spec_helper.rb

@@ -1,6 +1,7 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-require 'alf-core'
 require "rspec"
+require 'alf-core'
+require 'alf/lang/parser/safer'
 require 'shared/an_operator_class'
 require 'shared/a_valid_type_implementation'
 require 'shared/a_value'
@@ -20,7 +21,11 @@ module Helpers
   end
 
   def a_lispy
-    Alf::Lang::Lispy.new
+    Alf::Lang::Parser::Lispy.new
+  end
+
+  def parse(*args, &bl)
+    a_lispy.parse(*args, &bl)
   end
 
   def supplier_names
@@ -51,8 +56,8 @@ module Helpers
     Alf::Algebra.named_operand(:suppliers, examples_database)
   end
 
-  def an_operand
-    Alf::Algebra::Operand::Fake.new
+  def an_operand(cog = nil)
+    Alf::Algebra::Operand::Fake.new(nil, cog)
   end
 
   def viewpoint(&bl)
@@ -72,5 +77,4 @@ end
 RSpec.configure do |c|
   c.include Helpers
   c.extend  Helpers
-  c.filter_run_excluding :ruby19 => (RUBY_VERSION < "1.9")
 end

data/spec/type_check_helper.rb

@@ -0,0 +1 @@
+require 'update_helper'

data/spec/unit/alf-adapter/shared_examples/an_adapter_with_readable_cogs.rb

@@ -23,7 +23,7 @@ shared_examples_for "an adapter with readable cogs" do
 
     it 'returns a Cog instance' do
       readable_cogs.each do |cog_name|
-        connection.cog(cog_name).should be_a(Alf::Engine::Cog)
+        connection.cog(nil, Alf::Algebra::Operand::Named.new(cog_name)).should be_a(Alf::Engine::Cog)
       end
     end
   end

data/spec/unit/alf-aggregator/test_concat.rb

@@ -15,6 +15,14 @@ module Alf
         Concat.new{ qty }.aggregate(rel).should eq("10203040")
       end
 
+      it 'should work when used standalone with Proc of arity 1' do
+        Concat.new{|t| t.qty }.aggregate(rel).should eq("10203040")
+      end
+
+      it 'should work when used standalone with Proc of arity 1 passed as arg' do
+        Concat.new(->(t){ t.qty }).aggregate(rel).should eq("10203040")
+      end
+
       it 'should install factory methods' do
         Aggregator.concat{ qty }.should be_a(Concat)
         Aggregator.concat{ qty }.aggregate(rel).should eq("10203040")

data/spec/unit/alf-algebra/operand/named/test_hash_and_equal.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+module Alf
+  module Algebra
+    module Operand
+      describe Named, "hash and ==" do
+
+        let(:op1){
+          Named.new(:foo)
+        }
+
+        context '==' do
+
+          it 'recognizes same operands' do
+            op1.should eq(op1)
+            op1.should eq(Named.new(:foo))
+          end
+
+          it 'distinguises other operands' do
+            op1.should_not eq(nil)
+            op1.should_not eq(Named.new(:foo, :bar))
+          end
+        end
+
+        context 'hash' do
+
+          it 'it the same on same operands' do
+            op1.hash.should eq(Named.new(:foo).hash)
+          end
+        end
+
+        context 'using named operands as hash keys' do
+
+          let(:h){
+            { op1 => 1,
+              Named.new(:bar) => 2,
+              Named.new(:foo, :bar) => 3 }
+          }
+
+          it 'should lead to expected hash' do
+            h.size.should eq(3)
+          end
+
+          it 'should behave as expected' do
+            h[op1].should eq(1)
+            h[Named.new(:foo)].should eq(1)
+            h[Named.new(:foo, :bar)].should eq(3)
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/unit/alf-algebra/operand/named/test_keys.rb

@@ -4,7 +4,7 @@ module Alf
     module Operand
       describe Named, "keys" do
 
-        let(:operand){ Named.new(:foo).bind(self) }
+        let(:operand){ Named.new(:foo, self) }
 
         subject{ operand.keys }
 

data/spec/unit/alf-algebra/operand/named/test_to_ascii_tree.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+module Alf
+  module Algebra
+    module Operand
+      describe Named, "to_ascii_tree" do
+
+        subject{ operand.to_ascii_tree }
+
+        let(:operand){ Named.new(:foo, self) }
+
+        it 'returns the heading' do
+          subject.should eq("foo\n")
+        end
+
+      end
+    end
+  end
+end

data/spec/unit/alf-algebra/operand/named/test_to_cog.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+module Alf
+  module Algebra
+    module Operand
+      describe Named, "to_cog" do
+
+        let(:operand){ Named.new(:foo, self) }
+
+        subject{ operand.to_cog(12) }
+
+        def cog(plan, expr)
+          plan.should eq(12)
+          expr.should be(operand)
+          [:a_cog, expr.name]
+        end
+
+        it 'delegates to the underlying connection when bound' do
+          subject.should eq([:a_cog, :foo])
+        end
+
+      end
+    end
+  end
+end

data/spec/unit/alf-algebra/operand/named/test_to_relvar.rb

@@ -4,7 +4,7 @@ module Alf
     module Operand
       describe Named, "to_relvar" do
 
-        let(:operand){ Named.new(:foo).bind(self) }
+        let(:operand){ Named.new(:foo, self) }
 
         subject{ operand.to_relvar }
 

data/spec/unit/alf-algebra/operand/named/test_type_check.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+module Alf
+  module Algebra
+    module Operand
+      describe Named, "type_check" do
+
+        subject{ operand.type_check }
+
+        def knows?(name)
+          name == :foo
+        end
+
+        def heading(name)
+          :"#{name}_heading"
+        end
+
+        context 'when known' do
+          let(:operand){ Named.new(:foo, self) }
+
+          it 'returns the heading' do
+            subject.should eq(:foo_heading)
+          end
+        end
+
+        context 'when unknown' do
+          let(:operand){ Named.new(:bar, self) }
+
+          it 'raises a TypeCheckError' do
+            lambda{
+              subject
+            }.should raise_error(TypeCheckError, /No such relvar `bar`/)
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/unit/alf-algebra/operand/proxy/test_to_cog.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+module Alf
+  module Algebra
+    module Operand
+      describe Proxy, "to_cog" do
+
+        subject{
+          proxy.to_cog
+        }
+
+        let(:proxy){
+          Proxy.new(proxied)
+        }
+
+        context 'when delegable' do
+          let(:proxied){
+            Struct.new(:to_cog).new(:compiled)
+          }
+
+          before do
+            proxied.should respond_to(:to_cog)
+          end
+
+          it{ should eq(:compiled) }
+        end
+
+        context 'when non delegable' do
+          let(:proxied){
+            [{a: 1}]
+          }
+
+          it{ should be_a(Engine::Leaf) }
+
+          it 'should be the correct proxy' do
+            subject.operand.should be(proxied)
+          end
+        end
+
+      end
+    end
+  end
+end