rucoa 0.2.0 → 0.5.0

data/lib/rucoa/definition_store.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Rucoa
+  class DefinitionStore
+    # @return [Array<Rucoa::Definition::Base>]
+    attr_accessor :definitions
+
+    def initialize
+      @definitions = []
+    end
+
+    # @param source_path [String]
+    # @return [Array<Rucoa::Definition::Base>]
+    def update_definitions_defined_in(source_path, definitions:)
+      delete_definitions_defined_in(source_path)
+      @definitions += definitions
+    end
+
+    # @param full_qualified_name [String]
+    # @return [Array<Rucoa::Definitions::Base>]
+    def select_by_full_qualified_name(full_qualified_name)
+      @definitions.select do |definition|
+        definition.full_qualified_name == full_qualified_name
+      end
+    end
+
+    # @param namespace [String]
+    # @return [Array<Rucoa::Definitions::MethodDefinition>]
+    def method_definitions_of(namespace)
+      method_definitions.select do |method_definition|
+        method_definition.namespace == namespace
+      end
+    end
+
+    # @param namespace [String]
+    # @return [Array<Rucoa::Definitions::ConstantDefinition>] e.g. File::Separator, File::SEPARATOR, etc.
+    def constant_definitions_under(namespace)
+      constant_definitions.select do |constant_definition|
+        constant_definition.namespace == namespace
+      end
+    end
+
+    private
+
+    # @return [Array<Rucoa::Definition::ConstantDefinition>]
+    def constant_definitions
+      @definitions.grep(Definitions::ConstantDefinition)
+    end
+
+    # @return [Array<Rucoa::Definition::MethodDefinition>]
+    def method_definitions
+      @definitions.grep(Definitions::MethodDefinition)
+    end
+
+    # @param source_path [String]
+    # @return [Array<Rucoa::Definition::Base>]
+    def delete_definitions_defined_in(source_path)
+      @definitions.delete_if do |definition|
+        definition.source_path == source_path
+      end
+    end
+  end
+end

data/lib/rucoa/definitions/base.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Definitions
+    class Base
+      # @return [String]
+      def source_path
+        raise ::NotImplementedError
+      end
+    end
+  end
+end

data/lib/rucoa/definitions/constant_definition.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Definitions
+    # Represents class definition, module definition, or constant assignment.
+    class ConstantDefinition < Base
+      # @return [String]
+      attr_reader :full_qualified_name
+
+      # @return [String]
+      attr_reader :source_path
+
+      # @param full_qualified_name [String]
+      # @param source_path [String]
+      def initialize(full_qualified_name:, source_path:)
+        super()
+        @full_qualified_name = full_qualified_name
+        @source_path = source_path
+      end
+
+      # @return [String]
+      # @example returns non-full-qualified name
+      #   definition = Rucoa::Definitions::ConstantDefinition.new(
+      #     full_qualified_name: 'Foo::Bar::Baz',
+      #     source_path: '/path/to/foo/bar/baz.rb'
+      #   )
+      #   expect(definition.name).to eq('Baz')
+      def name
+        names.last
+      end
+
+      # @return [String]
+      # @example returns namespace
+      #   definition = Rucoa::Definitions::ConstantDefinition.new(
+      #     full_qualified_name: 'Foo::Bar::Baz',
+      #     source_path: '/path/to/foo/bar/baz.rb'
+      #   )
+      #   expect(definition.namespace).to eq('Foo::Bar')
+      def namespace
+        names[..-2].join('::')
+      end
+
+      private
+
+      # @return [Array<String>]
+      def names
+        @names ||= full_qualified_name.split('::')
+      end
+    end
+  end
+end

