alki 0.3.0 → 0.4.0

data/lib/alki/package.rb

@@ -1,33 +0,0 @@
-require 'alki/package_executor'
-require 'alki/package_processor'
-
-module Alki
-  class Package
-    def initialize(package_definition)
-      @def = package_definition
-      @cache = {}
-    end
-
-    def root
-      @root ||= __executor__.call @def, @cache, []
-    end
-
-    def package_definition
-      @def
-    end
-
-    def respond_to_missing?(name,include_all)
-      root.respond_to? name
-    end
-
-    def method_missing(name,*args,&blk)
-      root.send name, *args, &blk
-    end
-
-    private
-
-    def __executor__
-      @executor ||= Alki::PackageExecutor.new Alki::PackageProcessor.new
-    end
-  end
-end

data/lib/alki/package_builder.rb

@@ -1,2 +0,0 @@
-module Alki
-end

data/lib/alki/package_executor.rb

@@ -1,120 +0,0 @@
-require 'alki/service_delegator'
-require 'alki/overlay_delegator'
-
-module Alki
-  class PackageExecutor
-    def initialize(processor)
-      @processor = processor
-    end
-
-    def call(pkg,cache,path,*args,&blk)
-      elem = @processor.lookup(pkg,path)
-      triple = [pkg,cache,elem]
-      case elem[:type]
-        when :service
-          service triple, path, *args
-        when :factory
-          factory triple, path, *args, &blk
-        when :group
-          group triple, *args
-      end
-    end
-
-    def service(triple,path)
-      pkg,cache,elem = triple
-      unless cache[path]
-        with_scope_context(triple) do |ctx,blk|
-          cache[path] = apply_overlays triple,path, ctx.instance_exec(&blk)
-        end
-      end
-      cache[path]
-    end
-
-    def apply_overlays((pkg,cache,elem),path,obj)
-      elem[:overlays].inject(obj) do |obj,overlay_elem|
-        unless cache[overlay_elem[:block]]
-          with_scope_context([pkg,cache,overlay_elem]) do |ctx,blk|
-            cache[overlay_elem[:block]] = ctx.instance_exec(&blk)
-          end
-        end
-        local_path = path[overlay_elem[:scope][:root].size..-1].join('.')
-        Alki::OverlayDelegator.new local_path,obj, cache[overlay_elem[:block]]
-      end
-    end
-
-    def factory(triple,path,*args,&blk)
-      pkg,cache,elem = triple
-      unless cache[path]
-        with_scope_context(triple) do |ctx,blk|
-          cache[path] = ctx.instance_exec(&blk)
-        end
-      end
-      cache[path].call *args, &blk
-    end
-
-    def group((pkg,cache,elem))
-      proc = -> (name,*args,&blk) {
-        call pkg, cache, elem[:children][name], *args, &blk
-      }
-
-      GroupContext.new(proc,elem[:children].keys)
-    end
-
-    def with_scope_context((pkg,cache,elem))
-      proc = -> (name,*args,&blk) {
-        call pkg, cache, elem[:scope][name], *args, &blk
-      }
-
-      yield ServiceContext.new(proc,elem[:scope].keys), elem[:block]
-    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 ServiceContext < Context
-      def lookup(path)
-        unless path.is_a?(String) or path.is_a?(Symbol)
-          raise ArgumentError.new("lookup can only take Strings or Symbols")
-        end
-        path.to_s.split('.').inject(self) do |group,name|
-          raise "Invalid lookup path" unless group.is_a? Context
-          group.send name.to_sym
-        end
-      end
-
-      def lazy(path)
-        unless path.is_a?(String) or path.is_a?(Symbol)
-          raise ArgumentError.new("lazy can only take Strings or Symbols")
-        end
-        Alki::ServiceDelegator.new root, path
-      end
-    end
-
-    class GroupContext < Context
-      def lookup(path)
-        unless path.is_a?(String) or path.is_a?(Symbol)
-          raise ArgumentError.new("lookup can only take Strings or Symbols")
-        end
-        path.to_s.split('.').inject(self) do |group,name|
-          group.send name.to_sym
-        end
-      end
-    end
-  end
-end

data/lib/alki/package_processor.rb

