alki 0.13.2 → 0.13.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c45abd42f73d63b3416055e3d9b7083a987a933d
-  data.tar.gz: 9eb429b7597cb856e731f0eb46a6e3094db4464a
+  metadata.gz: 477bb49ab83abf569bcc2b415b077cf15428c016
+  data.tar.gz: 32261729b502b2a85e66f5fa6b00f4c6ecd20adf
 SHA512:
-  metadata.gz: d15a85dc3d44267dafe127f76dd7c54faa594b163926ff2d8198afe3a2493297904d0d778b82bbd649ee0c47dea2f0aa18961c7ef3ad7be00f8ba66c846af854
-  data.tar.gz: 6bd49d1cd77f45018e376e059555f17b066d0c5be9c0cf40f6be653bb8518b737df5ef69811a673c0943aba3b1603bea42ae3ba84fce1d5127ade5c40ca8f3fd
+  metadata.gz: 250fe69e4e13e33b5e66886fba89685511fafe043c45ecbf69c419075f249f069f80a791bcee2e1d569d2a8ab533321a6625c868c65ab30d5db7809958367c57
+  data.tar.gz: 229abd1df5d0b641eb2ace2d7ebf7788a0b750daed24db20d648cf52b5cee416313a9e2332fcce65fa567ec5885b676f4a1b9394b8d867fdb44cdb17c7f569bb

data/Gemfile

@@ -1,6 +1,6 @@
 source 'https://rubygems.org'
 
-gem 'alki-testing', '= 0.3.0'
+gem 'alki-testing'
 gem 'rake'
 
 gemspec

data/README.adoc

@@ -1,12 +1,14 @@
 # What is Alki?
 
-Alki is a small library to help organize and scale your Ruby project, so you can focus on the
-important stuff. It can be used alongside frameworks such as Ruby on Rails.
+Alki (AL-kai) is a Dependency Injection framework for Ruby. Alki is designed to help organize and scale your project,
+so you can focus on the important stuff.
+It can be used alongside frameworks such as Ruby on Rails.
 
 Some high level features:
 
 * Easily manage objects and dependencies
 * Enables writing reusable and testable code
+* Requires no annotations, mixins, or other changes to your code.
 * https://github.com/alki-project/alki-console[Developer console] (built on pry)
 * Automatic https://github.com/alki-project/alki-reload[code reloading]
 * Powerful https://github.com/alki-project/alki-dsl[DSL toolkit]
@@ -39,7 +41,7 @@ that connects our classes and modules together, and puts them into a special obj
 called an Assembly.
 
 There are many ways to use Assemblies, but the most common is to have a single
-Assembly for you project. For example, if you hade a "todo" command line utility
+Assembly for a project. For example, if you hade a "todo" command line utility
 project that you wanted to use Alki with, all you would need to do to create
 an Assembly is add this file.
 
@@ -61,18 +63,19 @@ $ bundle exec irb -Ilib
 
 ### Defining Elements
 
-Add things to the assembly requires an assembly definition file. By convention this is
+Adding things to the assembly requires an assembly definition file. By convention this is
 named `config/assembly.rb` and is built using a simple DSL. There are
 a handful of different element types in Assemblies. Below are a few of the
-most common. Full documentation of the DSL can be found
-https://github.com/alki-project/alki/blob/master/doc/assembly_dsl.adoc[here]
+most common. Full documentation of the DSL can be found at http://alki.io[alki.io].
+
+Elements can refer to other elements, and can be defined in any order.
 
 .config/assembly.rb
 ```ruby
 Alki do
   group :settings do <1>
     set(:home) { ENV['HOME'] } <2>
-    set(:db_path) { ENV['TODO_DB_PATH'] || File.join(home,'.todo_db2') }
+    set(:db_path) { ENV['TODO_DB_PATH'] || File.join(home,'.todo_db') }
     set :prompt, 'todo> '
   end
 
@@ -97,7 +100,7 @@ Alki do
   end
 end
 ```
-<1> `group` allows bundling together subelements and can be moved to their own files
+<1> `group` allows bundling together subelements (and which can be moved to their own files)
 <2> `set` defines simple values
 <3> `service` defines our main application objects
 
@@ -109,12 +112,22 @@ $ bundle exec irb -Ilib
  => true
 2.4.0 :002 > todo = Todo.new
  => #<Todo:21964520>
