ruby-lsp-ree 0.1.0 → 0.1.2

data/lib/ruby_lsp/ruby_lsp_ree/ree_lsp_utils.rb

@@ -1,78 +1,54 @@
 module RubyLsp
   module Ree
     module ReeLspUtils
+      Entry = RubyIndexer::Entry
+
+      def find_local_file_path(file_path)
+        file_name = file_path + ".rb"
+        Dir[File.join('**', file_name)].first
+      end
+
       def package_name_from_uri(uri)
         uri_parts = uri.to_s.split('/')
-        package_index = uri_parts.find_index('package') + 1
-        uri_parts[package_index]
-      end
+        
+        package_folder_index = uri_parts.find_index('package')
+        return unless package_folder_index
 
-      def path_from_package(uri)
-        uri_parts = uri.chomp(File.extname(uri)).split('/')
-        pack_folder_index = uri_parts.index('package')
-        uri_parts.drop(pack_folder_index+1).join('/')
+        uri_parts[package_folder_index + 1]
       end
 
-      def parse_document_from_uri(uri)
-        ast = Prism.parse_file(uri.path).value
-        result = parse_document(ast)
+      def path_from_package_folder(uri)
+        uri_parts = uri.chomp(File.extname(uri)).split('/')
 
-        result.package_name = package_name_from_uri(uri)
+        package_folder_index = uri_parts.index('package')
+        return unless package_folder_index
 
-        result
+        uri_parts.drop(package_folder_index+1).join('/')
       end
 
-      def parse_document_from_source(source)
-        ast = Prism.parse(source).value
-        parse_document(ast)
-      end
+      def get_ree_type(ree_object)
+        type_comment = ree_object.comments.to_s.lines[1]
+        return unless type_comment
 
-      def parse_document(ast)
-        class_node = ast.statements.body.detect{ |node| node.is_a?(Prism::ClassNode) }
-        fn_node = class_node.body.body.detect{ |node| node.name == :fn }
-        block_node = fn_node.block
+        type_comment.split(' ').last
+      end
 
-        link_nodes = if block_node && block_node.body
-          block_node.body.body.select{ |node| node.name == :link }
-        else
-          []
-        end
+      def get_range_for_fn_insert(parsed_doc, link_text)
+        fn_line = nil
+        position = nil
 
-        linked_objects = link_nodes.map do |link_node|
-          name_arg_node = link_node.arguments.arguments.first
+        if parsed_doc.links_container_node
+          links_container_node = parsed_doc.links_container_node
+          fn_line = links_container_node.location.start_line
 
-          name_val = case name_arg_node
-          when Prism::SymbolNode
-            name_arg_node.value
-          when Prism::StringNode
-            name_arg_node.unescaped
+          position = if parsed_doc.links_container_block_node
+            parsed_doc.links_container_block_node.opening_loc.end_column + 1
           else
-            ""
+            links_container_node.arguments.location.end_column + 1
           end
-
-          OpenStruct.new(
-            name: name_val,
-            imports: parse_link_node_imports(link_node)
-          )
-        end
-
-        return OpenStruct.new(
-          ast: ast,
-          class_node: class_node,
-          fn_node: fn_node,
-          block_node: block_node,
-          link_nodes: link_nodes,
-          linked_objects: linked_objects
-        )
-      end   
-
-      def get_range_for_fn_insert(doc_info, link_text)
-        fn_line = doc_info.fn_node.location.start_line
-
-        position = if doc_info.block_node
-          doc_info.block_node.opening_loc.end_column + 1
-        else
-          doc_info.fn_node.arguments.location.end_column + 1
+        elsif parsed_doc.includes_link_dsl?
+          fn_line = parsed_doc.link_nodes.first.location.start_line - 1
+          position = parsed_doc.link_nodes.first.location.start_column
         end
 
         Interface::Range.new(
@@ -81,24 +57,94 @@ module RubyLsp
         )
       end
 
-      def parse_link_node_imports(node)
-        return [] if node.arguments.arguments.size == 1
-        
-        last_arg = node.arguments.arguments.last
 
