rubocop-lsp 0.1.2 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e39f6df6dfef436bd3d67d745e2b300e9eead65c37ddeb8d28e05ac916d6ce5
-  data.tar.gz: d537d77e74bef4a92db2a71a05fd4e1b8c4832f4ca40a9a524b94433e9a1f204
+  metadata.gz: ac8fd19fc238910e86f2c8abfa03012be286ff2af399b44ea4b5fdda63980bc8
+  data.tar.gz: 5c4c6707a1ab16c7fd16fed74befca83d74688665f08d89d95fa5ed15aba986e
 SHA512:
-  metadata.gz: 5de228c6fa093e2835e58686a6452d04971d5808a84ed15b2cae42a2ccbecc126e0ca115695b0c82075d455b2cf59778d35a3b6ca5cc44d8ba0f5c2e09fbb6b5
-  data.tar.gz: 33eeba13254dc0ee9617ef1b1d8f559da3a91ac3e9c9daeafc528fe38bdafab90975260ed7b04a8a4d22771b097c381574ef0398d3219aa48fd125bd47319423
+  metadata.gz: 657ba77190d8707641aa2163d75342f150a021f1a6575862335b5a5d948c27801e3d1827353a5ce2db008a54932f9910bedc11ff97b66e68a2fbe58a9fbc18fc
+  data.tar.gz: 941e7c81ce62851f4c5b7afe18028cb0033168f4d9ef99f3e902695d2ea5ed2352f7818a9e5e1908f1b3a8b7c40250b0c0bed5b9e1f5361b7abc3a544353b028

data/.rubocop.yml

@@ -4,3 +4,6 @@ inherit_gem:
 AllCops:
   TargetRubyVersion: 2.6
   SuggestExtensions: false
+
+Layout/HashAlignment:
+  EnforcedColonStyle: table

data/.vscode/settings.json

@@ -1,3 +1,4 @@
 {
-  "rubocop-lsp.trace.server": "verbose"
+  // "rubocop-lsp.trace.server": "verbose",
+  "editor.formatOnSave": true
 }

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rubocop-lsp (0.1.2)
+    rubocop-lsp (0.1.6)
       language_server-protocol (>= 3.16)
       rubocop (>= 1.0)
 

data/lib/rubocop/lsp/cli.rb

@@ -9,75 +9,66 @@ require "rubocop/lsp/handler"
 module Rubocop
   module Lsp
     module Cli
-      Interface = LanguageServer::Protocol::Interface
-      Constant = LanguageServer::Protocol::Constant
-
       def self.start(_argv)
         handler = Handler.new
 
         handler.config do
           on("initialize") do
-            DiagnosticStore.clear_diagnostics
-            Interface::InitializeResult.new(
-              capabilities: Interface::ServerCapabilities.new(
-                text_document_sync: Interface::TextDocumentSyncOptions.new(
-                  change: Constant::TextDocumentSyncKind::FULL,
-                  open_close: true,
-                ),
-                document_formatting_provider: true,
-                code_action_provider: true
-              ),
-            )
+            store.clear
+
+            respond_with_capabilities
           end
 
           on("shutdown") do
-            DiagnosticStore.clear_diagnostics
+            store.clear
+
             nil
           end
 
           on("textDocument/didChange") do |request|
-            uri = request[:params][:textDocument][:uri]
-            text = request[:params][:contentChanges][0][:text]
+            uri = request.dig(:params, :textDocument, :uri)
+            text = request.dig(:params, :contentChanges, 0, :text)
 
-            send_diagnostics(uri: uri, text: text)
+            collector = collect_diagnostics(uri: uri, text: text)
+            send_diagnostics(collector)
 
             nil
           end
 
           on("textDocument/didOpen") do |request|
-            uri = request[:params][:textDocument][:uri]
-            text = request[:params][:textDocument][:text]
+            uri = request.dig(:params, :textDocument, :uri)
+            text = request.dig(:params, :textDocument, :text)
 