-2.4.0 :003 > todo.settings.prompt
- => 'todo> '
+2.4.0 :003 > todo.interface.run
+> ?
+All commands can be shortened to their first letters
+print
+add <description>
+edit <id> <description>
+complete <id>
+uncomplete <id>
+remove <id>
+move <from> <to>
+quit
+
 ```
 
 The 'alki-console' tool can also be used to quickly work with assemblies.
-Add `gem 'alki-console'` to your Gemspec and run `bundle --binstubs`.
+Add `gem 'alki-console'` to your Gemfile and run `bundle --binstubs`.
 
 ```
 $ bin/alki-console
@@ -125,9 +138,12 @@ todo> settings.prompt
 ### Creating an executable
 
 Read more about creating executables with Alki
-https://github.com/alki-project/alki/blob/master/doc/executables.adoc[here]
+http://alki.io/executables.html[here].
 
 In the todo example, it's a CLI utility so it requires an executable.
+The executable just needs to require the main project file,
+create a new instance of the assembly,
+and call a method on a service.
 
 .exe/todo
 ```ruby
@@ -135,9 +151,44 @@ require 'todo'
 Todo.new.interface.run
 ```
 
+### Splitting up the Assembly configuration
+
+As a project grows, it's helpful to be able to split out
+parts of the Assembly configuration into multiple files.
+
+This can be accomplished with the `load` method in the DSL,
+which will load the named file and add it the elements
+defined in it as a group in the assembly.
+
+For example, it's common to split out application settings into
+a separate config file.
+
+.config/settings.rb
+```ruby
+Alki do
+ set(:home) { ENV['HOME'] }
+ set(:db_path) { ENV['TODO_DB_PATH'] || File.join(home,'.todo_db') }
+ set :prompt, 'todo> '
+end
+```
+
+.config/assembly.rb
+```ruby
+Alki do
+  load :settings
+
+  service :interface do
+    require 'todo/readline_interface'
+    Todo::ReadlineInterface.new settings.prompt, handler
+  end
+
+  ...
+end
+```
+
 ## Further Documentation
 
-Further documentation can be found https://github.com/alki-project/alki/blob/master/doc/index.adoc[here]
+Further documentation can be found at http://alki.io[alki.io].
 
 Example projects can be found https://github.com/alki-project/alki-examples[here]
 

data/lib/alki/assembly/instance.rb

@@ -28,6 +28,12 @@ module Alki
         end
       end
 
+      def __reloading__
+        @lock.with_read_lock do
+          @needs_load
+        end
+      end
+
       def __version__
         @lock.with_read_lock do
           @version
@@ -69,11 +75,16 @@ module Alki
       def __load__
         @lock.with_write_lock do
           @needs_load = false
-          @obj.__unload__ if @obj.respond_to?(:__unload__)
-          @executor = Executor.new(self)
-          InstanceBuilder.build @executor,@assembly_module, @overrides do |instance|
-            @obj = instance
-            self
+          begin
+            @obj.__unload__ if @obj.respond_to?(:__unload__)
+            @executor = Executor.new(self)
+            InstanceBuilder.build @executor,@assembly_module, @overrides do |instance|
+              @obj = instance
+              self
+            end
+          rescue Exception
+            @needs_load = true
+            __raise__
           end
         end
       end

data/lib/alki/version.rb

@@ -1,3 +1,3 @@
 module Alki
-  VERSION = "0.13.2"
+  VERSION = "0.13.3"
 end

data/test/feature/reload_test.rb

@@ -29,4 +29,28 @@ describe 'Reload' do
     @obj.__reload__
     @obj.__version__.must_equal 0
   end
+
+  it 'should work if reloading after previous loading raises an error' do
+    assembly = @assembly
+    raise_error = []
+    proxy = Class.new do
+      define_method :root do
+        raise SyntaxError, 'error' unless raise_error.empty?
+        assembly.root
+      end
+      define_method :meta do
+        assembly.meta
+      end
+    end.new
+    obj = Alki::Assembly::Instance.new proxy, Alki::OverrideBuilder.build
+    obj.svc.must_equal 1
+    ref = obj.__reference_svc__
+    raise_error.push true
+    obj.__reload__
+    assert_raises(SyntaxError) do
+      obj.svc
+    end
+    raise_error.pop
+    obj.svc.must_equal 2
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alki
 version: !ruby/object:Gem::Version
-  version: 0.13.2
+  version: 0.13.3
 platform: ruby
 authors:
 - Matt Edlefsen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-10 00:00:00.000000000 Z
