ruby_mod_kit 0.0.3 → 0.0.5

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

@@ -7,24 +7,30 @@ 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]
         def correctable_error_types
           %i[unexpected_token_ignore def_params_term_paren argument_formal_constant]
         end
 
+        # @rbs return: void
+        def setup
+          super
+          @last_parameter_offsets = Set.new
+        end
+
         # @rbs parse_error: Prism::ParseError
         # @rbs generation: Generation
-        # @rbs root_node: Node::ProgramNode
-        # @rbs memo_pad: MemoPad
         # @rbs return: void
-        def correct(parse_error, generation, root_node, memo_pad)
+        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, root_node, memo_pad)
+            remove_arrow_before_parameter(parse_error, generation)
           when :def_params_term_paren
-            remove_arrow_after_quailifier(parse_error, generation, root_node, memo_pad)
+            remove_arrow_after_quailifier(parse_error, generation)
           when :argument_formal_constant
             wrap_parameter_type_for_next_parse(parse_error, generation)
           end
@@ -32,45 +38,55 @@ module RubyModKit
 
         # @rbs parse_error: Prism::ParseError
         # @rbs generation: Generation
-        # @rbs root_node: Node::ProgramNode
-        # @rbs memo_pad: MemoPad
         # @rbs return: void
-        def remove_arrow_before_parameter(parse_error, generation, root_node, memo_pad)
-          def_node = root_node.def_node_at(parse_error.location.start_offset) || return
+        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] = ""
-          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 root_node: Node::ProgramNode
-        # @rbs memo_pad: MemoPad
         # @rbs return: void
-        def remove_arrow_after_quailifier(parse_error, generation, root_node, memo_pad)
+        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 = root_node.node_at(offset + length) || return
+          parameter_position_node = generation.root_node.node_at(offset + length) || return
 
           generation[parse_error.location.start_offset, length - 1] = ""
-          parameter_memo = memo_pad.parameter_memo(parameter_position_node)
+          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
 

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

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

@@ -9,16 +9,20 @@ module RubyModKit
         # The mission for parameter types
         class TypeAttrMission < Mission
           # @rbs generation: Generation
-          # @rbs root_node: Node::ProgramNode
-          # @rbs _parse_result: Prism::ParseResult
-          # @rbs memo_pad: MemoPad
           # @rbs return: bool
-          def perform(generation, root_node, _parse_result, memo_pad)
-            memo_pad.def_parents_memo.each_value do |def_parent_memo|
+          def perform(generation)
+            generation.memo_pad.def_parents_memo.each_value do |def_parent_memo|
               ivars_memo = def_parent_memo.ivars_memo.dup
-              def_parent_node = root_node.def_parent_node_at(def_parent_memo.offset) || raise(RubyModKit::Error)
+              def_parent_node = generation.root_node.def_parent_node_at(def_parent_memo.offset)
+              raise(RubyModKit::Error) unless def_parent_node
+
               def_parent_node.body_node&.children&.each do |call_node|
                 break if ivars_memo.empty?
+
+                if call_node.is_a?(Node::CallNode) && %i[public private protected].include?(call_node.name)
+                  call_node = call_node.children[0]
+                  call_node = call_node.children[0] if call_node
+                end
                 next unless call_node.is_a?(Node::CallNode)
                 next unless %i[attr_reader attr_writer attr_accessor].include?(call_node.name)
 
@@ -28,7 +32,8 @@ module RubyModKit
                 name = argument_nodes[0].value || next
                 ivar_memo = ivars_memo.delete(name) || next
                 line = generation.line(call_node)
