alki 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1d03b924924111f899b88319c5fae18228e4a060
-  data.tar.gz: 14231faa1ae0f3b455ecae08335b0b49198ee537
+  metadata.gz: b62e2164cbf952d15c45aa1845bdd03afac913b0
+  data.tar.gz: 749ebc7d797b44ec3ecd900d4cb48b2e45af625d
 SHA512:
-  metadata.gz: 34d3014edc286dba4028867b4dac194e2982029ccc5bd430e87b34df0c4ab136c4e4899aac0c89e84f666ef3f422bfbb5635555e76b8f00afbf58c7f7a108d9e
-  data.tar.gz: 4544b374525cb978fdd42fe39709cac0e1e47f6ab69dad77ab001dc942ff41bf9eae406c85df3a15319497c2574a3bd80800bb8d846c12eae38d7cbd00057e74
+  metadata.gz: 56a1e7009e25e8c846f13cbeefa8e5043f3d1148675534f6082358f8ed4de0f0a53f146af5ec19219e0d9ec9ecf618abb9e290e1db731d86d28b51cd133c6ef3
+  data.tar.gz: db587ec5e1a2a6f3594ec7081729b96aa666da5bc2ebceba4c3360fa723befb900c45e9c24e07d4d4c9b29f94a49af8c644ce491f41beb27516737a8c8b62893

data/Gemfile

@@ -1,9 +1,3 @@
 source 'https://rubygems.org'
 
 gemspec
-
-gem 'pry'
-
-group :test do
-  gem 'minitest', '~> 5.4.2'
-end

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.2"
-  spec.add_dependency "alki-support", "~> 0.4"
+  spec.add_dependency "alki-dsl", "~> 0.3"
+  spec.add_dependency "alki-support", "~> 0.5"
 end

data/lib/alki/assembly.rb

@@ -3,15 +3,15 @@ require 'alki/assembly_executor'
 module Alki
   module Assembly
     def new
-      Alki::Assembly::Instance.new assembly, load_path: config_root
+      Alki::Assembly::Instance.new assembly, self.assembly_options
     end
 
     def assembly
-      self.assembly_class.assembly
+      self.definition.assembly
     end
 
     def root
-      self.assembly_class.root
+      self.definition.root
     end
 
     class Instance

data/lib/alki/assembly_builder.rb

@@ -0,0 +1,102 @@
+require 'alki/assembly'
+require 'alki/class_builder'
+require 'alki/dsl'
+require 'alki/support'
+
+module Alki
+  class AssemblyBuilder
+    def initialize
+      @assembly_options = {}
+      @assembly_name = nil
+      @definition = nil
+    end
+
+    attr_reader :assembly_options, :assembly_name, :definition
+
+    def self.build(opts={},&blk)
+      new.build(opts,&blk)
+    end
+
+    def build(opts={},&blk)
+      build_assembly blk if blk
+      set_config_directory opts[:config_dir] if opts[:config_dir]
+      set_assembly_name opts[:name] if opts[:name]
+      detect_from_path opts[:path] if opts[:path]
+      load_assembly_file opts[:primary_config] unless definition
+      build_empty_assembly unless definition
+      build_class
+    end
+
+    def detect_from_path(path)
+      root = Alki::Support.find_root(path) do |dir|
+        File.exists?(File.join(dir,'config','assembly.rb')) ||
+          File.exists?(File.join(dir,'Gemfile')) ||
+          !Dir.glob(File.join(dir,'*.gemspec')).empty?
+      end
+      if root
+        unless @assembly_options[:load_path]
+          config_dir = File.join(root,'config')
+          set_config_directory 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
+          unless name
+            raise "Can't auto-detect name of assembly"
+          end
+          set_assembly_name name
+        end
+      end
+    end
+
+    def set_assembly_name(name)
+      @assembly_name = name
+    end
+
+    def set_config_directory(config_dir)
+      Alki::Dsl.register_dir config_dir, 'alki/dsls/assembly'
+      @assembly_options[:load_path] = config_dir
+    end
+
+    def load_assembly_file(name = nil)
+      name ||= 'assembly'
+      if @assembly_options[:load_path]
+        assembly_config_path = File.join(@assembly_options[:load_path],"#{name}.rb")
+        if File.exists? assembly_config_path
+          @definition = Alki::Dsl.load(assembly_config_path)[:class]
+          true
+        end
+      end
+    end
+
+    def build_empty_assembly
+      build_assembly ->{}
+    end
+
+    def build_assembly(blk)
+      @definition = Alki::Dsl.build('alki/dsls/assembly', &blk)[:class]
+    end
+
+    def build_class
+      assembly_options = @assembly_options
+      definition = @definition
+      Alki::ClassBuilder.build(
+        prefix: '',
+        name: @assembly_name,
+        class_modules: [Alki::Assembly],
+        type: :module,
+        class_methods: {
+          definition: {
+            body: ->{
+              definition
+            }
+          },
+          assembly_options: {
+            body: ->{ assembly_options }
+          }
+        }
+      )
+    end
+  end
+end

