rucoa 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7206c3901e7ceea282b2de34f31ab90cc5ffa7fa48c06e58ae64bb718f48cd52
-  data.tar.gz: 6188a2047317b98160565599de3dc08663e732d7b54a546a8bc3e610379cb39a
+  metadata.gz: 1656b3603d72a44829a30fd9bd0d0d876ab9daa3af05cad16ad78298fa6fce7d
+  data.tar.gz: ff2fffdb7e90ed0f23cf782bc5c25db77dabb327c3e5b1d0a92aad8d2a5dc201
 SHA512:
-  metadata.gz: afa9c37dae4a5c460eb1f5505ca511138c20f5b8c483a5ba68f798d1f9b18a5f5c4a481ee3ec743eb8585328538b5daec613b9f69a9599e5337106c57b1c0ea8
-  data.tar.gz: 539517254cff781a99b6ec463aed13bd04cbbcf3da3a9ff15cf72dac809b12c53ef9ff53c51828a163975bbdbe60a174767a472d2b4476f03f1813b5f513c62d
+  metadata.gz: 49421faba6f35b3cf0bd33c12ae521cf55125fc8c8b044f5a4d353b4ee9413150b0ca4082884e786329b1cefa3cb5eb5ab513b9723e638cb9786ab768d2f8dd0
+  data.tar.gz: 8ef7dfaf46a49d70eb9404558191aadb3e1778f761a4642c432b53c9e3b1f208ff57f64a5b43ec7aef527dc4b573baaed10f4d859043574e86452b0af60aecb4

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rucoa (0.3.0)
+    rucoa (0.4.0)
       parser
       rubocop
 

data/README.md

@@ -6,7 +6,7 @@ Language server for Ruby.
 
 ## Usage
 
-Install both rucoa gem and [vscode-rucoa](https://github.com/r7kamura/vscode-rucoa) extension, then open your Ruby project in VSCode.
+Install both rucoa gem and [vscode-rucoa](https://marketplace.visualstudio.com/items?itemName=r7kamura.vscode-rucoa) extension, then open your Ruby project in VSCode.
 
 To install rucoa gem, if your project is managed by bundler, add to your Gemfile:
 
@@ -36,6 +36,7 @@ gem install rucoa
 - Formatting
 - Quick Fix
 - Selection Range
+- Symbol
 
 ### Coming soon
 
@@ -44,4 +45,3 @@ gem install rucoa
 - Go to Definition
 - Highlight
 - Semantic Tokens
-- Symbol

data/lib/rucoa/configuration.rb

@@ -14,6 +14,9 @@ module Rucoa
         'diagnostics' => {
           'enable' => true
         },
+        'documentSymbol' => {
+          'enable' => true
+        },
         'formatting' => {
           'enable' => true
         },
@@ -37,6 +40,11 @@ module Rucoa
       @settings.dig('feature', 'diagnostics', 'enable')
     end
 
+    # @return [Boolean]
+    def enables_document_symbol?
+      @settings.dig('feature', 'documentSymbol', 'enable')
+    end
+
     # @return [Boolean]
     def enables_formatting?
       @settings.dig('feature', 'formatting', 'enable')

data/lib/rucoa/handler_concerns/diagnostics_publishable.rb

@@ -27,6 +27,146 @@ module Rucoa
           }
         )
       end
