alki 0.12.0 → 0.12.1

data/doc/{projects.adoc → executables.adoc}

@@ -1,36 +1,48 @@
-Setting up Alki Projects
-========================
+Creating Executables
+====================
 :toc:
 
-Generally, projects that use alki work the same as normal Ruby projects but there are a couple of
-guidelines to make life easier.
+Generally, projects that use alki are setup the same as normal Ruby projects but there are a couple of
+few differences plus some common conventions.
 
-Alki projects should always use Bundler and have a `Gemfile` in the project root. It is also optional
-that the project itself be a gem, with a `<project name>.gemspec` file in the project root and a `gemspec`
-line in the `Gemfile`.
 
-
-Using Alki without a gemspec
-----------------------------
+Without a gemspec
+-----------------
 
 If your project isn't a gem, and doesn't have a gemspec, executables should go in `bin` and should include these two
 lines before `require`-ing any other files.
 ```ruby
 require 'bundler/setup'
-require 'alki/bin`
+require 'alki/bin'
 ```
 
-After that you can require your library files and run them.
+After that you can use your library.
+
+.bin/my_exe
+```ruby
+require 'bundler/setup'
+require 'alki/bin'
+
+require 'my_project'
 
-Using Alki with a gemspec
--------------------------
+MyProject.new.cli.run
+```
+
+```
+$ bin/my_exe
+...
+```
+
+
+With a gemspec
+--------------
 
 If your project *is* a gem, you'll do things a bit differently.
 
 First, in your gemspec, set the `bindir` option to `'exe'` (not `'bin'`). Also if automatically setting
 the `executables` option, make sure it is looking for files in `exe`, not `bin`.
 
-As noted, executables should be placed in `exe`, not `bin`.
+Executables should be placed in `exe`, not `bin`.
 
 Finally, once your gemspec is setup, run `bundle binstubs <gem name>` where `<gem name>` is whatever
 you set `spec.name` to in your gemspec.
@@ -40,5 +52,17 @@ should run for testing/development. If you add new executables to `exe`, just ru
 generate new binstubs for them.
 
 Second, executables in `exe` shouldn't require any extra files other then the project files they need to
-run (no `bundle/setup` or `alki/bin`).
+run (**do not require `bundle/setup` or `alki/bin`**).
+
+.exe/my_exe
+```ruby
+require 'my_gem'
 
