standard 0.13.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0e6cc49d6d26e0bb428b7d05637a45b00ea6e0542f04a215a621ae5238c35dc
-  data.tar.gz: b7599f068adeff886b013330d72c2dd8fceb415ac6d53299fee208eec6c7b141
+  metadata.gz: b3d6131b141958b49962a43f3f415ede32f3ca768e338e3c2783537f4ac325f7
+  data.tar.gz: 998dfccb3c11abced12b56b9225cbd7979055df18c25af5771d0470ffdf79b8a
 SHA512:
-  metadata.gz: 5711e67885d2ed2167fc9ec61614a69397967cbe57f97d313973e17b0d932c822b4fc832e4159caec22a204ac4e4a8144b260bd8368ead6917f9429f8464ce41
-  data.tar.gz: 5f1b78ef4a3962a83bfae6b4593c42efc9cdd588da671e912ed66ff1f9d1bd3571cf05960198989405627211207aa4303f58dc173c8a650d37468d984d66ce3e
+  metadata.gz: a92a4ac4920e0394914a3a2e23ec1cfe0f9c383cd48336df1e2d80e60e1c39289233331bd0dbfd4e0af68c3451cd19122fe3da3cb37758b559220808b2b8eec7
+  data.tar.gz: 617a43459e7766639e610c149a28c6d9fb888557ff1ba9104384c2e7e1972e83cacdf2b817dc76cb13073db5afcb6011a0044c3bde0857fe727620e818fcb094

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 1.0.0
+
+* Relax multi-line block rules, moving away from enforcing semantic blocks to
+  instead allowing code to adhere to whatever multi-line format the author deems
+  best [#263](https://github.com/testdouble/standard/pull/263)
+* Allow a `standard:disable` comment directive in addition to `rubocop:disable`
+  [#186](https://github.com/testdouble/standard/pull/186)
+* Remove the banner text that standard outputs after failure
+  [#264](https://github.com/testdouble/standard/pull/264)
+
 ## 0.13.0
 
 * Update rubocop from 1.7.0 to [1.10.0](https://github.com/rubocop-hq/rubocop/releases/tag/v1.10.0) enabling:
@@ -12,7 +22,7 @@
 * Update rubocop from 1.7.0 to [1.8.1](https://github.com/rubocop-hq/rubocop/releases/tag/v1.8.1)
 * Enabled [`Style/SlicingWithRange`](https://github.com/testdouble/standard/issues/175)
 
-## 0.11.0 
+## 0.11.0
 
 * Update rubocop-performance from 1.9.1 to [1.9.2](https://github.com/rubocop-hq/rubocop-performance/releases/tag/v1.9.2)
 * Update rubocop from 1.4.2 to [1.7.0](https://github.com/rubocop-hq/rubocop/releases/tag/v1.7.0)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    standard (0.13.0)
+    standard (1.0.0)
       rubocop (= 1.10.0)
       rubocop-performance (= 1.9.2)
 
@@ -13,7 +13,7 @@ GEM
     docile (1.3.5)
     gimme (0.5.0)
     method_source (1.0.0)
-    minitest (5.14.3)
+    minitest (5.14.4)
     parallel (1.20.1)
     parser (3.0.0.0)
       ast (~> 2.4.1)
@@ -22,7 +22,7 @@ GEM
       method_source (~> 1.0)
     rainbow (3.0.0)
     rake (13.0.3)
-    regexp_parser (2.0.3)
+    regexp_parser (2.1.1)
     rexml (3.2.4)
     rubocop (1.10.0)
       parallel (~> 1.10)
@@ -60,4 +60,4 @@ DEPENDENCIES
   standard!
 
 BUNDLED WITH
-   2.2.6
+   2.2.3

data/LICENSE.txt

@@ -2,7 +2,7 @@ Copyright (c) 2019 Test Double, LLC
 
 Portions of these files Copyright (c) 2012-18 Bozhidar Batsov:
   - config/base.yml
-  - lib/standard/cop/semantic_blocks.rb
+  - lib/standard/cop/block_delimiters.rb
   - test/cop_invoker.rb
 
 Permission is hereby granted, free of charge, to any person obtaining

data/README.md

@@ -40,10 +40,12 @@ flag.
   you'll need interpolation in a string slows people down
 - **1.9 hash syntax** - When all the keys in a hash literal are symbols,
   Standard enforces Ruby 1.9's `{hash: syntax}`
-- **Semantic blocks** - `{`/`}` for functional blocks that return a value, and
-  `do`/`end` for procedural blocks that have side effects. More
-  [here](http://www.virtuouscode.com/2011/07/26/the-procedurefunction-block-convention-in-ruby/)
-  and [here](https://github.com/rubocop-hq/ruby-style-guide/issues/162)
+- **Braces for single-line blocks** - Require `{`/`}` for one-line blocks, but
+  allow either braces or `do`/`end` for multiline blocks. Like using `do`/`end`
+  for multiline blocks? Prefer `{`/`}` when chaining? A fan of expressing intent
+  with Jim Weirich's [semantic
+  block](http://www.virtuouscode.com/2011/07/26/the-procedurefunction-block-convention-in-ruby/)
+  approach? Standard lets you do you!
 - **Leading dots on multi-line method chains** - chosen for
   [these](https://github.com/testdouble/standard/issues/75) reasons.
 - **Spaces inside blocks, but not hash literals** - In Ruby, the `{` and `}`
@@ -58,12 +60,6 @@ can look at Standard's current base configuration in
 significant changes to the configuration will be documented as [GitHub release
 notes](https://github.com/testdouble/standard/releases).
 
-**[NOTE: until StandardRB hits 1.0.0, we consider this configuration to be a
-non-final work in progress and we encourage you to submit your opinions (and
-reasoned arguments) for the addition, removal, or change to a rule by [opening
-an issue](https://github.com/testdouble/standard/issues/new). If you start using
-Standard, don't be shocked if things change a bit!]**
-
 ## Usage
 
 Once you've installed Standard, you should be able to use the `standardrb`
@@ -302,10 +298,50 @@ ignore:
     - Style/BlockDelimiters
 ```
 
+## How do I disable a warning within my source code?
+
 You can also use special comments to disable all or certain rules within your
-source code. See [RuboCop's
-docs](https://docs.rubocop.org/en/latest/configuration/#disabling-cops-within-source-code)
-for details.
+source code.
+
+Given this source listing `foo.rb`:
+
+```ruby
+baz = 42
+```
+
+Running `standard foo.rb` would fail:
+
+```
+foo.rb:1:1: Lint/UselessAssignment: Useless assignment to variable - `baz`.
+```
+
+If we wanted to make an exception, we could add the following comment:
+
+```ruby
+baz = 42 # standard:disable Lint/UselessAssignment
+```
+
+The comment directives (both `standard:disable` and `rubocop:disable`) will
+suppress the error and Standard would succeed.
+
+If, however, you needed to disable standard for multiple lines, you could use
+open and closing directives like this:
+
+```ruby
+# standard:disable Layout/IndentationWidth
+def foo
+    123
+end
+# standard:enable Layout/IndentationWidth
+```
+
+And if you don't know or care which rule is being violated, you can also
+substitute its name for "all". This line actually triggers three different
+violations, so we can suppress them like this:
+
+```ruby
+baz = ['a'].each do end # standard:disable all
+```
 
 ## How do I specify a Ruby version? What is supported?
 

data/config/base.yml

@@ -738,39 +738,8 @@ Security/YAMLLoad:
   Enabled: true
   SafeAutoCorrect: false
 
-Standard/SemanticBlocks:
-  ProceduralMethods:
-    - benchmark
-    - bm
-    - bmbm
-    - tap
-    # Enumerable
-    - cycle
-    - each
-    - each_cons
-    - each_entry
-    - each_slice
-    - each_with_index
-    # Rails
-    - transaction
-  FunctionalMethods:
-    - given
-    - given!
-    - let
-    - let!
-    - subject
-    - watch
-    - Given
-    - Given!
-    - Invariant
-    - Then
-    - And
-  IgnoredMethods:
-    - lambda
-    - proc
-    - describe
-    - it
-    - When
+Standard/BlockDelimiters:
+  Enabled: true
 
 Style/Alias:
   Enabled: true

data/docs/RELEASE.md

@@ -23,7 +23,7 @@ really the only one we'll need for releasing the gem to
 
 1. Make sure git is up to date and `bundle exec rake` exits cleanly
 2. If you upgraded a Rubocop dependency, be sure to lock it down in
-   `standard.gemspec`. Until Rubocop hits 1.0, we're going to stick to exact
+   `standard.gemspec`. To avoid being broken transitively, we stick to exact
    release dependencies (e.g. "0.91.0" instead of "~> 0.91")
 3. Bump the appropriate version segment in `lib/standard/version.rb` (basic
    semantic versioning rules apply; if the release updates Rubocop, follow its

data/lib/standard.rb

@@ -7,7 +7,7 @@ require "standard/cli"
 require "standard/railtie" if defined?(Rails) && defined?(Rails::Railtie)
 
 require "standard/formatter"
-require "standard/cop/semantic_blocks"
+require "standard/cop/block_delimiters"
 
 module Standard
 end

data/lib/standard/cop/block_delimiters.rb

@@ -0,0 +1,96 @@
+module RuboCop::Cop
+  module Standard
+    # Check for uses of braces around single line blocks, but allows either
+    # braces or do/end for multi-line blocks.
+    #
+    # @example
+    #   # bad - single line block
+    #   items.each do |item| item / 5 end
+    #
+    #   # good - single line block
+    #   items.each { |item| item / 5 }
+    #
+    class BlockDelimiters < RuboCop::Cop::Base
+      extend RuboCop::Cop::AutoCorrector
+
+      def on_send(node)
+        return unless node.arguments?
+        return if node.parenthesized?
+        return if node.operator_method? || node.assignment_method?
+
+        node.arguments.each do |arg|
+          get_blocks(arg) do |block|
+            # If there are no parentheses around the arguments, then braces
+            # and do-end have different meaning due to how they bind, so we
+            # allow either.
+            ignore_node(block)
+          end
+        end
+      end
+
+      def on_block(node)
+        return if ignored_node?(node)
+        return if proper_block_style?(node)
+
+        message = message(node)
+        add_offense(node.loc.begin, message: message) do |corrector|
+          autocorrect(corrector, node)
+        end
+      end
+
+      private
+
+      def get_blocks(node, &block)
+        case node.type
+        when :block
+          yield node
+        when :send
+          get_blocks(node.receiver, &block) if node.receiver
+        when :hash
+          # A hash which is passed as method argument may have no braces
+          # In that case, one of the K/V pairs could contain a block node
+          # which could change in meaning if do...end replaced {...}
+          return if node.braces?
+
+          node.each_child_node { |child| get_blocks(child, &block) }
+        when :pair
+          node.each_child_node { |child| get_blocks(child, &block) }
+        end
+      end
+
+      def proper_block_style?(node)
+        node.multiline? || node.braces?
+      end
+
+      def message(node)
+        "Prefer `{...}` over `do...end` for single-line blocks."
+      end
+
+      def autocorrect(corrector, node)
+        return if correction_would_break_code?(node)
+
+        replace_do_end_with_braces(corrector, node.loc)
+      end
+
+      def correction_would_break_code?(node)
+        return unless node.keywords?
+
+        node.send_node.arguments? && !node.send_node.parenthesized?
+      end
+
+      def replace_do_end_with_braces(corrector, loc)
+        b = loc.begin
+        e = loc.end
+
+        corrector.insert_after(b, " ") unless whitespace_after?(b, 2)
+
+        corrector.replace(b, "{")
+        corrector.replace(e, "}")
+      end
+
+      def whitespace_after?(range, length = 1)
+        /\s/.match?(range.source_buffer.source[range.begin_pos + length, 1])
+      end
+    end
+  end
+end

data/lib/standard/formatter.rb

@@ -8,11 +8,6 @@ module Standard
       standard: Use Ruby Standard Style (https://github.com/testdouble/standard)
     MSG
 
-    CALL_TO_ACTION_MESSAGE = <<-MSG.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
-    MSG
-
     def self.fixable_error_message(command)
       <<-MSG.gsub(/^ {8}/, "")
         standard: Run `#{command}` to automatically fix some problems.
@@ -24,7 +19,6 @@ module Standard
       @detects_fixability = DetectsFixability.new
       @header_printed_already = false
       @fix_suggestion_printed_already = false
-      @any_uncorrected_offenses = false
     end
 
     def started(_target_files)
@@ -33,7 +27,6 @@ module Standard
 
     def file_finished(file, offenses)
       return unless (uncorrected_offenses = offenses.reject(&:corrected?)).any?
-      @any_uncorrected_offenses = true
 
       print_header_once
       print_fix_suggestion_once(uncorrected_offenses)
@@ -43,10 +36,6 @@ module Standard
       end
     end
 
-    def finished(_)
-      print_call_for_feedback if @any_uncorrected_offenses
-    end
-
     private
 
     def print_header_once
@@ -90,11 +79,6 @@ 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
-    end
-
     def auto_correct_option_provided?
       options[:auto_correct] || options[:safe_auto_correct]
     end

data/lib/standard/rubocop/ext.rb

@@ -5,4 +5,12 @@ module RuboCop
       "Wrap assignment in parentheses if intentional"
     end
   end
+
+  class CommentConfig
+    remove_const :COMMENT_DIRECTIVE_REGEXP
+    COMMENT_DIRECTIVE_REGEXP = Regexp.new(
+      ('# (?:standard|rubocop) : ((?:disable|enable|todo))\b ' + COPS_PATTERN)
+        .gsub(" ", '\s*')
+    )
+  end
 end

data/lib/standard/version.rb

@@ -1,3 +1,3 @@
 module Standard
-  VERSION = Gem::Version.new("0.13.0")
+  VERSION = Gem::Version.new("1.0.0")
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: standard
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Justin Searls
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-02-16 00:00:00.000000000 Z
+date: 2021-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -70,7 +70,7 @@ files:
 - lib/standard.rb
 - lib/standard/builds_config.rb
 - lib/standard/cli.rb
-- lib/standard/cop/semantic_blocks.rb
+- lib/standard/cop/block_delimiters.rb
 - lib/standard/creates_config_store.rb
 - lib/standard/creates_config_store/assigns_rubocop_yaml.rb
 - lib/standard/creates_config_store/configures_ignored_paths.rb
@@ -109,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
 summary: Ruby Style Guide, with linter & automatic code fixer

data/lib/standard/cop/semantic_blocks.rb

@@ -1,165 +0,0 @@
-module RuboCop::Cop
-  module Standard
-    class SemanticBlocks < RuboCop::Cop::Base
-      include RuboCop::Cop::IgnoredMethods
-      extend RuboCop::Cop::AutoCorrector
-
-      def on_send(node)
-        return unless node.arguments?
-        return if node.parenthesized? || node.operator_method?
-
-        node.arguments.each do |arg|
-          get_blocks(arg) do |block|
-            # If there are no parentheses around the arguments, then braces
-            # and do-end have different meaning due to how they bind, so we
-            # allow either.
-            ignore_node(block)
-          end
-        end
-      end
-
-      def on_block(node)
-        return if ignored_node?(node) ||
-          proper_block_style?(node) ||
-          (!node.braces? && rescue_child_block?(node))
-
-        add_offense(node.loc.begin, message: message(node)) do |corrector|
-          return if correction_would_break_code?(node)
-
-          if node.braces?
-            replace_braces_with_do_end(corrector, node.loc)
-          else
-            replace_do_end_with_braces(corrector, node.loc)
-          end
-        end
-      end
-
-      private
-
-      def message(node)
-        if node.single_line?
-          "Prefer `{...}` over `do...end` for single-line blocks."
-        elsif node.loc.begin.source == "{"
-          "Prefer `do...end` over `{...}` for procedural blocks."
-        else
-          "Prefer `{...}` over `do...end` for functional blocks."
-        end
-      end
-
-      def replace_braces_with_do_end(corrector, loc)
-        b = loc.begin
-        e = loc.end
-
-        corrector.insert_before(b, " ") unless whitespace_before?(b)
-        corrector.insert_before(e, " ") unless whitespace_before?(e)
-        corrector.insert_after(b, " ") unless whitespace_after?(b)
-        corrector.replace(b, "do")
-        corrector.replace(e, "end")
-      end
-
-      def replace_do_end_with_braces(corrector, loc)
-        b = loc.begin
-        e = loc.end
-
-        corrector.insert_after(b, " ") unless whitespace_after?(b, 2)
-
-        corrector.replace(b, "{")
-        corrector.replace(e, "}")
-      end
-
-      def whitespace_before?(range)
-        range.source_buffer.source[range.begin_pos - 1, 1] =~ /\s/
-      end
-
-      def whitespace_after?(range, length = 1)
-        range.source_buffer.source[range.begin_pos + length, 1] =~ /\s/
-      end
-
-      def get_blocks(node, &block)
-        case node.type
-        when :block
-          yield node
-        when :send
-          get_blocks(node.receiver, &block) if node.receiver
-        when :hash
-          # A hash which is passed as method argument may have no braces
-          # In that case, one of the K/V pairs could contain a block node
-          # which could change in meaning if do...end replaced {...}
-          return if node.braces?
-
-          node.each_child_node { |child| get_blocks(child, &block) }
-        when :pair
-          node.each_child_node { |child| get_blocks(child, &block) }
-        end
-      end
-
-      def proper_block_style?(node)
-        method_name = node.method_name
-
-        if ignored_method?(method_name)
-          true
-        elsif node.single_line?
-          node.braces?
-        elsif node.braces?
-          !procedural_method?(method_name) &&
-            (functional_method?(method_name) || functional_block?(node))
-        else
-          procedural_method?(method_name) || !return_value_used?(node)
-        end
-      end
-
-      def correction_would_break_code?(node)
-        rescue_child_block?(node) || non_parenthesized_keyword_args?(node)
-      end
-
-      def rescue_child_block?(node)
-        node.children.any? { |node| node.rescue_type? || node.ensure_type? }
-      end
-
-      def non_parenthesized_keyword_args?(node)
-        return unless node.keywords?
-
-        node.send_node.arguments? && !node.send_node.parenthesized?
-      end
-
-      def functional_method?(method_name)
-        cop_config["FunctionalMethods"].map(&:to_sym).include?(method_name)
-      end
-
-      def functional_block?(node)
-        return_value_used?(node) || return_value_of_scope?(node)
-      end
-
-      def procedural_method?(method_name)
-        cop_config["ProceduralMethods"].map(&:to_sym).include?(method_name)
-      end
-
-      def return_value_used?(node)
-        return unless node.parent
-
-        # If there are parentheses around the block, check if that
-        # is being used.
-        if node.parent.begin_type?
-          return_value_used?(node.parent)
-        else
-          node.parent.assignment? || node.parent.send_type?
-        end
-      end
-
-      def return_value_of_scope?(node)
-        return unless node.parent
-
-        conditional?(node.parent) || array_or_range?(node.parent) ||
-          node.parent.children.last == node
-      end
-
-      def conditional?(node)
-        node.if_type? || node.or_type? || node.and_type?
-      end
-
-      def array_or_range?(node)
-        node.array_type? || node.irange_type? || node.erange_type?
-      end
-    end
-  end
-end