alki 0.1.0

data/test/unit/application_test.rb

@@ -0,0 +1,159 @@
+require_relative '../test_helper'
+
+require 'alki/application'
+
+describe Alki::Application do
+  before do
+    @settings = {test: 1}
+    @app = Alki::Application.new @settings
+  end
+
+  describe :settings do
+    it 'should return settings passed into new' do
+      @app.settings.must_be_same_as @settings
+    end
+  end
+
+  describe :configure do
+    it 'should allow calling methods as a DSL' do
+      @app.configure do
+        service :test_m do
+          :test
+        end
+      end
+      @app.test_m.must_equal :test
+    end
+  end
+
+  describe :root do
+    it 'should allow extracting the root group from the application' do
+      @app.service(:test_m) { :test }
+      @app.root.test_m.must_equal :test
+    end
+  end
+
+  describe :service do
+    it 'should create method that gets result of block' do
+      @app.service(:test_m) { :test }
+      @app.respond_to?(:test_m).must_equal true
+      @app.test_m.must_equal :test
+    end
+
+    it 'generated method should run on demand' do
+      count = 0
+      @app.service(:test_m){ count += 1; :test }
+      count.must_equal 0
+      @app.test_m
+      count.must_equal 1
+    end
+
+    it 'generated method should run only once' do
+      count = 0
+      @app.service(:test_m){ count += 1; :test }
+      @app.test_m
+      @app.test_m
+      count.must_equal 1
+    end
+  end
+
+  describe :group do
+    it 'should create group with block' do
+      @app.configure do
+        group :g1 do
+        end
+      end
+      @app.g1.wont_be_nil
+    end
+
+    it 'should add services to group' do
+      @app.configure do
+        group :g1 do
+          service(:testm1) { :test1 }
+        end
+        group :g1 do
+          service(:testm2) { :test2 }
+        end
+      end
+      @app.g1.testm1.must_equal :test1
+      @app.g1.testm2.must_equal :test2
+    end
+
+    it 'should allow creation of subgroups' do
+      @app.configure do
+        group :g1 do
+          group :g2 do
+            service(:test_m) { :test }
+          end
+        end
+      end
+      @app.g1.g2.test_m.must_equal :test
+    end
+
+    it 'should allow calling services of parent groups' do
+      @app.configure do
+        service(:test1) { :test1 }
+        group :g1 do
+          service(:test2) { :test2 }
+          group :g2 do
+            service(:test3) { [test1,test2] }
+          end
+        end
+      end
+      @app.g1.g2.test3.must_equal [:test1,:test2]
+    end
+
+    it 'should allow aliasing groups' do
+      @app.configure do
+        group :g1 do
+          service(:test_m) { :test }
+        end
+      end
+      @app.group(:g2,@app.g1)
+      @app[:g2].test_m.must_equal :test
+    end
+
+    it 'should allow moving groups to other applications' do
+      app2 = Alki::Application.new
+      app2.service(:test_m) { :test }
+      @app.group(:other,app2.root)
+      @app.other.test_m.must_equal :test
+    end
+
+    it 'should raise ArgumentError if non-group is provided' do
+      assert_raises ArgumentError do
+        @app.group(:test, {})
+      end
+    end
+  end
+
+  describe :lookup do
+    it 'should allow lookups of services by string' do
+      @app.service(:test_m) { :test }
+      @app.lookup('test_m').must_equal :test
+    end
+
+    it 'should allow looking up services in groups using dot separators' do
+      @app.configure do
+        group :g1 do
+          service(:test_m) { :test1 }
+          group :g2 do
+            service(:test_m) { :test2 }
+          end
+        end
+      end
+      @app.lookup('g1.test_m').must_equal :test1
+      @app.lookup('g1.g2.test_m').must_equal :test2
+    end
+  end
+
+  describe :delegate do
+    it 'should allow service reference cycles' do
+      @app.configure do
+        service(:all) { {print_all: delegate(:print_all)} }
+        service(:print_all) { list = all.keys; ->{ p list } }
+      end
+
+      @app.print_all.call.must_equal [:print_all]
+    end
+  end
+end

