ruby_mod_kit 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83923be4714ddc71e6c09823f58468b46717815164235dc5437d495c62cd6b7c
-  data.tar.gz: d7a12ed80c113de570b7a1a30c39a0f31d13803c140c1b3c1fe946ec26dde484
+  metadata.gz: bb9b6cf5cb887308d1237eb07d40b4b2b2514173c5e76d19e13a27687f2c107f
+  data.tar.gz: 418e2d01aec4c8f8b4f0b6241625a0b550aec118a3dbd0618987171bb270e4f7
 SHA512:
-  metadata.gz: ffbd1485194583c50a78287cbb779437d1bfe8991e31e4eca113b3ec0af2d06682e42ab652bed96b7bd9edd6595116c94ffac3c34693b4575696a5ba89e48e39
-  data.tar.gz: 8d5cd3e6989aa21225e9bdaeae4ab68658670bbbb727f5a6f965e3b5e83323a1d79b5debb79861b00fc141bb57f3630a678c5caa386583cb7a4fa0d8eefaaf79
+  metadata.gz: 17a8efaedb26b0b3256fd0b24501298a1f56fdf4dc8d5c33adc8cb6005abf6c5fcca4c0d1d634b34784dd2528ec57c8d2effdaf4042bc522a15359c86b01b804
+  data.tar.gz: 73758c1ef48bcb7884a6f37859115b952474084abca4b6560f7d21c5380ec4bece1f97e165e6ef27b8270b0f5209877f5b2b63f1cd408ed5b4b6f5cb517d8dc1

data/.ruby_mod_kit.yml

@@ -0,0 +1,5 @@
+features:
+  - instance_variable_parameter
+  - overload
+  - type
+  - type/rbs_inline

data/lib/ruby_mod_kit/cli.rb

@@ -12,7 +12,7 @@ module RubyModKit
     # @rbs *args: String
     # @rbs return: void
     def exec(*args)
-      RubyModKit.execute_file(*args)
+      RubyModKit.execute_file(*args, config: config)
     end
 
     desc "transpile", "transpile rbm files"
@@ -28,9 +28,24 @@ module RubyModKit
       else
         options[:output]
       end
+      config = self.config
       args.each do |path|
-        RubyModKit.transpile_file(path, output: output || RubyModKit.rb_path(path))
+        RubyModKit.transpile_file(path, output: output || RubyModKit.rb_path(path), config: config)
       end
     end
+
+    private
+
+    # @rbs return: Config | nil
+    def config
+      if options[:config]
+        config_path = options[:config]
+        if_none = :raise
+      else
+        config_path = "."
+        if_none = nil
+      end
+      Config.load(config_path, if_none: if_none)
+    end
   end
 end

data/lib/ruby_mod_kit/config.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+require "yaml"
+
+module RubyModKit
+  # config class
+  class Config
+    # @rbs @features: Array[Config]
+
+    attr_reader :features #: Array[Config]
+
+    DEFAULT_FEATURES = %w[instance_variable_parameter overload type type/rbs_inline].freeze #: Array[String]
+
+    # @rbs features: Array[String]
+    # @rbs return: void
+    def initialize(features: DEFAULT_FEATURES)
+      @features = features.sort.map do |feature_name|
+        raise ArgumentError, "invalid feature: #{feature_name}" if feature_name.include?(".")
+
+        require "ruby_mod_kit/feature/#{feature_name}"
+        const_name = feature_name
+          .gsub(/[A-Za-z0-9]+/) { (::Regexp.last_match(0) || "").capitalize }
+          .gsub("_", "").gsub("/", "::")
+        Feature.const_get(const_name).new
+      end
+    end
+
+    class << self
+      # @rbs path: String
+      # @rbs if_none: nil | Symbol
+      # @rbs return: Config | nil
+      def load(path, if_none: nil)
+        return load(File.join(path, ".ruby_mod_kit.yml"), if_none: if_none) if File.directory?(path)
+
+        unless File.exist?(path)
+          case if_none
+          when nil
+            return nil
+          when :raise
+            raise LoadError, "Can't load #{path}"
+          else
+            raise ArgumentError, "unexpected if_none: #{if_none.inspect}"
+          end
+        end
+
+        options = YAML.safe_load(File.read(path), symbolize_names: true)
+        new(**options) if options.is_a?(Hash)
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/core_ext/eval.rb

