alki 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bfc0e6ec1368d9f0df28e72d8978aef6afe37ecf
-  data.tar.gz: a251bd8975e08e982b0cf18710bb5abbea957cb0
+  metadata.gz: 31a32ce28977b35ce72bab1992d4512c7ea33f44
+  data.tar.gz: c6ab121484e99b437aaae6390db983d83a011cc7
 SHA512:
-  metadata.gz: 6203b1f5a0914be306e711733aabe161f11346e286a4a2011eeea8d97cff7a2ebc8e5ed6ea41df0506917062b54dab07175b6061a6ccae32bf1cb29294009b91
-  data.tar.gz: 3a8d1da8bc5a4396fb5124c7e6b823747942f38b56e046e5933b77d806656b8567276f3e5d129caf1998f415ace2287e722adaf42958d951aa05a7083485467c
+  metadata.gz: bd1da1b284b8caa1d75a32ac5e199f5f64e504213de1abeedb694e6f6fca517633992b8f2572129b71d329ed0069de2d698b89c0dd2f395a72d49243dbe2032c
+  data.tar.gz: fd7e999ffc561b91e6452bd859f8f8783fd0a90f097a703febd7746d837227717fa2bfafdaac310903eecef08090d1b2fd834444682b49a38ccdb37dac404a10

data/.gitignore

@@ -7,7 +7,6 @@ Gemfile.lock
 InstalledFiles
 _yardoc
 coverage
-doc/
 lib/bundler/man
 pkg
 rdoc

data/README.ad

@@ -0,0 +1,12 @@
+# What is Alki?
+
+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.
+
+# Synopsis
+
+Best place to start would be to check out some examples:
+
+* https://github.com/alki-project/alki-example
+* https://github.com/alki-project/alki/tree/master/test/fixtures/example

data/doc/assemblies.ad

@@ -0,0 +1,138 @@
+Assemblies
+==========
+
+Project Assemblies
+------------------
+
+Most of the time, a project will have a single assembly. Alki makes doing this 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 but it in a subdirectory
+as usual, `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 be a normal Alki loader block.
+
+```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
+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
+```
+
+Once 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 do 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 of values which will set values (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 accessibly via the `original` method.
+This can also be used to access the original versions of elements that have been overriden.

data/doc/assembly_dsl.ad

@@ -0,0 +1,242 @@
+Assembly DSL
+===========
+
+Building Assemblies is done via a DSL that makes putting together the pieces of your project easy.
+
+Groups
+------
+
+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
+```
+
+Scoping is also done by group, so that an element will be found by moving up parent groups until
+it is found.
+
+```ruby
+require 'alki'
+assembly = Alki.create_assembly do
+  set :val, "one"
+  group :g1 do
+    set :val, "two"
+    group :g2 do
+      func :print do
+        puts val
+      end
+    end
+  end
+end
+assembly.new.g1.g2.print
+
+#output: two
+```
+
+=== Loading groups
+
+Groups can also be loaded from other config files via the `load` command.
+
+.config/settings.rb
+```ruby
+Alki do
+  set :val, "hello"
+end
+```
+
+```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
+------
+
+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.
+One difference between the block form of `set` and `service` is that services are affected
+by overlays, whereas basic values are not.
+
+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"
+
+#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 object (like a Proc). This object
+is then called directly when the factory is referenced. This allows you to require files or construct
+a factory object once but still run code on every reference.
+
+```ruby
+require 'alki'
+assembly = Alki.create_assembly do
+  factory :logger do
+    require 'logger'
+    -> (io) { Logger.new io }
+  end
+
+  service :main_logger do
+    logger STDOUT
+  end
+end
+assembly.new.main_logger << "hello"
+
+#output: hello
+```
+
+### Overlays (overlay)
+
+Overlays are a way to intercept and transform calls made to all services in a given group or it's
+sub-groups.
+
+Overlays are often most useful in groups where all services adhere to a common interface, and overlays
+can be used to perform aspect oriented programming like logging, validation, or access controls.
+
+
+### Assemblies (assembly)
+
+Other assemblies can be mounted into your Assembly using the `assembly` command.
+
+The first argument is what it should be named in your assembly. The optional second argument
+is the name of the assembly. This should be formatted like a require string (relative path but
+no `.rb`) and will default to the value of the first argument. If a classified version of that name
+can't be found, it will attempt to `require` it, and then try again.
+
+```ruby
+require 'alki'
+Alki.create_assembly name: 'other_assembly' do
+  set :val, "one"
+
+  set :invalid_val2 do
+    val2
+  end
+
+  set :root_val2 do
+    root.val2
+  end
+end
+
+Alki.create_assembly name: 'main_assembly' do
+  set :val2, "two"
+  assembly :other, 'other_assembly'
+end
+instance = MainAssembly.new
+puts instance.other.val
+#output: one
+
+# Can't access val2 in main assembly
+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
+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'
+Alki.create_assembly name: 'other_assembly' do
+  set :msg, nil
+  func :print do
+    puts msg
+  end
+end
+
+Alki.create_assembly name: 'main_assembly' do
+  set :val, "hello"
+  assembly :other, 'other_assembly' do
+    set :msg do
+      val
+    end
+  end
+end
+MainAssembly.new.other.print
+
+#output: hello
+```

data/doc/index.ad

@@ -0,0 +1,15 @@
+Alki
+====
+
+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::projects.ad[]
+
+:leveloffset: 1
+include::assemblies.ad[]
+
+:leveloffset: 1
+include::assembly_dsl.ad[]

data/doc/projects.ad

@@ -0,0 +1,43 @@
+Setting up Alki Projects
+========================
+
+Generally, projects that use alki work the same as normal Ruby projects but there are a couple of
+guidelines to make life easier.
+
+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
+----------------------------
+
+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 require your library files and run them.
+
+Using Alki 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`.
+
+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 (no `bundle/setup` or `alki/bin`).
+

