ruby_mod_kit 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36509ee4c00db1106b7447ba1d4fe09ee2fd2a8f8ce763c40b1da185f19cfc61
-  data.tar.gz: eccbdb68bb6159aa95c7fda5d171e4089b9dfa9b262ef136caf019fa3c339d7f
+  metadata.gz: e5888d6187dc2620b37315d72fddee6b134bbd14181277ff600e864eb9c06ca0
+  data.tar.gz: 7ffb4ec96c231e6122eeaa7d47601f67a28620951ed08e9d3b3888e9fa684fbc
 SHA512:
-  metadata.gz: a8b12f06259193345becd29a14a1c6397481c41b390daed390cf4ed0bc7016afe0fbcf9ba95a9c3639b37150c98791d3e501cf2490725bfc5cf3c405fdc99f94
-  data.tar.gz: 684d9b858ac50e78b40f92a2d1cb8ddaafb99983bbdafc7788d786878af5b03c2187995bbe312de59495c9e4f796c352a9e203428d91018075a88791a79320eb
+  metadata.gz: 3c2e632593d2d0a7061f8a71a7e65131a1b72434ac3853467024503d13c57328abe88ade105b2532baf94d44bd428bd02b4eae9e0c50462d4dca6bebc767d4f9
+  data.tar.gz: 81b17d66702c1fc89c77bc3270f74608fca6ed8e9a12f26c04ea69f7d0bdceb4b91b104bfa45b0f944e5ba5dae79e789de720b8a5605df0d4ac4bb4e48e62d6d

data/.ruby_mod_kit.yml

@@ -0,0 +1,5 @@
+features:
+  - instance_variable_parameter
+  - overload
+  - type
+  - type/rbs_inline

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/lib/ruby_mod_kit/cli.rb

@@ -12,7 +12,7 @@ module RubyModKit
     # @rbs *args: String
     # @rbs return: void
     def exec(*args)
-      RubyModKit.execute_file(*args)
+      RubyModKit.execute_file(*args, config: config)
     end
 
     desc "transpile", "transpile rbm files"
@@ -28,9 +28,24 @@ module RubyModKit
       else
         options[:output]
       end
+      config = self.config
       args.each do |path|
-        RubyModKit.transpile_file(path, output: output || RubyModKit.rb_path(path))
+        RubyModKit.transpile_file(path, output: output || RubyModKit.rb_path(path), config: config)
       end
     end
+
+    private
+
+    # @rbs return: Config | nil
+    def config
+      if options[:config]
+        config_path = options[:config]
+        if_none = :raise
+      else
+        config_path = "."
+        if_none = nil
+      end
+      Config.load(config_path, if_none: if_none)
+    end
   end
 end

data/lib/ruby_mod_kit/config.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+require "yaml"
+
+module RubyModKit
+  # config class
+  class Config
+    # @rbs @features: Array[Config]
+
+    attr_reader :features #: Array[Config]
+
+    DEFAULT_FEATURES = %w[instance_variable_parameter overload type type/rbs_inline].freeze #: Array[String]
+
+    # @rbs features: Array[String]
+    # @rbs return: void
+    def initialize(features: DEFAULT_FEATURES)
+      @features = features.sort.map do |feature_name|
+        raise ArgumentError, "invalid feature: #{feature_name}" if feature_name.include?(".")
+
+        require "ruby_mod_kit/feature/#{feature_name}"
+        const_name = feature_name
+          .gsub(/[A-Za-z0-9]+/) { (::Regexp.last_match(0) || "").capitalize }
+          .gsub("_", "").gsub("/", "::")
+        Feature.const_get(const_name).new
+      end
+    end
+
+    class << self
+      # @rbs path: String
+      # @rbs if_none: nil | Symbol
+      # @rbs 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)
+
+        unless File.exist?(path)
+          case if_none
+          when nil
+            return nil
+          when :raise
+            raise LoadError, "Can't load #{path}"
+          else
+            raise ArgumentError, "unexpected if_none: #{if_none.inspect}"
+          end
+        end
+
+        options = YAML.safe_load(File.read(path), symbolize_names: true)
+        new(**options) if options.is_a?(Hash)
+      end
+    end
+  end
+end

data/lib/ruby_mod_kit/core_ext/eval.rb

@@ -12,19 +12,15 @@ module RubyModKit
       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
+      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/corrector.rb

