rggen-core 0.33.1 → 0.35.0

data/lib/rggen/core/builder/plugin_manager.rb

@@ -73,8 +73,15 @@ module RgGen
           activation && activate_plugins
         end
 
-        def setup_plugin(plugin_name, &block)
-          @plugins << PluginSpec.new(plugin_name, &block)
+        def setup_plugin(plugin_name, &)
+          @plugins << PluginSpec.new(plugin_name, &)
+        end
+
+        def update_plugin(plugin_name)
+          plugin =
+            find_plugin(plugin_name) ||
+            (raise PluginError.new("unknown plugin: #{plugin_name}"))
+          block_given? && yield(plugin)
         end
 
         def activate_plugins
@@ -83,7 +90,7 @@ module RgGen
         end
 
         def activate_plugin_by_name(plugin_name)
-          @plugins.find { |plugin| plugin.name == plugin_name }
+          find_plugin(plugin_name)
             &.then do |plugin|
               plugin.activate(@builder)
               plugin.activate_additionally(@builder)
@@ -103,6 +110,10 @@ module RgGen
           raise Core::PluginError.new("cannot load such plugin: #{info}")
         end
 
+        def find_plugin(plugin_name)
+          @plugins.find { |plugin| plugin.name == plugin_name }
+        end
+
         def activate_plugin_gem(info)
           if (gemspec = find_gemspec(info))
             gem gemspec.name, gemspec.version

data/lib/rggen/core/builder/simple_feature_entry.rb

@@ -4,8 +4,8 @@ module RgGen
   module Core
     module Builder
       class SimpleFeatureEntry < FeatureEntryBase
-        def setup(base_feature, factory, context, &body)
-          define_feature(base_feature, context, &body)
+        def setup(base_feature, factory, context)
+          define_feature(base_feature, context)
           @factory = factory
         end
 
@@ -15,18 +15,17 @@ module RgGen
           :simple
         end
 
-        def define_feature(base, context, &body)
+        def define_feature(base, context)
           @feature = Class.new(base)
           attach_shared_context(context, @feature)
-          eval_body(&body)
         end
 
         def target_feature
           @feature
         end
 
-        def eval_body(&body)
-          block_given? && @feature.class_exec(@name, &body)
+        def eval_body(&)
+          block_given? && @feature.class_exec(@name, &)
         end
       end
     end

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

@@ -6,8 +6,8 @@ module RgGen
       class ComponentFactory < InputBase::ComponentFactory
         private
 
-        def create_input_data(*_args, &block)
-          InputData.new(valid_value_lists, &block)
+        def create_input_data(*_args, &)
+          InputData.new(valid_value_lists, &)
         end
       end
     end

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

@@ -4,8 +4,6 @@ module RgGen
   module Core
     module Configuration
       class Feature < InputBase::Feature
-        include RaiseError
-
         alias_method :configuration, :component
       end
     end

data/lib/rggen/core/configuration/feature_factory.rb

@@ -4,7 +4,6 @@ module RgGen
   module Core
     module Configuration
       class FeatureFactory < InputBase::FeatureFactory
-        include RaiseError
       end
     end
   end

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

@@ -4,10 +4,8 @@ module RgGen
   module Core
     module Configuration
       class InputData < InputBase::InputData
-        include RaiseError
-
-        def initialize(valid_value_lists, &block)
-          super(nil, valid_value_lists, &block)
+        def initialize(valid_value_lists, &)
+          super(nil, valid_value_lists, &)
         end
 
         undef_method :child

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

@@ -4,7 +4,6 @@ module RgGen
   module Core
     module Configuration
       class Loader < InputBase::Loader
-        include RaiseError
       end
     end
   end

data/lib/rggen/core/core_extensions/kernel.rb

@@ -5,7 +5,7 @@ module Kernel
 
   def Integer(arg, base = 0, exception: true)
     arg = arg.__getobj__ if arg.is_a?(::Delegator)
-    __orignal_Integer(arg, base, exception: exception)
+    __orignal_Integer(arg, base, exception:)
   end
 
   module_function :__orignal_Integer

data/lib/rggen/core/core_extensions/object.rb

@@ -1,13 +1,6 @@
 # frozen_string_literal: true
 
 class Object
-  def export_instance_variable(variable, to)
-    instance_variable_defined?(variable) &&
-      instance_variable_get(variable)
-        .then { |v| block_given? ? yield(v) : v }
-        .then { |v| to.instance_variable_set(variable, v) }
-  end
-
   def singleton_exec(...)
     singleton_class.class_exec(...)
   end

data/lib/rggen/core/dsl.rb

@@ -26,7 +26,8 @@ module RgGen
         :enable,
         :enable_all,
         :delete,