data/lib/alki/assembly.rb

@@ -1,10 +1,11 @@
 require 'alki/assembly_executor'
+require 'alki/override_builder'
 require 'alki/dsls/assembly'
 
 module Alki
   module Assembly
-    def new(overrides={})
-      Alki::Assembly::Instance.new create_assembly(overrides), self.assembly_options
+    def new(overrides={},&blk)
+      Alki::Assembly::Instance.new create_assembly(overrides,&blk), self.assembly_options
     end
 
     def root
@@ -13,36 +14,14 @@ module Alki
 
     private
 
-    def create_assembly(overrides={})
+    def create_assembly(overrides={},&blk)
       config_dir = if assembly_options[:load_path]
-        build_type :value, assembly_options[:load_path]
+        Alki::Support.load_class("alki/assembly_types/value").new assembly_options[:load_path]
       else
         nil
       end
 
-      build_type :assembly, root, config_dir, create_override_group(overrides)
-    end
-
-
-    def create_override_group(overrides)
-      unless overrides.empty?
-        root = build_type(:group)
-        overrides.each do |path,value|
-          set_override root, *path.to_s.split('.'), value
-        end
-        root
-      end
-    end
-
-    def set_override(root,*parent_keys,key,value)
-      parent = parent_keys.inject(root) do |parent,key|
-        parent.children[key.to_sym] ||= build_type(:group)
-      end
-      parent.children[key.to_sym] = build_type(:value, value)
-    end
-
-    def build_type(type,*args)
-      Alki::Support.load_class("alki/assembly_types/#{type}").new *args
+      Alki::Support.load_class("alki/assembly_types/assembly").new root, config_dir, OverrideBuilder.build(overrides,&blk)
     end
 
     class Instance

data/lib/alki/assembly_builder.rb

@@ -19,7 +19,14 @@ module Alki
 
     def build(opts={},&blk)
       build_assembly blk if blk
-      set_config_directory opts[:config_dir] if opts[:config_dir]
+      if opts[:config_dir]
+        context = if opts[:project_assembly]
+          File.dirname opts[:project_assembly]
+        else
+          Dir.pwd
+        end
+        set_config_directory File.expand_path opts[:config_dir], context
+      end
       set_assembly_name opts[:name] if opts[:name]
       setup_project_assembly opts[:project_assembly] if opts[:project_assembly]
       load_assembly_file opts[:primary_config] unless definition

data/lib/alki/assembly_executor.rb

@@ -65,42 +65,35 @@ module Alki
       proc = -> (name,*args,&blk) {
         call res.pkg, res.cache, res.elem[:scope][name], *args, &blk
       }
-      group = GroupContext.new(proc,res.elem[:scope].keys)
+      group = create_context(GroupContext,res)
       -> { group }
     end
 
     def with_scope_context(res,blk = nil)
