alki 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bc042cd47800b613d12e02456c24d25afc170f7b
-  data.tar.gz: 1ab703cbc5c5458d181f3b8d2a4c357d4d9c4056
+  metadata.gz: 3555b8b45ee20ff856590c5bd5b38cd91042d93a
+  data.tar.gz: d97785bfd1cc1cb00da4166f08af02dc959149ee
 SHA512:
-  metadata.gz: b85b7153906906aaabb7d3dfc18e6060765f68bcf3a2885972acbbbd1c3d6a01a15b5c112205dc8fa0f64cf8403f056dd9091fadc2849e3051806cb4fe3fb183
-  data.tar.gz: b4dabbf9b1b3514ae65e189334848768670839d4e086bb6160158154ece8b7041def60184036e819c15df41de971ebb126849c1db62cb52917014615995f0abd
+  metadata.gz: 47710dd291c0d8d8c4bdcff0d01bf9d4c4c370697183aba0a846ddfbef1ffe1022eab6848227af07eccdf2c48773fce4856bf1c5f56c0ba78a44440e04bce1b3
+  data.tar.gz: 844374a0d77f694b1b7075326b5fbe5528dea1835a93bfe619a8289703edb2988c1d9ba385acaf32d2eeba93efda4a23e44d54755d21fa475d3cd73cd6820aae

data/Gemfile

@@ -1,3 +1,5 @@
 source 'https://rubygems.org'
 
+gem 'alki-testing', path: '/home/matt/Projects/personal/alki/alki-testing'
+
 gemspec

data/alki.gemspec

@@ -20,7 +20,8 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake", '~> 10.0'
-  spec.add_dependency "minitest", "~> 5.9", '>= 5.9.1'
-  spec.add_dependency "alki-dsl", "~> 0.4"
+  spec.add_dependency "alki-dsl", "~> 0.4", ">= 0.4.2"
   spec.add_dependency "alki-support", "~> 0.7"
+  spec.add_dependency "concurrent-ruby", "~> 1.0"
+  spec.add_dependency "ice_nine", "~> 0.11"
 end

data/config/assembly.rb

@@ -0,0 +1,21 @@
+Alki do
+  factory :delegate_overlay do
+    require 'alki/overlay_delegator'
+    -> obj, overlay, **args {
+      Alki::OverlayDelegator.new obj, overlay, args
+    }
+  end
+
+  factory :build_service do
+    -> (klass, grp=nil) {
+      klass = Alki.load klass
+      grp ||= parent
+      args = if klass.respond_to? :uses
+        klass.uses.map {|path| grp.lookup path }
+      else
+        []
+      end
+      klass.new *args
+    }
+  end
+end

data/lib/alki/assembly/executor.rb

@@ -1,24 +1,22 @@
 require 'alki/execution/context_class_builder'
 require 'alki/execution/cache_entry'
-require 'thread'
+require 'concurrent'
+require 'alki/invalid_path_error'
 
 module Alki
-  InvalidPathError = Class.new(StandardError)
   module Assembly
     class Executor
       def initialize(assembly,meta)
         @assembly = assembly
         @meta = meta
-        @data = {}
-        @semaphore = Monitor.new
+        @semaphore = Concurrent::ReentrantReadWriteLock.new
         @lookup_cache = {}
         @call_cache = {}
         @context_cache = {}
-        @processed_meta = false
       end
 
-      def synchronize
-        @semaphore.synchronize do
+      def lock
+        @semaphore.with_write_lock do
           yield
         end
       end
@@ -27,32 +25,19 @@ module Alki
         execute({},path,args,blk)
       end
 
-      def execute(meta,path,args,blk)
-        cache_entry = nil
-        synchronize do
-          cache_entry = @call_cache[path]
-        end
-        if cache_entry
-          if cache_entry.status == :building
-            raise "Circular element reference found: #{path.join(".")}"
-          end
-        else
-          synchronize do
-            cache_entry = @call_cache[path]
-            unless cache_entry
-              cache_entry = @call_cache[path] = Alki::Execution::CacheEntry.new
-              action = lookup(path)
-              if action[:build]
-                build_meta = meta.merge(building: path.join('.'))
-                build_meta.merge!(action[:meta]) if action[:meta]
-                build_action = action[:build].merge(scope: action[:scope],modules: action[:modules])
-                call_value(*process_action(build_action),build_meta,[action])
+      def lookup(path)
+        @semaphore.with_read_lock do
+          unless @lookup_cache[path]
+            @semaphore.with_write_lock do
+              @lookup_cache[path] = lookup_elem(path).tap do |elem|
+                unless elem
+                  raise InvalidPathError.new("Invalid path #{path.inspect}")
+                end
               end
