ruby_mod_kit 0.0.2 → 0.0.4

data/lib/ruby_mod_kit/mission/fix_parse_error.rb

@@ -1,216 +0,0 @@
-# frozen_string_literal: true
-
-# rbs_inline: enabled
-
-module RubyModKit
-  class Mission
-    # The mission for parameter types
-    class FixParseError < Mission
-      # @rbs @previous_error_messages: Array[String]
-
-      # @rbs return: void
-      def initialize
-        super(0)
-        @previous_error_messages = []
-      end
-
-      # @rbs generation: Generation
-      # @rbs root_node: Node
-      # @rbs parse_result: Prism::ParseResult
-      # @rbs memo: Memo
-      # @rbs return: bool
-      def perform(generation, root_node, parse_result, memo)
-        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|
-          case parse_error.type
-          when :argument_formal_ivar
-            fix_argument_formal_ivar(parse_error, generation, root_node, memo)
-          when :argument_formal_constant
-            fix_argument_formal_constant(parse_error, generation)
-          when :unexpected_token_ignore
-            case parse_error.location.slice
-            when "=>"
-              fix_unexpected_assoc(parse_error, generation, root_node, memo)
-            when ":"
-              fix_unexpected_colon(parse_error, generation, root_node, memo)
-            end
-          when :def_params_term_paren
-            fix_def_params_term_paren(parse_error, generation, root_node, memo)
-          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
-
-      # @rbs parse_error: Prism::ParseError
-      # @rbs generation: Generation
-      # @rbs root_node: Node
-      # @rbs memo: Memo
-      # @rbs return: void
-      def fix_def_params_term_paren(parse_error, generation, root_node, memo)
-        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.parameter_memo(parameter_position_node)
-        parameter_memo.type = type
-        parameter_memo.qualifier = "*"
-      end
-
-      # @rbs parse_error: Prism::ParseError
-      # @rbs generation: Generation
-      # @rbs root_node: Node
-      # @rbs memo: Memo
-      # @rbs return: void
-      def fix_argument_formal_ivar(parse_error, generation, root_node, memo)
-        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.parameter_memo(parameter_position_node)
-        parameter_memo.ivar_parameter = true
-        generation.add_mission(Mission::IvarArg.new(src_offset))
-
-        return unless parameter_memo.untyped?
-
-        def_parent_node = root_node.def_parent_node_at(parse_error.location.start_offset) || return
-        ivar_memo_type = memo.def_parent_memo(def_parent_node).ivar_memo(name.to_sym).type || return
-        parameter_memo.type = ivar_memo_type
-      end
-
-      # @rbs parse_error: Prism::ParseError
-      # @rbs generation: Generation
-      # @rbs return: void
-      def fix_argument_formal_constant(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
-
-      # @rbs parse_error: Prism::ParseError
-      # @rbs generation: Generation
-      # @rbs root_node: Node
-      # @rbs memo: Memo
-      # @rbs return: void
-      def fix_unexpected_assoc(parse_error, generation, root_node, memo)
-        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.parameter_memo(last_parameter_node).type = parameter_type
-      end
-
-      # @rbs parse_error: Prism::ParseError
-      # @rbs generation: Generation
-      # @rbs root_node: Node
-      # @rbs memo: Memo
-      # @rbs return: void
-      def fix_unexpected_colon(parse_error, generation, root_node, memo)
-        parent_node = root_node.statements_node_at(parse_error.location.start_offset)&.parent
-        case parent_node
-        when Node::DefNode
-          fix_unexpected_colon_in_def(parse_error, generation, root_node, parent_node, memo)
-        when Node::DefParentNode
-          fix_unexpected_colon_in_module(parse_error, generation, parent_node, memo)
-        end
-      end
-
-      # @rbs parse_error: Prism::ParseError
-      # @rbs generation: Generation
-      # @rbs root_node: Node
-      # @rbs def_node: Node::DefNode
-      # @rbs memo: Memo
-      # @rbs return: void
-      def fix_unexpected_colon_in_def(parse_error, generation, root_node, def_node, memo)
-        lparen_loc = def_node.lparen_loc
-        rparen_loc = def_node.rparen_loc
-        if !lparen_loc && !rparen_loc
-          src_offset = def_node.name_loc.end_offset
-        elsif lparen_loc && rparen_loc && lparen_loc.slice == "(" && rparen_loc.slice == ")"
-          src_offset = rparen_loc.end_offset
-        else
-          return
-        end
-        return if generation[src_offset...parse_error.location.start_offset] !~ /\A\s*\z/
-
-        return_type_location = root_node.node_at(parse_error.location.end_offset + 1)&.location || return_type_location
-        generation[src_offset, return_type_location.end_offset - src_offset] = ""
-        memo.method_memo(def_node).type = return_type_location.slice
-      end
-
-      # @rbs parse_error: Prism::ParseError
-      # @rbs generation: Generation
-      # @rbs def_parent_node: Node::DefParentNode
-      # @rbs memo: Memo
-      # @rbs return: void
-      def fix_unexpected_colon_in_module(parse_error, generation, def_parent_node, memo)
-        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*(.*)/
-
-        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.def_parent_memo(def_parent_node).ivar_memo(ivar_name.to_sym)
-        ivar_memo.type = type
-        ivar_memo.attr_kind = attr_kind if attr_kind
-
-        generation[line_offset, length] = "#{indent}# @rbs @#{ivar_name}: #{Memo.unify_type(type)}"
-      end
-    end
-  end
-end

data/lib/ruby_mod_kit/mission/ivar_arg.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-# rbs_inline: enabled
-
-module RubyModKit
-  class Mission
-    # The mission for instance variable arguments
-    class IvarArg < Mission
-      # @rbs @assignment: String
-
-      attr_reader :assignment #: String
-
-      # @rbs generation: Generation
-      # @rbs root_node: Node
-      # @rbs _parse_result: Prism::ParseResult
-      # @rbs _memo: Memo
-      # @rbs return: bool
-      def perform(generation, root_node, _parse_result, _memo)
-        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"
-        true
-      end
-    end
-  end
-end

data/lib/ruby_mod_kit/mission/overload.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-# rbs_inline: enabled
-
-module RubyModKit
-  class Mission
-    # The mission for overload
-    class Overload < Mission
-      OVERLOAD_METHOD_MAP = {
-        "*": "_mul",
-      }.freeze #: Hash[Symbol, String]
-
-      # @rbs return: void
-      def initialize
-        super(0)
-      end
-
-      # @rbs generation: Generation
-      # @rbs root_node: Node
-      # @rbs parse_result: Prism::ParseResult
-      # @rbs memo: Memo
-      # @rbs return: bool
-      def perform(generation, root_node, parse_result, memo)
-        method_memo_groups = memo.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
-
-          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 */] || ""
-          start_line -= 1 while parse_result.source.lines[start_line - 1] =~ /^ *# *@rbs /
-          src_offset = parse_result.source.offsets[start_line]
-          script = +""
-
-          method_memos.each do |method_memo|
-            script << if script.empty?
-              "# @rbs"
-            else
-              "#    |"
-            end
-            type = method_memo.type
-            type = "(#{type})" if type.include?(" ")
-            script << " (#{method_memo.parameters.map(&:type).join(", ")}) -> #{type}\n"
-          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
-        true
-      end
-    end
-  end
-end

