rggen-core 0.24.0 → 0.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 040113a3bef96502aae386b3aa7dafcca07af29d8881b41bfc6e17b3e0769885
-  data.tar.gz: 4392f0ae0bc1cd8d7422606eea73f11dffe293e29cc39250c5fd3479581dc349
+  metadata.gz: fe3a65999b49b800216dea110ca47e81c71cf4fe0a65626f50526be374647713
+  data.tar.gz: 160dbda800f4fef46bbe18ef34810851082d09271eb7754b6b4508eb4f56c8fd
 SHA512:
-  metadata.gz: c77e46129bc726cb7afee6b21b3b31e2a692ee3fa2d99aade8eb6f6a3d1082e4f3fab1c83ff4f20afead532c521dfea6f23c8c6762a0b54ed9ab9cfbf013b484
-  data.tar.gz: c20b96a0be7b1f15cae6cc8b1512d05b83d8f06cb3407b34fe1731221065de3467522bdabfd74b2b5336fcc96b245a9eff191629ff58c61635b8ca77af511be1
+  metadata.gz: eae55af6cdaa6eff67f15ef508dcd32af950d72f18621d0b8769011957c9c6a72c9f3c41557d197a0c1e9fec25ecaff34364f3518cd04c12f22bdb6ee8efa6af
+  data.tar.gz: 3d030a72ade1067dbb7450ff30ef4cffc3d97430e73a4ea96f9fb310a5cb633e314f1a9b280d4c4e615b1fce2ace5f5456f2881bd76a18fa05cef60420989ada

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017-2021 Taichi Ishitani
+Copyright (c) 2017-2022 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-2021 Taichi Ishitani. RgGen::Core is licensed under the [MIT License](https://opensource.org/licenses/MIT), see [LICENSE](LICENSE) for futher details.
+Copyright © 2017-2022 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.rb

@@ -70,15 +70,14 @@ module RgGen
 
         def define_proxy_calls(receiver, methods)
           Array(methods)
-            .map(&:to_sym)
             .each { |method| define_proxy_call(receiver, method) }
         end
 
-        def define_proxy_call(receiver, method)
-          @proxy_calls ||= {}
-          @proxy_calls[method] = ProxyCall.new(receiver, method)
-          define_singleton_method(method) do |*args, &block|
-            @proxy_calls[__method__].call(*args, &block)
+        def define_proxy_call(receiver, method_name)
+          (@proxy_receivers ||= {})[method_name.to_sym] = receiver
+          define_singleton_method(method_name) do |*args, &block|
+            name = __method__
+            @proxy_receivers[name].__send__(name, *args, &block)
           end
         end
       end

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

@@ -27,7 +27,7 @@ module RgGen
             if root_factory?
               [nil, preprocess(args)]
             else
-              [args.first, preprocess(args[1..-1])]
+              [args.first, preprocess(args[1..])]
             end
           create_component(parent, sources) do |component|
             build_component(parent, component, sources)
@@ -43,11 +43,15 @@ module RgGen
 
         def create_component(parent, sources, &block)
           actual_sources = Array(select_actual_sources(*sources))
-          @target_component
-            .new(parent, component_name, layer, *actual_sources, &block)
+          create_component?(*actual_sources) &&
+            @target_component.new(parent, component_name, layer, *actual_sources, &block)
         end
 
-        def select_actual_sources(*sources)
+        def select_actual_sources(*_sources)
+        end
+
+        def create_component?(*_sources)
+          true
         end
 
         def build_component(parent, component, sources)
@@ -88,8 +92,7 @@ module RgGen
         end
 
         def create_child(component, *args)
-          factory = find_child_factory(*args)
-          factory.create(component, *args)
+          find_child_factory(*args).create(component, *args)
         end
       end
     end

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

@@ -43,9 +43,8 @@ module RgGen
             else
               @layers.values
             end
-          target_layers.each do |layer|
-            layer.add_feature_registry(name, registry)
-          end
+          target_layers
+            .each { |layer| layer.add_feature_registry(name, registry) }
         end
 
         [
@@ -79,8 +78,7 @@ module RgGen
             if targets.empty?
               @component_registries[type]
             else
-              @component_registries[type]
-                .select { |name, _| targets.include?(name) }
+              @component_registries[type].slice(*targets)
             end
           registries.each_value.map(&:build_factory)
         end
@@ -130,9 +128,9 @@ module RgGen
 
         def component_registry(type, name, &body)
           registries = @component_registries[type]
-          klass = COMPONENT_REGISTRIES[type]
-          registries.key?(name) || (registries[name] = klass.new(name, self))
-          block_given? && Docile.dsl_eval(registries[name], &body) || registries[name]
+          registries.key?(name) ||
+            (registries[name] = COMPONENT_REGISTRIES[type].new(name, self))
+          body && Docile.dsl_eval(registries[name], &body) || registries[name]
         end
       end
     end

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

@@ -42,7 +42,7 @@ module RgGen
           factories =
             @entries
               .map(&:build_factory)
-              .map { |f| [f.layer, f] }.to_h
+              .to_h { |f| [f.layer, f] }
           factories.each_value { |f| f.component_factories factories }
           factories.values
         end

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

@@ -12,11 +12,11 @@ module RgGen
         end
 
         def define_simple_feature(name, context = nil, &body)
-          create_new_entry(:simple, name, context, body)
+          create_new_entry(:simple, name, context, &body)
         end
 
         def define_list_feature(list_name, context = nil, &body)
-          create_new_entry(:list, list_name, context, body)
+          create_new_entry(:list, list_name, context, &body)
         end
 
         def define_list_item_feature(list_name, feature_name, context = nil, &body)
@@ -88,10 +88,9 @@ module RgGen
         end
 
         def build_factories
-          @enabled_features
-            .select { |n, _| @feature_entries.key?(n) }
-            .map { |n, f| [n, @feature_entries[n].build_factory(f)] }
-            .to_h
+          @feature_entries
+            .slice(*@enabled_features.keys)
+            .transform_values(&method(:build_factory))
         end
 
         private
@@ -100,9 +99,9 @@ module RgGen
           simple: SimpleFeatureEntry, list: ListFeatureEntry
         }.freeze
 
-        def create_new_entry(type, name, context, body)
+        def create_new_entry(type, name, context, &body)
           entry = FEATURE_ENTRIES[type].new(self, name)
-          entry.setup(@base_feature, @factory, context, body)
+          entry.setup(@base_feature, @factory, context, &body)
           @feature_entries[name] = entry
         end
 
@@ -117,6 +116,10 @@ module RgGen
                                 .feature?(feature_name)
           @enabled_features[list_name].include?(feature_name)
         end
+
+        def build_factory(entry)
+          entry.build_factory(@enabled_features[entry.name])
+        end
       end
     end
   end

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

@@ -15,11 +15,11 @@ module RgGen
         attr_reader :registry
         attr_reader :name
 
-        def setup(base_feature, base_factory, context, body)
+        def setup(base_feature, base_factory, context, &body)
           @base_feature = Class.new(base_feature)
           @factory = Class.new(base_factory)
           context && attach_shared_context(context)
-          body && Docile.dsl_eval(self, @name, &body)
+          block_given? && Docile.dsl_eval(self, @name, &body)
         end
 
         def match_entry_type?(entry_type)
@@ -49,9 +49,8 @@ module RgGen
           @features[feature_name] ||= Class.new(@base_feature)
           feature = @features[feature_name]
           if context
-            feature.method_defined?(:shared_context) && (
-              raise BuilderError.new('shared context has already been set')
-            )
+            feature.method_defined?(:shared_context) &&
+              (raise BuilderError.new('shared context has already been set'))
             feature.attach_context(context)
           end
           body && feature.class_exec(feature_name, &body)
@@ -87,10 +86,7 @@ module RgGen
         end
 
         def target_features(enabled_features)
-          enabled_features
-            .select { |n| @features.key?(n) }
-            .map { |n| [n, @features[n]] }
-            .to_h
+          @features.slice(*enabled_features)
         end
       end
     end

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

@@ -19,8 +19,7 @@ module RgGen
         end
 
         def define_value_extractor(layers, value, &body)
-          @extractors <<
-            create_extractor(layers, value, &body)
+          @extractors << create_extractor(layers, value, &body)
         end
 
         def ignore_value(layers, value)

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

@@ -22,26 +22,80 @@ module RgGen
         end
       end
 
+      class PluginInfo
+        attr_reader :name
+        attr_reader :setup_path
+        attr_reader :gem_name
+        attr_reader :version
+
+        def parse(setup_path_or_name, version)
+          setup_path_or_name = setup_path_or_name.to_s.strip
+          @name, @setup_path, @gem_name, @version =
+            if setup_file_directly_given?(setup_path_or_name)
+              [nil, setup_path_or_name, *find_plugin_gem(setup_path_or_name)]
+            else
+              [
+                setup_path_or_name, get_setup_path(setup_path_or_name),
+                extract_gem_name(setup_path_or_name), version
+              ]
+            end
+          self
+        end
+
+        def to_s
+          if name && version
+            "#{name} (#{version})"
+          elsif name
+            name
+          else
+            setup_path
+          end
+        end
+
+        private
+
+        def setup_file_directly_given?(setup_path_or_name)
+          File.ext(setup_path_or_name) == 'rb' ||
+            File.basename(setup_path_or_name, '.*') == 'setup'
+        end
+
+        def find_plugin_gem(setup_path)
+          gemspec =
+            Gem::Specification
+              .each.find { |spec| match_gemspec?(spec, setup_path) }
+          gemspec && [gemspec.name, gemspec.version]
+        end
+
+        def match_gemspec?(gemspec, setup_path)
+          gemspec.full_require_paths.any?(&setup_path.method(:start_with?))
+        end
+
+        def extract_gem_name(plugin_name)
+          plugin_name.split('/', 2).first
+        end
+
+        def get_setup_path(plugin_name)
+          base, sub_directory = plugin_name.split('/', 2)
+          base = base.sub(/^rggen[-_]/, '').tr('-', '_')
+          File.join(*['rggen', base, sub_directory, 'setup'].compact)
+        end
+      end
+
       class PluginManager
         def initialize(builder)
           @builder = builder
           @plugins = []
         end
 
-        def load_plugin(setup_path_or_name)
-          setup_path_or_name = setup_path_or_name.to_s.strip
-          setup_path =
-            if setup_file_directly_given?(setup_path_or_name)
-              setup_path_or_name
-            else
-              get_setup_path(setup_path_or_name)
-            end
-          read_setup_file(setup_path, setup_path_or_name)
+        def load_plugin(setup_path_or_name, version = nil)
+          info = PluginInfo.new.parse(setup_path_or_name, version)
+          read_setup_file(info)
         end
 
         def load_plugins(plugins, no_default_plugins, activation = true)
           RgGen.builder(@builder)
-          merge_plugins(plugins, no_default_plugins).each(&method(:load_plugin))
+          merge_plugins(plugins, no_default_plugins)
+            .each { |plugin| load_plugin(*plugin) }
           activation && activate_plugins
         end
 
@@ -64,27 +118,11 @@ module RgGen
 
         private
 
-        def setup_file_directly_given?(setup_path_or_name)
-          File.ext(setup_path_or_name) == 'rb' ||
-            File.basename(setup_path_or_name, '.*') == 'setup'
-        end
-
-        def get_setup_path(name)
-          base, sub_directory = name.split('/', 2)
-          base = base.sub(/^rggen[-_]/, '').tr('-', '_')
-          File.join(*['rggen', base, sub_directory, 'setup'].compact)
-        end
-
-        def read_setup_file(setup_path, setup_path_or_name)
-          require setup_path
+        def read_setup_file(info)
+          info.gem_name && gem(info.gem_name, info.version)
+          require info.setup_path
         rescue ::LoadError
-          message =
-            if setup_path_or_name == setup_path
-              "cannot load such plugin: #{setup_path_or_name}"
-            else
-              "cannot load such plugin: #{setup_path_or_name} (#{setup_path})"
-            end
-          raise Core::PluginError.new(message)
+          raise Core::PluginError.new("cannot load such plugin: #{info}")
         end
 
         def merge_plugins(plugins, no_default_plugins)
@@ -110,7 +148,9 @@ module RgGen
 
         def plugins_from_env
           ENV['RGGEN_PLUGINS']
-            &.split(':')&.map(&:strip)&.reject(&:empty?)
+            &.split(':')
+            &.reject(&:blank?)
+            &.map { |entry| entry.split(',', 2) }
         end
 
         def plugin?(plugin_module)

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

@@ -12,8 +12,8 @@ module RgGen
         attr_reader :registry
         attr_reader :name
 
-        def setup(base_feature, factory, context, body)
-          @feature = define_feature(base_feature, context, body)
+        def setup(base_feature, factory, context, &body)
+          @feature = define_feature(base_feature, context, &body)
           @factory = factory
         end
 
@@ -27,10 +27,10 @@ module RgGen
 
         private
 
-        def define_feature(base, context, body)
+        def define_feature(base, context, &body)
           feature = Class.new(base)
           context && feature.attach_context(context)
-          body && feature.class_exec(@name, &body)
+          block_given? && feature.class_exec(@name, &body)
           feature
         end
       end

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

@@ -2,10 +2,10 @@
 
 class Object
   def export_instance_variable(variable, to)
-    return unless instance_variable_defined?(variable)
-    v = instance_variable_get(variable)
-    v = yield(v) if block_given?
-    to.instance_variable_set(variable, v)
+    instance_variable_defined?(variable) &&
+      instance_variable_get(variable)
+        .yield_self { |v| block_given? ? yield(v) : v }
+        .yield_self { |v| to.instance_variable_set(variable, v) }
   end
 
   def singleton_exec(*args, &block)

data/lib/rggen/core/facets.rb

@@ -2,6 +2,8 @@
 
 require 'facets/array/merge'
 require 'facets/file/ext'
+require 'facets/hash/except' if RUBY_VERSION < '3.0.0'
+require 'facets/kernel/blank'
 require 'facets/pathname/to_path'
 require 'facets/module/attr_setter'
 require 'facets/module/lastname'

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

@@ -9,10 +9,22 @@ module RgGen
           define_proxy_calls(feature, feature.properties)
         end
 
+        def document_only
+          @document_only = true
+        end
+
+        def document_only?
+          instance_variable_defined?(:@document_only) && @document_only
+        end
+
         def properties
           features.flat_map(&:properties)
         end
 
+        def post_build
+          features.each(&:post_build)
+        end
+
         def verify(scope)
           features.each { |feature| feature.verify(scope) }
           children.each { |child| child.verify(scope) } if scope == :all

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

@@ -79,6 +79,7 @@ module RgGen
         def post_build(component)
           exist_no_children?(component) &&
             raise_no_children_error(component)
+          component.post_build
           component.verify(:component)
         end
 

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

@@ -34,6 +34,13 @@ module RgGen
 
           attr_reader :builders
 
+          def post_build(&block)
+            @post_builders ||= []
+            @post_builders << block
+          end
+
+          attr_reader :post_builders
+
           def active_feature?
             !passive_feature?
           end
@@ -68,6 +75,7 @@ module RgGen
             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
@@ -95,6 +103,12 @@ module RgGen
           self.class.builders && do_build(args)
         end
 
+        def post_build
+          self.class.post_builders&.each do |post_builder|
+            instance_exec(&post_builder)
+          end
+        end
+
         def verify(scope)
           verified?(scope) || do_verify(scope)
         end
@@ -102,7 +116,7 @@ module RgGen
         def printables
           helper
             .printables
-            &.map { |name, body| [name, printable(name, body)] }
+            &.map { |name, body| [name, printable(name, &body)] }
         end
 
         def printable?
@@ -119,10 +133,10 @@ module RgGen
 
         def do_build(args)
           @position = args.last.position
-          args = [*args[0..-2], args.last.value]
-          match_automatically? && match_pattern(args.last)
+          value = args.last.value
+          match_automatically? && match_pattern(value)
           Array(self.class.builders)
-            .each { |builder| instance_exec(*args, &builder) }
+            .each { |builder| instance_exec(*args[0..-2], value, &builder) }
         end
 
         attr_reader :position
@@ -154,8 +168,8 @@ module RgGen
           (@verified ||= {})[scope] = true
         end
 
-        def printable(name, body)
-          body ? instance_exec(&body) : __send__(name)
+        def printable(name, &body)
+          block_given? ? instance_exec(&body) : __send__(name)
         end
       end
     end

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

@@ -17,14 +17,8 @@ module RgGen
 
         def value(value_name, value, position = nil)
           symbolized_name = value_name.to_sym
-          return unless valid_value?(symbolized_name)
-          @values[symbolized_name] =
-            case value
-            when InputValue
-              value
-            else
-              InputValue.new(value, position)
-            end
+          valid_value?(symbolized_name) &&
+            assign_value(symbolized_name, value, position)
         end
 
         def []=(value_name, position_or_value, value = nil)
@@ -44,16 +38,14 @@ module RgGen
 
         def child(layer, value_list = nil, &block)
           create_child_data(layer) do |child_data|
-            child_data.build_by_block(block)
+            child_data.build_by_block(&block)
             child_data.values(value_list)
             @children << child_data
           end
         end
 
         def load_file(file)
-          build_by_block(instance_eval(<<~BODY, file, 1))
-            -> { #{File.binread(file)} }  # -> { File.binread(file) }
-          BODY
+          build_by_block { instance_eval(File.binread(file), file, 1) }
         end
 
         private
@@ -62,6 +54,16 @@ module RgGen
           @valid_value_lists[layer].include?(value_name)
         end
 
+        def assign_value(value_name, value, position)
+          @values[value_name] =
+            case value
+            when InputValue
+              value
+            else
+              InputValue.new(value, position)
+            end
+        end
+
         def define_setter_methods
           @valid_value_lists[layer].each(&method(:define_setter_method))
         end
@@ -73,8 +75,7 @@ module RgGen
         end
 
         def value_setter(value_name, value, position)
-          position ||= position_from_caller
-          value(value_name, value, position)
+          value(value_name, value, position || position_from_caller)
         end
 
         def position_from_caller
@@ -96,8 +97,8 @@ module RgGen
 
         protected
 
-        def build_by_block(block)
-          block && Docile.dsl_eval(self, &block)
+        def build_by_block(&block)
+          block_given? && Docile.dsl_eval(self, &block)
         end
       end
     end

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

@@ -11,9 +11,10 @@ module RgGen
         end
 
         def match(rhs)
-          rhs = rhs.to_s
-          rhs = delete_blanks(rhs) if ignore_blanks?
-          match_patterns(rhs)
+          rhs
+            .to_s
+            .yield_self { |s| ignore_blanks? && delete_blanks(s) || s }
+            .yield_self(&method(:match_patterns))
         end
 
         def match_automatically?
@@ -64,8 +65,7 @@ module RgGen
           index, match_data =
             @patterns
               .transform_values { |pattern| pattern.match(rhs) }
-              .compact
-              .max_by { |_, m| m[0].length }
+              .max_by { |_, m| m && m[0].length || 0 }
           match_data && [convert_match_data(match_data), index]
         end
 

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

@@ -42,44 +42,42 @@ module RgGen
         end
 
         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
+          format_sub_layer_data(read_data, layer, file)&.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 =
+            valid_values(layer)
+              .map { |value_name| extract_value(read_data, layer, value_name) }
+              .compact.to_h
           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)
+        def extract_value(read_data, layer, value_name)
+          value =
+            @extractors
+              .select { |extractor| extractor.target_value?(layer, value_name) }
+              .map { |extractor| extractor.extract(read_data) }
+              .compact.last
+          value && [value_name, value]
         end
 
         def filter_layer_data(layer_data, layer)
-          layer_data
-            .select { |key, _| valid_values(layer).include?(key) }
+          layer_data.slice(*valid_values(layer))
         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) }