-              cache_entry.finish *process_action(action)
             end
           end
+          @lookup_cache[path]
         end
-        call_value(cache_entry.type,cache_entry.value,meta,args,blk)
       end
 
       def canonical_path(from,path)
@@ -64,58 +49,52 @@ module Alki
         end
       end
 
-      private
-
-      def process_meta
-        unless @processed_meta
-          @processed_meta = true
-          @data[:overlays] = {}
-          @data[:tags] = {}
-          @meta.each do |(from,type,info)|
-            case type
-              when :overlay then process_overlay from, info
-              when :tags then process_tags from, info
+      def execute(meta,path,args,blk)
+        type,value = nil,nil
+        @semaphore.with_read_lock do
+          cache_entry = @call_cache[path]
+          if cache_entry
+            if cache_entry == :building
+              raise "Circular element reference found: #{path.join(".")}"
+            end
+            type,value = cache_entry.type,cache_entry.value
+          else
+            @semaphore.with_write_lock do
+              @call_cache[path] = :building
+              type, value = build(path)
+              @call_cache[path] = Alki::Execution::CacheEntry.finished type, value
             end
           end
         end
+        call_value(type, value, meta, args, blk)
       end
 
-      def process_tags(from,tags)
-        tags.each do |tag|
-          (@data[:tags][tag]||=[]) << from
-        end
-      end
+      private
 
-      def process_overlay(from,info)
-        target_path = info.target.dup
-        if target_path.last.to_s.start_with?('%')
-          tag = target_path.pop
-        end
-        if target_path == []
-          target_path = [:root]
+      def build(path)
+        action = lookup(path)
+        if action[:build]
+          build_meta = {building: path.join('.')}
+          build_meta.merge!(action[:meta]) if action[:meta]
+          build_action = action[:build].merge(scope: action[:scope], modules: action[:modules])
+          call_value(*process_action(build_action), build_meta, [action])
         end
-        target = canonical_path(from,target_path) or
-          raise InvalidPathError.new("Invalid overlay target #{info.target.join('.')}")
-        target = target.dup.push tag if tag
-        overlay = info.overlay
-        if overlay.is_a?(Array)
-          overlay = canonical_path(from,info.overlay) or
-            raise InvalidPathError.new("Invalid overlay path #{info.overlay.join('.')}")
-        end
-        (@data[:overlays][target]||=[]) << [info.type, overlay, info.args]
+        process_action action
       end
 
-      def lookup(path)
-        process_meta
-        @lookup_cache[path] ||= lookup_elem(path).tap do |elem|
-          unless elem
-            raise InvalidPathError.new("Invalid path #{path.inspect}")
+      def data_copy
+        unless @data
+          @data = {}
+          @meta.each do |(from,meta)|
+            meta.process self, from, @data
           end
+          IceNine.deep_freeze @data
         end
+        @data.dup
       end
 
       def lookup_elem(path)
-        data = @data.dup
+        data = data_copy
         elem = @assembly
         path.each do |key|
           elem = elem.index data, key

data/lib/alki/assembly/instance.rb

@@ -1,5 +1,7 @@
 require 'delegate'
+require 'concurrent'
 require 'alki/support'
+require 'concurrent'
 
 module Alki
   module Assembly
@@ -8,37 +10,46 @@ module Alki
         @assembly_module = assembly_module
         @args = args
         @version = 0
+        @needs_load = true
+        @lock = Concurrent::ReentrantReadWriteLock.new
       end
 
       def __reload__
-        if @obj.respond_to? :__reload__
-          did_something = @obj.__reload__
+        @lock.with_read_lock do
+          if @obj
+            @lock.with_write_lock do
+              @needs_load = true
+              @version+=1
+            end
+          end
         end
-        if did_something != false && @obj
-          __setobj__ nil
-          did_something = true
-        end
-        if did_something
-          GC.start
-        end
-        !!did_something
-      end
-
-      def __setobj__(obj)
-        @version += 1
-        @obj = obj
       end
 
       def __version__
