rucoa 0.5.1 → 0.7.0

data/lib/rucoa/position.rb

@@ -21,7 +21,7 @@ module Rucoa
         )
       end
 
-      # @param hash [Hash{Symbol => Integer}]
+      # @param hash [Hash{String => Integer}]
       # @return [Rucoa::Position]
       def from_vscode_position(hash)
         new(
@@ -44,6 +44,17 @@ module Rucoa
       @line = line
     end
 
+    # @param text [String]
+    # @return [Integer]
+    def to_index_of(text)
+      text.each_line.take(@line - 1).sum(&:length) + @column
+    end
+
+    # @return [Rucoa::Range]
+    def to_range
+      Range.new(self, self)
+    end
+
     # @return [Hash]
     def to_vscode_position
       {

data/lib/rucoa/{definition_builders/rbs_constant_definition_builder.rb → rbs/constant_definition_mapper.rb}

@@ -1,28 +1,24 @@
 # frozen_string_literal: true
 
 module Rucoa
-  module DefinitionBuilders
-    # Build Rucoa contant definition from RBS constant declaration.
-    class RbsConstantDefinitionBuilder
+  module Rbs
+    class ConstantDefinitionMapper
       class << self
         # @param declaration [RBS::AST::Declarations::Constant]
         # @return [Rucoa::Definitions::ConstantDefinition]
         def call(declaration:)
-          new(
-            declaration: declaration
-          ).call
+          new(declaration: declaration).call
         end
       end
 
       # @param declaration [RBS::AST::Declarations::Constant]
-      # @return [Rucoa::Definitions::ConstantDefinition]
       def initialize(declaration:)
         @declaration = declaration
       end
 
       # @return [Rucoa::Definitions::ConstantDefinition]
       def call
-        ::Rucoa::Definitions::ConstantDefinition.new(
+        Definitions::ConstantDefinition.new(
           full_qualified_name: full_qualified_name,
           source_path: source_path
         )

data/lib/rucoa/{definition_builders/rbs_method_definition_builder.rb → rbs/method_definition_mapper.rb}

@@ -1,11 +1,8 @@
 # frozen_string_literal: true
 
-require 'rbs'
-
 module Rucoa
-  module DefinitionBuilders
-    # Build Rucoa method definition from RBS method definition.
-    class RbsMethodDefinitionBuilder
+  module Rbs
+    class MethodDefinitionMapper
       class << self
         # @param declaration [RBS::AST::Declarations::Class, RBS::AST::Declarations::Module]
         # @param method_definition [RBS::AST::Members::MethodDefinition]
@@ -42,7 +39,7 @@ module Rucoa
       # @return [Array<Rucoa::Types::MethodType>]
       def types
         @method_definition.types.map do |method_type|
-          RbsMethodTypeToRucoaMethodTypeMapper.call(
+          MethodTypeMapper.call(
             method_type: method_type
           )
         end
@@ -73,7 +70,7 @@ module Rucoa
         @declaration.location.name
       end
 
-      class RbsMethodTypeToRucoaMethodTypeMapper
+      class MethodTypeMapper
         class << self
           # @param method_type [RBS::Types::MethodType]
           # @return [Rucoa::Types::MethodType]

data/lib/rucoa/rbs/ruby_definitions_loader.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'rbs'
+
+module Rucoa
+  module Rbs
+    # Load definitions for Ruby core and standard libraries.
+    class RubyDefinitionsLoader
+      class << self
+        # @return [Array<Rucoa::Definitions::Base>]
+        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
+            [
+              ConstantDefinitionMapper.call(declaration: declaration)
+            ]
+          when ::RBS::AST::Declarations::Class, ::RBS::AST::Declarations::Module
+            [
+              ConstantDefinitionMapper.call(declaration: declaration)
+            ] +
+              declaration.members.grep(::RBS::AST::Members::MethodDefinition).map do |method_definition|
+                MethodDefinitionMapper.call(
+                  declaration: declaration,
+                  method_definition: method_definition
+                )
+              end
+          else
+            []
+          end
+        end
+      end
+
+      private
+
+      # @return [Array<RBS::AST::Declarations::Base>]
+      def declarations
+        class_declarations + constant_declarations
+      end
+
+      # @return [Array<RBS::AST::Declarations::Class>]
+      def class_declarations
+        environment.class_decls.values.flat_map do |multi_entry|
+          multi_entry.decls.map(&:decl)
+        end
+      end
+
+      # @return [Array<RBS::AST::Declarations::Constant>]
+      def constant_declarations
+        environment.constant_decls.values.map(&:decl)
+      end
+
+      # @return [RBS::Environment]
+      def environment
+        @environment ||= ::RBS::Environment.from_loader(
+          environment_loader
+        ).resolve_type_names
+      end
+
+      # @return [RBS::EnvironmentLoader]
+      def environment_loader
+        loader = ::RBS::EnvironmentLoader.new
+        ::RBS::Repository::DEFAULT_STDLIB_ROOT.children.sort.each do |pathname|
+          loader.add(
+            library: pathname.basename.to_s
+          )
+        end
+        loader
+      end
+    end
+  end
+end

data/lib/rucoa/rbs.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Rbs
+    autoload :ConstantDefinitionMapper, 'rucoa/rbs/constant_definition_mapper'
+    autoload :MethodDefinitionMapper, 'rucoa/rbs/method_definition_mapper'
+    autoload :RubyDefinitionsLoader, 'rucoa/rbs/ruby_definitions_loader'
+  end
+end

data/lib/rucoa/rubocop/autocorrector.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Rucoa
+  module Rubocop
+    class Autocorrector < ::RuboCop::Runner
+      class << self
+        # @param source [Rucoa::Source]
+        # @return [String]
+        def call(source:)
+          new(source: source).call
+        end
+      end
+
+      # @param source [Rucoa::Source]
+      def initialize(source:)
+        @source = source
+        super(
+          ::RuboCop::Options.new.parse(
+            %w[
+              --stderr
+              --force-exclusion
+              --format RuboCop::Formatter::BaseFormatter
+              -A
+            ]
+          ).first,
+          ::RuboCop::ConfigStore.new
+        )
+      end
+
+      # @return [String]
+      def call
+        @options[:stdin] = @source.content
+        run([@source.path || 'untitled'])
+        @options[:stdin]
+      end
+    end
+  end
+end

data/lib/rucoa/rubocop/configuration_checker.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Rucoa
+  module Rubocop
+    class ConfigurationChecker
+      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
+end

data/lib/rucoa/rubocop/investigator.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Rucoa
+  module Rubocop
+    class Investigator < ::RuboCop::Runner
+      class << self
+        # @param source [Rucoa::Source]
+        # @return [Array<RuboCop::Cop::Offense>]
+        def call(source:)
+          new(source: source).call
+        end
+      end
+
+      # @param source [Rucoa::Source]
+      def initialize(source:)
+        @source = source
+        @offenses = []
+        super(
+          ::RuboCop::Options.new.parse(
+            %w[
+              --stderr
+              --force-exclusion
+              --format RuboCop::Formatter::BaseFormatter
+            ]
+          ).first,
+          ::RuboCop::ConfigStore.new
+        )
+      end
+
+      # @return [Array<RuboCop::Cop::Offense>]
+      def call
+        @options[:stdin] = @source.content
+        run([@source.path || 'untitled'])
+        @offenses
+      end
+
+      private
+
+      # @param file [String]
+      # @param offenses [Array<RuboCop::Cop::Offense>]
+      # @return [void]
+      def file_finished(file, offenses)
+        @offenses = offenses
+        super
+      end
+    end
+  end
+end

data/lib/rucoa/rubocop.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Rubocop
+    autoload :Autocorrector, 'rucoa/rubocop/autocorrector'
+    autoload :ConfigurationChecker, 'rucoa/rubocop/configuration_checker'
+    autoload :Investigator, 'rucoa/rubocop/investigator'
+  end
+end

data/lib/rucoa/server.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'logger'
+require 'stringio'
+
 module Rucoa
   class Server
     # @return [Hash{String => Class}]
@@ -9,10 +12,13 @@ module Rucoa
       'initialized' => Handlers::InitializedHandler,
       'shutdown' => Handlers::ShutdownHandler,
       'textDocument/codeAction' => Handlers::TextDocumentCodeActionHandler,
+      'textDocument/completion' => Handlers::TextDocumentCompletionHandler,
       'textDocument/didChange' => Handlers::TextDocumentDidChangeHandler,
+      'textDocument/didClose' => Handlers::TextDocumentDidCloseHandler,
       'textDocument/didOpen' => Handlers::TextDocumentDidOpenHandler,
       'textDocument/documentSymbol' => Handlers::TextDocumentDocumentSymbolHandler,
       'textDocument/formatting' => Handlers::TextDocumentFormattingHandler,
+      'textDocument/hover' => Handlers::TextDocumentHoverHandler,
       'textDocument/rangeFormatting' => Handlers::TextDocumentRangeFormattingHandler,
       'textDocument/selectionRange' => Handlers::TextDocumentSelectionRangeHandler,
       'textDocument/signatureHelp' => Handlers::TextDocumentSignatureHelpHandler,
@@ -32,11 +38,18 @@ module Rucoa
     # @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)
+    # @param io_log [IO]
+    # @param io_in [IO]
+    # @param io_out [IO]
+    def initialize(
+      io_log: ::StringIO.new,
+      io_in: ::StringIO.new,
+      io_out: ::StringIO.new
+    )
+      @logger = ::Logger.new(io_log)
+      @logger.level = ::Logger::DEBUG
+      @reader = MessageReader.new(io_in)
+      @writer = MessageWriter.new(io_out)
 
       @client_response_handlers = {}
       @configuration = Configuration.new
@@ -50,8 +63,14 @@ module Rucoa
 
     # @return [void]
     def start
-      @reader.read do |request|
-        handle(request)
+      @reader.read do |message|
+        debug do
+          {
+            kind: :read,
+            message: message
+          }
+        end
+        handle(message)
       end
     end
 
@@ -91,6 +110,11 @@ module Rucoa
       end
     end
 
+    # @yieldparam log [String]
+    def debug(&block)
+      @logger.debug(&block) if configuration.enables_debug?
+    end
+
     # @param request [Hash]
     # @return [void]
     def handle_client_request(request)
@@ -115,11 +139,14 @@ module Rucoa
     # @param message [Hash]
     # @return [void]
     def write_server_request(message, &block)
-      @writer.write(
-        message.merge(
-          id: @server_request_id
-        )
-      )
+      message = message.merge('id' => @server_request_id)
+      debug do
+        {
+          kind: :write,
+          message: message
+        }
+      end
+      @writer.write(message)
       @client_response_handlers[@server_request_id] = block
       @server_request_id += 1
     end
@@ -127,6 +154,12 @@ module Rucoa
     # @param message [Hash]
     # @return [void]
     def write_server_response(message)
+      debug do
+        {
+          kind: :write,
+          message: message
+        }
+      end
       @writer.write(message)
     end
   end

data/lib/rucoa/source.rb

@@ -33,7 +33,7 @@ module Rucoa
     #     ]
     #   )
     def definitions
-      @definitions ||= YardStringDocumentLoader.call(
+      @definitions ||= Yard::DefinitionsLoader.load_string(
         content: @content,
         path: path
       )
@@ -78,6 +78,11 @@ module Rucoa
       nil
     end
 
+    # @return [Boolean]
+    def syntax_error?
+      root_node.nil?
+    end
+
     private
 
     # @return [Array<Rucoa::Nodes::Base>]

data/lib/rucoa/version.rb

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

data/lib/rucoa/{definition_builders/yard_method_definition_builder.rb → yard/definition_mapper.rb}

@@ -3,30 +3,29 @@
 require 'yard'
 
 module Rucoa
-  module DefinitionBuilders
-    class YardMethodDefinitionBuilder
+  module Yard
+    class DefinitionMapper
       class << self
-        # @param code_object [YARD::CodeObjects::MethodObject]
-        # @param path [String]
-        # @return [Rucoa::Definitions::Base]
-        def call(code_object:, path:)
-          new(
-            code_object: code_object,
-            path: path
-          ).call
+        # @param code_object [YARD::CodeObjects::Base]
+        # @param path [String] This must be passed if the path is not available from code object.
+        # @return [Rucoa::Definitions::Base, nil]
+        def call(code_object, path: code_object.file)
+          new(code_object, path: path).call
         end
       end
 
       # @param code_object [YARD::CodeObjects::Base]
       # @param path [String]
-      def initialize(code_object:, path:)
+      def initialize(code_object, path:)
         @code_object = code_object
         @path = path
       end
 
-      # @return [Rucoa::Definitions::Base]
+      # @return [Rucoa::Definitions::Base, nil]
       def call
-        ::Rucoa::Definitions::MethodDefinition.new(
+        return unless @code_object.is_a?(::YARD::CodeObjects::MethodObject)
+
+        Definitions::MethodDefinition.new(
           description: description,
           kind: kind,
           method_name: method_name,
@@ -74,7 +73,7 @@ module Rucoa
 
       # @return [String]
       # @example
-      #   definitions = Rucoa::YardStringDocumentLoader.call(
+      #   definitions = Rucoa::Yard::DefinitionsLoader.load_string(
       #     content: <<~RUBY,
       #       class Foo
       #         def bar(
@@ -133,7 +132,7 @@ module Rucoa
       # @return [Array<String>]
       # @return [String]
       # @example returns return type annotated by YARD @return tags
-      #   definitions = Rucoa::YardStringDocumentLoader.call(
+      #   definitions = Rucoa::Yard::DefinitionsLoader.load_string(
       #     content: <<~RUBY,
       #       # @return [String]
       #       def foo
@@ -148,7 +147,7 @@ module Rucoa
       #     ]
       #   )
       # @example ignores empty @return tags
-      #   definitions = Rucoa::YardStringDocumentLoader.call(
+      #   definitions = Rucoa::Yard::DefinitionsLoader.load_string(
       #     content: <<~RUBY,
       #       # @return []
       #       def foo
@@ -181,27 +180,27 @@ module Rucoa
 
         # @return [String]
         # @example scrubs "Array<String>" to "Array"
-        #   yard_type = Rucoa::DefinitionBuilders::YardMethodDefinitionBuilder::YardType.new(
+        #   yard_type = Rucoa::Yard::DefinitionMapper::YardType.new(
         #     'Array<String>'
         #   )
         #   expect(yard_type.to_rucoa_type).to eq('Array')
         # @example scrubs "Array(String, Integer)" to "Array"
-        #   yard_type = Rucoa::DefinitionBuilders::YardMethodDefinitionBuilder::YardType.new(
+        #   yard_type = Rucoa::Yard::DefinitionMapper::YardType.new(
         #     'Array(String, Integer)'
         #   )
         #   expect(yard_type.to_rucoa_type).to eq('Array')
         # @example scrubs "::Array" to "Array"
-        #   yard_type = Rucoa::DefinitionBuilders::YardMethodDefinitionBuilder::YardType.new(
+        #   yard_type = Rucoa::Yard::DefinitionMapper::YardType.new(
         #     '::Array'
         #   )
         #   expect(yard_type.to_rucoa_type).to eq('Array')
         # @example scrubs "Hash{Symbol => Object}" to "Hash"
-        #   yard_type = Rucoa::DefinitionBuilders::YardMethodDefinitionBuilder::YardType.new(
+        #   yard_type = Rucoa::Yard::DefinitionMapper::YardType.new(
         #     'Hash{Symbol => Object}'
         #   )
         #   expect(yard_type.to_rucoa_type).to eq('Hash')
         # @example scrubs "Array<Array<Integer>>" to "Array"
-        #   yard_type = Rucoa::DefinitionBuilders::YardMethodDefinitionBuilder::YardType.new(
+        #   yard_type = Rucoa::Yard::DefinitionMapper::YardType.new(
         #     'Array<Array<Integer>>'
         #   )
         #   expect(yard_type.to_rucoa_type).to eq('Array')

data/lib/rucoa/yard/definitions_loader.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'yard'
+
+module Rucoa
+  module Yard
+    class DefinitionsLoader
+      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::Yard::DefinitionsLoader.load_string(
+        #     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 load_string(content:, path:)
+          ::YARD::Registry.clear
+          quietly do
+            ::YARD.parse_string(content)
+          end
+          ::YARD::Registry.all.filter_map do |code_object|
+            DefinitionMapper.call(code_object, path: path)
+          end
+        end
+
+        # @param globs [String]
+        # @return [Array<Rucoa::Definitions::Base>]
+        def load_globs(globs:)
+          ::YARD::Registry.clear
+          quietly do
+            ::YARD.parse(globs)
+          end
+          ::YARD::Registry.all.filter_map do |code_object|
+            DefinitionMapper.call(code_object)
+          end
+        end
+
+        private
+
+        def quietly(&block)
+          ::YARD::Logger.instance.enter_level(::Logger::FATAL, &block)
+        end
+      end
+    end
+  end
+end

data/lib/rucoa/yard.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Yard
+    autoload :DefinitionMapper, 'rucoa/yard/definition_mapper'
+    autoload :DefinitionsLoader, 'rucoa/yard/definitions_loader'
+  end
+end

data/lib/rucoa.rb

@@ -6,7 +6,6 @@ module Rucoa
   autoload :Cli, 'rucoa/cli'
   autoload :Configuration, 'rucoa/configuration'
   autoload :DefinitionArchiver, 'rucoa/definition_archiver'
-  autoload :DefinitionBuilders, 'rucoa/definition_builders'
   autoload :Definitions, 'rucoa/definitions'
   autoload :DefinitionStore, 'rucoa/definition_store'
   autoload :Errors, 'rucoa/errors'
@@ -21,14 +20,11 @@ module Rucoa
   autoload :ParserBuilder, 'rucoa/parser_builder'
   autoload :Position, 'rucoa/position'
   autoload :Range, 'rucoa/range'
-  autoload :RbsDocumentLoader, 'rucoa/rbs_document_loader'
-  autoload :RubocopAutocorrector, 'rucoa/rubocop_autocorrector'
-  autoload :RubocopConfigurationChecker, 'rucoa/rubocop_configuration_checker'
-  autoload :RubocopInvestigator, 'rucoa/rubocop_investigator'
+  autoload :Rbs, 'rucoa/rbs'
+  autoload :Rubocop, 'rucoa/rubocop'
   autoload :Server, 'rucoa/server'
   autoload :Source, 'rucoa/source'
   autoload :SourceStore, 'rucoa/source_store'
   autoload :Types, 'rucoa/types'
-  autoload :YardGlobDocumentLoader, 'rucoa/yard_glob_document_loader'
-  autoload :YardStringDocumentLoader, 'rucoa/yard_string_document_loader'
+  autoload :Yard, 'rucoa/yard'
 end