rggen-core 0.9.0

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module InputBase
+      class Feature < Base::Feature
+        include Utility::RegexpPatterns
+
+        class << self
+          def property(name, **options, &body)
+            Property.define(self, name, **options, &body)
+            properties.include?(name) || properties << name
+          end
+
+          alias_method :field, :property
+
+          def properties
+            @properties ||= []
+          end
+
+          def ignore_empty_value(value = nil)
+            @ignore_empty_value = value unless value.nil?
+            @ignore_empty_value
+          end
+
+          def ignore_empty_value?
+            @ignore_empty_value.nil? || @ignore_empty_value
+          end
+
+          def build(&block)
+            @builders ||= []
+            @builders << block
+          end
+
+          attr_reader :builders
+
+          def active_feature?
+            !passive_feature?
+          end
+
+          def passive_feature?
+            builders.nil?
+          end
+
+          def input_pattern(pattern_or_patterns, **options, &converter)
+            @input_matcher =
+              InputMatcher.new(pattern_or_patterns, options, &converter)
+          end
+
+          attr_reader :input_matcher
+
+          def verify(scope, &block)
+            @verifiers ||= {}
+            (@verifiers[scope] ||= []) << Verifier.new(&block)
+          end
+
+          attr_reader :verifiers
+
+          def inherited(subclass)
+            super
+            export_instance_variable(:@properties, subclass, &:dup)
+            export_instance_variable(:@ignore_empty_value, subclass)
+            export_instance_variable(:@builders, subclass, &:dup)
+            export_instance_variable(:@input_matcher, subclass)
+            export_verifiers(subclass) if @verifiers
+          end
+
+          private
+
+          def export_verifiers(subclass)
+            copied_verifiers =
+              @verifiers.map { |scope, blocks| [scope, blocks.dup] }.to_h
+            subclass.instance_variable_set(:@verifiers, copied_verifiers)
+          end
+        end
+
+        delegate_to_class [
+          :properties, :active_feature?, :passive_feature?, :ignore_empty_value?
+        ]
+
+        def build(*args)
+          self.class.builders && do_build(args)
+        end
+
+        def verify(scope)
+          verified?(scope) || do_verify(scope)
+        end
+
+        private
+
+        def do_build(args)
+          @position = args.last.position
+          args = [*args[0..-2], args.last.value]
+          match_automatically? && match_pattern(args.last)
+          Array(self.class.builders)
+            .each { |builder| instance_exec(*args, &builder) }
+        end
+
+        attr_reader :position
+
+        def match_automatically?
+          matcher = self.class.input_matcher
+          matcher&.match_automatically?
+        end
+
+        def match_pattern(rhs)
+          matcher = self.class.input_matcher
+          @match_data, @match_index = matcher&.match(rhs)
+        end
+
+        attr_reader :match_data
+        attr_reader :match_index
+
+        def pattern_matched?
+          !match_data.nil?
+        end
+
+        def verified?(scope)
+          @verified && @verified[scope]
+        end
+
+        def do_verify(scope)
+          Array(self.class.verifiers&.at(scope))
+            .each { |verifier| verifier.verify(self) }
+          (@verified ||= {})[scope] = true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module InputBase
+      class FeatureFactory < Base::FeatureFactory
+        class << self
+          def convert_value(&block)
+            @value_converter = block
+          end
+
+          attr_reader :value_converter
+
+          def default_value(&block)
+            @default_value = block if block_given?
+            @default_value
+          end
+        end
+
+        def create(component, *args)
+          input_value = preprocess(args.last)
+          create_feature(component, *args[0..-2], input_value) do |feature|
+            build_feature(feature, input_value)
+            feature.verify(:feature)
+          end
+        end
+
+        def active_feature_factory?
+          !passive_feature_factory?
+        end
+
+        def passive_feature_factory?
+          @target_features.nil? && @target_feature.passive_feature?
+        end
+
+        private
+
+        def preprocess(input_value)
+          converted_value =
+            active_feature_factory? && convert_value(input_value)
+          converted_value || input_value
+        end
+
+        def convert_value(input_value)
+          new_value =
+            if input_value.empty_value?
+              evaluate_defalt_value(input_value.position)
+            else
+              convert(input_value.value, input_value.position)
+            end
+          new_value && InputValue.new(new_value, input_value.position)
+        end
+
+        def evaluate_defalt_value(position)
+          block = self.class.default_value
+          block && instance_exec(position, &block)
+        end
+
+        def convert(value, position)
+          block = self.class.value_converter
+          block && instance_exec(value, position, &block)
+        end
+
+        def build_feature(feature, input_value)
+          build?(feature, input_value) && feature.build(input_value)
+        end
+
+        def build?(feature, input_value)
+          active_feature_factory? &&
+            input_value.available? &&
+            !ignore_empty_value?(feature, input_value)
+        end
+
+        def ignore_empty_value?(feature, input_value)
+          feature.ignore_empty_value? && input_value.empty_value?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module InputBase
+      class InputData
+        def initialize(valid_value_lists)
+          @valid_value_lists = valid_value_lists
+          @values = Hash.new(NAValue)
+          @children = []
+          define_setter_methods
+          block_given? && yield(self)
+        end
+
+        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
+        end
+
+        def []=(value_name, position = nil, value)
+          value(value_name, value, position)
+        end
+
+        def [](value_name)
+          @values[value_name]
+        end
+
+        def values(value_list = nil, position = nil)
+          value_list && Hash(value_list).each { |n, v| value(n, v, position) }
+          @values
+        end
+
+        attr_reader :children
+
+        def child(value_list = nil, &block)
+          create_child_data do |child_data|
+            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)
+          )
+        end
+
+        private
+
+        def valid_value?(value_name)
+          @valid_value_lists.first.include?(value_name)
+        end
+
+        def define_setter_methods
+          @valid_value_lists.first.each(&method(:define_setter_method))
+        end
+
+        def define_setter_method(value_name)
+          define_singleton_method(value_name) do |value, position = nil|
+            value_setter(value_name, value, position)
+          end
+        end
+
+        def value_setter(value_name, value, position)
+          position ||= position_from_caller
+          value(value_name, value, position)
+        end
+
+        def position_from_caller
+          locations = caller_locations(3, 2)
+          locations[0].path.include?('docile') ? locations[1] : locations[0]
+        end
+
+        def create_child_data(&block)
+          child_data_class.new(@valid_value_lists[1..-1], &block)
+        end
+
+        def child_data_class
+          InputData
+        end
+
+        protected
+
+        def build_by_block(block)
+          block && Docile.dsl_eval(self, &block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module InputBase
+      class InputMatcher
+        def initialize(pattern_or_patterns, options, &converter)
+          @options = options
+          @converter = converter
+          @patterns = format_patterns(pattern_or_patterns)
+        end
+
+        def match(rhs)
+          rhs = rhs.to_s
+          rhs = delete_blanks(rhs) if ignore_blanks?
+          match_patterns(rhs)
+        end
+
+        def match_automatically?
+          @options.fetch(:match_automatically, true)
+        end
+
+        private
+
+        def format_patterns(patterns)
+          if @options.fetch(:match_wholly, true)
+            patterns_hash(patterns)
+              .map { |i, pattern| [i, /\A#{pattern}\z/] }
+              .to_h
+          else
+            patterns_hash(patterns)
+          end
+        end
+
+        def patterns_hash(patterns)
+          if patterns.is_a?(Hash)
+            patterns
+          else
+            Array(patterns)
+              .map.with_index { |pattern, i| [i, pattern] }
+              .to_h
+          end
+        end
+
+        def ignore_blanks?
+          @options.fetch(:ignore_blanks, true)
+        end
+
+        DELETE_BLANK_PATTERN =
+          Regexp.union(
+            /(?<=\w)[[:blank:]]+(?=[[:punct:]&&[^_]])/,
+            /(?<=[[:punct:]&&[^_]])[[:blank:]]+(?=\w)/
+          ).freeze
+
+        COMPRESS_BLANK_PATTERN = /[[:blank:]]+/.freeze
+
+        def delete_blanks(rhs)
+          rhs
+            .strip
+            .gsub(DELETE_BLANK_PATTERN, '')
+            .gsub(COMPRESS_BLANK_PATTERN, ' ')
+        end
+
+        def match_patterns(rhs)
+          match_data, index =
+            @patterns
+              .map { |i, pattern| pattern.match(rhs) { |m| [m, i] } }
+              .compact
+              .max { |m| m[0].length }
+          match_data && [convert_match_data(match_data), index]
+        end
+
+        def convert_match_data(match_data)
+          @converter&.call(match_data) || match_data
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module InputBase
+      class InputValue
+        def initialize(value, position)
+          @value = (value.is_a?(String) && value.strip) || value
+          @position = position
+        end
+
+        attr_accessor :value
+        attr_reader :position
+
+        def empty_value?
+          return true if @value.nil?
+          return true if @value.respond_to?(:empty?) && @value.empty?
+          false
+        end
+
+        def available?
+          true
+        end
+      end
+
+      NAValue = InputValue.new(nil, nil).instance_eval do
+        def available?
+          false
+        end
+        freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module InputBase
+      module JSONLoader
+        private
+
+        def load_json(file)
+          json = File.binread(file)
+          JSON.parse(json, symbolize_names: true)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RgGen
+  module Core
+    module InputBase
+      class Loader
+        class << self
+          def support_types(types)
+            @support_types = types.map(&:to_sym)
+          end
+
+          def support?(file)
+            file_ext = File.ext(file).to_sym
+            @support_types.any? { |type| type.casecmp?(file_ext) }
+          end
+
+          def load_file(file, input_data, valid_value_list)
+            new(input_data, valid_value_list).load_file(file)
+          end
+        end
+
+        def initialize(input_data, valid_value_lists)
+          @input_data = input_data
+          @valid_value_lists = valid_value_lists
+        end
+
+        def load_file(file)
+          File.readable?(file) || (
+            raise Core::LoadError.new('cannot load such file', file)
+          )
+          format(read_file(file), file)
+        end
+
+        private
+
+        def format(_read_data, _file)
+        end
+
+        attr_reader :input_data
+        attr_reader :valid_value_lists
+      end
+    end
+  end
+end