data/lib/ruby_mod_kit/mission/type_attr.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-# rbs_inline: enabled
-
-module RubyModKit
-  class Mission
-    # The mission for parameter types
-    class TypeAttr < Mission
-      # @rbs return: void
-      def initialize
-        super(0)
-      end
-
-      # @rbs generation: Generation
-      # @rbs root_node: Node
-      # @rbs _parse_result: Prism::ParseResult
-      # @rbs memo: Memo
-      # @rbs return: bool
-      def perform(generation, root_node, _parse_result, memo)
-        memo.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)
-          attr_adding_line = 0
-          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)
-
-            attr_adding_line = call_node.location.end_line
-            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
-
-          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 != ""
-          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
-
-          if def_parent_node.body_node
-            first_line = generation.line(def_parent_node.body_node)
-            indent = first_line[/\A\s*/] || raise(RubyModKit::Error)
-          else
-            def_parent_line = generation.line(def_parent_node)
-            indent = "  #{def_parent_line[/\A\s*/]}"
-          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} #: #{ivar_memo.type}\n"
-          end
-          generation[offset, 0] = "\n" if add_separator_line
-        end
-        true
-      end
-    end
-  end
-end

data/lib/ruby_mod_kit/mission/type_parameter.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-# rbs_inline: enabled
-
-module RubyModKit
-  class Mission
-    # The mission for parameter types
-    class TypeParameter < Mission
-      # @rbs return: void
-      def initialize
-        super(0)
-      end
-
-      # @rbs generation: Generation
-      # @rbs root_node: Node
-      # @rbs parse_result: Prism::ParseResult
-      # @rbs memo: Memo
-      # @rbs return: bool
-      def perform(generation, root_node, parse_result, memo)
-        memo.parameters_memo.each do |offset, parameter_memo|
-          next if parameter_memo.untyped?
-
-          def_node = 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)
-          raise RubyModKit::Error, "ParameterNode not found" unless parameter_node
-
-          type = parameter_memo.type
-          src_offset = parse_result.source.offsets[def_node.location.start_line - 1]
-          indent = def_node.offset - src_offset
-          qualified_name = "#{parameter_memo.qualifier}#{parameter_node.name}"
-          generation[src_offset, 0] = "#{" " * indent}# @rbs #{qualified_name}: #{type}\n"
-        end
-        true
-      end
-    end
-  end
-end

