alki 0.8.0 → 0.9.0

data/lib/alki/execution/cache_entry.rb

@@ -0,0 +1,16 @@
+module Alki
+  module Execution
+    class CacheEntry
+      attr_accessor :type,:value,:status
+      def initialize
+        @status = :building
+      end
+
+      def finish(type,value)
+        @status = :done
+        @type = type
+        @value = value
+      end
+    end
+  end
+end

data/lib/alki/execution/context.rb

@@ -0,0 +1,29 @@
+require 'alki/service_delegator'
+
+module Alki
+  module Execution
+    module Context
+      def lookup(*path)
+        path.flatten.inject(self) do |group,elem|
+          unless elem.is_a?(String) or elem.is_a?(Symbol)
+            raise ArgumentError.new("lookup can only take Strings or Symbols")
+          end
+          elem.to_s.split('.').inject(group) do |group,name|
+            raise "Invalid lookup elem" unless group.is_a? Context
+            group.send name.to_sym
+          end
+        end
+      end
+
+      def lazy(*path)
+        path = path.flatten.inject('') do |path,elem|
+          unless elem.is_a?(String) or elem.is_a?(Symbol)
+            raise ArgumentError.new("lookup can only take Strings or Symbols")
+          end
+          path << elem.to_s
+        end
+        Alki::ServiceDelegator.new self, path
+      end
+    end
+  end
+end

data/lib/alki/execution/context_class_builder.rb

@@ -0,0 +1,36 @@
+require 'alki/class_builder'
+
+module Alki
+  module Execution
+    module ContextClassBuilder
+      def self.build(config)
+        if config[:body]
+          methods = {
+            __call__: {body: (config[:body])},
+            meta: {body: ->{@__meta__}}
+          }
+        else
+          methods = {}
+        end
+        (config[:scope]||{}).each do |name,path|
+          methods[name] = {
+            body:->(*args,&blk) {
+              @__executor__.execute @__meta__, path, args, blk
+            }
+          }
+        end
+        (config[:methods]||{}).each do |name,body|
+          methods[name] = {
+            body: body,
+            private: true,
+          }
+        end
+        ClassBuilder.build(
+          initialize_params: [:__executor__,:__meta__],
+          modules: config[:modules],
+          instance_methods: methods,
+        )
+      end
+    end
+  end
+end

data/lib/alki/execution/value_context.rb

@@ -0,0 +1,14 @@
+require 'alki/execution/context'
+require 'alki/overlay_delegator'
+
+module Alki
+  module Execution
+    module ValueContext
+      include Context
+
+      def delegate_overlay(obj,overlay,**args)
+        Alki::OverlayDelegator.new(obj,overlay,args)
+      end
+    end
+  end
+end

data/lib/alki/overlay_delegator.rb

@@ -1,33 +1,21 @@
 module Alki
   class OverlayDelegator
-    def initialize(name,obj,overlay)
-      @name = name
+    def initialize(obj,overlay,info=nil)
       @obj = obj
       @overlay = overlay
-      @key = :"#{obj.object_id}:#{overlay.object_id}"
+      @info = info
     end
 
     def respond_to_missing(method,include_private = false)
-      unless Thread.current[@key]
-        Thread.current[@key] = true
-        if @overlay.respond_to? :overlay_respond_to?
-          @overlay.overlay_respond_to? @obj, method, include_private
-        else
-          @obj.respond_to? method, include_private
-        end
-        Thread.current[@key] = false
+      if @overlay.respond_to? :overlay_respond_to?
+        @overlay.overlay_respond_to? @obj, method, include_private
+      else
+        @obj.respond_to? method, include_private
       end
     end
 
     def method_missing(method,*args,&blk)
-      if Thread.current[@key]
-        res = @obj.send method, *args, &blk
-      else
-        Thread.current[@key] = true
-        res = @overlay.overlay_send @name, @obj, method, *args, &blk
-        Thread.current[@key] = false
-      end
-      res
+      @overlay.overlay_send @obj, @info, method, *args, &blk
     end
   end
-end
+end

data/lib/alki/overlay_info.rb

@@ -0,0 +1,3 @@
+module Alki
+  OverlayInfo = Struct.new(:target,:overlay,:args)
+end

data/lib/alki/override_builder.rb

@@ -4,9 +4,11 @@ module Alki
   module OverrideBuilder
     def self.build(override_hash=nil,&blk)
       if blk
-        Alki::Dsls::Assembly.build(&blk)[:root]
+        Alki::Dsls::AssemblyGroup.build(&blk)
       elsif override_hash && !override_hash.empty?
-        create_override_group override_hash
+        { root: create_override_group(override_hash), overlays: [] }
+      else
+        { root: nil, overlays: [] }
       end
     end
 
