rggen-core 0.15.0 → 0.20.0

data/lib/rggen/core/base/feature_layer_extension.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Base
+      module FeatureLayerExtension
+        private
+
+        module Common
+          def root?
+            @component.root?
+          end
+
+          def register_block?
+            @component.register_block?
+          end
+
+          def register_file?
+            @component.register_file?
+          end
+
+          def register?
+            @component.register?
+          end
+
+          def bit_field?
+            @component.bit_field?
+          end
+        end
+
+        module Root
+          include Common
+
+          def root
+            @component
+          end
+        end
+
+        module RegisterBlock
+          include Common
+
+          def root
+            register_block.root
+          end
+
+          def register_block
+            @component
+          end
+
+          def register_blocks
+            root.register_blocks
+          end
+        end
+
+        module RegisterFile
+          include Common
+
+          def root
+            register_file.root
+          end
+
+          def register_block
+            register_file.register_block
+          end
+
+          def block_or_file
+            register_file.block_or_file
+          end
+
+          def register_file(layer = nil)
+            layer == :upper ? @component.register_file : @component
+          end
+
+          def files_and_registers
+            block_or_file.files_and_registers
+          end
+        end
+
+        module Register
+          include Common
+
+          def root
+            register.root
+          end
+
+          def register_block
+            register.register_block
+          end
+
+          def register_file
+            register.register_file
+          end
+
+          def register_files
+            register.register_files
+          end
+
+          def block_or_file
+            register.block_or_file
+          end
+
+          def register
+            @component
+          end
+
+          def files_and_registers
+            block_or_file.files_and_registers
+          end
+        end
+
+        module BitField
+          include Common
+
+          def root
+            bit_field.root
+          end
+
+          def register_block
+            bit_field.register_block
+          end
+
+          def register_file
+            bit_field.register_file
+          end
+
+          def register_files
+            bit_field.register_files
+          end
+
+          def register
+            bit_field.register
+          end
+
+          def bit_field
+            @component
+          end
+
+          def bit_fields
+            register.bit_fields
+          end
+        end
+
+        ACCESSOR_EXTENSIONS = {
+          root: Root,
+          register_block: RegisterBlock,
+          register_file: RegisterFile,
+          register: Register,
+          bit_field: BitField
+        }.freeze
+
+        def define_layer_methods
+          ACCESSOR_EXTENSIONS.key?(component.layer) &&
+            (extend ACCESSOR_EXTENSIONS[component.layer])
+        end
+      end
+    end
+  end
+end

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,6 +6,11 @@ module RgGen
       class ComponentEntry
         Entry = Struct.new(:target, :factory)
 
+        def initialize(component_name, layer)
+          @component_name = component_name
+          @layer = layer
+        end
+
         [:component, :feature].each do |entry_name|
           define_method(entry_name) do |target, factory|
             instance_variable_set("@#{__method__}", Entry.new(target, factory))
@@ -18,7 +23,7 @@ module RgGen
         end
 
         def build_factory
-          @component.factory.new 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

@@ -4,16 +4,16 @@ module RgGen
   module Core
     module Builder
       class ComponentRegistry
-        def initialize(name, builder)
-          @name = name
+        def initialize(component_name, builder)
+          @component_name = component_name
           @builder = builder
           @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,25 +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
-          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(@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