+          list = @valid_value_lists[layer]
+          ignore_values = @ignore_values[layer]
+          ignore_values && (list - ignore_values) || list
         end
       end
     end

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

@@ -5,13 +5,18 @@ module RgGen
     module InputBase
       class Property
         def self.define(feature, name, **options, &body)
-          new(name, options, body).define(feature)
+          new(name, options, &body).define(feature)
         end
 
-        def initialize(name, options, body)
+        def initialize(name, options, &body)
           @name = name
           @options = options
-          @costom_property = create_costom_property(@options[:body] || body)
+          @costom_property =
+            if options[:body]
+              create_costom_property(&options[:body])
+            elsif block_given?
+              create_costom_property(&body)
+            end
         end
 
         attr_reader :name
@@ -19,15 +24,15 @@ module RgGen
         def define(feature)
           feature.class_exec(self) do |property|
             define_method(property.name) do |*args, &block|
-              property.evaluate(self, args, block)
+              property.evaluate(self, args, &block)
             end
           end
         end
 
-        def evaluate(feature, args, block)
+        def evaluate(feature, args, &block)
           feature.verify(@options[:verify]) if @options.key?(:verify)
           if proxy_property?
-            proxy_property(feature, args, block)
+            proxy_property(feature, args, &block)
           else
             default_property(feature)
           end