-      proc = -> (name,*args,&blk) {
-        call res.pkg, res.cache, res.elem[:scope][name], *args, &blk
+      methods = {
+        __call__: { body: (blk || res.elem[:block])}
       }
+      yield create_context(ValueContext,res,methods)
+    end
 
-      context_class = Alki::ClassBuilder.build(
-        super_class: ValueContext,
-        instance_methods: {
-          __call__: { body: (blk || res.elem[:block])}
+    def create_context(super_class,res,methods={})
+      executor = self
+
+      res.elem[:scope].keys.each do |meth|
+        methods[meth] = {
+          body: ->(*args,&blk) {
+            executor.call res.pkg, res.cache, res.elem[:scope][meth], *args, &blk
+          }
         }
+      end
+      context_class = Alki::ClassBuilder.build(
+        super_class: super_class,
+        instance_methods: methods
       )
-
-      yield context_class.new(proc, res.elem[:scope].keys)
+      context_class.new
     end
 
     class Context
-      def initialize(executor,scope)
-        @executor = executor
-        @scope = scope
-      end
-
-      def respond_to_missing?(name,include_all)
-        @scope.include? name
-      end
-
-      def method_missing(name,*args,&blk)
-        if @scope.include? name
-          @executor.call name, *args, &blk
-        else
-          super
-        end
-      end
     end
 
     class ValueContext < Context
@@ -118,7 +111,7 @@ module Alki
         unless path.is_a?(String) or path.is_a?(Symbol)
           raise ArgumentError.new("lazy can only take Strings or Symbols")
         end
-        Alki::ServiceDelegator.new pkg, path
+        Alki::ServiceDelegator.new assembly, path
       end
     end
 

data/lib/alki/bin.rb

@@ -0,0 +1,5 @@
+lib_dir = File.join(Bundler.root,'lib')
+
+unless $LOAD_PATH.include? lib_dir
+  $LOAD_PATH.unshift lib_dir
+end

data/lib/alki/dsls/assembly.rb

@@ -12,7 +12,7 @@ Alki do
   end
 
   finish do
-    root = build_group(ctx[:elems], ctx[:overlays])
+    ctx[:root] = root = build_group(ctx.delete(:elems), ctx.delete(:overlays))
     add_class_method :root do
       root
     end

data/lib/alki/dsls/assembly_types/assembly.rb

@@ -1,16 +1,15 @@
+require 'alki/override_builder'
 require 'alki/support'
 
 Alki do
   require_dsl 'alki/dsls/assembly_types/group'
   require_dsl 'alki/dsls/assembly_types/value'
 
-  dsl_method :assembly do |name,pkg=name.to_s,&blk|
+  dsl_method :assembly do |name,pkg=name.to_s,**overrides,&blk|
     klass = Alki::Support.load_class pkg
     config_dir = klass.assembly_options[:load_path]
     config_dir = build_value config_dir if config_dir
-    overrides = if blk
-       build_group_dsl(blk)
-    end
+    overrides = Alki::OverrideBuilder.build overrides, &blk
 
     add_assembly name, klass.root, config_dir, overrides
   end
@@ -24,11 +23,13 @@ Alki do
       if key == :config_dir
         data.merge! main_data
         config_dir
+      elsif key == :original
+        root
       else
         if overrides
           data.replace(
             main: data.merge(main_data),
-            override: data.dup,
+            override: override_data,
           )
           override.index data, key
         else
@@ -40,6 +41,7 @@ Alki do
     output do
       scope = root.output(data)[:scope]
       scope[:config_dir] = (data[:prefix]||[]) + [:config_dir]
+      scope[:original] = (data[:prefix]||[]) + [:original]
       scope.merge! overrides.output(data)[:scope] if overrides
       {
         type: :group,
@@ -47,9 +49,16 @@ Alki do
       }
     end
 
+    def override_data
+      od = data.dup
+      od[:scope] ||= {}
+      od[:scope].merge! original: ((data[:prefix]||[]) + [:original])
+      od
+    end
+
     def main_data
-      pkg = data[:prefix] ? data[:prefix].dup : []
-      {scope: {pkg: pkg, root: []}, overlays: []}
+      assembly_path = data[:prefix] ? data[:prefix].dup : []
+      {scope: {assembly: assembly_path, root: []}, overlays: []}
     end
 
     def override

data/lib/alki/dsls/assembly_types/group.rb

@@ -2,12 +2,7 @@ require 'alki/dsls/assembly'
 
 Alki do
   dsl_method :group do |name,&blk|
-    add name, build_group_dsl(blk)
-  end
-
-  helper :build_group_dsl do |blk|
-    data = Alki::Dsls::Assembly.build &blk
-    build_group data[:elems], data[:overlays]
+    add name, Alki::Dsls::Assembly.build(&blk)[:root]
   end
 
   element_type :group do

data/lib/alki/override_builder.rb

@@ -0,0 +1,35 @@
+require 'alki/dsls/assembly'
+
+module Alki
+  module OverrideBuilder
+    def self.build(override_hash=nil,&blk)
+      if blk
+        Alki::Dsls::Assembly.build(&blk)[:root]
+      elsif override_hash && !override_hash.empty?
+        create_override_group override_hash
+      end
+    end
+
+    def self.create_override_group(overrides)
+      unless overrides.empty?
+        root = build_type(:group)
+        overrides.each do |path,value|
+          set_override root, *path.to_s.split('.'), value
+        end
+        root
+      end
+    end
+
+    def self.set_override(root,*parent_keys,key,value)
+      parent = parent_keys.inject(root) do |parent,key|
+        parent.children[key.to_sym] ||= build_type(:group)
+      end
+      parent.children[key.to_sym] = build_type(:value, value)
+    end
+
+    def self.build_type(type,*args)
+      Alki::Support.load_class("alki/assembly_types/#{type}").new *args
+    end
+
+  end
+end

data/lib/alki/version.rb

@@ -1,3 +1,3 @@
 module Alki
-  VERSION = "0.6.1"
+  VERSION = "0.7.0"
 end

data/test/feature/overrides_test.rb

@@ -1,18 +1,50 @@
 require_relative '../test_helper'
-
-$LOAD_PATH.unshift Alki::Test.fixture_path('tlogger','lib')
-require 'tlogger'
+require 'logger'
+require 'alki'
 require 'stringio'
 
 describe 'Overrides' do
+  before do
+    @assembly = Alki.create_assembly do
+      set :log_io do
+        raise "Must set log_io"
+      end
+      group :util do
+        service :logger do
+          require 'logger'
+          Logger.new log_io
+        end
+      end
+    end
+  end
+
   it 'should be possibly to override assembly values on initialize' do
     assert_raises RuntimeError do
-      Tlogger.new.log << "test"
+      @assembly.new.util.logger << "test"
     end
     io = StringIO.new
-    logger = Tlogger.new(io: io)
-    logger.log << "test"
-    logger.log << "test"
+    logger = @assembly.new(log_io: io)
+    logger.util.logger << "test"
+    logger.util.logger << "test"
     io.string.must_equal "testtest"
   end
+
+  it 'should allow overriding via block' do
+    logger_class = Class.new(Logger) do
+      def info(msg)
+        self << "INFO #{msg}"
+      end
+    end
+    io = StringIO.new
+    instance = @assembly.new do
+      set :log_io, io
+      group :util do
+        service :logger do
+          logger_class.new original.log_io
+        end
+      end
+    end
+    instance.util.logger.info "test"
+    io.string.must_equal "INFO test"
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alki
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Matt Edlefsen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-12-03 00:00:00.000000000 Z
+date: 2016-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -103,15 +103,20 @@ files:
 - ".gitignore"
 - Gemfile
 - LICENSE.txt
-- README.md
+- README.ad
 - Rakefile
 - alki.gemspec
 - config/dsls.rb
+- doc/assemblies.ad
+- doc/assembly_dsl.ad
+- doc/index.ad
+- doc/projects.ad
 - lib/alki.rb
 - lib/alki/assembly.rb
 - lib/alki/assembly_builder.rb
 - lib/alki/assembly_executor.rb
 - lib/alki/assembly_handler_base.rb
+- lib/alki/bin.rb
 - lib/alki/dsls/assembly.rb
 - lib/alki/dsls/assembly_type.rb
 - lib/alki/dsls/assembly_type_dsl.rb
@@ -122,6 +127,7 @@ files:
 - lib/alki/dsls/assembly_types/value.rb
 - lib/alki/dsls/service.rb
 - lib/alki/overlay_delegator.rb
+- lib/alki/override_builder.rb
 - lib/alki/service_delegator.rb
 - lib/alki/test.rb
 - lib/alki/version.rb

data/README.md

@@ -1,55 +0,0 @@
-# What is Alki?
-
-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.
-
-# Synopsis
-
-Best place to start would be to check out some examples:
-
-* https://github.com/alki-project/alki-example
-* https://github.com/alki-project/alki/tree/master/test/fixtures/example
-
-# The Alki Assembly
-
-If a set of classes are the raw materials of your product, an Assembly is the finished product, ready to ship.
-
-To get there, you provide Alki with your assembly definition, which acts as the instructions for how to piece together your classes and objects.
-
-Assembly definitions are written in a simple DSL and are transformed into classes.
-
-```ruby
-require 'alki'
-
-class Printer
-  def print(msg)
-    puts msg
-  end
-end
-
-MyAssembly = Alki.create_assembly do
-  service :printer do
-    Printer.new
-  end
-end
-
-MyAssembly.new.printer.print "hello world"
-```
-
-## Project Assemblies
-
-While Assemblies can be created directly as in the previous example, most
-of the time an entire project will contain instructions for a single Assembly.
-
-To ease this use case, Alki supports a simple standard project layout.
-
-* `config` and `lib` directories in your project root.
-* A file called `config/assembly.rb` with your assembly definition inside an `Alki do ... end` block.
-* A file under lib that has the name of your project. For example if your project was called `MyProject`, create a file called `lib/my_project.rb`.
-  Inside the file put the following two lines:
-  
-    ```ruby
-require 'alki'
-Alki.project_assembly!
-    ```