rucoa 0.4.0 → 0.5.0

data/lib/rucoa/nodes/def_node.rb

@@ -4,9 +4,68 @@ module Rucoa
   module Nodes
     class DefNode < Base
       # @return [String]
+      # @example returns method name
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY
+      #       module Foo
+      #         class Bar
+      #           def baz
+      #           end
+      #         end
+      #       end
+      #     RUBY
+      #   ).node_at(
+      #     Rucoa::Position.new(
+      #       column: 4,
+      #       line: 3
+      #     )
+      #   )
+      #   expect(node.name).to eq('baz')
       def name
         children[0].to_s
       end
+
+      # @return [String]
+      # @example returns full qualified name
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY
+      #       module Foo
+      #         class Bar
+      #           def baz
+      #           end
+      #         end
+      #       end
+      #     RUBY
+      #   ).node_at(
+      #     Rucoa::Position.new(
+      #       column: 4,
+      #       line: 3
+      #     )
+      #   )
+      #   expect(node.full_qualified_name).to eq('Foo::Bar#baz')
+      def full_qualified_name
+        [
+          namespace,
+          method_marker,
+          name
+        ].join
+      end
+
+      private
+
+      # @return [String]
+      def method_marker
+        if singleton?
+          '.'
+        else
+          '#'
+        end
+      end
+
+      # @return [Boolean]
+      def singleton?
+        each_ancestor(:sclass).any?
+      end
     end
   end
 end

data/lib/rucoa/nodes/lvar_node.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Nodes
+    class LvarNode < Base
+      # @return [String]
+      # @example returns local variable name
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY
+      #       foo = 1
+      #       foo
+      #     RUBY
+      #   ).node_at(
+      #     Rucoa::Position.new(
+      #       column: 2,
+      #       line: 2
+      #     )
+      #   )
+      #   expect(node.name).to eq('foo')
+      def name
+        children[0].to_s
+      end
+    end
+  end
+end

data/lib/rucoa/nodes/send_node.rb

@@ -4,14 +4,57 @@ module Rucoa
   module Nodes
     class SendNode < Base
       # @return [Array<Rucoa::Nodes::Base>]
+      # @example returns arguments
+      #   node = Rucoa::Parser.call(
+      #     <<~RUBY
+      #       foo(bar, baz)
+      #     RUBY
+      #   )
+      #   expect(node.arguments.map(&:name)).to eq(
+      #     %w[
+      #       bar
+      #       baz
+      #     ]
+      #   )
       def arguments
         children[2..]
       end
 
       # @return [String]
+      # @example returns method name
+      #   node = Rucoa::Parser.call(
+      #     <<~RUBY
+      #       foo(bar, baz)
+      #     RUBY
+      #   )
+      #   expect(node.name).to eq('foo')
       def name
         children[1].to_s
       end
+
+      # @return [Rucoa::Nodes::Base, nil]
+      # @example returns nil for receiver-less method call
+      #   node = Rucoa::Parser.call(
+      #     <<~RUBY
+      #       foo(bar, baz)
+      #     RUBY
+      #   )
+      #   expect(node.receiver).to be_nil
+      # @example returns receiver
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY
+      #       foo.bar
+      #     RUBY
+      #   ).node_at(
+      #     Rucoa::Position.new(
+      #       column: 4,
+      #       line: 1
+      #     )
+      #   )
+      #   expect(node.receiver).to be_a(Rucoa::Nodes::SendNode)
+      def receiver
+        children[0]
+      end
     end
   end
 end

data/lib/rucoa/nodes.rb

@@ -8,6 +8,7 @@ module Rucoa
     autoload :ConstNode, 'rucoa/nodes/const_node'
     autoload :DefNode, 'rucoa/nodes/def_node'
     autoload :DefsNode, 'rucoa/nodes/defs_node'
+    autoload :LvarNode, 'rucoa/nodes/lvar_node'
     autoload :ModuleNode, 'rucoa/nodes/module_node'
     autoload :SclassNode, 'rucoa/nodes/sclass_node'
     autoload :SendNode, 'rucoa/nodes/send_node'

data/lib/rucoa/parser_builder.rb

@@ -10,6 +10,7 @@ module Rucoa
       const: Nodes::ConstNode,
       def: Nodes::DefNode,
       defs: Nodes::DefsNode,
+      lvar: Nodes::LvarNode,
       module: Nodes::ModuleNode,
       sclass: Nodes::SclassNode,
       send: Nodes::SendNode,

data/lib/rucoa/range.rb