@@ -1,167 +0,0 @@
-module Alki
-  class PackageProcessor
-    def lookup(package,path)
-      lookup_path(package,path)
-    end
-
-    private
-
-    def lookup_path(desc, path, data = {})
-      data_defaults data
-      path = path.dup
-      update_data data, desc
-      until path.empty?
-        key = path.shift
-        data[:prefix] += [key]
-        elem = desc[key]
-        if !elem
-          return nil
-        else
-          unless path.empty?
-            if elem[:type] == :group
-              desc = elem[:children]
-              update_data data, desc
-            elsif elem[:type] == :package
-              return package_lookup_path elem, path, data
-            else
-              raise "Invalid path"
-            end
-          end
-        end
-      end
-      if elem
-        case elem[:type]
-          when :group
-            {type: :group, children: prefix_keys(elem[:children], data[:prefix])}
-          when :package
-            children = prefix_keys([elem[:children],elem[:overrides]], data[:prefix])
-            {type: :group, children: children}
-          when :service, :factory
-            last_clear = data[:overlays].rindex(:clear)
-            overlays = last_clear ? data[:overlays][(last_clear + 1)..-1] : data[:overlays]
-            {type: elem[:type], block: elem[:block], overlays: overlays, scope: data[:scope]}
-          else
-            raise "Invalid elem type: #{elem[:type]}"
-        end
-      else
-        {type: :group, children: prefix_keys(desc,data[:prefix])}
-      end
-    end
-
-    def package_lookup_path(elem,path,data)
-      if path[0] == :orig
-        if path.size == 1
-          {type: :group, children: prefix_keys(elem[:children],data[:prefix]+[:orig])}
-        else
-          lookup_path(elem[:children],path[1..-1],data.merge(scope:nil))
-        end
-      else
-        override_scope = data[:scope].merge(pkg: data[:prefix]+[:orig])
-        override_data = data.merge(overlays: data[:overlays].dup, scope: override_scope)
-        lookup_path(merge_overlays(elem[:overrides],elem[:children]), path, override_data) or
-            lookup_path(
-                merge_overrides(elem[:children], elem[:overrides]),
-                path, data.merge(scope: nil)
-            )
-      end
-    end
-
-    def data_defaults(data)
-      data[:overlays] ||= []
-      data[:prefix] ||= []
-      data[:scope] ||= {root: data[:prefix]}
-    end
-
-    def prefix_keys(source, prefix, result={})
-      source = [source] unless source.is_a? Array
-      source.inject([]){|a,h| a|=h.keys}.inject(result) do |h,k|
-        h.merge! k => (prefix+[k])
-      end
-      result
-    end
-
-    def update_data(data,desc)
-      prefix_keys desc, data[:prefix], data[:scope]
-      if desc['overlays']
-        data[:overlays].push *desc['overlays'].map { |o|
-          o == :clear ? o : {block: o, scope: data[:scope]}
-        }
-      end
-    end
-
-    def merge_overlays(a,b)
-      updates = {}
-      b.keys.each do |k|
-        if k == 'overlays'
-          updates[k] = (a[k] || []) + b[k]
-        elsif a.key? k
-          val = merge_item_overlays(a[k],b[k])
-          updates[k] = val unless a[k].equal? val
-        end
-      end
-      if updates.empty?
-        a
-      else
-        a.merge updates
-      end
-    end
-
-    def merge_item_overlays(a,b)
-      if a[:children] && b[:children]
-        if b[:type] == :package
-          b_children = merge_overlays(b[:children],b[:overrides])
-        elsif b[:type] == :group
-          b_children = b[:children]
-        end
-        if a[:type] == :package
-          a.merge(overrides: merge_overlays(a[:overrides],b_children))
-        elsif b[:type] == :group
-          a.merge(children: merge_overlays(a[:children],b_children))
-        end
-      else
-        a
-      end
-    end
-
-    def merge_overrides(a,b)
-      updates = {}
-      b.keys.each do |k|
-        if a.key? k
-          if k == 'overlays'
-            updates[k] = b[k] + a[k]
-          else
-            val = merge_item(a[k],b[k])
-            updates[k] = val unless a[k].equal? val
-          end
-        else
-          updates[k] = b[k]
-        end
-      end
-      if updates.empty?
-        a
-      else
-        a.merge updates
-      end
-
-    end
-
-    def merge_item(a,b)
-      if a[:children] && b[:children]
-        if b[:type] == :package
-          b_children = merge_overrides(b[:children],b[:overrides])
-        elsif b[:type] == :group
-          b_children = b[:children]
-        end
-        if a[:type] == :package
-          a.merge(overrides: merge_overrides(a[:overrides],b_children))
-        elsif b[:type] == :group
-          a.merge(children: merge_overrides(a[:children],b_children))
-        end
-      elsif a != b
-        b
-      else
-        a
-      end
-    end
-  end
-end

data/lib/alki/standard_package.rb

@@ -1,19 +0,0 @@
-require 'alki/package'
-require 'alki/loader'
-require 'alki/group_builder'
-
-module Alki
-  class StandardPackage < Package
-    def initialize(root_dir)
-      @root_dir = root_dir
-      loader = Alki::Loader.new(File.join(root_dir,'config'))
-      builder = Alki::GroupBuilder.new loader
-      pkg = builder.build &loader.load('package')
-      loader_proc = ->() { loader }
-      builder.build pkg do
-        service :loader, &loader_proc
-      end
-      super pkg
-    end
-  end
-end

data/lib/alki/util.rb

