rggen-core 0.19.0 → 0.23.1

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module InputBase
+      class InputValueExtractor
+        def initialize(target_layers, target_value)
+          @target_layers = Array(target_layers)
+          @target_value = target_value
+        end
+
+        class << self
+          attr_reader :extractor
+
+          private
+
+          def extract(&body)
+            @extractor = body
+          end
+        end
+
+        def target_value?(layer, value)
+          value == @target_value &&
+            (@target_layers.empty? || @target_layers.include?(layer))
+        end
+
+        def extract(input_data)
+          body = self.class.extractor
+          instance_exec(input_data, &body)
+        end
+      end
+    end
+  end
+end

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

@@ -4,40 +4,83 @@ module RgGen
   module Core
     module InputBase
       class Loader
-        class << self
-          def support_types(types)
-            @support_types = types.map(&:to_sym)
-          end
+        def self.support_types(types = nil)
+          types && (@support_types ||= []).concat(types.map(&:to_sym))
+          @support_types
+        end
 
-          def support?(file)
-            file_ext = File.ext(file).to_sym
-            @support_types.any? { |type| type.casecmp?(file_ext) }
-          end
+        def initialize(extractors, ignore_values)
+          @extractors = extractors
+          @ignore_values = ignore_values
+        end
 
-          def load_file(file, input_data, valid_value_list)
-            new(input_data, valid_value_list).load_file(file)
-          end
+        def support?(file)
+          ext = File.ext(file).to_sym
+          types = self.class.support_types
+          types&.any? { |type| type.casecmp?(ext) } || false
         end
 
-        def initialize(input_data, valid_value_lists)
+        def load_file(file, input_data, valid_value_lists)
+          File.readable?(file) ||
+            (raise Core::LoadError.new('cannot load such file', file))
           @input_data = input_data
           @valid_value_lists = valid_value_lists
+          format(read_file(file), input_data, input_data.layer, file)
         end
 
-        def load_file(file)
-          File.readable?(file) || (
-            raise Core::LoadError.new('cannot load such file', file)
-          )
-          format(read_file(file), file)
+        private
+
+        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
 
-        private
+        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(_read_data, _file)
+        def format_layer_data(_read_data, _layer, _file)
         end
 
-        attr_reader :input_data
-        attr_reader :valid_value_lists
+        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/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/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

@@ -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

@@ -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