@@ -35,7 +40,7 @@ module RgGen
 
         private
 
-        def create_costom_property(body)
+        def create_costom_property(&body)
           body && Module.new.module_eval do
             define_method(:__costom_property__, &body)
             instance_method(:__costom_property__)
@@ -50,7 +55,7 @@ module RgGen
           ].any?
         end
 
-        def proxy_property(feature, args, block)
+        def proxy_property(feature, args, &block)
           receiver, method =
             if @costom_property
               [@costom_property.bind(feature), :call]
@@ -63,7 +68,7 @@ module RgGen
         end
 
         def default_property(feature)
-          varible_name = "@#{@name[-1] == '?' ? @name[0..-2] : @name}"
+          varible_name = "@#{@name.to_s.delete_suffix('?')}"
           if feature.instance_variable_defined?(varible_name)
             feature.instance_variable_get(varible_name)
           elsif @options.key?(:initial)
@@ -74,8 +79,9 @@ module RgGen
         end
 
         def set_initial_value(feature, varible_name)
-          value = evaluate_default_initial_value(feature, @options[:initial])
-          feature.instance_variable_set(varible_name, value)
+          @options[:initial]
+            .yield_self { |v| evaluate_default_initial_value(feature, v) }
+            .yield_self { |v| feature.instance_variable_set(varible_name, v) }
         end
 
         def evaluate_default_initial_value(feature, value)

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