@@ -28,8 +30,8 @@ module Alki
     end
 
     def self.build_type(type,*args)
-      Alki::Support.load_class("alki/assembly_types/#{type}").new *args
+      Alki::Support.load_class("alki/assembly/types/#{type}").new *args
     end
 
   end
-end
+end

data/lib/alki/service_delegator.rb

@@ -2,13 +2,13 @@ require 'delegate'
 
 module Alki
   class ServiceDelegator < Delegator
-    def initialize(app,path)
-      @app = app
+    def initialize(elem,path)
+      @elem = elem
       @path = path
     end
 
     def __getobj__
-      @obj ||= @app.lookup(@path)
+      @obj ||= @elem.lookup(@path)
     end
   end
 end

data/lib/alki/version.rb

@@ -1,3 +1,3 @@
 module Alki
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end

data/lib/alki.rb

@@ -1,17 +1,17 @@
 require 'alki/dsl'
-require 'alki/assembly_builder'
+require 'alki/assembly/builder'
 
 module Alki
   class << self
     def project_assembly!(opts={},&blk)
       opts[:project_assembly] ||= caller_locations(1,1)[0].absolute_path
-      AssemblyBuilder.build(opts,&blk)
+      Assembly::Builder.build(opts,&blk)
     end
 
     alias_method :create_assembly!, :project_assembly!
 
     def create_assembly(opts={},&blk)
-      AssemblyBuilder.build(opts,&blk)
+      Assembly::Builder.build(opts,&blk)
     end
   end
-end
+end

data/test/feature/alki_test.rb

@@ -1,5 +1,4 @@
-require_relative '../test_helper'
-require 'alki'
+require 'alki/feature_test'
 
 describe Alki do
   describe :create_assembly do

data/test/feature/example_test.rb

@@ -1,5 +1,4 @@
-require_relative '../test_helper'
-
+require 'alki/test'
 
 $LOAD_PATH.unshift Alki::Test.fixture_path('example','lib')
 $LOAD_PATH.unshift Alki::Test.fixture_path('tlogger','lib')
@@ -46,4 +45,4 @@ describe 'Example' do
   it 'should have config_dir value' do
     Example.new.config_dir.must_equal Alki::Test.fixture_path('example','config')
   end
-end
+end

data/test/feature/factories_test.rb

@@ -0,0 +1,48 @@
+require 'alki/feature_test'
+
+describe 'Factories' do
+  def assembly(&blk)
+    @assembly = Alki.create_assembly(&blk)
+  end
+
+  def obj
+    @obj ||= @assembly.new
+  end
+
+  it 'should call returned callable when referenced' do
+    assembly do
+      factory :test do
+        -> (val) { val + 1 }
+      end
+    end
+    obj.test(1).must_equal 2
+  end
+
+  it 'should evaluate the given block once' do
+    counter = 0
+    proc_counter = 0
+    assembly do
+      factory :test do
+        counter += 1
+        -> (val) {
+          proc_counter += 1
+          val
+        }
+      end
+    end
+    obj.test(1)
+    obj.test(1)
+    counter.must_equal 1
+    proc_counter.must_equal 2
+  end
+
+  it 'should return Proc of factory if no arguments are provided when referenced' do
+    assembly do
+      factory :test do
+        -> (val) { val + 1 }
+      end
+    end
+    proc = obj.test
+    proc.call(1).must_equal 2
+  end
+end

data/test/feature/overlays_test.rb