@@ -30,28 +30,85 @@ module Rucoa
 
     # @param beginning [Rucoa::Position]
     # @param ending [Ruoca::Position]
-    # @param exclude_end [Boolean]
-    def initialize(beginning, ending, exclude_end: true)
+    # @param including_ending [Boolean]
+    def initialize(beginning, ending, including_ending: true)
       @beginning = beginning
       @ending = ending
-      @exclude_end = exclude_end
+      @including_ending = including_ending
     end
 
     # @param range [Rucoa::Range]
     # @return [Boolean]
-    def contains?(range)
-      copy = with_including_end
-      copy.include?(range.beginning) && copy.include?(range.ending)
+    # @example returns true when the range is contained in self
+    #   range = Rucoa::Range.new(
+    #     Rucoa::Position.new(
+    #       column: 0,
+    #       line: 0
+    #     ),
+    #     Rucoa::Position.new(
+    #       column: 0,
+    #       line: 2
+    #     )
+    #   )
+    #   expect(range).to contain(
+    #     Rucoa::Range.new(
+    #       Rucoa::Position.new(
+    #         column: 0,
+    #         line: 0
+    #       ),
+    #       Rucoa::Position.new(
+    #         column: 0,
+    #         line: 0
+    #       )
+    #     )
+    #   )
+    def contain?(range)
+      include?(range.beginning) && include?(range.ending)
     end
 
     # @param position [Rucoa::Position]
     # @return [Boolean]
+    # @example returns true when the position is included in self
+    #   range = Rucoa::Range.new(
+    #     Rucoa::Position.new(
+    #       column: 0,
+    #       line: 0
+    #     ),
+    #     Rucoa::Position.new(
+    #       column: 0,
+    #       line: 2
+    #     )
+    #   )
+    #   expect(range).to include(
+    #     Rucoa::Position.new(
+    #       column: 0,
+    #       line: 0
+    #     )
+    #   )
+    #   expect(range).to include(
+    #     Rucoa::Position.new(
+    #       column: 0,
+    #       line: 1
+    #     )
+    #   )
+    #   expect(range).to include(
+    #     Rucoa::Position.new(
+    #       column: 0,
+    #       line: 2
+    #     )
+    #   )
+    #   expect(range).not_to include(
+    #     Rucoa::Position.new(
+    #       column: 0,
+    #       line: 3
+    #     )
+    #   )
     def include?(position)
       return false if position.line > @ending.line
       return false if position.line < @beginning.line
       return false if position.column < @beginning.column
       return false if position.column > @ending.column
-      return false if position.column == @ending.column && @exclude_end
+      return false if position.column == @ending.column && !@including_ending
 
       true
     end
@@ -63,12 +120,5 @@ module Rucoa
         start: @beginning.to_vscode_position
       }
     end
-
-    private
-
-    # @return [Rucoa::Range]
-    def with_including_end
-      self.class.new(@beginning, @ending, exclude_end: false)
-    end
   end
 end

data/lib/rucoa/rbs_document_loader.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'rbs'
+
+module Rucoa
+  class RbsDocumentLoader
+    class << self
+      def call
+        new.call
+      end
+    end
+
+    # @return [Array<Rucoa::Definitions::Base>]
+    def call
+      declarations.flat_map do |declaration|
+        case declaration
+        when ::RBS::AST::Declarations::Constant
+          [
+            DefinitionBuilders::RbsConstantDefinitionBuilder.call(declaration: declaration)
+          ]
+        when ::RBS::AST::Declarations::Class, ::RBS::AST::Declarations::Module
+          declaration.members.grep(::RBS::AST::Members::MethodDefinition).map do |method_definition|
+            DefinitionBuilders::RbsMethodDefinitionBuilder.call(
+              declaration: declaration,
+              method_definition: method_definition
+            )
+          end
+        else
+          []
+        end
+      end
+    end
+
+    private
+
+    # @return [Array<RBS::AST::Declarations::Base>]
+    def declarations
+      ::RBS::Environment.from_loader(
+        ::RBS::EnvironmentLoader.new
+      ).resolve_type_names.declarations
+    end
+  end
+end

data/lib/rucoa/rubocop_autocorrector.rb

@@ -31,7 +31,7 @@ module Rucoa
     # @return [String]
     def call
       @options[:stdin] = @source.content
-      run([@source.path])
+      run([@source.path || 'untitled'])
       @options[:stdin]
     end
   end

data/lib/rucoa/rubocop_investigator.rb

@@ -31,7 +31,7 @@ module Rucoa
     # @return [Array<RuboCop::Cop::Offense>]
     def call
       @options[:stdin] = @source.content
