alki 0.13.3 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 477bb49ab83abf569bcc2b415b077cf15428c016
-  data.tar.gz: 32261729b502b2a85e66f5fa6b00f4c6ecd20adf
+SHA256:
+  metadata.gz: 0c6c996e3cc167d5050b102082788df3b5a903c04f7ac47c916a3e972d9b08b4
+  data.tar.gz: '0998b6b90e8662383ee9dbeb612eea8d46d9f8e7f71facb5dcb6eca9c445a66e'
 SHA512:
-  metadata.gz: 250fe69e4e13e33b5e66886fba89685511fafe043c45ecbf69c419075f249f069f80a791bcee2e1d569d2a8ab533321a6625c868c65ab30d5db7809958367c57
-  data.tar.gz: 229abd1df5d0b641eb2ace2d7ebf7788a0b750daed24db20d648cf52b5cee416313a9e2332fcce65fa567ec5885b676f4a1b9394b8d867fdb44cdb17c7f569bb
+  metadata.gz: ae2e60c2e81b564e29af9867fc4377200ee52a65cb5b14f4703b22e196a9e79fec6e45284e87aea3e876c457f66497aaf2bab4850d8900f3e2e69e12b6d185f5
+  data.tar.gz: 9d2d44039ded951d456e1a937f17c95499dca97e99dc968fdc5aedc5812e75ed022495efec372fba2ac6a165815e289563d0ec69693dec1fb2b9e1969b4c2ec8

data/.gitignore

@@ -19,4 +19,5 @@ tmp
 *.o
 *.a
 mkmf.log
-*.iml
+*.iml
+/bin/

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.1.10
+  - 2.5.1
+  - jruby

data/README.adoc

@@ -1,21 +1,27 @@
-# What is Alki?
+= What is Alki?
+
+image:https://travis-ci.org/alki-project/alki.svg?branch=master["Build Status", link="https://travis-ci.org/alki-project/alki"]
 
 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.
+It can be used alongside frameworks such as http://alki.io/projects/alki-rails.html[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]
+* http://alki.io/projects/alki-console.html[Developer console] (built on pry)
+* Automatic http://alki.io/projects/alki-reload.html[code reloading]
+* Powerful http://alki.io/projects/alki-dsl/[DSL toolkit]
 * Extensible
 
+For more documentation, check out http://alki.io[alki.io].
+
+For questions or discussion about Alki, head over to the https://groups.google.com/forum/#!forum/alki-project[Google Group].
 
-## Installation
+[[installation]]
+== Installation
 
 Add this line to your application's Gemfile:
 
@@ -31,19 +37,298 @@ Or install it yourself as:
 
     $ gem install alki
 
-## Introduction
-
-[NOTE]
-Full "todo" example can be found https://github.com/alki-project/alki-examples/tree/master/todo[here]
+== How to use Alki
 
 Alki simplifies project organization by pulling out all of the "connective tissue"
-that connects our classes and modules together, and puts them into a special object
-called an Assembly.
+that connects your classes and modules together.
+Alki provides a central place to build your application objects,
+where they can easily refer to other objects,
+and access configuration settings.
+
+For example,
+if your project has an http client
+
+.my_project/http_client.rb
+```ruby
+module MyProject
+  class HttpClient
+    ...
+  end
+end
+```
+
+you might normally use it by either creating a new instance of it when needed,
+or directly calling methods on the class.
+
+```ruby
+client = MyProject::HttpClient.new
+client.get '/page1.html'
+# -or-
+MyProject::HttpClient.get '/page1.html'
+```
+
+With Alki, you would instead define instructions for how to build the http client.
+
+.config/assembly.rb
+```ruby
+Alki do
+  service :http_client do
+    require 'my_project/http_client'
+    MyProject::HttpClient.new
+  end
+end
+```
 
