rucoa 0.2.0 → 0.5.0

data/lib/rucoa/range.rb

@@ -11,19 +11,106 @@ module Rucoa
           Position.from_parser_range_ending(range)
         )
       end
+
+      # @param hash [Hash]
+      # @return [Rucoa::Range]
+      def from_vscode_range(hash)
+        new(
+          Position.from_vscode_position(hash['start']),
+          Position.from_vscode_position(hash['end'])
+        )
+      end
     end
 
+    # @return [Rucoa::Position]
+    attr_reader :beginning
+
+    # @return [Rucoa::Position]
+    attr_reader :ending
+
     # @param beginning [Rucoa::Position]
     # @param ending [Ruoca::Position]
-    def initialize(beginning, ending)
+    # @param including_ending [Boolean]
+    def initialize(beginning, ending, including_ending: true)
       @beginning = beginning
       @ending = ending
+      @including_ending = including_ending
+    end
+
+    # @param range [Rucoa::Range]
+    # @return [Boolean]
+    # @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)
-      !exclude?(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 && !@including_ending
+
+      true
     end
 
     # @return [Hash]
@@ -33,16 +120,5 @@ module Rucoa
         start: @beginning.to_vscode_position
       }
     end
-
-    private
-
-    # @param position [Rucoa::Position]
-    # @return [Boolean]
-    def exclude?(position)
-      position.line > @ending.line ||
-        position.line < @beginning.line ||
-        (position.line == @beginning.line && position.column < @beginning.column) ||
-        (position.line == @ending.line && position.column >= @ending.column)
-    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_configuration_checker.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Rucoa
+  class RubocopConfigurationChecker
+    class << self
+      # @return [Boolean]
+      def call
+        new.call
+      end
+    end
+
+    # @return [Boolean]
+    def call
+      rubocop_configured_for_current_directory?
+    end
+
+    private
+
+    # @return [Boolean]
+    def rubocop_configured_for_current_directory?
+      each_current_and_ancestor_pathname.any? do |pathname|
+        pathname.join('.rubocop.yml').exist?
+      end
+    end
+
+    # @return [Enumerable<Pathname>]
+    def each_current_and_ancestor_pathname
+      return to_enum(__method__) unless block_given?
+
+      pathname = ::Pathname.pwd
+      loop do
+        yield pathname
+        break if pathname.root?
+
+        pathname = pathname.parent
+      end
+      self
+    end
+  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

@@ -2,158 +2,132 @@
 
 module Rucoa
   class Server
-    # @param reader [IO]
-    # @param writer [IO]
-    def initialize(reader:, writer:)
-      @reader = MessageReader.new(reader)
-      @writer = MessageWriter.new(writer)
+    # @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,
+      'textDocument/documentSymbol' => Handlers::TextDocumentDocumentSymbolHandler,
+      '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
+
+    # @param input [IO]
+    # @param output [IO]
+    def initialize(input:, output:)
+      @reader = MessageReader.new(input)
+      @writer = MessageWriter.new(output)
+
+      @client_response_handlers = {}
+      @configuration = Configuration.new
+      @server_request_id = 0
+      @shutting_down = false
       @source_store = SourceStore.new
+
+      @definition_store = DefinitionStore.new
+      @definition_store.definitions += DefinitionArchiver.load
     end
 
     # @return [void]
     def start
-      read do |request|
-        result = handle(request)
-        if result
-          write(
-            request: request,
-            result: result
-          )
-        end
+      @reader.read do |request|
+        handle(request)
       end
     end
 
-    private
-
-    # @param request [Hash]
-    # @return [Object]
-    def handle(request)
-      case request['method']
-      when 'initialize'
-        on_initialize(request)
-      when 'textDocument/codeAction'
-        on_text_document_code_action(request)
-      when 'textDocument/didChange'
-        on_text_document_did_change(request)
-      when 'textDocument/didOpen'
-        on_text_document_did_open(request)
-      when 'textDocument/formatting'
-        on_text_document_formatting(request)
-      when 'textDocument/selectionRange'
-        on_text_document_selection_range(request)
-      end
-    end
-
-    # @yieldparam request [Hash]
     # @return [void]
-    def read(&block)
-      @reader.read(&block)
+    def finish
+      exit(0)
     end
 
-    # @param request [Hash]
-    # @param result [Object]
+    # @yieldparam response [Hash]
+    # @param message [Hash]
     # @return [void]
-    def write(request:, result:)
-      @writer.write(
-        {
-          id: request['id'],
-          result: result
-        }
-      )
+    def write(message, &block)
+      if block
+        write_server_request(message, &block)
+      else
+        write_server_response(message)
+      end
     end
 
