standard 0.1.0 → 1.51.1

data/config/default.yml

@@ -0,0 +1,8 @@
+AllCops:
+  TargetRubyVersion: 3.0
+  Exclude: []
+  DisabledByDefault: true
+  StyleGuideBaseURL: https://github.com/standardrb/standard
+
+Lint/Syntax:
+  Enabled: true

data/config/ruby-1.8.yml

@@ -1,8 +1,16 @@
 inherit_from: ./ruby-1.9.yml
 
+Style/HashSyntax:
+  EnforcedStyle: hash_rockets
+
 Style/Lambda:
   Enabled: false
 
-Style/HashSyntax:
-  EnforcedStyle: hash_rockets
+Style/FileWrite:
+  Enabled: false
+
+Style/FileRead:
+  Enabled: false
 
+Layout/DotPosition:
+  Enabled: false

data/config/ruby-1.9.yml

@@ -1,4 +1,14 @@
-inherit_from: ./ruby-2.2.yml
+inherit_from: ./ruby-2.0.yml
 
 Style/Encoding:
   Enabled: false
+
+Style/HashConversion:
+  Enabled: false
+
+# Percent delimiters are not supported until Ruby 2.0
+Style/PercentLiteralDelimiters:
+  Enabled: false
+
+Style/FileNull:
+  Enabled: false

data/config/ruby-2.0.yml

@@ -0,0 +1,4 @@
+inherit_from: ./ruby-2.1.yml
+
+AllCops:
+  TargetRubyVersion: 2.0

data/config/ruby-2.1.yml

@@ -0,0 +1,4 @@
+inherit_from: ./ruby-2.2.yml
+
+AllCops:
+  TargetRubyVersion: 2.1

data/config/ruby-2.2.yml

@@ -1,8 +1,16 @@
-inherit_from: ./base.yml
+inherit_from: ./ruby-2.3.yml
 
 AllCops:
-  TargetRubyVersion: 2.3 # The oldest supported
+  TargetRubyVersion: 2.2
 
-Layout:
-  IndentHeredoc:
-    Enabled: false
+# The below cops are for features not available until Ruby 2.3 but,
+# as of this writing, the cops don't correctly use the TargetRubyVersion.
+
+Style/HashFetchChain:
+  Enabled: false
+
+Layout/HeredocIndentation:
+  Enabled: false
+
+Style/SafeNavigation:
+  Enabled: false

data/config/ruby-2.3.yml

@@ -0,0 +1,10 @@
+inherit_from: ./ruby-2.4.yml
+
+AllCops:
+  TargetRubyVersion: 2.3
+
+Style/ComparableClamp:
+  Enabled: false
+
+Style/DirEmpty:
+  Enabled: false

data/config/ruby-2.4.yml

@@ -0,0 +1,10 @@
+inherit_from: ./ruby-2.5.yml
+
+AllCops:
+  TargetRubyVersion: 2.4
+
+Style/RedundantBegin:
+  Enabled: false
+
+Style/HashSlice:
+  Enabled: false

data/config/ruby-2.5.yml

@@ -0,0 +1,10 @@
+inherit_from: ./ruby-2.6.yml
+
+AllCops:
+  TargetRubyVersion: 2.5
+
+Style/SlicingWithRange:
+  Enabled: false
+
+Lint/SuppressedExceptionInNumberConversion:
+  Enabled: false

data/config/ruby-2.6.yml

@@ -0,0 +1,13 @@
+inherit_from: ./ruby-2.7.yml
+
+AllCops:
+  TargetRubyVersion: 2.6
+
+Style/NumberedParameters:
+  Enabled: false
+
+Style/NumberedParametersLimit:
+  Enabled: false
+
+Lint/DuplicateMatchPattern:
+  Enabled: false

data/config/ruby-2.7.yml

@@ -0,0 +1,10 @@
+inherit_from: ./ruby-3.0.yml
+
+AllCops:
+  TargetRubyVersion: 2.7
+
+Style/HashExcept:
+  Enabled: false
+
+Style/RedundantInterpolationUnfreeze:
+  Enabled: false