data/lib/ruby_mod_kit/mission/type_return.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-# rbs_inline: enabled
-
-module RubyModKit
-  class Mission
-    # The mission for parameter types
-    class TypeReturn < Mission
-      # @rbs return: void
-      def initialize
-        super(0)
-      end
-
-      # @rbs generation: Generation
-      # @rbs root_node: Node
-      # @rbs parse_result: Prism::ParseResult
-      # @rbs memo: Memo
-      # @rbs return: bool
-      def perform(generation, root_node, parse_result, memo)
-        memo.methods_memo.each do |offset, method_memo|
-          def_node = 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]
-          indent = offset - src_offset
-          generation[src_offset, 0] = "#{" " * indent}# @rbs return: #{method_memo.type}\n"
-        end
-        true
-      end
-    end
-  end
-end

data/lib/ruby_mod_kit/transpiler.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-# rbs_inline: enabled
-
-module RubyModKit
-  # The class of transpiler.
-  class Transpiler
-    # @rbs src: String
-    # @rbs filename: String | nil
-    # @rbs return: String
-    def transpile(src, filename: nil)
-      generation = Generation.new(src.dup, filename: filename)
-      until generation.completed?
-        generation.resolve
-        generation = generation.succ
-      end
-      generation.script
-    end
-  end
-end

data/sig/generated/examples/user.rbs

@@ -1,60 +0,0 @@
-# Generated from examples/user.rb with RBS::Inline
-
-# Example class
-class User
-  @email: String
-
-  @tel: nil | String
-
-  @nick: nil | String
-
-  attr_reader email: String
-
-  attr_reader name: nil | String
-
-  attr_reader nick: nil | String
-
-  # @rbs email: String
-  # @rbs tel: nil | String
-  # @rbs name: nil | String
-  # @rbs nick: nil | String
-  # @rbs return: void
-  def initialize: (String email, ?nil | String tel, ?name: nil | String, ?nick: nil | String) -> void
-end
-
-# Example class
-class Pos
-  @x: Integer
-
-  @y: Integer
-
-  @z: Integer
-
-  attr_reader x: Integer
-
-  attr_reader y: Integer
-
-  attr_reader z: Integer
-
-  # @rbs x: Integer
-  # @rbs y: Integer
-  # @rbs z: Integer
-  # @rbs return: void
-  def initialize: (Integer x, Integer y, ?Integer z) -> void
-
-  # @rbs (Pos) -> Integer
-  #    | (Integer) -> Pos
-  def *: (Pos) -> Integer
-       | (Integer) -> Pos
-
-  # @rbs other: Pos
-  # @rbs return: Integer
-  def _mul__overload0: (Pos other) -> Integer
-
-  # @rbs n: Integer
-  # @rbs return: Pos
-  def _mul__overload1: (Integer n) -> Pos
-
-  # @rbs return: String
-  def to_s: () -> String
-end

