rggen-core 0.19.0 → 0.20.0

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

@@ -25,9 +25,8 @@ module RgGen
         end
 
         def load_file(file)
-          File.readable?(file) || (
-            raise Core::LoadError.new('cannot load such file', file)
-          )
+          File.readable?(file) ||
+            (raise Core::LoadError.new('cannot load such file', file))
           format(read_file(file), file)
         end
 

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

@@ -26,13 +26,14 @@ module RgGen
 
           def symbolize_keys(result)
             if result.is_a? Hash
-              result.keys.each do |key|
-                result[key.to_sym] = symbolize_keys(result.delete(key))
+              result.each_with_object({}) do |(key, value), hash|
+                hash[key.to_sym] = symbolize_keys(value)
               end
             elsif result.is_a? Array
-              result.map! { |value| symbolize_keys(value) }
+              result.map(&method(:symbolize_keys))
+            else
+              result
             end
-            result
           end
         end
 

data/lib/rggen/core/output_base/code_generator.rb

@@ -9,11 +9,10 @@ module RgGen
           code_blocks[kind] << block
         end
 
-        def generate(context, kind, code)
-          return code unless generatable?(kind)
-          execute_code_blocks(
-            context, kind, code || context.create_blank_code
-          )
+        def generate(context, code, kind)
+          code_blocks[kind].each do |block|
+            execute_code_block(context, code, block)
+          end
         end
 
         def copy
@@ -28,30 +27,18 @@ module RgGen
           @code_blocks ||= Hash.new { |blocks, kind| blocks[kind] = [] }
         end
 
-        def generatable?(kind)
-          @code_blocks&.key?(kind)
-        end
-
-        def execute_code_blocks(context, kind, code)
-          code_blocks[kind].each(&code_block_executor(context, code))
-          code
-        end
-
-        def code_block_executor(context, code)
-          lambda do |block|
-            if block.arity.zero?
-              code << context.instance_exec(&block)
-            else
-              context.instance_exec(code, &block)
-            end
+        def execute_code_block(context, code, block)
+          if block.arity.zero?
+            code << context.instance_exec(&block)
+          else
+            context .instance_exec(code, &block)
           end
         end
 
         protected
 
         def copy_code_blocks(original_blocks)
-          original_blocks
-            .each { |kind, blocks| code_blocks[kind] = blocks.dup }
+          original_blocks.each { |kind, blocks| code_blocks[kind] = blocks.dup }
         end
       end
     end

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

@@ -4,22 +4,21 @@ module RgGen
   module Core
     module OutputBase
       class Component < Base::Component
-        include Base::HierarchicalAccessors
+        include Base::ComponentLayerExtension
 
         attr_reader :configuration
-        attr_reader :source
+        attr_reader :register_map
 
-        def post_initialize(_paren, configuration, source)
+        def post_initialize(configuration, register_map)
           @configuration = configuration
-          @source = source
-          @need_children = source.need_children?
-          define_hierarchical_accessors
-          define_children_presense_indicator
-          define_proxy_calls(@source, @source.properties)
+          @register_map = register_map
+          @need_children = register_map.need_children?
+          define_layer_methods
+          define_proxy_calls(@register_map, @register_map.properties)
         end
 
         def children?
-          !source.children.empty?
+          !register_map.children.empty?
         end
 
         def add_feature(feature)
@@ -28,7 +27,7 @@ module RgGen
         end
 
         def printables
-          @source.printables
+          register_map.printables
         end
 
         def pre_build
@@ -40,8 +39,9 @@ module RgGen
           @children.each(&:build)
         end
 
-        def generate_code(kind, mode, code = nil)
-          code_generators(kind, mode).inject(code) { |c, g| g[c] }
+        def generate_code(code, kind, mode, target_or_range = nil, depth = 0)
+          code_generator_contexts(kind, mode, target_or_range, depth)
+            .each { |context| context.generate(code) }
         end
 
         def write_file(directory = nil)
@@ -51,18 +51,6 @@ module RgGen
 
         private
 
-        INDICATOR_NAMES = {
-          register_map: :register_blocks?,
-          register_block: :registers?,
-          register: :bit_fields?
-        }.freeze
-
-        def define_children_presense_indicator
-          indicator_name = INDICATOR_NAMES[hierarchy]
-          indicator_name &&
-            singleton_exec { alias_method indicator_name, :children? }
-        end
-
         def build_feature(feature)
           feature.build
           import_feature_methods(feature, :object)
@@ -73,25 +61,40 @@ module RgGen
           define_proxy_calls(feature, methods)
         end
 