@@ -6,43 +6,13 @@ module RgGen
       module YAMLLoader
         private
 
-        if RUBY_VERSION >= '2.6.0'
-          def yaml_safe_load(yaml, file)
-            YAML.safe_load(
-              yaml,
-              permitted_classes: [Symbol], aliases: true, filename: file,
-              symbolize_names: true
-            )
-          end
-        elsif RUBY_VERSION >= '2.5.0'
-          def yaml_safe_load(yaml, file)
-            YAML.safe_load(yaml, [Symbol], [], true, file, symbolize_names: true)
-          end
-        else
-          def yaml_safe_load(yaml, file)
-            reuslt = YAML.safe_load(yaml, [Symbol], [], true, file)
-            symbolize_keys(reuslt)
-          end
-
-          def symbolize_keys(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)
-          yaml_safe_load(File.binread(file), file)
+          yaml = File.binread(file)
+          YAML.safe_load(
+            yaml,
+            permitted_classes: [Symbol], aliases: true,
+            filename: file, symbolize_names: true
+          )
         end
       end
     end

data/lib/rggen/core/options.rb

@@ -109,9 +109,9 @@ module RgGen
     end
 
     Options.add_option(:plugins) do |option|
-      option.long_option '--plugin PLUGIN'
+      option.long_option '--plugin PLUGIN[:VERSION]'
       option.default { [] }