data/lib/alki/assembly_executor.rb

@@ -1,5 +1,6 @@
 require 'alki/service_delegator'
 require 'alki/overlay_delegator'
+require 'alki/class_builder'
 
 module Alki
   class AssemblyExecutor
@@ -26,10 +27,8 @@ module Alki
         raise "Path not found: #{path.join('.')}" unless elem
         res = Resource.new assembly, cache, elem
         cache[path] = case elem[:type]
-          when :service
-            service res, path
-          when :factory
-            factory res, &blk
+          when :value
+            value res, path
           when :group
             group res
         end
@@ -37,6 +36,19 @@ module Alki
       cache[path].call *args, &blk
     end
 
+    def value(res,path)
+      evaluator = -> (value_block,*args,&blk) {
+        with_scope_context(res,value_block) do |ctx|
+          val = ctx.__call__(*args,&blk)
+          if res.elem[:overlays]
+            val = apply_overlays res, path, val
+          end
+          val
+        end
+      }
+      res.elem[:block].call evaluator
+    end
+
     def service(res,path)
       with_scope_context(res) do |ctx,blk|
         svc = apply_overlays res, path, ctx.instance_exec(&blk)
@@ -47,8 +59,8 @@ module Alki
     def apply_overlays(res,path,obj)
       res.elem[:overlays].inject(obj) do |obj,overlay_elem|
         unless res.cache[overlay_elem[:block]]
-          with_scope_context(res.with_elem(overlay_elem)) do |ctx,blk|
-            res.cache[overlay_elem[:block]] = ctx.instance_exec(&blk)
+          with_scope_context(res.with_elem(overlay_elem)) do |ctx|
+            res.cache[overlay_elem[:block]] = ctx.__call__
           end
         end
         local_path = path[overlay_elem[:scope][:root].size..-1].join('.')
@@ -60,11 +72,7 @@ module Alki
       with_scope_context(res) do |ctx,blk|
         factory = ctx.instance_exec(&blk)
         -> (*args,&blk) {
-          if !args.empty? or blk
-            factory.call *args, &blk
-          else
-            factory
-          end
+          factory.call *args, &blk
         }
       end
     end
@@ -77,12 +85,19 @@ module Alki
       -> { group }
     end
 
-    def with_scope_context(res)
+    def with_scope_context(res,blk = nil)
       proc = -> (name,*args,&blk) {
         call res.pkg, res.cache, res.elem[:scope][name], *args, &blk
       }
 
-      yield ServiceContext.new(proc,res.elem[:scope].keys), res.elem[:block]
+      context_class = Alki::ClassBuilder.build(
+        super_class: ValueContext,
+        instance_methods: {
+          __call__: { body: (blk || res.elem[:block])}
+        }
+      )
+
+      yield context_class.new(proc, res.elem[:scope].keys)
     end
 
     class Context
@@ -104,7 +119,7 @@ module Alki
       end
     end
 
-    class ServiceContext < Context
+    class ValueContext < Context
       def lookup(path)
         unless path.is_a?(String) or path.is_a?(Symbol)
           raise ArgumentError.new("lookup can only take Strings or Symbols")

data/lib/alki/dsls/assembly.rb

@@ -1,9 +1,9 @@
 Alki do
   require_dsl 'alki/dsls/class'
   require_dsl 'alki/dsls/assembly_types/group'
