rucoa 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1656b3603d72a44829a30fd9bd0d0d876ab9daa3af05cad16ad78298fa6fce7d
-  data.tar.gz: ff2fffdb7e90ed0f23cf782bc5c25db77dabb327c3e5b1d0a92aad8d2a5dc201
+  metadata.gz: '05869f9180ae7dbf00c359ad9d0b89fe3b126c8f9a6171b8b8155c7ad683f95f'
+  data.tar.gz: 429c84f3e305a90bcc1b7c39fbb14af894a95e24117c91d6914681ae8c53624c
 SHA512:
-  metadata.gz: 49421faba6f35b3cf0bd33c12ae521cf55125fc8c8b044f5a4d353b4ee9413150b0ca4082884e786329b1cefa3cb5eb5ab513b9723e638cb9786ab768d2f8dd0
-  data.tar.gz: 8ef7dfaf46a49d70eb9404558191aadb3e1778f761a4642c432b53c9e3b1f208ff57f64a5b43ec7aef527dc4b573baaed10f4d859043574e86452b0af60aecb4
+  metadata.gz: db443ae921e01609343392377664bf625bb4c2a057dc9d41ec1d611a7723807e6499d6669f097fb7d903b706110b6a34d83c09539612aba9d7b0e2fbd2302cf0
+  data.tar.gz: a6dabfb0fb1ac3228cb7217c9f9360fe6f32de32b65642492f00dbdc628d4578ed1c3a4f799c94c42ca8fe2553b3426c2105582569f9acd3e9971d68cc6722ec

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,8 +1,9 @@
 PATH
   remote: .
   specs:
-    rucoa (0.4.0)
+    rucoa (0.5.0)
       parser
+      rbs
       rubocop
 
 GEM
@@ -16,6 +17,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 +53,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 +75,7 @@ DEPENDENCIES
   rubocop-rspec
   rucoa!
   sevencop
+  yardspec
 
 BUNDLED WITH
    2.3.21

data/README.md

@@ -32,11 +32,42 @@ gem install rucoa
 
 ## Features
 
-- Diagnostics
-- Formatting
-- Quick Fix
-- Selection Range
-- Symbol
+### 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
 

data/lib/rucoa/configuration.rb

@@ -2,57 +2,68 @@
 
 module Rucoa
   class Configuration
-    DEFAULT_SETTINGS = {
-      'base' => {
-        'enable' => 'auto',
-        'useBundler' => 'auto'
-      },
-      'feature' => {
-        'codeAction' => {
-          'enable' => true
-        },
-        'diagnostics' => {
-          'enable' => true
-        },
-        'documentSymbol' => {
-          'enable' => true
-        },
-        'formatting' => {
-          'enable' => true
-        },
-        'selectionRange' => {
-          'enable' => true
-        }
-      }
-    }.freeze
-
     def initialize
-      reset
+      @settings = {}
+    end
+
+    # @return [Boolean]
+    def disable_code_action
+      disable('codeAction')
+    end
+
+    # @return [Boolean]
+    def disable_diagnostics
+      disable('diagnostics')
+    end
+
+    # @return [Boolean]
+    def disable_document_symbol
+      disable('documentSymbol')
+    end
+
+    # @return [Boolean]
+    def disable_formatting
+      disable('formatting')
+    end
+
+    # @return [Boolean]
+    def disable_selection_range
+      disable('selectionRange')
+    end
+
+    # @return [Boolean]
+    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?
-      @settings.dig('feature', 'documentSymbol', 'enable')
+      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]
@@ -63,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,191 @@
+# 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>]
+      def return_types
+        return %w[Object] if return_tags.empty?
+
+        return_tags.flat_map(&:types).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')
+        # @exampel 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