data/config/ruby-3.0.yml

@@ -0,0 +1,13 @@
+inherit_from: ./ruby-3.1.yml
+
+AllCops:
+  TargetRubyVersion: 3.0
+
+Naming/BlockForwarding:
+  Enabled: false
+
+Style/NestedFileDirname:
+  Enabled: false
+
+Lint/RefinementImportMethods:
+  Enabled: false

data/config/ruby-3.1.yml

@@ -0,0 +1,11 @@
+inherit_from: ./ruby-3.2.yml
+
+AllCops:
+  TargetRubyVersion: 3.1
+
+Style/DataInheritance:
+  Enabled: false
+
+Style/ArgumentsForwarding:
+  Enabled: false
+  AllowOnlyRestArgument: true

data/config/ruby-3.2.yml

@@ -0,0 +1,4 @@
+inherit_from: ./ruby-3.3.yml
+
+AllCops:
+  TargetRubyVersion: 3.2

data/config/ruby-3.3.yml

@@ -0,0 +1,7 @@
+inherit_from: ./base.yml
+
+AllCops:
+  TargetRubyVersion: 3.3
+
+Style/ItBlockParameter:
+  Enabled: false

data/docs/ARCHITECTURE.md

@@ -0,0 +1,33 @@
+# Standard Ruby's Architecture
+
+Architecture is not a 4-letter word (but the silly abbreviation 'a10e' is!), so
+as Standard's internal structure has introduced more moving parts, it's
+important to plant a stake in the ground and explain where all the cops are
+buried.
+
+Starting with version 1.28.0, Standard Ruby introduced plugin support and
+refactored how it loads its own rules from one large YAML file into several
+plugins. As a result, what was a single `standard` gem is now spread across 3
+gems.
+
+Here's how it's all organized:
+
+* [standard](https://github.com/standardrb/standard) - The main gem. The one
+people install and think of. Because `standard` has a hard dependency on `rubocop`,
+the base configuration of RuboCop's built-in rules is bundled into the gem, even
+though it's now [defined as a plugin](lib/standard/base/plugin.rb)
+* [standard-performance](https://github.com/standardrb/standard-performance) - A
+plugin that depends on and configures
+[rubocop-performance](https://github.com/rubocop/rubocop-performance)
+* [standard-custom](https://github.com/standardrb/standard-custom) - A plugin
+that implements and configures any custom rules that the Standard team writes
+and maintains itself with the intention that they be part of the default
+Standard Ruby experience (there's only one of these rules so far)
+
+To glue these things together, yet another gem was created (gems are free,
+right?) to define a very simple plugin API. That gem is called
+[lint_roller](https://github.com/standardrb/lint_roller) and it can be used by
+any gem that provides or consumes linting and formatting rules. Because Standard
+Ruby is built on RuboCop's configuration and runner, RuboCop could adopt
+`lint_roller` as its plugin system and plugins could support both `rubocop`
+and `standard` out of the box.

data/docs/RELEASE.md

@@ -0,0 +1,41 @@
+# How to release Standard Ruby
+
+Because this gem was generated with the [bundler `gem`
+command](https://bundler.io/man/bundle-gem.1.html), [our Rakefile](/Rakefile)
+loads `bundler/gem_tasks`, which provides a lot of the commands one needs
+to manage a gem's release lifecycle:
+
+```
+$ rake -T
+rake build            # Build standard-x.x.x.gem into the pkg directory
+rake clean            # Remove any temporary products
+rake clobber          # Remove any generated files
+rake install          # Build and install standard-x.x.x.gem into system gems
+rake install:local    # Build and install standard-x.x.x.gem into system gems without network access
+rake release[remote]  # Create tag vx.x.x and build and push standard-0.5.2.gem to rubygems.org
+```
+
+Most of these commands are depended on (read: run by) `./bin/rake release`, which is
+really the only one we'll need for releasing the gem to
+[Rubygems.org](https://rubygems.org/gems/standard).
+
+## Release steps
+
+1. Make sure git is up to date and `./bin/rake` exits cleanly
+1. If you upgraded a Rubocop dependency, be sure to lock it down in
+   `standard.gemspec`. To avoid being broken transitively, we stick to exact
+   release dependencies (e.g. "0.91.0" instead of "~> 0.91")
+1. Update `CHANGELOG.md` as exhaustively as you are able and set the top header
+   to "Unreleased"
+1. Bump the appropriate version segment in `lib/standard/version.rb` (basic
+   semantic versioning rules apply; if the release updates Rubocop, follow its
+   version bump at a minimum—if rubocop saw minor bump, we'll also bump the
+   minor version)
+1. Run `bundle` so that Bundler writes this version to `Gemfile.lock`
+1. Commit `lib/standard/version.rb`, `Gemfile.lock`, and `CHANGELOG.md` together
+   with the message equal to the new version (e.g. "0.42.1")
+1. Finally, run `./bin/rake release`, which will hopefully succeed
+1. Provide your multi-factor-auth token when prompted to finish publishing the
+   gem
+1. [Tweet](https://twitter.com) about your awesome new release! (Shameless
+   self-promotion is the most important part of open source software)

data/docs/RUBY_VERSIONS.md

@@ -0,0 +1,51 @@
+# Ruby versions
+
+## Handling new releases
+
+When a new Ruby version comes out, you shouldn't have to make any immediate
+changes to Standard Ruby. The default configuration is the `base.yml`
+configuration and should continue to work correctly.
+
+Often, Rubocop will add new rules to encourage usage of new language features in
+new Ruby versions. When that happens:
+
+1. Add the rule to the `base.yml` file and disable it.
+1. Assess the new rule and see if it should be added to Standard Ruby. If not,
+   you're done. If so, enable it in `base.yml` and read on.
+1. Add a new config file for the penultimate minor version of Ruby. For example,
+   if the new version is `3.1` then the new config file would be for `3.0`.
+1. In the new config file, make sure it inherits from `base.yml` and disable the
+   new rule.
+1. In what was previously the latest config file, make sure it inherits from
+   your new config file.
+
+That should add new rules to Standard Ruby safely and gracefully.
+
+## Maintenance and support
+
+We will support the actively maintained ruby versions from the [ruby maintenance
+policy](https://www.ruby-lang.org/en/downloads/branches/) along with the most
+recently EOL version for an additional ~9 months, dropping support for EOL
+versions around the time that a new supported ruby version is released and
+added.
+
+With the current ruby release cadence (new version near end of year, EOL drop
+around April 1), this means we'll have a release of all the Standard gems around
+the new year which adds support for the new ruby version and drops support for
+what was an already-EOL but still-supported older ruby version.
+
+## Coordination across gems
+
+We will align versions/dependencies amongst the Standard gems:
+
+- [standard-custom](https://github.com/standardrb/standard-custom)
+- [standard-performance](https://github.com/standardrb/standard-performance)
+- [standard-rails](https://github.com/standardrb/standard-rails)
+- [standard-sorbet](https://github.com/standardrb/standard-sorbet)
+- [standard](https://github.com/standardrb/standard)
+
+This means keeping them consistent in regard to:
+
+- The minimum required ruby version configured in their `gemspec`
+- Using that version in their internal `.standard.yml` configurations
+- Including the full range of supported rubies in their CI ruby matrix

data/docs/UPGRADING.md

@@ -0,0 +1,31 @@
+# Upgrading Standard
+
+Since standard now encompasses both a tool itself and a series of plug-ins it makes sense to first update the standard plug-ins and then the standard tool itself. Each plug-in is a configuration for its corresponding rubocop plug-in.
+
+The official standard plug-ins that are included in standard are:
+
+- **Standard Performance:** corresponding to rubocop-performance
+- **Standard Custom:** for custom cops created for standard
+
+## Updating Standard Plugins
+
+1. Update Rubocop plugin in the gemspec file and gem file.
+1. Keep standard in the gem file up-to-date. This will bring any testing utilities in standard into the plug-in repository.
+1. Run `./bin/rake` to run the tests
+1. Configure any cops that need to be configured so that the tests pass
+1. Update the change log to the best of your ability and title it as unreleased
+1. Make your commit for these updates and push to the main branch
+1. Update the version in version.rb and update the version in the Changelog replacing the word “Unreleased”
+1. Run bundle to write the new version number to the lock file
+1. Run `./bin/rake release` to release the gem to RubyGems and create the version git tag. Push the tag to GitHub.
+
+## Updating Standard
+
+1. Update Rubocop as well as Standard Performance in the gemspec file and gem file.
+1. Run `./bin/rake` to run the tests
+1. Configure any cops that need to be configured so that the tests pass
+1. Update the change log to the best of your ability and title it as unreleased
+1. Make your commit for these updates and push to the main branch
+1. Update the version in version.rb and update the version in the Changelog replacing the word “Unreleased”
+1. Run bundle to write the new version number to the lock file
+1. Run `./bin/rake` to release the gem to RubyGems and create the version git tag. Push the tag to GitHub.

data/lib/ruby_lsp/standard/addon.rb

@@ -0,0 +1,58 @@
+require "standard"
+require_relative "wraps_built_in_lsp_standardizer"
+
+module RubyLsp
+  module Standard
+    class Addon < ::RubyLsp::Addon
+      def name
+        "Standard Ruby"
+      end
+
+      def activate(global_state, message_queue)
+        @logger = ::Standard::Lsp::Logger.new(prefix: "[Standard Ruby]")
+        @logger.puts "Activating Standard Ruby LSP addon v#{::Standard::VERSION}"
+        ::RuboCop::LSP.enable
+        @wraps_built_in_lsp_standardizer = WrapsBuiltinLspStandardizer.new
+        global_state.register_formatter("standard", @wraps_built_in_lsp_standardizer)
+        register_additional_file_watchers(global_state, message_queue)
+        @logger.puts "Initialized Standard Ruby LSP addon #{::Standard::VERSION}"
+      end
+
+      def deactivate
+        @wraps_built_in_lsp_standardizer = nil
+      end
+
+      def register_additional_file_watchers(global_state, message_queue)
+        return unless global_state.supports_watching_files
+
+        message_queue << Request.new(
+          id: "standard-file-watcher",
+          method: "client/registerCapability",
+          params: Interface::RegistrationParams.new(
+            registrations: [
+              Interface::Registration.new(
+                id: "workspace/didChangeWatchedFilesStandard",
+                method: "workspace/didChangeWatchedFiles",
+                register_options: Interface::DidChangeWatchedFilesRegistrationOptions.new(
+                  watchers: [
+                    Interface::FileSystemWatcher.new(
+                      glob_pattern: "**/.standard{,_todo}.yml",
+                      kind: Constant::WatchKind::CREATE | Constant::WatchKind::CHANGE | Constant::WatchKind::DELETE
+                    )
+                  ]
+                )
+              )
+            ]
+          )
+        )
+      end
+
+      def workspace_did_change_watched_files(changes)
+        if changes.any? { |change| change[:uri].end_with?(".standard.yml") }
+          @wraps_built_in_lsp_standardizer.init!
+          @logger.puts "Re-initialized Standard Ruby LSP addon #{::Standard::VERSION} due to .standard.yml file change"
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/standard/wraps_built_in_lsp_standardizer.rb

@@ -0,0 +1,44 @@
+module RubyLsp
+  module Standard
+    class WrapsBuiltinLspStandardizer
+      include RubyLsp::Requests::Support::Formatter
+
+      def initialize
+        init!
+      end
+
+      def init!
+        @standardizer = ::Standard::Lsp::Standardizer.new(
+          ::Standard::BuildsConfig.new.call([])
+        )
+      end
+
+      def run_formatting(uri, document)
+        @standardizer.format(uri_to_path(uri), document.source)
+      end
+
+      def run_diagnostic(uri, document)
+        @standardizer.offenses(uri_to_path(uri), document.source, document.encoding)
+      end
+
+      def run_range_formatting(_uri, _partial_source, _base_indentation)
+        # Not yet supported. Should return the formatted version of `partial_source` which is a partial selection of the
+        # entire document. For example, it should not try to add a frozen_string_literal magic comment and all style
+        # corrections should start from the `base_indentation`
+        nil
+      end
+
+      private
+
+      # duplicated from: lib/standard/lsp/routes.rb
+      # modified to incorporate Ruby LSP's to_standardized_path method
+      def uri_to_path(uri)
+        if uri.respond_to?(:to_standardized_path) && !(standardized_path = uri.to_standardized_path).nil?
+          standardized_path
+        else
+          uri.to_s.sub(%r{^file://}, "")
+        end
+      end
+    end
+  end
+end

data/lib/standard/base/plugin.rb

@@ -0,0 +1,69 @@
+module Standard::Base
+  class Plugin < LintRoller::Plugin
+    def initialize(config)
+      @config = config
+    end
+
+    def about
+      LintRoller::About.new(
+        name: "standard-base",
+        version: VERSION,
+        homepage: "https://github.com/standardrb/standard",
+        description: "Configuration for RuboCop's built-in rules"
+      )
+    end
+
+    def supported?(context)
+      true
+    end
+
+    def rules(context)
+      LintRoller::Rules.new(
+        type: :path,
+        config_format: :rubocop,
+        value: determine_yaml_path(context.target_ruby_version)
+      )
+    end
+
+    private
+
+    def determine_yaml_path(desired_version)
+      desired_version = Gem::Version.new(desired_version) unless desired_version.is_a?(Gem::Version)
+      default = "base.yml"
+
+      file_name = if !Gem::Version.correct?(desired_version)
+        default
+      elsif desired_version < Gem::Version.new("1.9")
+        "ruby-1.8.yml"
+      elsif desired_version < Gem::Version.new("2.0")
+        "ruby-1.9.yml"
+      elsif desired_version < Gem::Version.new("2.1")
+        "ruby-2.0.yml"
+      elsif desired_version < Gem::Version.new("2.2")
+        "ruby-2.1.yml"
+      elsif desired_version < Gem::Version.new("2.3")
+        "ruby-2.2.yml"
+      elsif desired_version < Gem::Version.new("2.4")
+        "ruby-2.3.yml"
+      elsif desired_version < Gem::Version.new("2.5")
+        "ruby-2.4.yml"
+      elsif desired_version < Gem::Version.new("2.6")
+        "ruby-2.5.yml"
+      elsif desired_version < Gem::Version.new("3.0")
+        "ruby-2.7.yml"
+      elsif desired_version < Gem::Version.new("3.1")
+        "ruby-3.0.yml"
+      elsif desired_version < Gem::Version.new("3.2")
+        "ruby-3.1.yml"
+      elsif desired_version < Gem::Version.new("3.3")
+        "ruby-3.2.yml"
+      elsif desired_version < Gem::Version.new("3.4")
+        "ruby-3.3.yml"
+      else
+        default
+      end
+
+      Pathname.new(__dir__).join("../../../config/#{file_name}")
+    end
+  end
+end

data/lib/standard/base.rb

@@ -0,0 +1,8 @@
+require "lint_roller"
+
+require_relative "base/plugin"
+
+module Standard
+  module Base
+  end
+end

data/lib/standard/builds_config.rb

@@ -7,13 +7,23 @@ module Standard
 
   class BuildsConfig
     def initialize
+      @resolves_yaml_option = ResolvesYamlOption.new
       @loads_yaml_config = LoadsYamlConfig.new
       @merges_settings = MergesSettings.new
       @creates_config_store = CreatesConfigStore.new
     end
 
     def call(argv, search_path = Dir.pwd)
-      standard_config = @loads_yaml_config.call(argv, search_path)
+      standard_yaml_path = @resolves_yaml_option.call(argv, search_path, "--config", ".standard.yml")
+
+      # Don't load the existing todo file when generating a new todo file.  Otherwise the
+      # new todo file won't have the ignore rules in the existing file.
+      todo_yaml_path = unless argv.include?("--generate-todo")
+        @resolves_yaml_option.call(argv, search_path, "--todo", ".standard_todo.yml")
+      end
+
+      standard_config = @loads_yaml_config.call(standard_yaml_path, todo_yaml_path)
+
       settings = @merges_settings.call(argv, standard_config)
       Config.new(
         settings.runner,

data/lib/standard/cli.rb

@@ -3,9 +3,6 @@ require_relative "loads_runner"
 
 module Standard
   class Cli
-    SUCCESS_STATUS_CODE = 0
-    FAILURE_STATUS_CODE = 1
-
     def initialize(argv)
       @argv = argv
       @builds_config = BuildsConfig.new
@@ -14,10 +11,7 @@ module Standard
 
     def run
       config = @builds_config.call(@argv)
-
-      success = @loads_runner.call(config.runner).call(config)
-
-      success ? SUCCESS_STATUS_CODE : FAILURE_STATUS_CODE
+      @loads_runner.call(config.runner).call(config).to_i
     end
   end
 end

data/lib/standard/creates_config_store/assigns_rubocop_yaml.rb

@@ -3,24 +3,8 @@ require "pathname"
 class Standard::CreatesConfigStore
   class AssignsRubocopYaml
     def call(config_store, standard_config)
-      config_store.options_config = rubocop_yaml_path(standard_config[:ruby_version])
-      config_store.instance_variable_get("@options_config")
-    end
-
-    private
-
-    def rubocop_yaml_path(desired_version)
-      file_name = if desired_version < Gem::Version.new("1.9")
-        "ruby-1.8.yml"
-      elsif desired_version < Gem::Version.new("2.0")
-        "ruby-1.9.yml"
-      elsif desired_version < Gem::Version.new("2.3")
-        "ruby-2.2.yml"
-      else
-        "base.yml"
-      end
-
-      Pathname.new(__dir__).join("../../../config/#{file_name}")
+      config_store.options_config = Pathname.new(__dir__).join("../../../config/default.yml")
+      config_store.instance_variable_get(:@options_config)
     end
   end
 end

data/lib/standard/creates_config_store/configures_ignored_paths.rb

@@ -8,7 +8,7 @@ class Standard::CreatesConfigStore
       # Standard's own default ignores:
       "bin/*",
       "db/schema.rb",
-      "tmp/**/*",
+      "tmp/**/*"
     ].map { |path| [path, ["AllCops"]] }.freeze
 
     def call(options_config, standard_config)
@@ -17,7 +17,7 @@ class Standard::CreatesConfigStore
           options_config[cop] ||= {}
           options_config[cop]["Exclude"] ||= []
           options_config[cop]["Exclude"] |= [
-            absolutify(standard_config[:config_root], path),
+            absolutify(standard_config[:config_root], path)
           ]
         end
       end

data/lib/standard/creates_config_store/merges_user_config_extensions.rb

@@ -0,0 +1,37 @@
+require_relative "../file_finder"
+require_relative "../plugin"
+
+class Standard::CreatesConfigStore
+  class MergesUserConfigExtensions
+    class ExtendConfigPlugin < LintRoller::Plugin
+      def initialize(path)
+        @yaml_path = Standard::FileFinder.new.call(path, Dir.pwd)
+      end
+
+      def about
+        About.new("Pseudo-plugin wrapping the `extend_config' path: #{@yaml_path}")
+      end
+
+      def rules(context)
+        LintRoller::Rules.new(
+          type: :path,
+          config_format: :rubocop,
+          value: @yaml_path
+        )
+      end
+    end
+
+    def initialize
+      @merges_plugins_into_rubocop_config = Standard::Plugin::MergesPluginsIntoRubocopConfig.new
+    end
+
+    def call(options_config, standard_config)
+      return unless standard_config[:extend_config]&.any?
+
+      plugins = standard_config[:extend_config].map { |path|
+        ExtendConfigPlugin.new(path)
+      }
+      @merges_plugins_into_rubocop_config.call(options_config, standard_config, plugins, permit_merging: false)
+    end
+  end
+end