-  require_dsl 'alki/dsls/assembly_types/load'
-  require_dsl 'alki/dsls/assembly_types/service'
+  require_dsl 'alki/dsls/assembly_types/value'
   require_dsl 'alki/dsls/assembly_types/assembly'
+  require_dsl 'alki/dsls/assembly_types/load'
   require_dsl 'alki/dsls/assembly_types/overlay'
 
   init do

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

@@ -2,11 +2,10 @@ require 'alki/support'
 
 Alki do
   dsl_method :load do |group_name,name=group_name.to_s|
-    add_load group_name, ctx[:prefix], name
+    add_load group_name, name
   end
 
   element_type :load do
-    attr :prefix
     attr :name
 
     index do
@@ -19,17 +18,12 @@ Alki do
 
     def group
       unless (data[:loaded]||={})[name]
-        if data[:load_path]
-          require File.join(data[:load_path],name)
-        else
-          require name
-        end
-        prefixed_name = if prefix
-          File.join(prefix,name)
+        path = if data[:load_path]
+          File.join(data[:load_path],"#{name}.rb")
         else
           name
         end
-        data[:loaded][name] = Alki::Support.load_class(prefixed_name).root
+        data[:loaded][name] = Alki::Dsl.load(path)[:class].root
       end
       data[:loaded][name]
     end

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

@@ -0,0 +1,54 @@
+Alki do
+  dsl_method :set do |name,value=nil,&blk|
+    add_value name, false, -> (evaluator) {
+      val = if blk
+         evaluator.call blk
+      else
+        value
+      end
+      -> { val }
+    }
+  end
+
+  dsl_method :service do |name,&blk|
+    add_value name, true, -> (evaluator) {
+      svc = evaluator.call blk
+      -> { svc }
+    }
+  end
+
+  dsl_method :factory do |name,&blk|
+    add_value name, false, -> (evaluator) {
+      factory = evaluator.call blk
+      -> (*args,&blk) {
+        factory.call *args, &blk
+      }
+    }
+  end
+
+  dsl_method :func do |name,&value_blk|
+    add_value name, false, -> (evaluator) {
+      -> (*args,&blk) {
+        evaluator.call(value_blk,*args,&blk)
+      }
+    }
+  end
+
+  element_type :value do
+    attr :apply_overlays
+    attr :block
+
+    output do
+      result  = {
+        type: :value,
+        block: block,
+        scope: data[:scope].merge(root: [])
+      }
+      if apply_overlays
+        last_clear = data[:overlays].rindex(:clear)
+        result[:overlays] =  last_clear ? data[:overlays][(last_clear + 1)..-1] : data[:overlays]
+      end
+      result
+    end
+  end
+end

data/lib/alki/version.rb

@@ -1,3 +1,3 @@
 module Alki
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

data/lib/alki.rb

@@ -1,39 +1,12 @@
-require 'alki/support'
-require 'alki/assembly'
-require 'alki/class_builder'
-require 'alki/dsl'
+require 'alki/assembly_builder'
 
 module Alki
-  def self.create_assembly!(name=nil,root=nil)
-    if !root
-      root = Alki::Support.find_root(caller_locations(1, 1)[0].absolute_path) do |dir|
-        File.exists?(File.join(dir,'config','assembly.rb'))
-      end
-    end
-    if !name
-      path = caller_locations(1,1)[0].absolute_path
-      lib_dir = File.join(root,'lib','')
-      unless path.start_with?(lib_dir) && path.end_with?('.rb')
-        raise "Can't auto-detect name of assembly"
-      end
-      name = path[lib_dir.size..-4]
-    end
-    config_root = File.join(root,'config')
-    Alki::ClassBuilder.build(
-      name: name,
-      class_modules: [Alki::Assembly],
-      type: :module,
-      class_methods: {
-        assembly_class: {
-          body: ->{
-            @assembly_class ||= Alki::Dsl.load(File.join(config_root,'assembly.rb'))[:class]
-          }
-        },
-        config_root: {
-          body: ->{ config_root }
-        }
-      }
-    )
-    Alki::Dsl.register_dir config_root, 'alki/dsls/assembly', prefix: File.join(name,'assembly')
+  def self.create_assembly!(opts={},&blk)
+    opts[:path] ||= caller_locations(1,1)[0].absolute_path
+    AssemblyBuilder.build(opts,&blk)
+  end
+
+  def self.create_assembly(opts={},&blk)
+    AssemblyBuilder.build(opts,&blk)
   end
 end

