alki 0.9.1 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bc1b79ca08e965916ecbd78625d9635f9b11868c
-  data.tar.gz: 7d847de049a43edefa043d07ef4d64160c625407
+  metadata.gz: bc042cd47800b613d12e02456c24d25afc170f7b
+  data.tar.gz: 1ab703cbc5c5458d181f3b8d2a4c357d4d9c4056
 SHA512:
-  metadata.gz: 05ffaa08ff5d51121f127ee2db0cc01238031b1b0ff6f7e0c1a95eedab5cd551e6733c991ea54a7058cc308468843b97591e40fdbac5c19b005317fbaddd5614
-  data.tar.gz: a1db4bc72926268f1d1ccb789215c903bfd83a0e165816a98777fa15bf5ab70f230a2a35854f94ebf62df8cb0810f9f7b3a2c1fc09bc1cd3cac0d468964b148b
+  metadata.gz: b85b7153906906aaabb7d3dfc18e6060765f68bcf3a2885972acbbbd1c3d6a01a15b5c112205dc8fa0f64cf8403f056dd9091fadc2849e3051806cb4fe3fb183
+  data.tar.gz: b4dabbf9b1b3514ae65e189334848768670839d4e086bb6160158154ece8b7041def60184036e819c15df41de971ebb126849c1db62cb52917014615995f0abd

data/README.adoc

@@ -1,19 +1,20 @@
 # What is Alki?
-:toc:
 
-Alki is a small framework for writing Ruby projects, providing a powerful dependency injection system with
-helpers for testing, creating executables, and easy to use libraries.
+Alki is a small framework for Ruby that provides a powerful dependency injection and program
+management system with helpers for testing, creating executables, and writing DSLs.
 
 It's goal is to remove uncertainty and friction when building Ruby projects, allowing developers to focus on
 implementing business logic. It can be used alongside other frameworks such as Ruby on Rails.
 
-Alki tries to combine the time tested software engineering concepts such as
+Alki tries to combine time tested software engineering concepts such as
 https://en.wikipedia.org/wiki/SOLID_(object-oriented_design)[SOLID],
 and  https://en.wikipedia.org/wiki/Inversion_of_control[Inversion of Control], with
 Ruby style ease of use, DSLs, and
 https://en.wikipedia.org/wiki/Convention_over_configuration[Convention over Configuration].
 
-Documentation can be found at https://github.com/alki-project/alki/blob/master/doc/index.adoc
+Further documentation can be found at https://github.com/alki-project/alki/blob/master/doc/index.adoc
+
+Example projects can be found at https://github.com/alki-project/alki-examples
 
 ## Getting Started
 
@@ -21,94 +22,13 @@ Install from rubygems
 
     gem install alki
 
-Setting up Alki in your project requires only created a couple of files, but the
+Setting up Alki in your project requires only creating a couple of files, but the
 `alki` command line tool can also be used to automate the process. Project names
 should be given in lowercase using underscores and forward slashes as separators.
 
 .Example project
 ```
 $ cd <project dir>
-$ alki init --console <project name>
+$ alki init --addons console <project name>
 ```
-## Example
-
-To demonstrate the basic features of Alki, this will go through the creation of
-a simple example project.
-
-To get started, a new project should be created.
-
-```
-$ mkdir example
-$ cd example
-$ alki init --console example
-```
-
-### First Service
-
-Open up `config/assembly.rb` in your favorite text editor and add a simple log
-service as an example. The service definition should require the files it needs and
-then construct an object.
-
-.config/assembly.rb
-```ruby
-Alki do
-  mount :console, 'alki/console', name: 'example'
-
-  service :log do
-    require 'logger'
-    Logger.new STDERR
-  end
-end
-```
-
-To test, we can open up the console and interact with our new service.
-
-```bash
-$ bin/console
-example> log.info "test message"
-I, [<timestamp>]  INFO -- : test message
-=> true
-test> exit
-```
-
-### Adding Settings
-
-Many times in a project there will end with a lot of configuration settings or magic
-numbers sprinkled throughout your code, maybe pulled from `ENV` or just set directly
-as constants. Alki provides a simple way to centralize them. By convention this is done
-by creating a `config/settings.rb` and loading it into your Assembly.
-
-To demonstrate we can pull the log io (`STDERR`) out of our main assembly and add it
-to our settings.
-
-.config/settings.rb
-```ruby
-Alki do
-  set :log_io, STDERR
-end
-```
-Now we can load our settings file in our assembly config (`load :settings`) and use
-the setting in our log service.
-
-.config/assembly.rb
-```ruby
-Alki do
-  load :settings
-  mount :console, 'alki/console', name: 'example'
-
-  service :log do
-    require 'logger'
-    Logger.new settings.log_io
-  end
-end
-```
-
-### Adding your own Classes
-
-Generally, you're not just going to be using other people's classes. Alki doesn't have any requirements as to
-where your classes need to go, but conventionally they can be placed under `lib/<project-name>/`.
-
-The Alki style of writing a Class is to only `require` external libraries, or utility files in your class files.
-All of the "glue" that ties your code together can instead be put in your assembly definition. This allows you
-to modularize and loosely couple your programs.
 

