rubbycop 0.49.0

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for usage of the %q/%Q syntax when '' or "" would do.
+      class UnneededPercentQ < Cop
+        MSG = 'Use `%s` only for strings that contain both single quotes and ' \
+              'double quotes%s.'.freeze
+        DYNAMIC_MSG = ', or for dynamic strings that contain ' \
+                      'double quotes'.freeze
+        SINGLE_QUOTE = "'".freeze
+        QUOTE = '"'.freeze
+        EMPTY = ''.freeze
+        PERCENT_Q = '%q'.freeze
+        PERCENT_CAPITAL_Q = '%Q'.freeze
+        STRING_INTERPOLATION_REGEXP = /#\{.+}/
+        ESCAPED_NON_BACKSLASH = /\\[^\\]/
+
+        def on_dstr(node)
+          check(node)
+        end
+
+        def on_str(node)
+          # Interpolated strings that contain more than just interpolation
+          # will call `on_dstr` for the entire string and `on_str` for the
+          # non interpolated portion of the string
+          return unless string_literal?(node)
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          return unless start_with_percent_q_variant?(node)
+          return if interpolated_quotes?(node) || allowed_percent_q?(node)
+
+          add_offense(node, :expression)
+        end
+
+        def interpolated_quotes?(node)
+          node.source.include?(SINGLE_QUOTE) && node.source.include?(QUOTE)
+        end
+
+        def allowed_percent_q?(node)
+          node.source.start_with?(PERCENT_Q) && acceptable_q?(node) ||
+            node.source.start_with?(PERCENT_CAPITAL_Q) &&
+              acceptable_capital_q?(node)
+        end
+
+        def message(node)
+          src = node.source
+          extra = if src.start_with?(PERCENT_CAPITAL_Q)
+                    DYNAMIC_MSG
+                  else
+                    EMPTY
+                  end
+          format(MSG, src[0, 2], extra)
+        end
+
+        def autocorrect(node)
+          delimiter =
+            node.source =~ /^%Q[^"]+$|'/ ? QUOTE : SINGLE_QUOTE
+          lambda do |corrector|
+            corrector.replace(node.loc.begin, delimiter)
+            corrector.replace(node.loc.end, delimiter)
+          end
+        end
+
+        def string_literal?(node)
+          node.loc.respond_to?(:begin) && node.loc.respond_to?(:end) &&
+            node.loc.begin && node.loc.end
+        end
+
+        def start_with_percent_q_variant?(string)
+          string.source.start_with?(PERCENT_Q, PERCENT_CAPITAL_Q)
+        end
+
+        def acceptable_q?(node)
+          src = node.source
+
+          return true if src =~ STRING_INTERPOLATION_REGEXP
+
+          src.scan(/\\./).any? { |s| s =~ ESCAPED_NON_BACKSLASH }
+        end
+
+        def acceptable_capital_q?(node)
+          src = node.source
+          src.include?(QUOTE) &&
+            (src =~ STRING_INTERPOLATION_REGEXP ||
+            (node.str_type? && double_quotes_required?(src)))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for variable interpolation (like "#@ivar").
+      class VariableInterpolation < Cop
+        MSG = 'Replace interpolated variable `%s` ' \
+              'with expression `#{%s}`.'.freeze
+
+        def on_dstr(node)
+          check_for_interpolation(node)
+        end
+
+        def on_regexp(node)
+          check_for_interpolation(node)
+        end
+
+        def on_xstr(node)
+          check_for_interpolation(node)
+        end
+
+        private
+
+        def check_for_interpolation(node)
+          var_nodes(node.children).each do |v|
+            var = v.source
+            add_offense(v, :expression, format(MSG, var, var))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, "{#{node.source}}")
+          end
+        end
+
+        def var_nodes(nodes)
+          nodes.select { |n| n.variable? || n.reference? }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop makes sure that all variables use the configured style,
+      # snake_case or camelCase, for their names.
+      class VariableName < Cop
+        include ConfigurableNaming
+
+        def on_lvasgn(node)
+          name, = *node
+          check_name(node, name, node.loc.name)
+        end
+
+        def on_ivasgn(node)
+          name, = *node
+          check_name(node, name, node.loc.name)
+        end
+
+        def on_cvasgn(node)
+          name, = *node
+          check_name(node, name, node.loc.name)
+        end
+
+        def on_arg(node)
+          name, = *node
+          check_name(node, name, node.loc.name)
+        end
+
+        private
+
+        def message(style)
+          format('Use %s for variable names.', style)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop makes sure that all numbered variables use the
+      # configured style, snake_case, normalcase or non_integer,
+      # for their numbering.
+      #
+      # @example
+      #   "EnforcedStyle => 'snake_case'"
+      #
+      #   # bad
+      #
+      #   variable1 = 1
+      #
+      #   # good
+      #
+      #   variable_1 = 1
+      #
+      # @example
+      #   "EnforcedStyle => 'normalcase'"
+      #
+      #   # bad
+      #
+      #   variable_1 = 1
+      #
+      #   # good
+      #
+      #   variable1 = 1
+      #
+      # @example
+      #   "EnforcedStyle => 'non_integer'"
+      #
+      #   #bad
+      #
+      #   variable1 = 1
+      #
+      #   variable_1 = 1
+      #
+      #   #good
+      #
+      #   variableone = 1
+      #
+      #   variable_one = 1
+      #
+      class VariableNumber < Cop
+        include ConfigurableNumbering
+
+        def on_lvasgn(node)
+          name, = *node
+          check_name(node, name, node.loc.name)
+        end
+
+        def on_ivasgn(node)
+          name, = *node
+          check_name(node, name, node.loc.name)
+        end
+
+        def on_cvasgn(node)
+          name, = *node
+          check_name(node, name, node.loc.name)
+        end
+
+        def on_arg(node)
+          name, = *node
+          check_name(node, name, node.loc.name)
+        end
+
+        private
+
+        def message(style)
+          format('Use %s for variable numbers.', style)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for *when;* uses in *case* expressions.
+      class WhenThen < Cop
+        MSG = 'Do not use `when x;`. Use `when x then` instead.'.freeze
+
+        def on_when(node)
+          return if node.multiline? || node.then? || !node.body
+
+          add_offense(node, :begin)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.begin, ' then')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # Checks for uses of `do` in multi-line `while/until` statements.
+      class WhileUntilDo < Cop
+        MSG = 'Do not use `do` with multi-line `%s`.'.freeze
+
+        def on_while(node)
+          handle(node)
+        end
+
+        def on_until(node)
+          handle(node)
+        end
+
+        def handle(node)
+          return unless node.multiline? && node.do?
+
+          add_offense(node, :begin, format(MSG, node.keyword))
+        end
+
+        private
+
+        def autocorrect(node)
+          do_range = node.condition.source_range.end.join(node.loc.begin)
+
+          lambda do |corrector|
+            corrector.remove(do_range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # Checks for while and until statements that would fit on one line
+      # if written as a modifier while/until.
+      # The maximum line length is configurable.
+      class WhileUntilModifier < Cop
+        include StatementModifier
+
+        MSG = 'Favor modifier `%s` usage when having a single-line body.'.freeze
+
+        def on_while(node)
+          check(node)
+        end
+
+        def on_until(node)
+          check(node)
+        end
+
+        private
+
+        def autocorrect(node)
+          oneline = "#{node.body.source} #{node.keyword} " \
+                    "#{node.condition.source}"
+
+          lambda do |corrector|
+            corrector.replace(node.source_range, oneline)
+          end
+        end
+
+        def check(node)
+          return unless node.multiline? && single_line_as_modifier?(node)
+
+          add_offense(node, :keyword, format(MSG, node.keyword))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop can check for array literals made up of word-like
+      # strings, that are not using the %w() syntax.
+      #
+      # Alternatively, it can check for uses of the %w() syntax, in projects
+      # which do not want to include 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
+      #   %w[foo bar baz]
+      #
+      #   # bad
+      #   ['foo', 'bar', 'baz']
+      #
+      # @example
+      #   EnforcedStyle: brackets
+      #
+      #   # good
+      #   ['foo', 'bar', 'baz']
+      #
+      #   # bad
+      #   %w[foo bar baz]
+      class WordArray < Cop
+        include ArrayMinSize
+        include ArraySyntax
+        include ConfigurableEnforcedStyle
+        include PercentLiteral
+
+        PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'.freeze
+        ARRAY_MSG = 'Use `[]` for an array of words.'.freeze
+        QUESTION_MARK_SIZE = '?'.size
+
+        class << self
+          attr_accessor :largest_brackets
+        end
+
+        def on_array(node)
+          if bracketed_array_of?(:str, node)
+            check_bracketed_array(node)
+          elsif node.percent_literal?(:string)
+            check_percent_array(node)
+          end
+        end
+
+        def autocorrect(node)
+          if style == :percent
+            correct_percent(node, 'w')
+          else
+            correct_bracketed(node)
+          end
+        end
+
+        private
+
+        def check_bracketed_array(node)
+          return if complex_content?(node.values) ||
+                    comments_in_array?(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 percent_syntax?(node)
+          node.loc.begin && node.loc.begin.source =~ /\A%[wW]/
+        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 complex_content?(strings)
+          strings.any? do |s|
+            string = s.str_content
+            !string.valid_encoding? || string !~ word_regex || string =~ / /
+          end
+        end
+
+        def word_regex
+          Regexp.new(cop_config['WordRegex'])
+        end
+
+        def correct_bracketed(node)
+          words = node.children.map { |w| to_string_literal(w.children[0]) }
+
+          lambda do |corrector|
+            corrector.replace(node.source_range, "[#{words.join(', ')}]")
+          end
+        end
+      end
+    end
+  end
+end