ruby-lsp-ree 0.1.0 → 0.1.2

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

@@ -0,0 +1,150 @@
+require_relative 'parsed_link_node'
+
+class RubyLsp::Ree::ParsedDocument
+  include RubyLsp::Ree::ReeLspUtils
+
+  LINK_DSL_MODULE = 'Ree::LinkDSL'
+
+  attr_reader :ast, :package_name, :class_node, :fn_node, :fn_block_node, :class_includes,
+    :link_nodes, :values, :action_node, :action_block_node, :dao_node, :dao_block_node, :filters,
+    :bean_node, :bean_block_node, :bean_methods
+
+  def initialize(ast)
+    @ast = ast
+  end
+
+  def links_container_node
+    @fn_node || @action_node || @dao_node || @bean_node
+  end
+
+  def links_container_block_node
+    @fn_block_node || @action_block_node || @dao_block_node || @bean_block_node
+  end
+
+  def includes_link_dsl?
+    @class_includes.any?{ _1.name == LINK_DSL_MODULE }
+  end
+
+  def includes_linked_constant?(const_name)
+    @link_nodes.map(&:imports).flatten.include?(const_name)
+  end
+
+  def includes_linked_object?(obj_name)
+    @link_nodes.map(&:name).include?(obj_name)
+  end
+
+  def has_blank_links_container?
+    links_container_node && !links_container_block_node
+  end
+
+  def set_package_name(package_name)
+    @package_name = package_name
+  end
+
+  def parse_class_node
+    @class_node ||= ast.statements.body.detect{ |node| node.is_a?(Prism::ClassNode) }
+  end
+
+  def parse_fn_node
+    return unless class_node
+
+    @fn_node ||= class_node.body.body.detect{ |node| node.name == :fn }
+    @fn_block_node = @fn_node&.block
+  end
+
+  def parse_action_node
+    return unless class_node
+
+    @action_node ||= class_node.body.body.detect{ |node| node.name == :action }
+    @action_block_node = @action_node&.block
+  end
+
+  def parse_dao_node
+    return unless class_node
+
+    @dao_node ||= class_node.body.body.detect{ |node| node.name == :dao }
+    @dao_block_node = @dao_node&.block
+  end
+
+  def parse_bean_node
+    return unless class_node
+
+    @bean_node ||= class_node.body.body.detect{ |node| node.name == :bean }
+    @bean_block_node = @bean_node&.block
+  end
+
+  def parse_class_includes
+    return unless class_node
+
+    @class_includes ||= class_node.body.body.select{ _1.name == :include }.map do |class_include|
+      parent_name = class_include.arguments.arguments.first.parent.name.to_s
+      module_name = class_include.arguments.arguments.first.name
+    
+      OpenStruct.new(
+        name: [parent_name, module_name].compact.join('::')
+      )          
+    end
+  end
+
+  def parse_links
+    return unless class_node
+
+    nodes = if links_container_node && links_container_block_node.body
+      links_container_block_node.body.body.select{ |node| node.name == :link }
+    elsif class_includes.any?{ _1.name == LINK_DSL_MODULE }
+      class_node.body.body.select{ |node| node.name == :link }
+    else
+      []
+    end
+
+    @link_nodes = nodes.map do |link_node|
+      link_node = RubyLsp::Ree::ParsedLinkNode.new(link_node, package_name)
+      link_node.parse_imports
+      link_node
+    end
+  end
+
+  def parse_values
+    return unless class_node
+    
+    @values ||= class_node.body.body
+      .select{ _1.name == :val }
+      .map{ OpenStruct.new(name: _1.arguments.arguments.first.unescaped) }
+  end
+
+  def parse_filters
+    return unless class_node
+    
+    @filters ||= class_node.body.body
+      .select{ _1.name == :filter }
+      .map{ OpenStruct.new(name: _1.arguments.arguments.first.unescaped, signatures: parse_filter_signature(_1)) }
+
+  end
+
+  def parse_bean_methods
+    return unless class_node
+    
+    @bean_methods ||= class_node.body.body
+      .select{ _1.is_a?(Prism::DefNode) }
+      .map{ OpenStruct.new(name: _1.name.to_s, signatures: parse_signatures_from_params(_1.parameters)) }
+  end
+
+  def parse_filter_signature(filter_node)
+    return [] unless filter_node
+
+    lambda_node = filter_node.arguments&.arguments[1]
+    return [] unless lambda_node
+
+    parse_signatures_from_params(lambda_node.parameters.parameters)
+  end
+
+  def parse_signatures_from_params(parameters)
+    signature_params = signature_params_from_node(parameters)
+    [RubyIndexer::Entry::Signature.new(signature_params)]
+  end
+
+  def get_class_name
+    name_parts = [class_node.constant_path&.parent&.name, class_node.constant_path.name]
+    name_parts.compact.map(&:to_s).join('::')
+  end
+end

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

