rucoa 0.6.0 → 0.8.0

data/lib/rucoa/node_inspector.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module Rucoa
   class NodeInspector
     # @param definition_store [Rucoa::DefinitionStore]
@@ -11,10 +9,24 @@ module Rucoa
       @node = node
     end
 
-    # @return [Array<String>]
+    # @return [Array<Rucoa::Definitions::Base>]
+    def definitions
+      case @node
+      when Nodes::ConstNode
+        [constant_definition]
+      when Nodes::SendNode
+        method_definitions
+      else
+        []
+      end
+    end
+
+    # @return [Array<Rucoa::Definitions::MethodDefinition>]
     def method_definitions
-      method_full_qualified_names.flat_map do |full_qualified_name|
-        @definition_store.select_by_full_qualified_name(full_qualified_name)
+      method_receiver_types.flat_map do |type|
+        @definition_store.instance_method_definitions_of(type)
+      end.select do |method_definition|
+        method_definition.method_name == @node.name
       end
     end
 
@@ -36,7 +48,7 @@ module Rucoa
     def return_types
       case @node.type
       when :const
-        [@node.name]
+        ["singleton<#{@node.name}>"]
       when :lvar
         return_types_for_lvar
       when :send
@@ -74,16 +86,33 @@ module Rucoa
 
     private
 
-    # @return [Array<String>]
-    def method_full_qualified_names
-      method_receiver_types.map do |type|
+    # @return [Rucoa::Definitions::ConstantDefinition, nil]
+    def constant_definition
+      return unless @node.is_a?(Nodes::ConstNode)
+
+      module_nesting_full_qualified_names = @node.each_ancestor(:class, :module).map(&:full_qualified_name)
+      candidate_full_qualified_names = module_nesting_full_qualified_names.flat_map do |module_nesting_full_qualified_name|
         [
-          type,
-          @node.name
-        ].join('#')
+          module_nesting_full_qualified_name
+          # TODO: *ancestors_of(module_nesting_full_qualified_name)
+        ].map do |full_qualified_name|
+          [
+            full_qualified_name,
+            @node.chained_name
+          ].join('::')
+        end
+      end + [@node.chained_name]
+      candidate_full_qualified_names.find do |candidate_full_qualified_name|
+        definition = @definition_store.select_by_full_qualified_name(candidate_full_qualified_name).first
+        break definition if definition
       end
     end
 
+    # @return [Boolean]
+    def singleton_method_call?
+      @node.is_a?(Nodes::ConstNode)
+    end
+
     # @return [String, nil]
     def nearest_def_full_qualified_name
       @node.each_ancestor(:def).first&.full_qualified_name
@@ -103,9 +132,13 @@ module Rucoa
 
     # @return [Array<String>]
     def return_types_for_send
-      method_full_qualified_names.flat_map do |full_qualified_name|
-        @definition_store.select_by_full_qualified_name(full_qualified_name).flat_map(&:return_types)
-      end.uniq
+      method_receiver_types.flat_map do |type|
+        @definition_store.find_method_definition_by(
+          method_name: @node.name,
+          namespace: type,
+          singleton: singleton_method_call?
+        )&.return_types
+      end.compact
     end
   end
 end

data/lib/rucoa/nodes/base.rb

@@ -121,8 +121,8 @@ module Rucoa
       # @param types [Array<Symbol>]
       # @return [void]
       def visit_descendants(types, &block)
-        each_child_node(*types) do |child|
-          yield(child)
+        each_child_node do |child|
+          yield(child) if types.empty? || types.include?(child.type)
           child.visit_descendants(types, &block)
         end
       end

data/lib/rucoa/nodes/const_node.rb

@@ -4,9 +4,40 @@ module Rucoa
   module Nodes
     class ConstNode < Base
       # @return [String]
+      # @example returns "A" for "A"
+      #   node = Rucoa::Parser.call('A')
+      #   expect(node.name).to eq('A')
+      # @example returns "B" for "A::B"
+      #   node = Rucoa::Parser.call('A::B')
+      #   expect(node.name).to eq('B')
       def name
         children[1].to_s
       end
+
+      # @return [String]
+      # @example returns "A" for "A"
+      #   node = Rucoa::Parser.call('A')
+      #   expect(node.chained_name).to eq('A')
+      # @example returns "A::B" for "A::B"
+      #   node = Rucoa::Parser.call('A::B')
+      #   expect(node.chained_name).to eq('A::B')
+      def chained_name
+        if receiver.is_a?(ConstNode)
+          [
+            receiver.chained_name,
+            name
+          ].join('::')
+        else
+          name
+        end
+      end
+
+      private
+
+      # @return [Rucoa::Nodes::Base, nil]
+      def receiver
+        children[0]
+      end
     end
   end
 end

data/lib/rucoa/position.rb

@@ -39,7 +39,7 @@ module Rucoa
 
     # @param column [Integer] 0-origin column number
     # @param line [Integer] 1-origin line number
-    def initialize(column:, line:)
+    def initialize(column: 0, line: 1)
       @column = column
       @line = line
     end