+
+      class DiagnosticProvider
+        # @param source [Rucoa::Source]
+        # @param uri [String]
+        # @return [Array<Hash>]
+        def self.call(source:, uri:)
+          new(
+            source: source,
+            uri: uri
+          ).call
+        end
+
+        # @param source [Rucoa::Source]
+        # @param uri [String]
+        def initialize(source:, uri:)
+          @source = source
+          @uri = uri
+        end
+
+        # @return [Array<Hash>]
+        def call
+          return [] unless RubocopConfigurationChecker.call
+
+          offenses.map do |offense|
+            OffenseToDiagnosticMapper.call(
+              offense,
+              source: @source,
+              uri: @uri
+            )
+          end
+        end
+
+        private
+
+        # @return [Array<RuboCop::Cop::Offense>]
+        def offenses
+          RubocopInvestigator.call(source: @source)
+        end
+
+        class OffenseToDiagnosticMapper
+          LSP_SEVERITY_NAME_TO_VALUE_MAP = {
+            error: 1,
+            hint: 4,
+            information: 3,
+            warning: 2
+          }.freeze
+          private_constant :LSP_SEVERITY_NAME_TO_VALUE_MAP
+
+          RUBOCOP_SEVERITY_NAME_TO_LSP_SEVERITY_MAP = {
+            convention: LSP_SEVERITY_NAME_TO_VALUE_MAP[:information],
+            error: LSP_SEVERITY_NAME_TO_VALUE_MAP[:error],
+            fatal: LSP_SEVERITY_NAME_TO_VALUE_MAP[:error],
+            info: LSP_SEVERITY_NAME_TO_VALUE_MAP[:information],
+            refactor: LSP_SEVERITY_NAME_TO_VALUE_MAP[:hint],
+            warning: LSP_SEVERITY_NAME_TO_VALUE_MAP[:warning]
+          }.freeze
+          private_constant :RUBOCOP_SEVERITY_NAME_TO_LSP_SEVERITY_MAP
+
+          class << self
+            # @param offense [RuboCop::Cop::Offense]
+            # @param source [Rucoa::Source]
+            # @param uri [String]
+            # @return [Hash]
+            def call(offense, source:, uri:)
+              new(
+                offense,
+                source: source,
+                uri: uri
+              ).call
+            end
+          end
+
+          # @param offense [RuboCop::Cop::Offense]
+          # @param source [Rucoa::Source]
+          # @param uri [String]
+          def initialize(offense, source:, uri:)
+            @offense = offense
+            @source = source
+            @uri = uri
+          end
+
+          # @return [Hash]
+          def call
+            {
+              code: code,
+              data: data,
+              message: message,
+              range: range,
+              severity: severity,
+              source: source
+            }
+          end
+
+          private
+
+          # @return [String]
+          def code
+            @offense.cop_name
+          end
+
+          # @return [Hash]
+          def data
+            {
+              cop_name: @offense.cop_name,
+              edits: edits,
+              uri: @uri
+            }
+          end
+
+          # @return [Array<Hash>, nil]
+          def edits
+            @offense.corrector&.as_replacements&.map do |range, replacement|
+              {
+                newText: replacement,
+                range: Range.from_parser_range(range).to_vscode_range
+              }
+            end
+          end
+
+          # @return [String]
+          def message
+            @offense.message.delete_prefix("#{@offense.cop_name}: ")
+          end
+
+          # @return [Hash]
+          def range
+            Range.from_parser_range(@offense.location).to_vscode_range
+          end
+
+          # @return [Integer]
+          def severity
+            RUBOCOP_SEVERITY_NAME_TO_LSP_SEVERITY_MAP.fetch(@offense.severity.name, 1)
+          end
+
+          # @return [String]
+          def source
+            'RuboCop'
+          end
+        end
+      end
     end
   end
 end

data/lib/rucoa/handlers/initialize_handler.rb

@@ -9,6 +9,7 @@ module Rucoa
             codeActionProvider: true,
             documentFormattingProvider: true,
             documentRangeFormattingProvider: true,
