rggen-core 0.20.0 → 0.24.0

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

@@ -4,39 +4,83 @@ module RgGen
   module Core
     module InputBase
       class Loader
-        class << self
-          def support_types(types)
-            @support_types = types.map(&:to_sym)
-          end
-
-          def support?(file)
-            file_ext = File.ext(file).to_sym
-            @support_types.any? { |type| type.casecmp?(file_ext) }
-          end
+        def self.support_types(types = nil)
+          types && (@support_types ||= []).concat(types.map(&:to_sym))
+          @support_types
+        end
 
-          def load_file(file, input_data, valid_value_list)
-            new(input_data, valid_value_list).load_file(file)
-          end
+        def initialize(extractors, ignore_values)
+          @extractors = extractors
+          @ignore_values = ignore_values
         end
 
-        def initialize(input_data, valid_value_lists)
-          @input_data = input_data
-          @valid_value_lists = valid_value_lists
+        def support?(file)
+          ext = File.ext(file).to_sym
+          types = self.class.support_types
+          types&.any? { |type| type.casecmp?(ext) } || false
         end
 
-        def load_file(file)
+        def load_file(file, input_data, valid_value_lists)
           File.readable?(file) ||
             (raise Core::LoadError.new('cannot load such file', file))
-          format(read_file(file), file)
+          @input_data = input_data
+          @valid_value_lists = valid_value_lists
+          format(read_file(file), input_data, input_data.layer, file)
         end
 
         private
 
-        def format(_read_data, _file)
+        attr_reader :input_data
+
+        def format(read_data, input_data, layer, file)
+          layer_data =
+            format_layer_data(read_data, layer, file) ||
+            format_layer_data_by_extractors(read_data, layer)
+          layer_data &&
+            input_data.values(filter_layer_data(layer_data, layer), file)
+          format_sub_layer(read_data, input_data, layer, file)
         end
 
-        attr_reader :input_data
-        attr_reader :valid_value_lists
+        def format_sub_layer(read_data, input_data, layer, file)
+          format_sub_layer_data(read_data, layer, file)
+            &.flat_map { |sub_layer, data_array| [sub_layer].product(data_array) }
+            &.each do |(sub_layer, data)|
+              format(data, input_data.child(sub_layer), sub_layer, file)
+            end
+        end
+
+        def format_layer_data(_read_data, _layer, _file)
+        end
+
+        def format_layer_data_by_extractors(read_data, layer)
+          layer_data = {}
+          valid_values(layer).each do |value|
+            @extractors
+              .select { |extractor| extractor.target_value?(layer, value) }
+              .each do |extractor|
+                extract_value(read_data, extractor, layer_data, value)
+              end
+          end
+          layer_data.empty? ? nil : layer_data
+        end
+
+        def extract_value(read_data, extractor, layer_data, value)
+          data = extractor.extract(read_data)
+          data && (layer_data[value] = data)
+        end
+
+        def filter_layer_data(layer_data, layer)
+          layer_data
+            .select { |key, _| valid_values(layer).include?(key) }
+        end
+
+        def format_sub_layer_data(_read_data, _layer, _file)
+        end
+
+        def valid_values(layer)
+          @valid_value_lists[layer]
+            .reject { |value| @ignore_values[layer]&.include?(value) }
+        end
       end
     end
   end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module InputBase
+      module TOMLLoader
+        private
+
+        def load_toml(file)
+          toml = File.binread(file)
+          Tomlrb.parse(toml, symbolize_keys: true)
+        end
+      end
+    end
+  end
+end

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

@@ -25,16 +25,20 @@ module RgGen
           end
 
           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
+            case result
+            when Hash then symbolize_hash(result)
+            when Array then symbolize_array(result)
+            else result
             end
           end
+
+          def symbolize_hash(result)
+            result.map { |key, value| [key.to_sym, symbolize_keys(value)] }.to_h
+          end
+
+          def symbolize_array(result)
+            result.map(&method(:symbolize_keys))
+          end
         end
 
         def load_yaml(file)

data/lib/rggen/core/options.rb

@@ -101,21 +101,19 @@ module RgGen
       end
     end
 
-    Options.add_option(:setup) do |option|
-      option.long_option '--setup FILE'
-      option.default { default_steup_file }
-      option.description 'Specify a Ruby file to set up RgGen tool'
-
-      def option.default_steup_file
-        ENV['RGGEN_DEFAULT_SETUP_FILE'] || define_setup_file_from_const
-      end
+    Options.add_option(:no_default_plugins) do |option|
+      option.long_option '--no-default-plugins'
+      option.default false
+      option.action { |_, options| options[:no_default_plugins] = true }
+      option.description 'Do not load default plugins'
+    end
 
