alki 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e86bb1b3528f9cb309acbc92afc214435f8a2277
-  data.tar.gz: a58361e3a16adfdeabfe85f340baef09559250c2
+  metadata.gz: af6d088cbc8aa150a26faf3bac734b926bc8904e
+  data.tar.gz: faee9dfca16adb81a2d0e4581651ebb7143262eb
 SHA512:
-  metadata.gz: de5bc37efcdadd68024bad12dcc29219484888ed31c2d0b09cd634d877ac097696335ff5ac38fbb6fd917ca3b0b35458c4fd18a549e10b967801aa50dfb48989
-  data.tar.gz: 2e129fbb5b609d32be08ace86498a77183a59ceccf2b60330cf09f77986408484e503f021ce61d5f430ac2f882a2a2c90fb9757bd622b8975cfd5d305cd45dbb
+  metadata.gz: f2a8859220bc71ade390e9b66e2c5ea5ae0960763f1aa2c760fff15cb47af76abaa8457a289e70f684f735ba9cab01b0dbdbe64aec5070ab5d62b426b9d4d845
+  data.tar.gz: 4f3cfe787245cd977233e33fa3fe01f8555940701e92cb38a732839b0f0006ed5ae314af238aa8bb272c0438193a426539503b322c5b8e05ea2fe454f86cd4eb

data/Gemfile

@@ -2,6 +2,8 @@ source 'https://rubygems.org'
 
 gemspec
 
+gem 'pry'
+
 group :test do
   gem 'minitest', '~> 5.4.2'
 end

data/README.md

@@ -1,4 +1,4 @@
-# base.alki
+# Alki
 
 Basic library for creating applications.
 

data/alki.gemspec

@@ -21,4 +21,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake", '~> 10.0'
+  spec.add_development_dependency "minitest", "~> 5.9"
+  spec.add_dependency "alki-dsl", "~> 0.2"
+  spec.add_dependency "alki-support", "~> 0.4"
 end

data/config/dsls.rb

@@ -0,0 +1,4 @@
+Alki do
+  register_lib_dir 'alki/dsls/assembly_types', 'alki/dsls/assembly_type_dsl'
+  register_lib_dir 'alki/dsls', 'alki/dsls/dsl'
+end

data/lib/alki/assembly.rb

@@ -0,0 +1,43 @@
+require 'alki/assembly_executor'
+
+module Alki
+  module Assembly
+    def new
+      Alki::Assembly::Instance.new assembly, load_path: config_root
+    end
+
+    def assembly
+      self.assembly_class.assembly
+    end
+
+    def root
+      self.assembly_class.root
+    end
+
+    class Instance
+      def initialize(assembly,opts={})
+        @assembly = assembly
+        @cache = {}
+        @opts = opts
+      end
+
+      def root
+        @root ||= __executor__.call @assembly, @cache, []
+      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::AssemblyExecutor.new @opts
+      end
+    end
+  end
+end

data/lib/alki/assembly_executor.rb

@@ -0,0 +1,137 @@
+require 'alki/service_delegator'
+require 'alki/overlay_delegator'
+
+module Alki
+  class AssemblyExecutor
+    class Resource
+      attr_reader :pkg, :cache, :elem
+      def initialize(pkg,cache,elem)
+        @pkg = pkg
+        @cache = cache
+        @elem = elem
+      end
+
+      def with_elem(elem)
+        Resource.new @pkg, @cache, elem
+      end
+    end
+
+    def initialize(data={})
+      @data = data
+    end
+
+    def call(assembly,cache,path,*args,&blk)
+      unless cache[path]
+        elem = assembly.lookup path, @data
+        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 :group
+            group res
+        end
+      end
+      cache[path].call *args, &blk
+    end
+
+    def service(res,path)
+      with_scope_context(res) do |ctx,blk|
+        svc = apply_overlays res, path, ctx.instance_exec(&blk)
+        -> { svc }
+      end
+    end
+
+    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)
+          end
+        end
+        local_path = path[overlay_elem[:scope][:root].size..-1].join('.')
+        Alki::OverlayDelegator.new local_path,obj, res.cache[overlay_elem[:block]]
+      end
+    end
+
+    def factory(res)
+      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
+        }
+      end
+    end
+
+    def group(res)
+      proc = -> (name,*args,&blk) {
+        call res.pkg, res.cache, res.elem[:scope][name], *args, &blk
+      }
+      group = GroupContext.new(proc,res.elem[:scope].keys)
+      -> { group }
+    end
+
+    def with_scope_context(res)
+      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]
+    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 pkg, 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/assembly_handler_base.rb