-            send_diagnostics(uri: uri, text: text)
+            collector = collect_diagnostics(uri: uri, text: text)
+            send_diagnostics(collector)
 
             nil
           end
 
           on("textDocument/didClose") do |request|
-            uri = request[:params][:textDocument][:uri]
+            uri = request.dig(:params, :textDocument, :uri)
 
-            DiagnosticStore.remove_diagnostics_for(uri)
-
-            send_diagnostics(uri: uri, diagnostics: [])
+            clear_diagnostics(uri: uri)
 
             nil
           end
 
           on("textDocument/formatting") do |request|
-            uri = request[:params][:textDocument][:uri]
-            file = CGI.unescape(URI.parse(uri).path)
-
-            collector = DiagnosticCollector.new(file: file, text: File.binread(file))
-            collector.run
+            uri = request.dig(:params, :textDocument, :uri)
 
-            collector.text_edits_from_formatting
+            collector = collect_diagnostics(uri: uri, text: store.text_for(uri))
+            send_text_edits(collector)
           end
 
           on("textDocument/codeAction") do |request|
-            uri = request[:params][:textDocument][:uri]
-            range = request[:params][:range]
+            uri = request.dig(:params, :textDocument, :uri)
+            range = request.dig(:params, :range)
+            start_line = range.dig(:start, :line)
+            end_line = range.dig(:end, :line)
+
+            line_range = Range.new(start_line, end_line)
 
-            DiagnosticStore.code_actions_for(uri, range)
+            send_code_actions(uri, line_range)
           end
         end
 

data/lib/rubocop/lsp/diagnostic_collector.rb

@@ -1,82 +1,44 @@
 # frozen_string_literal: true
 
-class DiagnosticCollector < RuboCop::Formatter::BaseFormatter
-  Interface = LanguageServer::Protocol::Interface
-  Constant = LanguageServer::Protocol::Constant
+require "rubocop/lsp/model/diagnostic_collection"
 
-  attr_reader :file, :text, :formatted_text, :diagnostics
+class DiagnosticCollector < RuboCop::Runner
+  RUBOCOP_FLAGS = [
+    "--stderr", # Print any output to stderr so that our stdout does not get polluted
+    "--format",
+    "quiet", # Supress any progress output by setting the formatter to `quiet`
+    "--auto-correct", # Apply the autocorrects on the supplied buffer
+  ]
 
-  def initialize(file:, text:)
-    super({}, nil)
-    @file = file
+  attr_reader :uri, :file, :text, :formatted_text, :diagnostics
+
+  def initialize(uri:, text:)
+    @uri = uri
+    @file = CGI.unescape(URI.parse(uri).path)
     @text = text
     @formatted_text = nil
-  end
-
-  def run
-    config_store = ::RuboCop::ConfigStore.new
-    options, paths = ::RuboCop::Options.new.parse(["--stderr", "--auto-correct"])
-    # config_store.options_config = options[:config] if options[:config]
-    options[:stdin] = text
-    paths << file
-    runner = ::RuboCop::Runner.new(options, config_store)
-    runner.send(:formatter_set).clear.push(self)
-    runner.run(paths)
-    @formatted_text = options[:stdin]
-  end
-
-  def file_finished(_file, offenses)
-    @diagnostics = offenses.map do |offense|
-      diagnostic_from_offense(offense)
-    end
-  end
 