-      def option.define_setup_file_from_const
-        require 'rggen/default_setup_file'
-        RgGen::DEFAULT_SETUP_FILE
-      rescue ::LoadError
-        nil
-      end
+    Options.add_option(:plugins) do |option|
+      option.long_option '--plugin PLUGIN'
+      option.default { [] }
+      option.action { |value, options| options[:plugins] << value }
+      option.description 'Load a RgGen plugin ' \
+                         "(name of plugin/path to 'setup.rb' file)"
     end
 
     Options.add_option(:configuration) do |option|
@@ -152,6 +150,12 @@ module RgGen
       end
     end
 
+    Options.add_option(:print_verbose_info) do |option|
+      option.long_option '--print-verbose-info'
+      option.default false
+      option.description 'Print verbose information when an error occurs'
+    end
+
     Options.add_option(:print_backtrace) do |option|
       option.long_option '--print-backtrace'
       option.default false

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

@@ -31,7 +31,7 @@ module RgGen
           if block.arity.zero?
             code << context.instance_exec(&block)
           else
-            context .instance_exec(code, &block)
+            context.instance_exec(code, &block)
           end
         end
 

data/lib/rggen/core/plugin.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Plugin
+      attr_reader :plugin_spec
+
+      private
+
+      def setup_plugin(name)
+        @plugin_spec = Builder::PluginSpec.new(name, self)
+        block_given? && yield(@plugin_spec)
+      end
+    end
+  end
+end

data/lib/rggen/core/printers.rb

@@ -18,18 +18,20 @@ module RgGen
       end
 
       def run(builder, options)
-        verbose? && load_setup_file(builder, options[:setup])
+        verbose? && load_plugins(builder, options)
         puts version_message(builder)
       end
 
       private
 
-      def verbose?
-        @verbose
+      def load_plugins(builder, options)
+        plugins = options[:plugins]
+        no_default_plugins = options[:no_default_plugins]
+        builder.load_plugins(plugins, no_default_plugins, false)
       end
 
-      def load_setup_file(builder, file)
-        file.nil? || file.empty? || builder.load_setup_file(file, false)
+      def verbose?
+        @verbose
       end
 
       def version_message(builder)
@@ -44,8 +46,10 @@ module RgGen
       end
 
       def verbose_version(builder)
-        ["rggen-core #{Core::VERSION}", *builder.plugins.version_info]
-          .map { |version_info| "  - #{version_info}" }
+        [
+          "rggen-core #{Core::VERSION}",
+          *builder.plugin_manager.version_info
+        ].map { |version_info| "  - #{version_info}" }
       end
     end
   end

data/lib/rggen/core/register_map.rb

@@ -5,15 +5,15 @@ module RgGen
     module RegisterMap
       def self.setup(builder)
         builder.input_component_registry(:register_map) do
-          register_component [
-            :root, :register_block, :register_file, :register, :bit_field
-          ] do |layer|
+          register_component do
             component Component, ComponentFactory
-            feature Feature, FeatureFactory if layer != :root
+            feature Feature, FeatureFactory
           end
 
-          base_loader Loader
-          register_loaders [RubyLoader, JSONLoader, YAMLLoader]
+          register_loader :ruby, RubyLoader
+          register_loader :json, JSONLoader
+          register_loader :toml, TOMLLoader
+          register_loader :yaml, YAMLLoader
         end
       end
     end

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

@@ -4,36 +4,77 @@ module RgGen
   module Core
     module RegisterMap
       module HashLoader
-        def format(read_data, file)
-          format_data(:root, root, read_data, file)
-        rescue TypeError => e
-          raise Core::LoadError.new(e.message, file)
-        end
-
         private
 
-        LAYER_MAP = {
+        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
+
+        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(layer, input_data, read_data, file)
-          read_data = Hash(read_data)
-          input_data.values(read_data, file)
-          format_next_layer_data(layer, input_data, read_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_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
-              )
+        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 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
   end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module RegisterMap
+      class TOMLLoader < Loader
+        include HashLoader
+        include InputBase::TOMLLoader
+
+        support_types [:toml]
+
+        def read_file(file)
+          load_toml(file)
+        end
+      end
+    end
+  end
+end

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

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

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