alki 0.9.1 → 0.10.0

data/lib/alki/dsls/assembly.rb

@@ -5,15 +5,14 @@ Alki do
   finish do
     add :config_dir, build(:value, ctx[:config_dir])
     add :assembly_name, build(:value, ctx[:assembly_name])
-    prefix_overlays :original, ctx[:overlays]
 
     root = ctx[:root]
-    overlays = ctx[:overlays]
+    meta = ctx[:meta]
     add_class_method :root do
       root
     end
-    add_class_method :overlays do
-      overlays
+    add_class_method :meta do
+      meta
     end
   end
 end

data/lib/alki/dsls/assembly_group.rb

@@ -3,31 +3,52 @@ require 'alki/support'
 require 'alki/overlay_info'
 
 Alki do
-  require_dsl 'alki/dsls/dsl'
-
   init do
     ctx[:root] = build(:group,{})
-    ctx[:overlays] = []
+    ctx[:meta] = []
   end
 
   helper :add do |name,elem|
+    if @tags
+      ctx[:meta] << [[name.to_sym],:tags,@tags]
+      @tags = nil
+    end
     ctx[:root].children[name.to_sym] = elem
     nil
   end
 
   helper :build do |type,*args|
-    Alki::Support.load_class("alki/assembly/types/#{type}").new *args
+    Alki.load("alki/assembly/types/#{type}").new *args
   end
 
-  helper :prefix_overlays do |*prefix,overlays|
-    overlays.each do |overlay|
-      overlay[0].unshift *prefix
+  dsl_method :add_overlay do |type,target,overlay,args|
+    (ctx[:meta]||=[]) << [
+      [], :overlay,
+      Alki::OverlayInfo.new(
+        type,
+        target.to_s.split('.').map(&:to_sym),
+        overlay.to_s.split('.').map(&:to_sym),
+        args
+      )
+    ]
+  end
+
+  helper :prefix_meta do |*prefix,meta|
+    meta.each do |data|
+      data[0].unshift *prefix.map(&:to_sym)
     end
-    overlays
+    meta
+  end
+
+  helper :update_meta do |*prefix,meta|
+    ctx[:meta].push *prefix_meta(*prefix,meta)
   end
 
-  helper :update_overlays do |*prefix,overlays|
-    ctx[:overlays].push *prefix_overlays(*prefix,overlays)
+  dsl_method :tag do |*tags|
+    unless tags.all?{|t| t.is_a? Symbol }
+      raise "Tags must be symbols"
+    end
+    @tags = tags
   end
 
   dsl_method :config_dir do
@@ -57,36 +78,36 @@ Alki do
   dsl_method :group do |name,&blk|
     grp = Alki::Dsls::AssemblyGroup.build(&blk)
     add name, grp[:root]
-    update_overlays name, grp[:overlays]
+    update_meta name, grp[:meta]
   end
 
   dsl_method :load do |group_name,name=group_name.to_s|
-    grp = Alki::Dsl.load(File.expand_path(name+'.rb',ctx[:config_dir]))[:class]
+    unless ctx[:prefix]
+      raise "Load command is not available without a config directory"
+    end
+    grp = Alki.load(File.join(ctx[:prefix],name))
     add name, grp.root
-    update_overlays name, grp.overlays
+    update_meta name, grp.meta
   end
 
   dsl_method :mount do |name,pkg=name.to_s,**overrides,&blk|
-    klass = Alki::Support.load_class pkg
-    mounted_assemblies = klass.overlays.map do |(path,info)|
-      [path.dup,info]
+    klass = Alki.load pkg
+    mounted_meta = klass.meta.map do |(path,type,info)|
+      [path.dup,type,info]
     end
-    update_overlays name, mounted_assemblies
+    update_meta name, mounted_meta
 
     overrides = Alki::OverrideBuilder.build overrides, &blk
-    update_overlays name, overrides[:overlays]
+    update_meta name, overrides[:meta]
 
     add name, build(:assembly, klass.root, overrides[:root])
   end
 
+  dsl_method :reference_overlay do |target,overlay,*args|
+    add_overlay :reference, target, overlay, args
+  end
+
   dsl_method :overlay do |target,overlay,*args|