-  def formatting_text_edits
-    return unless formatted_text
-
-    [
-      Interface::TextEdit.new(
-        range: Interface::Range.new(
-          start: Interface::Position.new(line: 0, character: 0),
-          end: Interface::Position.new(line: text.size, character: text.size)
-        ),
-        new_text: formatted_text
-      ),
-    ]
-  end
-
-  private
-
-  def diagnostic_from_offense(offense)
-    Interface::Diagnostic.new(
-      message: offense.message,
-      severity: Constant::DiagnosticSeverity::INFORMATION,
-      range: Interface::Range.new(
-        start: Interface::Position.new(line: offense.line - 1, character: offense.column),
-        end: Interface::Position.new(line: offense.last_line - 1, character: offense.last_column)
-      ),
-      data: {
-        cop_name: offense.cop_name,
-        edits: replacements_from_offense(offense),
-      }
+    super(
+      ::RuboCop::Options.new.parse(RUBOCOP_FLAGS).first,
+      ::RuboCop::ConfigStore.new
     )
   end
 
-  def replacements_from_offense(offense)
-    return unless offense.correctable?
+  def run
+    # Send text via "stdin".
+    # RuboCop reads all of stdin into the "stdin" option, when `--stdin`
+    # flag is supplied
+    @options[:stdin] = text
+
+    # Invoke the actual run method with just this file in `paths`
+    super([file])
 
-    offense.corrector.as_replacements.map do |range, replacement|
-      edit_from_replacement(range, replacement)
-    end
+    # RuboCop applies autocorrections to the "stdin" option,
+    # so read that into the formatted text attribute
+    @formatted_text = @options[:stdin]
   end
 
-  def edit_from_replacement(range, replacement)
-    Interface::TextEdit.new(
-      range: Interface::Range.new(
-        start: Interface::Position.new(line: range.line - 1, character: range.column),
-        end: Interface::Position.new(line: range.last_line - 1, character: range.last_column)
-      ),
-      new_text: replacement
-    )
+  def file_finished(_file, offenses)
+    @diagnostics = Model::DiagnosticCollection.new(uri, offenses)
   end
 end

data/lib/rubocop/lsp/handler.rb

@@ -1,18 +1,17 @@
 # frozen_string_literal: true
 
-require "rubocop/lsp/diagnostic_store"
+require "rubocop/lsp/state_store"
 require "rubocop/lsp/diagnostic_collector"
 
 class Handler
   Interface = LanguageServer::Protocol::Interface
   Constant = LanguageServer::Protocol::Constant
 
-  attr_reader :writer, :reader
-
   def initialize
     @writer = LanguageServer::Protocol::Transport::Stdio::Writer.new
     @reader = LanguageServer::Protocol::Transport::Stdio::Reader.new
     @handlers = {}
+    @store = StateStore.new
   end
 
   def config(&blk)
@@ -27,6 +26,8 @@ class Handler
 
   private
 
+  attr_reader :writer, :reader, :store
+
   def on(message, &blk)
     @handlers[message.to_s] = blk
   end
@@ -51,22 +52,69 @@ class Handler
     writer.write(method: method, params: params)
   end
 
-  def send_diagnostics(uri:, text: nil, diagnostics: [])
-    diagnostics = collect_diagnostics(uri: uri, text: text) if text
+  def respond_with_capabilities
+    Interface::InitializeResult.new(
+      capabilities: Interface::ServerCapabilities.new(
+        text_document_sync: Interface::TextDocumentSyncOptions.new(
+          change: Constant::TextDocumentSyncKind::FULL,
+          open_close: true,
+        ),
+        document_formatting_provider: true,
+        code_action_provider: true
+      ),
+    )
+  end
 
+  def notify_diagnostics(uri:, diagnostics_response:)
     notify(
       method: "textDocument/publishDiagnostics",
       params: Interface::PublishDiagnosticsParams.new(
         uri: uri,
-        diagnostics: diagnostics
+        diagnostics: diagnostics_response
       )
     )
   end
 
+  def clear_diagnostics(uri:)
+    store.delete(uri)
+
+    notify_diagnostics(uri: uri, diagnostics_response: [])
+  end
+
+  def send_diagnostics(collector)
+    notify_diagnostics(
+      uri: collector.uri,
+      diagnostics_response: collector.diagnostics.response
+    )
+  end
+
+  def send_code_actions(uri, line_range)
+    store.code_actions_for(uri, line_range)
+  end
+
+  def send_text_edits(collector)
+    return unless collector.formatted_text
+
+    [
+      Interface::TextEdit.new(
+        range: Interface::Range.new(
+          start: Interface::Position.new(line: 0, character: 0),
+          end: Interface::Position.new(
+            line: collector.text.size,
+            character: collector.text.size
+          )
+        ),
+        new_text: collector.formatted_text
+      ),
+    ]
+  end
+
   def collect_diagnostics(uri:, text:)
-    file = CGI.unescape(URI.parse(uri).path)
-    collector = DiagnosticCollector.new(file: file, text: text)
+    collector = DiagnosticCollector.new(uri: uri, text: text)
     collector.run
-    DiagnosticStore.set_diagnostics_for(uri, collector.diagnostics)
+
+    store.set(uri: collector.uri, text: collector.text, diagnostics: collector.diagnostics)
+
+    collector
   end
 end

data/lib/rubocop/lsp/model/diagnostic.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Model
+  class Diagnostic
+    attr_reader :badge, :message, :start, :end, :replacements
+
+    DOCS_URLS = {
+      "Bundler":          "https://docs.rubocop.org/rubocop/cops_bundler.html#%{anchor}",
+      "Gemspec":          "https://docs.rubocop.org/rubocop/cops_gemspec.html#%{anchor}",
+      "Layout":           "https://docs.rubocop.org/rubocop/cops_layout.html#%{anchor}",
+      "Lint":             "https://docs.rubocop.org/rubocop/cops_lint.html#%{anchor}",
+      "Metrics":          "https://docs.rubocop.org/rubocop/cops_metrics.html#%{anchor}",
+      "Migration":        "https://docs.rubocop.org/rubocop/cops_migration.html#%{anchor}",
+      "Naming":           "https://docs.rubocop.org/rubocop/cops_naming.html#%{anchor}",
+      "Security":         "https://docs.rubocop.org/rubocop/cops_security.html#%{anchor}",
+      "Style":            "https://docs.rubocop.org/rubocop/cops_style.html#%{anchor}",
+      "Minitest":         "https://docs.rubocop.org/rubocop-minitest/cops_minitest.html#%{anchor}",
+      "Performance":      "https://docs.rubocop.org/rubocop-performance/cops_performance.html#%{anchor}",
+      "Rails":            "https://docs.rubocop.org/rubocop-rails/cops_rails.html#%{anchor}",
+      "RSpec":            "https://docs.rubocop.org/rubocop-rspec/cops_rspec.html#%{anchor}",
+      "RSpec/Capybara":   "https://docs.rubocop.org/rubocop-rspec/cops_rspec/capybara.html#%{anchor}",
+      "RSpec/FactoryBot": "https://docs.rubocop.org/rubocop-rspec/cops_rspec/factorybot.html#%{anchor}",
+      "RSpec/Rails":      "https://docs.rubocop.org/rubocop-rspec/cops_rspec/rails.html#%{anchor}",
+      "Sorbet":           "https://github.com/Shopify/rubocop-sorbet/blob/master/manual/cops_sorbet.md#%{anchor}",
+    }
+
+    def initialize(offense)
+      @badge = RuboCop::Cop::Badge.parse(offense.cop_name)
+      @message = offense.message
+      @start = Interface::Position.new(line: offense.line - 1, character: offense.column)
+      @end = Interface::Position.new(line: offense.last_line - 1, character: offense.last_column)
+      @replacements = replacements_from_offense(offense)
+    end
+
+    def correctable?
+      !!@replacements
+    end
+
+    def cop_name
+      @cop_name ||= badge.to_s
+    end
+
+    def diagnostic_response
+      @diagnostic_response ||= Interface::Diagnostic.new(
+        message: message,
+        "source": "RuboCop",
+        code: cop_name,
+        code_description: Interface::CodeDescription.new(
+          href: doc_url
+        ),
+        severity: Constant::DiagnosticSeverity::INFORMATION,
+        range: Interface::Range.new(
+          start: start,
+          end: self.end
+        )
+      )
+    end
+
+    private
+
+    def doc_url
+      @doc_url ||= begin
+        anchor = cop_name.downcase.gsub(%r{/}, "")
+        docs_url_template = DOCS_URLS[badge.department]
+
+        return unless docs_url_template
+
+        format(docs_url_template, anchor: anchor)
+      end
+    end
+
+    def replacements_from_offense(offense)
+      return unless offense.correctable?
+
+      offense.corrector.as_replacements.map do |range, replacement|
+        edit_from_replacement(range, replacement)
+      end
+    end
+
+    def edit_from_replacement(range, replacement)
+      Interface::TextEdit.new(
+        range: Interface::Range.new(
+          start: Interface::Position.new(line: range.line - 1, character: range.column),
+          end: Interface::Position.new(line: range.last_line - 1, character: range.last_column)
+        ),
+        new_text: replacement
+      )
+    end
+  end
+end

data/lib/rubocop/lsp/model/diagnostic_collection.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "rubocop/lsp/model/diagnostic"
+
+module Model
+  Interface = LanguageServer::Protocol::Interface
+  Constant = LanguageServer::Protocol::Constant
+
+  class DiagnosticCollection
+    attr_reader :uri, :diagnostics
+
+    def initialize(uri, offenses)
+      @uri = uri
+      @diagnostics = offenses.map do |offense|
+        Diagnostic.new(offense)
+      end
+    end
+
+    def response
+      diagnostics.map(&:diagnostic_response)
+    end
+
+    def correctable_diagnostics
+      @correctable_diagnostics ||= diagnostics.select(&:correctable?)
+    end
+
+    def code_actions(line_range)
+      line_diagnostics = correctable_diagnostics.select do |diagnostic|
+        line_range.include?(diagnostic.start.line)
+      end
+
+      actions = line_diagnostics.map do |diagnostic|
+        code_action_from(
+          diagnostic,
+          title: "Autocorrect `#{diagnostic.cop_name}`",
+          kind: Constant::CodeActionKind::QUICK_FIX
+        )
+      end
+
+      if actions.any?
+        actions << code_action_from(
+          line_diagnostics,
+          title: "Autocorrect all offenses on line",
+          kind: "rubocop.fix"
+        )
+      end
+
+      actions
+    end
+
+    private
+
+    def code_action_from(diagnostics, title:, kind:)
+      diagnostics = Array(diagnostics)
+
+      Interface::CodeAction.new(
+        title: title,
+        kind: kind,
+        edit: Interface::WorkspaceEdit.new(
+          document_changes: [
+            Interface::TextDocumentEdit.new(
+              text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
+                uri: uri,
+                version: nil
+              ),
+              edits: diagnostics.flat_map(&:replacements)
+            ),
+          ]
+        ),
+        is_preferred: true,
+      )
+    end
+  end
+end