@@ -0,0 +1,82 @@
+require 'prism'
+require_relative 'parsed_document'
+
+class RubyLsp::Ree::ParsedDocumentBuilder
+  extend RubyLsp::Ree::ReeLspUtils
+
+  def self.build_from_uri(uri, type = nil)
+    ast = Prism.parse_file(uri.path).value
+    document = build_document(ast, type)
+
+    document.set_package_name(package_name_from_uri(uri))
+
+    document
+  end
+
+  def self.build_from_ast(ast, uri, type = nil)
+    document = build_document(ast, type)
+
+    document.set_package_name(package_name_from_uri(uri))
+
+    document
+  end
+
+  def self.build_from_source(source, type = nil)
+    ast = Prism.parse(source).value
+    build_document(ast, type)
+  end
+
+  def self.build_document(ast, type)
+    case type
+    when :enum
+      build_enum_document(ast)
+    when :dao
+      build_dao_document(ast)
+    when :bean
+      build_bean_document(ast)
+    else
+      build_regular_document(ast)
+    end
+  end
+
+  def self.build_regular_document(ast)
+    document = RubyLsp::Ree::ParsedDocument.new(ast)
+    
+    document.parse_class_node
+    document.parse_fn_node
+    document.parse_action_node
+    document.parse_bean_node
+    document.parse_dao_node
+    document.parse_class_includes
+    document.parse_links
+
+    document
+  end   
+
+  def self.build_enum_document(ast)
+    document = RubyLsp::Ree::ParsedDocument.new(ast)
+    
+    document.parse_class_node
+    document.parse_values
+
+    document
+  end   
+
+  def self.build_dao_document(ast)
+    document = RubyLsp::Ree::ParsedDocument.new(ast)
+    
+    document.parse_class_node
+    document.parse_filters
+
+    document
+  end  
+  
+  def self.build_bean_document(ast)
+    document = RubyLsp::Ree::ParsedDocument.new(ast)
+    
+    document.parse_class_node
+    document.parse_bean_methods
+
+    document
+  end  
+end

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

