rggen-core 0.18.0 → 0.23.0

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/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/{category.rb → layer.rb}

@@ -3,13 +3,14 @@
 module RgGen
   module Core
     module Builder
-      class Category
+      class Layer
         class Proxy
-          def initialize(body)
-            body.call(self)
+          def initialize
+            block_given? && yield(self)
           end
 
-          attr_setter :method
+          attr_setter :body
+          attr_setter :method_name
           attr_setter :list_names
           attr_setter :feature_names
 
@@ -21,25 +22,22 @@ module RgGen
             @shared_context
           end
 
-          def register_execution(registry, args, body)
+          def register_execution(registry, &body)
             @executions ||= []
-            @executions << { registry: registry, args: args, body: body }
+            @executions << { registry: registry, body: body }
           end
 
-          def execute(category, body)
-            Docile.dsl_eval(category, &body)
-            Array(@executions).each { |execution| call_execution(execution) }
+          def execute(layer)
+            Docile.dsl_eval(layer, &body)
+            @executions&.each(&method(:call_execution))
           end
 
           private
 
           def call_execution(execution)
-            send_args = [
-              list_names, feature_names, shared_context, *execution[:args]
-            ].compact
-            execution[:registry].__send__(
-              method, *send_args, &execution[:body]
-            )
+            args = [list_names, feature_names, shared_context].compact
+            execution[:registry]
+              .__send__(method_name, *args, &execution[:body])
           end
         end
 
@@ -58,22 +56,25 @@ module RgGen
         end
 
         def define_simple_feature(feature_names, &body)
-          do_proxy_call(body) do |proxy|
-            proxy.method(__method__)
+          do_proxy_call do |proxy|
+            proxy.body(body)
+            proxy.method_name(__method__)
             proxy.feature_names(feature_names)
           end
         end
 
         def define_list_feature(list_names, &body)
-          do_proxy_call(body) do |proxy|
-            proxy.method(__method__)
+          do_proxy_call do |proxy|
+            proxy.body(body)
+            proxy.method_name(__method__)
             proxy.list_names(list_names)
           end
         end
 
         def define_list_item_feature(list_name, feature_names, &body)
-          do_proxy_call(body) do |proxy|
-            proxy.method(__method__)
+          do_proxy_call do |proxy|
+            proxy.body(body)
+            proxy.method_name(__method__)
             proxy.list_names(list_name)
             proxy.feature_names(feature_names)
           end
@@ -100,14 +101,14 @@ module RgGen
         private
 
         def define_proxy_call(name)
-          define_singleton_method(name) do |*args, &body|
-            @proxy.register_execution(@feature_registries[name], args, body)
+          define_singleton_method(name) do |&body|
+            @proxy.register_execution(@feature_registries[__method__], &body)
           end
         end
 
-        def do_proxy_call(body, &proxy_block)
-          @proxy = Proxy.new(proxy_block)
-          @proxy.execute(self, body)
+        def do_proxy_call(&block)
+          @proxy = Proxy.new(&block)
+          @proxy.execute(self)
           remove_instance_variable(:@proxy)
         end
       end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Builder
+      class LoaderRegistry
+        def initialize
+          @loaders = []
+          @extractors = []
+          @ignore_values = {}
+        end
+
+        def register_loader(loader)
+          register_loaders([loader])
+        end
+
+        def register_loaders(loaders)
+          @loaders.concat(Array(loaders))
+        end
+
+        def define_value_extractor(layers, value, &body)
+          @extractors <<
+            create_extractor(layers, value, &body)
+        end
+
+        def ignore_value(layers, value)
+          ignore_values(layers, [value])
+        end
+
+        def ignore_values(layers, values)
+          [layers].flatten.each do |layer|
+            (@ignore_values[layer] ||= []).concat(Array(values))
+          end
+        end
+
+        def create_loaders
+          @loaders.map { |loader| loader.new(@extractors, @ignore_values) }
+        end
+
+        private
+
+        def create_extractor(layers, value, &body)
+          Class.new(Core::InputBase::InputValueExtractor, &body).new(layers, value)
+        end
+      end
+    end
+  end
+end