rggen-core 0.24.0 → 0.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 040113a3bef96502aae386b3aa7dafcca07af29d8881b41bfc6e17b3e0769885
-  data.tar.gz: 4392f0ae0bc1cd8d7422606eea73f11dffe293e29cc39250c5fd3479581dc349
+  metadata.gz: 57e33c7b563198efa0e1d2c20adcb0b6896d72d4575673c9f64761aeca93779a
+  data.tar.gz: 61e593cab9704bdc330a3767791afc9e6373020809777c7cd4f67ac18adb7b92
 SHA512:
-  metadata.gz: c77e46129bc726cb7afee6b21b3b31e2a692ee3fa2d99aade8eb6f6a3d1082e4f3fab1c83ff4f20afead532c521dfea6f23c8c6762a0b54ed9ab9cfbf013b484
-  data.tar.gz: c20b96a0be7b1f15cae6cc8b1512d05b83d8f06cb3407b34fe1731221065de3467522bdabfd74b2b5336fcc96b245a9eff191629ff58c61635b8ca77af511be1
+  metadata.gz: 40b23ff5bd0eca3b9a53cda4cb37a220bd8e7a5648bfce598c1404031bfb43421eda997eb8a7c37868e31418a54c7267d336f72631d29522106c20dc3752433a
+  data.tar.gz: 6918ad93d019dd22e4af13205eb5c8529b1ae8b7c71cd50352b183ae84d3c5a54682189e606859adcd7e70cd292f42d11b8621997cff95ac2e89e2b47f876d1f

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'
 

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

@@ -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/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/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,7 @@
 
 require 'facets/array/merge'
 require 'facets/file/ext'
+require 'facets/hash/except' if RUBY_VERSION < '3.0.0'
 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,14 +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))
+          build_by_block(&instance_eval(<<~BODY, file, 1))
             -> { #{File.binread(file)} }  # -> { File.binread(file) }
           BODY
         end
@@ -62,6 +56,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 +77,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 +99,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

@@ -53,33 +53,33 @@ module RgGen
         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

@@ -14,30 +14,9 @@ module RgGen
               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))
+            YAML.safe_load(yaml, [Symbol], [], true, file, symbolize_names: true)
           end
         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

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)
@@ -55,10 +54,8 @@ module RgGen
 
         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
 

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.25.0'
     MAJOR, MINOR, PATCH = VERSION.split('.').map(&:to_i)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rggen-core
 version: !ruby/object:Gem::Version
-  version: 0.24.0
+  version: 0.25.0
 platform: ruby
 authors:
 - Taichi Ishitani
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-01-20 00:00:00.000000000 Z
+date: 2021-02-28 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
@@ -204,7 +205,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -214,5 +215,5 @@ requirements: []
 rubygems_version: 3.2.3
 signing_key: 
 specification_version: 4
-summary: rggen-core-0.24.0
+summary: rggen-core-0.25.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