data/sig/generated/ruby_mod_kit/memo/def_parent.rbs

@@ -1,20 +0,0 @@
-# Generated from lib/ruby_mod_kit/memo/def_parent.rb with RBS::Inline
-
-module RubyModKit
-  class Memo
-    # The memo for def parent (class, module)
-    class DefParent < OffsetMemo
-      @ivars_memo: Hash[Symbol, Memo::Ivar]
-
-      attr_reader ivars_memo: Hash[Symbol, Memo::Ivar]
-
-      # @rbs def_parent_node: Node::DefParentNode
-      # @rbs return: void
-      def initialize: (Node::DefParentNode def_parent_node) -> void
-
-      # @rbs name: Symbol
-      # @rbs return: Memo::Ivar
-      def ivar_memo: (Symbol name) -> Memo::Ivar
-    end
-  end
-end

data/sig/generated/ruby_mod_kit/memo/located.rbs

@@ -1,14 +0,0 @@
-# Generated from lib/ruby_mod_kit/memo/located.rb with RBS::Inline
-
-module RubyModKit
-  class Memo
-    # The base class for located memo
-    class Located
-      attr_reader offset: Integer
-
-      # @rbs offset: Integer
-      # @rbs return: void
-      def initialize: (Integer offset) -> void
-    end
-  end
-end

data/sig/generated/ruby_mod_kit/memo/parameter_type.rbs

@@ -1,14 +0,0 @@
-# Generated from lib/ruby_mod_kit/memo/parameter_type.rb with RBS::Inline
-
-module RubyModKit
-  class Memo
-    # The memo for parameter type
-    class ParameterType < Located
-      # @rbs offset: Integer
-      # @rbs name: Symbol
-      # @rbs type: String
-      # @rbs return: void
-      def initialize: (Integer offset, Symbol name, String type) -> void
-    end
-  end
-end

data/sig/generated/ruby_mod_kit/memo.rbs

@@ -1,41 +0,0 @@
-# Generated from lib/ruby_mod_kit/memo.rb with RBS::Inline
-
-module RubyModKit
-  # The class of transpiler generation.
-  class Memo
-    @def_parents_memo: Hash[Integer, Memo::DefParent]
-
-    @methods_memo: Hash[Integer, Memo::Method]
-
-    @parameters_memo: Hash[Integer, Memo::Parameter]
-
-    attr_reader def_parents_memo: Hash[Integer, Memo::DefParent]
-
-    attr_reader methods_memo: Hash[Integer, Memo::Method]
-
-    attr_reader parameters_memo: Hash[Integer, Memo::Parameter]
-
-    # @rbs return: void
-    def initialize: () -> void
-
-    # @rbs offset_diff: OffsetDiff
-    # @rbs return: void
-    def succ: (OffsetDiff offset_diff) -> void
-
-    # @rbs def_parent_node: Node::DefParentNode
-    # @rbs return: Memo::DefParent
-    def def_parent_memo: (Node::DefParentNode def_parent_node) -> Memo::DefParent
-
-    # @rbs def_node: Node::DefNode
-    # @rbs return: Memo::Method
-    def method_memo: (Node::DefNode def_node) -> Memo::Method
-
-    # @rbs node: Node
-    # @rbs return: Memo::Parameter
-    def parameter_memo: (Node node) -> Memo::Parameter
-
-    # @rbs type: String
-    # @rbs return: String
-    def self.unify_type: (String type) -> String
-  end
-end