rggen-core 0.21.0 → 0.25.0

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
@@ -149,13 +163,13 @@ module RgGen
         end
 
         def do_verify(scope)
-          Array(self.class.verifiers&.at(scope))
-            .each { |verifier| verifier.verify(self) }
+          self.class.verifiers&.[](scope)
+            &.each { |verifier| verifier.verify(self) }
           (@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,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

@@ -101,21 +101,19 @@ module RgGen
       end
     end
 
-    Options.add_option(:setup) do |option|
-      option.long_option '--setup FILE'
-      option.default { default_steup_file }
-      option.description 'Specify a Ruby file to set up RgGen tool'
-
-      def option.default_steup_file
-        ENV['RGGEN_DEFAULT_SETUP_FILE'] || define_setup_file_from_const
-      end
+    Options.add_option(:no_default_plugins) do |option|
+      option.long_option '--no-default-plugins'
+      option.default false
+      option.action { |_, options| options[:no_default_plugins] = true }
+      option.description 'Do not load default plugins'
+    end
 
-      def option.define_setup_file_from_const
-        require 'rggen/default_setup_file'
-        RgGen::DEFAULT_SETUP_FILE
-      rescue ::LoadError
-        nil
-      end
+    Options.add_option(:plugins) do |option|
+      option.long_option '--plugin PLUGIN'
+      option.default { [] }
+      option.action { |value, options| options[:plugins] << value }
+      option.description 'Load a RgGen plugin ' \
+                         "(name of plugin/path to 'setup.rb' file)"
     end
 
     Options.add_option(:configuration) do |option|
@@ -152,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