rggen-core 0.19.0 → 0.23.1

data/lib/rggen/core/builder/builder.rb

@@ -4,13 +4,15 @@ module RgGen
   module Core
     module Builder
       class Builder
+        extend Forwardable
+
         def initialize
           initialize_component_registries
-          initialize_categories
-          @plugins = Plugins.new
+          initialize_layers
+          @plugin_manager = PluginManager.new(self)
         end
 
-        attr_reader :plugins
+        attr_reader :plugin_manager
 
         def input_component_registry(name, &body)
           component_registry(:input, name, body)
@@ -20,27 +22,25 @@ module RgGen
           component_registry(:output, name, body)
         end
 
-        def register_loader(component, loader)
-          @component_registries[:input][component].register_loader(loader)
-        end
-
-        def register_loaders(component, loaders)
-          @component_registries[:input][component].register_loaders(loaders)
-        end
-
-        def define_loader(component, &body)
-          @component_registries[:input][component].define_loader(&body)
+        [
+          :register_loader, :register_loaders,
+          :define_value_extractor, :ignore_value, :ignore_values
+        ].each do |method_name|
+          define_method(method_name) do |component, *args, &block|
+            @component_registries[:input][component]
+              .__send__(__method__, *args, &block)
+          end
         end
 
-        def add_feature_registry(name, target_category, registry)
-          target_categories =
-            if target_category
-              Array(@categories[target_category])
+        def add_feature_registry(name, target_layer, registry)
+          target_layers =
+            if target_layer
+              Array(@layers[target_layer])
             else
-              @categories.values
+              @layers.values
             end
-          target_categories.each do |category|
-            category.add_feature_registry(name, registry)
+          target_layers.each do |layer|
+            layer.add_feature_registry(name, registry)
           end
         end
 
@@ -49,21 +49,21 @@ module RgGen
           :define_list_feature,
           :define_list_item_feature
         ].each do |method_name|
-          define_method(method_name) do |category, *args, &body|
-            @categories[category].__send__(__method__, *args, &body)
+          define_method(method_name) do |layer, *args, &body|
+            @layers[layer].__send__(__method__, *args, &body)
           end
         end
 
-        def enable(category, *args)
-          @categories[category].enable(*args)
+        def enable(layer, *args)
+          @layers[layer].enable(*args)
         end
 
         def disable_all
-          @categories.each_value(&:disable)
+          @layers.each_value(&:disable)
         end
 
-        def disable(category, *args)
-          @categories.key?(category) && @categories[category].disable(*args)
+        def disable(layer, *args)
+          @layers.key?(layer) && @layers[layer].disable(*args)
         end
 
         def build_factory(type, component)
@@ -81,8 +81,8 @@ module RgGen
           registries.each_value.map(&:build_factory)
         end
 
-        def delete(category, *args)
-          @categories.key?(category) && @categories[category].delete(*args)
+        def delete(layer, *args)
+          @layers.key?(layer) && @layers[layer].delete(*args)
         end
 
         def register_input_components
@@ -90,23 +90,9 @@ module RgGen
           RegisterMap.setup(self)
         end
 
-        def setup(name, module_or_version = nil, &block)
-          plugins.add(name, module_or_version, &block)
-        end
-
-        def activate_plugins
-          plugins.activate(self)
-        end
-
-        def load_setup_file(file, activation = true)
-          (file.nil? || file.empty?) &&
-            (raise Core::LoadError.new('no setup file is given'))
-          File.readable?(file) ||
-            (raise Core::LoadError.new("cannot load such setup file: #{file}"))
-          RgGen.builder(self)
-          load(file)
-          activation && activate_plugins
-        end
+        def_delegator :plugin_manager, :load_plugin
+        def_delegator :plugin_manager, :load_plugins
+        def_delegator :plugin_manager, :setup
 
         private
 
@@ -119,14 +105,14 @@ module RgGen
           end
         end
 
-        def initialize_categories
-          @categories = Hash.new do |_, category_name|
-            raise BuilderError.new("unknown category: #{category_name}")
+        def initialize_layers
+          @layers = Hash.new do |_, layer_name|
+            raise BuilderError.new("unknown layer: #{layer_name}")
           end
           [
-            :global, :register_map, :register_block, :register, :bit_field
-          ].each do |category|
-            @categories[category] = Category.new(category)
+            :global, :root, :register_block, :register_file, :register, :bit_field
+          ].each do |layer|
+            @layers[layer] = Layer.new(layer)
           end
         end
 

data/lib/rggen/core/builder/component_entry.rb