data/alki.gemspec

@@ -21,6 +21,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake", '~> 10.0'
   spec.add_dependency "minitest", "~> 5.9", '>= 5.9.1'
-  spec.add_dependency "alki-dsl", "~> 0.3", '>= 0.3.3'
-  spec.add_dependency "alki-support", "~> 0.6"
+  spec.add_dependency "alki-dsl", "~> 0.4"
+  spec.add_dependency "alki-support", "~> 0.7"
 end

data/exe/alki

@@ -102,7 +102,8 @@ if options[:addons].include? "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?){ ENV['#{env_name}'] == 'development' }", match: /^\s*set :development?/, 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/assembly/builder.rb

@@ -11,6 +11,7 @@ module Alki
         @assembly_name = nil
         @definition = nil
         @load_mode = :direct
+        @primary_config = 'assembly'
       end
 
       attr_reader :config_dir, :assembly_name, :definition
@@ -22,6 +23,9 @@ module Alki
       def build(opts={},&blk)
         @load_mode = opts[:load_mode] if opts[:load_mode]
         build_assembly blk if blk
+        @primary_config = opts[:primary_config] if opts[:primary_config]
+        set_assembly_name opts[:name] if opts[:name]
+        setup_project_assembly opts[:project_assembly] if opts[:project_assembly]
         if opts[:config_dir]
           context = if opts[:project_assembly]
             File.dirname opts[:project_assembly]
@@ -30,13 +34,11 @@ module Alki
           end
           @config_dir = 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]
         register_config_directory if @config_dir
         if blk
           build_assembly blk
         else
-          load_assembly_file opts[:primary_config]
+          load_assembly_file
         end
         build_empty_assembly unless definition
         build_class
@@ -44,16 +46,11 @@ module Alki
 
       def setup_project_assembly(path)
         root = Alki::Support.find_root(path) do |dir|
-          File.exists?(File.join(dir,'config','assembly.rb')) ||
+          File.exists?(File.join(dir,'config',"#{@primary_config}.rb")) ||
             File.exists?(File.join(dir,'Gemfile')) ||
             !Dir.glob(File.join(dir,'*.gemspec')).empty?
         end
         if root
-          unless @config_dir
-            config_dir = File.join(root,'config')
-            @config_dir = config_dir if File.exists? config_dir
-          end
-
           unless @assembly_name
             lib_dir = File.join(root,'lib')
             name = Alki::Support.path_name path, lib_dir
@@ -62,6 +59,11 @@ module Alki
             end
             set_assembly_name name
           end
+
+          unless @config_dir
+            config_dir = File.join(root,'config')
+            @config_dir = config_dir if File.exists? config_dir
+          end
         end
       end
 
@@ -69,18 +71,21 @@ module Alki
         @assembly_name = name
       end
 
+      def config_prefix
+        unless @assembly_name
+          raise "Can't use config directory without a name"
+        end
+        File.join(@assembly_name,'assembly_config')
+      end
+
       def register_config_directory
-        Alki::Dsl.register_dir @config_dir, 'alki/dsls/assembly', dsl_opts
+        Alki::Loader.register @config_dir, builder: 'alki/dsls/assembly', name: config_prefix, **dsl_opts
       end
 
-      def load_assembly_file(name = nil)
-        name ||= 'assembly'
+      def load_assembly_file
         if @config_dir
-          assembly_config_path = File.join(@config_dir,"#{name}.rb")
-          if File.exists? assembly_config_path
-            @definition = assembly_config_path
-            true
-          end
+          @definition = File.join(config_prefix,@primary_config)
+          true
         end
       end
 
