alki 0.8.0 → 0.9.0

data/lib/alki/assembly/executor.rb

@@ -0,0 +1,127 @@
+require 'alki/execution/context_class_builder'
+require 'alki/execution/cache_entry'
+require 'thread'
+
+module Alki
+  InvalidPathError = Class.new(StandardError)
+  module Assembly
+    class Executor
+      def initialize(assembly,overlays)
+        @assembly = assembly
+        @overlays = overlays
+        @data = {}
+        @semaphore = Monitor.new
+        clear
+      end
+
+      def clear
+        @lookup_cache = {}
+        @call_cache = {}
+        @context_cache = {}
+        @processed_overlays = false
+      end
+
+      def call(path,*args,&blk)
+        execute({},path,args,blk)
+      end
+
+      def execute(meta,path,args,blk)
+          cache_entry = @call_cache[path]
+          if cache_entry
+            if cache_entry.status == :building
+              raise "Circular element reference found"
+            end
+          else
+            @semaphore.synchronize do
+              cache_entry = @call_cache[path]
+              unless cache_entry
+                cache_entry = @call_cache[path] = Alki::Execution::CacheEntry.new
+                action = lookup(path)
+                if action[:build]
+                  build_meta = meta.merge(building: path.join('.'))
+                  build_action = action[:build].merge(scope: action[:scope],modules: action[:modules])
+                  call_value(*process_action(build_action),build_meta,[action])
+                end
+                cache_entry.finish *process_action(action)
+              end
+            end
+          end
+        call_value(cache_entry.type,cache_entry.value,meta,args,blk)
+      end
+
+      private
+
+      def process_overlays
+        unless @processed_overlays
+          @processed_overlays = true
+          @data[:overlays] = {}
+          @overlays.each do |(from,info)|
+            target = canonical_path(from,info.target) or
+              raise InvalidPathError.new("Invalid overlay target #{info.target.join('.')}")
+            overlay = canonical_path(from,info.overlay) or
+              raise InvalidPathError.new("Invalid overlay path #{info.overlay.join('.')}")
+            (@data[:overlays][target]||=[]) << [overlay,info.args]
+          end
+        end
+      end
+
+      def lookup(path)
+        process_overlays
+        @lookup_cache[path] ||= lookup_elem(path).tap do |elem|
+          unless elem
+            raise InvalidPathError.new("Invalid path #{path.inspect}")
+          end
+        end
+      end
+
+      def lookup_elem(path)
+        data = @data.dup
+        elem = @assembly
+        path.each do |key|
+          elem = elem.index data, key
+          return nil unless elem
+        end
+        elem.output data
+      end
+
+
+      def canonical_path(from,path)
+        scope = lookup(from)[:full_scope]
+        path.inject(nil) do |p,elem|
+          scope = lookup(p)[:scope] if p
+          scope[elem]
+        end
+      end
+
+      def process_action(action)
+        if action.key?(:value)
+          [:value,action[:value]]
+        elsif action[:proc]
+          if action[:scope]
+            [:class,context_class(action)]
+          else
+            [:proc,action[:proc]]
+          end
+        end or raise "Invalid action"
+      end
+
+      def call_value(type,value,meta,args=[],blk=nil)
+        case type
+          when :value then value
+          when :proc then proc.call *args, &blk
+          when :class then value.new(self,meta).__call__ *args, &blk
+        end
+      end
+
+      def context_class(action)
+        desc = {
+          scope: action[:scope],
+          body: action[:proc],
+          modules: action[:modules],
+          methods: action[:methods]
+        }
+        @context_cache[desc] ||= Alki::Execution::ContextClassBuilder.build(desc)
+      end
+    end
+  end
+end

data/lib/alki/assembly/handler_base.rb

@@ -0,0 +1,21 @@
+module Alki
+  module Assembly
+    class HandlerBase
+      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
+end

data/lib/alki/assembly/instance.rb

@@ -0,0 +1,21 @@
+module Alki
+  module Assembly
+    class Instance
+      def initialize(executor)
+        @executor = executor
+      end
+
+      def root
+        @root ||= @executor.call []
+      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
+    end
+  end
+end

data/lib/alki/assembly/types/assembly.rb