@@ -6,8 +6,9 @@ module RgGen
       class ComponentEntry
         Entry = Struct.new(:target, :factory)
 
-        def initialize(component_name)
+        def initialize(component_name, layer)
           @component_name = component_name
+          @layer = layer
         end
 
         [:component, :feature].each do |entry_name|
@@ -22,7 +23,7 @@ module RgGen
         end
 
         def build_factory
-          @component.factory.new(@component_name) do |f|
+          @component.factory.new(@component_name, @layer) do |f|
             f.target_component(@component.target)
             f.feature_factories(feature_registry&.build_factories)
           end

data/lib/rggen/core/builder/component_registry.rb

@@ -10,10 +10,10 @@ module RgGen
           @entries = []
         end
 
-        def register_component(categories = nil, &block)
-          if categories
-            Array(categories).each do |category|
-              @entries << create_new_entry(category, block)
+        def register_component(layers = nil, &block)
+          if layers
+            Array(layers).each do |layer|
+              @entries << create_new_entry(layer, block)
             end
           else
             @entries << create_new_entry(nil, block)
@@ -21,26 +21,31 @@ module RgGen
         end
 
         def build_factory
-          factories = @entries.map(&:build_factory)
-          factories.each_cons(2) { |(f0, f1)| f0.child_factory(f1) }
-          root_factory = factories.first
-          root_factory.root_factory
-          root_factory
+          build_factories.first.tap(&:root_factory)
         end
 
         private
 
-        def create_new_entry(category, block)
-          entry = ComponentEntry.new(@component_name)
-          Docile.dsl_eval(entry, category, &block)
-          add_feature_registry(category, entry.feature_registry)
+        def create_new_entry(layer, block)
+          entry = ComponentEntry.new(@component_name, layer)
+          Docile.dsl_eval(entry, layer, &block)
+          add_feature_registry(layer, entry.feature_registry)
           entry
         end
 
-        def add_feature_registry(category, feature_registry)
-          feature_registry || return
-          @builder
-            .add_feature_registry(@component_name, category, feature_registry)
+        def add_feature_registry(layer, feature_registry)
+          feature_registry &&
+            @builder
+              .add_feature_registry(@component_name, layer, feature_registry)
+        end
+
+        def build_factories
+          factories =
+            @entries
+              .map(&:build_factory)
+              .map { |f| [f.layer, f] }.to_h
+          factories.each_value { |f| f.component_factories factories }
+          factories.values
         end
       end
     end

data/lib/rggen/core/builder/feature_registry.rb

@@ -11,22 +11,19 @@ module RgGen
           @enabled_features = {}
         end
 
-        def define_simple_feature(names, context = nil, &body)
-          Array(names)
-            .each { |name| create_new_entry(:simple, name, context, body) }
+        def define_simple_feature(name, context = nil, &body)
+          create_new_entry(:simple, name, context, body)
         end
 
-        def define_list_feature(list_names, context = nil, &body)
-          Array(list_names)
-            .each { |name| create_new_entry(:list, name, context, body) }
+        def define_list_feature(list_name, context = nil, &body)
+          create_new_entry(:list, list_name, context, body)
         end
 
-        def define_list_item_feature(list_name, feature_names, context = nil, &body)
+        def define_list_item_feature(list_name, feature_name, context = nil, &body)
           entry = @feature_entries[list_name]
           entry&.match_entry_type?(:list) ||
             (raise BuilderError.new("unknown list feature: #{list_name}"))
-          Array(feature_names)
-            .each { |name| entry.define_feature(name, context, &body) }
+          entry.define_feature(feature_name, context, &body)
         end
 
         def enable(feature_or_list_names, feature_names = nil)

data/lib/rggen/core/builder/input_component_registry.rb

@@ -6,29 +6,62 @@ module RgGen
       class InputComponentRegistry < ComponentRegistry
         def initialize(name, builder)
           super
-          @loaders = []
+          @loader_registries = {}
         end
 
-        attr_setter :base_loader
+        def register_loader(loader_type, loader)
+          loader_registry(loader_type).register_loader(loader)
+        end
+
+        def register_loaders(loader_type, loaders)
+          loader_registry(loader_type).register_loaders(loaders)
+        end
 
-        def register_loader(loader)
-          @loaders << loader
+        def define_value_extractor(loader_type, layers_or_value, value = nil, &body)
+          layers, value =
+            if value
+              [layers_or_value, value]
+            else
+              [nil, layers_or_value]
+            end
+          loader_registry(loader_type).define_value_extractor(layers, value, &body)
         end
 