-    (ctx[:overlays]||=[]) << [
-      [],
-      Alki::OverlayInfo.new(
-        target.to_s.split('.').map(&:to_sym),
-        overlay.to_s.split('.').map(&:to_sym),
-        args
-      )
-    ]
+    add_overlay :value, target, overlay, args
   end
 end

data/lib/alki/dsls/assembly_type.rb

@@ -1,22 +1,12 @@
-require 'alki/assembly/handler_base'
+require 'alki/assembly/type'
+require 'alki/assembly/handler'
 
 Alki do
   require_dsl 'alki/dsls/class'
 
   init do
-    set_super_class Alki::Assembly::HandlerBase, subclass: 'Handler'
-
-    add_method :handler, private: true do |*args|
-      self.class::Handler.new(self,*args)
-    end
-
-    add_method :index do |*args|
-      handler(*args).index
-    end
-
-    add_method :output do |*args|
-      handler(*args).output
-    end
+    set_super_class Alki::Assembly::Handler, subclass: 'Handler'
+    set_super_class Alki::Assembly::Type
 
     # Add defined methods to handler class
     class_builder('Handler')[:module] = class_builder[:module]

data/lib/alki/execution/context.rb

@@ -1,28 +1,25 @@
-require 'alki/service_delegator'
-
+require 'alki/execution/reference'
 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
+    class Context
+      def initialize(executor,meta)
+        @__executor__ = executor
+        @__meta__ = meta
+      end
+
+      private
+
+      def __reference__(path,args,blk)
+        Reference.new(@__executor__,@__meta__,path,args,blk)
       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
+      def __execute__(path,args,blk)
+        ref = __reference__ path, args, blk
+        if respond_to?(:__process_reference__,true)
+          __process_reference__ ref
+        else
+          ref.call
         end
-        Alki::ServiceDelegator.new self, path
       end
     end
   end

data/lib/alki/execution/context_class_builder.rb

@@ -1,4 +1,5 @@
 require 'alki/class_builder'
+require 'alki/execution/context'
 
 module Alki
   module Execution
@@ -15,9 +16,22 @@ module Alki
         (config[:scope]||{}).each do |name,path|
           methods[name] = {
             body:->(*args,&blk) {
-              @__executor__.execute @__meta__, path, args, blk
+               __execute__ path, args, blk
             }
           }
+
+          methods[:"__raw_#{name}__"] = {
+            body:->(*args,&blk) {
+              @__executor__.execute @__meta__, path, args, blk
+            },
+            private: true
+          }
+
+          methods[:"__reference_#{name}__"] = {
+            body:->(*args,&blk) {
+              __reference__ path, args, blk
+            },
+          }
         end
         (config[:methods]||{}).each do |name,body|
           methods[name] = {
@@ -26,7 +40,7 @@ module Alki
           }
         end
         ClassBuilder.build(
-          initialize_params: [:__executor__,:__meta__],
+          super_class: Alki::Execution::Context,
           modules: config[:modules],
           instance_methods: methods,
         )

data/lib/alki/execution/helpers.rb

@@ -0,0 +1,29 @@
+require 'alki/service_delegator'
+
+module Alki
+  module Execution
+    module Helpers
+      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? Helpers
+            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/reference.rb

@@ -0,0 +1,18 @@
+module Alki
+  module Execution
+    class Reference
+      attr_accessor :executor, :meta, :path, :args, :blk
+      def initialize(executor,meta,path,args,blk)
+        @executor = executor
+        @meta = meta
+        @path = path
+        @args = args
+        @blk = blk
+      end
+
+      def call
+        @executor.execute @meta, @path, @args, @blk
+      end
+    end
+  end
+end

data/lib/alki/execution/value_helpers.rb

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

data/lib/alki/overlay_info.rb

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

data/lib/alki/override_builder.rb

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

data/lib/alki/version.rb

@@ -1,3 +1,3 @@
 module Alki
-  VERSION = "0.9.1"
+  VERSION = "0.10.0"
 end

data/lib/alki_loader.rb