+date: 2018-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: alki-dsl
@@ -76,8 +76,7 @@ description: Base library for building applications. Provides tools for organizi
   and connecting application units.
 email:
 - matt.edlefsen@gmail.com
-executables:
-- alki
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
@@ -91,11 +90,6 @@ files:
 - bin/bundler
 - bin/rake
 - config/assembly.rb
-- doc/assemblies.adoc
-- doc/assembly_dsl.adoc
-- doc/executables.adoc
-- doc/index.adoc
-- exe/alki
 - lib/alki.rb
 - lib/alki/assembly.rb
 - lib/alki/assembly/builder.rb
@@ -132,7 +126,6 @@ files:
 - lib/alki/execution/tag_map.rb
 - lib/alki/execution/value_helpers.rb
 - lib/alki/executor.rb
-- lib/alki/generator.rb
 - lib/alki/invalid_path_error.rb
 - lib/alki/overlay_delegator.rb
 - lib/alki/overlay_info.rb

data/doc/assemblies.adoc

@@ -1,152 +0,0 @@
-Assemblies
-==========
-:toc:
-
-If a set of classes are your raw materials, an Assembly is the finished product,
-ready to be used.
-
-To get there, you provide Alki with your assembly definition, which acts as the instructions for
-how to piece together your classes and objects. Assemblies are made up of elements, which are groups
-of other elements, or various value types like services and factories.
-
-Assembly definitions are written in a simple DSL.
-
-Project Assemblies
-------------------
-
-Most of the time, a project will have a single assembly, so Alki makes having a single project wide
-assembly especially easy.
-
-First, in your project's `lib` directory create a ruby file for your assembly. If your assembly is
-to be called `MyAssembly`, create `lib/my_assembly.rb`. If it's namespaced put it in a subdirectory
-as usual (i.e. `MyModule::MyAssembly` would go in `lib/my_module/my_assembly.rb`).
-
-Your assembly file just needs two lines:
-
-```ruby
-require 'alki'
-Alki.project_assembly!
-```
-
-It will detect the project root and what class name it should create automatically.
-
-Second, a `config` directory must be created in the project root, and in that directory an `assembly.rb`
-file should be created. It should contain an `Alki do ... end` block which contains the top level
-definition for your Assembly.
-
-```ruby
-Alki do
-  # Assembly DSL ...
-end
-```
-
-`Alki.project_assembly!` defaults can be overridden by passing in the following keyword arguments:
-
-[horizontal]
-name:: Set the name of the assembly. Should be formatted how you would put it in a `require` call
-       (e.g. if `MyModule::MyAssembly` is desired, use `'my_module/my_assembly'`). Default is
-       determined from the filename of the caller.
-
-config_dir:: Set directory where assembly config files are found. Default is `<project root>/config`.
-
-primary_config:: Sets the name of the main config file to load. Defaults to `assembly.rb`.
-
-Manually Creating Assemblies
-----------------------------
-
-In addition to Project Assemblies, you can also create assemblies directly using `Alki.create_assembly`.
-It should be called with a block that contains the assembly DSL. It will return a Module object that can
-be used directly or assigned to a constant.
-
-```ruby
-require 'alki'
-assembly = Alki.create_assembly do
-  set :msg, "hello world"
-  func :run do
-    puts msg
-  end
-end
-
-assembly.new.run
-
-# output: hello world
-```
-
-Using Assemblies
-----------------
-
-Assemblies have a `new` method used to create new assembly instances (like a normal class). Once an
-instance is created, anything in the assembly is accessible by drilling down into groups.
-
-Given an assembly like this:
-
-```ruby
-require 'alki'
-assembly = Alki.create_assembly do
-  set :log_io, STDERR
-  group :util do
-    service :logger do
-      require 'logger'
-      Logger.new log_io
-    end
-  end
-end
-```
-
-One can use the logger service like so:
-
-```ruby
-instance = assembly.new
-instance.util.logger.info "test"
-
-# output: I, [<timestamp>] INFO -- : test
-```
-
-### Overrides
-
-Assembly overrides provide a way to configure or customize an Assembly when
-constructing an instance.
-
-For example, using the assembly created above, one might want to change the IO object logged to.
-
-The simplist way to do this is to provide a hash which will override values in the assembly (as if the `set`
-command was called in the DSL):
-
-```ruby
-require 'stringio'
-io = StringIO.new
-instance = assembly.new log_io: io
-instance.util.logger.info "test"
-puts(io.string.match(/INFO -- : test/) != nil)
-
-# output: true
-```
-
-The limitiation of this is that it can only override basic values. To override more complex elements
-a block can be given to `new` allowing the full assembly DSL.
-
-```ruby
-class MyLogger
-  def initialize(io)
-    @io = io
-  end
-  def info(msg)
-    @io.puts "INFO #{msg}"
-  end
-end
-
-instance = assembly.new do
-  group :util do
-    service :logger do
-      MyLogger.new original.log_io
-    end
-  end
-end
-instance.util.logger.info "test"
-
-# output: INFO test
-```
-
-One thing of note is that elements from the assembly are accessible in overrides via the `original`
-method, as seen above. This can also be used to access the original versions of elements that have
-been overriden.

