ruby_mod_kit 0.0.4 → 0.0.6

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

@@ -7,14 +7,27 @@ module RubyModKit
     class Type
       # the class to correct `def foo(Bar => bar, *Buz => buz)` -> `def foo(bar, *buz)`
       class ParameterArrowCorrector < Corrector
+        # @rbs @last_parameter_offsets: Set[Integer]
+
         # @rbs return: Array[Symbol]
+        # @return [Array<Symbol>]
         def correctable_error_types
           %i[unexpected_token_ignore def_params_term_paren argument_formal_constant]
         end
 
+        # @rbs return: void
+        # @return [void]
+        def setup
+          super
+          @last_parameter_offsets = Set.new
+        end
+
         # @rbs parse_error: Prism::ParseError
         # @rbs generation: Generation
         # @rbs return: void
+        # @param parse_error [Prism::ParseError]
+        # @param generation [Generation]
+        # @return [void]
         def correct(parse_error, generation)
           case parse_error.type
           when :unexpected_token_ignore
@@ -31,46 +44,69 @@ module RubyModKit
         # @rbs parse_error: Prism::ParseError
         # @rbs generation: Generation
         # @rbs return: void
+        # @param parse_error [Prism::ParseError]
+        # @param generation [Generation]
+        # @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
+          body_node = body_node.children[0] if body_node.is_a?(Node::BeginNode)
           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
+          return if @last_parameter_offsets.include?(last_parameter_offset)
 
+          @last_parameter_offsets << last_parameter_offset
           right_node = body_node.children.find { _1.offset >= parse_error.location.end_offset } || return
           right_offset = right_node.offset
+          name = right_node.slice[/\A\w+/]
           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
+          qualifier = nil
+          parameter_type = parameter_type.sub(/\A&\(\((.*)\) *: +(.*)\)\z/) do
+            qualifier = "&"
+            "(#{::Regexp.last_match(1)}) -> #{::Regexp.last_match(2)}"
+          end
+          generation[last_parameter_offset, right_offset - last_parameter_offset] = qualifier.to_s
+          parameter_memo = generation.memo_pad.parameter_memo(last_parameter_node)
+          parameter_memo.name = name.to_sym if name
+          parameter_memo.type = parameter_type
+          parameter_memo.qualifier = qualifier if qualifier
         end
 
         # @rbs parse_error: Prism::ParseError
         # @rbs generation: Generation
         # @rbs return: void
+        # @param parse_error [Prism::ParseError]
+        # @param generation [Generation]
+        # @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
+          line =~ /(\A\*(.*?)\s*=>\s*)(\w*)/
+          length = ::Regexp.last_match(1)&.length || return
+          type = ::Regexp.last_match(2) || return
+          name = ::Regexp.last_match(3)
           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.name = name.to_sym if name
           parameter_memo.qualifier = "*"
         end
 
         # @rbs parse_error: Prism::ParseError
         # @rbs generation: Generation
         # @rbs return: void
+        # @param parse_error [Prism::ParseError]
+        # @param generation [Generation]
+        # @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

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

@@ -11,6 +11,7 @@ module RubyModKit
           # @rbs @reloaded: bool
 
           # @rbs return: void
+          # @return [void]
           def initialize
             super
             @reloaded = false
@@ -18,6 +19,8 @@ module RubyModKit
 
           # @rbs generation: Generation
           # @rbs return: bool
+          # @param generation [Generation]
+          # @return [Boolean]
           def perform(generation)
             return true unless generation.memo_pad.flags[:rbs_annotated]
 

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

@@ -10,6 +10,8 @@ module RubyModKit
         class TypeAttrMission < Mission
           # @rbs generation: Generation
           # @rbs return: bool
+          # @param generation [Generation]
+          # @return [Boolean]
           def perform(generation)
             generation.memo_pad.def_parents_memo.each_value do |def_parent_memo|
               ivars_memo = def_parent_memo.ivars_memo.dup

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

@@ -10,14 +10,17 @@ module RubyModKit
         class TypeInstanceVariableMission < Mission
           # @rbs generation: Generation
           # @rbs return: bool
+          # @param generation [Generation]
+          # @return [Boolean]
           def perform(generation)
             generation.memo_pad.def_parents_memo.each_value do |def_parent_memo|
               def_parent_memo.ivars_memo.each do |name, ivar_memo|
                 offset = ivar_memo.offset || next
                 def_parent_node = generation.root_node.def_parent_node_at(offset) || next
