standard 0.1.0 → 1.51.1

data/lib/standard/creates_config_store/sets_target_ruby_version.rb

@@ -1,23 +1,36 @@
 class Standard::CreatesConfigStore
   class SetsTargetRubyVersion
+    # This is minimum version that Rubocop can parse, not the minimum
+    # version it can run on (e.g. TargetRubyVersion).  See the following
+    # for more details:
+    #
+    # https://docs.rubocop.org/rubocop/configuration.html#setting-the-target-ruby-version
+    #
+    # https://github.com/rubocop/rubocop/blob/master/lib/rubocop/target_ruby.rb
+    MIN_TARGET_RUBY_VERSION = "2.0"
+
     def call(options_config, standard_config)
-      options_config["AllCops"]["TargetRubyVersion"] = floatify_version(
-        max_rubocop_supported_version(standard_config[:ruby_version])
+      options_config["AllCops"]["TargetRubyVersion"] = normalize_version(
+        min_target_ruby_version_supported(standard_config[:ruby_version])
       )
     end
 
     private
 
-    def max_rubocop_supported_version(desired_version)
-      rubocop_supported_version = Gem::Version.new("2.3")
-      if desired_version < rubocop_supported_version
-        rubocop_supported_version
+    def min_target_ruby_version_supported(desired_target_ruby_version)
+      return desired_target_ruby_version unless Gem::Version.correct?(desired_target_ruby_version)
+
+      min_target_ruby_version = Gem::Version.new(MIN_TARGET_RUBY_VERSION)
+      if desired_target_ruby_version < min_target_ruby_version
+        min_target_ruby_version
       else
-        desired_version
+        desired_target_ruby_version
       end
     end
 
-    def floatify_version(version)
+    def normalize_version(version)
+      return version unless Gem::Version.correct?(version)
+
       major, minor = version.segments
       "#{major}.#{minor}".to_f # lol
     end

data/lib/standard/creates_config_store.rb

@@ -3,6 +3,7 @@ require "rubocop"
 require_relative "creates_config_store/assigns_rubocop_yaml"
 require_relative "creates_config_store/sets_target_ruby_version"
 require_relative "creates_config_store/configures_ignored_paths"
+require_relative "creates_config_store/merges_user_config_extensions"
 
 module Standard
   class CreatesConfigStore
@@ -10,12 +11,16 @@ module Standard
       @assigns_rubocop_yaml = AssignsRubocopYaml.new
       @sets_target_ruby_version = SetsTargetRubyVersion.new
       @configures_ignored_paths = ConfiguresIgnoredPaths.new
+      @combines_plugin_configs = Plugin::CombinesPluginConfigs.new
+      @merges_user_config_extensions = MergesUserConfigExtensions.new
     end
 
     def call(standard_config)
       RuboCop::ConfigStore.new.tap do |config_store|
         options_config = @assigns_rubocop_yaml.call(config_store, standard_config)
         @sets_target_ruby_version.call(options_config, standard_config)
+        @combines_plugin_configs.call(options_config, standard_config)
+        @merges_user_config_extensions.call(options_config, standard_config)
         @configures_ignored_paths.call(options_config, standard_config)
       end
     end

data/lib/standard/formatter.rb

@@ -1,35 +1,42 @@
+require "yaml"
 require "rubocop"
-require_relative "detects_fixability"
 
 module Standard
   class Formatter < RuboCop::Formatter::BaseFormatter
-    CALL_TO_ACTION_MESSAGE = <<-CALL_TO_ACTION.gsub(/^ {6}/, "")
-      Notice: Disagree with these rules? While StandardRB is pre-1.0.0, feel free to submit suggestions to:
-        https://github.com/testdouble/standard/issues/new
-    CALL_TO_ACTION
-
-    def initialize(*args)
-      super
-      @detects_fixability = DetectsFixability.new
+    STANDARD_GREETING = <<~MSG
+      standard: Use Ruby Standard Style (https://github.com/standardrb/standard)
+    MSG
+
+    def started(_target_files)
       @header_printed_already = false
-      @fix_suggestion_printed_already = false
-      @any_uncorrected_offenses = false
+      @total_correction_count = 0
+      @total_correctable_count = 0
+      @total_uncorrected_count = 0
+      print_todo_warning
     end
 
     def file_finished(file, offenses)
-      return unless (uncorrected_offenses = offenses.reject(&:corrected?)).any?
-      @any_uncorrected_offenses = true
+      track_stats(offenses)
 
-      print_header_once
-      print_fix_suggestion_once(uncorrected_offenses)
+      if (uncorrected_offenses = offenses.reject(&:corrected?)).any?
+        print_header_once
 
-      uncorrected_offenses.each do |o|
-        output.printf("  %s:%d:%d: %s\n", path_to(file), o.line, o.real_column, o.message.tr("\n", " "))
+        uncorrected_offenses.each do |o|
+          output.printf("  %s:%d:%d: %s\n", path_to(file), o.line, o.real_column, o.message.tr("\n", " "))
+        end
       end
     end
 
-    def finished(_)
-      print_call_for_feedback if @any_uncorrected_offenses
+    def track_stats(offenses)
+      corrected = offenses.count(&:corrected?)
+      @total_correction_count += corrected
+      @total_correctable_count += offenses.count(&:correctable?) - corrected
+      @total_uncorrected_count += offenses.count - corrected
+    end
+
+    def finished(_inspected_files)
+      print_fix_suggestion
+      print_todo_congratulations
     end
 
     private
@@ -37,25 +44,48 @@ module Standard
     def print_header_once
       return if @header_printed_already
 
-      output.print <<-HEADER.gsub(/^ {8}/, "")
-        standard: Use Ruby Standard Style (https://github.com/testdouble/standard)
-      HEADER
+      output.print STANDARD_GREETING
 
       @header_printed_already = true
     end
 
-    def print_fix_suggestion_once(offenses)
-      if !@fix_suggestion_printed_already && should_suggest_fix?(offenses)
-        command = if File.split($PROGRAM_NAME).last == "rake"
-          "rake standard:fix"
+    def print_fix_suggestion
+      if (fix_mode = potential_fix_mode)
+        run_mode = determine_run_mode
+
+        command = if run_mode == :rake
+          "rake standard:#{fix_mode}"
         else
-          "standardrb --fix"
+          "standardrb --#{fix_mode.to_s.tr("_", "-")}"
         end
 
-        output.print <<-HEADER.gsub(/^ {10}/, "")
-          standard: Run `#{command}` to automatically fix some problems.
+        output.print fixable_error_message(command)
+      end
+    end
+
+    def print_todo_warning
+      todo_file = options[:todo_file]
+      return unless todo_file
+
+      todo_ignore_files = options[:todo_ignore_files]
+      return unless todo_ignore_files&.any?
+
+      output.print <<~HEADER
+        WARNING: this project is being migrated to standard gradually via `#{todo_file}` and is ignoring these files:
+      HEADER
+
+      todo_ignore_files.each do |f|
+        output.printf("  %s\n", f)
+      end
+    end
+
+    def print_todo_congratulations
+      if @total_uncorrected_count == 0 &&
+          options[:todo_file] &&
+          options[:todo_ignore_files]&.none?
+        output.print <<~HEADER
+          Congratulations, you've successfully migrated this project to Standard! Delete `#{options[:todo_file]}` in celebration.
         HEADER
-        @fix_suggestion_printed_already = true
       end
     end
 
@@ -63,17 +93,42 @@ module Standard
       Pathname.new(file).relative_path_from(Pathname.new(Dir.pwd))
     end
 
-    def print_call_for_feedback
-      output.print "\n"
-      output.print CALL_TO_ACTION_MESSAGE
+    def potential_fix_mode
+      return nil unless @total_correctable_count > 0
+
+      if !options[:autocorrect]
+        :fix
+      elsif options[:autocorrect] && options[:safe_autocorrect]
+        :fix_unsafely
+      end
     end
 
-    def auto_correct_option_provided?
-      options[:auto_correct] || options[:safe_auto_correct]
+    def determine_run_mode
+      if File.split($PROGRAM_NAME).last == "rake"
+        :rake
+      else
+        :cli
+      end
     end
 
-    def should_suggest_fix?(offenses)
-      !auto_correct_option_provided? && @detects_fixability.call(offenses)
+    def fixable_error_message(command)
+      sales_pitch = if !options[:autocorrect]
+        if @total_correctable_count > 1
+          "fix up to #{@total_correctable_count} problems"
+        else
+          "potentially fix one problem"
+        end
+      elsif options[:autocorrect] && options[:safe_autocorrect]
+        if @total_correctable_count > 1
+          "DANGEROUSLY fix #{@total_correctable_count} problems"
+        else
+          "DANGEROUSLY fix one problem"
+        end
+      end
+
+      <<~MSG
+        standard: Run `#{command}` to #{sales_pitch}.
+      MSG
     end
   end
 end

data/lib/standard/loads_runner.rb

@@ -1,9 +1,23 @@
+require_relative "runners/rubocop"
+require_relative "runners/version"
+require_relative "runners/verbose_version"
+require_relative "runners/lsp"
+require_relative "runners/genignore"
+require_relative "runners/help"
+
 module Standard
   class LoadsRunner
-    # Warning: clever metaprogramming. 99% of the time this is Runners::Rubocop
+    RUNNERS = {
+      rubocop: ::Standard::Runners::Rubocop,
+      version: ::Standard::Runners::Version,
+      verbose_version: ::Standard::Runners::VerboseVersion,
+      lsp: ::Standard::Runners::Lsp,
+      genignore: ::Standard::Runners::Genignore,
+      help: ::Standard::Runners::Help
+    }.freeze
+
     def call(command)
-      require_relative "runners/#{command}"
-      ::Standard::Runners.const_get(command.to_s.capitalize).new
+      RUNNERS[command].new
     end
   end
 end

data/lib/standard/loads_yaml_config.rb

@@ -1,18 +1,15 @@
 require "yaml"
 require "pathname"
 require_relative "file_finder"
-require_relative "parses_cli_option"
+require_relative "resolves_yaml_option"
 
 module Standard
   class LoadsYamlConfig
-    def initialize
-      @parses_cli_option = ParsesCliOption.new
-    end
+    def call(standard_yaml_path, todo_yaml_path)
+      standard_yaml = load_standard_yaml(standard_yaml_path)
+      todo_yaml = load_standard_yaml(todo_yaml_path)
 
-    def call(argv, search_path)
-      yaml_path = @parses_cli_option.call(argv, "--config") ||
-        FileFinder.new.call(".standard.yml", search_path)
-      construct_config(yaml_path, load_standard_yaml(yaml_path))
+      construct_config(standard_yaml_path, standard_yaml, todo_yaml_path, todo_yaml)
     end
 
     private
@@ -25,18 +22,28 @@ module Standard
       end
     end
 
-    def construct_config(yaml_path, standard_yaml)
+    def construct_config(yaml_path, standard_yaml, todo_path, todo_yaml)
       {
-        ruby_version: Gem::Version.new((standard_yaml["ruby_version"] || RUBY_VERSION)),
+        ruby_version: normalized_ruby_version(standard_yaml["ruby_version"]),
         fix: !!standard_yaml["fix"],
         format: standard_yaml["format"],
         parallel: !!standard_yaml["parallel"],
-        ignore: expand_ignore_config(standard_yaml["ignore"]),
+        ignore: expand_ignore_config(standard_yaml["ignore"]) + expand_ignore_config(todo_yaml["ignore"]),
         default_ignores: standard_yaml.key?("default_ignores") ? !!standard_yaml["default_ignores"] : true,
         config_root: yaml_path ? Pathname.new(yaml_path).dirname.to_s : nil,
+        todo_file: todo_path,
+        todo_ignore_files: Array(todo_yaml["ignore"]).map { |f| (Hash === f) ? f.keys.first : f },
+        plugins: Array(standard_yaml["plugins"]),
+        extend_config: Array(standard_yaml["extend_config"])
       }
     end
 
+    def normalized_ruby_version(version)
+      return version if version && !Gem::Version.correct?(version)
+
+      Gem::Version.new(version || RUBY_VERSION)
+    end
+
     def expand_ignore_config(ignore_config)
       arrayify(ignore_config).map { |rule|
         if rule.is_a?(String)

data/lib/standard/lsp/diagnostic.rb

@@ -0,0 +1,174 @@
+module Standard
+  module Lsp
+    class Diagnostic
+      Constant = LanguageServer::Protocol::Constant
+      Interface = LanguageServer::Protocol::Interface
+
+      RUBOCOP_TO_LSP_SEVERITY = {
+        info: Constant::DiagnosticSeverity::HINT,
+        refactor: Constant::DiagnosticSeverity::INFORMATION,
+        convention: Constant::DiagnosticSeverity::INFORMATION,
+        warning: Constant::DiagnosticSeverity::WARNING,
+        error: Constant::DiagnosticSeverity::ERROR,
+        fatal: Constant::DiagnosticSeverity::ERROR
+      }.freeze
+
+      def initialize(document_encoding, offense, uri, cop_class)
+        @document_encoding = document_encoding
+        @offense = offense
+        @uri = uri
+        @cop_class = cop_class
+      end
+
+      def to_lsp_code_actions
+        code_actions = []
+
+        code_actions << autocorrect_action if correctable?
+        code_actions << disable_line_action
+
+        code_actions
+      end
+
+      def to_lsp_diagnostic(config)
+        highlighted = @offense.highlighted_area
+        Interface::Diagnostic.new(
+          message: message,
+          source: "Standard Ruby",
+          code: @offense.cop_name,
+          code_description: code_description(config),
+          severity: severity,
+          range: Interface::Range.new(
+            start: Interface::Position.new(
+              line: @offense.line - 1,
+              character: highlighted.begin_pos
+            ),
+            end: Interface::Position.new(
+              line: @offense.line - 1,
+              character: highlighted.end_pos
+            )
+          ),
+          data: {
+            correctable: correctable?,
+            code_actions: to_lsp_code_actions
+          }
+        )
+      end
+
+      private
+
+      def message
+        message = @offense.message
+        message += "\n\nThis offense is not auto-correctable.\n" unless correctable?
+        message
+      end
+
+      def severity
+        RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name]
+      end
+
+      def code_description(config)
+        return unless @cop_class
+
+        if (doc_url = @cop_class.documentation_url(config))
+          Interface::CodeDescription.new(href: doc_url)
+        end
+      end
+
+      def autocorrect_action
+        Interface::CodeAction.new(
+          title: "Autocorrect #{@offense.cop_name}",
+          kind: Constant::CodeActionKind::QUICK_FIX,
+          edit: Interface::WorkspaceEdit.new(
+            document_changes: [
+              Interface::TextDocumentEdit.new(
+                text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
+                  uri: ensure_uri_scheme(@uri.to_s).to_s,
+                  version: nil
+                ),
+                edits: correctable? ? offense_replacements : []
+              )
+            ]
+          ),
+          is_preferred: true
+        )
+      end
+
+      def offense_replacements
+        @offense.corrector.as_replacements.map do |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
+
+      def disable_line_action
+        Interface::CodeAction.new(
+          title: "Disable #{@offense.cop_name} for this line",
+          kind: Constant::CodeActionKind::QUICK_FIX,
+          edit: Interface::WorkspaceEdit.new(
+            document_changes: [
+              Interface::TextDocumentEdit.new(
+                text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
+                  uri: ensure_uri_scheme(@uri.to_s).to_s,
+                  version: nil
+                ),
+                edits: line_disable_comment
+              )
+            ]
+          )
+        )
+      end
+
+      def line_disable_comment
+        new_text = if @offense.source_line.include?(" # standard:disable ")
+          ",#{@offense.cop_name}"
+        else
+          " # standard:disable #{@offense.cop_name}"
+        end
+
+        eol = Interface::Position.new(
+          line: @offense.line - 1,
+          character: length_of_line(@offense.source_line)
+        )
+
+        # TODO: fails for multiline strings - may be preferable to use block
+        # comments to disable some offenses
+        inline_comment = Interface::TextEdit.new(
+          range: Interface::Range.new(start: eol, end: eol),
+          new_text: new_text
+        )
+
+        [inline_comment]
+      end
+
+      def length_of_line(line)
+        if @document_encoding == Encoding::UTF_16LE
+          line_length = 0
+          line.codepoints.each do |codepoint|
+            line_length += 1
+            if codepoint > RubyLsp::Document::Scanner::SURROGATE_PAIR_START
+              line_length += 1
+            end
+          end
+          line_length
+        else
+          line.length
+        end
+      end
+
+      def correctable?
+        !@offense.corrector.nil?
+      end
+
+      def ensure_uri_scheme(uri)
+        uri = URI.parse(uri)
+        uri.scheme = "file" if uri.scheme.nil?
+        uri
+      end
+    end
+  end
+end

data/lib/standard/lsp/kills_server.rb

@@ -0,0 +1,10 @@
+module Standard
+  module Lsp
+    class KillsServer
+      def call(&blk)
+        at_exit(&blk) unless blk.nil?
+        exit 0
+      end
+    end
+  end
+end

data/lib/standard/lsp/logger.rb

@@ -0,0 +1,21 @@
+module Standard
+  module Lsp
+    class Logger
+      def initialize(prefix: "[server]")
+        @prefix = prefix
+        @puts_onces = []
+      end
+
+      def puts(message)
+        warn [@prefix, message].compact.join(" ")
+      end
+
+      def puts_once(message)
+        return if @puts_onces.include?(message)
+
+        @puts_onces << message
+        puts(message)
+      end
+    end
+  end
+end