@@ -4,6 +4,7 @@
 
 require "ruby_mod_kit"
 
+# Define RubyMotKit.eval
 module RubyModKit
   module CoreExt
     # the extension for eval
@@ -27,4 +28,9 @@ module RubyModKit
       end
     end
   end
+
+  class << self
+    include(CoreExt::Eval)
+    public :eval
+  end
 end

data/lib/ruby_mod_kit/core_ext/load.rb

@@ -3,8 +3,9 @@
 # rbs_inline: enabled
 
 require "ruby_mod_kit"
-require "ruby_mod_kit/core_ext/eval"
+require_relative "eval"
 
+# Define RubyMotKit.load/require
 module RubyModKit
   module CoreExt
     # the extension for load/require
@@ -15,23 +16,25 @@ module RubyModKit
 
       # @rbs path: String
       # @rbs wrap: bool
-      # @rbs return: void
+      # @rbs return: bool
       def load(path, wrap = false) # rubocop:disable Style/OptionalBooleanParameter
         return super unless path.end_with?(".rbm")
 
         b = wrap ? binding : TOPLEVEL_BINDING
         RubyModKit::CoreExt::Eval.eval(File.read(path), b, path)
+        true
       end
 
       # @rbs path: String
-      # @rbs return: void
+      # @rbs return: bool
       def require(path)
         require_path = Load.require_path(path)
         return super unless require_path&.end_with?(".rbm")
-        return if Load.loaded_features.include?(require_path)
+        return false if Load.loaded_features.include?(require_path)
 
         Load.loaded_features << require_path
         load(require_path)
+        true
       end
 
       class << self
@@ -63,4 +66,9 @@ module RubyModKit
       end
     end
   end
+
+  class << self
+    include(CoreExt::Load)
+    public :load, :require, :require_relative
+  end
 end

data/lib/ruby_mod_kit/core_ext.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "ruby_mod_kit/core_ext/eval"
-require "ruby_mod_kit/core_ext/load"
+require_relative "core_ext/eval"
+require_relative "core_ext/load"
 
 Object.prepend(RubyModKit::CoreExt::Eval)
 Object.prepend(RubyModKit::CoreExt::Load)

data/lib/ruby_mod_kit/corrector.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  # the base class of corrector
+  class Corrector
+    # @rbs return: Array[Symbol]
+    def correctable_error_types
+      []
+    end
+
+    # @rbs _parse_error: Prism::ParseError
+    # @rbs _generation: Generation
+    # @rbs return: void
+    def correct(_parse_error, _generation)
+      raise RubyModKit::Error, "Unexpected type #{self.class}"
+    end
+  end
+end

data/lib/ruby_mod_kit/corrector_manager.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  # the class to manege parse error correctors
+  class CorrectorManager
+    # @rbs @previous_error_messages: Array[String]
+    # @rbs @correctors_error_map: Hash[Symbol, Array[Corrector]]
+
+    # @rbs features: Array[Feature]
+    # @rbs return: void
+    def initialize(features)
+      @previous_error_messages = []
+      @correctors_error_map = {}
+      features.each do |feature|
+        feature.create_correctors.each do |corrector|
+          corrector.correctable_error_types.each do |error_type|
+            (@correctors_error_map[error_type] ||= []) << corrector
+          end
+        end
+      end
+    end
+
+    # @rbs generation: Generation
+    # @rbs return: bool
+    def perform(generation)
+      return true if generation.errors.empty?
+
+      check_prev_errors(generation)
+      @previous_error_messages = generation.errors.map(&:message)
+
+      generation.errors.each do |parse_error|
+        correctors = @correctors_error_map[parse_error.type] || next
+        correctors.each do |corrector|
+          corrector.correct(parse_error, generation)
+        end
+      end
+
+      false
+    end
+
+    # @rbs generation: Generation
+    # @rbs return: void
+    def check_prev_errors(generation)
+      return if @previous_error_messages.empty?
+      return if generation.errors.empty?
+      return if @previous_error_messages != generation.errors.map(&:message)
+
+      message = +""
+      generation.errors.each do |parse_error|
+        message << "\n" unless message.empty?
+        message << "#{generation.name}:#{parse_error.location.start_line}:#{parse_error.message} "
+        message << "(#{parse_error.type})"
+        line = generation.lines[parse_error.location.start_line - 1]
+        if line
+          message << "\n#{line.chomp}\n"
+          message << "#{" " * parse_error.location.start_column}^#{"~" * [parse_error.location.length - 1, 0].max}"
+        end
+      end
+      raise RubyModKit::SyntaxError, message
+    end
+  end
+end