@@ -0,0 +1,92 @@
+require 'alki/assembly/types/override'
+
+Alki do
+  attr :root
+  attr(:overrides) { nil }
+
+  index do
+    data[:scope] ||= {}
+    data[:prefix] ||= []
+    data[:overlays] ||= {}
+
+    if key == :original
+      update_main data
+      if overrides
+        overrides.children.keys.each do |k|
+          data[:scope][k] = data[:prefix] + [k]
+        end
+      end
+      root
+    else
+      if overrides
+        data.replace(
+          main: deep_copy(data),
+          override: data.dup,
+        )
+        update_main data[:main]
+        update_override data[:override]
+        override.index data, key
+      else
+        update_main data
+        root.index data, key
+      end
+    end
+  end
+
+  output do
+    data[:scope] ||= {}
+    data[:prefix] ||= []
+    data[:overlays] ||= {}
+
+    output = root.output(data)
+    add_parent_path output[:scope]
+    update_scope data, output[:full_scope]
+    output[:scope].merge! overrides.output(data)[:scope] if overrides
+    output[:full_scope].merge! overrides.output(data)[:full_scope] if overrides
+    output
+  end
+
+  def deep_copy(val)
+    if val.is_a?(Hash)
+      val.inject({}) do |h,(k,v)|
+        h[k] = deep_copy v
+        h
+      end
+    elsif val.is_a?(Array)
+      val.inject([]) do |a,v|
+        a.push deep_copy v
+      end
+    else
+      val
+    end
+  end
+
+  def update_main(data)
+    data[:scope] = {assembly: data[:scope][:assembly], root: []}
+    update_scope data
+    data[:scope][:assembly] = data[:prefix].dup
+  end
+
+  def update_override(data)
+    data[:scope][:root] ||= []
+    add_original data[:scope], data
+  end
+
+  def update_scope(data,scope=data[:scope])
+    add_parent_path scope, data
+    add_original scope, data
+  end
+
+  def add_parent_path(scope,data=self.data)
+    parent_path = data[:scope][:assembly]||nil
+    scope[:parent] = parent_path if parent_path
+  end
+
+  def add_original(scope,data=self.data)
+    scope[:original] = data[:prefix] + [:original]
+  end
+
+  def override
+    Alki::Assembly::Types::Override.new root, overrides
+  end
+end

data/lib/alki/assembly/types/factory.rb

@@ -0,0 +1,29 @@
+Alki do
+  require 'alki/execution/value_context'
+
+  attr :block
+
+  output do
+    {
+      modules: [Alki::Execution::ValueContext],
+      scope: data[:scope],
+      build: {
+        methods: {
+          __build__: block
+        },
+        proc: ->(desc) {
+          desc[:methods] = {
+            __create__: __build__
+          }
+          desc[:proc] = ->(*args,&blk) {
+            if !args.empty? || blk
+              __create__ *args, &blk
+            else
+              method(:__create__)
+            end
+          }
+        }
+      }
+    }
+  end
+end

data/lib/alki/assembly/types/func.rb

@@ -0,0 +1,12 @@
+Alki do
+  require 'alki/execution/value_context'
+
+  attr :block
+  output do
+    {
+      modules: [Alki::Execution::ValueContext],
+      scope: data[:scope],
+      proc: block
+    }
+  end
+end

data/lib/alki/assembly/types/group.rb

@@ -0,0 +1,39 @@
+Alki do
+  require 'alki/execution/context'
+
+  attr(:children){ {} }
+
+  index do
+    update_scope children, data[:prefix], data[:scope]
+
+    data[:overlays] = data[:overlays].inject({}) do |no,(target,overlays)|
+      target = target.dup
+      if target.empty? || target.shift == key.to_sym
+        (no[target]||=[]).push *overlays
+      end
+      no
+    end
+
+    data[:prefix] << key
+
+    children[key]
+  end
+
+  output do
+    {
+      full_scope: update_scope(children, data[:prefix], data[:scope]),
+      scope: update_scope(children,data[:prefix]),
+      modules: [Alki::Execution::Context],
+      proc: ->{self}
+    }
+  end
+
+  def update_scope(children, prefix, scope=nil)
+    scope ||= {}
+    prefix ||= []
+    children.keys.inject(scope) do |h,k|
+      h.merge! k => (prefix+[k])
+    end
+    scope
+  end
+end