-        @version
+        @lock.with_read_lock do
+          @version
+        end
       end
 
       def __getobj__
-        unless @obj
-          # Will call __setobj__
-          Alki.load(@assembly_module).raw_instance self, *@args
+        @lock.with_read_lock do
+          __load__ if @needs_load
+          @obj
+        end
+      end
+
+      private
+
+      def __load__
+        # Calls __setobj__
+        @lock.with_write_lock do
+          @needs_load = false
+          @obj.__unload__ if @obj.respond_to?(:__unload__)
+          Alki.load(@assembly_module).raw_instance *@args do |obj|
+            @obj = obj
+            self
+          end
         end
-        @obj
       end
     end
   end

data/lib/alki/assembly/meta/overlay.rb

@@ -0,0 +1,40 @@
+require 'alki/invalid_path_error'
+require 'alki/overlay_info'
+
+module Alki
+  module Assembly
+    module Meta
+      class Overlay
+        def initialize(type,target,overlay,args)
+          @type = type
+          @target = target
+          @overlay = overlay
+          @args = args
+        end
+
+        def process(executor,from,data)
+          data[:total_overlays] ||= 0
+          data[:overlays]||={}
+          target_path = @target.dup
+          if target_path.last.to_s.start_with?('%')
+            tag = target_path.pop
+          end
+          if target_path == []
+            target_path = [:root]
+          end
+          target = executor.canonical_path(from,target_path) or
+            raise InvalidPathError.new("Invalid overlay target #{@target.join('.')}")
+          target = target.dup.push tag if tag
+          overlay = @overlay
+          if overlay.is_a?(Array)
+            overlay = executor.canonical_path(from,@overlay) or
+              raise InvalidPathError.new("Invalid overlay path #{@overlay.join('.')}")
+          end
+          order = data[:total_overlays]
+          (data[:overlays][target]||=[]) << OverlayInfo.new(order,@type, overlay, @args)
+          data[:total_overlays] += 1
+        end
+      end
+    end
+  end
+end

data/lib/alki/assembly/meta/tags.rb

@@ -0,0 +1,18 @@
+module Alki
+  module Assembly
+    module Meta
+      class Tags
+        def initialize(tags)
+          @tags = tags
+        end
+
+        def process(_executor,from,data)
+          data[:tags]||={}
+          @tags.each do |tag|
+            (data[:tags][tag.to_sym]||=[]) << from
+          end
+        end
+      end
+    end
+  end
+end

data/lib/alki/assembly/types/factory.rb

@@ -5,7 +5,7 @@ Alki do
 
   output do
     {
-      modules: [Alki::Execution::ValueHelpers],
+      modules: [Alki::Execution::Helpers],
       scope: data[:scope],
       build: {
         methods: {

data/lib/alki/assembly/types/func.rb

@@ -4,7 +4,7 @@ Alki do
   attr :block
   output do
     {
-      modules: [Alki::Execution::ValueHelpers],
+      modules: [Alki::Execution::Helpers],
       scope: data[:scope],
       proc: block
     }

data/lib/alki/assembly/types/group.rb

@@ -6,6 +6,7 @@ Alki do
   index do
     update_scope children, data[:prefix], data[:scope]
 
+    data[:tags] ||= {}
     data[:tags] = data[:tags].inject({}) do |tags,(tag,tagged)|
       tagged.each do |path|
         if path.empty? || path[0] == key.to_sym
@@ -15,6 +16,7 @@ Alki do
       tags
     end
 
+    data[:overlays] ||= {}
     data[:overlays] = data[:overlays].inject({}) do |no,(target,overlays)|
       target = target.dup
       if target.size == 1 && target[0].to_s.start_with?('%')
@@ -36,10 +38,16 @@ Alki do
   end
 
   output do
+    children_names = children.keys.map(&:to_sym)
     {
       full_scope: update_scope(children, data[:prefix], data[:scope]),
       scope: update_scope(children,data[:prefix]),
       modules: [Alki::Execution::Helpers],
+      methods: {
+        children: -> {
+          children_names
+        }
+      },
       proc: ->{self}
     }
   end

data/lib/alki/assembly/types/proc_value.rb

@@ -11,7 +11,7 @@ Alki do
         },
         proc: ->(desc) {desc[:value] = __build__}
       },
-      modules: [Alki::Execution::ValueHelpers],
+      modules: [Alki::Execution::Helpers],
       scope: data[:scope]
     }
   end