-                body_line_offset = generation.offsets[def_parent_node.location.start_line]
+                body_line_offset = generation.line_offset(def_parent_node, 1) || next
                 generation.memo_pad.flags[:rbs_annotated] = true
-                generation[body_line_offset, 0] = "#{ivar_memo.indent}# @rbs @#{name}: #{ivar_memo.type}\n"
+                script = "#{ivar_memo.indent}# @rbs @#{name}: #{ivar_memo.type}\n#{ivar_memo.separator}"
+                generation[body_line_offset, 0] = script
               end
             end
             true

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

@@ -10,13 +10,14 @@ module RubyModKit
         class TypeOverloadMission < Mission
           # @rbs generation: Generation
           # @rbs return: bool
+          # @param generation [Generation]
+          # @return [Boolean]
           def perform(generation)
             generation.memo_pad.overloads_memo.each_value do |overload_memo|
               overload_memo.correct_offset(generation.root_node)
               offset = overload_memo.offset
               def_node = generation.root_node.def_node_at(offset) || raise(RubyModKit::Error)
-              start_line = def_node.location.start_line - 1
-              indent = generation.lines[start_line][/\A */] || ""
+              indent = generation.line_indent(def_node)
               offset -= indent.length
 
               annotation = +""

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

@@ -10,22 +10,25 @@ module RubyModKit
         class TypeParameterMission < Mission
           # @rbs generation: Generation
           # @rbs return: bool
+          # @param generation [Generation]
+          # @return [Boolean]
           def perform(generation)
-            generation.memo_pad.parameters_memo.each do |offset, parameter_memo|
+            generation.memo_pad.each_parameter_memo do |parameter_memo|
               next if parameter_memo.untyped?
 
+              offset = parameter_memo.offset
               def_node = generation.root_node.def_node_at(offset)
               raise RubyModKit::Error, "DefNode not found" if !def_node || !def_node.is_a?(Node::DefNode)
 
               parameter_node = generation.root_node.parameter_node_at(offset)
               raise RubyModKit::Error, "ParameterNode not found" unless parameter_node
 
+              line_offset = generation.line_offset(def_node) || raise(RubyModKit::Error)
               type = parameter_memo.type
-              src_offset = generation.offsets[def_node.location.start_line - 1]
-              indent = def_node.offset - src_offset
+              indent = generation.line_indent(def_node)
               qualified_name = "#{parameter_memo.qualifier}#{parameter_node.name}"
               generation.memo_pad.flags[:rbs_annotated] = true
-              generation[src_offset, 0] = "#{" " * indent}# @rbs #{qualified_name}: #{type}\n"
+              generation[line_offset, 0] = "#{indent}# @rbs #{qualified_name}: #{type}\n"
             end
             true
           end

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

@@ -10,13 +10,15 @@ module RubyModKit
         class TypeReturnMission < Mission
           # @rbs generation: Generation
           # @rbs return: bool
+          # @param generation [Generation]
+          # @return [Boolean]
           def perform(generation)
             generation.memo_pad.methods_memo.each do |offset, method_memo|
               def_node = generation.root_node.def_node_at(offset)
               raise RubyModKit::Error, "DefNode not found" if !def_node || !def_node.is_a?(Node::DefNode)
               next if method_memo.untyped?
 
-              src_offset = generation.offsets[def_node.location.start_line - 1]
+              src_offset = generation.line_offset(def_node) || raise(RubyModKit::Error)
               indent = offset - src_offset
               generation.memo_pad.flags[:rbs_annotated] = true
               generation[src_offset, 0] = "#{" " * indent}# @rbs return: #{method_memo.type}\n"

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

@@ -8,6 +8,7 @@ module RubyModKit
       # namespace for type with rbs-line feature
       class RbsInline < Feature
         # @rbs return: Array[Mission]