-        def register_loaders(loaders)
-          @loaders.concat(Array(loaders))
+        def ignore_value(loader_type, layers_or_value, value = nil)
+          layers, value =
+            if value
+              [layers_or_value, value]
+            else
+              [nil, layers_or_value]
+            end
+          loader_registry(loader_type).ignore_value(layers, value)
         end
 
-        def define_loader(&body)
-          loader = Class.new(@base_loader, &body)
-          register_loader(loader)
+        def ignore_values(loader_type, layers_or_values, values = nil)
+          layers, values =
+            if values
+              [layers_or_values, values]
+            else
+              [nil, layers_or_values]
+            end
+          loader_registry(loader_type).ignore_values(layers, values)
         end
 
         def build_factory
           factory = super
-          factory.loaders(@loaders)
+          factory.loaders(build_loaders)
           factory
         end
+
+        private
+
+        def loader_registry(loader_type)
+          @loader_registries[loader_type] ||= LoaderRegistry.new
+        end
+
+        def build_loaders
+          @loader_registries.values.flat_map(&:create_loaders)
+        end
       end
     end
   end

data/lib/rggen/core/builder/layer.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Builder
+      class Layer
+        class Proxy
+          def initialize
+            block_given? && yield(self)
+          end
+
+          attr_setter :body
+          attr_setter :method_name
+          attr_setter :list_name
+          attr_setter :feature_name
+
+          def register_execution(registry, &body)
+            @executions ||= []
+            @executions << { registry: registry, body: body }
+          end
+
+          def execute(layer)
+            Docile.dsl_eval(layer, &body)
+            @executions&.each { |execution| call_execution(layer, execution) }
+          end
+
+          private
+
+          def call_execution(layer, execution)
+            args = [list_name, feature_name, layer.shared_context].compact
+            execution[:registry].__send__(method_name, *args, &execution[:body])
+          end
+        end
+
+        def initialize(name)
+          @name = name
+          @feature_registries = {}
+        end
+
+        def add_feature_registry(name, registry)
+          @feature_registries[name] = registry
+          define_proxy_call(name)
+        end
+
+        def shared_context(&body)
+          return unless @proxy
+
+          if block_given?
+            context = current_shared_context(true)
+            context.singleton_exec(&body)
+          end
+
+          current_shared_context(false)
+        end
+
+        def define_simple_feature(feature_names, &body)
+          Array(feature_names).each do |feature_name|
+            do_proxy_call do |proxy|
+              proxy.body(body)
+              proxy.method_name(__method__)
+              proxy.feature_name(feature_name)
+            end
+          end
+        end
+
+        def define_list_feature(list_names, &body)
+          Array(list_names).each do |list_name|
+            do_proxy_call do |proxy|
+              proxy.body(body)
+              proxy.method_name(__method__)
+              proxy.list_name(list_name)
+            end
+          end
+        end
+
+        def define_list_item_feature(list_name, feature_names, &body)
+          Array(feature_names).each do |feature_name|
+            do_proxy_call do |proxy|
+              proxy.body(body)
+              proxy.method_name(__method__)
+              proxy.list_name(list_name)
+              proxy.feature_name(feature_name)
+            end
+          end
+        end
+
+        def enable(feature_or_list_names, feature_names = nil)
+          @feature_registries.each_value do |registry|
+            registry.enable(feature_or_list_names, feature_names)
+          end
+        end
+
+        def disable(feature_or_list_names = nil, feature_names = nil)
+          @feature_registries.each_value do |registry|
+            registry.disable(*[feature_or_list_names, feature_names].compact)
+          end
+        end
+
+        def delete(feature_or_list_names = nil, feature_names = nil)
+          @feature_registries.each_value do |registry|
+            registry.delete(*[feature_or_list_names, feature_names].compact)
+          end
+        end
+
+        private
+
+        def define_proxy_call(name)
+          define_singleton_method(name) do |&body|
+            @proxy.register_execution(@feature_registries[__method__], &body)
+          end
+        end
+
+        def do_proxy_call(&block)
+          @proxy = Proxy.new(&block)
+          @proxy.execute(self)
+          remove_instance_variable(:@proxy)
+        end
+
+        def current_shared_context(allocate)
+          list_name = @proxy.list_name || @proxy.feature_name
+          feature_name = @proxy.feature_name
+          allocate && (shared_contexts[list_name][feature_name] ||= Object.new)
+          shared_contexts[list_name][feature_name]
+        end
+
+        def shared_contexts
+          @shared_contexts ||= Hash.new { |h, k| h[k] = {} }
+        end
+      end
+    end
+  end
+end