@@ -0,0 +1,19 @@
+module Alki
+  class AssemblyHandlerBase
+    def initialize(elem,data,key=nil)
+      @elem = elem
+      @data = data
+      @key = key
+    end
+
+    attr_reader :elem, :data, :key
+
+    def index
+      raise NotImplementedError.new("Can't index into this element")
+    end
+
+    def output
+      raise NotImplementedError.new("Can't output this element")
+    end
+  end
+end

data/lib/alki/dsls/assembly.rb

@@ -0,0 +1,24 @@
+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/assembly'
+  require_dsl 'alki/dsls/assembly_types/overlay'
+
+  init do
+    ctx[:elems] = {}
+    ctx[:overlays] = []
+  end
+
+  finish do
+    root = build_group(ctx[:elems], ctx[:overlays])
+    assembly = build_assembly root, nil
+    add_class_method :root do
+      root
+    end
+    add_class_method :assembly do
+      assembly
+    end
+  end
+end

data/lib/alki/dsls/assembly_type.rb

@@ -0,0 +1,48 @@
+require 'alki/assembly_handler_base'
+
+Alki do
+  require_dsl 'alki/dsls/class'
+
+  init do
+    set_super_class Alki::AssemblyHandlerBase, subclass: 'Handler'
+
+    add_method :handler, private: true do |*args|
+      self.class::Handler.new(self,*args)
+    end
+
+    add_method :index do |*args|
+      handler(*args).index
+    end
+
+    add_method :output do |*args|
+      handler(*args).output
+    end
+
+    add_method :lookup do |path,data={}|
+      data = data.dup
+      elem = self
+      path.each do |key|
+        elem = elem.index data, key
+        return nil unless elem
+      end
+      elem.output data
+    end
+
+    # Add defined methods to handler class
+    class_builder('Handler')[:module] = class_builder[:module]
+  end
+
+  dsl_method :attr do |name,default=nil|
+    add_delegator name, :@elem, subclass: 'Handler'
+    add_initialize_param name, default
+    add_accessor name
+  end
+
+  dsl_method :index do |&blk|
+    add_method :index, subclass: 'Handler', &blk
+  end
+
+  dsl_method :output do |&blk|
+    add_method :output, subclass: 'Handler', &blk
+  end
+end

data/lib/alki/dsls/assembly_type_dsl.rb

