rggen-core 0.19.0 → 0.20.0

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

@@ -6,7 +6,7 @@ module RgGen
       class Builder
         def initialize
           initialize_component_registries
-          initialize_categories
+          initialize_layers
           @plugins = Plugins.new
         end
 
@@ -32,15 +32,15 @@ module RgGen
           @component_registries[:input][component].define_loader(&body)
         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
@@ -94,8 +94,8 @@ module RgGen
           plugins.add(name, module_or_version, &block)
         end
 
-        def activate_plugins
-          plugins.activate(self)
+        def activate_plugins(**options)
+          plugins.activate(self, **options)
         end
 
         def load_setup_file(file, activation = true)
@@ -119,14 +119,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/{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/plugins.rb

@@ -63,9 +63,11 @@ module RgGen
           @plugins << Plugin.new(name, module_or_version, &block)
         end
 
-        def activate(builder)
-          @plugins.each { |plugin| plugin.default_setup(builder) }
-          @plugins.each { |plugin| plugin.optional_setup(builder) }
+        def activate(builder, **options)
+          options[:no_default_setup] ||
+            @plugins.each { |plugin| plugin.default_setup(builder) }
+          options[:no_optional_setup] ||
+            @plugins.each { |plugin| plugin.optional_setup(builder) }
         end
 
         def version_info

data/lib/rggen/core/configuration/component.rb

@@ -4,6 +4,11 @@ module RgGen
   module Core
     module Configuration
       class Component < InputBase::Component
+        private
+
+        def post_initialize
+          need_no_children
+        end
       end
     end
   end

data/lib/rggen/core/configuration/component_factory.rb

@@ -7,7 +7,7 @@ module RgGen
         private
 
         def create_input_data(&block)
-          InputBase::InputData.new(valid_value_lists, &block)
+          InputData.new(valid_value_lists, &block)
         end
       end
     end

data/lib/rggen/core/configuration/input_data.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Configuration
+      class InputData < InputBase::InputData
+        def initialize(valid_value_lists, &block)
+          super(nil, valid_value_lists, &block)
+        end
+
+        undef_method :child
+      end
+    end
+  end
+end

data/lib/rggen/core/input_base/component_factory.rb

@@ -4,6 +4,20 @@ module RgGen
   module Core
     module InputBase
       class ComponentFactory < Base::ComponentFactory
+        class << self
+          def enable_no_children_error
+            @enable_no_children_error = true
+          end
+
+          def disable_no_children_error
+            @enable_no_children_error = false
+          end
+
+          def enable_no_children_error?
+            @enable_no_children_error.nil? || @enable_no_children_error
+          end
+        end
+
         attr_setter :loaders
 
         private
@@ -27,8 +41,13 @@ module RgGen
         end
 
         def find_loader(file)
-          loader = loaders.find { |l| l.support?(file) }
-          loader || (raise Core::LoadError.new('unsupported file type', file))
+          loaders.find { |l| l.support?(file) } ||
+            (raise Core::LoadError.new('unsupported file type', file))
+        end
+
+        def valid_value_lists
+          component_factories
+            .transform_values(&->(f) { f.valid_value_list })
         end
 
         def create_input_data(&block)
@@ -58,9 +77,23 @@ module RgGen
         end
 
         def post_build(component)
+          exist_no_children?(component) &&
+            raise_no_children_error(component)
           component.verify(:component)
         end
 
+        def exist_no_children?(component)
+          enable_no_children_error? &&
+            component.need_children? && component.children.empty?
+        end
+
+        def enable_no_children_error?
+          self.class.enable_no_children_error?
+        end
+
+        def raise_no_children_error(_component)
+        end
+
         def finalize(component)
           component.verify(:all)
         end
@@ -77,10 +110,8 @@ module RgGen
 
         protected
 
-        def valid_value_lists
-          list = [Array(active_feature_factories&.keys)]
-          list.concat(Array(child_factory&.valid_value_lists))
-          list
+        def valid_value_list
+          Array(active_feature_factories&.keys)
         end
       end
     end

data/lib/rggen/core/input_base/feature.rb

@@ -80,9 +80,9 @@ module RgGen
           end
 
           def export_verifiers(subclass)
-            copied_verifiers =
-              @verifiers.map { |scope, blocks| [scope, blocks.dup] }.to_h
-            subclass.instance_variable_set(:@verifiers, copied_verifiers)
+            subclass.instance_variable_set(
+              :@verifiers, @verifiers.transform_values(&:dup)
+            )
           end
         end
 

data/lib/rggen/core/input_base/input_data.rb

@@ -4,7 +4,8 @@ module RgGen
   module Core
     module InputBase
       class InputData
-        def initialize(valid_value_lists)
+        def initialize(layer, valid_value_lists)
+          @layer = layer
           @valid_value_lists = valid_value_lists
           @values = Hash.new(NAValue)
           @children = []
@@ -12,6 +13,8 @@ module RgGen
           block_given? && yield(self)
         end
 
+        attr_reader :layer
+
         def value(value_name, value, position = nil)
           symbolized_name = value_name.to_sym
           return unless valid_value?(symbolized_name)
@@ -24,8 +27,8 @@ module RgGen
             end
         end
 
-        def []=(value_name, position = nil, value)
-          value(value_name, value, position)
+        def []=(value_name, position_or_value, value = nil)
+          value(value_name, value || position_or_value, position_or_value)
         end
 
         def [](value_name)
@@ -39,8 +42,8 @@ module RgGen
 
         attr_reader :children
 
-        def child(value_list = nil, &block)
-          create_child_data do |child_data|
+        def child(layer, value_list = nil, &block)
+          create_child_data(layer) do |child_data|
             child_data.build_by_block(block)
             child_data.values(value_list)
             @children << child_data
@@ -56,11 +59,11 @@ module RgGen
         private
 
         def valid_value?(value_name)
-          @valid_value_lists.first.include?(value_name)
+          @valid_value_lists[layer].include?(value_name)
         end
 
         def define_setter_methods
-          @valid_value_lists.first.each(&method(:define_setter_method))
+          @valid_value_lists[layer].each(&method(:define_setter_method))
         end
 
         def define_setter_method(value_name)
@@ -79,12 +82,12 @@ module RgGen
           locations[0].path.include?('docile') ? locations[1] : locations[0]
         end
 
-        def create_child_data(&block)
-          child_data_class.new(@valid_value_lists[1..-1], &block)
+        def create_child_data(layer, &block)
+          child_data_class.new(layer, @valid_value_lists, &block)
         end
 
         def child_data_class
-          InputData
+          self.class
         end
 
         protected