rggen-core 0.16.0 → 0.21.0

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

@@ -6,34 +6,39 @@ module RgGen
       module YAMLLoader
         private
 
-        def load_yaml(file)
-          result = yaml_safe_load(File.binread(file), file)
-          symbolize_key(result)
-        end
-
-        if Psych::VERSION >= '3.1.0'
+        if RUBY_VERSION >= '2.6.0'
           def yaml_safe_load(yaml, file)
             YAML.safe_load(
               yaml,
-              permitted_classes: [Symbol], aliases: true, filename: file
+              permitted_classes: [Symbol], aliases: true, filename: file,
+              symbolize_names: true
             )
           end
+        elsif RUBY_VERSION >= '2.5.0'
+          def yaml_safe_load(yaml, file)
+            YAML.safe_load(yaml, [Symbol], [], true, file, symbolize_names: true)
+          end
         else
           def yaml_safe_load(yaml, file)
-            YAML.safe_load(yaml, [Symbol], [], true, file)
+            reuslt = YAML.safe_load(yaml, [Symbol], [], true, file)
+            symbolize_keys(reuslt)
           end
-        end
 
-        def symbolize_key(result)
-          case result
-          when Hash
-            result.keys.each do |key|
-              result[key.to_sym] = symbolize_key(result.delete(key))
+          def symbolize_keys(result)
+            if result.is_a? Hash
+              result.each_with_object({}) do |(key, value), hash|
+                hash[key.to_sym] = symbolize_keys(value)
+              end
+            elsif result.is_a? Array
+              result.map(&method(:symbolize_keys))
+            else
+              result
             end
-          when Array
-            result.map! { |value| symbolize_key(value) }
           end
-          result
+        end
+
+        def load_yaml(file)
+          yaml_safe_load(File.binread(file), file)
         end
       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/printers.rb

@@ -19,7 +19,7 @@ module RgGen
 
       def run(builder, options)
         verbose? && load_setup_file(builder, options[:setup])
-        puts help_message(builder)
+        puts version_message(builder)
       end
 
       private
@@ -32,7 +32,7 @@ module RgGen
         file.nil? || file.empty? || builder.load_setup_file(file, false)
       end
 
-      def help_message(builder)
+      def version_message(builder)
         [
           simple_version,
           *(verbose? && verbose_version(builder) || nil)

data/lib/rggen/core/register_map.rb

@@ -6,14 +6,15 @@ 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
-          register_loaders [RubyLoader, JSONLoader, YAMLLoader]
+          register_loader :ruby, RubyLoader
+          register_loader :yaml, YAMLLoader
+          register_loader :json, JSONLoader
         end
       end
     end

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

@@ -4,42 +4,76 @@ module RgGen
   module Core
     module RegisterMap
       module HashLoader
-        def format(read_data, file)
-          format_data(:register_map, register_map, 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
+        SUB_LAYER_KEYS = {
+          root: [:register_block, :register_blocks],
+          register_block: [:register_file, :register_files, :register, :registers],
+          register_file: [:register_file, :register_files, :register, :registers],
+          register: [:bit_field, :bit_fields]
         }.freeze
 
-        CHILD_HIERARCHY_KEY = {
-          register_map: :register_blocks,
-          register_block: :registers,
-          register: :bit_fields
+        SUB_LAYER_KEY_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
 
-        def format_data(hierarchy, 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
-            )
+        def format_layer_data(read_data, layer, file)
+          if read_data.is_a?(Array)
+            format_array_layer_data(read_data, layer, file)
+          else
+            fomrat_hash_layer_data(read_data, layer, file)
+          end
+        end
+
+        def format_array_layer_data(read_data, layer, file)
+          read_data.each_with_object({}) do |data, layer_data|
+            layer_data.merge!(fomrat_hash_layer_data(data, layer, file))
+          end
+        end
+
+        def fomrat_hash_layer_data(read_data, layer, file)
+          convert_to_hash(read_data, file)
+            .reject { |key, _| SUB_LAYER_KEYS[layer]&.include?(key) }
+        end
+
+        def format_sub_layer_data(read_data, layer, file)
+          if read_data.is_a?(Array)
+            format_array_sub_layer_data(read_data, layer, file)
+          else
+            format_hash_sub_layer_data(read_data, layer, file)
+          end
+        end
+
+        def format_array_sub_layer_data(read_data, layer, file)
+          read_data.each_with_object({}) do |data, sub_layer_data|
+            format_hash_sub_layer_data(data, layer, file, sub_layer_data)
           end
         end
 
-        def read_data_for_child(hierarchy, read_data)
-          key = CHILD_HIERARCHY_KEY[hierarchy]
-          Array(key && read_data[key])
+        def format_hash_sub_layer_data(read_data, layer, file, sub_layer_data = {})
+          convert_to_hash(read_data, file)
+            .select { |key, _| SUB_LAYER_KEYS[layer]&.include?(key) }
+            .each do |key, value|
+              merge_sub_layer_data(sub_layer_data, layer, key, value)
+            end
+          sub_layer_data
+        end
+
+        def merge_sub_layer_data(sub_layer_data, layer, key, value)
+          if SUB_LAYER_KEY_MAP[layer].key?(key)
+            (sub_layer_data[SUB_LAYER_KEY_MAP[layer][key]] ||= []).concat(value)
+          else
+            (sub_layer_data[key] ||= []) << value
+          end
+        end
+
+        def convert_to_hash(read_data, file)
+          Hash(read_data)
+        rescue TypeError => e
+          raise Core::LoadError.new(e.message, file)
         end
       end
     end