alki 0.12.0 → 0.12.1

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

@@ -0,0 +1,12 @@
+Alki do
+  attr :group
+
+  index do
+    group.index data, key
+  end
+
+  output do
+    data[:prefix] << :original
+    group.output(data)
+  end
+end

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

@@ -1,5 +1,3 @@
-require 'alki/assembly/types/override'
-
 Alki do
   attr :main
   attr :override

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

@@ -4,10 +4,10 @@ Alki do
   attr :block
 
   output do
-    overlays = (data[:overlays][[]]||[]).sort_by(&:order).group_by(&:type)
-    value_overlays = overlays[:value]||[]
-    reference_overlays = overlays[:reference]||[]
-    tags = data[:tags].inject({}){|tags,(tag,tagged)| tags[tag] = tagged[[]]; tags}
+    all_overlays = data[:overlays]&.overlays || []
+    value_overlays = all_overlays[:value] || []
+    reference_overlays = all_overlays[:reference] || []
+    tags = data[:tags]&.tags || {}
     methods = {
       __build__: block,
       __apply_overlays__: -> obj, overlays {

data/lib/alki/circular_reference_error.rb

@@ -0,0 +1,25 @@
+module Alki
+  class CircularReferenceError < RuntimeError
+    attr_reader :chain
+
+    def initialize
+      @chain = []
+      super
+    end
+
+    def to_s
+      "Circular Alki element reference:\n#{formatted_chain}"
+    end
+
+    def formatted_chain
+      chain.reverse.map do |path|
+        p = path.join('.')
+        if path == chain[0]
+          "> #{p}"
+        else
+          "  #{p}"
+        end
+      end.join("\n")
+    end
+  end
+end

data/lib/alki/dsls/assembly.rb

@@ -7,7 +7,7 @@ Alki do
     add :config_dir, build(:value, ctx[:config_dir])
     add :assembly_name, build(:value, ctx[:assembly_name])
 
-    root = IceNine.deep_freeze ctx[:root]
+    root = ctx[:root]
     meta = IceNine.deep_freeze ctx[:meta]
     add_class_method :root do
       root

data/lib/alki/dsls/assembly_group.rb

@@ -6,14 +6,14 @@ Alki do
   init do
     ctx[:root] = build(:group,{})
     ctx[:meta] = []
-    @addons = Array ctx[:addons]
-    @addons.each do |addon|
+    ctx[:addons] ||= []
+    ctx[:addons].each do |addon|
       require_dsl addon
     end
   end
 
   helper :add do |name,elem|
-    if @tags
+    if defined?(@tags) && @tags
       ctx[:meta] << [[name.to_sym],build_meta(:tags,@tags)]
       @tags = nil
     end
@@ -58,7 +58,7 @@ Alki do
       addon = addon.alki_addon
     end
     require_dsl addon
-    @addons << addon
+    ctx[:addons] << addon
   end
 
   dsl_method :tag do |*tags,**value_tags|
@@ -94,7 +94,7 @@ Alki do
   end
 
   dsl_method :group do |name,&blk|
-    grp = Alki::Dsls::AssemblyGroup.build(&blk)
+    grp = Alki::Dsls::AssemblyGroup.build(addons: ctx[:addons], &blk)
     add name, grp[:root]
     update_meta name, grp[:meta]
   end
@@ -107,10 +107,10 @@ Alki do
       if require_path
         elems = path[dir.size..-1].chomp('.rb').split('/')
         *parents,basename = elems
-        parent_group = parents.inject(grp) do |grp,parent|
-          grp.children[parent] ||= build(:group)
+        parent_group = parents.inject(grp) do |group,parent|
+          group.children[parent.to_sym] ||= build(:group)
         end
-        parent_group.children[basename] = build :service,-> {
+        parent_group.children[basename.to_sym] = build :service,-> {
           lookup(callable).call require_path, *args
         }
       end
@@ -123,8 +123,8 @@ Alki do
       raise "Load command is not available without a config directory"
     end
     grp = Alki.load(File.join(ctx[:prefix],name))
-    add name, grp.root
-    update_meta name, grp.meta
+    add group_name, grp.root
+    update_meta group_name, grp.meta
   end
 
   dsl_method :mount do |name,pkg=name.to_s,**overrides,&blk|
@@ -135,16 +135,32 @@ Alki do
     update_meta name, mounted_meta
 
     overrides = Alki::OverrideBuilder.build overrides, &blk
-    update_meta name, overrides[:meta]
+    update_meta name, overrides.meta
 
-    add name, build(:assembly, klass.root, overrides[:root])
+    add name, build(:assembly, klass.root, overrides.root)
+  end
+
+  dsl_method :try_mount do |name,pkg=name.to_s,**overrides,&blk|
+    begin
+      mount name,pkg,overrides,&blk
+    rescue LoadError
+      nil
+    end
   end
 
   dsl_method :reference_overlay do |target,overlay,*args|
     add_overlay :reference, target, overlay, args
   end
+  
+  dsl_method :reference_overlay_tag do |target,overlay,*args|
+    add_overlay :reference, "%#{target}", overlay, args
+  end
 
   dsl_method :overlay do |target,overlay,*args|
     add_overlay :value, target, overlay, args
   end
+  
+  dsl_method :overlay_tag do |target,overlay,*args|
+    add_overlay :value, "%#{target}", overlay, args
+  end
 end

data/lib/alki/execution/context_class_builder.rb

@@ -13,7 +13,7 @@ module Alki
         else
           methods = {}
         end
-        (config[:scope]||{}).each do |name,path|
+        (config[:lookup_methods]||config[:scope]||{}).each do |name,path|
           methods[name] = {
             body:->(*args,&blk) {
                __execute__ path, args, blk

data/lib/alki/execution/helpers.rb

@@ -4,11 +4,11 @@ module Alki
   module Execution
     module Helpers
       def lookup(*path)
-        path.flatten.inject(self) do |group,elem|
+        path.flatten.inject(self) do |from_group,elem|
           unless elem.is_a?(String) or elem.is_a?(Symbol)
             raise ArgumentError.new("lookup can only take Strings or Symbols")
           end
-          elem.to_s.split('.').inject(group) do |group,name|
+          elem.to_s.split('.').inject(from_group) do |group,name|
             raise "Invalid lookup elem" unless group.is_a? Helpers
             if name =~ /^\d/
               group[name.to_i]
@@ -20,11 +20,11 @@ module Alki
       end
 
       def lazy(*path)
-        path = path.flatten.inject('') do |path,elem|
+        path = path.flatten.inject('') do |new_path,elem|
           unless elem.is_a?(String) or elem.is_a?(Symbol)
             raise ArgumentError.new("lookup can only take Strings or Symbols")
           end
-          path << elem.to_s
+          new_path << elem.to_s
         end
         Alki::ServiceDelegator.new self, path
       end

data/lib/alki/execution/overlay_map.rb

@@ -0,0 +1,37 @@
+module Alki
+  module Execution
+    class OverlayMap
+      def initialize(overlays = {})
+        @overlays = overlays
+      end
+
+      def index(key,tags)
+        self.class.new.tap do |new_overlays|
+          @overlays.each do |target,overlays|
+            target = target.dup
+            if target.size == 1 && target[0].to_s.start_with?('%')
+              if tags
+                tag = target[0].to_s[1..-1].to_sym
+                tags.elements_in(tag).each do |path|
+                  new_overlays.add path, *overlays
+                end
+              end
+            elsif target.empty? || target.shift == key.to_sym
+              new_overlays.add target, *overlays
+            end
+          end
+        end
+      end
+
+      def add(path,*overlays)
+        @overlays[path] ||= []
+        @overlays[path].push *overlays
+      end
+
+      def overlays
+        overlays = @overlays[[]] || []
+        overlays.sort_by(&:order).group_by(&:type)
+      end
+    end
+  end
+end

data/lib/alki/execution/tag_map.rb

@@ -0,0 +1,42 @@
+module Alki
+  module Execution
+    class TagMap
+      def initialize(tag_map = {})
+        @tag_map = tag_map
+      end
+
+      def add(path,tags)
+        tags.each do |tag,value|
+          @tag_map[tag] ||= {}
+          @tag_map[tag][path] = value
+        end
+      end
+
+      def elements_in(tag)
+        @tag_map[tag]&.keys || []
+      end
+
+      def index(key)
+        new_tag_map = {}
+        @tag_map.each do |tag,tagged|
+          tagged.each do |path,value|
+            if path.empty? || path[0] == key.to_sym
+              new_tag_map[tag] ||= {}
+              new_path = path[1..-1] || []
+              new_tag_map[tag][new_path] = value
+            end
+          end
+        end
+        self.class.new new_tag_map
+      end
+
+      def tags
+        Hash.new.tap do |tags|
+          @tag_map.each do |tag,tagged|
+            tags[tag] = tagged[[]]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/alki/executor.rb

@@ -0,0 +1,140 @@
+require 'alki/execution/context_class_builder'
+require 'alki/execution/cache_entry'
+require 'concurrent'
+require 'alki/invalid_path_error'
+require 'alki/circular_reference_error'
+
+module Alki
+  class Executor
+    attr_accessor :root, :meta
+
+    def initialize
+      @semaphore = Concurrent::ReentrantReadWriteLock.new
+      @lookup_cache = {}
+      @call_cache = {}
+      @context_cache = {}
+      @data = nil
+    end
+
+    def lock
+      @semaphore.with_write_lock do
+        yield
+      end
+    end
+
+    def call(path,*args,&blk)
+      execute({},path,args,blk)
+    end
+
+    def lookup(path)
+      @semaphore.with_read_lock do
+        unless @lookup_cache[path]
+          @semaphore.with_write_lock do
+            @lookup_cache[path] = lookup_elem(path).tap do |elem|
+              unless elem
+                raise InvalidPathError.new("Invalid path #{path.inspect}")
+              end
+            end
+          end
+        end
+        @lookup_cache[path]
+      end
+    end
+
+    def canonical_path(from,path)
+      from_elem = lookup(from)
+      scope = from_elem[:scope]
+      path.inject(nil) do |p,elem|
+        scope = lookup(p)[:scope] if p
+        scope[elem]
+      end
+    end
+
+    def execute(meta,path,args,blk)
+      type,value = nil,nil
+      @semaphore.with_read_lock do
+        cache_entry = @call_cache[path]
+        if cache_entry
+          if cache_entry == :building
+            raise Alki::CircularReferenceError.new
+          end
+          type,value = cache_entry.type,cache_entry.value
+        else
+          @semaphore.with_write_lock do
+            @call_cache[path] = :building
+            type, value = build(path)
+            @call_cache[path] = Alki::Execution::CacheEntry.finished type, value
+          end
+        end
+      end
+      call_value(type, value, meta, args, blk)
+    rescue Alki::CircularReferenceError => e
+      e.chain << path
+      raise
+    end
+
+    private
+
+    def build(path)
+      action = lookup(path)
+      if action[:build]
+        build_meta = {building: path.join('.')}
+        build_meta.merge!(action[:meta]) if action[:meta]
+        build_action = action[:build].merge(scope: action[:scope], modules: action[:modules])
+        call_value(*process_action(build_action), build_meta, [action])
+      end
+      process_action action
+    end
+
+    def data_copy
+      unless @data
+        @data = {}
+        @meta.each do |(from,meta)|
+          meta.process self, from, @data
+        end
+        IceNine.deep_freeze @data
+      end
+      @data.dup
+    end
+
+    def lookup_elem(path)
+      data = data_copy
+      elem = @root
+      path.each do |key|
+        elem = elem.index data, key
+        return nil unless elem
+      end
+      elem.output data
+    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

data/lib/alki/override_builder.rb

@@ -1,37 +1,43 @@
-require 'alki/dsls/assembly'
+require 'alki/dsl'
+require 'alki/overrides'
+require 'alki/assembly/types'
 
 module Alki
   module OverrideBuilder
-    def self.build(override_hash=nil,&blk)
-      if blk
-        Alki::Dsls::AssemblyGroup.build(&blk)
-      elsif override_hash && !override_hash.empty?
-        { root: create_override_group(override_hash), meta: [] }
-      else
-        { root: nil, meta: [] }
+    class << self
+      def build(override_hash=nil,&blk)
+        if blk
+          data = Alki::Dsl.build('alki/dsls/assembly_group',&blk)
+          Overrides.new data[:root], data[:meta]
+        elsif override_hash && !override_hash.empty?
+          Overrides.new create_override_group(override_hash), []
+        else
+          Overrides.new build_type(:group), []
+        end
       end
-    end
 
-    def self.create_override_group(overrides)
-      unless overrides.empty?
-        root = build_type(:group)
-        overrides.each do |path,value|
-          set_override root, *path.to_s.split('.'), value
+      private
+
+      def create_override_group(overrides)
+        unless overrides.empty?
+          root = build_type(:group)
+          overrides.each do |path,value|
+            set_override root, *path.to_s.split('.'), value
+          end
+          root
         end
-        root
       end
-    end
 
-    def self.set_override(root,*parent_keys,key,value)
-      parent = parent_keys.inject(root) do |parent,key|
-        parent.children[key.to_sym] ||= build_type(:group)
+      def set_override(root,*parent_keys,key,value)
+        parent = parent_keys.inject(root) do |group,parent_key|
+          group.children[parent_key.to_sym] ||= build_type(:group)
+        end
+        parent.children[key.to_sym] = build_type(:value, value)
       end
-      parent.children[key.to_sym] = build_type(:value, value)
-    end
 
-    def self.build_type(type,*args)
-      Alki.load("alki/assembly/types/#{type}").new *args
+      def build_type(type,*args)
+        Assembly::Types.build(type,*args)
+      end
     end
-
   end
 end