-        :setup_plugin
+        :setup_plugin,
+        :update_plugin
       ].each do |method_name|
         def_delegator :'RgGen.builder', method_name
       end

data/lib/rggen/core/exceptions.rb

@@ -25,13 +25,13 @@ module RgGen
     class PluginError < RgGenError
     end
 
-    class RuntimeError < RgGenError
+    class LoadError < RgGenError
     end
 
-    class LoadError < Core::RuntimeError
+    class SourceError < RgGenError
     end
 
-    class GeneratorError < Core::RuntimeError
+    class GeneratorError < RgGenError
     end
   end
 end

data/lib/rggen/core/generator.rb

@@ -27,8 +27,6 @@ module RgGen
       end
 
       def load_register_map(builder, files)
-        files.empty? &&
-          (raise Core::LoadError.new('no register map files are given'))
         @register_map =
           builder
             .build_factory(:input, :register_map)

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

@@ -4,6 +4,8 @@ module RgGen
   module Core
     module InputBase
       class ComponentFactory < Base::ComponentFactory
+        include RaiseError
+
         class << self
           def enable_no_children_error
             @enable_no_children_error = true
@@ -24,26 +26,35 @@ module RgGen
 
         def preprocess(args)
           if root_factory?
-            [*args[0..-2], load_files(args)]
+            [*args[0..-2], load_inputs(args)]
           else
             args
           end
         end
 
-        def load_files(args)
+        def load_inputs(args)
           files = args.last
           create_input_data(*args[0..-2]) do |input_data|
-            files.each { |file| load_file(file, input_data) }
+            if files.empty?
+              handle_empty_input(input_data)
+            else
+              files.each { |file| load_file(input_data, file) }
+            end
           end
         end
 
-        def load_file(file, input_data)
-          find_loader(file).load_file(file, input_data, valid_value_lists)
+        def handle_empty_input(_input_data)
+        end
+
+        def load_file(input_data, file)
+          loader = find_loader { _1.support?(file) }
+          raise Core::LoadError.new('unsupported file type', file) unless loader
+
+          loader.load_data(input_data, valid_value_lists, file)
         end
 
-        def find_loader(file)
-          loaders.reverse_each.find { |l| l.support?(file) } ||
-            (raise Core::LoadError.new('unsupported file type', file))
+        def find_loader(&)
+          loaders.reverse_each.find(&)
         end
 
         def valid_value_lists
@@ -51,23 +62,24 @@ module RgGen
             .transform_values(&->(f) { f.valid_value_list })
         end
 
-        def create_input_data(*_args, &block)
+        def create_input_data(*_args, &)
         end
 
         def create_features(component, *sources)
-          create_active_features(component, sources.last)
-          create_passive_features(component)
+          create_active_features(component, sources)
+          create_passive_features(component, sources)
         end
 
-        def create_active_features(component, input_data)
+        def create_active_features(component, sources)
           active_feature_factories.each do |name, factory|
-            create_feature(component, factory, input_data[name])
+            input_data = sources.last[name]
+            create_feature(component, factory, *sources[0..-2], input_data)
           end
         end
 
-        def create_passive_features(component)
+        def create_passive_features(component, sources)
           passive_feature_factories.each_value do |factory|
-            create_feature(component, factory)
+            create_feature(component, factory, *sources[0..-2])
           end
         end
 

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

@@ -18,7 +18,7 @@ module RgGen
 
         def error(message, position = nil)
           pos = extract_error_position(position)
-          raise error_exception.new(message, pos)
+          raise SourceError.new(message, pos)
         end
 
         def extract_error_position(position)

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

@@ -6,102 +6,86 @@ module RgGen
       class Feature < Base::Feature
         include Utility::RegexpPatterns
         include Utility::TypeChecker
+        include RaiseError
         include ConversionUtility
 
         class << self
-          def property(name, ...)
-            Property.define(self, name, ...)
-            properties.include?(name) || properties << name
-          end
-
-          alias_method :field, :property
-
           def properties
-            @properties ||= []
+            feature_hash_variable_get(:@properties)&.keys
           end
 
-          def ignore_empty_value(value = nil)
-            @ignore_empty_value = value unless value.nil?
-            @ignore_empty_value
+          def active_feature?
+            !passive_feature?
           end
 
-          def ignore_empty_value?
-            @ignore_empty_value.nil? || @ignore_empty_value
+          def passive_feature?
+            feature_array_variable_get(:@builders).nil?
           end
 
-          def build(&block)
-            (@builders ||= []) << block
-          end
+          private
 
-          attr_reader :builders
+          def property(name, ...)
+            feature_hash_variable_store(:@properties, name, Property.new(name, ...))
+            return if method_defined?(name)
 
-          def post_build(&block)
-            (@post_builders ||= []) << block
+            public alias_method(name, :property_method)
           end
 