data/test/feature/alki_test.rb

@@ -0,0 +1,59 @@
+require_relative '../test_helper'
+require 'alki'
+
+describe Alki do
+  describe :create_assembly do
+    def build(opts={},&blk)
+      Alki.create_assembly opts, &blk
+    end
+
+    it 'should return module with ::assembly, ::root, and ::new methods' do
+      klass = build
+      klass.must_respond_to :assembly
+      klass.must_respond_to :root
+      klass.must_respond_to :new
+    end
+
+    it 'should use provided block to provide assembly definition' do
+      klass = build do
+        service :svc do
+          :val1
+        end
+      end
+      klass.new.svc.must_equal :val1
+    end
+
+    it 'should load assembly definition from config_dir if provided' do
+      build(config_dir: fixture_path('tlogger','config')).new.must_respond_to :log
+    end
+
+    it 'should load file other than assembly if provided with primary_config' do
+      build(
+        config_dir: fixture_path('example','config'),
+        primary_config: 'settings'
+      ).new.must_respond_to :fizz
+    end
+
+    it 'should create class if provided with a name' do
+      klass = build(name: 'alki_test/test_assembly')
+      AlkiTest::TestAssembly.must_equal klass
+      Object.send :remove_const, :AlkiTest
+    end
+
+    it 'should automatically determine config_dir and name if path provided' do
+      was_defined = defined? Tlogger
+      Object.send :remove_const, :Tlogger if was_defined
+      klass = build(path: fixture_path('tlogger','lib','tlogger.rb'))
+      Tlogger.must_equal klass
+      klass.new.must_respond_to :log
+      Object.send :remove_const, :Tlogger unless was_defined
+    end
+  end
+
+  describe :create_assembly! do
+    it 'should automatically set path option using path of caller' do
+      require fixture_path('tlogger','lib','tlogger.rb')
+      Tlogger.new.must_respond_to :log
+    end
+  end
+end

data/test/feature/example_test.rb

@@ -0,0 +1,45 @@
+require_relative '../test_helper'
+
+
+$LOAD_PATH.unshift Alki::Test.fixture_path('example','lib')
+$LOAD_PATH.unshift Alki::Test.fixture_path('tlogger','lib')
+
+describe 'Example' do
+  before do
+    require 'example'
+
+    @expected = [
+      "1","2","Fizz!","4","Buzz!","Fizz!","7", "8", "Fizz!",
+      "Buzz!", "11", "Fizz!", "13", "14", "Fizzbuzz!", "16",
+      "17", "Fizz!", "19", "Buzz!"
+    ]
+    @handlers = [
+      ['fizzbuzz', /Fizzbuzz!/],
+      ['fizz', /Fizz!/],
+      ['buzz', /Buzz!/],
+      ['echo', /\d+/],
+    ]
+  end
+
+  describe 'run' do
+    before do
+      @app = Example.new
+      @app.run 1..20
+    end
+
+    it 'should set output to correct fizzbuzz results' do
+      @app.output.to_a.must_equal @expected
+    end
+
+    it 'should log calls to handlers due to overlay' do
+      log_lines = @app.log_io.string.split(/\n/)
+
+      @expected.each.with_index do |val,i|
+        @handlers.find do |(handler,re)|
+          log_lines.shift.must_equal "Calling handlers.#{handler}#handle #{i+1}"
+          val =~ re
+        end
+      end
+    end
+  end
+end

data/test/fixtures/example/config/assembly.rb

@@ -12,6 +12,10 @@ Alki do
                       ]
   end
 
+  func :run do |range|
+    range_handler.handle range
+  end
+
   service :range_handler do
     require 'range_handler'
     RangeHandler.new lazy('handler')
@@ -22,8 +26,15 @@ Alki do
     ArrayOutput.new
   end
 
+  service :log_io do
+    require 'stringio'
+    StringIO.new
+  end
+
   assembly :tlogger do
-    set :io, STDERR
+    set :io do
+      log_io
+    end
   end
 
   service :log do

data/test/fixtures/example/config/handlers.rb

