rubocop 0.87.1

data/lib/rubocop/cop/style/stderr_puts.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop identifies places where `$stderr.puts` can be replaced by
+      # `warn`. The latter has the advantage of easily being disabled by,
+      # the `-W0` interpreter flag or setting `$VERBOSE` to `nil`.
+      #
+      # @example
+      #   # bad
+      #   $stderr.puts('hello')
+      #
+      #   # good
+      #   warn('hello')
+      #
+      class StderrPuts < Cop
+        include RangeHelp
+
+        MSG =
+          'Use `warn` instead of `%<bad>s` to allow such output to be disabled.'
+
+        def_node_matcher :stderr_puts?, <<~PATTERN
+          (send
+            {(gvar #stderr_gvar?) (const {nil? cbase} :STDERR)}
+            :puts $_
+            ...)
+        PATTERN
+
+        def on_send(node)
+          return unless stderr_puts?(node)
+
+          add_offense(node, location: stderr_puts_range(node))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(stderr_puts_range(node), 'warn')
+          end
+        end
+
+        private
+
+        def message(node)
+          format(MSG, bad: "#{node.receiver.source}.#{node.method_name}")
+        end
+
+        def stderr_gvar?(sym)
+          sym == :$stderr
+        end
+
+        def stderr_puts_range(send)
+          range_between(
+            send.loc.expression.begin_pos,
+            send.loc.selector.end_pos
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/string_hash_keys.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the use of strings as keys in hashes. The use of
+      # symbols is preferred instead.
+      #
+      # @example
+      #   # bad
+      #   { 'one' => 1, 'two' => 2, 'three' => 3 }
+      #
+      #   # good
+      #   { one: 1, two: 2, three: 3 }
+      class StringHashKeys < Cop
+        MSG = 'Prefer symbols instead of strings as hash keys.'
+
+        def_node_matcher :string_hash_key?, <<~PATTERN
+          (pair (str _) _)
+        PATTERN
+
+        def_node_matcher :receive_environments_method?, <<~PATTERN
+          {
+            ^^(send (const {nil? cbase} :IO) :popen ...)
+            ^^(send (const {nil? cbase} :Open3)
+                {:capture2 :capture2e :capture3 :popen2 :popen2e :popen3} ...)
+            ^^^(send (const {nil? cbase} :Open3)
+                {:pipeline :pipeline_r :pipeline_rw :pipeline_start :pipeline_w} ...)
+            ^^(send {nil? (const {nil? cbase} :Kernel)} {:spawn :system} ...)
+            ^^(send _ {:gsub :gsub!} ...)
+          }
+        PATTERN
+
+        def on_pair(node)
+          return unless string_hash_key?(node)
+          return if receive_environments_method?(node)
+
+          add_offense(node.key)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            symbol_content = node.str_content.to_sym.inspect
+            corrector.replace(node, symbol_content)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/string_literals.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks if uses of quotes match the configured preference.
+      #
+      # @example EnforcedStyle: single_quotes (default)
+      #   # bad
+      #   "No special symbols"
+      #   "No string interpolation"
+      #   "Just text"
+      #
+      #   # good
+      #   'No special symbols'
+      #   'No string interpolation'
+      #   'Just text'
+      #   "Wait! What's #{this}!"
+      #
+      # @example EnforcedStyle: double_quotes
+      #   # bad
+      #   'Just some text'
+      #   'No special chars or interpolation'
+      #
+      #   # good
+      #   "Just some text"
+      #   "No special chars or interpolation"
+      #   "Every string in #{project} uses double_quotes"
+      class StringLiterals < Cop
+        include ConfigurableEnforcedStyle
+        include StringLiteralsHelp
+
+        MSG_INCONSISTENT = 'Inconsistent quote style.'
+
+        def on_dstr(node)
+          # Strings which are continued across multiple lines using \
+          # are parsed as a `dstr` node with `str` children
+          # If one part of that continued string contains interpolations,
+          # then it will be parsed as a nested `dstr` node
+          return unless consistent_multiline?
+          return if node.heredoc?
+
+          children = node.children
+          return unless all_string_literals?(children)
+
+          quote_styles = detect_quote_styles(node)
+
+          if quote_styles.size > 1
+            add_offense(node, message: MSG_INCONSISTENT)
+          else
+            check_multiline_quote_style(node, quote_styles[0])
+          end
+
+          ignore_node(node)
+        end
+
+        def autocorrect(node)
+          StringLiteralCorrector.correct(node, style)
+        end
+
+        private
+
+        def all_string_literals?(nodes)
+          nodes.all? { |n| n.str_type? || n.dstr_type? }
+        end
+
+        def detect_quote_styles(node)
+          styles = node.children.map { |c| c.loc.begin }
+
+          # For multi-line strings that only have quote marks
+          # at the beginning of the first line and the end of
+          # the last, the begin and end region of each child
+          # is nil. The quote marks are in the parent node.
+          return [node.loc.begin.source] if styles.all?(&:nil?)
+
+          styles.map(&:source).uniq
+        end
+
+        def message(_node)
+          if style == :single_quotes
+            "Prefer single-quoted strings when you don't need string " \
+            'interpolation or special symbols.'
+          else
+            'Prefer double-quoted strings unless you need single quotes to ' \
+            'avoid extra backslashes for escaping.'
+          end
+        end
+
+        def offense?(node)
+          # If it's a string within an interpolation, then it's not an offense
+          # for this cop.
+          return false if inside_interpolation?(node)
+
+          wrong_quotes?(node)
+        end
+
+        def consistent_multiline?
+          cop_config['ConsistentQuotesInMultiline']
+        end
+
+        def check_multiline_quote_style(node, quote)
+          range = node.source_range
+          children = node.children
+          if unexpected_single_quotes?(quote)
+            all_children_with_quotes = children.all? { |c| wrong_quotes?(c) }
+            add_offense(node, location: range) if all_children_with_quotes
+          elsif unexpected_double_quotes?(quote) &&
+                !accept_child_double_quotes?(children)
+            add_offense(node, location: range)
+          end
+        end
+
+        def unexpected_single_quotes?(quote)
+          quote == "'" && style == :double_quotes
+        end
+
+        def unexpected_double_quotes?(quote)
+          quote == '"' && style == :single_quotes
+        end
+
+        def accept_child_double_quotes?(nodes)
+          nodes.any? do |n|
+            n.dstr_type? || double_quotes_required?(n.source)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/string_literals_in_interpolation.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks that quotes inside the string interpolation
+      # match the configured preference.
+      #
+      # @example EnforcedStyle: single_quotes (default)
+      #   # bad
+      #   result = "Tests #{success ? "PASS" : "FAIL"}"
+      #
+      #   # good
+      #   result = "Tests #{success ? 'PASS' : 'FAIL'}"
+      #
+      # @example EnforcedStyle: double_quotes
+      #   # bad
+      #   result = "Tests #{success ? 'PASS' : 'FAIL'}"
+      #
+      #   # good
+      #   result = "Tests #{success ? "PASS" : "FAIL"}"
+      class StringLiteralsInInterpolation < Cop
+        include ConfigurableEnforcedStyle
+        include StringLiteralsHelp
+
+        def autocorrect(node)
+          StringLiteralCorrector.correct(node, style)
+        end
+
+        private
+
+        def message(_node)
+          # single_quotes -> single-quoted
+          kind = style.to_s.sub(/_(.*)s/, '-\1d')
+
+          "Prefer #{kind} strings inside interpolations."
+        end
+
+        def offense?(node)
+          # If it's not a string within an interpolation, then it's not an
+          # offense for this cop.
+          return false unless inside_interpolation?(node)
+
+          wrong_quotes?(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/string_methods.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of consistent method names
+      # from the String class.
+      #
+      # @example
+      #   # bad
+      #   'name'.intern
+      #   'var'.unfavored_method
+      #
+      #   # good
+      #   'name'.to_sym
+      #   'var'.preferred_method
+      class StringMethods < Cop
+        include MethodPreference
+
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
+
+        def on_send(node)
+          return unless preferred_method(node.method_name)
+
+          add_offense(node, location: :selector)
+        end
+        alias on_csend on_send
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.selector,
+                              preferred_method(node.method_name))
+          end
+        end
+
+        private
+
+        def message(node)
+          format(MSG,
+                 prefer: preferred_method(node.method_name),
+                 current: node.method_name)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/strip.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop identifies places where `lstrip.rstrip` can be replaced by
+      # `strip`.
+      #
+      # @example
+      #   # bad
+      #   'abc'.lstrip.rstrip
+      #   'abc'.rstrip.lstrip
+      #
+      #   # good
+      #   'abc'.strip
+      class Strip < Cop
+        include RangeHelp
+
+        MSG = 'Use `strip` instead of `%<methods>s`.'
+
+        def_node_matcher :lstrip_rstrip, <<~PATTERN
+          {(send $(send _ $:rstrip) $:lstrip)
+           (send $(send _ $:lstrip) $:rstrip)}
+        PATTERN
+
+        def on_send(node)
+          lstrip_rstrip(node) do |first_send, method_one, method_two|
+            range = range_between(first_send.loc.selector.begin_pos,
+                                  node.source_range.end_pos)
+            add_offense(node,
+                        location: range,
+                        message: format(MSG,
+                                        methods: "#{method_one}.#{method_two}"))
+          end
+        end
+
+        def autocorrect(node)
+          range = range_between(node.receiver.loc.selector.begin_pos,
+                                node.source_range.end_pos)
+
+          ->(corrector) { corrector.replace(range, 'strip') }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/struct_inheritance.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for inheritance from Struct.new.
+      #
+      # @example
+      #   # bad
+      #   class Person < Struct.new(:first_name, :last_name)
+      #     def age
+      #       42
+      #     end
+      #   end
+      #
+      #   # good
+      #   Person = Struct.new(:first_name, :last_name) do
+      #     def age
+      #       42
+      #     end
+      #   end
+      class StructInheritance < Cop
+        include RangeHelp
+
+        MSG = "Don't extend an instance initialized by `Struct.new`. " \
+              'Use a block to customize the struct.'
+
+        def on_class(node)
+          return unless struct_constructor?(node.parent_class)
+
+          add_offense(node, location: node.parent_class.source_range)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(range_with_surrounding_space(range: node.loc.keyword))
+            corrector.replace(node.loc.operator, '=')
+
+            correct_parent(node.parent_class, corrector)
+          end
+        end
+
+        def_node_matcher :struct_constructor?, <<~PATTERN
+          {(send (const {nil? cbase} :Struct) :new ...)
+           (block (send (const {nil? cbase} :Struct) :new ...) ...)}
+        PATTERN
+
+        private
+
+        def correct_parent(parent, corrector)
+          if parent.block_type?
+            corrector.remove(range_with_surrounding_space(range: parent.loc.end, newlines: false))
+          else
+            corrector.insert_after(parent.loc.expression, ' do')
+          end
+        end
+      end
+    end
+  end
+end