data/lib/ruby_mod_kit/feature/instance_variable_parameter/instance_variable_parameter_corrector.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class InstanceVariableParameter
+      # the class to correct `def foo(@bar) ...` -> `def foo(bar) ...`
+      class InstanceVariableParameterCorrector < Corrector
+        # @rbs return: Array[Symbol]
+        def correctable_error_types
+          %i[argument_formal_ivar]
+        end
+
+        # @rbs parse_error: Prism::ParseError
+        # @rbs generation: Generation
+        # @rbs return: void
+        def correct(parse_error, generation)
+          src_offset = parse_error.location.start_offset
+
+          name = parse_error.location.slice[1..]
+          raise RubyModKit::Error unless name
+
+          parameter_position_node = generation.root_node.node_at(src_offset)
+          raise RubyModKit::Error unless parameter_position_node
+
+          generation[src_offset, parse_error.location.length] = name
+          parameter_memo = generation.memo_pad.parameter_memo(parameter_position_node)
+          parameter_memo.ivar_parameter = true
+
+          return unless parameter_memo.untyped?
+
+          def_parent_node = generation.root_node.def_parent_node_at(parse_error.location.start_offset) || return
+          ivar_memo_type = generation.memo_pad.def_parent_memo(def_parent_node).ivar_memo(name.to_sym).type || return
+          parameter_memo.type = ivar_memo_type
+        end
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/feature/instance_variable_parameter/instance_variable_parameter_mission.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class InstanceVariableParameter
+      # The mission for instance variable arguments
+      class InstanceVariableParameterMission < Mission
+        # @rbs generation: Generation
+        # @rbs return: bool
+        def perform(generation)
+          generation.memo_pad.parameters_memo.each_value do |parameter_memo|
+            next unless parameter_memo.ivar_parameter
+
+            offset = parameter_memo.offset
+            parameter_node = generation.root_node.parameter_node_at(offset)
+            raise RubyModKit::Error unless parameter_node
+
+            def_node = generation.root_node.def_node_at(offset)
+            raise RubyModKit::Error, "DefNode not found" unless def_node
+
+            def_body_location = def_node.body_location
+            end_loc = def_node.end_keyword_loc
+            if def_body_location
+              indent = def_body_location.start_column
+              src_offset = def_body_location.start_offset - indent
+            elsif end_loc
+              indent = end_loc.start_column + 2
+              src_offset = end_loc.start_offset - indent + 2
+            end
+            raise RubyModKit::Error if !src_offset || !indent
+
+            name = parameter_node.name
+            generation[src_offset, 0] = "#{" " * indent}@#{name} = #{name}\n"
+          end
+          true
+        end
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/feature/instance_variable_parameter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    # namespace for instance_variable parameter feature
+    class InstanceVariableParameter < Feature
+      # @rbs return: Array[Corrector]
+      def create_correctors
+        [
+          InstanceVariableParameterCorrector.new,
+        ]
+      end
+
+      # @rbs return: Array[Mission]
+      def create_missions
+        [
+          InstanceVariableParameterMission.new,
+        ]
+      end
+    end
+  end
+end
+
+require_relative "instance_variable_parameter/instance_variable_parameter_corrector"
+require_relative "instance_variable_parameter/instance_variable_parameter_mission"

