rggen-core 0.22.0 → 0.25.1

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,16 @@ 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("-> { #{File.binread(file)} }", file, 1)
-          )
+          build_by_block(&instance_eval(<<~BODY, file, 1))
+            -> { #{File.binread(file)} }  # -> { File.binread(file) }
+          BODY
         end
 
         private
@@ -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,13 +77,16 @@ 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
           locations = caller_locations(3, 2)
-          locations[0].path.include?('docile') ? locations[1] : locations[0]
+          include_docile_path?(locations[0]) && locations[1] || locations[0]
+        end
+
+        def include_docile_path?(caller_location)
+          caller_location.path.include?('docile')
         end
 
         def create_child_data(layer, &block)
@@ -92,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/toml_loader.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module InputBase
+      module TOMLLoader
+        private
+
+        def load_toml(file)
+          toml = File.binread(file)
+          Tomlrb.parse(toml, symbolize_keys: true)
+        end
+      end
+    end
+  end
+end

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

@@ -14,26 +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)
-            if result.is_a? Hash
-              result.each_with_object({}) do |(key, value), hash|
-                hash[key.to_sym] = symbolize_keys(value)
-              end
-            elsif result.is_a? Array
-              result.map(&method(:symbolize_keys))
-            else
-              result
-            end
+            YAML.safe_load(yaml, [Symbol], [], true, file, symbolize_names: true)
           end
         end
 

data/lib/rggen/core/options.rb

@@ -150,6 +150,12 @@ module RgGen
       end
     end
 
+    Options.add_option(:print_verbose_info) do |option|
+      option.long_option '--print-verbose-info'
+      option.default false
+      option.description 'Print verbose information when an error occurs'
+    end
+
     Options.add_option(:print_backtrace) do |option|
       option.long_option '--print-backtrace'
       option.default false

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,11 +26,11 @@ 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
-            context .instance_exec(code, &block)
+            context.instance_exec(code, &block)
           end
         end
 

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/plugin.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module Plugin
+      attr_reader :plugin_spec
+
+      private
+
+      def setup_plugin(name)
+        @plugin_spec = Builder::PluginSpec.new(name, self)
+        block_given? && yield(@plugin_spec)
+      end
+    end
+  end
+end