rggen-core 0.33.0 → 0.34.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2aeafc6b9c5006079ba7092d6546ac9218c70ce3a23177cae0dcd5d1d3311077
-  data.tar.gz: 4619ca5a98de243ba83a1181d50d0588818c3d8c28b8d46e41c9af7b50f3c711
+  metadata.gz: 86d2fa5fdfb9614f951da1504aba34a38170c0905360b6d18fc494015503a370
+  data.tar.gz: 607f2e2c60a1e6680d93d9bdf93110c47b8c20451e7f5d816b3460c42f1be315
 SHA512:
-  metadata.gz: 4dd425f916899d6432598ee00ba5b03f859108bb30f50782fdd66c9fa52b13ea7d2aa33200375e63dc166e9bda63bd607e14a8da7852d11dfa0d26d729631e3c
-  data.tar.gz: a258aa368135ae231c015c13a6892fc7e3520aeec5e12296f834ca26278beb3cc61b3e4d48f0ee64d56e1dad64faa02159c220f55ce93dbbb41ad98b17cc5dc2
+  metadata.gz: 34cb517f2fd07a2da84be0f9987d783cd4402b82c84f553de23b595bf81691cfae8e2870e95c3cc6e550dd74ab326f717951bf3453ddbf961c8e4f4fca1d4a6a
+  data.tar.gz: 3d2c506953dceb732293a141f6b33e78d5bcf38ea72fab8babe38f0097ec79c1fe8f44410417015a3a07c28f1423bacc4550522e7873e7587ed82215e2043389

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2024 Taichi Ishitani
+Copyright (c) 2017-2025 Taichi Ishitani
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -44,7 +44,7 @@ Feedbacks, bug reports, questions and etc. are wellcome! You can post them by us
 
 ## Copyright & License
 
