ruby_mod_kit 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83923be4714ddc71e6c09823f58468b46717815164235dc5437d495c62cd6b7c
-  data.tar.gz: d7a12ed80c113de570b7a1a30c39a0f31d13803c140c1b3c1fe946ec26dde484
+  metadata.gz: 36509ee4c00db1106b7447ba1d4fe09ee2fd2a8f8ce763c40b1da185f19cfc61
+  data.tar.gz: eccbdb68bb6159aa95c7fda5d171e4089b9dfa9b262ef136caf019fa3c339d7f
 SHA512:
-  metadata.gz: ffbd1485194583c50a78287cbb779437d1bfe8991e31e4eca113b3ec0af2d06682e42ab652bed96b7bd9edd6595116c94ffac3c34693b4575696a5ba89e48e39
-  data.tar.gz: 8d5cd3e6989aa21225e9bdaeae4ab68658670bbbb727f5a6f965e3b5e83323a1d79b5debb79861b00fc141bb57f3630a678c5caa386583cb7a4fa0d8eefaaf79
+  metadata.gz: a8b12f06259193345becd29a14a1c6397481c41b390daed390cf4ed0bc7016afe0fbcf9ba95a9c3639b37150c98791d3e501cf2490725bfc5cf3c405fdc99f94
+  data.tar.gz: 684d9b858ac50e78b40f92a2d1cb8ddaafb99983bbdafc7788d786878af5b03c2187995bbe312de59495c9e4f796c352a9e203428d91018075a88791a79320eb

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,22 @@
+# 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 _root_node: Node::ProgramNode
+    # @rbs _memo_pad: MemoPad
+    # @rbs return: void
+    def correct(_parse_error, _generation, _root_node, _memo_pad)
+      raise RubyModKit::Error, "Unexpected type #{self.class}"
+    end
+  end
+end

data/lib/ruby_mod_kit/corrector_manager.rb

@@ -0,0 +1,68 @@
+# 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 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)
+      return true if parse_result.errors.empty?
+
+      check_prev_errors(generation, parse_result)
+      @previous_error_messages = parse_result.errors.map(&:message)
+
+      parse_result.errors.each do |parse_error|
+        correctors = @correctors_error_map[parse_error.type] || next
+        correctors.each do |corrector|
+          corrector.correct(parse_error, generation, root_node, memo_pad)
+        end
+      end
+
+      false
+    end
+
+    # @rbs generation: Generation
+    # @rbs parse_result: Prism::ParseResult
+    # @rbs return: void
+    def check_prev_errors(generation, parse_result)
+      return if @previous_error_messages.empty?
+      return if parse_result.errors.empty?
+      return if @previous_error_messages != parse_result.errors.map(&:message)
+
+      message = +""
+      parse_result.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 = parse_result.source.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,42 @@
+# 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 root_node: Node::ProgramNode
+        # @rbs memo_pad: MemoPad
+        # @rbs return: void
+        def correct(parse_error, generation, root_node, memo_pad)
+          src_offset = parse_error.location.start_offset
+
+          name = parse_error.location.slice[1..]
+          raise RubyModKit::Error unless name
+
+          parameter_position_node = root_node.node_at(src_offset)
+          raise RubyModKit::Error unless parameter_position_node
+
+          generation[src_offset, parse_error.location.length] = name
+          parameter_memo = memo_pad.parameter_memo(parameter_position_node)
+          parameter_memo.ivar_parameter = true
+
+          return unless parameter_memo.untyped?
+
+          def_parent_node = root_node.def_parent_node_at(parse_error.location.start_offset) || return
+          ivar_memo_type = 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,49 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class InstanceVariableParameter
+      # The mission for instance variable arguments
+      class InstanceVariableParameterMission < Mission
+        # @rbs @assignment: String
+
+        attr_reader :assignment #: String
+
+        # @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_value do |parameter_memo|
+            next unless parameter_memo.ivar_parameter
+
+            offset = parameter_memo.offset
+            parameter_node = root_node.parameter_node_at(offset)
+            raise RubyModKit::Error unless parameter_node
+
+            def_node = 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,80 @@
+# 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 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)
+          return true if @modified
+
+          method_memo_groups = memo_pad.methods_memo.each_value.group_by do |method_memo|
+            [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 = 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 = parse_result.source.lines[start_line][/\A */] || ""
+            src_offset = parse_result.source.offsets[start_line]
+            script = +""
+
+            overload_memo = 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 = 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,49 @@
+# 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
+        # @rbs return: Array[Symbol]
+        def correctable_error_types
+          %i[unexpected_token_ignore]
+        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)
+          return if parse_error.location.slice != ":"
+
+          def_parent_node = 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
+          attr_patterns = %i[attr_reader reader getter attr_writer writer setter attr_accessor accessor property]
+          return if line !~ /(\A\s*)(?:(#{attr_patterns.join("|")}) )?@(\w*)\s*:\s*(.*)\n/
+
+          length = ::Regexp.last_match(0)&.length
+          indent = ::Regexp.last_match(1)
+          attr_kind = ::Regexp.last_match(2)
+          ivar_name = ::Regexp.last_match(3)
+          type = ::Regexp.last_match(4)
+          return if !length || !indent || !ivar_name || !type
+
+          ivar_memo = 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
+
+          generation[line_offset, length] = ""
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# 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 root_node: Node::ProgramNode
+        # @rbs memo_pad: MemoPad
+        # @rbs return: void
+        def correct(parse_error, generation, root_node, memo_pad)
+          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)
+          when :def_params_term_paren
+            remove_arrow_after_quailifier(parse_error, generation, root_node, memo_pad)
+          when :argument_formal_constant
+            wrap_parameter_type_for_next_parse(parse_error, generation)
+          end
+        end
+
+        # @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_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] = ""
+          memo_pad.parameter_memo(last_parameter_node).type = parameter_type
+        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)
+          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 = 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.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/type_attr_mission.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      class RbsInline
+        # 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|
+              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.body_node&.children&.each do |call_node|
+                break if ivars_memo.empty?
+                next unless call_node.is_a?(Node::CallNode)
+                next unless %i[attr_reader attr_writer attr_accessor].include?(call_node.name)
+
+                argument_nodes = call_node.children[0].children
+                next if argument_nodes.size != 1 || !argument_nodes[0].is_a?(Node::SymbolNode)
+
+                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
+                generation[call_node.location.start_offset + length, 0] = " #: #{ivar_memo.type}"
+              end
+            end
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      class RbsInline
+        # 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_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"
+              end
+            end
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      class RbsInline
+        # 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)
+              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 */] || ""
+              offset -= indent.length
+
+              annotation = +""
+              overload_memo.overload_types.each do |parameter_types, return_type|
+                annotation << if annotation.empty?
+                  "# @rbs"
+                else
+                  "#    |"
+                end
+                annotation << " (#{parameter_types.join(", ")}) -> #{return_type}\n"
+              end
+              annotation.gsub!(/^/, indent)
+              generation[offset, 0] = annotation
+            end
+            true
+          end
+        end
+      end
+    end
+  end
+end