-      option.action { |value, options| options[:plugins] << value }
+      option.action { |value, options| options[:plugins] << value.split(':', 2) }
       option.description 'Load a RgGen plugin ' \
                          "(name of plugin/path to 'setup.rb' file)"
     end

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

@@ -4,14 +4,13 @@ module RgGen
   module Core
     module OutputBase
       class CodeGenerator
-        def register(kind, block)
-          return unless block
-          code_blocks[kind] << block
+        def register(kind, &block)
+          block_given? && (code_blocks[kind] << block)
         end
 
         def generate(context, code, kind)
           code_blocks[kind].each do |block|
-            execute_code_block(context, code, block)
+            execute_code_block(context, code, &block)
           end
         end
 
@@ -27,7 +26,7 @@ module RgGen
           @code_blocks ||= Hash.new { |blocks, kind| blocks[kind] = [] }
         end
 
-        def execute_code_block(context, code, block)
+        def execute_code_block(context, code, &block)
           if block.arity.zero?
             code << context.instance_exec(&block)
           else

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module OutputBase
+      class DocumentComponentFactory < ComponentFactory
+      end
+    end
+  end
+end

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

@@ -40,26 +40,30 @@ module RgGen
 
           [:pre_code, :main_code, :post_code].each do |phase|
             define_method(phase) do |kind, **options, &body|