-          attr_reader :post_builders
-
-          def active_feature?
-            !passive_feature?
-          end
+          alias_method :field, :property
 
-          def passive_feature?
-            builders.nil?
+          def ignore_empty_value(value)
+            @ignore_empty_value = value
           end
 
-          def input_pattern(pattern_or_patterns, ...)
-            @input_matcher = InputMatcher.new(pattern_or_patterns, ...)
+          def build(&block)
+            feature_array_variable_push(:@builders, block)
           end
 
-          attr_reader :input_matcher
-
-          def verify(scope, &block)
-            @verifiers ||= {}
-            (@verifiers[scope] ||= []) << create_verifier(&block)
+          def post_build(&block)
+            feature_array_variable_push(:@post_builders, block)
           end
 
-          attr_reader :verifiers
-
-          def printable(name, &body)
-            (@printables ||= {})[name] = body
+          def input_pattern(pattern_or_patterns, ...)
+            @input_matcher = InputMatcher.new(pattern_or_patterns, ...)
           end
 
-          attr_reader :printables
-
-          def inherited(subclass)
-            super
-            export_instance_variable(:@properties, subclass, &:dup)
-            export_instance_variable(:@ignore_empty_value, subclass)
-            export_instance_variable(:@builders, subclass, &:dup)
-            export_instance_variable(:@post_builders, subclass, &:dup)
-            export_instance_variable(:@input_matcher, subclass)
-            export_instance_variable(:@printables, subclass, &:dup)
-            export_verifiers(subclass) if @verifiers
+          def verify(scope, prepend: false, &)
+            verifyier = create_verifier(&)
+            if prepend
+              feature_hash_array_variable_prepend(:@verifiers, scope, verifyier)
+            else
+              feature_hash_array_variable_push(:@verifiers, scope, verifyier)
+            end
           end
 
-          private
-
-          def create_verifier(&body)
-            Verifier.new(&body)
+          def create_verifier(&)
+            Verifier.new(&)
           end
 
-          def export_verifiers(subclass)
-            subclass
-              .instance_variable_set(:@verifiers, @verifiers.transform_values(&:dup))
+          def printable(name, &body)
+            feature_hash_variable_store(:@printables, name, body)
           end
         end
 
-        def_delegator :'self.class', :properties
-        def_delegator :'self.class', :active_feature?
-        def_delegator :'self.class', :passive_feature?
-        def_delegator :'self.class', :ignore_empty_value?
+        def properties
+          feature_hash_variable_get(:@properties)&.keys
+        end
 
         def build(*args)
-          self.class.builders && do_build(args)
+          builders = feature_array_variable_get(:@builders)
+          return unless builders
+
+          do_build(builders, args)
         end
 
         def post_build
-          self.class.post_builders&.each { |block| instance_exec(&block) }
+          feature_array_variable_get(:@post_builders)
+            &.each { |block| instance_exec(&block) }
+        end
+
+        def ignore_empty_value?
+          feaure_scala_variable_get(:@ignore_empty_value)
+            .then { _1.nil? || _1 }
         end
 
         def verify(scope)
@@ -109,11 +93,12 @@ module RgGen
         end
 
         def printables
-          helper.printables&.map { |name, body| [name, printable(name, &body)] }
+          feature_hash_variable_get(:@printables)
+            &.map { |name, body| [name, printable(name, &body)] }
         end
 
         def printable?
-          !helper.printables.nil?
+          !feature_hash_variable_get(:@printables).nil?
         end
 
         def inspect
@@ -135,23 +120,31 @@ module RgGen
 
         private
 
-        def do_build(args)
+        def property_method(...)
+          feature_hash_variable_fetch(:@properties, __callee__).evaluate(self, ...)
+        end
+
+        def do_build(builders, args)
           @position = args.last.position
           match_automatically? && match_pattern(args.last)
-          execute_build_blocks(args)
+          execute_build_blocks(builders, args)
         end
 
-        def execute_build_blocks(args)
+        def execute_build_blocks(builders, args)
           args = [*args, args.last.options] if args.last.with_options?
-          self.class.builders.each { |builder| instance_exec(*args, &builder) }
+          builders.each { |builder| instance_exec(*args, &builder) }
+        end
+
+        def input_matcher
+          feaure_scala_variable_get(:@input_matcher)
         end
 
         def match_automatically?
-          self.class.input_matcher&.match_automatically?
+          input_matcher&.match_automatically?
         end
 
         def match_pattern(rhs)
-          @match_data, @match_index = self.class.input_matcher&.match(rhs)
+          @match_data, @match_index = input_matcher&.match(rhs)
         end
 
         attr_reader :match_data
@@ -166,12 +159,15 @@ module RgGen
         end
 
         def do_verify(scope)