-      run([@source.path])
+      run([@source.path || 'untitled'])
       @offenses
     end
 

data/lib/rucoa/server.rb

@@ -4,8 +4,10 @@ module Rucoa
   class Server
     # @return [Hash{String => Class}]
     METHOD_TO_HANDLER_MAP = {
+      'exit' => Handlers::ExitHandler,
       'initialize' => Handlers::InitializeHandler,
       'initialized' => Handlers::InitializedHandler,
+      'shutdown' => Handlers::ShutdownHandler,
       'textDocument/codeAction' => Handlers::TextDocumentCodeActionHandler,
       'textDocument/didChange' => Handlers::TextDocumentDidChangeHandler,
       'textDocument/didOpen' => Handlers::TextDocumentDidOpenHandler,
@@ -13,13 +15,20 @@ module Rucoa
       'textDocument/formatting' => Handlers::TextDocumentFormattingHandler,
       'textDocument/rangeFormatting' => Handlers::TextDocumentRangeFormattingHandler,
       'textDocument/selectionRange' => Handlers::TextDocumentSelectionRangeHandler,
+      'textDocument/signatureHelp' => Handlers::TextDocumentSignatureHelpHandler,
       'workspace/didChangeConfiguration' => Handlers::WorkspaceDidChangeConfigurationHandler
     }.freeze
     private_constant :METHOD_TO_HANDLER_MAP
 
+    # @return [Boolean]
+    attr_accessor :shutting_down
+
     # @return [Rucoa::Configuration]
     attr_reader :configuration
 
+    # @return [Rucoa::DefinitionStore]
+    attr_reader :definition_store
+
     # @return [Rucoa::SourceStore]
     attr_reader :source_store
 
@@ -29,10 +38,14 @@ module Rucoa
       @reader = MessageReader.new(input)
       @writer = MessageWriter.new(output)
 
+      @client_response_handlers = {}
       @configuration = Configuration.new
       @server_request_id = 0
-      @client_response_handlers = {}
+      @shutting_down = false
       @source_store = SourceStore.new
+
+      @definition_store = DefinitionStore.new
+      @definition_store.definitions += DefinitionArchiver.load
     end
 
     # @return [void]
@@ -42,6 +55,11 @@ module Rucoa
       end
     end
 
+    # @return [void]
+    def finish
+      exit(0)
+    end
+
     # @yieldparam response [Hash]
     # @param message [Hash]
     # @return [void]

data/lib/rucoa/source.rb

@@ -6,13 +6,59 @@ module Rucoa
     attr_reader :content
 
     # @return [String]
-    attr_reader :path
+    attr_reader :uri
 
     # @param content [String]
-    # @param path [String, nil]
-    def initialize(content:, path: nil)
+    # @param uri [String, nil]
+    def initialize(content:, uri: nil)
       @content = content
-      @path = path
+      @uri = uri
+    end
+
+    # @return [Array<Rucoa::Definition::Base>]
+    # @example returns definitions from given source
+    #   content = <<~RUBY
+    #     class Foo
+    #       def bar
+    #       end
+    #     end
+    #   RUBY
+    #   source = Rucoa::Source.new(
+    #     content: content,
+    #     uri: 'file:///path/to/foo.rb'
+    #   )
+    #   expect(source.definitions).to match(
+    #     [
+    #       a_kind_of(Rucoa::Definitions::MethodDefinition)
+    #     ]
+    #   )
+    def definitions
+      @definitions ||= YardStringDocumentLoader.call(
+        content: @content,
+        path: path
+      )
+    end
+
+    # @return [String, nil]
+    # @example returns path from given VSCode URI
+    #   source = Rucoa::Source.new(
+    #     content: '',
+    #     uri: 'file:///path/to/foo.rb'
+    #   )
+    #   expect(source.path).to eq('/path/to/foo.rb')
+    # @example returns nil for untitled URI
+    #   source = Rucoa::Source.new(
+    #     content: '',
+    #     uri: 'untitled:Untitled-1'
+    #   )
+    #   expect(source.path).to be_nil
+    def path
+      return unless @uri
+
+      path = ::URI.parse(@uri).path
+      return unless path
+
+      ::CGI.unescape(path)
     end
 
     # @param position [Rucoa::Position]
@@ -21,11 +67,15 @@ module Rucoa
       root_and_descendant_nodes.reverse.find do |node|
         node.include_position?(position)
       end
+    rescue ::Parser::SyntaxError
+      nil
     end
 
     # @return [Rucoa::Nodes::Base, nil]
     def root_node
       @root_node ||= Parser.call(@content)