-Copyright © 2017-2024 Taichi Ishitani. RgGen::Core is licensed under the [MIT License](https://opensource.org/licenses/MIT), see [LICENSE](LICENSE) for futher details.
+Copyright © 2017-2025 Taichi Ishitani. RgGen::Core is licensed under the [MIT License](https://opensource.org/licenses/MIT), see [LICENSE](LICENSE) for futher details.
 
 ## Code of Conduct
 

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

@@ -41,10 +41,10 @@ module RgGen
           @root_factory
         end
 
-        def create_component(parent, sources, &block)
+        def create_component(parent, sources, &)
           actual_sources = Array(select_actual_sources(*sources))
           create_component?(*actual_sources) &&
-            @target_component.new(parent, component_name, layer, *actual_sources, &block)
+            @target_component.new(parent, component_name, layer, *actual_sources, &)
         end
 
         def select_actual_sources(*_sources)

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

@@ -4,6 +4,7 @@ module RgGen
   module Core
     module Base
       class Feature
+        extend FeatureVariable
         extend InternalStruct
         extend SharedContext
         extend Forwardable
@@ -36,12 +37,12 @@ module RgGen
 
           private
 
-          def define_helpers(&body)
-            singleton_class.class_exec(&body)
+          def define_helpers(&)
+            singleton_class.class_exec(&)
           end
 
-          def available?(&body)
-            define_method(:available?, &body)
+          def available?(&)
+            define_method(:available?, &)
           end
         end
 

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Base
+      module FeatureVariable
+        module IncludeMethods
+          private
+
+          def feaure_scala_variable_get(name)
+            self.class.feaure_scala_variable_get(name)
+          end
+
+          def feature_array_variable_get(name)
+            self.class.feature_array_variable_get(name)
+          end
+
+          def feature_hash_variable_get(name)
+            self.class.feature_hash_variable_get(name)
+          end
+
+          def feature_hash_array_variable_get(name)
+            self.class.feature_hash_array_variable_get(name)
+          end
+        end
+
+        def self.extended(klass)
+          klass.include(IncludeMethods)
+        end
+
+        def feaure_scala_variable_get(name)
+          if instance_variable_defined?(name)
+            instance_variable_get(name)
+          else
+            parent_feature_variable_get(__method__, name)
+          end
+        end
+
+        def feature_array_variable_get(name)
+          parent = parent_feature_variable_get(__method__, name)
+          own = instance_variable_get(name)
+
+          if [parent, own] in [Array, Array]
+            [*parent, *own]
+          else
+            parent || own
+          end
+        end
+
+        def feature_hash_variable_get(name)
+          parent = parent_feature_variable_get(__method__, name)
+          own = instance_variable_get(name)
+
+          if [parent, own] in [Hash, Hash]
+            parent.merge(own)
+          else
+            parent || own
+          end
+        end
+
+        def feature_hash_array_variable_get(name)
+          parent = parent_feature_variable_get(__method__, name)
+          own = instance_variable_get(name)
+
+          if [parent, own] in [Hash, Hash]
+            parent
+              .merge(own) { |_, parent_val, own_val| [*parent_val, *own_val] }
+          else
+            parent || own
+          end
+        end
+
+        private
+
+        def feature_array_variable_push(name, value)
+          array =
+            instance_variable_get(name) ||
+            instance_variable_set(name, [])
+          array << value
+        end
+
+        def feature_hash_variable_store(name, key, value)
+          hash =
+            instance_variable_get(name) ||
+            instance_variable_set(name, {})
+          hash[key] = value
+        end
+
+        def feature_hash_array_variable_update(name, method, key, value)
+          hash =
+            instance_variable_get(name) ||
+            instance_variable_set(name, Hash.new { |h, k| h[k] = [] })
+          hash[key].__send__(method, value)
+        end
+
+        def feature_hash_array_variable_push(name, key, value)
+          feature_hash_array_variable_update(name, :push, key, value)
+        end
+
+        def feature_hash_array_variable_prepend(name, key, value)
+          feature_hash_array_variable_update(name, :prepend, key, value)
+        end
+
+        def parent_feature_variable_get(method, name)
+          return unless superclass.respond_to?(method, true)
+
+          superclass.__send__(method, name)
+        end
+      end
+    end
+  end
+end

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

@@ -6,8 +6,8 @@ module RgGen
       module InternalStruct
         private
 
-        def define_struct(name, members, &body)
-          struct = Struct.new(*members, &body)
+        def define_struct(name, members, &)
+          struct = Struct.new(*members, &)
           define_method(name) { struct }
           private name
         end

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

@@ -14,12 +14,12 @@ module RgGen
 
         attr_reader :plugin_manager
 
-        def input_component_registry(name, &body)
-          component_registry(:input, name, &body)
+        def input_component_registry(name, &)
+          component_registry(:input, name, &)
         end
 
-        def output_component_registry(name, &body)
-          component_registry(:output, name, &body)
+        def output_component_registry(name, &)
+          component_registry(:output, name, &)
         end
 
         [
@@ -95,6 +95,7 @@ module RgGen
         def_delegator :plugin_manager, :load_plugin
         def_delegator :plugin_manager, :load_plugins
         def_delegator :plugin_manager, :setup_plugin
+        def_delegator :plugin_manager, :update_plugin
 
         private
 

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

@@ -10,14 +10,14 @@ module RgGen
           @entries = []
         end
 
-        def register_component(layers = nil, &block)
+        def register_component(layers = nil, &)
           Array(layers || @builder.register_map_layers).each do |layer|
-            @entries << create_new_entry(layer, &block)
+            @entries << create_new_entry(layer, &)
           end
         end
 
-        def register_global_component(&block)
-          @entries << create_new_entry(nil, &block)
+        def register_global_component(&)
+          @entries << create_new_entry(nil, &)
         end
 
         def build_factory
@@ -26,9 +26,9 @@ module RgGen
 
         private
 
-        def create_new_entry(layer, &block)
+        def create_new_entry(layer, &)
           entry = ComponentEntry.new(@component_name, layer)
-          Docile.dsl_eval(entry, layer, &block)
+          Docile.dsl_eval(entry, layer, &)
           add_feature_registry(layer, entry.feature_registry)
           entry
         end

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

@@ -12,8 +12,8 @@ module RgGen
         attr_reader :registry
         attr_reader :name
 
-        def modify(&body)
-          eval_body(&body)
+        def eval_bodies(bodies)
+          bodies.each { |body| eval_body(&body) }
         end
 
         def match_entry_type?(entry_type)
@@ -35,8 +35,8 @@ module RgGen
           end
         end
 
-        def eval_body(&body)
-          block_given? && Docile.dsl_eval(self, @name, &body)
+        def eval_body(&)
+          block_given? && Docile.dsl_eval(self, @name, &)
         end
 
         def target_features(_tergets)

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

@@ -11,36 +11,36 @@ module RgGen
           @enabled_features = {}
         end
 
-        def define_feature(name, context = nil, &body)
-          create_new_entry(:general, name, context, &body)
+        def define_feature(name, context, bodies)
+          create_new_entry(:general, name, context, bodies)
         end
 
-        def define_simple_feature(name, context = nil, &body)
-          create_new_entry(:simple, name, context, &body)
+        def define_simple_feature(name, context, bodies)
+          create_new_entry(:simple, name, context, bodies)
         end
 
-        def define_list_feature(list_name, context = nil, &body)
-          create_new_entry(:list, list_name, context, &body)
+        def define_list_feature(list_name, context, bodies)
+          create_new_entry(:list, list_name, context, bodies)
         end
 
-        def define_list_item_feature(list_name, feature_name, context = nil, &body)
-          list_item_entry(list_name).define_feature(feature_name, context, &body)
+        def define_list_item_feature(list_name, feature_name, context, bodies)
+          list_item_entry(list_name).define_feature(feature_name, context, bodies)
         end
 
-        def modify_feature(name, &body)
-          modify_entry(:general, name, &body)
+        def modify_feature(name, bodies)
+          modify_entry(:general, name, bodies)
         end
 
-        def modify_simple_feature(name, &body)
-          modify_entry(:simple, name, &body)
+        def modify_simple_feature(name, bodies)
+          modify_entry(:simple, name, bodies)
         end
 
-        def modify_list_feature(list_name, &body)
-          modify_entry(:list, list_name, &body)
+        def modify_list_feature(list_name, bodies)
+          modify_entry(:list, list_name, bodies)
         end
 
-        def modify_list_item_feature(list_name, feature_name, &body)
-          list_item_entry(list_name).modify_feature(feature_name, &body)
+        def modify_list_item_feature(list_name, feature_name, bodies)
+          list_item_entry(list_name).modify_feature(feature_name, bodies)
         end
 
         def enable(list_name = nil, feature_names)
@@ -102,17 +102,18 @@ module RgGen
           list: ListFeatureEntry
         }.freeze
 
-        def create_new_entry(type, name, context, &body)
+        def create_new_entry(type, name, context, bodies)
           entry = FEATURE_ENTRIES[type].new(self, name)
-          entry.setup(@base_feature, @factory, context, &body)
+          entry.setup(@base_feature, @factory, context)
+          entry.eval_bodies(bodies)
           @feature_entries[name] = entry
         end
 
-        def modify_entry(type, name, &body)
+        def modify_entry(type, name, bodies)
           entry = @feature_entries[name]
           entry&.match_entry_type?(type) ||
             (raise BuilderError.new("unknown feature: #{name}"))
-          entry.modify(&body)
+          entry.eval_bodies(bodies)
         end
 
         def list_item_entry(list_name)

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

@@ -6,21 +6,20 @@ module RgGen
       class GeneralFeatureEntry < FeatureEntryBase
         include Base::SharedContext
 
-        def setup(base_feature, base_factory, context, &body)
+        def setup(base_feature, base_factory, context)
           @feature = Class.new(base_feature)
           @factory = Class.new(base_factory)
           attach_shared_context(context, @feature, @factory, self)
-          eval_body(&body)
         end
 
-        def define_factory(&body)
-          @factory.class_exec(&body)
+        def define_factory(&)
+          @factory.class_exec(&)
         end
 
         alias_method :factory, :define_factory
 
-        def define_feature(&body)
-          @feature.class_exec(&body)
+        def define_feature(&)
+          @feature.class_exec(&)
         end
 
         alias_method :feature, :define_feature

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

@@ -23,9 +23,9 @@ module RgGen
           block_given? && yield(@loader_registries[loader_type])
         end
 
-        def define_value_extractor(loader_type, layers = nil, value, &body)
+        def define_value_extractor(loader_type, layers = nil, value, &)
           @loader_registries[loader_type]
-            .define_value_extractor(layers, value, &body)
+            .define_value_extractor(layers, value, &)
         end
 
         def build_factory

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

@@ -5,28 +5,50 @@ module RgGen
     module Builder
       class Layer
         class Proxy
-          def initialize(list_name, feature_name)
-            @list_name = list_name
-            @feature_name = feature_name
+          def initialize(**proxy_config)
+            @proxy_config = proxy_config
           end
 
-          attr_reader :list_name
-          attr_reader :feature_name
+          def feature_name
+            @proxy_config[:feature_name]
+          end
+
+          def list_name
+            @proxy_config[:list_name]
+          end
 
           def register_execution(registry, &body)
-            @executions ||= []
-            @executions << { registry: registry, body: body }
+            @executions ||= Hash.new { |h, k| h[k] = [] }
+            @executions[registry] << body
           end
 
-          def execute(layer, method_name, &body)
-            Docile.dsl_eval(layer, &body)
+          def execute(layer, method_name, &)
+            Docile.dsl_eval(layer, &)
             return unless @executions
 
-            args = [list_name, feature_name, layer.shared_context].compact
-            @executions.each do |execution|
-              execution[:registry].__send__(method_name, *args, &execution[:body])
+            args = execution_args(layer)
+            @executions.each do |(registry, bodies)|
+              registry.__send__(method_name, *args, bodies)
             end
           end
+
+          private
+
+          def execution_args(layer)
+            args = []
+            [:list_name, :feature_name, :use_shared_context].each do |key|
+              next unless @proxy_config.key?(key)
+
+              args <<
+                if key != :use_shared_context
+                  @proxy_config[key]
+                elsif @proxy_config[key]
+                  layer.shared_context
+                end
+            end
+
+            args
+          end
         end
 
         def initialize(name)
@@ -39,12 +61,19 @@ module RgGen
           define_proxy_call(name)
         end
 
-        def shared_context(&body)
+        def component(name, &)
+          registory =
+            @feature_registries
+              .fetch(name) { raise BuilderError.new("unknown component: #{name}") }
+          block_given? && @proxy.register_execution(registory, &)
+        end
+
+        def shared_context(&)
           return unless @proxy
 
           if block_given?
             context = current_shared_context(true)
-            context.singleton_exec(&body)
+            context.singleton_exec(&)
           end
 
           current_shared_context(false)
@@ -54,51 +83,53 @@ module RgGen
           @feature_registries.key?(component_name)
         end
 
-        def define_feature(feature_names, &body)
+        def define_feature(feature_names, &)
           Array(feature_names).each do |feature_name|
-            do_proxy_call(__method__, nil, feature_name, &body)
+            do_proxy_call(__method__, feature_name:, use_shared_context: true, &)
           end
         end
 
-        def modify_feature(feature_names, &body)
+        def modify_feature(feature_names, &)
           Array(feature_names).each do |feature_name|
-            do_proxy_call(__method__, nil, feature_name, &body)
+            do_proxy_call(__method__, feature_name:, &)
           end
         end
 
-        def define_simple_feature(feature_names, &body)
+        def define_simple_feature(feature_names, &)
           Array(feature_names).each do |feature_name|
-            do_proxy_call(__method__, nil, feature_name, &body)
+            do_proxy_call(__method__, feature_name:, use_shared_context: true, &)
           end
         end
 
-        def modify_simple_feature(feature_names, &body)
+        def modify_simple_feature(feature_names, &)
           Array(feature_names).each do |feature_name|
-            do_proxy_call(__method__, nil, feature_name, &body)
+            do_proxy_call(__method__, feature_name:, &)
           end
         end
 
-        def define_list_feature(list_names, &body)
+        def define_list_feature(list_names, &)
           Array(list_names).each do |list_name|
-            do_proxy_call(__method__, list_name, nil, &body)
+            do_proxy_call(__method__, list_name:, use_shared_context: true, &)
           end
         end
 
-        def modify_list_feature(list_names, &body)
+        def modify_list_feature(list_names, &)
           Array(list_names).each do |list_name|
-            do_proxy_call(__method__, list_name, nil, &body)
+            do_proxy_call(__method__, list_name:, &)
           end
         end
 
-        def define_list_item_feature(list_name, feature_names, &body)
+        def define_list_item_feature(list_name, feature_names, &)
           Array(feature_names).each do |feature_name|
-            do_proxy_call(__method__, list_name, feature_name, &body)
+            do_proxy_call(
+              __method__, list_name:, feature_name:, use_shared_context: true, &
+            )
           end
         end
 
-        def modify_list_item_feature(list_name, feature_names, &body)
+        def modify_list_item_feature(list_name, feature_names, &)
           Array(feature_names).each do |feature_name|
-            do_proxy_call(__method__, list_name, feature_name, &body)
+            do_proxy_call(__method__, list_name:, feature_name:, &)
           end
         end
 
@@ -126,13 +157,13 @@ module RgGen
 
         def define_proxy_call(name)
           define_singleton_method(name) do |&body|
-            @proxy.register_execution(@feature_registries[__method__], &body)
+            component(__method__, &body)
           end
         end
 
-        def do_proxy_call(method_name, list_name, feature_name, &body)
-          @proxy = Proxy.new(list_name, feature_name)
-          @proxy.execute(self, method_name, &body)
+        def do_proxy_call(method_name, **proxy_config, &)
+          @proxy = Proxy.new(**proxy_config)
+          @proxy.execute(self, method_name, &)
           remove_instance_variable(:@proxy)
         end
 

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

@@ -7,19 +7,18 @@ module RgGen
         include Base::SharedContext
 
         def initialize(registry, name)
-          super(registry, name)
+          super
           @features = {}
         end
 
-        def setup(base_feature, base_factory, context, &body)
+        def setup(base_feature, base_factory, context)
           @base_feature = Class.new(base_feature)
           @factory = Class.new(base_factory)
           attach_shared_context(context, @base_feature, @factory, self)
-          eval_body(&body)
         end
 
-        def define_factory(&body)
-          @factory.class_exec(&body)
+        def define_factory(&)
+          @factory.class_exec(&)
         end
 
         alias_method :factory, :define_factory
@@ -30,22 +29,22 @@ module RgGen
 
         alias_method :base_feature, :define_base_feature
 
-        def define_feature(feature_name, context = nil, &body)
+        def define_feature(feature_name, context, bodies)
           feature = @features[feature_name] = Class.new(@base_feature)
           if context
             feature.method_defined?(:shared_context) &&
               (raise BuilderError.new('shared context has already been set'))
             attach_shared_context(context, feature)
           end
-          body && feature.class_exec(feature_name, &body)
+          eval_feature_bodies(feature, feature_name, bodies)
         end
 
         alias_method :feature, :define_feature
 
-        def modify_feature(feature_name, &body)
+        def modify_feature(feature_name, bodies)
           @features.key?(feature_name) ||
             (raise BuilderError.new("unknown feature: #{feature_name}"))
-          body && @features[feature_name].class_exec(feature_name, &body)
+          eval_feature_bodies(@features[feature_name], feature_name, bodies)
         end
 
         def define_default_feature(&body)
@@ -84,6 +83,10 @@ module RgGen
         def target_feature
           @default_feature
         end
+
+        def eval_feature_bodies(feature, feature_name, bodies)
+          bodies.each { |body| feature.class_exec(feature_name, &body) }
+        end
       end
     end
   end

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

@@ -18,8 +18,8 @@ module RgGen
           @loaders.concat(Array(loaders))
         end
 
-        def define_value_extractor(layers = nil, value, &body)
-          @extractors << create_extractor(layers, value, &body)
+        def define_value_extractor(layers = nil, value, &)
+          @extractors << create_extractor(layers, value, &)
         end
 
         def ignore_value(layers = nil, value)
@@ -38,8 +38,8 @@ module RgGen
 
         private
 
-        def create_extractor(layers, value, &body)
-          Class.new(Core::InputBase::InputValueExtractor, &body).new(layers, value)
+        def create_extractor(layers, value, &)
+          Class.new(Core::InputBase::InputValueExtractor, &).new(layers, value)
         end
       end
     end