rubbycop 0.49.0

data/lib/rubbycop/cop/style/stabby_lambda_parentheses.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # Check for parentheses around stabby lambda arguments.
+      # There are two different styles. Defaults to `require_parentheses`.
+      #
+      # @example
+      #   # require_parentheses - bad
+      #   ->a,b,c { a + b + c }
+      #
+      #   # require_parentheses - good
+      #   ->(a,b,c) { a + b + c}
+      #
+      #   # require_no_parentheses - bad
+      #   ->(a,b,c) { a + b + c }
+      #
+      #   # require_no_parentheses - good
+      #   ->a,b,c { a + b + c}
+      class StabbyLambdaParentheses < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG_REQUIRE = 'Wrap stabby lambda arguments with parentheses.'.freeze
+        MSG_NO_REQUIRE = 'Do not wrap stabby lambda arguments ' \
+                         'with parentheses.'.freeze
+        ARROW = '->'.freeze
+
+        def on_send(node)
+          return unless arrow_lambda_with_args?(node)
+
+          if style == :require_parentheses
+            if parentheses?(node)
+              correct_style_detected
+            else
+              missing_parentheses(node)
+            end
+          elsif parentheses?(node)
+            unwanted_parentheses(node)
+          else
+            correct_style_detected
+          end
+        end
+
+        def autocorrect(node)
+          if style == :require_parentheses
+            missing_parentheses_corrector(node)
+          elsif style == :require_no_parentheses
+            unwanted_parentheses_corrector(node)
+          end
+        end
+
+        private
+
+        def missing_parentheses(node)
+          add_offense(node_args(node), :expression, MSG_REQUIRE) do
+            opposite_style_detected
+          end
+        end
+
+        def unwanted_parentheses(node)
+          add_offense(node_args(node), :expression, MSG_NO_REQUIRE) do
+            opposite_style_detected
+          end
+        end
+
+        def missing_parentheses_corrector(node)
+          lambda do |corrector|
+            args_loc = node_args(node).source_range
+
+            corrector.insert_before(args_loc, '(')
+            corrector.insert_after(args_loc, ')')
+          end
+        end
+
+        def unwanted_parentheses_corrector(node)
+          lambda do |corrector|
+            args_loc = node_args(node).loc
+
+            corrector.replace(args_loc.begin, '')
+            corrector.remove(args_loc.end)
+          end
+        end
+
+        def arrow_lambda_with_args?(node)
+          lambda_node?(node) && arrow_form?(node) && args?(node)
+        end
+
+        def lambda_node?(node)
+          receiver, call = *node
+          !receiver && call == :lambda
+        end
+
+        def arrow_form?(node)
+          node.loc.selector.source == ARROW
+        end
+
+        def node_args(node)
+          _call, args, _body = *node.parent
+          args
+        end
+
+        def args?(node)
+          !node_args(node).children.empty?
+        end
+
+        def parentheses?(node)
+          node_args(node).loc.begin
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # Checks if uses of quotes match the configured preference.
+      class StringLiterals < Cop
+        include ConfigurableEnforcedStyle
+        include StringLiteralsHelp
+
+        MSG_INCONSISTENT = 'Inconsistent quote style.'.freeze
+
+        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.loc.is_a?(Parser::Source::Map::Heredoc)
+
+          children = node.children
+          return unless all_string_literals?(children)
+
+          quote_styles = detect_quote_styles(node)
+
+          if quote_styles.size > 1
+            add_offense(node, :expression, MSG_INCONSISTENT)
+          else
+            check_multiline_quote_style(node, quote_styles[0])
+          end
+
+          ignore_node(node)
+        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(*)
+          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)
+            add_offense(node, range) if children.all? { |c| wrong_quotes?(c) }
+          elsif unexpected_double_quotes?(quote) &&
+                !accept_child_double_quotes?(children)
+            add_offense(node, 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/rubbycop/cop/style/string_literals_in_interpolation.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # Checks if uses of quotes match the configured preference.
+      class StringLiteralsInInterpolation < Cop
+        include ConfigurableEnforcedStyle
+        include StringLiteralsHelp
+
+        private
+
+        def message(*)
+          # 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/rubbycop/cop/style/string_methods.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop enforces the use of consistent method names
+      # from the String class.
+      class StringMethods < Cop
+        include MethodPreference
+
+        MSG = 'Prefer `%s` over `%s`.'.freeze
+
+        def on_send(node)
+          return unless preferred_method(node.method_name)
+
+          add_offense(node, :selector)
+        end
+
+        private
+
+        def message(node)
+          format(MSG, preferred_method(node.method_name), node.method_name)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.selector,
+                              preferred_method(node.method_name))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for inheritance from Struct.new.
+      #
+      # @example
+      #   # bad
+      #   class Person < Struct.new(:first_name, :last_name)
+      #   end
+      #
+      #   # good
+      #   Person = Struct.new(:first_name, :last_name)
+      class StructInheritance < Cop
+        MSG = "Don't extend an instance initialized by `Struct.new`.".freeze
+
+        def on_class(node)
+          _name, superclass, _body = *node
+          return unless struct_constructor?(superclass)
+
+          add_offense(node, superclass.source_range, MSG)
+        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/rubbycop/cop/style/symbol_array.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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, perhaps because they
+      # support a version of Ruby lower than 2.0.
+      #
+      # 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 PercentLiteral
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.0
+
+        PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'.freeze
+        ARRAY_MSG = 'Use `[]` for an array of symbols.'.freeze
+
+        class << self
+          attr_accessor :largest_brackets
+        end
+
+        def on_array(node)
+          if bracketed_array_of?(:sym, node)
+            check_bracketed_array(node)
+          elsif node.percent_literal?(:symbol)
+            check_percent_array(node)
+          end
+        end
+
+        def autocorrect(node)
+          if style == :percent
+            correct_percent(node, 'i')
+          else
+            correct_bracketed(node)
+          end
+        end
+
+        private
+
+        def check_bracketed_array(node)
+          return if comments_in_array?(node) ||
+                    symbols_contain_spaces?(node) ||
+                    below_array_length?(node)
+
+          array_style_detected(:brackets, node.values.size)
+          add_offense(node, :expression, PERCENT_MSG) if style == :percent
+        end
+
+        def check_percent_array(node)
+          array_style_detected(:percent, node.values.size)
+          add_offense(node, :expression, ARRAY_MSG) if style == :brackets
+        end
+
+        def comments_in_array?(node)
+          comments = processed_source.comments
+          array_range = node.source_range.to_a
+
+          comments.any? do |comment|
+            !(comment.loc.expression.to_a & array_range).empty?
+          end
+        end
+
+        def symbols_contain_spaces?(node)
+          node.children.any? do |sym|
+            content, = *sym
+            content =~ / /
+          end
+        end
+
+        def correct_bracketed(node)
+          syms = node.children.map { |c| to_symbol_literal(c.children[0].to_s) }
+
+          lambda do |corrector|
+            corrector.replace(node.source_range, "[#{syms.join(', ')}]")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/symbol_literal.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks symbol literal syntax.
+      #
+      # @example
+      #
+      #   # bad
+      #   :"symbol"
+      #
+      #   # good
+      #   :symbol
+      class SymbolLiteral < Cop
+        MSG = 'Do not use strings for word-like symbol literals.'.freeze
+
+        def on_sym(node)
+          return unless node.source =~ /\A:["'][A-Za-z_]\w*["']\z/
+
+          add_offense(node, :expression)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, node.source.delete(%q('")))
+          end
+        end
+      end
+    end
+  end
+end