@@ -0,0 +1,225 @@
+require 'alki/feature_test'
+
+describe 'Overlays' do
+  it 'should allow setting an overlay on a service' do
+    values = []
+    assembly = Alki.create_assembly do
+      service :svc do
+        :test
+      end
+
+      overlay :svc, :test_overlay
+
+      set :test_overlay, ->(value) {values << value; :transformed}
+    end
+    assembly.new.svc.must_equal :transformed
+    values.must_equal [:test]
+  end
+
+  it 'should call new if overlay responds to it' do
+    assembly = Alki.create_assembly do
+      service :svc do
+        :test
+      end
+
+      overlay :svc, :test_overlay
+
+      set :test_overlay, Struct.new(:val)
+    end
+    assembly.new.svc.val.must_equal :test
+  end
+
+  it 'should allow using factories as overlays' do
+    values = []
+    assembly = Alki.create_assembly do
+      service :svc do
+        :test
+      end
+
+      overlay :svc, :test_overlay
+
+      factory :test_overlay do
+        ->(value) {values << value; :transformed}
+      end
+    end
+    assembly.new.svc.must_equal :transformed
+    values.must_equal [:test]
+  end
+
+  it 'should allow setting an overlay on groups of services' do
+    values = []
+    assembly = Alki.create_assembly do
+      service :svc do
+        :test
+      end
+
+      group :svcs do
+        service :one do
+          :svc_one
+        end
+
+        service :two do
+          :svc_two
+        end
+      end
+
+      overlay :svcs, :test_overlay
+
+      set :test_overlay, ->(value) {values << value; "overlay_#{value}".to_sym}
+    end
+    obj = assembly.new
+    obj.svc.must_equal :test
+    obj.svcs.one.must_equal :overlay_svc_one
+    obj.svcs.two.must_equal :overlay_svc_two
+    values.must_equal [:svc_one,:svc_two]
+  end
+
+  it 'should not apply to non-services' do
+    values = []
+    assembly = Alki.create_assembly do
+      group :vals do
+        set :one do
+          :val_one
+        end
+
+        factory :two do
+          ->(v) { "val_two_#{v}".to_sym }
+        end
+
+        func :three do
+          :val_three
+        end
+      end
+
+      overlay :vals, :test_overlay
+
+      set :test_overlay, ->(value) {values << value; "overlay_#{value}".to_sym}
+    end
+    obj = assembly.new
+    obj.vals.one.must_equal :val_one
+    obj.vals.two(1).must_equal :val_two_1
+    obj.vals.three.must_equal :val_three
+    values.must_equal []
+  end
+
+  it 'should chain overlays when multiple are set' do
+    values = []
+    assembly = Alki.create_assembly do
+
+      group :svcs do
+        service :svc do
+          :test
+        end
+      end
+
+      overlay :svcs, :overlay1
+      overlay 'svcs.svc', :overlay2
+
+      set :overlay1, ->(value) {values << value; "overlay_#{value}".to_sym}
+      set :overlay2, ->(value) {values << value; :transformed}
+
+    end
+    obj = assembly.new
+    obj.svcs.svc.must_equal :transformed
+    values.must_equal [:test,:overlay_test]
+  end
+
+  it 'should follow paths when setting overlay targets' do
+    values = []
+    assembly = Alki.create_assembly do
+      service :svc do
+        :test
+      end
+
+      group :grp do
+        overlay 'assembly.svc', :test_overlay
+
+        set :test_overlay, ->(value) {values << value; :transformed}
+      end
+    end
+    obj = assembly.new
+    obj.svc.must_equal :transformed
+    values.must_equal [:test]
+  end
+
+  it 'should raise error if either target or overlay paths are invalid' do
+    assembly = Alki.create_assembly do
+      service :svc do
+        :test
+      end
+      overlay :invalid, :test_overlay
+      set :test_overlay, ->(value) {:child}
+    end
+    assert_raises Alki::InvalidPathError do
+      assembly.new.svc
+    end
+    assembly = Alki.create_assembly do
+      service :svc do
+        :test
+      end
+      overlay :svc, :invalid
+    end
+    assert_raises Alki::InvalidPathError do
+      assembly.new.svc
+    end
+  end
+
+  it 'should set overlays through mounted assemblies' do
+    child = Alki.create_assembly do
+      service :svc do
+        :test
+      end
+      overlay 'parent.svc', :test_overlay
+      set :test_overlay, ->(value) {:child}
+    end
+    assembly = Alki.create_assembly do
+      service :svc do
+        :test
+      end
+      mount :mounted, child
+      overlay 'mounted.svc', :test_overlay
+      set :test_overlay, ->(value) {:parent}
+    end
+    obj = assembly.new
+    obj.svc.must_equal :child
+    obj.mounted.svc.must_equal :parent
+  end
+
+  it 'should set overlays from overrides' do
+    child = Alki.create_assembly do
+      service :svc1 do
+        :test
+      end
+    end
+    assembly = Alki.create_assembly do
+      service :svc2 do
+        :test
+      end
+      mount :mounted, child do
+        overlay 'original.svc1', :test_overlay
+        set :test_overlay, ->(value) {:parent}
+      end
+    end
+    obj = assembly.new do
+      overlay 'original.svc2', :test_overlay
+      set :test_overlay, ->(value) {:child}
+    end
+    obj.svc2.must_equal :child
+    obj.mounted.svc1.must_equal :parent
+  end
+
+  it 'should allow setting overlays on assembly_instance' do
+    values = []
+    assembly = Alki.create_assembly do
+      overlay :assembly_instance, :test_overlay
+
+      set :test_overlay, ->(value) {
+        values << value
+        :transformed
+      }
+    end
+    assembly.new.must_equal :transformed
+    values.size.must_equal 1
+    values[0].must_be_instance_of Alki::Assembly::Instance
+  end
+end

