rggen-core 0.33.0 → 0.34.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,11 +4,18 @@ module RgGen
   module Core
     module Configuration
       class InputData < InputBase::InputData
-        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
+
+        private
+
+        def raise_unknown_field_error(field_name, position)
+          message = "unknown configuration field is given: #{field_name}"
+          error(message, position)
+        end
       end
     end
   end

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/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
@@ -51,23 +53,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,85 @@ 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_array_variable_get(:@properties)
           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
+          private
+
+          def property(name, ...)
+            Property.define(self, name, ...)
+            properties&.include?(name) ||
+              feature_array_variable_push(:@properties, name)
           end
 
-          attr_reader :builders
+          alias_method :field, :property
 
-          def post_build(&block)
-            (@post_builders ||= []) << block
+          def ignore_empty_value(value)
+            @ignore_empty_value = value
           end
 
-          attr_reader :post_builders
-
-          def active_feature?
-            !passive_feature?
+          def build(&block)
+            feature_array_variable_push(:@builders, block)
           end
 
-          def passive_feature?
-            builders.nil?
+          def post_build(&block)
+            feature_array_variable_push(:@post_builders, block)
           end
 
           def input_pattern(pattern_or_patterns, ...)
             @input_matcher = InputMatcher.new(pattern_or_patterns, ...)
           end
 
-          attr_reader :input_matcher
-
-          def verify(scope, &block)
-            @verifiers ||= {}
-            (@verifiers[scope] ||= []) << create_verifier(&block)
-          end
-
-          attr_reader :verifiers
-
-          def printable(name, &body)
-            (@printables ||= {})[name] = body
+          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
 
-          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 create_verifier(&)
+            Verifier.new(&)
           end
 
-          private
-
-          def create_verifier(&body)
-            Verifier.new(&body)
-          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_array_variable_get(:@properties)
+        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 +92,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 +119,27 @@ module RgGen
 
         private
 
-        def do_build(args)
+        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 +154,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
@@ -17,8 +19,9 @@ module RgGen
 
         def value(value_name, value, position = nil)
           symbolized_name = value_name.to_sym
-          valid_value?(symbolized_name) &&
-            assign_value(symbolized_name, value, position)
+          valid_value?(symbolized_name) ||
+            raise_unknown_field_error(symbolized_name, position)
+          assign_value(symbolized_name, value, position)
         end
 
         def []=(value_name, position = nil, value)
@@ -36,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
@@ -97,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,6 +4,8 @@ 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
@@ -68,7 +70,11 @@ module RgGen
         end
 
         def filter_layer_data(layer_data, layer)
-          layer_data.slice(*valid_values(layer))
+          if @ignore_values.key?(layer)
+            layer_data.except(*@ignore_values[layer])
+          else
+            layer_data
+          end
         end
 
         def format_sub_layer_data(_read_data, _layer, _file)

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

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

@@ -4,18 +4,18 @@ module RgGen
   module Core
     module InputBase
       class Property
-        def self.define(feature, name, **options, &body)
-          new(name, options, &body).define(feature)
+        def self.define(feature, name, **options, &)
+          new(name, options, &).define(feature)
         end
 
-        def initialize(name, options, &body)
+        def initialize(name, options, &)
           @name = name
           @options = options
           @costom_property =
             if options[:body]
               create_costom_property(&options[:body])
             elsif block_given?
-              create_costom_property(&body)
+              create_costom_property(&)
             end
         end
 

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

@@ -4,8 +4,8 @@ module RgGen
   module Core
     module InputBase
       class Verifier
-        def initialize(&block)
-          instance_eval(&block)
+        def initialize(&)
+          instance_eval(&)
         end
 
         def check_error(&block)
@@ -20,6 +20,10 @@ module RgGen
           @message = block
         end
 
+        def position(&block)
+          @position = block
+        end
+
         def verify(feature, *values)
           if @error_checker
             feature.instance_exec(*values, &@error_checker)
@@ -31,8 +35,11 @@ module RgGen
         private
 
         def default_error_check(feature, values)
-          feature.instance_exec(*values, &@condition) &&
-            feature.__send__(:error, feature.instance_exec(*values, &@message))
+          return unless feature.instance_exec(*values, &@condition)
+
+          message = feature.instance_exec(*values, &@message)
+          position = @position && feature.instance_exec(*values, &@position)
+          feature.__send__(:error, message, position)
         end
       end
     end

data/lib/rggen/core/options.rb

@@ -67,8 +67,8 @@ module RgGen
         @options ||= {}
       end
 
-      def self.add_option(option_name, &body)
-        options[option_name] = Option.new(option_name, &body)
+      def self.add_option(option_name, &)
+        options[option_name] = Option.new(option_name, &)
       end
 
       def initialize