-There are many ways to use Assemblies, but the most common is to have a single
-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.
+The 'service' method defines a new object with the name 'http_client',
+and the provided block contains the code needed to build it.
+
+To use the http client, an "Assembly" for the project has to be created.
+Assemblies are container objects that hold your application objects once
+they're built.
+
+Typically you can just add the following code to your project's main library file.
+More information can be found about this method http://alki.io/assemblies/project_assemblies.html[here].
+
+.lib/my_project.rb
+```ruby
+require 'alki'
+Alki.project_assembly!
+```
+
+This will add a 'new' method to the the MyProject module,
+which will return a new Assembly instance.
+The http client can be accessed by calling the method that matches the name we chose for it
+when it was defined,
+'http_client'.
+
+```ruby
+require 'my_project'
+
+app = MyProject.new
+app.http_client.get '/page1.html'
+```
+
+=== Configuration Settings
+
+Most projects, at some point,
+have to deal with configuration settings.
+
+In Ruby the typical pattern is to reference Modules and Classes directly,
+either by constructing them on demand when needed,
+or calling class methods on them.
+
+Often this leaves Modules and Classes to essentially have to configure themselves.
+Sometimes this is by pulling configuration from the environment or a configration file,
+sometimes it's by requiring a global variable to be set before the class is used.
+
+This means that classes are often cluttered with configuration code.
+Classes from different libraries might have different, inconsistent ways of being configured,
+and it can be difficult if not impossible to change how they're configured.
+
+In Alki, configuration becomes straightforward.
+Classes can just take configuration settings as initializer parameters,
+without worrying about where they comes from.
+
+.lib/my_project/http_client.rb
+```
+module MyProject
+  class HttpClient
+    def initializer(base_uri)
+      @base_uri = base_uri
+    end
+    ...
+  end
+end
+```
+
+Then the Assembly can be updated to pass in a configuration parameter.
+We can also define a new element for our base_url setting.
+
+.config/assembly.rb
+```ruby
+Alki do
+  set :http_base_url do
+     ENV.fetch('HTTP_BASE_URL')
+  end
+
+  service :http_client do
+    require 'my_project/http_client'
+    MyProject::HttpClient.new http_base_url
+  end
+end
+```
+
+The 'set' method is used to define simple values in the Assembly,
+and the http client can refer to it by name.
+
+Nothing changes with how we use the http client,
+but it's now pulling it's configuration from the environment.
+
+Changing this to have a default value,
+pull from a different source,
+or have multiple clients with different configuration parameters
+can be done easily without changing the class code.
+
+For example,
+to change the settings to come from a YAML file we can define a new
+element to parse the YAML file,
+and then redifine our setting to pull it's value from the parsed options.
+Note that the order doesn't matter.
+Even if a dependency is defined after an element that uses it,
+the objects will still be built in the correct order.
+
+.config/assembly.rb
+```ruby
+Alki do
+  set :yaml_settings do
+    require 'yaml'
+    YAML.load_file File.join(config_dir,'settings.yml')
+  end
+
+  set :http_base_url do
+    yaml_settings['http_base_ur']
+  end
+
+  service :http_client do
+    require 'my_project/http_client'
+    MyProject::HttpClient.new http_base_url
+  end
+end
+```
+
+No changes to the class,
+or in this case even the build code for the http client,
+are required.
+
+Configuration settings can be grouped together in the assembly,
+to namespace them.
+This group can be called anything, but we'll call it 'settings'.
+
+.config/assembly.rb
+```ruby
+Alki do
+  group :settings do
+    set :http_base_url do
+      yaml_settings['http_base_ur']
+    end
+
+    set :yaml_settings do
+      require 'yaml'
+      YAML.parse(File.read(File.join(config_dir,'settings.yml')))
+    end
+  end
+
+  service :http_client do
+    require 'my_project/http_client'
+    MyProject::HttpClient.new settings.http_base_url
+  end
+end
+```
+
+The can also be moved to an entirely different file to keep them
+seperate from your application objects.
+
+.config/settings.rb
+```ruby
+Alki do
+  set :http_base_url do
+    yaml_settings['http_base_ur']
+  end
+
+  set :yaml_settings do
+    require 'yaml'
+    YAML.parse(File.read(File.join(config_dir,'settings.yml')))
+  end
+end
+```
+
+.config/assembly.rb
+```ruby
+Alki do
+  load :settings
+
+  service :http_client do
+    require 'my_project/http_client'
+    MyProject::HttpClient.new settings.http_base_url
+  end
+end
+```
+
+== Dependency Injection
+
+Dependency Injection is a way of designing your classes to maximise
+their modularity and reusability.
+
+Much like with configuration settings,
+instead of directly referencing a classes dependencies a depenency injected
+class takes it's dependencies as arguments.
+
+The advantage of this is that classes can be developed and tested in isolation,
+can have dependencies easily changed by other code (like users of a library),
+or have multiple instances with different dependencies.
+
+Like configuration settings,
+a lot of Ruby projects end up needing some amount of dependency injection,
+but it's typically implemented in an ad-hoc way with class variables or other global
+variables.
+
+With Alki, dependency injection is the norm and very straightforward.
+
+Perhaps we have client for API that works over HTTP.
+We can write our API client so that it takes an HTTP client as an arugment
+and just calls methods on it.
+It doesn't need to pick a particular client library or decide what configuration
+settings it should have.
+
+.lib/my_project/api_client.rb
+```ruby
+module MyProject
+  class ApiClient
+    def initialize(http_client)
+      @http_client = http_client
+    end
+
+    def all
+      parse_response @http_client.get('/all.json')
+    end
+
+    ...
+   end
+end
+```
+
+With this design it's easy to change out the http client,
+or provide a stubbed or mocked one for testing.
+It maximizes the reusability of our API client
+because it only handles one thing
+(Single Responsibility Principle). 
+
+To add it to the previous assembly definition.
+
+.config/assembly.rb
+```ruby
+  load :settings
+
+  service :api_client do
+    require 'my_project/api_client'
+    MyProject::ApiClient.new http_client
+  end
+
+  service :http_client do
+    require 'my_project/http_client'
+    MyProject::HttpClient.new settings.http_base_url
+  end
+```
+
+== Example
+
+[NOTE]
+Full "todo" source code can be found https://github.com/alki-project/alki-examples/tree/master/todo[here]
+
+To demonstrate how a full Alki project can be put together,
+we'll go through an example application.
+This application is a little todo list command line utility
+that stores the todo list in a json file.
 
 .lib/todo.rb
 ```ruby
@@ -61,25 +346,25 @@ $ bundle exec irb -Ilib
  => #<Todo:21964520>
 ```
 
