ruby_mod_kit 0.0.4 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb9b6cf5cb887308d1237eb07d40b4b2b2514173c5e76d19e13a27687f2c107f
-  data.tar.gz: 418e2d01aec4c8f8b4f0b6241625a0b550aec118a3dbd0618987171bb270e4f7
+  metadata.gz: 7d1688dd299feefd22167740d43d09a691ba4e01359edbdfdcb81462ec7c4d47
+  data.tar.gz: 1ea7711fddb58f15c1257fb8a63595d300a7c45483af595f4defc48c5a842466
 SHA512:
-  metadata.gz: 17a8efaedb26b0b3256fd0b24501298a1f56fdf4dc8d5c33adc8cb6005abf6c5fcca4c0d1d634b34784dd2528ec57c8d2effdaf4042bc522a15359c86b01b804
-  data.tar.gz: 73758c1ef48bcb7884a6f37859115b952474084abca4b6560f7d21c5380ec4bece1f97e165e6ef27b8270b0f5209877f5b2b63f1cd408ed5b4b6f5cb517d8dc1
+  metadata.gz: fa6c821537ec79c43ed5b092f2a0044126c0b925bff381c33971c2462a0578e92b0f681d313d3053c0fbc688f13907a6b10180738fa075bc192e1b582c843479
+  data.tar.gz: a84c961311ae15bc60b8db3594a1f412ca7b1a71d4922707d271c7d3eba9338e91338c69f2414a04907c1bc1e2b76581d1298a3effd22706913d4731fe93b084

data/.ruby_mod_kit.yml

@@ -3,3 +3,4 @@ features:
   - overload
   - type
   - type/rbs_inline
+  - type/yard

data/.yardopts

@@ -0,0 +1,3 @@
+--tag rbs:rbs
+--exclude lib/ruby_mod_kit/core_ext.rb
+--exclude lib/internal/

data/README.md

@@ -15,6 +15,95 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
 ## Usage
 
+### as library
+
+`RubyModKit.transpile` returns transpiled script.
+
+```
+require "ruby_mod_kit"
+eval(
+  RubyModKit.transpile(<<~RBM),
+    class Foo
+      getter @foo: Integer
+      def initialize(@foo)
+      end
+    end
+  RBM
+)
+p Foo.new(1).foo # => 1
+```
+
+`require "ruby_mod_kit/core_ext/eval"` gives `RubyModKit.eval`.
+
+```
+require "ruby_mod_kit/core_ext/eval"
+RubyModKit.eval(<<~RBM)
+  class Foo
+    getter @foo: Integer
+    def initialize(@foo)
+    end
+  end
+RBM
+p Foo.new(1).foo # => 1
+```
+
+`require "ruby_mod_kit/core_ext/load"` gives `RubyModKit.load` and `RubyModKit.require`.
+
+```
+require "ruby_mod_kit/core_ext/load"
+require "tmpdir"
+
+script = <<~RBM
+  class Foo
+    getter @foo: Integer
+    def initialize(@foo)
+    end
+  end
+RBM
+
+Dir.mktmpdir do |tmpdir|
+  File.write("#{tmpdir}/some_lib.rbm", script)
+  $LOAD_PATH << tmpdir
+  RubyModKit.require "some_lib"
+end
+
+p Foo.new(1).foo # => 1
+```
+
+And `require "ruby_mod_kit/core_ext"` is more powerfull but dangerous. It overwrites `eval`, `require` and `load`.
+
+```
+require "ruby_mod_kit/core_ext"
+eval(<<~RBM)
+  class Foo
+    getter @foo: Integer
+    def initialize(@foo)
+    end
+  end
+RBM
+p Foo.new(1).foo # => 1
+```
+
+```
+require "ruby_mod_kit/core_ext"
+require "tmpdir"
+
+script = <<~RBM
+  class Foo
+    getter @foo: Integer
+    def initialize(@foo)
+    end
+  end
+RBM
+
+Dir.mktmpdir do |tmpdir|
+  File.write("#{tmpdir}/some_lib.rbm", script)
+  $LOAD_PATH << tmpdir
+  require "some_lib"
+end
+
+p Foo.new(1).foo # => 1
+```
 ### as command line tool
 
 #### `transpile`

data/examples/user.rb

@@ -50,25 +50,13 @@ class Pos
   #    | (Integer) -> Pos
   def *(*args)
     case args