data/lib/rucoa/definitions/method_definition.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Definitions
+    class MethodDefinition < Base
+      # @return [String, nil]
+      attr_reader :description
+
+      # @return [String]
+      attr_reader :method_name
+
+      # @return [String]
+      attr_reader :namespace
+
+      # @return [String]
+      attr_reader :source_path
+
+      # @param description [String, nil]
+      # @param kind [Symbol]
+      # @param method_name [String]
+      # @param namespace [String]
+      # @param source_path [String]
+      # @param types [Array<Rucoa::Types::MethodType>]
+      def initialize(
+        description:,
+        kind:,
+        method_name:,
+        namespace:,
+        source_path:,
+        types:
+      )
+        super()
+        @description = description
+        @kind = kind
+        @method_name = method_name
+        @namespace = namespace
+        @source_path = source_path
+        @types = types
+      end
+
+      # @return [String]
+      # @example returns qualified name of method
+      #   method_definition = Rucoa::Definitions::MethodDefinition.new(
+      #     description: nil,
+      #     kind: :instance,
+      #     method_name: 'foo',
+      #     namespace: 'Foo::Bar',
+      #     source_path: '/path/to/foo/bar.rb',
+      #     types: []
+      #   )
+      #   expect(method_definition.full_qualified_name).to eq('Foo::Bar#foo')
+      def full_qualified_name
+        [
+          @namespace,
+          method_kind_symbol,
+          @method_name
+        ].join
+      end
+
+      # @todo
+      # @return [Array<Rucoa::Definitions::MethodParameter>]
+      def parameters
+        []
+      end
+
+      # @return [Array<String>]
+      # @example returns return types
+      #   method_definition = Rucoa::Definitions::MethodDefinition.new(
+      #     description: nil,
+      #     kind: :instance,
+      #     method_name: 'foo',
+      #     namespace: 'Foo::Bar',
+      #     source_path: '/path/to/foo/bar.rb',
+      #     types: [
+      #       Rucoa::Types::MethodType.new(
+      #         parameters_string: '',
+      #         return_type: 'String'
+      #       )
+      #     ]
+      #   )
+      #   expect(method_definition.return_types).to eq(%w[String])
+      def return_types
+        @types.map(&:return_type)
+      end
+
+      # @return [Array<String>]
+      # @example returns signature
+      #   method_definition = Rucoa::Definitions::MethodDefinition.new(
+      #     description: nil,
+      #     kind: :instance,
+      #     method_name: 'foo',
+      #     namespace: 'Foo::Bar',
+      #     source_path: '/path/to/foo/bar.rb',
+      #     types: [
+      #       Rucoa::Types::MethodType.new(
+      #         parameters_string: '?::int base',
+      #         return_type: 'String'
+      #       )
+      #     ]
+      #   )
+      #   expect(method_definition.signatures).to eq(['Foo::Bar#foo(?::int base) -> String'])
+      def signatures
+        @types.map do |type|
+          format(
+            '%<full_qualified_name>s(%<parameters>s) -> %<return_types>s',
+            full_qualified_name: full_qualified_name,
+            parameters: type.parameters_string,
+            return_types: type.return_type
+          )
+        end
+      end
+
+      private
+
+      # @return [String]
+      def method_kind_symbol
+        case @kind
+        when :instance
+          '#'
+        else
+          '.'
+        end
+      end
+    end
+  end
+end

data/lib/rucoa/definitions/method_parameter_definition.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Definitions
+    # Represents method parameter definition.
+    class MethodParameterDefinition < Base
+      # @return [String]
+      attr_reader :name
+
+      # @return [Array<String>]
+      attr_reader :types
+
+      # @param name [String]
+      # @param types [Array<String>]
+      def initialize(name:, types:)
+        super()
+        @name = name
+        @types = types
+      end
+
+      # @return [Hash{Symbol => Object}]
+      def to_hash
+        {
+          name: name,
+          types: types
+        }
+      end
+    end
+  end
+end

data/lib/rucoa/definitions.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Definitions
+    autoload :Base, 'rucoa/definitions/base'
+    autoload :ConstantDefinition, 'rucoa/definitions/constant_definition'
+    autoload :MethodDefinition, 'rucoa/definitions/method_definition'
+  end
+end

data/lib/rucoa/handler_concerns/configuration_requestable.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module HandlerConcerns
+    module ConfigurationRequestable
+      include HandlerConcerns::DiagnosticsPublishable
+
+      private
+
+      # @return [void]
+      def request_workspace_configuration
+        write(
+          method: 'workspace/configuration',
+          params: {
+            items: [
+              {
+                section: 'rucoa'
+              }
+            ]
+          }
+        ) do |response|
+          configuration.update(response['result'][0])
+          publish_diagnostics_on_each_source
+        end
+      end
+
+      # @return [void]
+      def publish_diagnostics_on_each_source
+        source_store.each_uri do |uri|
+          publish_diagnostics_on(uri)
+        end
+      end
+    end
+  end
+end

