alf-core 0.13.1 → 0.14.0

data/lib/alf-types/alf/types/selection.rb

@@ -0,0 +1,18 @@
+module Alf
+  module Types
+    class Selection
+      extend Domain::Reuse.new(Array)
+
+      coercions do |c|
+        c.coercion(Array){|x,_|
+          Selection.new(x.map{|y| Selector.coerce(y) })
+        }
+      end
+
+      def select(tuple)
+        reused_instance.map{|s| s.select(tuple) }
+      end
+
+    end # class Selection
+  end # module Types
+end # module Alf

data/lib/alf-types/alf/types/selector.rb

@@ -0,0 +1,59 @@
+module Alf
+  module Types
+    class Selector
+      extend Domain::Reuse.new(Object)
+
+      coercions do |c|
+        c.coercion(Symbol){|v,_|
+          Selector.new(AttrName.coerce(v))
+        }
+        c.coercion(String){|v,_|
+          v =~ /\./ ? c.coerce(v.split('.')) : c.coerce(v.to_sym)
+        }
+        c.coercion(Array){|v,_|
+          Selector.new(v.map{|v| AttrName.coerce(v) })
+        }
+      end
+
+      def simple?
+        reused_instance.is_a?(Symbol)
+      end
+
+      def composite?
+        !simple?
+      end
+
+      def outcoerce
+        reused_instance
+      end
+
+      def select(tuple)
+        return tuple[reused_instance] unless reused_instance.is_a?(Array)
+        reused_instance.inject(tuple){|t,a| t && t[a] }
+      end
+
+      def dive(attr)
+        components = to_a
+        return nil unless (components.first == attr) && components.size > 1
+        rest  = components[1..-1]
+        Selector.new(rest.size == 1 ? rest.first : rest)
+      end
+
+      def to_a
+        Array(reused_instance)
+      end
+
+      def to_lispy
+        Support.to_ruby_literal(reused_instance)
+      end
+
+      def to_ruby_literal
+        "Alf::Selector[#{Support.to_ruby_literal(reused_instance)}]"
+      end
+
+      alias :to_s :to_ruby_literal
+      alias :inspect :to_ruby_literal
+
+    end # class Selector
+  end # module Types
+end # module Alf

data/lib/alf-types/alf/types/tuple_computation.rb

@@ -54,8 +54,8 @@ module Alf
       #
       # @param [TupleScope] scope a tuple scope instance.
       # @return [Hash] the resulting tuple
-      def evaluate(scope = nil)
-        hmap{|_,v| v.is_a?(TupleExpression) ? v.evaluate(scope) : v }
+      def evaluate(scope = nil, connection = nil)
+        hmap{|_,v| v.is_a?(TupleExpression) ? v.evaluate(scope, connection) : v }
       end
 
       # Returns self

data/lib/alf-types/alf/types/tuple_expression.rb

@@ -60,8 +60,18 @@ module Alf
       # @param [TupleScope] scope a tuple scope instance.
       # @return [Object] the result of evaluating the expression in the context
       #         of `scope`
-      def evaluate(scope = nil)
-        scope.instance_exec(&@expr_lambda)
+      def evaluate(scope = nil, connection = nil)
+        result = if @expr_lambda.arity == 1
+          @expr_lambda.call(scope)
+        else
+          scope.instance_exec(&@expr_lambda)
+        end
+        if looks_an_expression?(result)
+          result = result.bind(connection) unless result.bound?
+          result.to_relation
+        else
+          result
+        end
       end
 
       # Infers the resulting type.
@@ -127,6 +137,12 @@ module Alf
         end
       end
 
+    private
+
+      def looks_an_expression?(y)
+        Algebra::Operand::Named === y || Algebra::Operator === y
+      end
+
     end # class TupleExpression
   end # module Types
 end # module Alf

data/lib/alf-viewpoint/alf/viewpoint.rb

@@ -1,8 +1,27 @@
+require_relative 'viewpoint/metadata'
 module Alf
   module Viewpoint
 
     module ClassMethods
 
+      def metadata
+        @metadata ||= Metadata.new
+      end
+
+      def expects(*viewpoints)
+        metadata.expects(viewpoints)
+      end
+
+      def depends(as, *viewpoints)
+        metadata.depends(as => viewpoints)
+      end
+
+      def build(context = {})
+        x = self
+        metadata.to_module(context){ include(x) }
+      end
+      alias :[] :build
+
       def parser(connection = nil)
         Lang::Lispy.new([ self ], connection)
       end
@@ -17,18 +36,14 @@ module Alf
         end
       end
 
-      def namespace(name, *viewpoints)
-        define_method(name) do
-          Lang::Lispy.new(viewpoints, connection)
-        end
-      end
-
       def members
-        @members ||= []
+        metadata.all_members
       end
 
       def method_added(m)
-        super.tap{ members << m }
+        super.tap{
+          metadata.add_members([m]) if public_method_defined?(m)
+        }
       end
     end
     extend ClassMethods

data/lib/alf-viewpoint/alf/viewpoint/metadata.rb