@@ -0,0 +1,2 @@
+Alki::Loader.register 'alki/assembly/types', builder: 'alki/dsls/assembly_type'
+Alki::Loader.register 'alki/dsls', builder: 'alki/dsls/dsl'

data/test/feature/alki_test.rb

@@ -22,11 +22,12 @@ describe Alki do
     end
 
     it 'should load assembly definition from config_dir if provided' do
-      build(config_dir: fixture_path('tlogger','config')).new.must_respond_to :log
+      build(name: 'tlogger', config_dir: fixture_path('tlogger','config')).new.must_respond_to :log
     end
 
     it 'should load file other than assembly if provided with primary_config' do
       build(
+        name: 'example',
         config_dir: fixture_path('example','config'),
         primary_config: 'settings'
       ).new.must_respond_to :fizz
@@ -35,16 +36,13 @@ describe Alki do
     it 'should create class if provided with a name' do
       klass = build(name: 'alki_test/test_assembly')
       AlkiTest::TestAssembly.must_equal klass
-      Object.send :remove_const, :AlkiTest
+      undefine :AlkiTest
     end
 
     it 'should automatically determine config_dir and name if project_assembly provided' do
-      was_defined = defined? Tlogger
-      Object.send :remove_const, :Tlogger if was_defined
       klass = build(project_assembly: fixture_path('tlogger','lib','tlogger.rb'))
       Tlogger.must_equal klass
       klass.new.must_respond_to :log
-      Object.send :remove_const, :Tlogger unless was_defined
     end
   end
 

data/test/feature/example_test.rb

@@ -1,7 +1,4 @@
-require 'alki/test'
-
-$LOAD_PATH.unshift Alki::Test.fixture_path('example','lib')
-$LOAD_PATH.unshift Alki::Test.fixture_path('tlogger','lib')
+require 'alki/feature_test'
 
 describe 'Example' do
   before do

data/test/feature/overlays_test.rb

@@ -208,6 +208,40 @@ describe 'Overlays' do
     obj.mounted.svc1.must_equal :parent
   end
 
+  it 'should set overlays on overridden elements' do
+    child = Alki.create_assembly do
+      set :test_overlay, ->(value) {:"#{value}_child"}
+      overlay 'svc1', :test_overlay
+      service :svc1 do
+        :test1
+      end
+    end
+    assembly = Alki.create_assembly do
+      group :grp do
+        service :svc2 do
+          :test2
+        end
+      end
+      overlay 'grp.svc2', :test_overlay
+      set :test_overlay, ->(value) {:"#{value}_parent"}
+
+      mount :mounted, child do
+        service :svc1 do
+          :test12
+        end
+      end
+    end
+    obj = assembly.new do
+      group :grp do
+        service :svc2 do
+          :test22
+        end
+      end
+    end
+    obj.mounted.svc1.must_equal :test12_child
+    obj.grp.svc2.must_equal :test22_parent
+  end
+
   it 'should allow setting overlays on assembly_instance' do
     values = []
     mock = Minitest::Mock.new

data/test/feature/pseudo_elements_test.rb

@@ -22,7 +22,7 @@ describe 'Pseudo Elements' do
       mount :two, two
       set :num, 1
     end
-    zero = Alki.create_assembly(config_dir: @config_dir) do
+    zero = Alki.create_assembly(name: 'alki_test', config_dir: @config_dir) do
       mount :one, one
       set :num, 0
       set :has_parent do

data/test/feature/reference_overlays_test.rb

@@ -0,0 +1,24 @@
+require 'alki/feature_test'
+
+describe 'Reference Overlays' do
+  it 'should allow overlaying all references made by a service' do
+    assembly = Alki.create_assembly do
+      set :val, :val
+      service :svc_ref do
+        :svc
+      end
+      func :func do
+        :func
+      end
+      factory :fact do
+        -> val { val }
+      end
+      service :svc do
+        :"#{val}_#{svc_ref}_#{func}_#{fact(:f1)}_#{fact(:f2)}"
+      end
+      reference_overlay :svc, :overlay
+      set :overlay, -> ref { :"o#{ref.call}"}
+    end
+    assembly.new.svc.must_equal :oval_osvc_ofunc_of1_of2
+  end
+end