-### Defining Elements
-
-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 at http://alki.io[alki.io].
+[[defining-elements]]
+=== Defining Elements
 
+Adding things to the assembly requires an Assembly definition file.
+By convention this is named `config/assembly.rb` and is built using a DSL.
+There are a handful of different element types in Assemblies.
 Elements can refer to other elements, and can be defined in any order.
 
+Full documentation of the DSL can be found http://alki.io/dsl/[here].
+
+Below is an example Assembly definition for the todo application
+which uses a few of the core element types.
+
 .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_db') }
-    set :prompt, 'todo> '
-  end
+  load :settings
 
-  service :interface do <3>
+  service :interface do
     require 'todo/readline_interface'
     Todo::ReadlineInterface.new settings.prompt, handler
   end
@@ -100,11 +385,21 @@ Alki do
   end
 end
 ```
-<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
 
-Any element can be accessed directly from the assembly object.
+Along with a settings file to define our application settings.
+
+.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
+```
+
+Settings and services can be accessed by requiring the main "lib/todo.rb" file,
+creating a new assembly instance,
+and then calling methods to refer to the different elements.
 
 ```
 $ bundle exec irb -Ilib
@@ -112,7 +407,9 @@ $ bundle exec irb -Ilib
  => true
 2.4.0 :002 > todo = Todo.new
  => #<Todo:21964520>
-2.4.0 :003 > todo.interface.run
+2.4.0 :003 > todo.settings.prompt
+ => "> "
+2.4.0 :004 > todo.interface.run
 > ?
 All commands can be shortened to their first letters
 print
@@ -126,8 +423,11 @@ quit
 
 ```
 
-The 'alki-console' tool can also be used to quickly work with assemblies.
-Add `gem 'alki-console'` to your Gemfile and run `bundle --binstubs`.
+The http://alki.io/projects/alki-console.html[alki-console] developer console gem can also be used to quickly work with assemblies.
+It can be used by adding `gem 'alki-console'` to the Gemfile and running `bundle --binstubs` to add the console script to the 'bin' directory.
+
+Elements can be accessed directly without having to manually create an
+assembly instance.
 
 ```
 $ bin/alki-console
@@ -135,63 +435,45 @@ todo> settings.prompt
 => 'todo> '
 ```
 
+[[executable]]
 ### Creating an executable
 
-Read more about creating executables with Alki
-http://alki.io/executables.html[here].
+Read more about creating executables with Alki,
+including how to create executables to distribute in a gem,
+http://alki.io/assemblies/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
+.bin/todo
 ```ruby
+#!/usr/bin/env ruby
+
+# Setup 
+require 'bundler/setup'
+require 'alki/bin'
+
 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
+$ bin/todo
+> print
+1. take out the trash
+> quit
+$
 ```
 