data/lib/alki/assembly/types/override.rb

@@ -0,0 +1,40 @@
+require 'alki/assembly/types/override'
+
+Alki 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]||={}
+      if data[:override][:overlays]
+        data[:override][:overlays].each do |target,overlays|
+          (data[:main][:overlays][target]||=[]).push *overlays
+        end
+      end
+      data[:override][:overlays]=data[:main][:overlays].dup
+      Alki::Assembly::Types::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

data/lib/alki/assembly/types/proc_value.rb

@@ -0,0 +1,18 @@
+Alki do
+  require 'alki/execution/value_context'
+
+  attr :proc
+
+  output do
+    {
+      build: {
+        methods: {
+          __build__: proc
+        },
+        proc: ->(desc) {desc[:value] = __build__}
+      },
+      modules: [Alki::Execution::ValueContext],
+      scope: data[:scope]
+    }
+  end
+end

data/lib/alki/assembly/types/service.rb

@@ -0,0 +1,27 @@
+Alki do
+  require 'alki/execution/value_context'
+
+  attr :block
+
+  output do
+    overlays = data[:overlays][[]]||[]
+    {
+      build: {
+        methods: {
+          __build__: block
+        },
+        proc: -> (elem) {
+          elem[:value] = overlays.inject(__build__) do |val,(overlay,args)|
+            overlay = root.lookup(overlay)
+            if !overlay.respond_to?(:call) && overlay.respond_to?(:new)
+              overlay = overlay.method(:new)
+            end
+            overlay.call val, *args
+          end
+        },
+      },
+      modules: [Alki::Execution::ValueContext],
+      scope: data[:scope],
+    }
+  end
+end

data/lib/alki/assembly/types/value.rb

@@ -0,0 +1,9 @@
+Alki do
+  attr :value
+
+  output do
+    {
+      value: value
+    }
+  end
+end

data/lib/alki/assembly.rb

@@ -1,53 +1,34 @@
-require 'alki/assembly_executor'
 require 'alki/override_builder'
-require 'alki/dsls/assembly'
+require 'alki/assembly/types/assembly'
+require 'alki/assembly/types/group'
+require 'alki/assembly/instance'
+require 'alki/assembly/executor'
 
 module Alki
   module Assembly
     def new(overrides={},&blk)
-      Alki::Assembly::Instance.new create_assembly(overrides,&blk), self.assembly_options
-    end
+      overrides_info = OverrideBuilder.build(overrides,&blk)
+      override_root = overrides_info[:root] || build(:group)
 
-    def root
-      self.definition.root
-    end
+      assembly = build :assembly, root, override_root
+      executor = Executor.new(assembly, overlays+overrides_info[:overlays])
 
-    private
-
-    def create_assembly(overrides={},&blk)
-      config_dir = if assembly_options[:load_path]
-        Alki::Support.load_class("alki/assembly_types/value").new assembly_options[:load_path]
-      else
-        nil
-      end
-
-      Alki::Support.load_class("alki/assembly_types/assembly").new root, config_dir, OverrideBuilder.build(overrides,&blk)
+      override_root.children[:assembly_instance] = build(:service,->{
+        Instance.new(executor)
+      })
+      executor.call [:assembly_instance]
     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
+    def build(type,*args)
+      Alki::Support.load_class("alki/assembly/types/#{type}").new *args
+    end
 
-      private
+    def root
+      self.definition.root
+    end
 
-      def __executor__
-        @executor ||= Alki::AssemblyExecutor.new @opts
-      end
+    def overlays
+      self.definition.overlays
     end
   end
-end
+end

data/lib/alki/dsls/assembly.rb

@@ -1,20 +1,18 @@
 Alki do
   require_dsl 'alki/dsls/class'
-  require_dsl 'alki/dsls/assembly_types/group'
-  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
-    ctx[:elems] = {}
-    ctx[:overlays] = []
-  end
+  require_dsl 'alki/dsls/assembly_group'
 
   finish do