data/lib/rucoa/handler_concerns/diagnostics_publishable.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module HandlerConcerns
+    module DiagnosticsPublishable
+      private
+
+      # @param uri [String]
+      # @return [Array<Hash>]
+      def diagnostics_on(uri)
+        return [] unless configuration.enables_diagnostics?
+
+        DiagnosticProvider.call(
+          source: source_store.get(uri),
+          uri: uri
+        )
+      end
+
+      # @param uri [String]
+      # @return [void]
+      def publish_diagnostics_on(uri)
+        write(
+          method: 'textDocument/publishDiagnostics',
+          params: {
+            diagnostics: diagnostics_on(uri),
+            uri: uri
+          }
+        )
+      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/handler_concerns.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module HandlerConcerns
+    autoload :ConfigurationRequestable, 'rucoa/handler_concerns/configuration_requestable'
+    autoload :DiagnosticsPublishable, 'rucoa/handler_concerns/diagnostics_publishable'
+  end
+end

data/lib/rucoa/handlers/base.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Handlers
+    class Base
+      class << self
+        # @param server [Rucoa::Server]
+        # @param request [Hash]
+        # @return [void]
+        def call(request:, server:)
+          new(
+            request: request,
+            server: server
+          ).call
+        end
+      end
+
+      # @param request [Hash]
+      # @param server [Rucoa::Server]
+      def initialize(request:, server:)
+        @request = request
+        @server = server
+      end
+
+      # @return [void]
+      def call
+        raise ::NotImplementedError
+      end
+
+      private
+
+      # @return [Hash]
+      attr_reader :request
+
+      # @return [Rucoa::Server]
+      attr_reader :server
+
+      # @param message [Hash]
+      # @return [void]
+      def respond(message)
+        write(
+          id: request['id'],
+          result: message
+        )
+      end
+
+      # @return [Rucoa::Configuration]
+      def configuration
+        @server.configuration
+      end
+
+      # @return [Rucoa::DefinitionStore]
+      def definition_store
+        @server.definition_store
+      end
+
+      # @return [Rucoa::SourceStore]
+      def source_store
+        @server.source_store
+      end
+
+      # @param message [Hash]
+      # @return [void]
+      def write(message, &block)
+        @server.write(message, &block)
+      end
+    end
+  end
+end

data/lib/rucoa/handlers/exit_handler.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Handlers
+    class ExitHandler < Base
+      def call
+        server.finish
+      end
+    end
+  end
+end

data/lib/rucoa/handlers/initialize_handler.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Handlers
+    class InitializeHandler < Base
+      def call
+        respond(
+          capabilities: {
+            codeActionProvider: true,
+            documentFormattingProvider: true,
+            documentRangeFormattingProvider: true,
+            documentSymbolProvider: true,
+            selectionRangeProvider: true,
+            signatureHelpProvider: {
+              triggerCharacters: %w[
+                (
+                ,
+              ]
+            },
+            textDocumentSync: {
+              change: 1, # Full
+              openClose: true
+            }
+          }
+        )
+      end
+    end
+  end
+end

data/lib/rucoa/handlers/initialized_handler.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Handlers
+    class InitializedHandler < Base
+      include HandlerConcerns::ConfigurationRequestable
+
+      def call
+        request_workspace_configuration
+        load_definitions
+      end
+
+      private
+
+      # @return [void]
+      def load_definitions
+        YardGlobDocumentLoader.call(
+          globs: ::YARD::Parser::SourceParser::DEFAULT_PATH_GLOB
+        )
+      end
+    end
+  end
+end

data/lib/rucoa/handlers/shutdown_handler.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Handlers
+    class ShutdownHandler < Base
+      def call
+        server.shutting_down = true
+        respond(nil)
+      end
+    end
+  end
+end