-                length = line[/\A\s*(#{call_node.name}\s+:#{name})(?=\n\z)/, 1]&.length || next
+                length = line[/\A.*(#{call_node.name}\s+:#{name})(?=\n\z)/, 1]&.length || next
+                generation.memo_pad.flags[:rbs_annotated] = true
                 generation[call_node.location.start_offset + length, 0] = " #: #{ivar_memo.type}"
               end
             end

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

@@ -9,17 +9,16 @@ module RubyModKit
         # The mission for instance variable types
         class TypeInstanceVariableMission < Mission
           # @rbs generation: Generation
-          # @rbs root_node: Node::ProgramNode
-          # @rbs parse_result: Prism::ParseResult
-          # @rbs memo_pad: MemoPad
           # @rbs return: bool
-          def perform(generation, root_node, parse_result, memo_pad)
-            memo_pad.def_parents_memo.each_value do |def_parent_memo|
+          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 = root_node.def_parent_node_at(offset) || next
-                body_line_offset = parse_result.source.offsets[def_parent_node.prism_node.location.start_line]
-                generation[body_line_offset, 0] = "#{ivar_memo.indent}# @rbs @#{name}: #{ivar_memo.type}\n"
+                def_parent_node = generation.root_node.def_parent_node_at(offset) || next
+                body_line_offset = generation.line_offset(def_parent_node, 1) || next
+                generation.memo_pad.flags[:rbs_annotated] = true
+                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

@@ -9,17 +9,13 @@ module RubyModKit
         # The mission for parameter types
         class TypeOverloadMission < Mission
           # @rbs generation: Generation
-          # @rbs root_node: Node::ProgramNode
-          # @rbs parse_result: Prism::ParseResult
-          # @rbs memo_pad: MemoPad
           # @rbs return: bool
-          def perform(generation, root_node, parse_result, memo_pad)
-            memo_pad.overloads_memo.each_value do |overload_memo|
-              overload_memo.correct_offset(root_node)
+          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 = root_node.def_node_at(offset) || raise(RubyModKit::Error)
-              start_line = def_node.location.start_line - 1
-              indent = parse_result.source.lines[start_line][/\A */] || ""
+              def_node = generation.root_node.def_node_at(offset) || raise(RubyModKit::Error)
+              indent = generation.line_indent(def_node)
               offset -= indent.length
 
               annotation = +""
@@ -32,6 +28,7 @@ module RubyModKit
                 annotation << " (#{parameter_types.join(", ")}) -> #{return_type}\n"
               end
               annotation.gsub!(/^/, indent)
+              generation.memo_pad.flags[:rbs_annotated] = true
               generation[offset, 0] = annotation
             end
             true

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

@@ -9,25 +9,24 @@ module RubyModKit
         # The mission for parameter types
         class TypeParameterMission < Mission
           # @rbs generation: Generation
-          # @rbs root_node: Node::ProgramNode
-          # @rbs parse_result: Prism::ParseResult
-          # @rbs memo_pad: MemoPad
           # @rbs return: bool
-          def perform(generation, root_node, parse_result, memo_pad)
-            memo_pad.parameters_memo.each do |offset, parameter_memo|
+          def perform(generation)
+            generation.memo_pad.each_parameter_memo do |parameter_memo|
               next if parameter_memo.untyped?
 
-              def_node = root_node.def_node_at(offset)
+              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 = root_node.parameter_node_at(offset)
+              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 = parse_result.source.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[src_offset, 0] = "#{" " * indent}# @rbs #{qualified_name}: #{type}\n"
+              generation.memo_pad.flags[:rbs_annotated] = true
+              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

@@ -9,18 +9,16 @@ module RubyModKit
         # The mission for parameter types
         class TypeReturnMission < Mission
           # @rbs generation: Generation
-          # @rbs root_node: Node::ProgramNode
-          # @rbs parse_result: Prism::ParseResult
-          # @rbs memo_pad: MemoPad
           # @rbs return: bool
-          def perform(generation, root_node, parse_result, memo_pad)
-            memo_pad.methods_memo.each do |offset, method_memo|
-              def_node = root_node.def_node_at(offset)
+          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 = parse_result.source.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"
             end
             true

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

@@ -15,6 +15,8 @@ module RubyModKit
             TypeOverloadMission.new,
             TypeParameterMission.new,
             TypeReturnMission.new,
+            # This mission must be the last
+            AddMagicCommentMission.new,
           ]
         end
       end
@@ -22,6 +24,7 @@ module RubyModKit
   end
 end
 
+require_relative "rbs_inline/add_magic_comment_mission"
 require_relative "rbs_inline/type_attr_mission"
 require_relative "rbs_inline/type_instance_variable_mission"
 require_relative "rbs_inline/type_overload_mission"

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

@@ -14,13 +14,12 @@ module RubyModKit
 
         # @rbs parse_error: Prism::ParseError
         # @rbs generation: Generation
-        # @rbs root_node: Node::ProgramNode
-        # @rbs memo_pad: MemoPad
         # @rbs return: void
-        def correct(parse_error, generation, root_node, memo_pad)
+        def correct(parse_error, generation)
           return if parse_error.location.slice != ":"
 
-          def_node = root_node.statements_node_at(parse_error.location.start_offset)&.parent
+          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
@@ -34,10 +33,10 @@ module RubyModKit
           end
           return if generation[src_offset...parse_error.location.start_offset] !~ /\A\s*\z/
 
-          right_node = root_node.node_at(parse_error.location.end_offset + 1)
+          right_node = generation.root_node.node_at(parse_error.location.end_offset + 1)
           return_type_location = right_node&.location || return_type_location
           generation[src_offset, return_type_location.end_offset - src_offset] = ""
-          memo_pad.method_memo(def_node).type = return_type_location.slice
+          generation.memo_pad.method_memo(def_node).type = return_type_location.slice
         end
       end
     end

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

@@ -7,6 +7,8 @@ module RubyModKit
     class Type
       # The mission for parameter attributes
       class TypeAttrMission < Mission
+        # @rbs @modified: bool
+
         # @rbs return: void
         def initialize
           super
@@ -14,34 +16,26 @@ module RubyModKit
         end
 
         # @rbs generation: Generation
-        # @rbs root_node: Node::ProgramNode
-        # @rbs _parse_result: Prism::ParseResult
-        # @rbs memo_pad: MemoPad
         # @rbs return: bool
-        def perform(generation, root_node, _parse_result, memo_pad)
+        def perform(generation)
           return true if @modified
 
-          memo_pad.def_parents_memo.each_value do |def_parent_memo|
-            ivars_memo = def_parent_memo.ivars_memo.dup
-            def_parent_node = root_node.def_parent_node_at(def_parent_memo.offset) || raise(RubyModKit::Error)
+          generation.memo_pad.def_parents_memo.each_value do |def_parent_memo|
             attr_adding_line = 0
+            ivars_memo = def_parent_memo.ivars_memo.dup
+            def_parent_node = generation.root_node.def_parent_node_at(def_parent_memo.offset)
+            raise(RubyModKit::Error) unless def_parent_node
 
             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,11 +44,13 @@ 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|
-              generation[offset, 0] = "#{indent}#{ivar_memo.attr_kind} :#{name}\n"
+              attr = ivar_memo.attr_kind
+              attr = "#{ivar_memo.visibility} #{attr}" if ivar_memo.visibility
+              generation[offset, 0] = "#{indent}#{attr} :#{name}\n"
             end
             @modified = true
             generation[offset, 0] = "\n" if add_separator_line

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

@@ -0,0 +1,35 @@
+# 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
+          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,30 @@
+# 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
+          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,31 @@
+# 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]
+        def create_missions
+          [
+            TypeParameterMission.new,
+            TypeReturnMission.new,
+          ]
+        end
+
+        class << self
+          # @rbs type: String
+          # @rbs 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.rb

@@ -5,12 +5,6 @@
 module RubyModKit
   # the base class of feature
   class Feature
-    # @rbs other: Feature
-    # @rbs return: -1 | 0 | 1 | nil
-    def <=>(other)
-      self.class.name <=> other.class.name
-    end
-
     # @rbs return: Array[Corrector]
     def create_correctors
       []