@@ -0,0 +1,94 @@
+require 'prism'
+
+class RubyLsp::Ree::ParsedLinkNode
+  attr_reader :node, :document_package, :name, :imports
+
+  FROM_ARG_KEY = 'from'
+  IMPORT_ARG_KEY = 'import'
+
+  def initialize(node, document_package = nil)
+    @node = node
+    @document_package = document_package
+    @name = parse_name
+  end
+
+  def link_package_name
+    from_arg_value || document_package
+  end
+
+  def location
+    @node.location
+  end
+
+  def from_arg_value
+    @kw_args ||= @node.arguments.arguments.detect{ |arg| arg.is_a?(Prism::KeywordHashNode) }
+    return unless @kw_args
+
+    @from_param ||= @kw_args.elements.detect{ _1.key.unescaped == FROM_ARG_KEY }
+    return unless @from_param
+
+    @from_param.value.unescaped
+  end
+
+  def name_arg_node
+    @node.arguments.arguments.first
+  end
+
+  def link_type
+    return @link_type if @link_type
+    
+    @link_type = case name_arg_node
+    when Prism::SymbolNode
+      :object_name
+    when Prism::StringNode
+      :file_path
+    else
+      nil
+    end
+  end
+
+  def file_path_type?
+    link_type == :file_path
+  end
+
+  def object_name_type?
+    link_type == :object_name
+  end
+
+  def parse_name
+    case name_arg_node
+    when Prism::SymbolNode
+      name_arg_node.value
+    when Prism::StringNode
+      name_arg_node.unescaped
+    else
+      ""
+    end
+  end
+
+  def parse_imports
+    @imports ||= get_imports
+  end
+
+  private
+
+  def get_imports
+    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_ARG_KEY }
+      return [] unless import_arg
+
+      [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 []
+    end
+  rescue => e
+    $stderr.puts("can't parse imports: #{e.message}")
+    return []
+  end
+end

data/lib/ruby_lsp/ruby_lsp_ree/ree_formatter.rb

@@ -3,40 +3,31 @@ module RubyLsp
     class ReeFormatter
       include RubyLsp::Requests::Support::Formatter
       include RubyLsp::Ree::ReeLspUtils
-    
+
       def initialize
       end
-    
+
       def run_formatting(uri, document)
-        $stderr.puts("run_formating")
-    
         source = document.source
         sort_links(source)
       end
-    
+
       private
-    
+
       def sort_links(source)
-        doc_info = parse_document_from_source(source)
-      
-        return source unless doc_info.fn_node
-        return source if doc_info.fn_node && !doc_info.block_node
-        
-        if doc_info.link_nodes.size < doc_info.block_node.body.body.size
-          $stderr.puts("block contains not only link, don't sort")
-          return source
-        end
-    
-        if doc_info.link_nodes.any?{ _1.location.start_line != _1.location.end_line }
+        parsed_doc = RubyLsp::Ree::ParsedDocumentBuilder.build_from_source(source)
+        return source if !parsed_doc.link_nodes&.any?
+
+        if parsed_doc.link_nodes.any?{ _1.location.start_line != _1.location.end_line }
           $stderr.puts("multiline link definitions, don't sort")
           return source
         end
-    
+
         # sort link nodes
-        sorted_link_nodes = doc_info.link_nodes.sort{ |a, b|
-          a_name = a.arguments.arguments.first
-          b_name = b.arguments.arguments.first
-          
+        sorted_link_nodes = parsed_doc.link_nodes.sort{ |a, b|
+          a_name = a.node.arguments.arguments.first
+          b_name = b.node.arguments.arguments.first
+
           if a_name.is_a?(Prism::SymbolNode) && !b_name.is_a?(Prism::SymbolNode)
             -1
           elsif b_name.is_a?(Prism::SymbolNode) && !a_name.is_a?(Prism::SymbolNode)
@@ -45,25 +36,25 @@ module RubyLsp
             a_name.unescaped <=> b_name.unescaped
           end
         }
-          
+
         # check if no re-order
-        if doc_info.link_nodes.map{ _1.arguments.arguments.first.unescaped } == sorted_link_nodes.map{ _1.arguments.arguments.first.unescaped }
+        if parsed_doc.link_nodes.map{ _1.node.arguments.arguments.first.unescaped } == sorted_link_nodes.map{ _1.node.arguments.arguments.first.unescaped }
           return source
         end
-    
+
         # insert nodes to source
-        link_lines = doc_info.link_nodes.map{ _1.location.start_line }
-    
+        link_lines = parsed_doc.link_nodes.map{ _1.location.start_line }
+
         source_lines = source.lines
-    
+
         sorted_lines = sorted_link_nodes.map do |sorted_link|
           source_lines[sorted_link.location.start_line - 1]
         end
-    
+
         link_lines.each_with_index do |link_line, index|
           source_lines[link_line - 1] = sorted_lines[index]
         end
-    
+
         source_lines.join()
       end
     end

data/lib/ruby_lsp/ruby_lsp_ree/ree_indexing_enhancement.rb

@@ -1,42 +1,37 @@
+require 'prism'
+require_relative "ree_lsp_utils"
+
 module RubyLsp
   module Ree
     class ReeIndexingEnhancement < RubyIndexer::Enhancement
+      include RubyLsp::Ree::ReeLspUtils
+
+      REE_INDEXED_OBJECTS = [:fn, :enum, :action, :dao, :bean]
+
       def on_call_node_enter(node)
         return unless @listener.current_owner
 
-        # Return early unless the method call is the one we want to handle
-        return unless node.name == :fn
+        return unless REE_INDEXED_OBJECTS.include?(node.name)
         return unless node.arguments
+        return unless node.arguments.child_nodes.first.is_a?(Prism::SymbolNode)
+
+        obj_name = node.arguments.child_nodes.first.unescaped
+        return unless current_filename == obj_name
 
-        # index = @listener.instance_variable_get(:@index)
-        
         location = node.location
-        fn_name = node.arguments.child_nodes.first.unescaped
-        signatures = parse_signatures(fn_name)
-        comments = "ree_object\nsome_documentation"
-      
-        # visibility = RubyIndexer::Entry::Visibility::PUBLIC
-        # owner = index['Object'].first
-
-        # index.add(RubyIndexer::Entry::Method.new(
-        #   fn_name,
-        #   @listener.instance_variable_get(:@uri),
-        #   location,
-        #   location,
-        #   comments,
-        #   signatures,
-        #   visibility,
-        #   owner,
-        # ))
+        signatures = parse_signatures(obj_name)
+        comments = "ree_object\ntype: :#{node.name}"
 
         @listener.add_method(
-          fn_name,
+          obj_name,
           location, 
           signatures,
           comments: comments
         )
       end
 
+      private
+
       def parse_signatures(fn_name)
         uri = @listener.instance_variable_get(:@uri)
         ast = Prism.parse_file(uri.path).value
@@ -44,13 +39,18 @@ module RubyLsp
         class_node = ast.statements.body.detect{ |node| node.is_a?(Prism::ClassNode) }
         return [] unless class_node
 
-        call_node = class_node.body.body.detect{ |node| node.name == :call }
+        call_node = class_node.body.body.detect{ |node| node.respond_to?(:name) && node.name == :call }
         return [] unless call_node
-        
-        signature_params = @listener.send(:list_params, call_node.parameters)
+
+        signature_params = signature_params_from_node(call_node.parameters)
 
         [RubyIndexer::Entry::Signature.new(signature_params)]
       end
+
+      def current_filename
+        uri = @listener.instance_variable_get(:@uri)
+        File.basename(uri.path, '.rb')  
+      end
     end
   end
 end