rucoa 0.1.0 → 0.4.0

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Handlers
+    class TextDocumentFormattingHandler < Base
+      def call
+        respond(edits)
+      end
+
+      private
+
+      # @return [Boolean]
+      def formattable?
+        configuration.enables_formatting? &&
+          source &&
+          RubocopConfigurationChecker.call
+      end
+
+      # @return [Array<Hash>]
+      def edits
+        return [] unless formattable?
+
+        [text_edit]
+      end
+
+      # @return [Rucoa::Source, nil]
+      def source
+        @source ||= source_store.get(uri)
+      end
+
+      # @return [String]
+      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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Handlers
+    class TextDocumentRangeFormattingHandler < Base
+      def call
+        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

data/lib/rucoa/handlers/text_document_selection_range_handler.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Handlers
+    class TextDocumentSelectionRangeHandler < Base
+      def call
+        return unless respondable?
+
+        respond(
+          positions.filter_map do |position|
+            SelectionRangeProvider.call(
+              position: position,
+              source: source
+            )
+          end
+        )
+      end
+
+      private
+
+      # @return [Boolean]
+      def respondable?
+        configuration.enables_selection_range? &&
+          source
+      end
+
+      # @return [Rucoa::Source]
+      def source
+        @source ||= source_store.get(uri)
+      end
+
+      # @return [Array<Rucoa::Position>]
+      def positions
+        request.dig('params', 'positions').map do |position|
+          Position.from_vscode_position(position)
+        end
+      end
+
+      # @return [String]
+      def uri
+        request.dig('params', 'textDocument', 'uri')
+      end
+
+      class SelectionRangeProvider
+        class << self
+          # @param source [Rucoa::Source]
+          # @param position [Rucoa::Position]
+          # @return [Hash, nil]
+          def call(position:, source:)
+            new(
+              position: position,
+              source: source
+            ).call
+          end
+        end
+
+        # @param position [Rucoa::Position]
+        # @param source [Rucoa::Source]
+        def initialize(position:, source:)
+          @position = position
+          @source = source
+        end
+
+        # @return [Hash, nil]
+        def call
+          ranges.reverse.reduce(nil) do |result, range|
+            {
+              parent: result,
+              range: range.to_vscode_range
+            }
+          end
+        end
+
+        private
+
+        # @return [Rucoa::Nodes::Base, nil]
+        def node_at_position
+          if instance_variable_defined?(:@node_at_position)
+            @node_at_position
+          else
+            @node_at_position = @source.node_at(@position)
+          end
+        end
+
+        # @return [Array<Rucoa::Range>]
+        def ranges
+          return [] unless node_at_position
+
+          [node_at_position, *node_at_position.ancestors].flat_map do |node|
+            NodeToRangesMapper.call(node)
+          end
+        end
+
+        class NodeToRangesMapper
+          class << self
+            # @param node [Rucoa::Nodes::Base]
+            # @return [Array<Rucoa::Range>]
+            def call(node)
+              new(node).call
+            end
+          end
+
+          # @param node [Rucoa::Nodes::Base]
+          def initialize(node)
+            @node = node
+          end
+
+          # @return [Array<Rucoa::Range>]
+          def call
+            case @node
+            when Nodes::StrNode
+              [
+                inner_range,
+                expression_range
+              ]
+            else
+              [
+                expression_range
+              ]
+            end
+          end
+
+          private
+
+          # @return [Rucoa::Range]
+          def inner_range
+            Range.new(
+              Position.from_parser_range_ending(@node.location.begin),
+              Position.from_parser_range_beginning(@node.location.end)
+            )
+          end
+
+          # @return [Rucoa::Range]
+          def expression_range
+            Range.from_parser_range(@node.location.expression)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rucoa/handlers/workspace_did_change_configuration_handler.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Handlers
+    class WorkspaceDidChangeConfigurationHandler < Base
+      include HandlerConcerns::ConfigurationRequestable
+
+      def call
+        request_workspace_configuration
+      end
+    end
+  end
+end

