rucoa 0.3.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7206c3901e7ceea282b2de34f31ab90cc5ffa7fa48c06e58ae64bb718f48cd52
-  data.tar.gz: 6188a2047317b98160565599de3dc08663e732d7b54a546a8bc3e610379cb39a
+  metadata.gz: 4ffd244eb4ed0935120e2d33a03798897a4880e06ff999c1779a920e4926215c
+  data.tar.gz: fe7296dba2ff6d185a729e6649cd9630a5644961837d28306f3a5a193643d38e
 SHA512:
-  metadata.gz: afa9c37dae4a5c460eb1f5505ca511138c20f5b8c483a5ba68f798d1f9b18a5f5c4a481ee3ec743eb8585328538b5daec613b9f69a9599e5337106c57b1c0ea8
-  data.tar.gz: 539517254cff781a99b6ec463aed13bd04cbbcf3da3a9ff15cf72dac809b12c53ef9ff53c51828a163975bbdbe60a174767a472d2b4476f03f1813b5f513c62d
+  metadata.gz: 9f9965f568980d2f069a5670dcf5e008986399b8826a331410bdd0f31cacf10a01068bc8e37109241ccd2c1e79bf9f0bc639600b7608260fffd02b07251e310b
+  data.tar.gz: 1143b279fbbf845f07f0654b37eadf20226d96b1dc930ceea5fd9fc3daf90b6bd786d3a55c08b9601019d85b0e79284de1268de5ed628136cb0097be3e6af846

data/.rubocop.yml

@@ -29,6 +29,9 @@ RSpec/MultipleMemoizedHelpers:
 RSpec/NamedSubject:
   Enabled: false
 
+Security/MarshalLoad:
+  Enabled: false
+
 Sevencop/HashLiteralOrder:
   Enabled: true
 

data/Gemfile

@@ -11,3 +11,4 @@ gem 'rubocop-performance'
 gem 'rubocop-rake'
 gem 'rubocop-rspec'
 gem 'sevencop'
+gem 'yardspec'

data/Gemfile.lock

@@ -1,9 +1,11 @@
 PATH
   remote: .
   specs:
-    rucoa (0.3.0)
+    rucoa (0.5.1)
       parser
+      rbs
       rubocop
+      yard
 
 GEM
   remote: https://rubygems.org/
@@ -16,6 +18,7 @@ GEM
       ast (~> 2.4.1)
     rainbow (3.1.1)
     rake (13.0.6)
+    rbs (2.6.0)
     regexp_parser (2.5.0)
     rexml (3.2.5)
     rspec (3.11.0)
@@ -51,9 +54,15 @@ GEM
     rubocop-rspec (2.12.1)
       rubocop (~> 1.31)
     ruby-progressbar (1.11.0)
-    sevencop (0.9.3)
+    sevencop (0.10.0)
       rubocop
     unicode-display_width (2.2.0)
+    webrick (1.7.0)
+    yard (0.9.28)
+      webrick (~> 1.7.0)
+    yardspec (0.2.0)
+      rspec
+      yard
 
 PLATFORMS
   x86_64-linux
@@ -67,6 +76,7 @@ DEPENDENCIES
   rubocop-rspec
   rucoa!
   sevencop
+  yardspec
 
 BUNDLED WITH
    2.3.21

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:
 
@@ -32,10 +32,42 @@ gem install rucoa
 
 ## Features
 
-- Diagnostics
-- Formatting
-- Quick Fix
-- Selection Range
+### Diagnostics
+
+Displays RuboCop offenses and provides Quick Fix action for autocorrection.
+
+![demo](images/diagnostics.gif)
+
+### Formatting
+
+Run "Format Document" command or enable "Format On Save" in the settings to autocorrect RuboCop offenses.
+
+![demo](images/document-formatting.gif)
+
+### Selection
+
+Run "Expand Selection" command to select appropriate ranges.
+
+![demo](images/selection-ranges.gif)
+
+### Symbol
+
+See Outline section in the explorer panel to see document symbols in the current file, or run "Go to Symbol" command to search for symbols.
+
+This extension supports the folowiing types of symbols:
+
+- class
+- module
+- constant
+- instance method
+- singleton method (a.k.a. class method)
+- attribute (attr_accessor, attr_reader, and attr_writer)
+
+![demo](images/document-symbol.gif)
+
+### Signature help (experimental)
+
+Shows method signature help when you start to type method arguments like `"100".to_i(`.
 
 ### Coming soon
 