+            documentSymbolProvider: true,
             selectionRangeProvider: true,
             textDocumentSync: {
               change: 1, # Full

data/lib/rucoa/handlers/text_document_code_action_handler.rb

@@ -15,15 +15,90 @@ module Rucoa
       def code_actions
         return [] unless configuration.enables_code_action?
 
-        CodeActionProvider.call(
-          diagnostics: diagnostics
-        )
+        correctable_diagnostics.map do |diagnostic|
+          DiagnosticToCodeActionMapper.call(diagnostic)
+        end
+      end
+
+      # @return [Array<Hash>]
+      def correctable_diagnostics
+        diagnostics.select do |diagnostic|
+          diagnostic.dig('data', 'edits')
+        end
       end
 
       # @return [Array<Hash>, nil]
       def diagnostics
         @diagnostics ||= request.dig('params', 'context', 'diagnostics')
       end
+
+      class DiagnosticToCodeActionMapper
+        class << self
+          # @param diagnostic [Hash]
+          # @return [Hash]
+          def call(diagnostic)
+            new(diagnostic).call
+          end
+        end
+
+        # @param diagnostic [Hash]
+        def initialize(diagnostic)
+          @diagnostic = diagnostic
+        end
+
+        # @return [Hash]
+        def call
+          {
+            diagnostics: diagnostics,
+            edit: edit,
+            isPreferred: preferred?,
+            kind: kind,
+            title: title
+          }
+        end
+
+        private
+
+        # @return [Hash]
+        def edit
+          {
+            documentChanges: [
+              {
+                edits: @diagnostic.dig('data', 'edits'),
+                textDocument: {
+                  uri: @diagnostic.dig('data', 'uri'),
+                  version: nil
+                }
+              }
+            ]
+          }
+        end
+
+        # @return [String]
+        def cop_name
+          @diagnostic.dig('data', 'cop_name')
+        end
+
+        # @return [Array]
+        def diagnostics
+          [@diagnostic]
+        end
+
+        # @return [Boolean]
+        def preferred?
+          true
+        end
+
+        # @return [String]
+        def kind
+          'quickfix'
+        end
+
+        # @return [String]
+        def title
+          "Autocorrect #{cop_name}"
+        end
+      end
     end
   end
 end

data/lib/rucoa/handlers/text_document_document_symbol_handler.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Rucoa
+  module Handlers
+    class TextDocumentDocumentSymbolHandler < Base
+      DOCUMENT_SYMBOL_KIND_FOR_FILE = 1
+      DOCUMENT_SYMBOL_KIND_FOR_MODULE = 2
+      DOCUMENT_SYMBOL_KIND_FOR_NAMESPACE = 3
+      DOCUMENT_SYMBOL_KIND_FOR_PACKAGE = 4
+      DOCUMENT_SYMBOL_KIND_FOR_CLASS = 5
+      DOCUMENT_SYMBOL_KIND_FOR_METHOD = 6
+      DOCUMENT_SYMBOL_KIND_FOR_PROPERTY = 7
+      DOCUMENT_SYMBOL_KIND_FOR_FIELD = 8
+      DOCUMENT_SYMBOL_KIND_FOR_CONSTRUCTOR = 9
+      DOCUMENT_SYMBOL_KIND_FOR_ENUM = 10
+      DOCUMENT_SYMBOL_KIND_FOR_INTERFACE = 11
+      DOCUMENT_SYMBOL_KIND_FOR_FUNCTION = 12
+      DOCUMENT_SYMBOL_KIND_FOR_VARIABLE = 13
+      DOCUMENT_SYMBOL_KIND_FOR_CONSTANT = 14
+      DOCUMENT_SYMBOL_KIND_FOR_STRING = 15
+      DOCUMENT_SYMBOL_KIND_FOR_NUMBER = 16
+      DOCUMENT_SYMBOL_KIND_FOR_BOOLEAN = 17
+      DOCUMENT_SYMBOL_KIND_FOR_ARRAY = 18
+      DOCUMENT_SYMBOL_KIND_FOR_OBJECT = 19
+      DOCUMENT_SYMBOL_KIND_FOR_KEY = 20
+      DOCUMENT_SYMBOL_KIND_FOR_NULL = 21
+      DOCUMENT_SYMBOL_KIND_FOR_ENUMMEMBER = 22
+      DOCUMENT_SYMBOL_KIND_FOR_STRUCT = 23
+      DOCUMENT_SYMBOL_KIND_FOR_EVENT = 24
+      DOCUMENT_SYMBOL_KIND_FOR_OPERATOR = 25
+      DOCUMENT_SYMBOL_KIND_FOR_TYPEPARAMETER = 26
+
+      # @return [Set<String>]
+      ATTRIBUTE_METHOD_NAMES = ::Set[
+        'attr_accessor',
+        'attr_reader',
+        'attr_writer',
+      ]
+
+      def call
+        return unless respondable?
+
+        respond(document_symbols)
+      end
+
+      private
+
+      # @return [Array<Hash>]
+      def document_symbols
+        visit(source.root_node)
+        document_symbol_stack.first[:children]
+      end
+
+      # @param node [Rucoa::Nodes::Base]
+      # @return [void]
+      def visit(node)
+        document_symbols = create_document_symbols_for(node)
+        document_symbol_stack.last[:children].push(*document_symbols)
+        with_document_symbol_stack(document_symbols.first) do
+          with_singleton_class_stack(node) do
+            node.each_child_node do |child_node|
+              visit(child_node)
+            end
+          end
+        end
+      end
+
+      # @param document_symbol [Hash, nil]
+      # @return [void]
+      def with_document_symbol_stack(document_symbol)
+        unless document_symbol
+          yield
+          return
+        end
+
+        document_symbol_stack.push(document_symbol)
+        yield
+        document_symbol_stack.pop
+      end
+
+      # @param node [Rucoa::Nodes::Base]
+      def with_singleton_class_stack(node)
+        unless node.is_a?(Rucoa::Nodes::SclassNode)
+          yield
+          return
+        end
+
+        singleton_class_stack.push(node)
+        yield
+        singleton_class_stack.pop
+      end
+
+      # @param node [Rucoa::Nodes::Base]
+      # @return [Array<Hash>]
+      def create_document_symbols_for(node)
+        case node
+        when Nodes::CasgnNode
+          create_document_symbols_for_casgn(node)
+        when Nodes::ClassNode
+          create_document_symbols_for_class(node)
+        when Nodes::DefNode
+          create_document_symbols_for_def(node)
+        when Nodes::DefsNode
+          create_document_symbols_for_defs(node)
+        when Nodes::ModuleNode
+          create_document_symbols_for_module(node)
+        when Nodes::SendNode
+          create_document_symbols_for_send(node)
+        else
+          []
+        end
+      end
+
+      # @param node [Rucoa::Nodes::CasgnNode]
+      # @return [Array<Hash>]
+      def create_document_symbols_for_casgn(node)
+        [
+          {
+            children: [],
+            kind: DOCUMENT_SYMBOL_KIND_FOR_CONSTANT,
+            name: node.name,
+            range: Range.from_parser_range(node.location.expression).to_vscode_range,
+            selectionRange: Range.from_parser_range(node.location.name).to_vscode_range
+          }
+        ]
+      end
+
+      # @param node [Rucoa::Nodes::ClassNode]
+      # @return [Array<Hash>]
+      def create_document_symbols_for_class(node)
+        [
+          {
+            children: [],
+            kind: DOCUMENT_SYMBOL_KIND_FOR_CLASS,
+            name: node.name,
+            range: Range.from_parser_range(node.location.expression).to_vscode_range,
+            selectionRange: Range.from_parser_range(node.location.name).to_vscode_range
+          }
+        ]
+      end
+
+      # @param node [Rucoa::Nodes::ModuleNode]
+      # @return [Array<Hash>]
+      def create_document_symbols_for_module(node)
+        [
+          {
+            children: [],
+            kind: DOCUMENT_SYMBOL_KIND_FOR_MODULE,
+            name: node.name,
+            range: Range.from_parser_range(node.location.expression).to_vscode_range,
+            selectionRange: Range.from_parser_range(node.location.name).to_vscode_range
+          }
+        ]
+      end
+
+      # @param node [Rucoa::Nodes::DefNode]
+      # @return [Array<Hash>]
+      def create_document_symbols_for_def(node)
+        [
+          {
+            children: [],
+            kind: DOCUMENT_SYMBOL_KIND_FOR_METHOD,
+            name: singleton_class_stack.empty? ? "##{node.name}" : ".#{node.name}",
+            range: Range.from_parser_range(node.location.expression).to_vscode_range,
+            selectionRange: Range.from_parser_range(node.location.name).to_vscode_range
+          }
+        ]
+      end
+
+      # @param node [Rucoa::Nodes::DefNode]
+      # @return [Array<Hash>]
+      def create_document_symbols_for_defs(node)
+        [
+          {
+            children: [],
+            kind: DOCUMENT_SYMBOL_KIND_FOR_METHOD,
+            name: ".#{node.name}",
+            range: Range.from_parser_range(node.location.expression).to_vscode_range,
+            selectionRange: Range.from_parser_range(node.location.name).to_vscode_range
+          }
+        ]
+      end
+
+      # @param node [Rucoa::Nodes::SendNode]
+      # @return [Array<Hash>]
+      def create_document_symbols_for_send(node)
+        return [] unless ATTRIBUTE_METHOD_NAMES.include?(node.name)
+
+        simple_types = ::Set[
+          :str,
+          :sym
+        ]
+        node.arguments.select do |argument|
+          simple_types.include?(argument.type)
+        end.map do |argument|
+          {
+            children: [],
+            kind: DOCUMENT_SYMBOL_KIND_FOR_FIELD,
+            name: argument.value.to_s,
+            range: Range.from_parser_range(argument.location.expression).to_vscode_range,
+            selectionRange: Range.from_parser_range(argument.location.expression).to_vscode_range
+          }
+        end
+      end
+
+      # @return [Boolean]
+      def respondable?
+        configuration.enables_document_symbol? && source
+      end
+
+      # @return [Rucoa::Source]
+      def source
+        @source ||= @server.source_store.get(uri)
+      end
+
+      # @return [String]
+      def uri
+        request.dig('params', 'textDocument', 'uri')
+      end
+
+      # @return [Arrah<Hash>]
+      def document_symbol_stack
+        @document_symbol_stack ||= [dummy_document_symbol]
+      end
+
+      # @return [Hash]
+      def dummy_document_symbol
+        {
+          children: []
+        }
+      end
+
+      # @return [Array<Rucoa::Nodes::SclassNode>]
+      def singleton_class_stack
+        @singleton_class_stack ||= []
+      end
+    end
+  end
+end

data/lib/rucoa/handlers/text_document_formatting_handler.rb

@@ -9,14 +9,18 @@ module Rucoa
 
       private
 
+      # @return [Boolean]
+      def formattable?
+        configuration.enables_formatting? &&
+          source &&
+          RubocopConfigurationChecker.call
+      end
+
       # @return [Array<Hash>]
       def edits
-        return unless configuration.enables_formatting?
-        return unless source
+        return [] unless formattable?
 
-        FormattingProvider.call(
-          source: source
-        )
+        [text_edit]
       end
 
       # @return [Rucoa::Source, nil]
@@ -28,6 +32,33 @@ module Rucoa
       def uri
         request.dig('params', 'textDocument', 'uri')
       end
+
+      # @return [Hash]
+      def text_edit
+        {
+          newText: new_text,
+          range: range
+        }
+      end
+
+      # @return [String]
+      def new_text
+        RubocopAutocorrector.call(source: source)
+      end
+
+      # @return [Hash]
+      def range
+        Range.new(
+          Position.new(
+            column: 0,
+            line: 1
+          ),
+          Position.new(
+            column: @source.content.lines.last.length,
+            line: @source.content.lines.count + 1
+          )
+        ).to_vscode_range
+      end
     end
   end
 end

data/lib/rucoa/handlers/text_document_range_formatting_handler.rb

@@ -4,21 +4,73 @@ module Rucoa
   module Handlers
     class TextDocumentRangeFormattingHandler < Base
       def call
-        return unless configuration.enables_formatting?
-
-        uri = request.dig('params', 'textDocument', 'uri')
-        source = source_store.get(uri)
-        return unless source
-
-        respond(
-          RangeFormattingProvider.call(
-            range: Range.from_vscode_range(
-              request.dig('params', 'range')
-            ),
-            source: source
-          )
+        respond(edits)
+      end
+
+      private
+
+      # @return [Array<Hash>]
+      def edits
+        return [] unless formattable?
+
+        correctable_replacements.map do |replacement_range, replacement|
+          {
+            newText: replacement,
+            range: replacement_range.to_vscode_range
+          }
+        end
+      end
+
+      # @return [Boolean]
+      def formattable?
+        configuration.enables_formatting? &&
+          source &&
+          RubocopConfigurationChecker.call
+      end
+
+      # @return [Rucoa::Source]
+      def source
+        @source ||= source_store.get(uri)
+      end
+
+      # @return [String]
+      def uri
+        request.dig('params', 'textDocument', 'uri')
+      end
+
+      # @return [Rucoa::Range]
+      def range
+        @range ||= Range.from_vscode_range(
+          request.dig('params', 'range')
         )
       end
+
+      # @return [Array<RuboCop::Cop::Corrector>]
+      def correctable_offenses
+        offenses.select(&:corrector)
+      end
+
+      # @return [Array(Rucoa::Range, String)]
+      def correctable_replacements
+        replacements.select do |replacement_range, _|
+          range.contains?(replacement_range)
+        end
+      end
+
+      # @return [Array<RuboCop::Cop::Offense>]
+      def offenses
+        RubocopInvestigator.call(source: source)
+      end
+
+      # @return [Array(Rucoa::Range, String)]
+      def replacements
+        correctable_offenses.map(&:corrector).flat_map(&:as_replacements).map do |replacement_range, replacement|
+          [
+            Range.from_parser_range(replacement_range),
+            replacement
+          ]
+        end
+      end
     end
   end
 end