-    ctx[:root] = root = build_group(ctx.delete(:elems), ctx.delete(:overlays))
+    add :config_dir, build(:value, ctx[:config_dir])
+    prefix_overlays :original, ctx[:overlays]
+
+    root = ctx[:root]
+    overlays = ctx[:overlays]
     add_class_method :root do
       root
     end
+    add_class_method :overlays do
+      overlays
+    end
   end
-end
+end

data/lib/alki/dsls/assembly_group.rb

@@ -0,0 +1,92 @@
+require 'alki/override_builder'
+require 'alki/support'
+require 'alki/overlay_info'
+
+Alki do
+  require_dsl 'alki/dsls/dsl'
+
+  init do
+    ctx[:root] = build(:group,{})
+    ctx[:overlays] = []
+  end
+
+  helper :add do |name,elem|
+    ctx[:root].children[name.to_sym] = elem
+    nil
+  end
+
+  helper :build do |type,*args|
+    Alki::Support.load_class("alki/assembly/types/#{type}").new *args
+  end
+
+  helper :prefix_overlays do |*prefix,overlays|
+    overlays.each do |overlay|
+      overlay[0].unshift *prefix
+    end
+    overlays
+  end
+
+  helper :update_overlays do |*prefix,overlays|
+    ctx[:overlays].push *prefix_overlays(*prefix,overlays)
+  end
+
+  dsl_method :config_dir do
+    ctx[:config_dir]
+  end
+
+  dsl_method :set do |name,value=nil,&blk|
+    if blk
+      add name, build(:proc_value, blk)
+    else
+      add name, build(:value, value)
+    end
+  end
+
+  dsl_method :service do |name,&blk|
+    add name, build(:service, blk)
+  end
+
+  dsl_method :factory do |name,&blk|
+    add name, build(:factory, blk)
+  end
+
+  dsl_method :func do |name,&blk|
+    add name, build(:func, blk)
+  end
+
+  dsl_method :group do |name,&blk|
+    grp = Alki::Dsls::AssemblyGroup.build(&blk)
+    add name, grp[:root]
+    update_overlays name, grp[:overlays]
+  end
+
+  dsl_method :load do |group_name,name=group_name.to_s|
+    grp = Alki::Dsl.load(File.expand_path(name+'.rb',ctx[:config_dir]))[:class]
+    add name, grp.root
+    update_overlays name, grp.overlays
+  end
+
+  dsl_method :mount do |name,pkg=name.to_s,**overrides,&blk|
+    klass = Alki::Support.load_class pkg
+    mounted_assemblies = klass.overlays.map do |(path,info)|
+      [path.dup,info]
+    end
+    update_overlays name, mounted_assemblies
+
+    overrides = Alki::OverrideBuilder.build overrides, &blk
+    update_overlays name, overrides[:overlays]
+
+    add name, build(:assembly, klass.root, overrides[:root])
+  end
+
+  dsl_method :overlay do |target,overlay,*args|
+    (ctx[:overlays]||=[]) << [
+      [],
+      Alki::OverlayInfo.new(
+        target.to_s.split('.').map(&:to_sym),
+        overlay.to_s.split('.').map(&:to_sym),
+        args
+      )
+    ]
+  end
+end

data/lib/alki/dsls/assembly_type.rb

@@ -1,10 +1,10 @@
-require 'alki/assembly_handler_base'
+require 'alki/assembly/handler_base'
 
 Alki do
   require_dsl 'alki/dsls/class'
 
   init do
-    set_super_class Alki::AssemblyHandlerBase, subclass: 'Handler'
+    set_super_class Alki::Assembly::HandlerBase, subclass: 'Handler'
 
     add_method :handler, private: true do |*args|
       self.class::Handler.new(self,*args)
@@ -18,23 +18,13 @@ Alki do
       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|
+  dsl_method :attr do |name,&default|
     add_delegator name, :@elem, subclass: 'Handler'
-    add_initialize_param name, default
+    add_initialize_param name, &default
     add_accessor name
   end
 
@@ -45,4 +35,4 @@ Alki do
   dsl_method :output do |&blk|
     add_method :output, subclass: 'Handler', &blk
   end
-end
+end