ruby-lsp-ree 0.1.15 → 0.1.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f3673076ca0aee98f0f92d6db25a2939ae21a58464a70e1a1e534bfef3458d0
-  data.tar.gz: 2191d354bbe75911cc230ca20665e5882e15eabee5de30801db1960990d42c3b
+  metadata.gz: 4d1b2bf9c373c729b6412704fd6daf364ed4c8b278405f52b4c1fc32b256570c
+  data.tar.gz: 0bde5c4413ec6d4ccfd807dc6e6eb33d1e47ab018dfbfaad47200775b2c3badb
 SHA512:
-  metadata.gz: ec2b1c6e15509e7e8f18758ef3a6912c14dccbdc6348d353331894fc53efbd072b043e49b1ee933c2b552e11404a4f322f8336aa29f267f3a842724d67fc8d7a
-  data.tar.gz: c584181adbf4ed1a02dc2545c1b65cf4ada307ade2d46aee661a97319adf43d67e6d21bb47f7b05d73bc4a2b913053ca990cae0cf1722587c350be942151e385
+  metadata.gz: 6a97047d4924f208415ba6c5ed45e6abb57141e74fd44ad79368a9a7dd025a2ce0c36cfe2ca95db6fd0dab9586d9a1c5484be2e930ab129ab6acb7975fce310f
+  data.tar.gz: 17daba371512607775021704c56895bcc9e41666e598c9603c7da22ebac567de1cc7a2957f050a6657429057557dcbbc86654141eba98faa8c7ddde6e892a030

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## [0.1.16] - 2025-04-24
+
+- formatter: add missing imports
+
 ## [0.1.15] - 2025-04-18
 
 - autocomplete - don't overwrite existing arguments

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ruby-lsp-ree (0.1.15)
+    ruby-lsp-ree (0.1.16)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -32,7 +32,7 @@ To switch off/on formatter features, use Ruby LSP addon settings:
     }
   }
 ```
-available formatters: `SortLinksFormatter`, `MissingErrorDefinitionsFormatter`, `MissingErrorContractsFormatter`, `MissingErrorLocalesFormatter`, `UnusedLinksFormatter`
+available formatters: `SortLinksFormatter`, `MissingErrorDefinitionsFormatter`, `MissingErrorContractsFormatter`, `MissingErrorLocalesFormatter`, `UnusedLinksFormatter`, `MissingImportsFormatter`
 
 ## Functions
 

data/lib/ruby_lsp/ruby_lsp_ree/completion/method_additional_text_edits_creator.rb

@@ -33,7 +33,7 @@ module RubyLsp
         new_text = "\n" + link_text
 
         if @parsed_doc.has_blank_links_container?
-          new_text = "\sdo#{link_text}\n\s\send\n"
+          new_text = "\sdo#{new_text}\n\s\send\n"
         end
 
         range = get_range_for_fn_insert(@parsed_doc, link_text)

data/lib/ruby_lsp/ruby_lsp_ree/formatters/base_formatter.rb

@@ -4,7 +4,7 @@ module RubyLsp
       def self.call(source, uri, message_queue, index)
         new(message_queue, index).call(source, uri)
       rescue => e
-        $stderr.puts("error in #{self.class}: #{e.message} : #{e.backtrace.first}")
+        $stderr.puts("error in #{self}: #{e.message} : #{e.backtrace.first}")
         source
       end
 

data/lib/ruby_lsp/ruby_lsp_ree/formatters/missing_imports_formatter.rb

@@ -0,0 +1,63 @@
+require_relative 'base_formatter'
+require_relative "../ree_object_finder"
+
+module RubyLsp
+  module Ree
+    class MissingImportsFormatter < BaseFormatter
+      include RubyLsp::Ree::ReeLspUtils
+
+      def call(source, uri)
+        return source unless @index
+
+        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_source(source)
+        return source if !parsed_doc || !parsed_doc.has_root_class?
+
+        finder = ReeObjectFinder.new(@index)
+        editor = RubyLsp::Ree::ReeSourceEditor.new(source)
+
+        current_package = package_name_from_uri(uri)
+
+        fn_calls = parsed_doc.parse_fn_calls
+        filtered_fn_calls = filter_fn_calls(parsed_doc, fn_calls)
+        objects_to_add = filtered_fn_calls.map{ |fn_call|
+          finder.find_object(fn_call.name.to_s)
+        }.compact
+
+        bean_calls = parsed_doc.parse_bean_calls
+        filtered_bean_calls = filter_bean_calls(parsed_doc, bean_calls)
+        objects_to_add += filtered_bean_calls.map{ |bean_call|
+          finder.find_object(bean_call.receiver_name.to_s)
+        }.compact
+
+        objects_to_add.uniq!{ |obj| obj.name }
+        objects_to_add.reject!{ |obj| parsed_doc.includes_linked_object?(obj.name) }
+        return editor.source if objects_to_add.size == 0
+        
+        editor.add_links(parsed_doc, objects_to_add, current_package)
+        editor.source
+      end
+
+      private
+
+      def filter_fn_calls(parsed_doc, fn_calls)
+        parsed_doc.parse_instance_methods
+
+        fn_calls.reject{ |fn_call| 
+          parsed_doc.doc_instance_methods.map(&:name).include?(fn_call.name) 
+        }
+      end
+
+      def filter_bean_calls(parsed_doc, bean_calls)
+        bean_calls.select do |bean_call|
+          if !bean_call.method_name
+            true
+          else
+            method_obj = parsed_doc.doc_instance_methods.detect{ _1.name == bean_call.method_name }
+            local_variables = method_obj.parse_local_variables
+            !local_variables.map(&:name).include?(bean_call.receiver_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_ree/parsing/body_parsers/call_objects_parser.rb

@@ -0,0 +1,104 @@
+class RubyLsp::Ree::CallObjectsParser
+  attr_reader :parsed_doc
+
+  class CallObject
+    attr_reader :name, :type, :receiver_name, :method_name
+
+    def initialize(name:, type:, receiver_name: nil)
+      @name = name
+      @type = type
+      @receiver_name = receiver_name
+      @method_name = nil
+    end
+
+    def set_method_name(method_name)
+      @method_name = method_name
+    end
+  end
+
+  def initialize(parsed_doc)
+    @parsed_doc = parsed_doc
+  end
+
+  def class_call_objects
+    call_objects = []
+    return unless parsed_doc.has_body?
+
+    call_objects += parse_body_call_objects(parsed_doc.class_node.body.body)
+
+    parsed_doc.parse_instance_methods
+
+    parsed_doc.doc_instance_methods.each do |doc_instance_method|
+      call_objects += method_call_objects(doc_instance_method)
+    end
+
+    call_objects
+  end
+
+  def method_call_objects(method_object)
+    method_body = method_object.method_body
+    return [] unless method_body
+
+    call_nodes = parse_body_call_objects(method_body)
+    call_expressions = [] # don't parse call expressions for now parse_body_call_expressions(method_body)
+
+    call_objects = call_nodes + call_expressions
+
+    call_objects.each{ |call_object| call_object.set_method_name(method_object.name) }
+    call_objects
+  end
+
+  private 
+
+  def parse_body_call_objects(node_body)
+    call_objects = []
+    
+    node_body.each do |node|
+      if node.is_a?(Prism::CallNode)
+        receiver = get_first_receiver(node)
+        receiver_name = receiver.respond_to?(:name) ? receiver.name : nil
+        call_objects << CallObject.new(name: node.name, type: :method_call, receiver_name: receiver_name)
+      elsif node.respond_to?(:statements)
+        call_objects += parse_body_call_objects(node.statements.body)
+      elsif node.respond_to?(:block) && node.block && node.block.is_a?(Prism::BlockNode)
+        call_objects += parse_body_call_objects(get_method_body(node.block))
+      elsif node.respond_to?(:value) && node.value
+        call_objects += parse_body_call_objects([node.value])
+      end
+    end
+
+    call_objects
+  end
+
+  def parse_body_call_expressions(node_body)
+    call_expressions = []
+    
+    node_body.each do |node|
+      if node.respond_to?(:block) && node.block && node.block.is_a?(Prism::BlockArgumentNode) && node.block.expression.is_a?(Prism::SymbolNode)
+        call_expressions << CallObject.new(name: node.block.expression.unescaped.to_sym, type: :proc_to_sym)
+      end
+    end
+
+    call_expressions
+  end
+
+  def get_method_body(node)
+    return unless node.body
+
+    if node.body.is_a?(Prism::BeginNode)
+      node.body.statements.body
+    else
+      node.body.body
+    end
+  end
+
+  def get_first_receiver(node)
+    return nil unless node.receiver
+
+    if node.receiver.is_a?(Prism::CallNode) && node.receiver.receiver
+      return get_first_receiver(node.receiver)
+    end
+
+    node.receiver
+  end
+end

data/lib/ruby_lsp/ruby_lsp_ree/parsing/body_parsers/local_variables_parser.rb

@@ -0,0 +1,52 @@
+class RubyLsp::Ree::LocalVariablesParser
+  attr_reader :parsed_doc, :method_object
+
+  class LocalVariable
+    attr_reader :name
+
+    def initialize(name:)
+      @name = name
+    end
+  end
+
+  def initialize(method_obj)
+    @method_object = method_obj
+  end
+
+  def method_local_variables
+    method_body = method_object.method_body
+    return [] unless method_body
+
+    parse_body_local_variables(method_body)
+  end
+
+  private
+
+  def parse_body_local_variables(node_body)
+    local_variables = []
+    
+    node_body.each do |node|
+      if node.is_a?(Prism::LocalVariableWriteNode)
+        local_variables << LocalVariable.new(name: node.name)
+      elsif node.is_a?(Prism::MultiWriteNode)
+        local_variables += node.lefts.map{ |x| LocalVariable.new(name: x.name) }
+      elsif node.respond_to?(:statements)
+        local_variables += parse_body_local_variables(node.statements.body)
+      elsif node.respond_to?(:block) && node.block && node.block.is_a?(Prism::BlockNode)
+        local_variables += parse_body_local_variables(get_method_body(node.block))
+      end
+    end
+  
+    local_variables
+  end
+
+  def get_method_body(node)
+    return unless node.body
+
+    if node.body.is_a?(Prism::BeginNode)
+      node.body.statements.body
+    else
+      node.body.body
+    end
+  end
+end

data/lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_class_document.rb

@@ -2,6 +2,8 @@ require_relative 'parsed_base_document'
 require_relative 'parsed_link_node'
 require_relative 'parsed_method_node'
 require_relative "../ree_constants"
+require_relative "body_parsers/call_objects_parser"
+
 require 'ostruct'
 
 class RubyLsp::Ree::ParsedClassDocument < RubyLsp::Ree::ParsedBaseDocument
@@ -142,6 +144,7 @@ class RubyLsp::Ree::ParsedClassDocument < RubyLsp::Ree::ParsedBaseDocument
   end
 
   def parse_instance_methods
+    return if @doc_instance_methods
     @doc_instance_methods = []
 
     current_contract_node = nil
@@ -202,6 +205,14 @@ class RubyLsp::Ree::ParsedClassDocument < RubyLsp::Ree::ParsedBaseDocument
       .map(&:name)
   end
 
+  def parse_fn_calls
+    RubyLsp::Ree::CallObjectsParser.new(self).class_call_objects.select{ !_1.receiver_name }
+  end
+
+  def parse_bean_calls
+    RubyLsp::Ree::CallObjectsParser.new(self).class_call_objects.select{ _1.receiver_name }
+  end
+
   def class_name
     class_node.constant_path.name.to_s
   end

data/lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_method_node.rb

@@ -1,4 +1,5 @@
 require 'prism'
+require_relative "body_parsers/local_variables_parser"
 
 class RubyLsp::Ree::ParsedMethodNode
   attr_reader :method_node, :contract_node, :nested_local_methods
@@ -24,6 +25,10 @@ class RubyLsp::Ree::ParsedMethodNode
     @method_node.location.end_line - 1
   end
 
+  def method_body
+    get_method_body(@method_node)
+  end
+
   def raised_errors_nested
     return @raised_errors_nested if @raised_errors_nested
     raised = raised_errors
@@ -94,6 +99,10 @@ class RubyLsp::Ree::ParsedMethodNode
   def contract_in_parentheses?
     @contract_node.opening == '(' && @contract_node.closing == ')'
   end
+
+  def parse_local_variables
+    RubyLsp::Ree::LocalVariablesParser.new(self).method_local_variables
+  end
   
   def parse_nested_local_methods(local_methods)
     unless @method_node.body
@@ -111,6 +120,20 @@ class RubyLsp::Ree::ParsedMethodNode
     @nested_local_methods.each{ _1.parse_nested_local_methods(local_methods) }
   end
 
+  def parse_call_objects
+    method_body = get_method_body(@method_node)
+    return [] unless method_body
+
+    call_nodes = parse_body_call_objects(method_body)
+    call_expressions = parse_body_call_expressions(method_body)
+
+    call_node_names = call_nodes.map(&:name) + call_expressions
+
+    call_node_names
+  end
+
+  private
+
   def parse_body_call_objects(node_body)
     call_nodes = []
     
@@ -121,6 +144,8 @@ class RubyLsp::Ree::ParsedMethodNode
         call_nodes += parse_body_call_objects(node.statements.body)
       elsif node.respond_to?(:block) && node.block && node.block.is_a?(Prism::BlockNode)
         call_nodes += parse_body_call_objects(get_method_body(node.block))
+      elsif node.respond_to?(:value) && node.value
+        call_nodes += parse_body_call_objects([node.value])
       end
     end
 
@@ -140,6 +165,8 @@ class RubyLsp::Ree::ParsedMethodNode
   end
 
   def get_method_body(node)
+    return unless node.body
+
     if node.body.is_a?(Prism::BeginNode)
       node.body.statements.body
     else

data/lib/ruby_lsp/ruby_lsp_ree/ree_formatter.rb

@@ -3,6 +3,7 @@ require_relative 'formatters/missing_error_definitions_formatter'
 require_relative 'formatters/missing_error_contracts_formatter'
 require_relative 'formatters/missing_error_locales_formatter'
 require_relative 'formatters/unused_links_formatter'
+require_relative 'formatters/missing_imports_formatter'
 
 module RubyLsp
   module Ree
@@ -23,11 +24,12 @@ module RubyLsp
         source = document.source
 
         formatters = [
-          RubyLsp::Ree::SortLinksFormatter,
           RubyLsp::Ree::MissingErrorDefinitionsFormatter,
           RubyLsp::Ree::MissingErrorContractsFormatter,
           RubyLsp::Ree::MissingErrorLocalesFormatter,
           RubyLsp::Ree::UnusedLinksFormatter,
+          RubyLsp::Ree::MissingImportsFormatter,
+          RubyLsp::Ree::SortLinksFormatter,
         ].select do |formatter|
           formatter_name = formatter.name.split('::').last.to_sym
           @settings[formatter_name] != false

data/lib/ruby_lsp/ruby_lsp_ree/ree_source_editor.rb

@@ -63,6 +63,36 @@ module RubyLsp
           source_lines[i] = ''
         end
       end
+
+      def add_links(parsed_doc, ree_objects, current_package)
+        new_text = ''
+
+        ree_objects.each do |ree_object|
+          object_package = package_name_from_uri(ree_object.uri)
+
+          link_text = if current_package == object_package
+            "\s\slink :#{ree_object.name}"
+          else
+            "\s\slink :#{ree_object.name}, from: :#{object_package}"
+          end
+
+          if parsed_doc.links_container_node
+            link_text = "\s\s" + link_text
+          end
+        
+          new_text += "\n" + link_text
+        end
+
+        new_text += "\n"
+
+        if parsed_doc.has_blank_links_container?
+          new_text = "\sdo#{new_text}\s\send\n"
+        end
+
+        line = parsed_doc.links_container_node.location.start_line - 1
+
+        source_lines[line] = source_lines[line].chomp + new_text
+      end
     end
   end
 end

data/lib/ruby_lsp_ree/version.rb

@@ -2,6 +2,6 @@
 
 module RubyLsp
   module Ree
-    VERSION = "0.1.15"
+    VERSION = "0.1.16"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-ree
 version: !ruby/object:Gem::Version
-  version: 0.1.15
+  version: 0.1.16
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-04-18 00:00:00.000000000 Z
+date: 2025-04-24 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby LSP addon that adds extra editor functionality for Ree applications
 email:
@@ -33,6 +33,7 @@ files:
 - lib/ruby_lsp/ruby_lsp_ree/formatters/missing_error_contracts_formatter.rb
 - lib/ruby_lsp/ruby_lsp_ree/formatters/missing_error_definitions_formatter.rb
 - lib/ruby_lsp/ruby_lsp_ree/formatters/missing_error_locales_formatter.rb
+- lib/ruby_lsp/ruby_lsp_ree/formatters/missing_imports_formatter.rb
 - lib/ruby_lsp/ruby_lsp_ree/formatters/sort_links_formatter.rb
 - lib/ruby_lsp/ruby_lsp_ree/formatters/unused_links_formatter.rb
 - lib/ruby_lsp/ruby_lsp_ree/handlers/completion_handler.rb
@@ -41,6 +42,8 @@ files:
 - lib/ruby_lsp/ruby_lsp_ree/listeners/completion_listener.rb
 - lib/ruby_lsp/ruby_lsp_ree/listeners/definition_listener.rb
 - lib/ruby_lsp/ruby_lsp_ree/listeners/hover_listener.rb
+- lib/ruby_lsp/ruby_lsp_ree/parsing/body_parsers/call_objects_parser.rb
+- lib/ruby_lsp/ruby_lsp_ree/parsing/body_parsers/local_variables_parser.rb
 - lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_base_document.rb
 - lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_class_document.rb
 - lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_document_builder.rb