data/lib/ruby_mod_kit/feature/overload/overload_mission.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Overload
+      # The mission for overload
+      class OverloadMission < Mission
+        # @rbs @modified: bool
+
+        OVERLOAD_METHOD_MAP = {
+          "*": "_mul",
+        }.freeze #: Hash[Symbol, String]
+
+        # @rbs return: void
+        def initialize
+          super
+          @modified = false
+        end
+
+        # @rbs generation: Generation
+        # @rbs return: bool
+        def perform(generation)
+          return true if @modified
+
+          method_memo_groups = generation.memo_pad.methods_memo.each_value.group_by do |method_memo|
+            [generation.root_node.def_parent_node_at(method_memo.offset), method_memo.name]
+          end
+          method_memo_groups.each_value do |method_memos|
+            next if method_memos.length <= 1
+
+            @modified = true
+            first_method_memo = method_memos.first
+            name = first_method_memo.name
+            first_def_node = generation.root_node.def_node_at(first_method_memo.offset)
+            raise RubyModKit::Error unless first_def_node.is_a?(Node::DefNode)
+            raise RubyModKit::Error unless name.is_a?(Symbol)
+
+            start_line = first_def_node.location.start_line - 1
+            indent = generation.lines[start_line][/\A */] || ""
+            src_offset = generation.offsets[start_line]
+            script = +""
+
+            overload_memo = generation.memo_pad.overload_memo(first_method_memo.offset, name)
+
+            method_memos.each do |method_memo|
+              type = method_memo.type
+              type = "(#{type})" if type.include?(" ")
+              overload_memo.add_overload_type(method_memo.parameters.map(&:type), type)
+            end
+
+            script << "def #{name}(*args)\n  case args\n"
+            overload_prefix = +"#{OVERLOAD_METHOD_MAP[name] || name}_"
+            method_memos.each_with_index do |method_memo, i|
+              overload_name = "#{overload_prefix}_overload#{i}"
+              def_node = generation.root_node.def_node_at(method_memo.offset)
+              raise RubyModKit::Error if !def_node || !def_node.is_a?(Node::DefNode)
+
+              name_loc = def_node.name_loc
+              generation[name_loc.start_offset, name_loc.length] = overload_name
+              script << "  in [#{method_memo.parameters.map(&:type).join(", ")}]\n"
+              script << "    #{overload_name}(*args)\n"
+            end
+            script << "  end\nend\n\n"
+
+            script.gsub!(/^(?=.)/, indent)
+            generation[src_offset, 0] = script
+          end
+
+          # if script has been changed, request reparsing before proceeding to the next mission
+          !@modified
+        end
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/feature/overload.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    # namespace for overload feature
+    class Overload < Feature
+      # @rbs return: Array[Mission]
+      def create_missions
+        [
+          OverloadMission.new,
+        ]
+      end
+    end
+  end
+end
+
+require_relative "overload/overload_mission"