@@ -0,0 +1,73 @@
+module Alf
+  module Viewpoint
+    class Metadata
+
+      def initialize(expectations = [], dependencies = {}, members = [])
+        @expectations = expectations
+        @dependencies = dependencies
+        @members      = members
+        yield(self) if block_given?
+      end
+      attr_reader :expectations, :dependencies, :members
+
+      def expects(viewpoints)
+        @expectations |= viewpoints
+        self
+      end
+
+      def depends(pairs)
+        @dependencies.merge!(pairs) do |k,v1,v2|
+          v1 == v2 ? v1 : raise("Composition conflict on `#{k}`: #{v1.inspect} vs. #{v2.inspect}")
+        end
+        self
+      end
+
+      def add_members(members)
+        @members |= members
+        self
+      end
+
+      def all_members
+        expand.members
+      end
+
+      def expand
+        Metadata.new do |m|
+          expectations.map{|e| e.metadata.expand }.each do |m2|
+            m.expects(m2.expectations)
+            m.depends(m2.dependencies)
+            m.add_members(m2.members)
+          end
+          m.expects(expectations)
+          m.depends(dependencies)
+          m.add_members(members)
+        end
+      end
+
+      def dup
+        Metadata.new(expectations.dup, dependencies.dup, members.dup)
+      end
+
+      def to_module(context = {}, &bl)
+        expanded = expand
+        Module.new{
+          include Alf::Viewpoint
+          define_method(:contextual_params) do
+            context
+          end
+          expanded.expectations.each do |exp|
+            include(exp)
+          end
+          expanded.dependencies.each_pair do |as, vps|
+            provider = Metadata.new(vps).to_module(context)
+            define_method(as) do
+              Lang::Lispy.new([provider], connection)
+            end
+          end
+          instance_exec(&bl) if bl
+        }
+      end
+
+    end # class Metadata
+  end # module Viewpoint
+end # module Alf

data/spec/integration/relation/test_extend.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+describe Alf::Relation, 'extend' do
+
+  let(:rel) {
+    Relation(name: ["Jones", "Smith"])
+  }
+
+  let(:expected){
+    Relation(name: ["JONESfoo", "SMITHfoo"])
+  }
+
+  let(:scoped){
+    "foo"
+  }
+
+  it 'supports procs of arity 1' do
+    rel.extend(foo: ->(t){ t.name.upcase + scoped })
+  end
+
+end

data/spec/integration/relation/test_to_array.rb

@@ -15,7 +15,7 @@ describe Alf::Relation, 'to_array' do
     ]
   }
 
-  let(:ordering){ [:city, :name] }
+  let(:ordering){ [:city, [:incity, :name]] }
 
   it 'recursively converts to sorted arrays' do
     rel.to_array(:sort => ordering).should eq(expected)

data/spec/integration/test_examples.rb

@@ -6,8 +6,24 @@ Dir["#{File.expand_path('../../../examples', __FILE__)}/**/*.alf"].each do |file
     let(:example_dir) { File.dirname(file) }
     let(:example_db) { Alf.connect(example_dir) }
 
-    it "should run without error" do
-      example_db.query(File.read(example_path), example_path)
+    let(:source){ File.read(example_path) }
+
+    context 'when compiled' do
+      subject{
+        example_db.compile(example_db.parse(source))
+      }
+
+      it_should_behave_like "a traceable cog"
+    end
+
+    context 'when queried' do
+      subject{
+        example_db.query(source, example_path)
+      }
+      
+      it "should run without error" do
+        subject.should be_a(Relation)
+      end
     end
   end
 

data/spec/shared/a_cog.rb

@@ -0,0 +1,36 @@
+shared_examples_for 'a cog' do
+
+  it { should be_a(Alf::Engine::Cog) }
+
+  it 'should return self on to_cog' do
+    subject.to_cog.should be(subject)
+  end
+
+end
+
+shared_examples_for 'a traceable cog' do
+
+  it_should_behave_like "a cog"
+
+  def has_tracking!(compiled)
+    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|
+        has_tracking!(op)
+      end
+    else
+      raise "Unexpected cog: #{compiled}"
+    end
+  end
+
+  it 'should have traceability all way down expression' do
+    has_tracking!(subject)
+  end
+
+end

data/spec/spec_helper.rb

@@ -5,6 +5,7 @@ require 'shared/an_operator_class'
 require 'shared/a_valid_type_implementation'
 require 'shared/a_value'
 require 'shared/a_scope'
+require 'shared/a_cog'
 
 (Path.dir/"unit").glob("**/shared_examples/*").each do |f|
   require(f)
@@ -54,6 +55,13 @@ module Helpers
     Alf::Algebra::Operand::Fake.new
   end
 
+  def viewpoint(&bl)
+    Module.new{
+      include Alf::Viewpoint
+      instance_exec(&bl)
+    }
+  end
+
 end
 
 module HelpersInScope

data/spec/unit/alf-algebra/operand/test_proxy.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+module Alf
+  module Algebra
+    module Operand
+      describe Proxy do
+
+        DELEGATED = [ :heading, :keys ]
+
+        subject{
+          Proxy.new(victim).send(method)
+        }
+
+        DELEGATED.each do |method|
+          context "with #{method} with knowing victim" do
+            let(:method){
+              method
+            }
+            let(:victim){
+              Struct.new(method).new("foo")
+            }
+
+            before do
+              victim.should respond_to(method)
+            end
+
+            it "should delegate it" do
+              subject.should eq("foo")
+            end
+          end
+
+          context "with #{method} with knowing victim" do
+            let(:method){
+              method
+            }
+            let(:victim){
+              Object.new
+            }
+
+            before do
+              victim.should_not respond_to(method)
+            end
+
+            it "should raise a NotSupportedError" do
+              lambda{
+                subject
+              }.should raise_error(NotSupportedError)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/unit/alf-algebra/operator/hierarchize/test_heading.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+module Alf
+  module Algebra
+    describe Hierarchize, "heading" do
+
+      let(:base){
+        {id: Integer, parent: Integer, city: String}
+      }
+      let(:operand){
+        an_operand.with_heading(base)
+      }
+      let(:op){
+        a_lispy.hierarchize(operand, :id, :parent, :as)
+      }
+      subject{ op.heading }
+
+      it{
+        should eq(Relation.type(base){|r| {:as => r} }.heading)
+      }
+
+    end
+  end
+end