data/lib/rubocop/lsp/state.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class State
+  attr_reader :uri, :text, :diagnostics
+
+  def initialize(uri:, text:, diagnostics: [])
+    @uri = uri
+    @text = text
+    @diagnostics = diagnostics
+  end
+
+  def code_actions(line_range)
+    diagnostics.code_actions(line_range)
+  end
+end

data/lib/rubocop/lsp/state_store.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "rubocop/lsp/state"
+
+class StateStore
+  def initialize
+    @state_map = {}
+  end
+
+  def clear
+    @state_map = {}
+  end
+
+  def delete(uri)
+    @state_map.delete(uri)
+    []
+  end
+
+  def set(uri:, text:, diagnostics: [])
+    @state_map[uri] = State.new(uri: uri, text: text, diagnostics: diagnostics || [])
+  end
+
+  def get(uri)
+    @state_map[uri]
+  end
+
+  def text_for(uri)
+    state = get(uri)
+
+    return state.text if state
+
+    file = CGI.unescape(URI.parse(uri).path)
+    File.binread(file)
+  end
+
+  def code_actions_for(uri, line_range)
+    state = get(uri)
+
+    return [] unless state
+
+    state.code_actions(line_range)
+  end
+
+  private
+
+  attr_reader :state_map
+end

data/lib/rubocop/lsp/version.rb