@@ -0,0 +1,21 @@
+require 'alki/dsls/assembly_type'
+
+Alki do
+  require_dsl 'alki/dsls/dsl'
+
+  dsl_method :element_type do |name,&blk|
+    data = Alki::Dsls::AssemblyType.build(prefix: 'alki/assembly_types', name: name,&blk)
+    klass = data[:class]
+    add_helper "build_#{name}".to_sym, &klass.method(:new)
+    add_helper "add_#{name}".to_sym do |name,*args|
+      add name, klass.new(*args)
+    end
+  end
+
+  finish do
+    add_method :add do |name,elem|
+      (ctx[:elems]||={})[name.to_sym] = elem
+      nil
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+require 'alki/support'
+
+Alki do
+  require_dsl 'alki/dsls/assembly_types/group'
+
+  dsl_method :assembly do |name,pkg=name.to_s,&blk|
+    klass = Alki::Support.load_class pkg
+
+    elem = if blk
+      build_assembly klass.root, build_group_dsl(blk)
+    else
+      klass.root
+    end
+    add name, elem
+  end
+
+  element_type :assembly do
+    attr :root
+    attr :overrides, nil
+
+    index do
+      if overrides
+        data.replace(
+          main: data.merge(main_data),
+          override: data.dup,
+        )
+        override.index data, key
+      else
+        root.index data.merge!(main_data), key
+      end
+    end
+
+    output do
+      scope = root.output(data)[:scope]
+      scope.merge! overrides.output(data)[:scope] if overrides
+      {
+        type: :group,
+        scope: scope,
+      }
+    end
+
+    def main_data
+      pkg = data[:prefix] ? data[:prefix].dup : []
+      {scope: {pkg: pkg, root: []}, overlays: []}
+    end
+
+    def override
+      Alki::AssemblyTypes::Override.new root, overrides
+    end
+  end
+
+  element_type :override do
+    attr :main
+    attr :override
+
+    index do
+      main_child = main.index data[:main], key
+      override_child = override.index data[:override], key
+
+      if main_child && override_child
+        (data[:main][:scope]||={}).merge! (data[:override][:scope]||{})
+        (data[:main][:overlays]||=[]).push *(data[:override][:overlays]||[])
+        Alki::AssemblyTypes::Override.new main_child, override_child
+      elsif main_child
+        data.replace data[:main]
+        main_child
+      elsif override_child
+        data.replace data[:override]
+        override_child
+      end
+    end
+
+    output do
+      result = override.output(data[:override])
+      if result[:type] == :group
+        main_result = main.output(data[:main])
+        if main_result[:type] == :group
+          result[:scope] = main_result[:scope].merge result[:scope]
+        end
+      end
+      result
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require 'alki/dsls/assembly'
+
+Alki do
+  dsl_method :group do |name,&blk|
+    add name, build_group_dsl(blk)
+  end
+
+  helper :build_group_dsl do |blk|
+    data = Alki::Dsls::Assembly.build &blk
+    build_group data[:elems], data[:overlays]
+  end
+
+  element_type :group do
+    attr :children, {}
+    attr :overlays
+
+    index do
+      data[:scope] ||= {}
+      data[:prefix] ||= []
+      update_scope children, data[:prefix], data[:scope]
+      data[:prefix] << key
+
+      if overlays
+        data[:overlays] = overlays.map do |o|
+          o == :clear ? o : {block: o, scope: data[:scope].merge(root: [])}
+        end
+      end
+
+      children[key]
+    end
+
+    output do
+      {
+        type: :group,
+        scope: update_scope(children,data[:prefix]||[],{})
+      }
+    end
+
+    def update_scope(children, prefix, scope)
+      children.keys.inject(scope) do |h,k|
+        h.merge! k => (prefix+[k])
+      end
+      scope
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'alki/support'
+
+Alki do
+  dsl_method :load do |group_name,name=group_name.to_s|
+    add_load group_name, ctx[:prefix], name
+  end
+
+  element_type :load do
+    attr :prefix
+    attr :name
+
+    index do
+      group.index data, key
+    end
+
+    output do
+      group.output data
+    end
+
+    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)
+        else
+          name
+        end
+        data[:loaded][name] = Alki::Support.load_class(prefixed_name).root
+      end
+      data[:loaded][name]
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+Alki do
+  dsl_method :overlay do |&blk|
+    (ctx[:overlays]||=[]) << blk
+  end
+
+  dsl_method :clear_overlays do
+    (ctx[:overlays]||=[]) << :clear
+  end
+end

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

@@ -0,0 +1,25 @@
+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/lib/alki/dsls/service.rb

@@ -0,0 +1,22 @@
+Alki do
+  require_dsl 'alki/dsls/class'
+
+  init do
+    @uses = []
+  end
+
+  dsl_method :use do |name,service_path = name|
+    if name.is_a?(Hash) && name.size == 1
+      name, service_path = name.to_a.first
+    end
+    add_initialize_param name
+    @uses << service_path.to_s
+  end
+
+  finish do
+    uses = @uses
+    add_class_method :uses do
+      uses
+    end
+  end
+end

data/lib/alki/test.rb

@@ -1,29 +1,49 @@
 require 'bundler'
 Bundler.setup(:default,:test)
 require 'minitest/autorun'
+require 'alki/dsl'
 
-class Minitest::Spec
-  def app_root
-    Bundler.root
-  end
+module Alki
+  module Test
+    def app_root
+      Bundler.root
+    end
 
-  def lib_dir
-    File.join app_root, 'lib'
-  end
+    def lib_dir
+      File.join app_root, 'lib'
+    end
 
-  def tests_root
-    File.join app_root, 'test'
-  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 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
 
-  def load_fixture(fixture)
-    require fixture_path(fixture)
+    extend self
   end
 end
+
+class Minitest::Spec
+  include Alki::Test
+end
+
+unless $LOAD_PATH.include? Alki::Test.lib_dir
+  $LOAD_PATH.unshift Alki::Test.lib_dir
+end
+
+test_helper_dir = File.join(Alki::Test.tests_root,'test_helper.rb')
+
+if File.exists? test_helper_dir
+  require test_helper_dir
+end

data/lib/alki/version.rb

@@ -1,3 +1,3 @@
 module Alki
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end