-    in [Pos]
-      _mul__overload0(*args)
-    in [Integer]
-      _mul__overload1(*args)
+    in [Pos => other]
+      (@x * other.x) + (@y * other.y) + (@z * other.z)
+    in [Integer => n]
+      Pos.new(@x * n, @y * n, @z * n)
     end
   end
 
-  # @rbs other: Pos
-  # @rbs return: Integer
-  def _mul__overload0(other)
-    (@x * other.x) + (@y * other.y) + (@z * other.z)
-  end
-
-  # @rbs n: Integer
-  # @rbs return: Pos
-  def _mul__overload1(n)
-    Pos.new(@x * n, @y * n, @z * n)
-  end
-
   # @rbs return: String
   def to_s
     "#<Pos: (#{@x}, #{@y}, #{@z})>"

data/lib/ruby_mod_kit/cli.rb

@@ -11,6 +11,8 @@ module RubyModKit
     desc "exec", "execute rbm file"
     # @rbs *args: String
     # @rbs return: void
+    # @param args [String]
+    # @return [void]
     def exec(*args)
       RubyModKit.execute_file(*args, config: config)
     end
@@ -19,6 +21,8 @@ module RubyModKit
     method_option :output, type: :string
     # @rbs *args: String
     # @rbs return: void
+    # @param args [String]
+    # @return [void]
     def transpile(*args)
       output = case options[:output]
       when nil, "-", "/dev/stdout"
@@ -37,6 +41,7 @@ module RubyModKit
     private
 
     # @rbs return: Config | nil
+    # @return [Config, nil]
     def config
       if options[:config]
         config_path = options[:config]

data/lib/ruby_mod_kit/config.rb

@@ -15,6 +15,8 @@ module RubyModKit
 
     # @rbs features: Array[String]
     # @rbs return: void
+    # @param features [Array<String>]
+    # @return [void]
     def initialize(features: DEFAULT_FEATURES)
       @features = features.sort.map do |feature_name|
         raise ArgumentError, "invalid feature: #{feature_name}" if feature_name.include?(".")
@@ -29,8 +31,11 @@ module RubyModKit
 
     class << self
       # @rbs path: String
-      # @rbs if_none: nil | Symbol
+      # @rbs if_none: Symbol | nil
       # @rbs return: Config | nil
+      # @param path [String]
+      # @param if_none [Symbol, nil]
+      # @return [Config, nil]
       def load(path, if_none: nil)
         return load(File.join(path, ".ruby_mod_kit.yml"), if_none: if_none) if File.directory?(path)
 

data/lib/ruby_mod_kit/core_ext/eval.rb

@@ -6,25 +6,28 @@ require "ruby_mod_kit"
 
 # Define RubyMotKit.eval
 module RubyModKit
+  # the namespace for language core extensions
   module CoreExt
     # the extension for eval
     module Eval
       module_function
 
       # @rbs expr: String
-      # @rbs *rest: Object
+      # @rbs binding: Binding
+      # @rbs fname: String
+      # @rbs lineno: Integer
       # @rbs transpile: bool
       # @rbs return: Object
-      def eval(expr, *rest, transpile: true)
-        if transpile
-          fname = rest[1].is_a?(String) ? rest[1] : "(eval)"
-          expr = RubyModKit.transpile(expr, filename: fname)
-        end
+      # @param expr [String]
+      # @param binding [Binding]
+      # @param fname [String]
+      # @param lineno [Integer]
+      # @param transpile [Boolean]
+      # @return [Object]
+      def eval(expr, binding = TOPLEVEL_BINDING, fname = "(eval)", lineno = 1, transpile: true)
+        expr = RubyModKit.transpile(expr, filename: fname) if transpile
 
-        case rest
-        in [] | [Binding] | [Binding, String] | [Binding, String, Integer]
-          super(expr, *rest)
-        end
+        super(expr, binding, fname, lineno)
       end
     end
   end

data/lib/ruby_mod_kit/core_ext/load.rb

@@ -17,6 +17,9 @@ module RubyModKit
       # @rbs path: String
       # @rbs wrap: bool
       # @rbs return: bool
+      # @param path [String]
+      # @param wrap [Boolean]
+      # @return [Boolean]
       def load(path, wrap = false) # rubocop:disable Style/OptionalBooleanParameter
         return super unless path.end_with?(".rbm")
 
@@ -27,6 +30,8 @@ module RubyModKit
 
       # @rbs path: String
       # @rbs return: bool
+      # @param path [String]
+      # @return [Boolean]
       def require(path)
         require_path = Load.require_path(path)
         return super unless require_path&.end_with?(".rbm")
