alki 0.1.0

data/lib/alki/package_processor.rb

@@ -0,0 +1,167 @@
+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/service_delegator.rb

@@ -0,0 +1,14 @@
+require 'delegate'
+
+module Alki
+  class ServiceDelegator < Delegator
+    def initialize(app,path)
+      @app = app
+      @path = path
+    end
+
+    def __getobj__
+      @obj ||= @app.lookup(@path)
+    end
+  end
+end

data/lib/alki/standard_package.rb

@@ -0,0 +1,19 @@
+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/test.rb

@@ -0,0 +1,28 @@
+require 'minitest/autorun'
+Bundler.setup(:default,:test)
+
+class Minitest::Spec
+  def app_root
+    Bundler.root
+  end
+
+  def lib_dir
+    File.join app_root, 'lib'
+  end
+
+  def tests_root
+    File.join app_root, 'test'
+  end
+
+  def fixtures_path
+    File.join(tests_root, 'fixtures')
+  end
+
+  def fixture_path(fixture)
+    File.join(fixtures_path, fixture)
+  end
+
+  def load_fixture(fixture)
+    require fixture_path(fixture)
+  end
+end

data/lib/alki/util.rb

@@ -0,0 +1,35 @@
+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/lib/alki/version.rb

@@ -0,0 +1,3 @@
+module Alki
+  VERSION = "0.1.0"
+end

data/lib/alki.rb

@@ -0,0 +1,27 @@
+module Alki
+  def self.create_package!(name=nil,root=nil)
+    require 'alki/util'
+    require 'alki/standard_package'
+
+    if !root
+      root = Alki::Util.find_pkg_root(caller_locations(1, 1)[0].absolute_path)
+    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 package"
+      end
+      name = path[lib_dir.size..-4]
+    end
+    unless name =~ /[A-Z]/
+      name = Alki::Util.classify(name)
+    end
+    klass = Class.new(Alki::StandardPackage)
+    klass.send :define_method, :initialize do
+      super root
+    end
+
+    Alki::Util.create_class(name,klass)
+  end
+end

data/test/feature/create_package_test.rb

@@ -0,0 +1,17 @@
+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')
+      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

data/test/fixtures/config.rb

@@ -0,0 +1,6 @@
+wait = $wait || 0
+$wait =nil
+Alki do
+  wait
+end
+sleep wait if wait > 0

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

@@ -0,0 +1,29 @@
+Alki do
+  factory :num_handler do
+    require 'num_handler'
+    -> (num,str) {
+      NumHandler.new num, str, output
+    }
+  end
+  service :fizz do
+    num_handler 3, settings.fizz
+  end
+  service :buzz do
+    num_handler 5, settings.buzz
+  end
+  service :fizzbuzz do
+    num_handler 15, settings.fizzbuzz
+  end
+  service :echo do
+    require 'echo_handler'
+    EchoHandler.new output
+  end
+
+  overlay do
+    log_obj = log
+    -> (name,obj,method,*args,&blk) {
+      log_obj << "Calling #{name}##{method} #{args.join(", ")}\n"
+      obj.public_send method, *args, &blk
+    }
+  end
+end

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

@@ -0,0 +1,35 @@
+Alki do
+  load :settings
+  load :handlers
+
+  service :handler do
+    require 'switch_handler'
+    SwitchHandler.new [
+                        handlers.fizzbuzz,
+                        handlers.fizz,
+                        handlers.buzz,
+                        handlers.echo
+                      ]
+  end
+
+  service :range_handler do
+    require 'range_handler'
+    RangeHandler.new lazy('handler')
+  end
+
+  service :output do
+    require 'array_output'
+    ArrayOutput.new
+  end
+
+  service :log do
+    require 'logger'
+    Logger.new STDERR
+  end
+
+  service :message_proc do
+    -> (msg) {
+      msg[0].upcase+msg[1..-1].downcase+"!"
+    }
+  end
+end

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

@@ -0,0 +1,11 @@
+Alki do
+  set :fizz do
+    message_proc.call("fizz")
+  end
+  set :buzz do
+    message_proc.call("buzz")
+  end
+  set :fizzbuzz do
+    message_proc.call("fizzbuzz")
+  end
+end

data/test/fixtures/example/lib/array_output.rb

@@ -0,0 +1,11 @@
+class ArrayOutput
+  def initialize
+    @output = []
+  end
+  def <<(val)
+    @output << val
+  end
+  def to_a
+    @output.dup
+  end
+end

data/test/fixtures/example/lib/echo_handler.rb

@@ -0,0 +1,9 @@
+class EchoHandler
+  def initialize(output)
+    @output = output
+  end
+
+  def handle(val)
+    @output << val.to_s
+  end
+end

data/test/fixtures/example/lib/example.rb

@@ -0,0 +1,3 @@
+require 'alki'
+
+Alki.create_package!

data/test/fixtures/example/lib/num_handler.rb

@@ -0,0 +1,11 @@
+class NumHandler
+  def initialize(num,message,output)
+    @num = num
+    @msg = message
+    @output = output
+  end
+
+  def handle(val)
+    @output << @msg if val % @num == 0
+  end
+end

data/test/fixtures/example/lib/range_handler.rb

@@ -0,0 +1,11 @@
+class RangeHandler
+  def initialize(subhandler)
+    @subhandler = subhandler
+  end
+
+  def handle(range)
+    range.each do |i|
+      @subhandler.handle i
+    end
+  end
+end

data/test/fixtures/example/lib/switch_handler.rb

@@ -0,0 +1,9 @@
+class SwitchHandler
+  def initialize(handlers)
+    @handlers = handlers
+  end
+
+  def handle(val)
+    @handlers.find {|h| h.handle val }
+  end
+end

data/test/integration/class_builder_test.rb

@@ -0,0 +1,130 @@
+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

@@ -0,0 +1,36 @@
+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

data/test/test_helper.rb

@@ -0,0 +1 @@
+require_relative('../lib/alki/test')

data/test/unit/application_settings_test.rb

@@ -0,0 +1,56 @@
+require_relative '../test_helper'
+
+require 'alki/application_settings'
+
+describe Alki::ApplicationSettings do
+  before do
+    @settings = Alki::ApplicationSettings.new
+  end
+
+  describe :initialize do
+    it 'should set environment to development by default' do
+      @settings.environment.must_equal :development
+    end
+  end
+
+  describe :set do
+    it 'should add setting as method and make it available as an index' do
+      @settings.respond_to?(:test).must_equal false
+      @settings.set :test, :test_value
+      @settings.test.must_equal :test_value
+    end
+
+    it 'should make setting available as an index' do
+      @settings[:test].must_equal nil
+      @settings.set :test, :test_value
+      @settings[:test].must_equal :test_value
+    end
+  end
+
+  describe :environment? do
+    it 'should return whether environment is one of the arguments' do
+      @settings.environment?(:development).must_equal true
+      @settings.environment?(:production,:development).must_equal true
+      @settings.environment?(:production,:test).must_equal false
+    end
+
+    it 'should run provided block if true' do
+      test = false
+      @settings.environment?(:test) { test = true }
+      test.must_equal false
+      @settings.environment?(:development) { test = true }
+      test.must_equal true
+    end
+  end
+
+  describe :configure do
+    it 'should run provided block in object context' do
+      @settings.respond_to?(:test).must_equal false
+      @settings.configure do
+        set :test, :test_value
+        test.must_equal :test_value
+      end
+      @settings.test.must_equal :test_value
+    end
+  end
+end