rubocop 0.75.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? :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.source_range, 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,39 @@
+# 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
+        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_node_matcher :struct_constructor?, <<~PATTERN
+          {(send (const nil? :Struct) :new ...)
+           (block (send (const nil? :Struct) :new ...) ...)}
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop can check for array literals made up of symbols that are not
+      # using the %i() syntax.
+      #
+      # Alternatively, it checks for symbol arrays using the %i() syntax on
+      # projects which do not want to use that syntax.
+      #
+      # Configuration option: MinSize
+      # If set, arrays with fewer elements than this value will not trigger the
+      # cop. For example, a `MinSize of `3` will not enforce a style on an array
+      # of 2 or fewer elements.
+      #
+      # @example EnforcedStyle: percent (default)
+      #   # good
+      #   %i[foo bar baz]
+      #
+      #   # bad
+      #   [:foo, :bar, :baz]
+      #
+      # @example EnforcedStyle: brackets
+      #   # good
+      #   [:foo, :bar, :baz]
+      #
+      #   # bad
+      #   %i[foo bar baz]
+      class SymbolArray < Cop
+        include ArrayMinSize
+        include ArraySyntax
+        include ConfigurableEnforcedStyle
+        include PercentArray
+
+        PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'
+        ARRAY_MSG = 'Use `[]` for an array of symbols.'
+
+        class << self
+          attr_accessor :largest_brackets
+        end
+
+        def on_array(node)
+          if bracketed_array_of?(:sym, node)
+            return if symbols_contain_spaces?(node)
+
+            check_bracketed_array(node)
+          elsif node.percent_literal?(:symbol)
+            check_percent_array(node)
+          end
+        end
+
+        def autocorrect(node)
+          if style == :percent
+            PercentLiteralCorrector
+              .new(@config, @preferred_delimiters)
+              .correct(node, 'i')
+          else
+            correct_bracketed(node)
+          end
+        end
+
+        private
+
+        def symbols_contain_spaces?(node)
+          node.children.any? do |sym|
+            content, = *sym
+            content =~ / /
+          end
+        end
+
+        def correct_bracketed(node)
+          syms = node.children.map do |c|
+            if c.dsym_type?
+              string_literal = to_string_literal(c.source)
+
+              ':' + trim_string_interporation_escape_character(string_literal)
+            else
+              to_symbol_literal(c.value.to_s)
+            end
+          end
+
+          lambda do |corrector|
+            corrector.replace(node.source_range, "[#{syms.join(', ')}]")
+          end
+        end
+
+        def to_symbol_literal(string)
+          if symbol_without_quote?(string)
+            ":#{string}"
+          else
+            ":#{to_string_literal(string)}"
+          end
+        end
+
+        def symbol_without_quote?(string)
+          special_gvars = %w[
+            $! $" $$ $& $' $* $+ $, $/ $; $: $. $< $= $> $? $@ $\\ $_ $` $~ $0
+            $-0 $-F $-I $-K $-W $-a $-d $-i $-l $-p $-v $-w
+          ]
+          redefinable_operators = %w(
+            | ^ & <=> == === =~ > >= < <= << >>
+            + - * / % ** ~ +@ -@ [] []= ` ! != !~
+          )
+
+          # method name
+          string =~ /\A[a-zA-Z_]\w*[!?]?\z/ ||
+            # instance / class variable
+            string =~ /\A\@\@?[a-zA-Z_]\w*\z/ ||
+            # global variable
+            string =~ /\A\$[1-9]\d*\z/ ||
+            string =~ /\A\$[a-zA-Z_]\w*\z/ ||
+            special_gvars.include?(string) ||
+            redefinable_operators.include?(string)
+        end
+      end
+    end
+  end
+end