rggen-core 0.19.0 → 0.23.1

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

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

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

@@ -6,7 +6,7 @@ module RgGen
       class Loader < InputBase::Loader
         private
 
-        def register_map
+        def root
           input_data
         end
       end

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

@@ -7,7 +7,7 @@ module RgGen
         support_types [:rb]
 
         def read_file(file)
-          register_map.load_file(file)
+          root.load_file(file)
         end
       end
     end

data/lib/rggen/core/utility/attribute_setter.rb

@@ -24,6 +24,10 @@ module RgGen
               end
             end
           end
+
+          def inherited(subclass)
+            export_instance_variable(:@attributes, subclass, &:dup)
+          end
         end
 
         def self.included(class_or_module)

data/lib/rggen/core/utility/code_utility.rb

@@ -8,13 +8,15 @@ module RgGen
           code_block
         end
 
-        private
+        module_function
 
         def newline
           "\n"
         end
 
-        alias_method :nl, :newline
+        def nl
+          newline
+        end
 
         def comma
           ','
@@ -36,6 +38,10 @@ module RgGen
           "\"#{expression}\""
         end
 
+        def array_name(name, size)
+          [name, *size&.map { |s| "[#{s}]" }].join
+        end
+
         def code_block(indent = 0, &body)
           CodeBlock.new(indent, &body)
         end

data/lib/rggen/core/utility/error_utility.rb

@@ -4,14 +4,41 @@ module RgGen
   module Core
     module Utility
       module ErrorUtility
-        module_function
+        class MessageComposer
+          def compose(error, verbose, backtrace)
+            lines = []
+            add_basic_info(error, lines)
+            add_verbose_info(error, lines) if verbose
+            add_backtrace(error, lines) if backtrace
+            lines.join("\n")
+          end
+
+          private
+
+          def add_basic_info(error, lines)
+            lines << "[#{error.class.lastname}] #{error}"
+          end
+
+          def add_verbose_info(error, lines)
+            return unless error.respond_to?(:verbose_info)
+            return unless error.verbose_info
+
+            lines << 'verbose information:'
+            error
+              .verbose_info.lines(chomp: true)
+              .each { |info| lines << "    #{info}" }
+          end
 
-        def compose_error_message(error, verbose)
-          lines = []
-          lines << "[#{error.class.lastname}] #{error.message}"
-          verbose &&
+          def add_backtrace(error, lines)
+            lines << 'backtrace:'
             error.backtrace.each { |trace| lines << "    #{trace}" }
-          lines.join("\n")
+          end
+        end
+
+        module_function
+
+        def compose_error_message(error, verbose, backtrace)
+          MessageComposer.new.compose(error, verbose, backtrace)
         end
       end
     end

data/lib/rggen/core/version.rb

@@ -3,8 +3,8 @@
 module RgGen
   module Core
     MAJOR = 0
-    MINOR = 19
-    PATCH = 0
+    MINOR = 23
+    PATCH = 1
     VERSION = "#{MAJOR}.#{MINOR}.#{PATCH}"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rggen-core
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 0.23.1
 platform: ruby
 authors:
 - Taichi Ishitani
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-02-17 00:00:00.000000000 Z
+date: 2020-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: docile
@@ -81,23 +81,24 @@ files:
 - lib/rggen/core.rb
 - lib/rggen/core/base/component.rb
 - lib/rggen/core/base/component_factory.rb
+- lib/rggen/core/base/component_layer_extension.rb
 - lib/rggen/core/base/feature.rb
 - lib/rggen/core/base/feature_factory.rb
-- lib/rggen/core/base/hierarchical_accessors.rb
-- lib/rggen/core/base/hierarchical_feature_accessors.rb
+- lib/rggen/core/base/feature_layer_extension.rb
 - lib/rggen/core/base/internal_struct.rb
 - lib/rggen/core/base/proxy_call.rb
 - lib/rggen/core/base/shared_context.rb
 - lib/rggen/core/builder.rb
 - lib/rggen/core/builder/builder.rb
-- lib/rggen/core/builder/category.rb
 - lib/rggen/core/builder/component_entry.rb
 - lib/rggen/core/builder/component_registry.rb
 - lib/rggen/core/builder/feature_registry.rb
 - lib/rggen/core/builder/input_component_registry.rb
+- lib/rggen/core/builder/layer.rb
 - lib/rggen/core/builder/list_feature_entry.rb
+- lib/rggen/core/builder/loader_registry.rb
 - lib/rggen/core/builder/output_component_registry.rb
-- lib/rggen/core/builder/plugins.rb
+- lib/rggen/core/builder/plugin_manager.rb
 - lib/rggen/core/builder/simple_feature_entry.rb
 - lib/rggen/core/cli.rb
 - lib/rggen/core/configuration.rb
@@ -107,6 +108,7 @@ files:
 - lib/rggen/core/configuration/feature.rb
 - lib/rggen/core/configuration/feature_factory.rb
 - lib/rggen/core/configuration/hash_loader.rb
+- lib/rggen/core/configuration/input_data.rb
 - lib/rggen/core/configuration/json_loader.rb
 - lib/rggen/core/configuration/loader.rb
 - lib/rggen/core/configuration/ruby_loader.rb
@@ -123,6 +125,7 @@ files:
 - lib/rggen/core/input_base/input_data.rb
 - lib/rggen/core/input_base/input_matcher.rb
 - lib/rggen/core/input_base/input_value.rb
+- lib/rggen/core/input_base/input_value_extractor.rb
 - lib/rggen/core/input_base/json_loader.rb
 - lib/rggen/core/input_base/loader.rb
 - lib/rggen/core/input_base/property.rb
@@ -186,5 +189,5 @@ requirements: []
 rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
-summary: rggen-core-0.19.0
+summary: rggen-core-0.23.1
 test_files: []

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

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module RgGen
-  module Core
-    module Base
-      module HierarchicalAccessors
-        module RegisterMap
-          def hierarchy
-            :register_map
-          end
-
-          def register_blocks
-            children
-          end
-
-          def registers
-            register_blocks.flat_map(&:children)
-          end
-
-          def bit_fields
-            registers.flat_map(&:children)
-          end
-        end
-
-        module RegisterBlock
-          def hierarchy
-            :register_block
-          end
-
-          def register_map
-            parent
-          end
-
-          def registers
-            children
-          end
-
-          def bit_fields
-            registers.flat_map(&:children)
-          end
-        end
-
-        module Register
-          def hierarchy
-            :register
-          end
-
-          def register_map
-            register_block.parent
-          end
-
-          def register_block
-            parent
-          end
-
-          def bit_fields
-            children
-          end
-        end
-
-        module BitField
-          def hierarchy
-            :bit_field
-          end
-
-          def register_map
-            register_block.parent
-          end
-
-          def register_block
-            register.parent
-          end
-
-          def register
-            parent
-          end
-        end
-
-        private
-
-        ACCESSOR_EXTENSIONS = [
-          RegisterMap, RegisterBlock, Register, BitField
-        ].freeze
-
-        def define_hierarchical_accessors
-          extend ACCESSOR_EXTENSIONS[level]
-        end
-      end
-    end
-  end
-end