data/lib/rucoa/rbs/class_definition_mapper.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Rbs
+    class ClassDefinitionMapper
+      class << self
+        # @param declaration [RBS::AST::Declarations::Class]
+        # @return [Rucoa::Definitions::ClassDefinition]
+        def call(declaration:)
+          new(declaration: declaration).call
+        end
+      end
+
+      # @param declaration [RBS::AST::Declarations::Class]
+      def initialize(declaration:)
+        @declaration = declaration
+      end
+
+      # @return [Rucoa::Definitions::ClassDefinition]
+      def call
+        Definitions::ClassDefinition.new(
+          full_qualified_name: full_qualified_name,
+          source_path: source_path,
+          super_class_name: super_class_name
+        )
+      end
+
+      private
+
+      # @return [String]
+      def full_qualified_name
+        @declaration.name.to_s.delete_prefix('::')
+      end
+
+      # @return [String]
+      def source_path
+        @declaration.location.name
+      end
+
+      # @return [String, nil]
+      def super_class_name
+        @declaration.super_class&.name&.to_s&.delete_prefix('::')
+      end
+    end
+  end
+end

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/module_definition_mapper.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Rbs
+    class ModuleDefinitionMapper
+      class << self
+        # @param declaration [RBS::AST::Declarations::Module]
+        # @return [Rucoa::Definitions::ModuleDefinition]
+        def call(declaration:)
+          new(declaration: declaration).call
+        end
+      end
+
+      # @param declaration [RBS::AST::Declarations::Module]
+      def initialize(declaration:)
+        @declaration = declaration
+      end
+
+      # @return [Rucoa::Definitions::ModuleDefinition]
+      def call
+        Definitions::ModuleDefinition.new(
+          full_qualified_name: full_qualified_name,
+          source_path: source_path
+        )
+      end
+
+      private
+
+      # @return [String]
+      def full_qualified_name
+        @declaration.name.to_s.delete_prefix('::')
+      end
+
+      # @return [String]
+      def source_path
+        @declaration.location.name
+      end
+    end
+  end
+end

data/lib/rucoa/rbs/ruby_definitions_loader.rb

@@ -0,0 +1,82 @@
+# 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
+            [ClassDefinitionMapper.call(declaration: declaration)] +
+              declaration.members.grep(::RBS::AST::Members::MethodDefinition).map do |method_definition|
+                MethodDefinitionMapper.call(
+                  declaration: declaration,
+                  method_definition: method_definition
+                )
+              end
+          when ::RBS::AST::Declarations::Module
+            [ModuleDefinitionMapper.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,11 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Rbs
+    autoload :ClassDefinitionMapper, 'rucoa/rbs/class_definition_mapper'
+    autoload :ConstantDefinitionMapper, 'rucoa/rbs/constant_definition_mapper'
+    autoload :MethodDefinitionMapper, 'rucoa/rbs/method_definition_mapper'
+    autoload :ModuleDefinitionMapper, 'rucoa/rbs/module_definition_mapper'
+    autoload :RubyDefinitionsLoader, 'rucoa/rbs/ruby_definitions_loader'
+  end
+end

data/lib/rucoa/rubocop/autocorrector.rb

@@ -0,0 +1,51 @@
+# 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([path])
+        @options[:stdin]
+      end
+
+      private
+
+      # @return [String]
+      def path
+        if @source.untitled? || @source.path.nil?
+          'untitled'
+        else
+          @source.path
+        end
+      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,59 @@
+# 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([path])
+        @offenses
+      end
+
+      private
+
+      # @param file [String]
+      # @param offenses [Array<RuboCop::Cop::Offense>]
+      # @return [void]
+      def file_finished(file, offenses)
+        @offenses = offenses
+        super
+      end
+
+      # @return [String]
+      def path
+        if @source.untitled? || @source.path.nil?
+          'untitled'
+        else
+          @source.path
+        end
+      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

@@ -13,7 +13,9 @@ module Rucoa
       'shutdown' => Handlers::ShutdownHandler,
       'textDocument/codeAction' => Handlers::TextDocumentCodeActionHandler,
       'textDocument/completion' => Handlers::TextDocumentCompletionHandler,
+      'textDocument/definition' => Handlers::TextDocumentDefinitionHandler,
       'textDocument/didChange' => Handlers::TextDocumentDidChangeHandler,
+      'textDocument/didClose' => Handlers::TextDocumentDidCloseHandler,
       'textDocument/didOpen' => Handlers::TextDocumentDidOpenHandler,
       'textDocument/documentSymbol' => Handlers::TextDocumentDocumentSymbolHandler,
       'textDocument/formatting' => Handlers::TextDocumentFormattingHandler,

data/lib/rucoa/source.rb

@@ -29,11 +29,12 @@ module Rucoa
     #   )
     #   expect(source.definitions).to match(
     #     [
+    #       a_kind_of(Rucoa::Definitions::ClassDefinition),
     #       a_kind_of(Rucoa::Definitions::MethodDefinition)
     #     ]
     #   )
     def definitions
-      @definitions ||= YardStringDocumentLoader.call(
+      @definitions ||= Yard::DefinitionsLoader.load_string(
         content: @content,
         path: path
       )
@@ -46,15 +47,17 @@ module Rucoa
     #     uri: 'file:///path/to/foo.rb'
     #   )
     #   expect(source.path).to eq('/path/to/foo.rb')
-    # @example returns nil for untitled URI
+    # @example returns name for untitled URI
     #   source = Rucoa::Source.new(
     #     content: '',
     #     uri: 'untitled:Untitled-1'
     #   )
-    #   expect(source.path).to be_nil
+    #   expect(source.path).to eq('Untitled-1')
     def path
       return unless @uri
 
+      return @uri.split(':', 2).last if untitled?
+
       path = ::URI.parse(@uri).path
       return unless path
 
@@ -83,6 +86,11 @@ module Rucoa
       root_node.nil?
     end
 
+    # @return [Boolean]
+    def untitled?
+      @uri&.start_with?('untitled:')
+    end
+
     private
 
     # @return [Array<Rucoa::Nodes::Base>]

data/lib/rucoa/version.rb

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