+    rescue ::Parser::SyntaxError
+      nil
     end
 
     private

data/lib/rucoa/source_store.rb

@@ -9,22 +9,18 @@ module Rucoa
       @data = {}
     end
 
+    # @param source [Rucoa::Source]
+    # @return [void]
+    def update(source)
+      @data[source.uri] = source
+    end
+
     # @param uri [String]
     # @return [String, nil]
     def get(uri)
       @data[uri]
     end
 
-    # @param uri [String]
-    # @param content [String]
-    # @return [void]
-    def set(uri, content)
-      @data[uri] = Source.new(
-        content: content,
-        path: path_from_uri(uri)
-      )
-    end
-
     # @yieldparam uri [String]
     # @return [Enumerable<String>]
     def each_uri(&block)

data/lib/rucoa/types/method_type.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Types
+    class MethodType
+      # @return [String]
+      attr_reader :parameters_string
+
+      # @return [String]
+      attr_reader :return_type
+
+      # @param parameters_string [String]
+      # @param return_type [String]
+      def initialize(
+        parameters_string:,
+        return_type:
+      )
+        @parameters_string = parameters_string
+        @return_type = return_type
+      end
+    end
+  end
+end

data/lib/rucoa/types.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Types
+    autoload :MethodType, 'rucoa/types/method_type'
+  end
+end

data/lib/rucoa/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rucoa
-  VERSION = '0.4.0'
+  VERSION = '0.5.0'
 end

data/lib/rucoa/yard_glob_document_loader.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'yard'
+
+module Rucoa
+  class YardGlobDocumentLoader
+    class << self
+      # @param globs [Array<String>]
+      # @return [Array<Rucoa::Definitions::Base>]
+      def call(globs:)
+        new(
+          globs: globs
+        ).call
+      end
+    end
+
+    # @param globs [String]
+    def initialize(globs:)
+      @globs = globs
+    end
+
+    # @return [Array<Rucoa::Definitions::Base>]
+    def call
+      code_objects.filter_map do |code_object|
+        case code_object
+        when ::YARD::CodeObjects::MethodObject
+          DefinitionBuilders::YardMethodDefinitionBuilder.call(
+            code_object: code_object,
+            path: code_object.file
+          )
+        end
+      end
+    end
+
+    private
+
+    # @return [Array<YARD::CodeObjects::Base>]
+    def code_objects
+      ::YARD::Logger.instance.enter_level(::Logger::FATAL) do
+        ::YARD::Registry.clear
+        ::YARD.parse(@globs)
+        ::YARD::Registry.all
+      end
+    end
+  end
+end

data/lib/rucoa/yard_string_document_loader.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'yard'
+
+module Rucoa
+  class YardStringDocumentLoader
+    class << self
+      # @param content [String]
+      # @return [Array<Rucoa::Definitions::Base>]
+      # @example returns method definitions from Ruby source code
+      #   content = <<~RUBY
+      #     class Foo
+      #       # Return given argument as an Integer.
+      #       # @param bar [String]
+      #       # @return [Integer]
+      #       def foo(bar)
+      #         bar.to_i
+      #       end
+      #     end
+      #   RUBY
+      #   definitions = Rucoa::YardStringDocumentLoader.call(
+      #     content: content,
+      #     path: '/path/to/foo.rb'
+      #   )
+      #   expect(definitions.size).to eq(1)
+      #   expect(definitions.first.full_qualified_name).to eq('Foo#foo')
+      #   expect(definitions.first.source_path).to eq('/path/to/foo.rb')
+      #   expect(definitions.first.description).to eq('Return given argument as an Integer.')
+      #   expect(definitions.first.return_types).to eq(%w[Integer])
+      def call(content:, path:)
+        new(
+          content: content,
+          path: path
+        ).call
+      end
+    end
+
+    # @param content [String]
+    # @param path [String]
+    def initialize(content:, path:)
+      @content = content
+      @path = path
+    end
+
+    # @return [Array<Rucoa::Definitions::Base>]
+    def call
+      code_objects.filter_map do |code_object|
+        case code_object
+        when ::YARD::CodeObjects::MethodObject
+          DefinitionBuilders::YardMethodDefinitionBuilder.call(
+            code_object: code_object,
+            path: @path
+          )
+        end
+      end
+    end
+
+    private
+
+    # @return [Array<YARD::CodeObjects::Base>]
+    def code_objects
+      ::YARD::Logger.instance.enter_level(::Logger::FATAL) do
+        ::YARD::Registry.clear
+        ::YARD.parse_string(@content)
+        ::YARD::Registry.all
+      end
+    end
+  end
+end