@@ -1,35 +0,0 @@
-module Alki
-  module Util
-    def self.classify(str)
-      str.split('/').map do |c|
-        c.split('_').map{|n| n.capitalize }.join('')
-      end.join('::')
-    end
-
-    def self.create_class(name,klass = Class.new)
-      *ans, ln = name.to_s.split(/::/)
-      parent = Object
-      ans.each do |a|
-        unless parent.const_defined? a
-          parent.const_set a, Module.new
-        end
-        parent = parent.const_get a
-      end
-
-      parent.const_set ln, klass
-    end
-
-    def self.find_pkg_root(path)
-      old_dir = File.absolute_path(path)
-      dir = File.dirname(old_dir)
-      until dir == old_dir || File.exists?(File.join(dir,'config','package.rb'))
-        old_dir = dir
-        dir = File.dirname(old_dir)
-      end
-      if dir == old_dir
-        raise "Couldn't find app root"
-      end
-      dir
-    end
-  end
-end

data/test/integration/class_builder_test.rb

@@ -1,130 +0,0 @@
-require 'alki/test'
-require 'alki/class_builder'
-
-describe Alki::ClassBuilder do
-  class DoitBuilder
-    def initialize(c)
-      @c = c
-      @num = 0
-    end
-
-    def dsl_methods
-      [:doit]
-    end
-
-    def doit(&blk)
-      @c.send(:define_method,"doit#{@num}",&blk)
-      @num += 1
-    end
-
-    def finalize
-      num = @num
-      @c.define_singleton_method :doits do
-        num
-      end
-
-      @c.send(:define_method,:doit_all) do
-        num.times.map {|i| send "doit#{i}"}
-      end
-    end
-  end
-
-  class JobTypeBuilder
-    def initialize(c)
-      @c = c
-    end
-
-    def dsl_methods
-      [:job]
-    end
-
-    def job(job)
-      @job = job
-    end
-
-    def finalize
-      job = @job
-      @c.send :define_method, :job do
-        job
-      end
-    end
-  end
-
-  describe :build do
-    it 'should allow calling methods in dsl' do
-      c = Alki::ClassBuilder.build(DoitBuilder) do
-        doit { "hello" }
-        doit { "world" }
-      end
-      c.new.doit_all.must_equal ["hello","world"]
-    end
-
-    it 'should allow defining normal methods' do
-      c = Alki::ClassBuilder.build(DoitBuilder) do
-        def initialize(msg)
-          @msg = msg
-        end
-        def msg
-          @msg
-        end
-        doit { msg }
-        doit { "world" }
-      end
-      obj = c.new "hello"
-      obj.msg.must_equal "hello"
-      obj.doit_all.must_equal ["hello","world"]
-    end
-
-    it 'should allow setting class methods' do
-      c = Alki::ClassBuilder.build(DoitBuilder) do
-        def klass.doit_count
-          doits
-        end
-      end
-      c.doit_count.must_equal 0
-    end
-
-    it 'should not make dsl methods available on class' do
-      c = Alki::ClassBuilder.build(DoitBuilder) do
-      end
-      c.methods.wont_include :doit
-      assert_raises NoMethodError do
-        c.doit { puts "test" }
-      end
-      assert_raises NoMethodError do
-        c.send(:doit) { puts "test" }
-      end
-    end
-
-    it 'should only allow calling dsl methods returned from #dsl_methods' do
-      assert_raises NoMethodError do
-        Alki::ClassBuilder.build(DoitBuilder) do
-          finalize()
-        end
-      end
-    end
-
-    it 'should allow creating classes with names' do
-      Alki::ClassBuilder.build(:TestClass,DoitBuilder) do
-      end
-      TestClass.new.doit_all.must_equal []
-    end
-
-    it 'should allow creating classes in modules' do
-      module TestModule; end
-      Alki::ClassBuilder.build('TestModule::TestClass',DoitBuilder) do
-      end
-      TestModule::TestClass.new.doit_all.must_equal []
-    end
-
-    it 'should allow passing in multiple dsl builders' do
-      c = Alki::ClassBuilder.build([DoitBuilder,JobTypeBuilder]) do
-        job "greeter"
-        doit { "Welcome!" }
-      end
-      obj = c.new
-      obj.doit_all.must_equal ["Welcome!"]
-      obj.job.must_equal "greeter"
-    end
-  end
-end

data/test/integration/loader_test.rb

@@ -1,36 +0,0 @@
-require_relative '../test_helper'
-
-require 'alki/loader'
-
-describe Alki::Loader do
-  describe 'load' do
-    before do
-      @loader = Alki::Loader.new fixtures_path
-    end
-
-    it 'should load config file from root directory' do
-      @loader.load(:config).call.must_equal 0
-    end
-  end
-
-  describe 'self.load' do
-    before do
-      @config_path = fixture_path('config.rb')
-    end
-
-    it 'should load a config file and call block with proc' do
-      Alki::Loader::load(@config_path).call.must_equal 0
-    end
-
-    it 'should be threadsafe' do
-      t1 = Thread.new do
-        $wait = 1
-        Alki::Loader::load(@config_path).call
-      end
-      sleep 0.1
-      $wait = 0
-      Alki::Loader::load(@config_path).call.must_equal 0
-      t1.value.must_equal 1
-    end
-  end
-end