@@ -39,11 +44,13 @@ module RubyModKit
 
       class << self
         # @rbs return: Array[String]
+        # @return [Array<String>]
         def loaded_features
           $LOADED_FEATURES
         end
 
         # @rbs return: Array[String]
+        # @return [Array<String>]
         def load_path
           $LOAD_PATH
         end
@@ -51,6 +58,9 @@ module RubyModKit
         # @rbs path: String
         # @rbs expanded: bool
         # @rbs return: String | nil
+        # @param path [String]
+        # @param expanded [Boolean]
+        # @return [String, nil]
         def require_path(path, expanded: false)
           if !expanded && !File.absolute_path?(path)
             return load_path.each.lazy.map { require_path(File.join(_1, path), expanded: true) }.find(&:itself)

data/lib/ruby_mod_kit/corrector.rb

@@ -6,6 +6,7 @@ module RubyModKit
   # the base class of corrector
   class Corrector
     # @rbs return: Array[Symbol]
+    # @return [Array<Symbol>]
     def correctable_error_types
       []
     end
@@ -13,8 +14,15 @@ 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)
       raise RubyModKit::Error, "Unexpected type #{self.class}"
     end
+
+    # @rbs return: void
+    # @return [void]
+    def setup; end
   end
 end

data/lib/ruby_mod_kit/corrector_manager.rb

@@ -5,13 +5,15 @@
 module RubyModKit
   # the class to manege parse error correctors
   class CorrectorManager
-    # @rbs @previous_error_messages: Array[String]
+    # @rbs @previous_source: String
     # @rbs @correctors_error_map: Hash[Symbol, Array[Corrector]]
 
     # @rbs features: Array[Feature]
     # @rbs return: void
+    # @param features [Array<Feature>]
+    # @return [void]
     def initialize(features)
-      @previous_error_messages = []
+      @previous_source = +""
       @correctors_error_map = {}
       features.each do |feature|
         feature.create_correctors.each do |corrector|
@@ -24,11 +26,17 @@ module RubyModKit
 
     # @rbs generation: Generation
     # @rbs return: bool
+    # @param generation [Generation]
+    # @return [Boolean]
     def perform(generation)
       return true if generation.errors.empty?
 
       check_prev_errors(generation)
-      @previous_error_messages = generation.errors.map(&:message)
+      @previous_source = generation.script.dup
+
+      @correctors_error_map.each_value do |correctors|
+        correctors.each(&:setup)
+      end
 
       generation.errors.each do |parse_error|
         correctors = @correctors_error_map[parse_error.type] || next
@@ -42,17 +50,19 @@ module RubyModKit
 
     # @rbs generation: Generation
     # @rbs return: void
+    # @param generation [Generation]
+    # @return [void]
     def check_prev_errors(generation)
-      return if @previous_error_messages.empty?
+      return if @previous_source.empty?
       return if generation.errors.empty?
-      return if @previous_error_messages != generation.errors.map(&:message)
+      return if @previous_source != generation.script
 
       message = +""
       generation.errors.each do |parse_error|
         message << "\n" unless message.empty?
         message << "#{generation.name}:#{parse_error.location.start_line}:#{parse_error.message} "
         message << "(#{parse_error.type})"
-        line = generation.lines[parse_error.location.start_line - 1]
+        line = generation.line(parse_error)
         if line
           message << "\n#{line.chomp}\n"
           message << "#{" " * parse_error.location.start_column}^#{"~" * [parse_error.location.length - 1, 0].max}"

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

@@ -8,6 +8,7 @@ module RubyModKit
       # the class to correct `def foo(@bar) ...` -> `def foo(bar) ...`
       class InstanceVariableParameterCorrector < Corrector
         # @rbs return: Array[Symbol]
+        # @return [Array<Symbol>]
         def correctable_error_types
           %i[argument_formal_ivar]
         end
@@ -15,6 +16,9 @@ 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)
           src_offset = parse_error.location.start_offset
 

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

@@ -9,8 +9,10 @@ module RubyModKit
       class InstanceVariableParameterMission < Mission
         # @rbs generation: Generation
         # @rbs return: bool
+        # @param generation [Generation]
+        # @return [Boolean]
         def perform(generation)
-          generation.memo_pad.parameters_memo.each_value do |parameter_memo|
+          generation.memo_pad.each_parameter_memo do |parameter_memo|
             next unless parameter_memo.ivar_parameter
 
             offset = parameter_memo.offset

data/lib/ruby_mod_kit/feature/instance_variable_parameter.rb