+MyGem.new.cli.run
+```
+
+```
+$ bundle binstubs my_gem
+$ bin/my_exe
+...
+```

data/doc/index.adoc

@@ -6,11 +6,12 @@ Alki is a framework for creating projects that are modular, testable, and well o
 
 It's goal is to remove uncertainty and friction when building Ruby projects, allowing developers to focus on implementing business logic.
 
-:leveloffset: 1
-include::projects.adoc[]
-
 :leveloffset: 1
 include::assemblies.adoc[]
 
 :leveloffset: 1
 include::assembly_dsl.adoc[]
+
+:leveloffset: 1
+include::executables.adoc[]
+

data/lib/alki.rb

@@ -13,3 +13,6 @@ def Alki.create_assembly(opts={},&blk)
   Alki::Assembly::Builder.build(opts,&blk)
 end
 
+def Alki.singleton_assembly(opts={},&blk)
+  Alki.create_assembly(opts,&blk).new
+end

data/lib/alki/assembly.rb

@@ -1,35 +1,11 @@
-require 'alki/override_builder'
 require 'alki/assembly/instance'
-require 'alki/assembly/executor'
-require 'alki/assembly/meta/overlay'
-require 'alki/overlay_info'
-require 'ice_nine'
+require 'alki/override_builder'
 
 module Alki
   module Assembly
-    def new(overrides={},&blk)
-      Instance.new load_class, [overrides, blk]
-    end
-
-    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 = [[],Meta::Overlay.new(
-        :value,
-        [:assembly_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_executor] = build(:value,executor)
-
-      executor.call [:assembly_instance]
+    def new(override_values={},&override_blk)
+      overrides = OverrideBuilder.build override_values, &override_blk
+      Instance.new load_class, overrides
     end
 
     def root
@@ -39,11 +15,5 @@ module Alki
     def meta
       self.definition.meta
     end
-
-    private
-
-    def build(type,*args)
-      Alki.load("alki/assembly/types/#{type}").new *args
-    end
   end
 end

data/lib/alki/assembly/builder.rb

@@ -46,8 +46,8 @@ module Alki
 
       def setup_project_assembly(path)
         root = Alki::Support.find_root(path) do |dir|
-          File.exists?(File.join(dir,'config',"#{@primary_config}.rb")) ||
-            File.exists?(File.join(dir,'Gemfile')) ||
+          File.exist?(File.join(dir,'config',"#{@primary_config}.rb")) ||
+            File.exist?(File.join(dir,'Gemfile')) ||
             !Dir.glob(File.join(dir,'*.gemspec')).empty?
         end
         if root
@@ -62,7 +62,7 @@ module Alki
 
           unless @config_dir
             config_dir = File.join(root,'config')
-            @config_dir = config_dir if File.exists? config_dir
+            @config_dir = config_dir if File.exist? config_dir
           end
         end
       end

data/lib/alki/assembly/instance.rb

@@ -1,16 +1,19 @@
 require 'delegate'
 require 'concurrent'
 require 'alki/support'
+require 'alki/assembly/instance_builder'
 
 module Alki
   module Assembly
     class Instance < Delegator
-      def initialize(assembly_module,args)
+      def initialize(assembly_module,overrides)
         @assembly_module = assembly_module
-        @args = args
+        @overrides = overrides
         @version = 0
         @needs_load = true
         @lock = Concurrent::ReentrantReadWriteLock.new
+        @obj = nil
+        @executor = nil
       end
 
       def __reload__
@@ -30,6 +33,13 @@ module Alki
         end
       end
 
+      def __executor__
+        @lock.with_read_lock do
+          __load__ if @needs_load
+          @executor
+        end
+      end
+
       def __getobj__
         @lock.with_read_lock do
           __load__ if @needs_load
@@ -37,15 +47,31 @@ module Alki
         end
       end
 
+      def to_s
+        inspect
+      end
+
+      def inspect
+        if @assembly_module.is_a?(Module)
+          name = @assembly_module.name || 'AnonymousAssembly'
+        else
+          name = Alki::Support.classify(@assembly_module.to_s)
+        end
+        "#<#{name}:#{object_id}>"
+      end
+
+      def pretty_print(q)
+        q.text(inspect)
+      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
+          InstanceBuilder.build @assembly_module, @overrides do |instance,executor|
+            @obj = instance
+            @executor = executor
             self
           end
         end

data/lib/alki/assembly/instance_builder.rb

@@ -0,0 +1,48 @@
+require 'alki/assembly/types'
+require 'alki/executor'
+require 'alki/override_builder'
+require 'alki/assembly/meta/overlay'
+require 'alki/overrides'
+require 'ice_nine'
+
+module Alki
+  module Assembly
+    module InstanceBuilder
+      class << self
+        def build(assembly,overrides,&instance_wrapper)
+          assembly = Alki.load(assembly)
+          executor = Executor.new
+
+          overrides = inject_assembly_instance overrides, instance_wrapper, executor
+
+          executor.root = Types.build :assembly, assembly.root, overrides.root
+          executor.meta = IceNine.deep_freeze(assembly.meta+overrides.meta)
+
+          executor.call [:assembly_instance]
+        end
+
+        private
+        
+        def inject_assembly_instance(overrides,instance_wrapper,executor)
+          root = overrides.root.dup
+          root.children = root.children.merge(assembly_instance: assembly_instance)
+          meta = overrides.meta + [wrap_assembly_instance(instance_wrapper,executor)]
+          Overrides.new(root,meta)
+        end
+
+        def assembly_instance
+          Types.build(:service,-> { root })
+        end
+
+        def wrap_assembly_instance(wrapper,executor)
+          [[],Meta::Overlay.new(
+            :value,
+            [:assembly_instance],
+            -> obj { wrapper.call obj, executor },
+            []
+          )]
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,6 @@
 require 'alki/invalid_path_error'
 require 'alki/overlay_info'
+require 'alki/execution/overlay_map'
 
 module Alki
   module Assembly
@@ -14,7 +15,8 @@ module Alki
 
         def process(executor,from,data)
           data[:total_overlays] ||= 0
-          data[:overlays]||={}
+          data[:overlays] ||= Execution::OverlayMap.new
+
           target_path = @target.dup
           if target_path.last.to_s.start_with?('%')
             tag = target_path.pop
@@ -22,8 +24,10 @@ module Alki
           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)
@@ -31,7 +35,8 @@ module Alki
               raise InvalidPathError.new("Invalid overlay path #{@overlay.join('.')}")
           end
           order = data[:total_overlays]
-          (data[:overlays][target]||=[]) << OverlayInfo.new(order,@type, overlay, @args)
+
+          data[:overlays].add target, OverlayInfo.new(order,@type, overlay, @args)
           data[:total_overlays] += 1
         end
       end

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

@@ -1,3 +1,5 @@
+require 'alki/execution/tag_map'
+
 module Alki
   module Assembly
     module Meta
@@ -7,10 +9,8 @@ module Alki
         end
 
         def process(_executor,from,data)
-          data[:tags]||={}
-          @tags.each do |tag,value|
-            (data[:tags][tag.to_sym]||={})[from] = value
-          end
+          data[:tags]||=Execution::TagMap.new
+          data[:tags].add from, @tags
         end
       end
     end

data/lib/alki/assembly/types.rb

@@ -0,0 +1,9 @@
+module Alki
+  module Assembly
+    module Types
+      def self.build(type,*args)
+        Alki.load("alki/assembly/types/#{type}").new *args
+      end
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 require 'alki/assembly/types/override'
+require 'alki/assembly/types/original'
 
 Alki do
   attr :root
@@ -16,7 +17,7 @@ Alki do
           data[:scope][k] = data[:prefix] + [k]
         end
       end
-      root
+      Alki::Assembly::Types::Original.new root
     else
       if overrides
         data.replace(
@@ -40,9 +41,8 @@ Alki do
 
     output = root.output(data)
     add_parent_path output[:scope]
-    update_scope data, output[:full_scope]
+    update_scope data, output[:scope]
     output[:scope].merge! overrides.output(data)[:scope] if overrides
-    output[:full_scope].merge! overrides.output(data)[:full_scope] if overrides
     output
   end
 

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

@@ -1,5 +1,4 @@
 Alki do
-  require 'ostruct'
   require 'alki/execution/helpers'
 
   attr(:children){ {} }
@@ -7,30 +6,12 @@ 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,value|
-        if path.empty? || path[0] == key.to_sym
-          (tags[tag]||={})[(path[1..-1]||[])] = value
-        end
-      end
-      tags
+    if data[:tags]
+      data[:tags] = data[:tags].index key
     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?('%')
-        tags = data[:tags][target[0].to_s[1..-1].to_sym]
-        if tags
-          tags.keys.each do |path|
-            (no[path]||=[]).push *overlays
-          end
-        end
-      elsif target.empty? || target.shift == key.to_sym
-        (no[target]||=[]).push *overlays
-      end
-      no
+    if data[:overlays]
+      data[:overlays] = data[:overlays].index key, data[:tags]
     end
 
     data[:prefix] << key
@@ -41,13 +22,23 @@ Alki do
   output do
     children_names = children.keys.map(&:to_sym)
     {
-      full_scope: update_scope(children, data[:prefix], data[:scope]),
-      scope: update_scope(children,data[:prefix]),
+      lookup_methods: update_scope(children,data[:prefix]),
+      scope: update_scope(children, data[:prefix], data[:scope]),
       modules: [Alki::Execution::Helpers],
       methods: {
         children: -> {
           children_names
         },
+        elements: -> {
+          children.inject([]) do |elems, child_name|
+            child = send(child_name)
+            if child.respond_to?(:elements)
+              elems.push *child.elements
+            else
+              elems.push child
+            end
+          end
+        }
       },
       proc: ->{self}
     }