data/test/feature/overrides_test.rb

@@ -1,6 +1,5 @@
-require_relative '../test_helper'
+require 'alki/feature_test'
 require 'logger'
-require 'alki'
 require 'stringio'
 
 describe 'Overrides' do

data/test/feature/pseudo_elements_test.rb

@@ -0,0 +1,67 @@
+require 'alki/feature_test'
+
+describe 'Pseudo Elements' do
+  before do
+    @config_dir = fixture_path('example','config')
+    two = Alki.create_assembly do
+      set :num, 2
+      set :assembly_num do
+        assembly.num
+      end
+      set :parent_num do
+        parent.num
+      end
+      set :grandparent_num do
+        parent.parent.num
+      end
+      set :root_num do
+        root.num
+      end
+    end
+    one = Alki.create_assembly do
+      mount :two, two
+      set :num, 1
+    end
+    zero = Alki.create_assembly(config_dir: @config_dir) do
+      mount :one, one
+      set :num, 0
+      set :has_parent do
+        respond_to?(:parent)
+      end
+    end
+    @assembly = zero
+    @obj = @assembly.new
+  end
+
+  describe 'assembly' do
+    it 'should be the local assembly of the referring element' do
+      @obj.one.two.assembly_num.must_equal 2
+    end
+  end
+
+  describe 'parent' do
+    it 'should be the parent assembly of the referring element' do
+      @obj.one.two.parent_num.must_equal 1
+    end
+
+    it 'should be attribute on all assemblies with parents' do
+      @obj.one.two.grandparent_num.must_equal 0
+    end
+
+    it 'should only exist if assembly has parent' do
+      @obj.has_parent.must_equal false
+    end
+  end
+
+  describe 'root' do
+    it 'should be the root assembly' do
+      @obj.one.two.root_num.must_equal 0
+    end
+  end
+
+  describe 'config_dir' do
+    it 'should be the config_dir setting set in the assembly when it was created' do
+      @obj.config_dir.must_equal @config_dir
+    end
+  end
+end

data/test/feature_test_helper.rb

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

data/test/fixtures/example/config/assembly.rb

@@ -2,6 +2,15 @@ Alki do
   load :settings
   load :handlers
 
+  factory :log_overlay do
+    require 'log_overlay'
+    -> (obj) {
+      delegate_overlay obj, LogOverlay.new(log), name: meta[:building]
+    }
+  end
+
+  overlay :handlers, :log_overlay
+
   service :handler do
     require 'switch_handler'
     SwitchHandler.new [
@@ -31,7 +40,7 @@ Alki do
     StringIO.new
   end
 
-  assembly :tlogger do
+  mount :tlogger do
     set :io do
       log_io
     end
@@ -46,4 +55,4 @@ Alki do
       msg[0].upcase+msg[1..-1].downcase+"!"
     }
   end
-end
+end

data/test/fixtures/example/config/handlers.rb

@@ -2,7 +2,7 @@ Alki do
   factory :num_handler do
     require 'num_handler'
     -> (num,str) {
-      NumHandler.new num, str, output
+      NumHandler.new(num, str, output)
     }
   end
 
@@ -22,9 +22,4 @@ Alki do
     require 'echo_handler'
     EchoHandler.new output
   end
-
-  overlay do
-    require 'log_overlay'
-    LogOverlay.new lookup('log')
-  end
-end
+end

data/test/fixtures/example/lib/log_overlay.rb

@@ -3,8 +3,8 @@ class LogOverlay
     @log = log
   end
 
-  def overlay_send(name,obj,method,*args,&blk)
-    @log << "Calling #{name}##{method} #{args.join(", ")}\n"
+  def overlay_send(obj,info,method,*args,&blk)
+    @log << "Calling #{info[:name]}##{method} #{args.join(", ")}\n"
     obj.public_send method, *args, &blk
   end
-end
+end

data/test/integration/dsls/assembly_test.rb

@@ -1,25 +1,20 @@
-require_relative '../../test_helper'
+require 'alki/test'
 require 'alki/dsls/assembly'
 
 describe Alki::Dsls::Assembly do
-  it 'should work' do
+  it 'should allow creating Assembly config classes' do
     res = Alki::Dsls::Assembly.build do
       service :test do
         :val
       end
 
-      load 'file'
-
       group :group1 do
         service :test2 do
           :val2
         end
       end
     end
-    res[:class].root.children[:file].name.must_equal 'file'
     res[:class].root.children[:test].must_respond_to :block
     res[:class].root.children[:group1].children[:test2].must_respond_to :block
-
-    r = res[:class].root.lookup [:group1,:test2]
   end
-end
+end