data/doc/assembly_dsl.adoc

@@ -1,511 +0,0 @@
-Assembly DSL
-============
-:toc:
-
-Building Assemblies is done via a small DSL
-
-Groups (group)
---------------
-
-Groups are the basic way of organizing the elements of your Assembly. Creating elements at the top
-level of an Assembly will place them in a root group, but subgroups are easily created via the `group`
-command.
-
-```ruby
-require 'alki'
-assembly = Alki.create_assembly do
-  group :sub_group do
-    set :val, "hello world"
-  end
-end
-puts assembly.new.sub_group.val
-
-#output: hello world
-```
-
-Scoping is also done by group, so that an element will be found by searching through parent groups.
-
-```ruby
-require 'alki'
-assembly = Alki.create_assembly do
-  set :val, "one"
-  func :print do
-    puts val
-  end
-
-  group :g1 do
-    set :val, "two"
-
-    group :g2 do
-      func :print do
-        puts val
-      end
-    end
-
-  end
-end
-
-assembly.new.print
-
-#output: one
-
-assembly.new.g1.g2.print
-
-#output: two
-```
-
-=== Loading groups (load)
-
-Groups can also be loaded from other config files via the `load` command.
-
-.config/settings.rb
-```ruby
-Alki do
-  set :val, "hello"
-end
-```
-
-.main code
-```ruby
-require 'alki'
-assembly = Alki.create_assembly config_dir: 'config' do
-  load :settings
-  func :print do
-     puts settings.val
-  end
-end
-assembly.new.print
-
-# output: hello
-```
-
-
-Values
-------
-
-Values are how you add functionality to your Assembly. There are different types of values, but they
-all share a number of common features.
-
-### On-Demand
-
-Values are only built when referenced, on demand. This means even if you have a very large assembly
-only the things you actually use in a given run will be created, or often even `require`-d. It also
-means that all values will automatically be built in the correct order to satisfy dependencies.
-
-### Scope
-
-When providing a block for a value, the block will be executed in a special context with some
-additional helper methods.
-
-The most important methods available are other elements that are "in scope". For example, a value can
-reference a sibling element in the same group, or any value in any ancestor group. The order that
-elements are defined does not effect what is in scope. All other elements are out of scope, but can
-usually still be referenced by finding an ancestor group that 'is' in scope, and then drilling down
-from there.
-
-```ruby
-require 'alki'
-assembly = Alki.create_assembly config_dir: 'config' do
-  set :val1, "1"
-  group :main do
-    group :sub_group do
-      set :val2, "2"
-    end
-
-    set :values do
-      [
-        val1, # OK
-      # val2, # ERROR
-        sub_group.val2, # OK
-        val3, # OK
-      # val4, # ERROR
-        other_group.val4, #OK
-      ].join('')
-    end
-
-    set :val3, "3"
-  end
-
-  group :other_group do
-    set :val4, "4"
-  end
-
-end
-puts assembly.new.main.values
-
-#output: 1234
-```
-
-### Helpers
-
-In addition to elements in scope, there are some helper methods that are always available in value
-blocks.
-
-[horizontal]
-
-assembly:: This will return the root group of the assembly the element is defined in.
-
-root:: This will return the root group of the 'top most' assembly being run. If only a single
-assembly is being run, this will be the same as `assembly` but if the element being run is in
-an assembly that has been mounted into another assembly, they will differ.
-
-lookup(path):: This can be used to reference an element by a string path (using periods (`.`) to
-drill down into groups). If called directly it will lookup using the local scope. It is also available
-as a method on all groups, so `assembly.lookup(path)` would lookup an element starting from the root
-of the assembly.
-
-lazy(path):: This works the same as `lookup`, but with an important difference: Instead of doing the
-lookup immediately, it will instead return a "proxy" object, which will do the lookup the first time
-a method is called on the proxy object, and then delegate all method calls to the actual element. This
-can be used to handle circular references in services.
-
-Value Types
------------
-
-There are four types of elements loosely categorized as "values".
-
-### Basic Values (set)
-
-The simplest type of values are ones created via the `set` command. There are two forms of `set`.
-
-```ruby
-require 'alki'
-assembly = Alki.create_assembly do
-  # This form takes the value as the second argument
-  set :val1, "hello"
-
-  # INVALID! Value may not be a reference to another element
-  # set :val2, val1
-
-  # This form takes the value as a block.
-  # Block is run once and result cached.
-  # Allows referencing other elements
-  set :val2 do
-    val1
-  end
-end
-puts assembly.new.val2
-
-#output: hello
-```
-
-### Functions (func)
-
-Simple callable values can be created with the `func` command. These can take arguments, are run
-each time they are referenced, and can access other elements.
-
-```ruby
-require 'alki'
-assembly = Alki.create_assembly do
-  set :greeting, "Hello %s!"
-
-  func :greet do |name|
-    puts(greeting % [name])
-  end
-end
-puts assembly.new.greet "Matt"
-
-#output: Hello Matt!
-```
-
-### Services (service)
-
-Services are the key element Assemblies are typically made up of. Like the block form of `set`,
-`service` takes a name and block, which will be evaluated once on-demand and the result cached.
-Whereas `set` is a lightweight element for simple values, `service` provides more functionality.
-
-Commonly a service will require the file that defines a class, and then constructs an instance of
-that class.
-
-```ruby
-require 'alki'
-assembly = Alki.create_assembly do
-  service :logger do
-    require 'logger'
-    Logger.new STDOUT
-  end
-end
-assembly.new.logger << "hello\n"
-
-#output: hello
-```
-
-### Factories (factory)
-
-Factories are a mix between services and funcs. Like services, they take a block which is evaluated
-once. Unlike services though, that block must return a callable "builder" (like a Proc).
-
-If a factory is referenced as a service (i.e. no arguments) it returns a factory object
-that responds to either `#call` or `#new` and will call the builder in turn.
-
-If a factory is instead referenced like a method (i.e. with arguments) it will
-call the builder directly.
-
-```ruby
-require 'alki'
-assembly = Alki.create_assembly do
-  factory :logger do
-    require 'logger'
-    -> (io) { Logger.new io }
-  end
-
-  service :main_logger do
-    logger STDOUT
-    # -or-
-    logger.call STDOUT
-  end
-end
-assembly.new.main_logger << "hello\n"
-
-#output: hello
-```
-
-
-## Mounting Assemblies (mount)
-
-Other assemblies can be mounted into your Assembly using the `mount` command.
-
-The first argument is what the element should be named in the parent assembly.
-The optional second argument is the assembly to be mounted.
-This can either be the assembly module,
-or be a "require" string (relative path but no `.rb`).
-It defaults to the element name.
-If a string, Alki will attempt to `require` it, and then look for a matching constant.
-
-
-```ruby
-require 'alki'
-
-other_assembly = Alki.create_assembly do
-  set :val, "one"
-
-  # This is invalid as there is no such element as 'val2'
-  set :invalid_val2 do
-    val2
-  end
-
-  # Normally, this would also be invalid, but if mounted
-  # in an assembly that has a 'val2' element, this works.
-  set :root_val2 do
-    root.val2
-  end
-end
-
-assembly = Alki.create_assembly do
-  set :val2, "two"
-  mount :other, other_assembly
-end
-instance = assembly.new
-puts instance.other.val
-#output: one
-
-# Even though val2 exists in MainAssembly, it is not directly accessibly to elements
-# within OtherAssembly
-begin
-  puts instance.other.invalid_val2
-rescue => e
-  puts e
-end
-# output: undefined local variable or method 'val2'
-
-# This works, because root returns the root assembly, which has a 'val2' element
-puts instance.other.root_val2
-#output: two
-```
-
-In addition, `assembly` takes an optional third hash argument or a block which can be used to set
-overrides in the same way `::new` does for assemblies. Elements from the parent assembly are
-automatically in scope for overrides.
-
-```ruby
-require 'alki'
-other_assembly = Alki.create_assembly do
-  set :msg, nil
-  func :print do
-    puts msg
-  end
-end
-
-assembly = Alki.create_assembly do
-  set :val, "hello"
-  mount :other, other_assembly do
-    set :msg do
-      val
-    end
-  end
-end
-assembly.new.other.print
-
-#output: hello
-```
-
-### Optional mounts (try_mount)
-
-Sometimes a library might not always be present. For example, using Bundler
-for development only gems. In that case `try_mount` can be used instead of
-`mount`. If the assembly library can't be found, the mount will simply be
-ignore.
-
-## Overlays and Tags
-
-Overlays are a way to transparently wrap services. They work by taking the
-name of a service or a group, in which case they are applied to all services in that group,
-along with the name of an element to be used as the overlay, plus some optional arguments.
-
-When the named service is built, the overlay element will be called (with `.call`), with
-the built service object and the optional arguments, and it's result will be what's
-returned.
-
-Factories work well as overlay elements.
-
-```ruby
-require 'alki'
-
-assembly = Alki.create_assembly do
-  overlay :greeting, :exclaim, 3
-
-  service :greeting do
-    'Hello World'
-  end
-
-  factory :exclaim do
-    -> (string,count) do
-      string + ('!' * count)
-    end
-  end
-end
-
-puts assembly.new.greeting
-
-#output: Hello World!!!
-```
-
-### Tags (tag)
-
-Tags are way of adding metadata to your elements. They can either be just a name, or
-optionally carry a value
-
-```ruby
-require 'alki'
-
-assembly = Alki.create_assembly do
-  tag :tag1, with_value: 123
-  service :tagged do
-    meta[:tags]
-  end
-end
-
-puts assembly.new.tagged
-
-#output: {:with_value=>123, :tag1=>true}
-```
-
-Tags can be applied to groups to tag everything within that group
-
-```ruby
-require 'alki'
-
-assembly = Alki.create_assembly do
-  tag :tag1
-  group :grp do
-    tag :tag2
-    service :tagged do
-      meta[:tags]
-    end
-  end
-end
-
-puts assembly.new.grp.tagged
-
-#output: {:tag1=>true, :tag2=>true}
-```
-
-#### Overlaying tags (overlay_tag)
-
-Instead of overlaying services directly, it's often useful to overlay all services
-with a given tag.
-
-```ruby
-require 'alki'
-
-assembly = Alki.create_assembly do
-  overlay_tag :exclaimed, :exclaim, 3
-
-  tag :exclaimed
-  service :greeting do
-    'Hello World'
-  end
-
-  factory :exclaim do
-    -> (string,count) do
-      string + ('!' * count)
-    end
-  end
-end
-
-puts assembly.new.greeting
-
-#output: Hello World!!!
-```
-
-Factories can access the tags of the services their being called from, allowing you
-to customize the build based on what tags are present
-
-```ruby
-require 'alki'
-
-assembly = Alki.create_assembly do
-  overlay_tag :process, :process_string
-
-  tag :process, exclaim: 3
-  service :greeting do
-    'Hello World'
-  end
-
-  factory :process_string do
-    -> (string) do
-      if exclaim = meta[:tags][:exclaim]
-        string = string + ('!' * exclaim)
-      end
-      string
-    end
-  end
-end
-
-puts assembly.new.greeting
-
-#output: Hello World!!!
-```
-
-Finally, tag overlays work even across assembly mounts, allowing overlays to
-be defined in a library, and then applied by tagging services.
-
-```ruby
-require 'alki'
-
-string_processor = Alki.create_assembly do
-  overlay_tag :process, :process_string
-
-  factory :process_string do
-    -> (string) do
-      if exclaim = meta[:tags][:exclaim]
-        string = string + ('!' * exclaim)
-      end
-      string
-    end
-  end
-end
-
-assembly = Alki.create_assembly do
-  mount :string_processor, string_processor
-
-  tag :process, exclaim: 3
-  service :greeting do
-    'Hello World'
-  end
-end
-
-puts assembly.new.greeting
-
-#output: Hello World!!!
-```