@@ -12,11 +12,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)
       raise RubyModKit::Error, "Unexpected type #{self.class}"
     end
+
+    # @rbs return: void
+    def setup; end
   end
 end

data/lib/ruby_mod_kit/corrector_manager.rb

@@ -5,13 +5,13 @@
 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
     def initialize(features)
-      @previous_error_messages = []
+      @previous_source = +""
       @correctors_error_map = {}
       features.each do |feature|
         feature.create_correctors.each do |corrector|
@@ -23,20 +23,21 @@ 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)
-      return true if parse_result.errors.empty?
+    def perform(generation)
+      return true if generation.errors.empty?
 
-      check_prev_errors(generation, parse_result)
-      @previous_error_messages = parse_result.errors.map(&:message)
+      check_prev_errors(generation)
+      @previous_source = generation.script.dup
 
-      parse_result.errors.each do |parse_error|
+      @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
         correctors.each do |corrector|
-          corrector.correct(parse_error, generation, root_node, memo_pad)
+          corrector.correct(parse_error, generation)
         end
       end
 
@@ -44,19 +45,18 @@ module RubyModKit
     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)
+    def check_prev_errors(generation)
+      return if @previous_source.empty?
+      return if generation.errors.empty?
+      return if @previous_source != generation.script
 
       message = +""
-      parse_result.errors.each do |parse_error|
+      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 = parse_result.source.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

@@ -14,26 +14,24 @@ 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)
           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)
+          parameter_position_node = generation.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 = generation.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
+          def_parent_node = generation.root_node.def_parent_node_at(parse_error.location.start_offset) || return
+          ivar_memo_type = generation.memo_pad.def_parent_memo(def_parent_node).ivar_memo(name.to_sym).type || return
           parameter_memo.type = ivar_memo_type
         end
       end

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

@@ -7,24 +7,17 @@ module RubyModKit
     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|
+        def perform(generation)
+          generation.memo_pad.each_parameter_memo do |parameter_memo|
             next unless parameter_memo.ivar_parameter
 
             offset = parameter_memo.offset
-            parameter_node = root_node.parameter_node_at(offset)
+            parameter_node = generation.root_node.parameter_node_at(offset)
             raise RubyModKit::Error unless parameter_node
 
-            def_node = root_node.def_node_at(offset)
+            def_node = generation.root_node.def_node_at(offset)
             raise RubyModKit::Error, "DefNode not found" unless def_node
 
             def_body_location = def_node.body_location

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

@@ -20,15 +20,12 @@ 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
 
-          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]
+          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]
           end
           method_memo_groups.each_value do |method_memos|
             next if method_memos.length <= 1
@@ -36,16 +33,15 @@ module RubyModKit
             @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)
+            first_def_node = generation.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]
+            indent = generation.line_indent(first_def_node)
+            src_offset = generation.line_offset(first_def_node) || raise(RubyModKit::Error)
             script = +""
 
-            overload_memo = memo_pad.overload_memo(first_method_memo.offset, name)
+            overload_memo = generation.memo_pad.overload_memo(first_method_memo.offset, name)
 
             method_memos.each do |method_memo|
               type = method_memo.type
@@ -57,7 +53,7 @@ module RubyModKit
             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)
+              def_node = generation.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

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

@@ -0,0 +1,56 @@
+# 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
+          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,23 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+module RubyModKit
+  class Feature
+    class Type
+      module Check
+        # namespace for arguments type checker
+        class Arguments < Feature
+          # @rbs 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

@@ -7,6 +7,10 @@ module RubyModKit
     class Type
       # the class to correct `@var: Type` -> `# @rbs @var: Type`
       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(\n+)?/.freeze #: Regexp
+
         # @rbs return: Array[Symbol]
         def correctable_error_types
           %i[unexpected_token_ignore]
@@ -14,32 +18,36 @@ 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_parent_node = 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
-          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/
+          line_offset = generation.line_offset(parse_error) || return
+          line = generation[line_offset..]
+          return if line !~ REGEXP
 
           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)
+          visibility = ::Regexp.last_match(2)
+          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 = memo_pad.def_parent_memo(def_parent_node).ivar_memo(ivar_name.to_sym)
+          ivar_memo = generation.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
+          ivar_memo.visibility = visibility.to_sym if visibility
+          ivar_memo.separator = separator if separator
 
           generation[line_offset, length] = ""
         end