-        def code_generators(kind, mode)
+        CodeGeneratorContext = Struct.new(:receivers, :args) do
+          def generate(code)
+            receivers.each { |receiver| receiver.generate_code(code, *args) }
+          end
+        end
+
+        def code_generator_contexts(kind, mode, target_or_range, depth)
           [
-            [@features.each_value, [:pre_code, kind]],
-            *main_code_contexts(kind, mode),
-            [@features.each_value, [:post_code, kind]]
-          ].map do |receivers, args|
-            lambda do |code|
-              receivers.inject(code) { |c, r| r.generate_code(*args, c) }
-            end
+            feature_code_generator_context(:pre_code, kind, target_or_range, depth),
+            *main_code_generator_contexts(kind, mode, target_or_range, depth),
+            feature_code_generator_context(:post_code, kind, target_or_range, depth)
+          ].compact
+        end
+
+        def feature_code_generator_context(phase, kind, target_or_range, depth)
+          (target_depth?(depth, target_or_range) || nil) &&
+            CodeGeneratorContext.new(@features.each_value, [phase, kind])
+        end
+
+        def target_depth?(depth, target_or_range)
+          if target_or_range.nil?
+            true
+          elsif target_or_range.respond_to?(:include?)
+            target_or_range.include?(depth)
+          else
+            depth == target_or_range
           end
         end
 
-        def main_code_contexts(kind, mode)
-          contexts = [
-            [@features.each_value, [:main_code, kind]],
-            [@children, [kind, mode]]
-          ]
-          contexts.reverse! if mode == :bottom_up
-          contexts
+        def main_code_generator_contexts(kind, mode, target_or_range, depth)
+          [
+            feature_code_generator_context(:main_code, kind, target_or_range, depth),
+            CodeGeneratorContext.new(@children, [kind, mode, target_or_range, depth + 1])
+          ].tap { |contexts| mode == :bottom_up && contexts.reverse! }
         end
       end
     end

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

@@ -22,6 +22,10 @@ module RgGen
           end
         end
 
+        def find_child_factory(_configuration, register_map)
+          component_factories[register_map.layer]
+        end
+
         def post_build(component)
           component.pre_build
         end

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

@@ -4,7 +4,7 @@ module RgGen
   module Core
     module OutputBase
       class Feature < Base::Feature
-        include Base::HierarchicalFeatureAccessors
+        include Base::FeatureLayerExtension
         include RaiseError
 
         class << self
@@ -64,9 +64,8 @@ module RgGen
 
           def export(*methods)
             methods.each do |method|
-              exported_methods.include?(method) || (
-                exported_methods << method
-              )
+              exported_methods.include?(method) ||
+                (exported_methods << method)
             end
           end
         end
@@ -90,7 +89,7 @@ module RgGen
         end
 
         def post_initialize
-          define_hierarchical_accessors
+          define_layer_methods
         end
 
         def pre_build
@@ -122,9 +121,9 @@ module RgGen
           end
         end
 
-        def generate_code(phase, kind, code = nil)
+        def generate_code(code, phase, kind)
           generator = self.class.code_generators[phase]
-          (generator&.generate(self, kind, code)) || code
+          generator&.generate(self, code, kind)
         end
 
         def write_file(directory = nil)

data/lib/rggen/core/register_map.rb

@@ -6,10 +6,10 @@ module RgGen
       def self.setup(builder)
         builder.input_component_registry(:register_map) do
           register_component [
-            :register_map, :register_block, :register, :bit_field
-          ] do |category|
+            :root, :register_block, :register_file, :register, :bit_field
+          ] do |layer|
             component Component, ComponentFactory
-            feature Feature, FeatureFactory if category != :register_map
+            feature Feature, FeatureFactory if layer != :root
           end
 
           base_loader Loader

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

@@ -4,15 +4,16 @@ module RgGen
   module Core
     module RegisterMap
       class Component < InputBase::Component
-        include Base::HierarchicalAccessors
+        include Base::ComponentLayerExtension
 
         attr_reader :configuration
 
         private
 
-        def post_initialize(_parent, configuration)
+        def post_initialize(configuration)
           @configuration = configuration
-          define_hierarchical_accessors
+          define_layer_methods
+          layer == :bit_field && need_no_children
         end
       end
     end

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

@@ -4,6 +4,8 @@ module RgGen
   module Core
     module RegisterMap
       class ComponentFactory < InputBase::ComponentFactory
+        include RaiseError
+
         private
 
         def select_actual_sources(configuration, *_)
@@ -11,7 +13,22 @@ module RgGen
         end
 
         def create_input_data(&block)