data/lib/alki/assembly/types/service.rb

@@ -4,18 +4,19 @@ Alki do
   attr :block
 
   output do
-    overlays = (data[:overlays][[]]||[]).group_by(&:first)
+    overlays = (data[:overlays][[]]||[]).sort_by(&:order).group_by(&:type)
     value_overlays = overlays[:value]||[]
     reference_overlays = overlays[:reference]||[]
     methods = {
       __build__: block,
       __apply_overlays__: -> obj, overlays {
-        overlays.inject(obj) do |val,(_,overlay,args)|
+        overlays.inject(obj) do |val,info|
+          overlay = info.overlay
           overlay = __raw_root__.lookup(overlay) if overlay.is_a?(Array)
           if !overlay.respond_to?(:call) && overlay.respond_to?(:new)
             overlay = overlay.method(:new)
           end
-          overlay.call val, *args
+          overlay.call val, *info.args
         end
       }
     }
@@ -31,7 +32,7 @@ Alki do
           elem[:value] = __apply_overlays__ __build__, value_overlays
         },
       },
-      modules: [Alki::Execution::ValueHelpers],
+      modules: [Alki::Execution::Helpers],
       scope: data[:scope],
     }
   end

data/lib/alki/assembly.rb

@@ -1,9 +1,9 @@
 require 'alki/override_builder'
-require 'alki/assembly/types/assembly'
-require 'alki/assembly/types/group'
 require 'alki/assembly/instance'
 require 'alki/assembly/executor'
+require 'alki/assembly/meta/overlay'
 require 'alki/overlay_info'
+require 'ice_nine'
 
 module Alki
   module Assembly
@@ -11,24 +11,24 @@ module Alki
       Instance.new load_class, [overrides, blk]
     end
 
-    def raw_instance(instance,overrides,blk)
+    def raw_instance(overrides,blk,&wrapper)
       overrides_info = OverrideBuilder.build(overrides,&blk)
       override_root = overrides_info[:root] || build(:group)
 
       assembly = build :assembly, root, override_root