-              block =
-                if options[:from_template]
-                  caller_location = caller_locations(1, 1).first
-                  template_path = extract_template_path(options)
-                  -> { process_template(template_path, caller_location) }
-                else
-                  body
-                end
-              code_generators[__method__] ||= CodeGenerator.new
-              code_generators[__method__].register(kind, block)
+              register_code_generator(__method__, kind, **options, &body)
             end
           end
 
+          def register_code_generator(phase, kind, **options, &body)
+            block =
+              if options[:from_template]
+                path = extract_template_path(options)
+                location = caller_locations(2, 1).first
+                -> { process_template(path, location) }
+              else
+                body
+              end
+            (code_generators[phase] ||= CodeGenerator.new)
+              .register(kind, &block)
+          end
+
           def extract_template_path(options)
             path = options[:from_template]
             path.equal?(true) ? nil : path
           end
 
           def write_file(file_name_pattern, &body)
-            @file_writer = FileWriter.new(file_name_pattern, body)
+            @file_writer = FileWriter.new(file_name_pattern, &body)
           end
 
           def export(*methods)

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

@@ -4,7 +4,7 @@ module RgGen
   module Core
     module OutputBase
       class FileWriter
-        def initialize(pattern, body)
+        def initialize(pattern, &body)
           @pattern = Erubi::Engine.new(pattern)
           @body = body
         end