data/doc/executables.adoc

@@ -1,68 +0,0 @@
-Creating Executables
-====================
-:toc:
-
-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.
-
-
-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'
-```
-
-After that you can use your library.
-
-.bin/my_exe
-```ruby
-require 'bundler/setup'
-require 'alki/bin'
-
-require 'my_project'
-
-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`.
-
-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.
-
-Once done, you should have binstubs in `bin` for each executable you have in `exe`. These are what you
-should run for testing/development. If you add new executables to `exe`, just run `bundle install` to
-generate new binstubs for them.
-
-Second, executables in `exe` shouldn't require any extra files other then the project files they need to
-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

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

data/exe/alki

@@ -1,109 +0,0 @@
-#!/usr/bin/env ruby
-require 'fileutils'
-require 'optparse'
-require 'alki/support'
-require 'alki/generator'
-
-valid_addons = ["console","reload"]
-
-options = {
-  config_dir: nil,
-  primary_config: nil,
-  addons: [],
-  project_dir: Dir.pwd,
-}
-parser = OptionParser.new do |opts|
-  opts.banner = "Usage: alki init PROJECT_NAME [options]"
-
-  opts.on("-a", "--addons=ADDONS", Array, "Add addon to project. Valid addons: #{valid_addons.join(', ')}") do |vs|
-    vs.each do |v|
-      unless valid_addons.include? v
-        puts "Invalid addon: #{v}"
-        exit 1
-      end
-      options[:addons] |= [v]
-    end
-  end
-
-  opts.on('-d','--directory=DIRECTORY', 'Project root, defaults to the current working directory') do |v|
-    options[:project_dir] = v
-  end
-
-  opts.on("-c", "--config=DIECTORY", "Override config dir (default \"config\")") do |v|
-    options[:config_dir] = v
-  end
-
-  opts.on("-p", "--primary=PRIMARY_CONFIG", "Override primary config (default \"assembly\")") do |v|
-    options[:primary_config] = v
-  end
-end
-
-parser.parse!
-
-if ARGV.size != 2 || ARGV[0] != "init"
-  puts parser.banner
-  exit 1
-end
-
-unless ARGV[1] =~  %r{^[a-z0-9_]+(/[a-z0-9_]+)*$}
-  puts "Invalid project name. May only consist of lowercase letters, numbers, underscores, and forward slashes"
-  exit 1
-end
-
-project_name = ARGV[1]
-
-fw = Alki::Generator.new options[:project_dir]
-
-config_dir = options[:config_dir] || 'config'
-primary_config = options[:primary_config] || 'assembly'
-primary_config_path = File.join(config_dir,primary_config+'.rb')
-fw.opt_create primary_config_path, <<END
-Alki do
-  # Assembly config goes here
-end
-END
-
-opts = []
-opts << "config_dir: '#{options[:config_dir]}'" if options[:config_dir]
-opts << "primary_config: '#{options[:primary_config]}'" if options[:primary_config]
-unless opts.empty?
-  opt_str = " #{opts.join(', ')}"
-end
-fw.create "lib/#{project_name}.rb", <<END
-require 'alki'
-Alki.project_assembly!#{opt_str}
-END
-
-fw.opt_create "Gemfile", <<END
-source "https://rubygems.org"
-END
-
-fw.trigger 'Gemfile', 'bundle install'
-
-fw.add_line "Gemfile", "gem 'alki'", match: /^gem ['"]alki['"]/
-
-if options[:addons].include? "console"
-  fw.add_line "Gemfile", "gem 'alki-console'", match: /^gem ['"]alki-console['"]/
-
-  name = project_name.tr('/','-')
-  fw.add_line primary_config_path, "  mount :console, 'alki/console', name: '#{name}'", match: /^\s*mount\( *:console/, after: 'Alki do'
-
-  fw.create_exec 'bin/console', <<END
-#!/usr/bin/env ruby
-require 'bundler/setup'
-require 'alki/bin'
-require '#{project_name}'
-#{Alki::Support.classify(project_name)}.new.console.run
-END
-end
-
-if options[:addons].include? "reload"
-  fw.add_line "Gemfile", "gem 'alki-reload'", match: /^gem ['"]alki-reload['"]/
-
-  env_name = project_name.tr('a-z/','A-Z_')+"_ENV"
-  fw.add_line primary_config_path, "  mount(:reloader, 'alki/reload'){ set(:watch) { development? } }", match: /^\s*mount\(? *:reloader/, after: 'Alki do'
-  fw.add_line primary_config_path, "  set(:development?){ environment == 'development' }", match: /^\s*set\(? *:development\?/, after: 'Alki do'
-  fw.add_line primary_config_path, "  set(:environment){ ENV['#{env_name}'] || 'development' }", match: /^\s*set\(? *:environment/, after: 'Alki do'
-end
-
-fw.write

data/lib/alki/generator.rb

@@ -1,177 +0,0 @@
-module Alki
-  class Generator
-    def initialize(root_dir)
-      @root_dir = root_dir
-      @changes = []
-      @triggers = []
-    end
-
-    def create(file,contents)
-      @changes << [:create,file: file,contents: contents,opts: {}]
-    end
-
-    def create_exec(file,contents)
-      @changes << [:create,file: file,contents: contents,opts: {exec: true}]
-    end
-
-    def check_create(file:, contents:, opts:)
-      path = abs_path( file)
-      if File.exists? path
-        if File.read(path) == contents
-          :skip
-        end
-      end
-    end
-
-    def desc_create(file:, contents:, opts: {})
-      path = abs_path( file)
-      if opts[:exec]
-        adj = "executable "
-      end
-      if File.exists? path
-        "Overwriting #{adj}#{file}!"
-      else
-        "Create #{adj}#{file}"
-      end
-    end
-
-    def do_create(file:, contents:, opts: {})
-      path = abs_path( file)
-      FileUtils.mkdir_p File.dirname(path)
-      File.write path, contents
-      FileUtils.chmod '+x', path if opts[:exec]
-    end
-
-    def opt_create(file,contents)
-      @changes << [:opt_create,file: file,contents: contents]
-    end
-
-    def check_opt_create(file:, contents:)
-      if File.exists? abs_path( file)
-        :skip
-      end
-    end
-
-    def desc_opt_create(opts)
-      desc_create opts
-    end
-
-    def do_opt_create(opts)
-      do_create opts
-    end
-
-    def add_line(file,line,opts={})
-      @changes << [:add_line,file: file,line: line,opts: opts]
-    end
-
-    def check_add_line(file:,line:,opts:)
-      if File.exists? abs_path(file)
-        File.open(file) do |f|
-          if opts[:after]
-            found = until f.eof?
-              break true if f.readline.chomp == opts[:after]
-            end
-            unless found
-              puts "File \"#{file}\" doesn't contain required line #{opts[:after]}"
-              return :abort
-            end
-          end
-          until f.eof?
-            l = f.readline
-            if opts[:match] ? l.chomp.match(opts[:match]) : (l.chomp == line)
-              return :skip
-            end
-          end
-        end
-      else
-        unless @changes.find {|c| [:create,:opt_create].include?(c[0]) && c[1][:file] == file}
-          puts "File \"#{file}\" doesn't exist!"
-          return :abort
-        end
-      end
-    end
-
-    def desc_add_line(file:,line:,opts:)
-      "Add line \"#{line}\" to #{file}"
-    end
-
-    def do_add_line(file:,line:,opts:)
-      if opts[:after]
-        File.write file, File.read(file).sub(/^#{Regexp.quote(opts[:after])}\n/){|m| m + line + "\n"}
-      else
-        File.open(file,'a') do |f|
-          f.puts line
-        end
-      end
-    end
-
-    def trigger(file,cmd)
-      @triggers << [file, cmd]
-    end
-
-    def check_trigger(changes,file)
-      changes.find {|c| c[1][:file] == file}
-    end
-
-    def desc_trigger(cmd:)
-      "Run \"#{cmd}\""
-    end
-
-    def do_trigger(cmd:)
-      system cmd
-    end
-
-    def check_changes
-      puts "Checking preconditions..."
-      abort = false
-      unless Dir.exists?(@root_dir)
-        puts "Root dir doesn't exist"
-        exit 1
-      end
-      do_changes = []
-      @changes.each do |(type,args)|
-        res = send "check_#{type}", args
-        abort = true if res == :abort
-        do_changes << [type,args] unless res == :skip
-      end
-      @triggers.each do |(file,cmd)|
-        if check_trigger do_changes, file
-          do_changes << [:trigger,cmd: cmd]
-        end
-      end
-      exit 1 if abort
-      do_changes
-    end
-
-    def print_overview(changes)
-      puts "Overview of changes to be made:"
-
-      changes.each do |(type,args)|
-        desc = send "desc_#{type}", args
-        puts "  #{desc}" if desc
-      end
-      print "Proceed? "
-      resp = STDIN.gets.chomp
-      unless resp =~ /^y(es?)?/i
-        puts "Aborting"
-        exit
-      end
-    end
-
-    def write
-      puts "Using project root: #{@root_dir}\n"
-      do_changes = check_changes
-      print_overview do_changes
-
-      puts "Writing changes..."
-      do_changes.each do |(type,args)|
-        send "do_#{type}", args
-      end
-      puts "Done"
-    end
-
-    def abs_path(p)
-      File.expand_path(p,@root_dir)
-    end
-  end
-end