-## Further Documentation
-
-Further documentation can be found at http://alki.io[alki.io].
+== Documentation
 
-Example projects can be found https://github.com/alki-project/alki-examples[here]
+More documentation can be found at http://alki.io[alki.io],
+with in-depth explanations of http://alki.io/assemblies/[Assemblies],
+http://alki.io/dsl/[the Assembly DSL], and other
+http://alki.io/projects/[projects] that are part of Alki.
 
-## Authors
+== Authors
 
 Written by Matt Edlefsen

data/alki.gemspec

@@ -8,18 +8,19 @@ Gem::Specification.new do |spec|
   spec.version       = Alki::VERSION
   spec.authors       = ["Matt Edlefsen"]
   spec.email         = ["matt.edlefsen@gmail.com"]
-  spec.summary       = %q{Base library for building applications.}
-  spec.description   = %q{Base library for building applications. Provides tools for organizing and connecting application units.}
-  spec.homepage      = "https://github.com/alki-project/alki"
+  spec.summary       = %q{Dependency Injection for Ruby}
+  spec.description   = %q{Alki (AL-kai) is a Dependency Injection framework for Ruby. Helps organize and scale your project, so you can focus on the important stuff.}
+  spec.homepage      = "http://alki.io"
   spec.license       = "MIT"
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.bindir        = 'exe'
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
+  spec.required_ruby_version = '>= 2.1.0'
 
-  spec.add_dependency "alki-dsl", "~> 0.5", '>= 0.5.1'
-  spec.add_dependency "alki-support", "~> 0.7"
+  spec.add_dependency "alki-dsl", "~> 0.6"
+  spec.add_dependency "alki-support", "~> 0.7", ">= 0.7.1"
   spec.add_dependency "concurrent-ruby", "~> 1.0"
   spec.add_dependency "ice_nine", "~> 0.11"
 end

data/lib/alki.rb

@@ -3,16 +3,20 @@ require 'alki/assembly/builder'
 
 Alki::Assembly::Builder.build project_assembly: __FILE__, load_mode: :require
 
-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
+class << Alki
+  def 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 Alki.create_assembly(opts={},&blk)
-  Alki::Assembly::Builder.build(opts,&blk)
-end
+  def create_assembly(opts={},&blk)
+    Alki::Assembly::Builder.build(opts,&blk)
+  end
+
+  def new(opts={},&blk)
+    Alki.create_assembly(opts,&blk).new
+  end
 
-def Alki.singleton_assembly(opts={},&blk)
-  Alki.create_assembly(opts,&blk).new
+  alias_method :singleton_assembly, :new
 end

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

@@ -4,10 +4,10 @@ Alki do
   attr :block
 
   output do
-    all_overlays = data[:overlays]&.overlays || []
+    all_overlays = (data[:overlays] && data[:overlays].overlays) || []
     value_overlays = all_overlays[:value] || []
     reference_overlays = all_overlays[:reference] || []