@@ -2,6 +2,6 @@
 
 module Rubocop
   module Lsp
-    VERSION = "0.1.2"
+    VERSION = "0.1.6"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-lsp
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.6
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-07-22 00:00:00.000000000 Z
+date: 2021-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -60,8 +60,11 @@ files:
 - lib/rubocop/lsp.rb
 - lib/rubocop/lsp/cli.rb
 - lib/rubocop/lsp/diagnostic_collector.rb
-- lib/rubocop/lsp/diagnostic_store.rb
 - lib/rubocop/lsp/handler.rb
+- lib/rubocop/lsp/model/diagnostic.rb
+- lib/rubocop/lsp/model/diagnostic_collection.rb
+- lib/rubocop/lsp/state.rb
+- lib/rubocop/lsp/state_store.rb
 - lib/rubocop/lsp/version.rb
 - rubocop-lsp.gemspec
 homepage: https://github.com/Shopify/rubocop-lsp

data/lib/rubocop/lsp/diagnostic_store.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module DiagnosticStore
-  @diagnostic_map = {}
-
-  def self.clear_diagnostics
-    @diagnostic_map = {}
-  end
-
-  def self.remove_diagnostics_for(uri)
-    @diagnostic_map.delete(uri)
-    []
-  end
-
-  def self.set_diagnostics_for(uri, diagnostics)
-    @diagnostic_map[uri] = diagnostics
-  end
-
-  def self.diagnostics_for(uri)
-    @diagnostic_map[uri] || []
-  end
-
-  def self.correctable_diagnostics_for(uri)
-    diagnostics_for(uri).reject do |diagnostic|
-      diagnostic.data[:edits].nil?
-    end
-  end
-
-  def self.code_actions_for(uri, range)
-    line_range = Range.new(range[:start][:line], range[:end][:line])
-
-    file_diagnostics = correctable_diagnostics_for(uri)
-    line_diagnostics = file_diagnostics.select { |diagnostic| line_range.include?(diagnostic.range.start.line) }
-    actions = line_diagnostics.map { |diagnostic| code_action_from(uri, diagnostic) }
-
-    unless actions.empty?
-      actions << code_action_from_diagnostics(uri, line_diagnostics, title: "Autocorrect all offenses on line")
-    end
-
-    actions
-  end
-
-  def self.code_action_from_diagnostics(uri, diagnostics, title:)
-    diagnostics = diagnostics.sort_by do |diagnostic|
-      [diagnostic.range.start.line, diagnostic.range.start.character]
-    end
-
-    LanguageServer::Protocol::Interface::CodeAction.new(
-      title: title,
-      kind: "rubocop.fix",
-      edit: LanguageServer::Protocol::Interface::WorkspaceEdit.new(
-        document_changes: [
-          LanguageServer::Protocol::Interface::TextDocumentEdit.new(
-            text_document: LanguageServer::Protocol::Interface::OptionalVersionedTextDocumentIdentifier.new(
-              uri: uri,
-              version: nil
-            ),
-            edits: diagnostics.flat_map { |d| d.data[:edits] }
-          ),
-        ]
-      ),
-      is_preferred: true,
-    )
-  end
-
-  def self.code_action_from(uri, diagnostic)
-    LanguageServer::Protocol::Interface::CodeAction.new(
-      title: "Autocorrect `#{diagnostic.data[:cop_name]}`",
-      kind: LanguageServer::Protocol::Constant::CodeActionKind::QUICK_FIX,
-      edit: LanguageServer::Protocol::Interface::WorkspaceEdit.new(
-        document_changes: [
-          LanguageServer::Protocol::Interface::TextDocumentEdit.new(
-            text_document: LanguageServer::Protocol::Interface::OptionalVersionedTextDocumentIdentifier.new(
-              uri: uri,
-              version: nil
-            ),
-            edits: diagnostic.data[:edits]
-          ),
-        ]
-      ),
-      is_preferred: true,
-    )
-  end
-end