data/lib/ruby_mod_kit/feature/type/instance_variable_colon_corrector.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      # the class to correct `@var: Type` -> `# @rbs @var: Type`
+      class InstanceVariableColonCorrector < Corrector
+        VISIBILITIES = %i[private public protected].freeze #: Array[Symbol]
+        ATTR_PATTERNS = %i[attr_reader reader getter attr_writer writer setter attr_accessor accessor property].freeze #: Array[Symbol]
+        REGEXP = /(\A\s*)(?:(#{VISIBILITIES.join("|")}) )?(?:(#{ATTR_PATTERNS.join("|")}) )?@(\w*)\s*:\s*(.*)\n/.freeze #: Regexp
+
+        # @rbs return: Array[Symbol]
+        def correctable_error_types
+          %i[unexpected_token_ignore]
+        end
+
+        # @rbs parse_error: Prism::ParseError
+        # @rbs generation: Generation
+        # @rbs return: void
+        def correct(parse_error, generation)
+          return if parse_error.location.slice != ":"
+
+          def_parent_node = generation.root_node.statements_node_at(parse_error.location.start_offset)&.parent
+          return unless def_parent_node.is_a?(Node::DefParentNode)
+
+          line = generation.line(parse_error)
+          line_offset = generation.src_offset(parse_error) || return
+          return if line !~ REGEXP
+
+          length = ::Regexp.last_match(0)&.length
+          indent = ::Regexp.last_match(1)
+          visibility = ::Regexp.last_match(2)
+          attr_kind = ::Regexp.last_match(3)
+          ivar_name = ::Regexp.last_match(4)
+          type = ::Regexp.last_match(5)
+          return if !length || !indent || !ivar_name || !type
+
+          ivar_memo = generation.memo_pad.def_parent_memo(def_parent_node).ivar_memo(ivar_name.to_sym)
+          ivar_memo.type = type
+          ivar_memo.offset = line_offset
+          ivar_memo.indent = indent
+          ivar_memo.attr_kind = attr_kind if attr_kind
+          ivar_memo.visibility = visibility.to_sym if visibility
+
+          generation[line_offset, length] = ""
+        end
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/feature/type/parameter_arrow_corrector.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      # the class to correct `def foo(Bar => bar, *Buz => buz)` -> `def foo(bar, *buz)`
+      class ParameterArrowCorrector < Corrector
+        # @rbs return: Array[Symbol]
+        def correctable_error_types
+          %i[unexpected_token_ignore def_params_term_paren argument_formal_constant]
+        end
+
+        # @rbs parse_error: Prism::ParseError
+        # @rbs generation: Generation
+        # @rbs return: void
+        def correct(parse_error, generation)
+          case parse_error.type
+          when :unexpected_token_ignore
+            return if parse_error.location.slice != "=>"
+
+            remove_arrow_before_parameter(parse_error, generation)
+          when :def_params_term_paren
+            remove_arrow_after_quailifier(parse_error, generation)
+          when :argument_formal_constant
+            wrap_parameter_type_for_next_parse(parse_error, generation)
+          end
+        end
+
+        # @rbs parse_error: Prism::ParseError
+        # @rbs generation: Generation
+        # @rbs return: void
+        def remove_arrow_before_parameter(parse_error, generation)
+          def_node = generation.root_node.def_node_at(parse_error.location.start_offset) || return
+          def_parent_node = def_node.parent
+          parameters_node, body_node, = def_node.children
+          return if !def_parent_node || !parameters_node || !body_node
+
+          last_parameter_node = parameters_node.children.max_by(&:offset) || return
+          last_parameter_offset = last_parameter_node.offset
+
+          right_node = body_node.children.find { _1.offset >= parse_error.location.end_offset } || return
+          right_offset = right_node.offset
+          parameter_type = generation[last_parameter_offset...right_offset] || raise(RubyModKit::Error)
+          parameter_type = parameter_type.sub(/\s*=>\s*\z/, "")
+          generation[last_parameter_offset, right_offset - last_parameter_offset] = ""
+          generation.memo_pad.parameter_memo(last_parameter_node).type = parameter_type
+        end
+
+        # @rbs parse_error: Prism::ParseError
+        # @rbs generation: Generation
+        # @rbs return: void
+        def remove_arrow_after_quailifier(parse_error, generation)
+          column = parse_error.location.start_column - 1
+          return if column < 0
+
+          line = generation.line(parse_error)[column..] || return
+          line =~ /\A\*(.*?)\s*=>\s*/
+          length = ::Regexp.last_match(0)&.length || return
+          type = ::Regexp.last_match(1) || return
+          offset = parse_error.location.start_offset - 1
+          parameter_position_node = generation.root_node.node_at(offset + length) || return
+
+          generation[parse_error.location.start_offset, length - 1] = ""
+          parameter_memo = generation.memo_pad.parameter_memo(parameter_position_node)
+          parameter_memo.type = type
+          parameter_memo.qualifier = "*"
+        end
+
+        # @rbs parse_error: Prism::ParseError
+        # @rbs generation: Generation
+        # @rbs return: void
+        def wrap_parameter_type_for_next_parse(parse_error, generation)
+          line = generation.line(parse_error)
+          line = line[parse_error.location.start_column..] || return
+          parameter_type = line[/(\A[A-Z]\w*(?:::[A-Z]\w*)+)(?:\s*=>\s*)/, 1] || return
+          src_offset = parse_error.location.start_offset
+          generation[src_offset, parameter_type.length] = "(#{parameter_type})"
+        end
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/feature/type/rbs_inline/add_magic_comment_mission.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      class RbsInline
+        # The mission to add magic comment
+        class AddMagicCommentMission < Mission
+          # @rbs @reloaded: bool
+
+          # @rbs return: void
+          def initialize
+            super
+            @reloaded = false
+          end
+
+          # @rbs generation: Generation
+          # @rbs return: bool
+          def perform(generation)
+            return true unless generation.memo_pad.flags[:rbs_annotated]
+
+            unless @reloaded
+              @reloaded = true
+              return false
+            end
+
+            offset = 0
+            separated = false
+            generation.lines.each do |line|
+              break if line =~ /^# @rbs/
+              break if line !~ /^#( rbs_inline: enabled)?|(^$)/
+              return true if ::Regexp.last_match(1)
+
+              separated = !::Regexp.last_match(2).nil?
+
+              offset += line.length
+            end
+            script = +""
+            script << "\n" unless separated
+            generation[offset, 0] = "# rbs_inline: enabled\n\n"
+            true
+          end
+        end
+      end
+    end
+  end
+end