-    tags = data[:tags]&.tags || {}
+    tags = (data[:tags] && data[:tags].tags) || {}
     methods = {
       __build__: block,
       __apply_overlays__: -> obj, overlays {

data/lib/alki/execution/tag_map.rb

@@ -13,7 +13,7 @@ module Alki
       end
 
       def elements_in(tag)
-        @tag_map[tag]&.keys || []
+        (@tag_map[tag] && @tag_map[tag].keys) || []
       end
 
       def index(key)

data/lib/alki/version.rb

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

data/test/feature/auto_group_test.rb

@@ -13,7 +13,7 @@ describe 'Auto Group' do
   end
 
   it 'should create a group containing all items' do
-    @obj.grp.children.must_equal [:a,:one]
+    @obj.grp.children.sort.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

data/test/feature/mounts_test.rb

@@ -6,7 +6,7 @@ describe 'Mounts' do
       set :val, :test
     end
 
-    assembly = Alki.singleton_assembly do
+    assembly = Alki.new do
       mount :mounted, AlkiTest
     end
 

data/test/feature/overrides_test.rb

@@ -53,7 +53,7 @@ describe 'Overrides' do
 
   it 'should allow calling original when mounted' do
     other = @assembly
-    instance = Alki.singleton_assembly do
+    instance = Alki.new do
       mount :assembly, other do
         set :val do
           original.val

data/test/feature/references_test.rb

@@ -3,7 +3,7 @@ require 'alki/feature_test'
 describe 'References' do
   describe 'circular references' do
     before do
-      @assembly = Alki.singleton_assembly do
+      @assembly = Alki.new do
         set :a do
           b
         end
@@ -35,7 +35,7 @@ describe 'References' do
 
   describe 'reference objects' do
     before do
-      @obj = Alki.singleton_assembly do
+      @obj = Alki.new do
         service :broken do
           1.foo
         end

data/test/feature/try_mounts_test.rb

@@ -2,7 +2,7 @@ require 'alki/feature_test'
 
 describe 'Try mounts' do
   it 'should not mount if other assembly can be found' do
-    obj = Alki.singleton_assembly do
+    obj = Alki.new do
       try_mount :other, 'missing_assembly'
       set :val do
         respond_to? :other
@@ -12,7 +12,7 @@ describe 'Try mounts' do
   end
 
   it 'should mount if other assembly can be found' do
-    obj = Alki.singleton_assembly do
+    obj = Alki.new do
       try_mount :other, 'example' # example fixture assembly
       set :val do
         respond_to? :other

data/test/feature/values_test.rb

@@ -7,7 +7,7 @@ describe 'Values' do
         true
       end
     end.new
-    Alki.singleton_assembly do
+    Alki.new do
       set :obj, obj
     end
   end

metadata

@@ -1,79 +1,79 @@
 --- !ruby/object:Gem::Specification
 name: alki
 version: !ruby/object:Gem::Version
-  version: 0.13.3
+  version: 0.14.0
 platform: ruby
 authors:
 - Matt Edlefsen
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2018-03-23 00:00:00.000000000 Z
+date: 2018-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: alki-dsl
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.5'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.5.1
-  type: :runtime
+        version: '0.6'
+  name: alki-dsl
   prerelease: false
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.5'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: '0.6'
 - !ruby/object:Gem::Dependency
-  name: alki-support
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.7'
-  type: :runtime
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  name: alki-support
   prerelease: false
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.1
 - !ruby/object:Gem::Dependency
-  name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-  type: :runtime
+  name: concurrent-ruby
   prerelease: false
+  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         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
+  name: ice_nine
   prerelease: false
+  type: :runtime
   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.
+description: Alki (AL-kai) is a Dependency Injection framework for Ruby. Helps organize
+  and scale your project, so you can focus on the important stuff.
 email:
 - matt.edlefsen@gmail.com
 executables: []
@@ -81,14 +81,12 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.adoc
 - Rakefile
 - alki.gemspec
-- bin/alki
-- bin/bundler
-- bin/rake
 - config/assembly.rb
 - lib/alki.rb
 - lib/alki/assembly.rb
@@ -171,11 +169,11 @@ files:
 - test/integration/dsls/assembly_test.rb
 - test/integration/dsls/assembly_type_test.rb
 - test/integration/dsls/service_dsl_test.rb
-homepage: https://github.com/alki-project/alki
+homepage: http://alki.io
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -183,18 +181,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.12
-signing_key: 
+rubyforge_project:
+rubygems_version: 2.6.13
+signing_key:
 specification_version: 4
-summary: Base library for building applications.
+summary: Dependency Injection for Ruby
 test_files:
 - test/feature/alki_test.rb
 - test/feature/auto_group_test.rb

data/bin/alki

@@ -1,17 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-#
-# This file was generated by Bundler.
-#
-# The application 'alki' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-require "pathname"
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
-  Pathname.new(__FILE__).realpath)
-
-require "rubygems"
-require "bundler/setup"
-
-load Gem.bin_path("alki", "alki")

data/bin/bundler

@@ -1,17 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-#
-# This file was generated by Bundler.
-#
-# The application 'bundler' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-require "pathname"
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
-  Pathname.new(__FILE__).realpath)
-
-require "rubygems"
-require "bundler/setup"
-
-load Gem.bin_path("bundler", "bundler")

data/bin/rake

@@ -1,17 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-#
-# This file was generated by Bundler.
-#
-# The application 'rake' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-require "pathname"
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
-  Pathname.new(__FILE__).realpath)
-
-require "rubygems"
-require "bundler/setup"
-
-load Gem.bin_path("rake", "rake")