-        if last_arg.is_a?(Prism::KeywordHashNode)
-          import_arg = last_arg.elements.detect{ _1.key.unescaped == 'import' }
-          return [] unless import_arg
+      # params(parameters_node: Prism::ParametersNode).returns(Array[Entry::Parameter])
+      # copied from ruby-lsp DeclarationListener#list_params
+      def signature_params_from_node(parameters_node)
+        return [] unless parameters_node
+  
+        parameters = []
+  
+        parameters_node.requireds.each do |required|
+          name = parameter_name(required)
+          next unless name
+  
+          parameters << Entry::RequiredParameter.new(name: name)
+        end
+  
+        parameters_node.optionals.each do |optional|
+          name = parameter_name(optional)
+          next unless name
+  
+          parameters << Entry::OptionalParameter.new(name: name)
+        end
+  
+        rest = parameters_node.rest
+  
+        if rest.is_a?(Prism::RestParameterNode)
+          rest_name = rest.name || Entry::RestParameter::DEFAULT_NAME
+          parameters << Entry::RestParameter.new(name: rest_name)
+        end
+  
+        parameters_node.keywords.each do |keyword|
+          name = parameter_name(keyword)
+          next unless name
+  
+          case keyword
+          when Prism::RequiredKeywordParameterNode
+            parameters << Entry::KeywordParameter.new(name: name)
+          when Prism::OptionalKeywordParameterNode
+            parameters << Entry::OptionalKeywordParameter.new(name: name)
+          end
+        end
+  
+        keyword_rest = parameters_node.keyword_rest
+  
+        case keyword_rest
+        when Prism::KeywordRestParameterNode
+          keyword_rest_name = parameter_name(keyword_rest) || Entry::KeywordRestParameter::DEFAULT_NAME
+          parameters << Entry::KeywordRestParameter.new(name: keyword_rest_name)
+        when Prism::ForwardingParameterNode
+          parameters << Entry::ForwardingParameter.new
+        end
+  
+        parameters_node.posts.each do |post|
+          name = parameter_name(post)
+          next unless name
+  
+          parameters << Entry::RequiredParameter.new(name: name)
+        end
+  
+        block = parameters_node.block
+        parameters << Entry::BlockParameter.new(name: block.name || Entry::BlockParameter::DEFAULT_NAME) if block
+  
+        parameters
+      end
+
+      # params(node: Prism::Node).returns(Symbol)
+      # copied from ruby-lsp DeclarationListener#parameter_name
+      def parameter_name(node)
+        case node
+        when Prism::RequiredParameterNode, Prism::OptionalParameterNode,
+          Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode,
+          Prism::RestParameterNode, Prism::KeywordRestParameterNode
+          node.name
+        when Prism::MultiTargetNode
+          names = node.lefts.map { |parameter_node| parameter_name(parameter_node) }
+
+          rest = node.rest
+          if rest.is_a?(Prism::SplatNode)
+            name = rest.expression&.slice
+            names << (rest.operator == "*" ? "*#{name}".to_sym : name&.to_sym)
+          end
+
+          names << nil if rest.is_a?(Prism::ImplicitRestNode)
+
+          names.concat(node.rights.map { |parameter_node| parameter_name(parameter_node) })
 
-          [import_arg.value.body.body.first.name.to_s]
-        elsif last_arg.is_a?(Prism::LambdaNode)
-          [last_arg.body.body.first.name.to_s]
-        else
-          return []
+          names_with_commas = names.join(", ")
+          :"(#{names_with_commas})"
         end
-      rescue => e
-        $stderr.puts("can't parse imports: #{e.message}")
-        return []
       end
     end
   end

data/lib/ruby_lsp/ruby_lsp_ree/ree_object_finder.rb

@@ -0,0 +1,43 @@
+module RubyLsp
+  module Ree
+    class ReeObjectFinder
+      MAX_LIMIT = 1000
+
+      REE_OBJECT_STRING = 'ree_object'
+      ENUM_TYPE_STRING = 'type: :enum'
+      DAO_TYPE_STRING = 'type: :dao'
+      BEAN_TYPE_STRING = 'type: :bean'
+
+      def self.search_objects(index, name, limit)
+        index.prefix_search(name)
+          .take(MAX_LIMIT)
+          .flatten
+          .select{ _1.comments }
+          .select{ _1.comments.to_s.lines.first&.chomp == REE_OBJECT_STRING }
+          .sort_by{ _1.name.length }
+          .take(limit)
+      end
+
+      def self.find_enum(index, name)
+        objects_by_name = index[name]
+        return unless objects_by_name
+
+        objects_by_name.detect{ _1.comments.lines[1]&.chomp == ENUM_TYPE_STRING }
+      end
+
+      def self.find_dao(index, name)
+        objects_by_name = index[name]
+        return unless objects_by_name
+
+        objects_by_name.detect{ _1.comments.lines[1]&.chomp == DAO_TYPE_STRING }
+      end
+
+      def self.find_bean(index, name)
+        objects_by_name = index[name]
+        return unless objects_by_name
+
+        objects_by_name.detect{ _1.comments.lines[1]&.chomp == BEAN_TYPE_STRING }
+      end
+    end
+  end
+end

data/lib/ruby_lsp_ree/version.rb

@@ -3,7 +3,7 @@
 module Ruby
   module Lsp
     module Ree
-      VERSION = "0.1.0"
+      VERSION = "0.1.2"
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-ree
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Ruslan Gatiyatov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-01-31 00:00:00.000000000 Z
+date: 2025-02-14 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby LSP addon that adds extra editor functionality for Ree applications
 email:
@@ -20,15 +20,21 @@ files:
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/ruby_lsp/ruby_lsp_ree/addon.rb
 - lib/ruby_lsp/ruby_lsp_ree/completion.rb
+- lib/ruby_lsp/ruby_lsp_ree/completion_utils.rb
 - lib/ruby_lsp/ruby_lsp_ree/definition.rb
+- lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_document.rb
+- lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_document_builder.rb
+- lib/ruby_lsp/ruby_lsp_ree/parsing/parsed_link_node.rb
 - lib/ruby_lsp/ruby_lsp_ree/ree_formatter.rb
 - lib/ruby_lsp/ruby_lsp_ree/ree_indexing_enhancement.rb
 - lib/ruby_lsp/ruby_lsp_ree/ree_lsp_utils.rb
+- lib/ruby_lsp/ruby_lsp_ree/ree_object_finder.rb
 - lib/ruby_lsp_ree.rb
 - lib/ruby_lsp_ree/version.rb
 - ruby-lsp-ree.gemspec