data/test/feature/tags_test.rb

@@ -0,0 +1,77 @@
+require 'alki/feature_test'
+
+describe 'Tags' do
+  it 'should allow setting overlays via tags' do
+    assembly = Alki.create_assembly do
+      tag :tag1, :tag2
+      service :svc1 do
+        :svc1
+      end
+
+      tag :tag1
+      service :svc2 do
+        :svc2
+      end
+
+      overlay '%tag1', :overlay1
+      overlay '%tag2', :overlay2
+
+      set :overlay1, -> val { :"one_#{val}"}
+      set :overlay2, -> val { :"two_#{val}"}
+    end
+    obj = assembly.new
+
+    obj.svc1.must_equal :two_one_svc1
+    obj.svc2.must_equal :one_svc2
+  end
+
+  it 'should apply to all elements in groups' do
+    assembly = Alki.create_assembly do
+      tag :tag1
+      group :grp do
+        service :svc1 do
+          :svc1
+        end
+
+        service :svc2 do
+          :svc2
+        end
+      end
+
+      overlay '%tag1', :overlay1
+      set :overlay1, -> val { :"one_#{val}"}
+    end
+    obj = assembly.new
+
+    obj.grp.svc1.must_equal :one_svc1
+    obj.grp.svc2.must_equal :one_svc2
+  end
+
+  it 'should be accessible through mounts' do
+    child = Alki.create_assembly do
+      tag :tag1
+      service :svc1 do
+        :svc1
+      end
+
+      overlay '%tag2', :overlay
+      set :overlay, -> val { :"child_#{val}"}
+    end
+
+    assembly = Alki.create_assembly do
+      mount :child, child
+
+      tag :tag2
+      service :svc2 do
+        :svc2
+      end
+
+      overlay '%tag1', :overlay
+      set :overlay, -> val { :"parent_#{val}"}
+    end
+    obj = assembly.new
+
+    obj.svc2.must_equal :child_svc2
+    obj.child.svc1.must_equal :parent_svc1
+  end
+end

data/test/feature_test_helper.rb

@@ -1 +1,35 @@
 require 'alki'
+
+
+class Minitest::Spec
+  before do
+    @test_projects = [
+      Alki::Test.fixture_path('example'),
+      Alki::Test.fixture_path('tlogger')
+    ]
+    @test_projects.each do |proj|
+      $LOAD_PATH.unshift File.join(proj,'lib')
+    end
+  end
+
+  after do
+    $LOADED_FEATURES.delete_if do |p|
+      @test_projects.any? do |proj|
+        p.start_with?(File.join(proj,''))
+      end
+    end
+    $LOAD_PATH.delete_if do |p|
+      @test_projects.any? do |proj|
+        p.start_with?(File.join(proj,''))
+      end
+    end
+    undefine :Example, false
+    undefine :Tlogger, false
+  end
+
+  def undefine(sym,force=true)
+    if force || Object.const_defined?(sym)
+      Object.send :remove_const, sym
+    end
+  end
+end

data/test/integration/dsls/assembly_test.rb

@@ -14,7 +14,7 @@ describe Alki::Dsls::Assembly do
         end
       end
     end
-    res[:class].root.children[:test].must_respond_to :block
-    res[:class].root.children[:group1].children[:test2].must_respond_to :block
+    res.root.children[:test].must_respond_to :block
+    res.root.children[:group1].children[:test2].must_respond_to :block
   end
 end

data/test/integration/dsls/assembly_type_test.rb

@@ -3,7 +3,7 @@ require 'alki/dsls/assembly_type'
 
 describe Alki::Dsls::AssemblyType do
   def build(&blk)
-    @klass = Alki::Dsls::AssemblyType.build(&blk)[:class]
+    @klass = Alki::Dsls::AssemblyType.build(&blk)
   end
 
   def klass

data/test/integration/dsls/service_dsl_test.rb

@@ -3,7 +3,7 @@ require 'alki/dsls/service'
 
 describe Alki::Dsls::Service do
   def build(&blk)
-    @c = Alki::Dsls::Service.build(&blk)[:class]
+    @c = Alki::Dsls::Service.build(&blk)
   end
 
   describe :use do