@@ -7,6 +7,7 @@ module RubyModKit
     # namespace for instance_variable parameter feature
     class InstanceVariableParameter < Feature
       # @rbs return: Array[Corrector]
+      # @return [Array<Corrector>]
       def create_correctors
         [
           InstanceVariableParameterCorrector.new,
@@ -14,6 +15,7 @@ module RubyModKit
       end
 
       # @rbs return: Array[Mission]
+      # @return [Array<Mission>]
       def create_missions
         [
           InstanceVariableParameterMission.new,

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

@@ -14,6 +14,7 @@ module RubyModKit
         }.freeze #: Hash[Symbol, String]
 
         # @rbs return: void
+        # @return [void]
         def initialize
           super
           @modified = false
@@ -21,8 +22,19 @@ module RubyModKit
 
         # @rbs generation: Generation
         # @rbs return: bool
+        # @param generation [Generation]
+        # @return [Boolean]
         def perform(generation)
-          return true if @modified
+          if @modified
+            generation.memo_pad.overloads_memo.each_value do |overload_memo|
+              overload_memo.correct_offset(generation.root_node)
+              def_node = generation.root_node.def_node_at(overload_memo.offset)
+              raise RubyModKit::Error unless def_node.is_a?(Node::DefNode)
+
+              generation[def_node.end_offset, 0] = "\n" if def_node.parent.children[-1].offset > def_node.end_offset
+            end
+            return true
+          end
 
           method_memo_groups = generation.memo_pad.methods_memo.each_value.group_by do |method_memo|
             [generation.root_node.def_parent_node_at(method_memo.offset), method_memo.name]
@@ -37,9 +49,8 @@ module RubyModKit
             raise RubyModKit::Error unless first_def_node.is_a?(Node::DefNode)
             raise RubyModKit::Error unless name.is_a?(Symbol)
 
-            start_line = first_def_node.location.start_line - 1
-            indent = generation.lines[start_line][/\A */] || ""
-            src_offset = generation.offsets[start_line]
+            indent = generation.line_indent(first_def_node)
+            src_offset = generation.line_offset(first_def_node) || raise(RubyModKit::Error)
             script = +""
 
             overload_memo = generation.memo_pad.overload_memo(first_method_memo.offset, name)
@@ -51,18 +62,38 @@ module RubyModKit
             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}"
+            method_memos.each do |method_memo|
               def_node = generation.root_node.def_node_at(method_memo.offset)