-          self.class.verifiers&.[](scope)&.each { |verifier| verifier.verify(self) }
+          verifiers = feature_hash_array_variable_get(:@verifiers)
+          return unless verifiers
+
+          verifiers[scope]&.each { |verifier| verifier.verify(self) }
           (@verified ||= {})[scope] = true
         end
 
-        def printable(name, &body)
-          block_given? ? instance_exec(&body) : __send__(name)
+        def printable(name, &)
+          block_given? ? instance_exec(&) : __send__(name)
         end
       end
     end

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

@@ -5,6 +5,7 @@ module RgGen
     module InputBase
       class FeatureFactory < Base::FeatureFactory
         include Utility::TypeChecker
+        include RaiseError
 
         class << self
           def convert_value(&block)
@@ -66,7 +67,7 @@ module RgGen
 
         def parse_input_value(input_value, value_format)
           format, options = value_format
-          VALUE_PARSERS[format].new(error_exception, **options).parse(input_value)
+          VALUE_PARSERS[format].new(**options).parse(input_value)
         end
 
         def override_input_value(input_value, parsed_value, options)

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

@@ -4,6 +4,8 @@ module RgGen
   module Core
     module InputBase
       class InputData
+        include RaiseError
+
         def initialize(layer, valid_value_lists, *_args)
           @layer = layer
           @valid_value_lists = valid_value_lists
@@ -37,9 +39,9 @@ module RgGen
 
         attr_reader :children
 
-        def child(layer, value_list = nil, &block)
+        def child(layer, value_list = nil, &)
           create_child_data(layer) do |child_data|
-            child_data.build_by_block(&block)
+            child_data.build_by_block(&)
             child_data.values(value_list)
             @children << child_data
           end
@@ -98,8 +100,8 @@ module RgGen
 
         protected
 
-        def build_by_block(&block)
-          block_given? && Docile.dsl_eval(self, &block)
+        def build_by_block(&)
+          block_given? && Docile.dsl_eval(self, &)
         end
       end
     end

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

@@ -5,9 +5,9 @@ module RgGen
     module InputBase
       class InputValueParser
         include Utility::TypeChecker
+        include RaiseError
 
-        def initialize(exception, **_option)
-          @exception = exception
+        def initialize(**_options)
         end
 
         private
@@ -15,16 +15,6 @@ module RgGen
         def split_string(string, separator, limit)
           string&.split(separator, limit)&.map(&:strip)
         end
-
-        def error(message, position_or_input_value = nil)
-          position =
-            if position_or_input_value.respond_to?(:position)
-              position_or_input_value.position
-            else
-              position_or_input_value
-            end
-          raise @exception.new(message, position)
-        end
       end
     end
   end

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

@@ -4,11 +4,17 @@ module RgGen
   module Core
     module InputBase
       class Loader
+        include RaiseError
+
         def self.support_types(types = nil)
           types && (@support_types ||= []).concat(types.map(&:to_sym))
           @support_types
         end
 
+        def self.require_no_input_file
+          @require_input_file = false
+        end
+
         def initialize(extractors, ignore_values)
           @extractors = extractors
           @ignore_values = ignore_values
@@ -20,19 +26,33 @@ module RgGen
           types&.any? { |type| type.casecmp?(ext) } || false
         end
 
-        def load_file(file, input_data, valid_value_lists)
+        def require_input_file?
+          loader = self.class
+          !loader.instance_variable_defined?(:@require_input_file) ||
+            loader.instance_variable_get(:@require_input_file)
+        end
+
+        def load_data(input_data, valid_value_lists, file = nil)
+          if require_input_file?
+            load_file(input_data, valid_value_lists, file)
+          else
+            load_builtin_data(input_data)
+          end
+        end
+
+        def load_file(input_data, valid_value_lists, file)
           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)
+          format_data(read_file(file), input_data, input_data.layer, file)
         end
 
         private
 
         attr_reader :input_data
 
-        def format(read_data, input_data, layer, file)
+        def format_data(read_data, input_data, layer, file)
           layer_data =
             format_layer_data(read_data, layer, file) ||
             format_layer_data_by_extractors(read_data, layer)
@@ -43,7 +63,7 @@ module RgGen
 
         def format_sub_layer(read_data, input_data, layer, file)
           format_sub_layer_data(read_data, layer, file)&.each do |(sub_layer, data)|
-            format(data, input_data.child(sub_layer), sub_layer, file)
+            format_data(data, input_data.child(sub_layer), sub_layer, file)
           end
         end
 

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

@@ -4,7 +4,7 @@ module RgGen
   module Core
     module InputBase
       class OptionHashParser < InputValueParser
-        def initialize(exception, allowed_options: nil, multiple_values: false)
+        def initialize(allowed_options: nil, multiple_values: false)
           super
           @allowed_options = allowed_options
           @multiple_values = multiple_values