-      update_instance_overlay = [[],:overlay, OverlayInfo.new(
+      update_instance_overlay = [[],Meta::Overlay.new(
         :value,
         [:assembly_instance],
-        ->obj{instance.__setobj__ obj; instance},
+        ->obj{wrapper.call obj},
         []
       )]
       all_meta = meta+overrides_info[:meta]+[update_instance_overlay]
+      IceNine.deep_freeze all_meta
       executor = Executor.new(assembly, all_meta)
 
-      override_root.children[:assembly_instance] = build(:service,->{
-        root
-      })
+      override_root.children[:assembly_instance] = build(:service,->{ root })
       override_root.children[:assembly_executor] = build(:value,executor)
+
       executor.call [:assembly_instance]
     end
 

data/lib/alki/dsls/assembly.rb

@@ -1,4 +1,5 @@
 Alki do
+  require 'ice_nine'
   require_dsl 'alki/dsls/class'
   require_dsl 'alki/dsls/assembly_group'
 
@@ -6,8 +7,8 @@ Alki do
     add :config_dir, build(:value, ctx[:config_dir])
     add :assembly_name, build(:value, ctx[:assembly_name])
 
-    root = ctx[:root]
-    meta = ctx[:meta]
+    root = IceNine.deep_freeze ctx[:root]
+    meta = IceNine.deep_freeze ctx[:meta]
     add_class_method :root do
       root
     end

data/lib/alki/dsls/assembly_group.rb

@@ -10,7 +10,7 @@ Alki do
 
   helper :add do |name,elem|
     if @tags
-      ctx[:meta] << [[name.to_sym],:tags,@tags]
+      ctx[:meta] << [[name.to_sym],build_meta(:tags,@tags)]
       @tags = nil
     end
     ctx[:root].children[name.to_sym] = elem
@@ -21,12 +21,16 @@ Alki do
     Alki.load("alki/assembly/types/#{type}").new *args
   end
 
+  helper :build_meta do |type,*args|
+    Alki.load("alki/assembly/meta/#{type}").new *args
+  end
+
   dsl_method :add_overlay do |type,target,overlay,args|
     (ctx[:meta]||=[]) << [
-      [], :overlay,
-      Alki::OverlayInfo.new(
-        type,
-        target.to_s.split('.').map(&:to_sym),
+      [],
+      build_meta(
+        :overlay,
+        type, target.to_s.split('.').map(&:to_sym),
         overlay.to_s.split('.').map(&:to_sym),
         args
       )
@@ -81,6 +85,25 @@ Alki do
     update_meta name, grp[:meta]
   end
 
+  dsl_method :auto_group do |name,dir,callable,*args|
+    grp = build(:group)
+    dir = File.join(File.expand_path(dir,ctx[:config_dir]),"")
+    Dir.glob(File.join(dir,'**','*.rb')).each do |path|
+      require_path = Alki::Loader.lookup_name path
+      if require_path
+        elems = path[dir.size..-1].chomp('.rb').split('/')
+        *parents,basename = elems
+        parent_group = parents.inject(grp) do |grp,parent|
+          grp.children[parent] ||= build(:group)
+        end
+        parent_group.children[basename] = build :service,-> {
+          lookup(callable).call require_path, *args
+        }
+      end
+    end
+    add name, grp
+  end
+
   dsl_method :load do |group_name,name=group_name.to_s|
     unless ctx[:prefix]
       raise "Load command is not available without a config directory"

data/lib/alki/execution/cache_entry.rb

@@ -1,15 +1,14 @@
+require 'concurrent/immutable_struct'
+
 module Alki
   module Execution
-    class CacheEntry
-      attr_accessor :type,:value,:status
-      def initialize
-        @status = :building
+    class CacheEntry < Concurrent::ImmutableStruct.new(:type,:value,:status)
+      def self.building
+        new nil, nil, :building
       end
 
-      def finish(type,value)
-        @status = :done
-        @type = type
-        @value = value
+      def self.finished(type,value)
+        new type, value, :done
       end
     end
   end

data/lib/alki/execution/context_class_builder.rb

@@ -36,7 +36,7 @@ module Alki
         (config[:methods]||{}).each do |name,body|
           methods[name] = {
             body: body,
-            private: true,
+            private: name.to_s.start_with?('__'),
           }
         end
         ClassBuilder.build(

data/lib/alki/execution/value_helpers.rb

@@ -5,10 +5,6 @@ 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/invalid_path_error.rb

@@ -0,0 +1,3 @@
+module Alki
+  InvalidPathError = Class.new(StandardError)
+end

data/lib/alki/overlay_info.rb

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

data/lib/alki/version.rb

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

data/lib/alki.rb

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

data/test/feature/auto_group_test.rb

@@ -0,0 +1,21 @@
+require 'alki/feature_test'
+
+describe 'Auto Group' do
+  before do
+    @assembly = Alki.create_assembly do
+      auto_group :grp, fixture_path('auto_group','lib','auto_group_test'), :construct
+
+      factory :construct do
+        -> name { Alki.load(name).new }
+      end
+    end
+    @obj = @assembly.new
+  end
+
+  it 'should create a group containing all items' do
+    @obj.grp.children.must_equal [:a,:one]
+    @obj.grp.one.value.must_equal 1
+    @obj.grp.a.children.must_equal [:two]
+    @obj.grp.a.two.value.must_equal 2
+  end
+end

data/test/feature/multithreading_test.rb

@@ -0,0 +1,60 @@
+require 'alki/feature_test'
+require 'concurrent'
+
+describe 'Multithreading' do
+  it 'should cause access to block while assembly is building elements' do
+    cb = Concurrent::CyclicBarrier.new 2
+    e = Concurrent::Event.new
+
+    assembly = Alki.create_assembly do
+      service :svc do
+        cb.wait
+        e.wait
+      end
+
+      service :svc2 do
+        :val
+      end
+    end
+    obj = assembly.new
+    thread = Thread.new { obj.svc }
+    cb.wait
+    thread2 = Thread.new { obj.svc2 }
+    sleep 0.1
+    thread2.alive?.must_equal true
+    e.set
+    sleep 0.1
+    thread2.alive?.must_equal false
+
+    thread.join
+    thread2.join
+  end
+
+  it 'should allow concurrent access when not building elements' do
+    cb = Concurrent::CyclicBarrier.new 3
+    assembly = Alki.create_assembly do
+      func :f do
+        cb.wait
+        cb.wait
+      end
+
+      func :f2 do
+        cb.wait
+      end
+    end
+    obj = assembly.new
+    thread = Thread.new { obj.f }
+    thread2 = Thread.new { cb.wait; obj.f2 }
+    cb.wait
+    sleep 0.1
+    thread.alive?.must_equal true
+    thread2.alive?.must_equal true
+    cb.wait
+    sleep 0.1
+    thread.alive?.must_equal false
+    thread2.alive?.must_equal false
+
+    thread.join
+    thread2.join
+  end
+end

data/test/feature/reload_test.rb

@@ -0,0 +1,32 @@
+require 'alki/feature_test'
+
+describe 'Reload' do
+  before do
+    counter = 0
+    @assembly = Alki.create_assembly do
+      service :svc do
+        counter += 1
+      end
+    end
+    @obj = @assembly.new
+  end
+
+  it 'should cause services to be rebuilt' do
+    @obj.svc.must_equal 1
+    @obj.__reload__
+    @obj.svc.must_equal 2
+  end
+
+  it 'should increment version number of assembly' do
+    @obj.__version__.must_equal 0
+    @obj.svc
+    @obj.__reload__
+    @obj.__version__.must_equal 1
+  end
+
+  it 'should not reload if the assembly hasn\'t been used' do
+    @obj.__version__.must_equal 0
+    @obj.__reload__
+    @obj.__version__.must_equal 0
+  end
+end

data/test/feature_test_helper.rb

@@ -5,7 +5,8 @@ class Minitest::Spec
   before do
     @test_projects = [
       Alki::Test.fixture_path('example'),
-      Alki::Test.fixture_path('tlogger')
+      Alki::Test.fixture_path('tlogger'),
+      Alki::Test.fixture_path('auto_group')
     ]
     @test_projects.each do |proj|
       $LOAD_PATH.unshift File.join(proj,'lib')
@@ -25,6 +26,7 @@ class Minitest::Spec
     end
     undefine :Example, false
     undefine :Tlogger, false
+    undefine :AutoGroupTest, false
   end
 
   def undefine(sym,force=true)

data/test/fixtures/auto_group/lib/alki_loader.rb

@@ -0,0 +1,2 @@
+Alki::Loader.register 'auto_group_dsl.rb', builder: 'alki/dsls/dsl'
+Alki::Loader.register 'auto_group_test', builder: 'auto_group_dsl'

data/test/fixtures/auto_group/lib/auto_group_dsl.rb

@@ -0,0 +1,9 @@
+Alki do
+  require_dsl 'alki/dsls/class'
+
+  dsl_method :value do |val|
+    add_method :value do
+      val
+    end
+  end
+end

data/test/fixtures/auto_group/lib/auto_group_test/a/two.rb

@@ -0,0 +1,3 @@
+Alki do
+  value 2
+end

data/test/fixtures/auto_group/lib/auto_group_test/one.rb

@@ -0,0 +1,3 @@
+Alki do
+  value 1
+end

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

@@ -1,11 +1,13 @@
 Alki do
+  mount :alki
+
   load :settings
   load :handlers
 
   factory :log_overlay do
     require 'log_overlay'
     -> (obj) {
-      delegate_overlay obj, LogOverlay.new(log), name: meta[:building]
+      alki.delegate_overlay obj, LogOverlay.new(log), name: meta[:building]
     }
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alki
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Matt Edlefsen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-12-29 00:00:00.000000000 Z
+date: 2017-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -39,53 +39,67 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: alki-dsl
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.9'
+        version: '0.4'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.9.1
+        version: 0.4.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.9'
+        version: '0.4'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.9.1
+        version: 0.4.2
 - !ruby/object:Gem::Dependency
-  name: alki-dsl
+  name: alki-support
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.7'
 - !ruby/object:Gem::Dependency
-  name: alki-support
+  name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: ice_nine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
 description: Base library for building applications. Provides tools for organizing
   and connecting application units.
 email:
@@ -102,6 +116,7 @@ files:
 - Rakefile
 - alki.gemspec
 - bin/alki
+- config/assembly.rb
 - doc/assemblies.adoc
 - doc/assembly_dsl.adoc
 - doc/index.adoc
@@ -113,6 +128,8 @@ files:
 - lib/alki/assembly/executor.rb
 - lib/alki/assembly/handler.rb
 - lib/alki/assembly/instance.rb
+- lib/alki/assembly/meta/overlay.rb
+- lib/alki/assembly/meta/tags.rb
 - lib/alki/assembly/type.rb
 - lib/alki/assembly/types/assembly.rb
 - lib/alki/assembly/types/factory.rb
@@ -133,24 +150,30 @@ files:
 - lib/alki/execution/helpers.rb
 - lib/alki/execution/reference.rb
 - lib/alki/execution/value_helpers.rb
-- lib/alki/feature_test.rb
 - lib/alki/generator.rb
+- lib/alki/invalid_path_error.rb
 - lib/alki/overlay_delegator.rb
 - lib/alki/overlay_info.rb
 - lib/alki/override_builder.rb
 - lib/alki/service_delegator.rb
-- lib/alki/test.rb
 - lib/alki/version.rb
 - lib/alki_loader.rb
 - test/feature/alki_test.rb
+- test/feature/auto_group_test.rb
 - test/feature/example_test.rb
 - test/feature/factories_test.rb
+- test/feature/multithreading_test.rb
 - test/feature/overlays_test.rb
 - test/feature/overrides_test.rb
 - test/feature/pseudo_elements_test.rb
 - test/feature/reference_overlays_test.rb
+- test/feature/reload_test.rb
 - test/feature/tags_test.rb
 - test/feature_test_helper.rb
+- test/fixtures/auto_group/lib/alki_loader.rb
+- test/fixtures/auto_group/lib/auto_group_dsl.rb
+- test/fixtures/auto_group/lib/auto_group_test/a/two.rb
+- test/fixtures/auto_group/lib/auto_group_test/one.rb
 - test/fixtures/example/config/assembly.rb
 - test/fixtures/example/config/handlers.rb
 - test/fixtures/example/config/settings.rb
@@ -192,14 +215,21 @@ specification_version: 4
 summary: Base library for building applications.
 test_files:
 - test/feature/alki_test.rb
+- test/feature/auto_group_test.rb
 - test/feature/example_test.rb
 - test/feature/factories_test.rb
+- test/feature/multithreading_test.rb
 - test/feature/overlays_test.rb
 - test/feature/overrides_test.rb
 - test/feature/pseudo_elements_test.rb
 - test/feature/reference_overlays_test.rb
+- test/feature/reload_test.rb
 - test/feature/tags_test.rb
 - test/feature_test_helper.rb
+- test/fixtures/auto_group/lib/alki_loader.rb
+- test/fixtures/auto_group/lib/auto_group_dsl.rb
+- test/fixtures/auto_group/lib/auto_group_test/a/two.rb
+- test/fixtures/auto_group/lib/auto_group_test/one.rb
 - test/fixtures/example/config/assembly.rb
 - test/fixtures/example/config/handlers.rb
 - test/fixtures/example/config/settings.rb

data/lib/alki/feature_test.rb

@@ -1,7 +0,0 @@
-require 'alki/test'
-
-feature_test_helper = File.join(Alki::Test.tests_root,'feature_test_helper.rb')
-
-if File.exists? feature_test_helper
-  require feature_test_helper
-end

data/lib/alki/test.rb

@@ -1,47 +0,0 @@
-Bundler.require(:test)
-require 'minitest/autorun'
-require 'alki/dsl'
-
-module Alki
-  module Test
-    def app_root
-      Bundler.root
-    end
-
-    def lib_dir
-      File.join app_root, 'lib'
-    end
-
-    def tests_root
-      File.join app_root, 'test'
-    end
-
-    def fixtures_path
-      File.join tests_root, 'fixtures'
-    end
-
-    def fixture_path(*fixture)
-      File.join fixtures_path, *fixture
-    end
-
-    def load_fixture(*fixture)
-      require fixture_path(*fixture)
-    end
-
-    extend self
-  end
-end
-
-class Minitest::Spec
-  include Alki::Test
-end
-
-unless $LOAD_PATH.include? Alki::Test.lib_dir
-  $LOAD_PATH.unshift Alki::Test.lib_dir
-end
-
-test_helper = File.join(Alki::Test.tests_root,'test_helper.rb')
-
-if File.exists? test_helper
-  require test_helper
-end