data/test/unit/package_processor_test.rb

@@ -0,0 +1,319 @@
+require_relative '../test_helper'
+require 'alki/package_processor'
+
+describe Alki::PackageProcessor do
+  def pkg(pkg,overrides ={})
+    {
+        type: :package,
+        children: pkg,
+        overrides: overrides
+    }
+  end
+  def group(children={})
+    {
+        type: :group,
+        children: children
+    }
+  end
+  def svc(sym)
+    {
+        type: :service,
+        block: -> { sym }
+    }
+  end
+  def factory(sym)
+    {
+        type: :factory,
+        block: -> { sym }
+    }
+  end
+  before do
+    @pe = Alki::PackageProcessor.new
+    @pkg1 = {
+        a: svc(:orig1_a),
+        b: svc(:orig1_b),
+        c: group
+    }
+    @desc = {
+        a: group(
+            test: svc(:a_test)
+        ),
+        b: svc(:b),
+        test: svc(:test),
+        pkg1: pkg(
+            @pkg1,
+            b: svc(:orig1_b_or)
+        )
+    }
+  end
+
+  describe :lookup do
+    it 'should identify services and return their block and a scope' do
+      pkg = {
+          a: svc(:a)
+      }
+      result = @pe.lookup(pkg,[:a])
+      result[:type].must_equal :service
+      result[:block].call.must_equal :a
+      result[:scope].must_be_instance_of Hash
+    end
+
+    it 'should identify factory and return their block and a scope' do
+      pkg = {
+          a: factory(:a)
+      }
+      result = @pe.lookup(pkg,[:a])
+      result[:type].must_equal :factory
+      result[:block].call.must_equal :a
+      result[:scope].must_be_instance_of Hash
+    end
+
+    it 'should identify groups and return their children' do
+      pkg2 = {
+          e: svc(:e)
+      }
+      pkg = {
+          a: svc(:a),
+          b: group(
+              c: svc(:c),
+              d: pkg(
+                  pkg2,
+                  f: svc(:f)
+              )
+          ),
+      }
+      @pe.lookup(pkg,[]).must_equal(
+          type: :group, children: {a: [:a], b: [:b]})
+      @pe.lookup(pkg,[:b]).must_equal(
+          type: :group, children: {c: [:b,:c],d: [:b,:d]})
+      @pe.lookup(pkg,[:b,:d]).must_equal(
+          type: :group, children: {e: [:b,:d,:e],f: [:b,:d,:f]})
+      @pe.lookup(pkg,[:b,:d,:orig]).must_equal(
+          type: :group, children: {e: [:b,:d,:orig,:e]})
+    end
+  end
+
+  describe :lookup_scope do
+    def scope(pkg,path)
+      @pe.lookup(pkg,path)[:scope]
+    end
+
+    it 'should contain a root item for the tree root' do
+      pkg = {
+          a: svc(:a)
+      }
+      scope(pkg,[:a]).must_equal(root: [],a: [:a])
+    end
+
+    it 'should return all visible items for the given context' do
+      pkg = {
+          a: svc(:a),
+          b: group(
+              c: svc(:c),
+              d: svc(:d),
+          )
+      }
+      scope(pkg,[:b,:c]).must_equal(root: [], a: [:a], b: [:b], c: [:b,:c], d: [:b,:d])
+    end
+
+    it 'should respect shadowing of symbols' do
+      pkg = {
+          a: svc(:a),
+          b: group(
+              a: svc(:a),
+              c: svc(:c),
+          )
+      }
+      scope(pkg,[:b,:c]).must_equal(root: [], a: [:b,:a], b: [:b], c: [:b,:c])
+    end
+
+    it 'should hide parent scope of context is in a package' do
+      pkg = {
+          a: svc(:a),
+          b: pkg(
+              c: svc(:c),
+              d: svc(:d),
+          )
+      }
+      scope(pkg,[:b,:c]).must_equal(root: [:b], c: [:b,:c], d: [:b,:d])
+    end
+
+    it 'should respect package overrides' do
+      pkg2 = {
+          c: svc(:c),
+      }
+      pkg = {
+          a: svc(:a),
+          b: pkg(
+              pkg2,
+              d: svc(:d),
+          )
+      }
+      scope(pkg,[:b,:c]).must_equal(root: [:b], c: [:b,:c], d: [:b,:d])
+    end
+
+    it 'should not change root and should add :orig symbol to override contexts' do
+      pkg2 = {
+          d: svc(:d),
+      }
+      pkg = {
+          a: svc(:a),
+          b: pkg(
+              pkg2,
+              c: svc(:c),
+          )
+      }
+      scope(pkg,[:b,:c]).must_equal(root: [],pkg: [:b,:orig], c: [:b,:c], a: [:a], b: [:b])
+    end
+
+    it 'should respect :orig symbol in path to access non-overriden services' do
+      pkg2 = {
+          c: svc(:c),
+          d: svc(:d),
+      }
+      pkg = {
+          a: svc(:a),
+          b: pkg(
+              pkg2,
+              c: svc(:c),
+          )
+      }
+      scope(pkg,[:b,:orig,:c]).must_equal(root: [:b], c: [:b,:c], d: [:b,:d])
+    end
+
+    it 'should handle nested packages' do
+      pkg2 = {
+          e: svc(:e),
+      }
+      pkg = {
+          a: svc(:a),
+          b: pkg(
+              c: svc(:c),
+              d: pkg(
+                  pkg2,
+                  f: svc(:f),
+              )
+          )
+      }
+      scope(pkg,[:b,:d,:e]).must_equal(root: [:b,:d], e: [:b,:d,:e], f: [:b,:d,:f])
+      scope(pkg,[:b,:d,:f]).must_equal(root: [:b], pkg: [:b,:d,:orig], d: [:b,:d], c: [:b,:c], f: [:b,:d,:f])
+    end
+
+    it 'should handle nested packages in overrides' do
+      pkg2 = {
+          c: svc(:c),
+      }
+      pkg3 = {
+          e: svc(:e),
+      }
+      pkg = {
+          a: svc(:a),
+          b: pkg(
+              pkg2,
+              d: pkg(
+                  pkg3,
+                  f: svc(:f)
+              )
+          )
+      }
+      scope(pkg,[:b,:d,:e]).must_equal(root: [:b,:d], e: [:b,:d,:e], f: [:b,:d,:f])
+    end
+  end
+
+  describe :lookup_overlays do
+    def overlays(pkg,path)
+      @pe.lookup(pkg,path)[:overlays].map{|o| o[:block]}
+    end
+
+    it 'should contain a root item for the tree root' do
+      pkg = {
+          a: svc(:a)
+      }
+      overlays(pkg,[:a]).must_equal([])
+    end
+
+    it 'should contain a root item for the tree root2' do
+      pkg = {
+          'overlays' => [:o1,:o2],
+          a: svc(:a)
+      }
+      overlays(pkg,[:a]).must_equal([:o1,:o2])
+    end
+
+    it 'should contain a root item for the tree root3' do
+      pkg = {
+          'overlays' => [:o1,:o2],
+          a: svc(:a),
+          b: group(
+              'overlays' => [:o3,:o4],
+              c: svc(:c)
+          )
+      }
+      overlays(pkg,[:b,:c]).must_equal([:o1,:o2,:o3,:o4])
+    end
+
+    it 'should contain a root item for the tree root4' do
+      pkg = {
+          'overlays' => [:o1],
+          a: svc(:a),
+          b: pkg(
+              'overlays' => [:o3,:o4],
+              c: svc(:c)
+          )
+      }
+      overlays(pkg,[:b,:c]).must_equal([:o1,:o3,:o4])
+    end
+
+    it 'should contain a root item for the tree root5' do
+      pkg2 = {
+          'overlays' => [:o3],
+          d: svc(:d),
+      }
+      pkg = {
+          'overlays' => [:o1],
+          a: svc(:a),
+          b: pkg(pkg2,
+              'overlays' => [:o2],
+              c: svc(:c)
+          )
+      }
+      overlays(pkg,[:b,:c]).must_equal([:o1,:o2,:o3])
+      overlays(pkg,[:b,:d]).must_equal([:o1,:o2,:o3])
+    end
+
+    it 'should contain a root item for the tree root6' do
+      pkg2 = {
+          'overlays' => [:o3],
+          d: svc(:d),
+      }
+      pkg = {
+          'overlays' => [:o1],
+          a: svc(:a),
+          b: pkg(pkg2,
+                 'overlays' => [:clear,:o2],
+                 c: svc(:c)
+          )
+      }
+      overlays(pkg,[:b,:c]).must_equal([:o2,:o3])
+      overlays(pkg,[:b,:d]).must_equal([:o2,:o3])
+    end
+
+    it 'should contain a root item for the tree root7' do
+      pkg2 = {
+          'overlays' => [:clear,:o3],
+          d: svc(:d),
+      }
+      pkg = {
+          'overlays' => [:o1],
+          a: svc(:a),
+          b: pkg(pkg2,
+                 'overlays' => [:o2],
+                 c: svc(:c)
+          )
+      }
+      overlays(pkg,[:b,:c]).must_equal([:o3])
+      overlays(pkg,[:b,:d]).must_equal([:o3])
+    end
+
+  end
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: alki
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Matt Edlefsen
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-10-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Base library for building applications. Provides tools for organizing
+  and connection application units.
+email:
+- matt@xforty.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- alki.gemspec
+- lib/alki.rb
+- lib/alki/class_builder.rb
+- lib/alki/dsl_builder.rb
+- lib/alki/group_builder.rb
+- lib/alki/group_dsl.rb
+- lib/alki/loader.rb
+- lib/alki/overlay_delegator.rb
+- lib/alki/package.rb
+- lib/alki/package_builder.rb
+- lib/alki/package_executor.rb
+- lib/alki/package_processor.rb
+- lib/alki/service_delegator.rb
+- lib/alki/standard_package.rb
+- lib/alki/test.rb
+- lib/alki/util.rb
+- lib/alki/version.rb
+- test/feature/create_package_test.rb
+- test/fixtures/config.rb
+- test/fixtures/example/config/handlers.rb
+- test/fixtures/example/config/package.rb
+- test/fixtures/example/config/settings.rb
+- test/fixtures/example/lib/array_output.rb
+- test/fixtures/example/lib/echo_handler.rb
+- test/fixtures/example/lib/example.rb
+- test/fixtures/example/lib/num_handler.rb
+- test/fixtures/example/lib/range_handler.rb
+- test/fixtures/example/lib/switch_handler.rb
+- test/integration/class_builder_test.rb
+- test/integration/loader_test.rb
+- test/test_helper.rb
+- test/unit/application_settings_test.rb
+- test/unit/application_test.rb
+- test/unit/package_processor_test.rb
+homepage: https://gitlab.xforty.com/matt/base-alki
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Base library for building applications.
+test_files:
+- test/feature/create_package_test.rb
+- test/fixtures/config.rb
+- test/fixtures/example/config/handlers.rb
+- test/fixtures/example/config/package.rb
+- test/fixtures/example/config/settings.rb
+- test/fixtures/example/lib/array_output.rb
+- test/fixtures/example/lib/echo_handler.rb
+- test/fixtures/example/lib/example.rb
+- test/fixtures/example/lib/num_handler.rb
+- test/fixtures/example/lib/range_handler.rb
+- test/fixtures/example/lib/switch_handler.rb
+- test/integration/class_builder_test.rb
+- test/integration/loader_test.rb
+- test/test_helper.rb
+- test/unit/application_settings_test.rb
+- test/unit/application_test.rb
+- test/unit/package_processor_test.rb