-    # @param uri [String]
-    # @return [void]
-    def investigate_diagnostics(uri:)
-      @writer.write(
-        method: 'textDocument/publishDiagnostics',
-        params: {
-          diagnostics: DiagnosticProvider.call(
-            source: @source_store.get(uri),
-            uri: uri
-          ),
-          uri: uri
-        }
-      )
+    # @note This method is for testing.
+    # @return [Array<Hash>]
+    def responses
+      io = @writer.io
+      io.rewind
+      MessageReader.new(io).read.to_a
     end
 
-    # @param _request [Hash]
-    # @return [Hash]
-    def on_initialize(_request)
-      {
-        capabilities: {
-          codeActionProvider: true,
-          documentFormattingProvider: true,
-          selectionRangeProvider: true,
-          textDocumentSync: {
-            change: 1, # Full
-            openClose: true
-          }
-        }
-      }
-    end
+    private
 
     # @param request [Hash]
-    # @return [Array<Hash>, nil]
-    def on_text_document_code_action(request)
-      diagnostics = request.dig('params', 'context', 'diagnostics')
-      return unless diagnostics
-
-      CodeActionProvider.call(
-        diagnostics: diagnostics
-      )
+    # @return [void]
+    def handle(request)
+      if request['method']
+        handle_client_request(request)
+      elsif request['id']
+        handle_client_response(request)
+      end
     end
 
     # @param request [Hash]
-    # @return [nil]
-    def on_text_document_did_change(request)
-      uri = request.dig('params', 'textDocument', 'uri')
-      @source_store.set(
-        uri,
-        request.dig('params', 'contentChanges')[0]['text']
+    # @return [void]
+    def handle_client_request(request)
+      find_client_request_handler(request['method'])&.call(
+        request: request,
+        server: self
       )
-      investigate_diagnostics(uri: uri)
-      nil
     end
 
-    # @param request [Hash]
-    # @return [nil]
-    def on_text_document_did_open(request)
-      uri = request.dig('params', 'textDocument', 'uri')
-      @source_store.set(
-        uri,
-        request.dig('params', 'textDocument', 'text')
-      )
-      investigate_diagnostics(uri: uri)
-      nil
+    # @param response [Hash]
+    # @return [void]
+    def handle_client_response(response)
+      @client_response_handlers.delete(response['id'])&.call(response)
     end
 
-    # @param request [Hash]
-    # @return [Array<Hash>, nil]
-    def on_text_document_formatting(request)
-      uri = request.dig('params', 'textDocument', 'uri')
-      source = @source_store.get(uri)
-      return unless source
-
-      FormattingProvider.call(
-        source: source
-      )
+    # @param request_method [String]
+    # @return [Class, nil]
+    def find_client_request_handler(request_method)
+      METHOD_TO_HANDLER_MAP[request_method]
     end
 
-    # @param request [Hash]
-    # @return [Array<Hash>, nil]
-    def on_text_document_selection_range(request)
-      source = @source_store.get(
-        request.dig('params', 'textDocument', 'uri')
+    # @param message [Hash]
+    # @return [void]
+    def write_server_request(message, &block)
+      @writer.write(
+        message.merge(
+          id: @server_request_id
+        )
       )
-      return unless source
+      @client_response_handlers[@server_request_id] = block
+      @server_request_id += 1
+    end
 
-      request.dig('params', 'positions').filter_map do |position|
-        SelectionRangeProvider.call(
-          position: Position.from_vscode_position(position),
-          source: source
-        )
-      end
+    # @param message [Hash]
+    # @return [void]
+    def write_server_response(message)
+      @writer.write(message)
     end
   end
 end

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,15 +67,19 @@ module Rucoa
       root_and_descendant_nodes.reverse.find do |node|
         node.include_position?(position)
       end
+    rescue ::Parser::SyntaxError
+      nil
     end
 
-    private
-
     # @return [Rucoa::Nodes::Base, nil]
     def root_node
       @root_node ||= Parser.call(@content)
+    rescue ::Parser::SyntaxError
+      nil
     end
 
+    private
+
     # @return [Array<Rucoa::Nodes::Base>]
     def root_and_descendant_nodes
       return [] unless root_node

data/lib/rucoa/source_store.rb

@@ -9,20 +9,22 @@ 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)
-      )
+    # @yieldparam uri [String]
+    # @return [Enumerable<String>]
+    def each_uri(&block)
+      @data.each_key(&block)
     end
 
     private
@@ -31,7 +33,7 @@ module Rucoa
     # @return [String]
     def path_from_uri(uri)
       ::CGI.unescape(
-        ::URI.parse(uri).path
+        ::URI.parse(uri).path || 'untitled'
       )
     end
   end

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.2.0'
+  VERSION = '0.5.0'
 end