-              raise RubyModKit::Error if !def_node || !def_node.is_a?(Node::DefNode)
+              body_node = def_node&.body_node
+              raise RubyModKit::Error unless def_node
+
+              def_start_offset = generation.line_offset(def_node) || raise(RubyModKit::Error)
+              def_end_offset = generation.end_line_offset(def_node) || raise(RubyModKit::Error)
+              def_end_offset += generation[def_end_offset..][/.*\n*/]&.size || 0
+              generation[def_start_offset, def_end_offset - def_start_offset] = ""
+              generation.memo_pad.delete(method_memo)
+
+              params = method_memo.parameters.map { |param| "#{param.type} => #{param.name}" }
+              script << "  in [#{params.join(", ")}]\n"
+
+              body = nil
+              case body_node
+              when Node::StatementsNode
+                src_indent = generation.line_indent(body_node)
+                body = "#{src_indent}#{body_node.slice}\n".gsub(/^#{src_indent}/, "    ")
+              when Node::BeginNode
+                src_indent = generation.line_indent(body_node)
+                src_line_offset = generation.line_offset(body_node.children[0]) || raise(RubyModKit::Error)
+                body = body_node.slice[(src_line_offset - body_node.offset)..]
+                body = "#{src_indent}begin\n#{body}\n".gsub(/^#{src_indent}/, "    ")
+              when nil
+                body = ""
+              end
+              raise RubyModKit::Error unless body
 
-              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"
+              script << body
             end
-            script << "  end\nend\n\n"
+            script << "  end\nend\n"
 
             script.gsub!(/^(?=.)/, indent)
             generation[src_offset, 0] = script

data/lib/ruby_mod_kit/feature/overload.rb

@@ -7,6 +7,7 @@ module RubyModKit
     # namespace for overload feature
     class Overload < Feature
       # @rbs return: Array[Mission]
+      # @return [Array<Mission>]
       def create_missions
         [
           OverloadMission.new,

data/lib/ruby_mod_kit/feature/type/check/arguments/add_arguments_checker_mission.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      module Check
+        # The mission to add magic comment
+        class AddArgumentsCheckerMission < Mission
+          # @rbs generation: Generation
+          # @rbs return: bool
+          # @param generation [Generation]
+          # @return [Boolean]
+          def perform(generation)
+            # reload if line break is added
+            line_break_added = false
+
+            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" unless def_node
+              next if method_memo.parameters.empty?
+
+              def_line = generation.line(def_node.location.start_line - 1)
+              def_indent = def_line[/\A\s*/] || ""
+
+              location = def_node.body_location || def_node.end_keyword_loc
+              next unless location
+
+              def_right_loc = def_node.rparen_loc || def_node.name_loc
+              offset = location.start_offset - location.start_column
+              indent = "#{def_indent}  "
+              if location.start_line == def_right_loc.end_line
+                between_def_and_loc = generation[def_right_loc.end_offset...location.start_offset]
+                length = between_def_and_loc[/\A[ ^t]*;[ ^t]*\z/]&.length
+                if length
+                  line_break_added = true
+                  generation[def_right_loc.end_offset, length] = "\n#{def_indent}"
+                end
+              end
+              next if line_break_added
+
+              method_memo.parameters.each do |parameter_memo|
+                next if parameter_memo.untyped? || !parameter_memo.name
+                next if parameter_memo.qualifier # TODO: qualifier support
+
+                type = parameter_memo.type
+                type = type.gsub(/\[([^\[\]]+)\]/, "") # TODO: type variable support
+                generation[offset, 0] = "#{indent}#{parameter_memo.name} => #{type}\n"
+              end
+            end
+            !line_break_added
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/feature/type/check/arguments.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      # namespace for type checker
+      module Check
+        # namespace for arguments type checker
+        class Arguments < Feature
+          # @rbs return: Array[Mission]
+          # @return [Array<Mission>]
+          def create_missions
+            [
+              AddArgumentsCheckerMission.new,
+            ]
+          end
+        end
+      end
+    end
+  end
+end
+
+require_relative "arguments/add_arguments_checker_mission"

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

@@ -9,9 +9,10 @@ module RubyModKit
       class InstanceVariableColonCorrector < Corrector
         VISIBILITIES = %i[private public protected].freeze #: Array[Symbol]
         ATTR_PATTERNS = %i[attr_reader reader getter attr_writer writer setter attr_accessor accessor property].freeze #: Array[Symbol]
-        REGEXP = /(\A\s*)(?:(#{VISIBILITIES.join("|")}) )?(?:(#{ATTR_PATTERNS.join("|")}) )?@(\w*)\s*:\s*(.*)\n/.freeze #: Regexp
+        REGEXP = /(\A\s*)(?:(#{VISIBILITIES.join("|")}) )?(?:(#{ATTR_PATTERNS.join("|")}) )?@(\w*)\s*:\s*(.*)\n(\n+)?/.freeze #: Regexp
 
         # @rbs return: Array[Symbol]
+        # @return [Array<Symbol>]
         def correctable_error_types
           %i[unexpected_token_ignore]
         end
@@ -19,14 +20,20 @@ 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_parent_node = generation.root_node.statements_node_at(parse_error.location.start_offset)&.parent
+          def_parent_node = generation.root_node.def_parent_node_at(
+            parse_error.location.start_offset,
+            allowed: [Node::CallNode, Node::UntypedNode, Node::StatementsNode],
+          )
           return unless def_parent_node.is_a?(Node::DefParentNode)
 
-          line = generation.line(parse_error)
-          line_offset = generation.src_offset(parse_error) || return
+          line_offset = generation.line_offset(parse_error) || return
+          line = generation[line_offset..]
           return if line !~ REGEXP
 
           length = ::Regexp.last_match(0)&.length
@@ -35,6 +42,7 @@ module RubyModKit
           attr_kind = ::Regexp.last_match(3)
           ivar_name = ::Regexp.last_match(4)
           type = ::Regexp.last_match(5)
+          separator = ::Regexp.last_match(6)
           return if !length || !indent || !ivar_name || !type
 
           ivar_memo = generation.memo_pad.def_parent_memo(def_parent_node).ivar_memo(ivar_name.to_sym)
@@ -43,6 +51,7 @@ module RubyModKit
           ivar_memo.indent = indent
           ivar_memo.attr_kind = attr_kind if attr_kind
           ivar_memo.visibility = visibility.to_sym if visibility
+          ivar_memo.separator = separator if separator
 
           generation[line_offset, length] = ""
         end