+        # @return [Array<Mission>]
         def create_missions
           [
             TypeInstanceVariableMission.new,

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

@@ -8,6 +8,7 @@ module RubyModKit
       # the class to correct `def foo: Some ...` -> `def foo ...`
       class ReturnValueColonCorrector < Corrector
         # @rbs return: Array[Symbol]
+        # @return [Array<Symbol>]
         def correctable_error_types
           %i[unexpected_token_ignore]
         end
@@ -15,10 +16,14 @@ module RubyModKit
         # @rbs parse_error: Prism::ParseError
         # @rbs generation: Generation
         # @rbs return: void
+        # @param parse_error [Prism::ParseError]
+        # @param generation [Generation]
+        # @return [void]
         def correct(parse_error, generation)
           return if parse_error.location.slice != ":"
 
           def_node = generation.root_node.statements_node_at(parse_error.location.start_offset)&.parent
+          def_node = def_node.parent if def_node.is_a?(Node::BeginNode)
           return unless def_node.is_a?(Node::DefNode)
 
           lparen_loc = def_node.lparen_loc

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

@@ -10,6 +10,7 @@ module RubyModKit
         # @rbs @modified: bool
 
         # @rbs return: void
+        # @return [void]
         def initialize
           super
           @modified = false
@@ -17,6 +18,8 @@ module RubyModKit
 
         # @rbs generation: Generation
         # @rbs return: bool
+        # @param generation [Generation]
+        # @return [Boolean]
         def perform(generation)
           return true if @modified
 
@@ -29,19 +32,13 @@ module RubyModKit
             ivars_memo.keep_if { |_, ivar_memo| ivar_memo.attr_kind }
             next if ivars_memo.empty?
 
-            add_first_separator_line = false
             if attr_adding_line == 0
               attr_adding_line = def_parent_node.location.start_line
-              prev_line = nil
-              while generation.line(attr_adding_line) =~ /\A\s*#.*|\A$/
-                prev_line = ::Regexp.last_match(0)
-                attr_adding_line += 1
-              end
-              add_first_separator_line = prev_line != ""
+              attr_adding_line += 1 while generation.line(attr_adding_line) =~ /\A\s*#.*|\A$/
             end
             line = generation.line(attr_adding_line) || next
             add_separator_line = line != "\n" && line !~ /\A\s*end$/
-            offset = generation.src_offset(attr_adding_line) || next
+            offset = generation.line_offset(attr_adding_line) || next
 
             body_node = def_parent_node.body_node
             if body_node
@@ -50,9 +47,9 @@ module RubyModKit
             else
               def_parent_line = generation.line(def_parent_node)
               indent = "  #{def_parent_line[/\A\s*/]}"
+              generation[offset, 0] = "\n"
             end
 
-            generation[offset, 0] = "\n" if add_first_separator_line
             ivars_memo.each do |name, ivar_memo|
               attr = ivar_memo.attr_kind
               attr = "#{ivar_memo.visibility} #{attr}" if ivar_memo.visibility

data/lib/ruby_mod_kit/feature/type/yard/type_parameter_mission.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      class Yard
+        # The mission for parameter types
+        class TypeParameterMission < Mission
+          # @rbs generation: Generation
+          # @rbs return: bool
+          # @param generation [Generation]
+          # @return [Boolean]
+          def perform(generation)
+            generation.memo_pad.each_parameter_memo do |parameter_memo|
+              next if parameter_memo.untyped?
+
+              offset = parameter_memo.offset
+              def_node = generation.root_node.def_node_at(offset)
+              raise RubyModKit::Error, "DefNode not found" if !def_node || !def_node.is_a?(Node::DefNode)
+
+              parameter_node = generation.root_node.parameter_node_at(offset)
+              raise RubyModKit::Error, "ParameterNode not found" unless parameter_node
+
+              line_offset = generation.line_offset(def_node) || raise(RubyModKit::Error)
+              indent = generation.line_indent(def_node)
+              script = "#{indent}# @param #{parameter_node.name} [#{Yard.rbs2yard(parameter_memo.type)}]\n"
+              generation[line_offset, 0] = script
+            end
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/feature/type/yard/type_return_mission.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      class Yard
+        # The mission for return value type
+        class TypeReturnMission < Mission
+          # @rbs generation: Generation
+          # @rbs return: bool
+          # @param generation [Generation]
+          # @return [Boolean]
+          def perform(generation)
+            generation.memo_pad.methods_memo.each do |offset, method_memo|
+              def_node = generation.root_node.def_node_at(offset)
+              raise RubyModKit::Error, "DefNode not found" if !def_node || !def_node.is_a?(Node::DefNode)
+              next if method_memo.untyped?
+
+              src_offset = generation.line_offset(def_node) || raise(RubyModKit::Error)
+              indent = offset - src_offset
+              generation.memo_pad.flags[:rbs_annotated] = true
+              generation[src_offset, 0] = "#{" " * indent}# @return [#{Yard.rbs2yard(method_memo.type)}]\n"
+            end
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      # namespace for type with rbs-line feature
+      class Yard < Feature
+        # @rbs return: Array[Mission]
+        # @return [Array<Mission>]
+        def create_missions
+          [
+            TypeParameterMission.new,
+            TypeReturnMission.new,
+          ]
+        end
+
+        class << self
+          # @rbs type: String
+          # @rbs return: String
+          # @param type [String]
+          # @return [String]
+          def rbs2yard(type)
+            type.gsub(/\s*\|\s*/, ", ").tr("[]", "<>").gsub(/(?<=^|\W)bool(?=$|\W)/, "Boolean")
+          end
+        end
+      end
+    end
+  end
+end
+
+require_relative "yard/type_parameter_mission"
+require_relative "yard/type_return_mission"

data/lib/ruby_mod_kit/feature/type.rb

@@ -7,6 +7,7 @@ module RubyModKit
     # namespace for type feature
     class Type < Feature
       # @rbs return: Array[Corrector]
+      # @return [Array<Corrector>]
       def create_correctors
         [
           InstanceVariableColonCorrector.new,
@@ -16,6 +17,7 @@ module RubyModKit
       end
 
       # @rbs return: Array[Mission]
+      # @return [Array<Mission>]
       def create_missions
         [
           TypeAttrMission.new,

data/lib/ruby_mod_kit/feature.rb

@@ -6,11 +6,13 @@ module RubyModKit
   # the base class of feature
   class Feature
     # @rbs return: Array[Corrector]
+    # @return [Array<Corrector>]
     def create_correctors
       []
     end
 
     # @rbs return: Array[Mission]
+    # @return [Array<Mission>]
     def create_missions
       []
     end

data/lib/ruby_mod_kit/generation.rb

@@ -18,6 +18,7 @@ module RubyModKit
     # @rbs @errors: Array[Prism::ParseError]
     # @rbs @lines: Array[String]
     # @rbs @offsets: Array[Integer]
+    # @rbs @source: String
 
     attr_reader :script #: String
     attr_reader :memo_pad #: MemoPad
@@ -35,6 +36,15 @@ module RubyModKit
     # @rbs corrector_manager: CorrectorManager | nil
     # @rbs features: Array[Feature] | nil
     # @rbs return: void
+    # @param script [String]
+    # @param missions [Array<Mission>]
+    # @param memo_pad [MemoPad, nil]
+    # @param generation_num [Integer]
+    # @param config [Config, nil]
+    # @param filename [String, nil]
+    # @param corrector_manager [CorrectorManager, nil]
+    # @param features [Array<Feature>, nil]
+    # @return [void]
     def initialize(script, missions: [], memo_pad: nil, generation_num: 0, config: nil,
                    filename: nil, corrector_manager: nil, features: nil)
       @script = script
@@ -51,11 +61,13 @@ module RubyModKit
       @errors = parse_result.errors
       @lines = parse_result.source.lines
       @offsets = parse_result.source.offsets
+      @source = @script.dup
       @root_node = Node::ProgramNode.new(parse_result.value)
       init_missions
     end
 
     # @rbs return: void
+    # @return [void]
     def init_missions
       return unless first_generation?
 
@@ -67,20 +79,19 @@ module RubyModKit
     end
 
     # @rbs return: bool
+    # @return [Boolean]
     def first_generation?
       @generation_num == 0
     end
 
     # @rbs return: Generation
+    # @return [Generation]
     def succ
       if @errors.empty?
         perform_missions
       else
         perform_corrector
       end
-      @missions.each do |mission|
-        mission.succ(@offset_diff)
-      end
       @memo_pad.succ(@offset_diff)
 
       Generation.new(
@@ -96,11 +107,13 @@ module RubyModKit
     end
 
     # @rbs return: String
+    # @return [String]
     def name
       "#{@filename || "(eval)"}[gen #{@generation_num}]"
     end
 
     # @rbs return: bool
+    # @return [Boolean]
     def completed?
       @errors.empty? && @missions.empty?
     end
@@ -109,24 +122,22 @@ module RubyModKit
     # @rbs length: Integer
     # @rbs str: String
     # @rbs return: String
+    # @param src_offset [Integer]
+    # @param length [Integer]
+    # @param str [String]
+    # @return [String]
     def []=(src_offset, length, str)
       diff = str.length - length
       @script[@offset_diff[src_offset], length] = str
       @offset_diff.insert(src_offset, diff)
     end
 
-    # @rbs src_range: Range[Integer]
+    # @rbs src_range: Range[Integer | nil]
     # @rbs return: String
+    # @param src_range [Range<Integer, nil>]
+    # @return [String]
     def [](src_range)
-      dst_range = Range.new(@offset_diff[src_range.first], @offset_diff[src_range.last], src_range.exclude_end?)
-      @script[dst_range] || raise(RubyModKit::Error, "Invalid range")
-    end
-
-    # @rbs offset: Integer
-    # @rbs return: String
-    def line_by_offset(offset)
-      offset = @offset_diff[offset]
-      (@script.match(/.*\n?/, offset) && Regexp.last_match(0)) || raise(RubyModKit::Error)
+      @source[src_range] || raise(RubyModKit::Error, "Invalid range")
     end
 
     # @rbs (Integer) -> String
@@ -134,62 +145,63 @@ module RubyModKit
     #    | (Prism::ParseError) -> String
     def line(*args)
       case args
-      in [Integer]
-        line__overload0(*args)
-      in [Node::BaseNode]
-        line__overload1(*args)
-      in [Prism::ParseError]
-        line__overload2(*args)
+      in [Integer => line_num]
+        @lines[line_num] || raise(RubyModKit::Error)
+      in [Node::BaseNode => node]
+        line(node.location.start_line - 1)
+      in [Prism::ParseError => parse_error]
+        begin
+          line(parse_error.location.start_line - 1)
+        rescue RubyModKit::Error
+          ""
+        end
       end
     end
 
-    # @rbs line_num: Integer
-    # @rbs return: String
-    def line__overload0(line_num)
-      line_by_offset(@offsets[line_num])
-    end
-
-    # @rbs node: Node::BaseNode
-    # @rbs return: String
-    def line__overload1(node)
-      line(node.location.start_line - 1)
-    end
-
-    # @rbs parse_error: Prism::ParseError
-    # @rbs return: String
-    def line__overload2(parse_error)
-      line(parse_error.location.start_line - 1)
-    end
-
     # @rbs (Integer) -> (Integer | nil)
+    #    | (Node::BaseNode) -> (Integer | nil)
+    #    | (Node::BaseNode, Integer) -> (Integer | nil)
     #    | (Prism::ParseError) -> (Integer | nil)
-    def src_offset(*args)
+    def line_offset(*args)
       case args
-      in [Integer]
-        src_offset__overload0(*args)
-      in [Prism::ParseError]
-        src_offset__overload1(*args)
+      in [Integer => line_num]
+        @offsets[line_num]
+      in [Node::BaseNode => node]
+        line_offset(node, 0)
+      in [Node::BaseNode => node, Integer => line_offset]
+        line_offset(node.location.start_line - 1 + line_offset)
+      in [Prism::ParseError => parse_error]
+        line_offset(parse_error.location.start_line - 1)
       end
     end
 
-    # @rbs line_num: Integer
+    # @rbs node: Node::BaseNode
     # @rbs return: Integer | nil
-    def src_offset__overload0(line_num)
-      @offsets[line_num]
+    # @param node [Node::BaseNode]
+    # @return [Integer, nil]
+    def end_line_offset(node)
+      line_offset(node.location.end_line - 1)
     end
 
-    # @rbs parse_error: Prism::ParseError
-    # @rbs return: Integer | nil
-    def src_offset__overload1(parse_error)
-      src_offset(parse_error.location.start_line - 1)
+    # @rbs (Integer) -> String
+    #    | (Node::BaseNode) -> String
+    def line_indent(*args)
+      case args
+      in [Integer => line_num]
+        line(line_num)[/\A[ \t]*/] || ""
+      in [Node::BaseNode => node]
+        line_indent(node.location.start_line - 1)
+      end
     end
 
     # @rbs return: void
+    # @return [void]
     def perform_corrector
       @corrector_manager.perform(self)
     end
 
     # @rbs return: void
+    # @return [void]
     def perform_missions
       @missions.delete_if do |mission|
         mission.perform(self) || break
@@ -198,6 +210,8 @@ module RubyModKit
 
     # @rbs mission: Mission
     # @rbs return: void
+    # @param mission [Mission]
+    # @return [void]
     def add_mission(mission)
       @missions << mission
     end
@@ -207,6 +221,10 @@ module RubyModKit
       # @rbs filename: String | nil
       # @rbs config: Config | nil
       # @rbs return: Generation
+      # @param src [String]
+      # @param filename [String, nil]
+      # @param config [Config, nil]
+      # @return [Generation]
       def resolve(src, filename: nil, config: nil)
         generation = Generation.new(src.dup, filename: filename, config: config)
         generation = generation.succ until generation.completed?