data/lib/rucoa/handlers.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Handlers
+    autoload :Base, 'rucoa/handlers/base'
+    autoload :InitializeHandler, 'rucoa/handlers/initialize_handler'
+    autoload :InitializedHandler, 'rucoa/handlers/initialized_handler'
+    autoload :TextDocumentCodeActionHandler, 'rucoa/handlers/text_document_code_action_handler'
+    autoload :TextDocumentDidChangeHandler, 'rucoa/handlers/text_document_did_change_handler'
+    autoload :TextDocumentDidOpenHandler, 'rucoa/handlers/text_document_did_open_handler'
+    autoload :TextDocumentDocumentSymbolHandler, 'rucoa/handlers/text_document_document_symbol_handler'
+    autoload :TextDocumentFormattingHandler, 'rucoa/handlers/text_document_formatting_handler'
+    autoload :TextDocumentRangeFormattingHandler, 'rucoa/handlers/text_document_range_formatting_handler'
+    autoload :TextDocumentSelectionRangeHandler, 'rucoa/handlers/text_document_selection_range_handler'
+    autoload :WorkspaceDidChangeConfigurationHandler, 'rucoa/handlers/workspace_did_change_configuration_handler'
+  end
+end

data/lib/rucoa/message_reader.rb

@@ -11,8 +11,10 @@ module Rucoa
     end
 
     # @yieldparam message [Hash]
-    # @return [void]
+    # @return [Enumerator<Hash>, void]
     def read
+      return enum_for(:read) unless block_given?
+
       while (buffer = @io.gets("\r\n\r\n"))
         content_length = buffer[/Content-Length: (\d+)/i, 1]
         raise Errors::ContentLengthHeaderNotFound unless content_length

data/lib/rucoa/message_writer.rb

@@ -19,6 +19,9 @@ module Rucoa
       end
     end
 
+    # @return [IO]
+    attr_reader :io
+
     # @param io [IO]
     def initialize(io)
       @io = io

data/lib/rucoa/node_concerns/name_full_qualifiable.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module NodeConcerns
+    module NameFullQualifiable
+      # @return [String]
+      def full_qualified_name
+        [
+          name,
+          *each_ancestor(:class, :constant, :module).map(&:name)
+        ].reverse.join('::')
+      end
+
+      # @return [String]
+      def name
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/rucoa/node_concerns.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module NodeConcerns
+    autoload :NameFullQualifiable, 'rucoa/node_concerns/name_full_qualifiable'
+  end
+end

data/lib/rucoa/nodes/base.rb

@@ -64,6 +64,19 @@ module Rucoa
         self
       end
 
+      # @note Override.
+      #   Some nodes change their type depending on the context.
+      #   For example, `const` node can be `casgn` node.
+      # @return [Rucoa::Nodes::Base]
+      def updated(type = nil, children = nil, properties = {})
+        properties[:location] ||= @location
+        ParserBuilder.node_class_for(type || @type).new(
+          type || @type,
+          children || @children,
+          properties
+        )
+      end
+
       # @param position [Rucoa::Position]
       # @return [Boolean]
       def include_position?(position)

data/lib/rucoa/nodes/casgn_node.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Nodes
+    class CasgnNode < Base
+      include NodeConcerns::NameFullQualifiable
+
+      # @return [String]
+      def name
+        children[1].to_s
+      end
+    end
+  end
+end

data/lib/rucoa/nodes/class_node.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Nodes
+    class ClassNode < ModuleNode
+    end
+  end
+end

data/lib/rucoa/nodes/const_node.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Nodes
+    class ConstNode < Base
+      # @return [String]
+      def name
+        children[1].to_s
+      end
+    end
+  end
+end

data/lib/rucoa/nodes/def_node.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Nodes
+    class DefNode < Base
+      # @return [String]
+      def name
+        children[0].to_s
+      end
+    end
+  end
+end

data/lib/rucoa/nodes/defs_node.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Nodes
+    class DefsNode < Base
+      # @return [String]
+      def name
+        children[1].to_s
+      end
+    end
+  end
+end