-          RegisterMapData.new(valid_value_lists, &block)
+          InputData.new(:root, valid_value_lists, &block)
+        end
+
+        def find_child_factory(_configuration, register_map)
+          component_factories[register_map.layer]
+        end
+
+        NO_CHILDREN_ERROR_MESSAGES = {
+          root: 'no register blocks are given',
+          register_block: 'neither register files nor registers are given',
+          register_file: 'neither register files nor registers are given',
+          register: 'no bit fields are given'
+        }.freeze
+
+        def raise_no_children_error(comoponent)
+          error(NO_CHILDREN_ERROR_MESSAGES[comoponent.layer])
         end
       end
     end

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

@@ -4,7 +4,7 @@ module RgGen
   module Core
     module RegisterMap
       class Feature < InputBase::Feature
-        include Base::HierarchicalFeatureAccessors
+        include Base::FeatureLayerExtension
         include RaiseError
 
         private
@@ -14,7 +14,7 @@ module RgGen
         end
 
         def post_initialize
-          define_hierarchical_accessors
+          define_layer_methods
         end
       end
     end

data/lib/rggen/core/register_map/hash_loader.rb

@@ -5,41 +5,34 @@ module RgGen
     module RegisterMap
       module HashLoader
         def format(read_data, file)
-          format_data(:register_map, register_map, read_data, file)
+          format_data(:root, root, read_data, file)
         rescue TypeError => e
           raise Core::LoadError.new(e.message, file)
         end
 
         private
 
-        CHILD_HIERARCHY = {
-          register_map: :register_block,
-          register_block: :register,
-          register: :bit_field
+        LAYER_MAP = {
+          root: { register_blocks: :register_block },
+          register_block: { register_files: :register_file, registers: :register },
+          register_file: { register_files: :register_file, registers: :register },
+          register: { bit_fields: :bit_field }
         }.freeze
 
-        CHILD_HIERARCHY_KEY = {
-          register_map: :register_blocks,
-          register_block: :registers,
-          register: :bit_fields
-        }.freeze
-
-        def format_data(hierarchy, input_data, read_data, file)
+        def format_data(layer, input_data, read_data, file)
           read_data = Hash(read_data)
           input_data.values(read_data, file)
-          read_data_for_child(hierarchy, read_data).each do |data|
-            format_data(
-              CHILD_HIERARCHY[hierarchy],
-              input_data.child,
-              data,
-              file
-            )
-          end
+          format_next_layer_data(layer, input_data, read_data, file)
         end
 
-        def read_data_for_child(hierarchy, read_data)
-          key = CHILD_HIERARCHY_KEY[hierarchy]
-          Array(key && read_data[key])
+        def format_next_layer_data(layer, input_data, read_data, file)
+          LAYER_MAP[layer]&.each do |key, next_layer|
+            Array(read_data[key]).each do |data|
+              format_data(
+                next_layer, input_data.child(next_layer), data, file
+              )
+            end
+          end
         end
       end
     end

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

@@ -3,30 +3,44 @@
 module RgGen
   module Core
     module RegisterMap
-      class BitFieldData < InputBase::InputData
-      end
+      class InputData < InputBase::InputData
+        module Root
+          def register_block(value_list = nil, &block)
+            child(:register_block, value_list, &block)
+          end
+        end
 
-      class RegisterData < InputBase::InputData
-        alias_method :bit_field, :child
+        module RegisterBlockRegisterFile
+          def register_file(value_list = nil, &block)
+            child(:register_file, value_list, &block)
+          end
 
-        def child_data_class
-          BitFieldData
+          def register(value_list = nil, &block)
+            child(:register, value_list, &block)
+          end
         end
-      end
 
-      class RegisterBlockData < InputBase::InputData
-        alias_method :register, :child
+        module Register
+          def bit_field(value_list = nil, &block)
+            child(:bit_field, value_list, &block)
+          end
+        end
 
-        def child_data_class
-          RegisterData
+        module BitField
+          def self.extended(object)
+            object.singleton_exec { undef_method :child }
+          end
         end
-      end
 
-      class RegisterMapData < InputBase::InputData
-        alias_method :register_block, :child
+        LAYER_EXTENSIONS = {
+          root: Root, register_block: RegisterBlockRegisterFile,
+          register_file: RegisterBlockRegisterFile, register: Register,
+          bit_field: BitField
+        }.freeze
 
-        def child_data_class
-          RegisterBlockData
+        def initialize(layer, valid_value_list)
+          extend(LAYER_EXTENSIONS[layer])
+          super
         end
       end
     end