@@ -89,14 +94,17 @@ module Alki
       end
 
       def build_assembly(blk)
-        @definition = Alki::Dsl.build('alki/dsls/assembly', dsl_opts, &blk)[:class]
+        @definition = Alki::Dsl.build('alki/dsls/assembly', dsl_opts, &blk)
       end
 
       def dsl_opts
-        opts = {config_dir: @config_dir}
+        opts = {}
         if @assembly_name
-          opts[:prefix] = File.join(@assembly_name,'alki_config')
           opts[:assembly_name] = @assembly_name
+          if @config_dir
+            opts[:config_dir] = @config_dir
+            opts[:prefix] = config_prefix
+          end
         end
         opts
       end
@@ -122,9 +130,7 @@ module Alki
             },
             definition: {
               body: ->{
-                definition.is_a?(String) ?
-                  Alki::Dsl.load(definition)[:class] :
-                  definition
+                Alki.load definition
               }
             },
             load_class: {

data/lib/alki/assembly/executor.rb

@@ -6,15 +6,15 @@ module Alki
   InvalidPathError = Class.new(StandardError)
   module Assembly
     class Executor
-      def initialize(assembly,overlays)
+      def initialize(assembly,meta)
         @assembly = assembly
-        @overlays = overlays
+        @meta = meta
         @data = {}
         @semaphore = Monitor.new
         @lookup_cache = {}
         @call_cache = {}
         @context_cache = {}
-        @processed_overlays = false
+        @processed_meta = false
       end
 
       def synchronize
@@ -28,26 +28,30 @@ module Alki
       end
 
       def execute(meta,path,args,blk)
+        cache_entry = nil
+        synchronize do
           cache_entry = @call_cache[path]
-          if cache_entry
-            if cache_entry.status == :building
-              raise "Circular element reference found: #{path.join(".")}"
-            end
-          else
-            @semaphore.synchronize do
-              cache_entry = @call_cache[path]
-              unless cache_entry
-                cache_entry = @call_cache[path] = Alki::Execution::CacheEntry.new
-                action = lookup(path)
-                if action[:build]
-                  build_meta = meta.merge(building: path.join('.'))
-                  build_action = action[:build].merge(scope: action[:scope],modules: action[:modules])
-                  call_value(*process_action(build_action),build_meta,[action])
-                end
-                cache_entry.finish *process_action(action)
+        end
+        if cache_entry
+          if cache_entry.status == :building
+            raise "Circular element reference found: #{path.join(".")}"
+          end
+        else
+          synchronize do
+            cache_entry = @call_cache[path]
+            unless cache_entry
+              cache_entry = @call_cache[path] = Alki::Execution::CacheEntry.new
+              action = lookup(path)
+              if action[:build]
+                build_meta = meta.merge(building: path.join('.'))
+                build_meta.merge!(action[:meta]) if action[:meta]
+                build_action = action[:build].merge(scope: action[:scope],modules: action[:modules])
+                call_value(*process_action(build_action),build_meta,[action])
               end
+              cache_entry.finish *process_action(action)
             end
           end
+        end
         call_value(cache_entry.type,cache_entry.value,meta,args,blk)
       end
 
@@ -62,25 +66,47 @@ module Alki
 
       private
 
-      def process_overlays
-        unless @processed_overlays
-          @processed_overlays = true
+      def process_meta
+        unless @processed_meta
+          @processed_meta = true
           @data[:overlays] = {}
-          @overlays.each do |(from,info)|
-            target = canonical_path(from,info.target) or
-              raise InvalidPathError.new("Invalid overlay target #{info.target.join('.')}")
-            overlay = info.overlay
-            if overlay.is_a?(Array)
-              overlay = canonical_path(from,info.overlay) or
-                raise InvalidPathError.new("Invalid overlay path #{info.overlay.join('.')}")
+          @data[:tags] = {}
+          @meta.each do |(from,type,info)|
+            case type
+              when :overlay then process_overlay from, info
+              when :tags then process_tags from, info
             end
-            (@data[:overlays][target]||=[]) << [overlay,info.args]
           end
         end
       end
 
+      def process_tags(from,tags)
+        tags.each do |tag|
+          (@data[:tags][tag]||=[]) << from
+        end
+      end
+
+      def process_overlay(from,info)
+        target_path = info.target.dup
+        if target_path.last.to_s.start_with?('%')
+          tag = target_path.pop
+        end
+        if target_path == []
+          target_path = [:root]
+        end
+        target = canonical_path(from,target_path) or
+          raise InvalidPathError.new("Invalid overlay target #{info.target.join('.')}")
+        target = target.dup.push tag if tag
+        overlay = info.overlay
+        if overlay.is_a?(Array)
+          overlay = canonical_path(from,info.overlay) or
+            raise InvalidPathError.new("Invalid overlay path #{info.overlay.join('.')}")
+        end
+        (@data[:overlays][target]||=[]) << [info.type, overlay, info.args]
+      end
+
       def lookup(path)
-        process_overlays
+        process_meta
         @lookup_cache[path] ||= lookup_elem(path).tap do |elem|
           unless elem
             raise InvalidPathError.new("Invalid path #{path.inspect}")

data/lib/alki/assembly/{handler_base.rb → handler.rb}

@@ -1,6 +1,6 @@
 module Alki
   module Assembly
-    class HandlerBase
+    class Handler
       def initialize(elem,data,key=nil)
         @elem = elem
         @data = data

data/lib/alki/assembly/instance.rb

@@ -7,6 +7,7 @@ module Alki
       def initialize(assembly_module,args)
         @assembly_module = assembly_module
         @args = args
+        @version = 0
       end
 
       def __reload__
@@ -14,7 +15,7 @@ module Alki
           did_something = @obj.__reload__
         end
         if did_something != false && @obj
-          @obj = nil
+          __setobj__ nil
           did_something = true
         end
         if did_something
@@ -24,12 +25,18 @@ module Alki
       end
 
       def __setobj__(obj)
+        @version += 1
         @obj = obj
       end
 
+      def __version__
+        @version
+      end
+
       def __getobj__
         unless @obj
-          Alki::Support.load_class(@assembly_module).raw_instance self, *@args
+          # Will call __setobj__
+          Alki.load(@assembly_module).raw_instance self, *@args
         end
         @obj
       end

data/lib/alki/assembly/type.rb

@@ -0,0 +1,19 @@
+module Alki
+  module Assembly
+    class Type
+      def index(*args)
+        handler(args).index
+      end
+
+      def output(*args)
+        handler(args).output
+      end
+
+      private
+
+      def handler(args)
+        self.class::Handler.new(self,*args)
+      end
+    end
+  end
+end

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

@@ -73,6 +73,7 @@ Alki do
   end
 
   def update_scope(data,scope=data[:scope])
+    scope[:root] = []
     add_parent_path scope, data
     add_original scope, data
   end

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

@@ -1,11 +1,11 @@
 Alki do
-  require 'alki/execution/value_context'
+  require 'alki/execution/value_helpers'
 
   attr :block
 
   output do
     {
-      modules: [Alki::Execution::ValueContext],
+      modules: [Alki::Execution::ValueHelpers],
       scope: data[:scope],
       build: {
         methods: {

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

@@ -1,10 +1,10 @@
 Alki do
-  require 'alki/execution/value_context'
+  require 'alki/execution/value_helpers'
 
   attr :block
   output do
     {
-      modules: [Alki::Execution::ValueContext],
+      modules: [Alki::Execution::ValueHelpers],
       scope: data[:scope],
       proc: block
     }

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

@@ -1,14 +1,30 @@
 Alki do
-  require 'alki/execution/context'
+  require 'alki/execution/helpers'
 
   attr(:children){ {} }
 
   index do
     update_scope children, data[:prefix], data[:scope]
 
+    data[:tags] = data[:tags].inject({}) do |tags,(tag,tagged)|
+      tagged.each do |path|
+        if path.empty? || path[0] == key.to_sym
+          tags[tag] = (tags[tag]||[]) | [path[1..-1]]
+        end
+      end
+      tags
+    end
+
     data[:overlays] = data[:overlays].inject({}) do |no,(target,overlays)|
       target = target.dup
-      if target.empty? || target.shift == key.to_sym
+      if target.size == 1 && target[0].to_s.start_with?('%')
+        tags = data[:tags][target[0].to_s[1..-1].to_sym]
+        if tags
+          tags.each do |target|
+            (no[target]||=[]).push *overlays
+          end
+        end
+      elsif target.empty? || target.shift == key.to_sym
         (no[target]||=[]).push *overlays
       end
       no
@@ -23,7 +39,7 @@ Alki do
     {
       full_scope: update_scope(children, data[:prefix], data[:scope]),
       scope: update_scope(children,data[:prefix]),
-      modules: [Alki::Execution::Context],
+      modules: [Alki::Execution::Helpers],
       proc: ->{self}
     }
   end

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

@@ -10,13 +10,6 @@ Alki do
 
     if main_child && override_child
       (data[:main][:scope]||={}).merge! (data[:override][:scope]||{})
-      data[:main][:overlays]||={}
-      if data[:override][:overlays]
-        data[:override][:overlays].each do |target,overlays|
-          (data[:main][:overlays][target]||=[]).push *overlays
-        end
-      end
-      data[:override][:overlays]=data[:main][:overlays].dup
       Alki::Assembly::Types::Override.new main_child, override_child
     elsif main_child
       data.replace data[:main]

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

@@ -1,5 +1,5 @@
 Alki do
-  require 'alki/execution/value_context'
+  require 'alki/execution/value_helpers'
 
   attr :proc
 
@@ -11,7 +11,7 @@ Alki do
         },
         proc: ->(desc) {desc[:value] = __build__}
       },
-      modules: [Alki::Execution::ValueContext],
+      modules: [Alki::Execution::ValueHelpers],
       scope: data[:scope]
     }
   end

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

@@ -1,26 +1,37 @@
 Alki do
-  require 'alki/execution/value_context'
+  require 'alki/execution/value_helpers'
 
   attr :block
 
   output do
-    overlays = data[:overlays][[]]||[]
+    overlays = (data[:overlays][[]]||[]).group_by(&:first)
+    value_overlays = overlays[:value]||[]
+    reference_overlays = overlays[:reference]||[]
+    methods = {
+      __build__: block,
+      __apply_overlays__: -> obj, overlays {
+        overlays.inject(obj) do |val,(_,overlay,args)|
+          overlay = __raw_root__.lookup(overlay) if overlay.is_a?(Array)
+          if !overlay.respond_to?(:call) && overlay.respond_to?(:new)
+            overlay = overlay.method(:new)
+          end
+          overlay.call val, *args
+        end
+      }
+    }
+    unless reference_overlays.empty?
+      methods[:__process_reference__] = -> ref {
+        __apply_overlays__ ref, reference_overlays
+      }
+    end
     {
       build: {
-        methods: {
-          __build__: block
-        },
+        methods: methods,
         proc: -> (elem) {
-          elem[:value] = overlays.inject(__build__) do |val,(overlay,args)|
-            overlay = root.lookup(overlay) if overlay.is_a?(Array)
-            if !overlay.respond_to?(:call) && overlay.respond_to?(:new)
-              overlay = overlay.method(:new)
-            end
-            overlay.call val, *args
-          end
+          elem[:value] = __apply_overlays__ __build__, value_overlays
         },
       },
-      modules: [Alki::Execution::ValueContext],
+      modules: [Alki::Execution::ValueHelpers],
       scope: data[:scope],
     }
   end

data/lib/alki/assembly.rb

@@ -16,13 +16,14 @@ module Alki
       override_root = overrides_info[:root] || build(:group)
 
       assembly = build :assembly, root, override_root
-      update_instance_overlay = [[],OverlayInfo.new(
+      update_instance_overlay = [[],:overlay, OverlayInfo.new(
+        :value,
         [:assembly_instance],
         ->obj{instance.__setobj__ obj; instance},
         []
       )]
-      all_overlays = overlays+overrides_info[:overlays]+[update_instance_overlay]
-      executor = Executor.new(assembly, all_overlays)
+      all_meta = meta+overrides_info[:meta]+[update_instance_overlay]
+      executor = Executor.new(assembly, all_meta)
 
       override_root.children[:assembly_instance] = build(:service,->{
         root
@@ -35,14 +36,14 @@ module Alki
       self.definition.root
     end
 
-    def overlays
-      self.definition.overlays
+    def meta
+      self.definition.meta
     end
 
     private
 
     def build(type,*args)
-      Alki::Support.load_class("alki/assembly/types/#{type}").new *args
+      Alki.load("alki/assembly/types/#{type}").new *args
     end
   end
 end