@@ -44,4 +76,3 @@ gem install rucoa
 - Go to Definition
 - Highlight
 - Semantic Tokens
-- Symbol

data/lib/rucoa/configuration.rb

@@ -2,49 +2,68 @@
 
 module Rucoa
   class Configuration
-    DEFAULT_SETTINGS = {
-      'base' => {
-        'enable' => 'auto',
-        'useBundler' => 'auto'
-      },
-      'feature' => {
-        'codeAction' => {
-          'enable' => true
-        },
-        'diagnostics' => {
-          'enable' => true
-        },
-        'formatting' => {
-          'enable' => true
-        },
-        'selectionRange' => {
-          'enable' => true
-        }
-      }
-    }.freeze
-
     def initialize
-      reset
+      @settings = {}
+    end
+
+    # @return [void]
+    def disable_code_action
+      disable('codeAction')
+    end
+
+    # @return [void]
+    def disable_diagnostics
+      disable('diagnostics')
+    end
+
+    # @return [void]
+    def disable_document_symbol
+      disable('documentSymbol')
+    end
+
+    # @return [void]
+    def disable_formatting
+      disable('formatting')
+    end
+
+    # @return [void]
+    def disable_selection_range
+      disable('selectionRange')
+    end
+
+    # @return [void]
+    def disable_signature_help
+      disable('signatureHelp')
     end
 
     # @return [Boolean]
     def enables_code_action?
-      @settings.dig('feature', 'codeAction', 'enable')
+      enables?('codeAction')
     end
 
     # @return [Boolean]
     def enables_diagnostics?
-      @settings.dig('feature', 'diagnostics', 'enable')
+      enables?('diagnostics')
+    end
+
+    # @return [Boolean]
+    def enables_document_symbol?
+      enables?('documentSymbol')
     end
 
     # @return [Boolean]
     def enables_formatting?
-      @settings.dig('feature', 'formatting', 'enable')
+      enables?('formatting')
     end
 
     # @return [Boolean]
     def enables_selection_range?
-      @settings.dig('feature', 'selectionRange', 'enable')
+      enables?('selectionRange')
+    end
+
+    # @return [Boolean]
+    def enables_signature_help?
+      enables?('signatureHelp')
     end
 
     # @param settings [Hash]
@@ -55,9 +74,24 @@ module Rucoa
 
     private
 
+    # @param feature [String]
     # @return [void]
-    def reset
-      @settings = DEFAULT_SETTINGS.dup
+    def disable(feature)
+      @settings ||= {}
+      @settings['feature'] ||= {}
+      @settings['feature'][feature] ||= {}
+      @settings['feature'][feature]['enable'] = false
+    end
+
+    # @param feature [String]
+    # @return [Boolean]
+    def enables?(feature)
+      value = @settings.dig('feature', feature, 'enable')
+      if value.nil?
+        true
+      else
+        value
+      end
     end
   end
 end

data/lib/rucoa/definition_archiver.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Rucoa
+  class DefinitionArchiver
+    RUBY_DEFINITIONS_DUMP_PATH = ::File.expand_path('../../data/definitions_ruby_3_1', __dir__).freeze
+    private_constant :RUBY_DEFINITIONS_DUMP_PATH
+
+    class << self
+      # @param definitions [Array<Rucoa::Definition::Base>]
+      # @return [void]
+      def dump(definitions)
+        pathname = ::Pathname.new(RUBY_DEFINITIONS_DUMP_PATH)
+        pathname.parent.mkpath
+        pathname.write(
+          ::Marshal.dump(definitions)
+        )
+      end
+
+      # @return [Array<Rucoa::Definition::Base>]
+      def load
+        ::Marshal.load(
+          ::File.binread(RUBY_DEFINITIONS_DUMP_PATH)
+        )
+      end
+    end
+  end
+end