@@ -25,6 +25,6 @@ Alki do
 
   overlay do
     require 'log_overlay'
-    LogOverlay.new lazy('log')
+    LogOverlay.new lookup('log')
   end
 end

data/test/integration/dsls/assembly_test.rb

@@ -1,6 +1,5 @@
 require_relative '../../test_helper'
 require 'alki/dsls/assembly'
-require 'alki/assembly_processor'
 
 describe Alki::Dsls::Assembly do
   it 'should work' do
@@ -17,12 +16,10 @@ describe Alki::Dsls::Assembly do
         end
       end
     end
-    p res[:class].assembly
-    res[:class].assembly.children[:file].name.must_equal 'file'
-    res[:class].assembly.children[:test].block.call.must_equal :val
-    res[:class].assembly.children[:group1].children[:test2].block.call.must_equal :val2
+    res[:class].root.children[:file].name.must_equal 'file'
+    res[:class].root.children[:test].must_respond_to :block
+    res[:class].root.children[:group1].children[:test2].must_respond_to :block
 
-    r = res[:class].assembly.lookup [:group1,:test2]
-    p r
+    r = res[:class].root.lookup [:group1,:test2]
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alki
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Matt Edlefsen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-11-30 00:00:00.000000000 Z
+date: 2016-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -64,28 +64,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: alki-support
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.5'
 description: Base library for building applications. Provides tools for organizing
   and connecting application units.
 email:
@@ -103,6 +103,7 @@ files:
 - config/dsls.rb
 - 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/dsls/assembly.rb
@@ -112,13 +113,14 @@ files:
 - lib/alki/dsls/assembly_types/group.rb
 - lib/alki/dsls/assembly_types/load.rb
 - lib/alki/dsls/assembly_types/overlay.rb
-- lib/alki/dsls/assembly_types/service.rb
+- lib/alki/dsls/assembly_types/value.rb
 - lib/alki/dsls/service.rb
 - lib/alki/overlay_delegator.rb
 - lib/alki/service_delegator.rb
 - lib/alki/test.rb
 - lib/alki/version.rb
-- test/feature/create_package_test.rb
+- test/feature/alki_test.rb
+- test/feature/example_test.rb
 - test/fixtures/config.rb
 - test/fixtures/example/config/assembly.rb
 - test/fixtures/example/config/handlers.rb
@@ -161,7 +163,8 @@ signing_key:
 specification_version: 4
 summary: Base library for building applications.
 test_files:
-- test/feature/create_package_test.rb
+- test/feature/alki_test.rb
+- test/feature/example_test.rb
 - test/fixtures/config.rb
 - test/fixtures/example/config/assembly.rb
 - test/fixtures/example/config/handlers.rb

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

@@ -1,25 +0,0 @@
-Alki do
-  dsl_method :set do |name,value=nil,&blk|
-    add_service name, :service, (blk || -> { value })
-  end
-
-  dsl_method :service do |name,&blk|
-    add_service name, :service, blk
-  end
-
-  dsl_method :factory do |name,&blk|
-    add_service name, :factory, blk
-  end
-
-  element_type :service do
-    attr :type
-    attr :block
-
-    output do
-      last_clear = data[:overlays].rindex(:clear)
-      overlays = last_clear ? data[:overlays][(last_clear + 1)..-1] : data[:overlays]
-      scope = data[:scope].merge root: []
-      {type: type, block: block, overlays: overlays, scope: scope}
-    end
-  end
-end

data/test/feature/create_package_test.rb

@@ -1,18 +0,0 @@
-require_relative '../test_helper'
-
-describe 'Alki.create_package!' do
-  describe 'example' do
-    it 'should do fizzbuzz' do
-      $LOAD_PATH << File.join(fixtures_path,'example','lib')
-      $LOAD_PATH << File.join(fixtures_path,'tlogger','lib')
-      require 'example'
-      app = Example.new
-      app.range_handler.handle 1..20
-      app.output.to_a.must_equal [
-                                   "1","2","Fizz!","4","Buzz!","Fizz!","7", "8", "Fizz!",
-                                   "Buzz!", "11", "Fizz!", "13", "14", "Fizzbuzz!", "16",
-                                   "17", "Fizz!", "19", "Buzz!"
-                                 ]
-    end
-  end
-end