@@ -32,7 +32,7 @@ module RgGen
 
         def create_directory(path)
           directory = path.dirname
-          directory.directory? || directory.mkpath
+          directory.directory? || FileUtils.mkpath(directory)
         end
       end
     end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module OutputBase
+      class SourceFileComponentFactory < ComponentFactory
+        private
+
+        def create_component?(_, register_map)
+          !register_map.document_only?
+        end
+      end
+    end
+  end
+end

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

@@ -11,15 +11,14 @@ module RgGen
             caller_location ||= caller_locations(1, 1).first
             path = File.ext(caller_location.path, file_extension.to_s)
           end
-          render(context, templates[path])
+          render(context, template(path))
         end
 
         private
 
-        def templates
-          @templates ||= Hash.new do |templates, path|
-            templates[path] = parse_template(path)
-          end
+        def template(path)
+          @templates ||= {}
+          (@templates[path] ||= parse_template(path))
         end
       end
     end

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

@@ -29,14 +29,13 @@ module RgGen
         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
+          read_data
+            .map { |data| fomrat_hash_layer_data(data, layer, file) }
+            .inject(&:merge)
         end
 
         def fomrat_hash_layer_data(read_data, layer, file)
-          convert_to_hash(read_data, file)
-            .reject { |key, _| SUB_LAYER_KEYS[layer]&.include?(key) }
+          convert_to_hash(read_data, file).except(*SUB_LAYER_KEYS[layer])
         end
 
         def format_sub_layer_data(read_data, layer, file)
@@ -48,25 +47,24 @@ module RgGen
         end
 
         def format_array_sub_layer_data(read_data, layer, file)
-          read_data.each_with_object({}) do |data, sub_layer_data|
+          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 = {})
+        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
+            .slice(*SUB_LAYER_KEYS[layer])
+            .each { |k, v| merge_sub_layer_data(sub_layer_data, layer, k, v) }
           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)
+            sub_layer_data
+              .concat([SUB_LAYER_KEY_MAP[layer][key]].product(value))
           else
-            (sub_layer_data[key] ||= []) << value
+            sub_layer_data << [key, value]
           end
         end
 

data/lib/rggen/core/utility/code_utility/code_block.rb