data/lib/rucoa/definition_builders/rbs_constant_definition_builder.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module DefinitionBuilders
+    # Build Rucoa contant definition from RBS constant declaration.
+    class RbsConstantDefinitionBuilder
+      class << self
+        # @param declaration [RBS::AST::Declarations::Constant]
+        # @return [Rucoa::Definitions::ConstantDefinition]
+        def call(declaration:)
+          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(
+          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/definition_builders/rbs_method_definition_builder.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'rbs'
+
+module Rucoa
+  module DefinitionBuilders
+    # Build Rucoa method definition from RBS method definition.
+    class RbsMethodDefinitionBuilder
+      class << self
+        # @param declaration [RBS::AST::Declarations::Class, RBS::AST::Declarations::Module]
+        # @param method_definition [RBS::AST::Members::MethodDefinition]
+        # @return [Rucoa::Definitions::MethodDefinition]
+        def call(declaration:, method_definition:)
+          new(
+            declaration: declaration,
+            method_definition: method_definition
+          ).call
+        end
+      end
+
+      # @param declaration [RBS::AST::Declarations::Class, RBS::AST::Declarations::Module]
+      # @param method_definition [RBS::AST::Members::MethodDefinition]
+      def initialize(declaration:, method_definition:)
+        @declaration = declaration
+        @method_definition = method_definition
+      end
+
+      # @return [Rucoa::Definitions::MethodDefinition]
+      def call
+        Definitions::MethodDefinition.new(
+          description: description,
+          kind: kind,
+          method_name: method_name,
+          namespace: namespace,
+          source_path: source_path,
+          types: types
+        )
+      end
+
+      private
+
+      # @return [Array<Rucoa::Types::MethodType>]
+      def types
+        @method_definition.types.map do |method_type|
+          RbsMethodTypeToRucoaMethodTypeMapper.call(
+            method_type: method_type
+          )
+        end
+      end
+
+      # @return [String, nil]
+      def description
+        @method_definition.comment&.string&.sub(/\A\s*<!--.*-->\s*/m, '')
+      end
+
+      # @return [String]
+      def namespace
+        @declaration.name.to_s.delete_prefix('::')
+      end
+
+      # @return [String]
+      def method_name
+        @method_definition.name.to_s
+      end
+
+      # @return [Symbol]
+      def kind
+        @method_definition.kind
+      end
+
+      # @return [String]
+      def source_path
+        @declaration.location.name
+      end
+
+      class RbsMethodTypeToRucoaMethodTypeMapper
+        class << self
+          # @param method_type [RBS::Types::MethodType]
+          # @return [Rucoa::Types::MethodType]
+          def call(method_type:)
+            new(method_type: method_type).call
+          end
+
+          # @param type [RBS::Types::Base]
+          # @return [String]
+          def stringify(type)
+            type.to_s.delete_prefix('::')
+          end
+        end
+
+        # @param method_type [RBS::Types::MethodType]
+        def initialize(method_type:)
+          @method_type = method_type
+        end
+
+        # @return [Rucoa::Types::MethodType]
+        def call
+          Types::MethodType.new(
+            parameters_string: @method_type.type.param_to_s,
+            return_type: self.class.stringify(@method_type.type.return_type)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rucoa/definition_builders/yard_method_definition_builder.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require 'yard'
+
+module Rucoa
+  module DefinitionBuilders
+    class YardMethodDefinitionBuilder
+      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
+        end
+      end
+
+      # @param code_object [YARD::CodeObjects::Base]
+      # @param path [String]
+      def initialize(code_object:, path:)
+        @code_object = code_object
+        @path = path
+      end
+
+      # @return [Rucoa::Definitions::Base]
+      def call
+        ::Rucoa::Definitions::MethodDefinition.new(
+          description: description,
+          kind: kind,
+          method_name: method_name,
+          namespace: namespace,
+          source_path: @path,
+          types: types
+        )
+      end
+
+      private
+
+      # @return [String]
+      def description
+        @code_object.docstring.to_s
+      end
+
+      # @return [Symbol]
+      def kind
+        if @code_object.scope == :instance
+          :instance
+        else
+          :singleton
+        end
+      end
+
+      # @return [String
+      def method_name
+        @code_object.name
+      end
+
+      # @return [String]
+      def namespace
+        @code_object.namespace.to_s
+      end
+
+      # @return [Array<Rucoa::Types::MethodType>]
+      def types
+        return_types.map do |return_type|
+          ::Rucoa::Types::MethodType.new(
+            parameters_string: parameters_string,
+            return_type: return_type
+          )
+        end
+      end
+
+      # @return [String]
+      # @example
+      #   definitions = Rucoa::YardStringDocumentLoader.call(
+      #     content: <<~RUBY,
+      #       class Foo
+      #         def bar(
+      #           argument1,
+      #           argument2 = nil,
+      #           *arguments,
+      #           keyword1:,
+      #           keyword2: nil,
+      #           **keywords,
+      #           &block
+      #         )
+      #         end
+      #       end
+      #     RUBY
+      #     path: '/path/to/foo.rb'
+      #   )
+      #   expect(definitions.first.signatures).to eq(
+      #     [
+      #       'Foo#bar(argument1, argument2 = nil, *arguments, keyword1:, keyword2: nil, **keywords, &block) -> Object'
+      #     ]
+      #   )
+      def parameters_string
+        @code_object.parameters.map do |parameter_name, default_value|
+          default_value_part =
+            if default_value.nil?
+              nil
+            elsif parameter_name.end_with?(':')
+              " #{default_value}"
+            else
+              " = #{default_value}"
+            end
+          [
+            parameter_name,
+            default_value_part
+          ].join
+        end.join(', ')
+      end
+
+      # @return [Array<Rucoa::Definitions::MethodParameterDefinition>]
+      def parameters
+        parameter_tags.map do |parameter_tag|
+          ::Rucoa::Definitions::MethodParameterDefinition.new(
+            name: parameter_tag.name,
+            types: parameter_tag.types
+          )
+        end
+      end
+
+      # @return [Array<YARD::Tags::Tag>]
+      def parameter_tags
+        @code_object.tags(:param) + @code_object.tags(:overload).flat_map do |overload_tag|
+          overload_tag.tags(:param)
+        end
+      end
+
+      # @return [Array<String>]
+      # @return [String]
+      # @example returns return type annotated by YARD @return tags
+      #   definitions = Rucoa::YardStringDocumentLoader.call(
+      #     content: <<~RUBY,
+      #       # @return [String]
+      #       def foo
+      #         'foo'
+      #       end
+      #     RUBY
+      #     path: '/path/to/foo.rb'
+      #   )
+      #   expect(definitions.first.return_types).to eq(
+      #     %w[
+      #       String
+      #     ]
+      #   )
+      # @example ignores empty @return tags
+      #   definitions = Rucoa::YardStringDocumentLoader.call(
+      #     content: <<~RUBY,
+      #       # @return []
+      #       def foo
+      #         'foo'
+      #       end
+      #     RUBY
+      #     path: '/path/to/foo.rb'
+      #   )
+      #   expect(definitions.first.return_types).to eq([])
+      def return_types
+        return %w[Object] if return_tags.empty?
+
+        return_tags.flat_map(&:types).compact.map do |type|
+          YardType.new(type).to_rucoa_type
+        end
+      end
+
+      # @return [YARD::Tags::Tag]
+      def return_tags
+        @code_object.tags(:return) + @code_object.tags(:overload).flat_map do |overload_tag|
+          overload_tag.tags(:return)
+        end
+      end
+
+      class YardType
+        # @param type [String]
+        def initialize(type)
+          @type = type
+        end
+
+        # @return [String]
+        # @example scrubs "Array<String>" to "Array"
+        #   yard_type = Rucoa::DefinitionBuilders::YardMethodDefinitionBuilder::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(
+        #     'Array(String, Integer)'
+        #   )
+        #   expect(yard_type.to_rucoa_type).to eq('Array')
+        # @example scrubs "::Array" to "Array"
+        #   yard_type = Rucoa::DefinitionBuilders::YardMethodDefinitionBuilder::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(
+        #     '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(
+        #     'Array<Array<Integer>>'
+        #   )
+        #   expect(yard_type.to_rucoa_type).to eq('Array')
+        def to_rucoa_type
+          @type
+            .delete_prefix('::')
+            .gsub(/<.+>/, '')
+            .gsub(/\{.+\}/, '')
+            .gsub(/\(.+\)/, '')
+        end
+      end
+    end
+  end
+end

data/lib/rucoa/definition_builders.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module DefinitionBuilders
+    autoload :RbsConstantDefinitionBuilder, 'rucoa/definition_builders/rbs_constant_definition_builder'
+    autoload :RbsMethodDefinitionBuilder, 'rucoa/definition_builders/rbs_method_definition_builder'
+    autoload :YardMethodDefinitionBuilder, 'rucoa/definition_builders/yard_method_definition_builder'
+  end
+end