@@ -15,11 +15,13 @@ module RgGen
           attr_reader :indent
 
           def <<(rhs)
-            return push_string(rhs) if rhs.is_a?(String)
-            return push_code_block(rhs) if rhs.is_a?(CodeBlock)
-            return rhs.inject(self, :<<) if rhs.is_a?(Array)
-            return self << rhs.to_code if rhs.respond_to?(:to_code)
-            push_word(rhs)
+            case rhs
+            when String then push_string(rhs)
+            when CodeBlock then push_code_block(rhs)
+            when Array then rhs.inject(self, :<<)
+            when code? then self << rhs.to_code
+            else push_word(rhs)
+            end
           end
 
           def indent=(indent)
@@ -74,6 +76,10 @@ module RgGen
             self
           end
 
+          def code?
+            ->(rhs) { rhs.respond_to?(:to_code) }
+          end
+
           def newline
             "\n"
           end

data/lib/rggen/core/version.rb

@@ -2,7 +2,7 @@
 
 module RgGen
   module Core
-    VERSION = '0.24.0'
+    VERSION = '0.26.0'
     MAJOR, MINOR, PATCH = VERSION.split('.').map(&:to_i)
   end
 end

data/lib/rggen/core.rb

@@ -27,7 +27,6 @@ require_relative 'core/utility/regexp_patterns'
 
 require_relative 'core/exceptions'
 
-require_relative 'core/base/proxy_call'
 require_relative 'core/base/internal_struct'
 require_relative 'core/base/shared_context'
 require_relative 'core/base/component'
@@ -87,6 +86,8 @@ require_relative 'core/output_base/file_writer'
 require_relative 'core/output_base/raise_error'
 require_relative 'core/output_base/component'
 require_relative 'core/output_base/component_factory'
+require_relative 'core/output_base/source_file_component_factory'
+require_relative 'core/output_base/document_component_factory'
 require_relative 'core/output_base/feature'
 require_relative 'core/output_base/feature_factory'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rggen-core
 version: !ruby/object:Gem::Version
-  version: 0.24.0
+  version: 0.26.0
 platform: ruby
 authors:
 - Taichi Ishitani
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-01-20 00:00:00.000000000 Z
+date: 2022-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: docile
@@ -106,7 +106,6 @@ files:
 - lib/rggen/core/base/feature_factory.rb
 - lib/rggen/core/base/feature_layer_extension.rb
 - lib/rggen/core/base/internal_struct.rb
-- lib/rggen/core/base/proxy_call.rb
 - lib/rggen/core/base/shared_context.rb
 - lib/rggen/core/builder.rb
 - lib/rggen/core/builder/builder.rb
@@ -158,11 +157,13 @@ files:
 - lib/rggen/core/output_base/code_generator.rb
 - lib/rggen/core/output_base/component.rb
 - lib/rggen/core/output_base/component_factory.rb
+- lib/rggen/core/output_base/document_component_factory.rb
 - lib/rggen/core/output_base/erb_engine.rb
 - lib/rggen/core/output_base/feature.rb
 - lib/rggen/core/output_base/feature_factory.rb
 - lib/rggen/core/output_base/file_writer.rb
 - lib/rggen/core/output_base/raise_error.rb
+- lib/rggen/core/output_base/source_file_component_factory.rb
 - lib/rggen/core/output_base/template_engine.rb
 - lib/rggen/core/plugin.rb
 - lib/rggen/core/printers.rb
@@ -194,6 +195,7 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/rggen/rggen-core/issues
   mailing_list_uri: https://groups.google.com/d/forum/rggen
+  rubygems_mfa_required: 'true'
   source_code_uri: https://github.com/rggen/rggen-core
   wiki_uri: https://github.com/rggen/rggen/wiki
 post_install_message: 
@@ -204,15 +206,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.3.3
 signing_key: 
 specification_version: 4
-summary: rggen-core-0.24.0
+summary: rggen-core-0.26.0
 test_files: []

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

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module RgGen
-  module Core
-    module Base
-      class ProxyCall
-        def initialize(receiver, method)
-          @receiver = receiver
-          @method = method
-        end
-
-        def call(*args, &block)
-          @receiver.__send__(@method, *args, &block)
-        end
-      end
-    end
-  end
-end