rubbycop 0.49.0

data/lib/rubbycop/cop/lint/loop.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for uses of *begin...end while/until something*.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # using while
+      #   begin
+      #     do_something
+      #   end while some_condition
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # using until
+      #   begin
+      #     do_something
+      #   end until some_condition
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   # using while
+      #   while some_condition
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   # using until
+      #   until some_condition
+      #     do_something
+      #   end
+      class Loop < Cop
+        MSG = 'Use `Kernel#loop` with `break` rather than ' \
+              '`begin/end/until`(or `while`).'.freeze
+
+        def on_while_post(node)
+          register_offense(node)
+        end
+
+        def on_until_post(node)
+          register_offense(node)
+        end
+
+        private
+
+        def register_offense(node)
+          add_offense(node, :keyword)
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/multiple_compare.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # In math and Python, we can use `x < y < z` style comparison to compare
+      # multiple value. However, we can't use the comparison in Ruby. However,
+      # the comparison is not syntax error. This cop checks the bad usage of
+      # comparison operators.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   x < y < z
+      #   10 <= x <= 20
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   x < y && y < z
+      #   10 <= x && x <= 20
+      class MultipleCompare < Cop
+        MSG = 'Use the `&&` operator to compare multiple values.'.freeze
+
+        def_node_matcher :multiple_compare?, <<-PATTERN
+          (send (send _ {:< :> :<= :>=} $_) {:< :> :<= :>=} _)
+        PATTERN
+
+        def on_send(node)
+          return unless multiple_compare?(node)
+
+          add_offense(node, :expression)
+        end
+
+        def autocorrect(node)
+          center = multiple_compare?(node)
+          new_center = "#{center.source} && #{center.source}"
+
+          lambda do |corrector|
+            corrector.replace(center.source_range, new_center)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/nested_method_definition.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for nested method definitions.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   # `bar` definition actually produces methods in the same scope
+      #   # as the outer `foo` method. Furthermore, the `bar` method
+      #   # will be redefined every time `foo` is invoked.
+      #   def foo
+      #     def bar
+      #     end
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def foo
+      #     bar = -> { puts 'hello' }
+      #     bar.call
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def foo
+      #     self.class_eval do
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
+      #   def foo
+      #     self.module_exec do
+      #       def bar
+      #       end
+      #     end
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def foo
+      #     class << self
+      #       def bar
+      #       end
+      #     end
+      #   end
+      class NestedMethodDefinition < Cop
+        include OnMethodDef
+        extend RubbyCop::NodePattern::Macros
+
+        MSG = 'Method definitions must not be nested. ' \
+              'Use `lambda` instead.'.freeze
+
+        def on_method_def(node, _method_name, _args, _body)
+          find_nested_defs(node) do |nested_def_node|
+            add_offense(nested_def_node, :expression)
+          end
+        end
+
+        def find_nested_defs(node, &block)
+          node.each_child_node do |child|
+            if child.def_type?
+              yield child
+            elsif child.defs_type?
+              subject, = *child
+              next if subject.lvar_type?
+              yield child
+            elsif !scoping_method_call?(child)
+              find_nested_defs(child, &block)
+            end
+          end
+        end
+
+        private
+
+        def scoping_method_call?(child)
+          eval_call?(child) || exec_call?(child) || child.sclass_type? ||
+            class_or_module_or_struct_new_call?(child)
+        end
+
+        def_node_matcher :eval_call?, <<-PATTERN
+          (block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
+        PATTERN
+
+        def_node_matcher :exec_call?, <<-PATTERN
+          (block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
+        PATTERN
+
+        def_node_matcher :class_or_module_or_struct_new_call?, <<-PATTERN
+          (block (send (const nil {:Class :Module :Struct}) :new ...) ...)
+        PATTERN
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/next_without_accumulator.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # Don't omit the accumulator when calling `next` in a `reduce` block.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   result = (1..4).reduce(0) do |acc, i|
+      #     next if i.odd?
+      #     acc + i
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   result = (1..4).reduce(0) do |acc, i|
+      #     next acc if i.odd?
+      #     acc + i
+      #   end
+      class NextWithoutAccumulator < Cop
+        MSG = 'Use `next` with an accumulator argument in a `reduce`.'.freeze
+
+        def_node_matcher :on_body_of_reduce, <<-PATTERN
+          (block (send _recv {:reduce :inject} !sym) _blockargs $(begin ...))
+        PATTERN
+
+        def on_block(node)
+          on_body_of_reduce(node) do |body|
+            void_next = body.each_node(:next).find do |n|
+              n.children.empty? && parent_block_node(n) == node
+            end
+
+            add_offense(void_next, :expression) if void_next
+          end
+        end
+
+        private
+
+        def parent_block_node(node)
+          node.each_ancestor(:block).first
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/non_local_exit_from_iterator.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for non-local exits from iterators without a return
+      # value. It registers an offense under these conditions:
+      #
+      #  - No value is returned,
+      #  - the block is preceded by a method chain,
+      #  - the block has arguments,
+      #  - the method which receives the block is not `define_method`
+      #    or `define_singleton_method`,
+      #  - the return is not contained in an inner scope, e.g. a lambda or a
+      #    method definition.
+      #
+      # @example
+      #
+      #   class ItemApi
+      #     rescue_from ValidationError do |e| # non-iteration block with arg
+      #       return message: 'validation error' unless e.errors # allowed
+      #       error_array = e.errors.map do |error| # block with method chain
+      #         return if error.suppress? # warned
+      #         return "#{error.param}: invalid" unless error.message # allowed
+      #         "#{error.param}: #{error.message}"
+      #       end
+      #       message: 'validation error', errors: error_array
+      #     end
+      #
+      #     def update_items
+      #       transaction do # block without arguments
+      #         return unless update_necessary? # allowed
+      #         find_each do |item| # block without method chain
+      #           return if item.stock == 0 # false-negative...
+      #           item.update!(foobar: true)
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      class NonLocalExitFromIterator < Cop
+        MSG = 'Non-local exit from iterator, without return value. ' \
+              '`next`, `break`, `Array#find`, `Array#any?`, etc. ' \
+              'is preferred.'.freeze
+
+        def on_return(return_node)
+          return if return_value?(return_node)
+
+          return_node.each_ancestor(:block, :def, :defs) do |node|
+            break if scoped_node?(node)
+
+            send_node, args_node, _body_node = *node
+
+            # if a proc is passed to `Module#define_method` or
+            # `Object#define_singleton_method`, `return` will not cause a
+            # non-local exit error
+            break if define_method?(send_node)
+
+            next if args_node.children.empty?
+
+            if chained_send?(send_node)
+              add_offense(return_node, :keyword)
+              break
+            end
+          end
+        end
+
+        private
+
+        def scoped_node?(node)
+          node.def_type? || node.defs_type? || node.lambda?
+        end
+
+        def return_value?(return_node)
+          !return_node.children.empty?
+        end
+
+        def_node_matcher :chained_send?, '(send !nil ...)'
+        def_node_matcher :define_method?, <<-PATTERN
+          (send _ {:define_method :define_singleton_method} _)
+        PATTERN
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/parentheses_as_grouped_expression.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # Checks for space between a the name of a called method and a left
+      # parenthesis.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   puts (x + y)
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   puts(x + y)
+      class ParenthesesAsGroupedExpression < Cop
+        MSG = '`(...)` interpreted as grouped expression.'.freeze
+
+        def on_send(node)
+          return unless node.arguments.one?
+          return if node.operator_method? || node.setter_method?
+
+          return unless node.first_argument.source.start_with?('(')
+
+          space_length = spaces_before_left_parenthesis(node)
+          return unless space_length > 0
+
+          add_offense(nil, space_range(node.first_argument.source_range,
+                                       space_length))
+        end
+
+        private
+
+        def spaces_before_left_parenthesis(node)
+          receiver = node.receiver
+          receiver_length = if receiver
+                              receiver.source.length
+                            else
+                              0
+                            end
+          without_receiver = node.source[receiver_length..-1]
+
+          # Escape question mark if any.
+          method_regexp = Regexp.escape(node.method_name)
+
+          match = without_receiver.match(/^\s*\.?\s*#{method_regexp}(\s+)\(/)
+          match ? match.captures[0].length : 0
+        end
+
+        def space_range(expr, space_length)
+          range_between(expr.begin_pos - space_length, expr.begin_pos)
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/lint/percent_string_array.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for quotes and commas in %w, e.g. `%w('foo', "bar")`
+      #
+      # It is more likely that the additional characters are unintended (for
+      # example, mistranslating an array of literals to percent string notation)
+      # rather than meant to be part of the resulting strings.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   %w('foo', "bar")
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   %w(foo bar)
+      class PercentStringArray < Cop
+        include PercentLiteral
+
+        QUOTES_AND_COMMAS = [/,$/, /^'.*'$/, /^".*"$/].freeze
+        LEADING_QUOTE = /^['"]/
+        TRAILING_QUOTE = /['"]?,?$/
+
+        MSG = "Within `%w`/`%W`, quotes and ',' are unnecessary and may be " \
+          'unwanted in the resulting strings.'.freeze
+
+        def on_array(node)
+          process(node, '%w', '%W')
+        end
+
+        def on_percent_literal(node)
+          return unless contains_quotes_or_commas?(node)
+
+          add_offense(node, :expression, MSG)
+        end
+
+        private
+
+        def contains_quotes_or_commas?(node)
+          node.values.any? do |value|
+            literal = scrub_string(value.children.first.to_s)
+
+            # To avoid likely false positives (e.g. a single ' or ")
+            next if literal.gsub(/[^\p{Alnum}]/, '').empty?
+
+            QUOTES_AND_COMMAS.any? { |pat| literal =~ pat }
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            node.values.each do |value|
+              range = value.loc.expression
+
+              match = range.source.match(TRAILING_QUOTE)
+              corrector.remove_trailing(range, match[0].length) if match
+
+              if range.source =~ LEADING_QUOTE
+                corrector.remove_leading(range, 1)
+              end
+            end
+          end
+        end
+
+        def scrub_string(string)
+          if string.respond_to?(:scrub)
+            string.scrub
+          else
+            string
+              .encode('UTF-16BE', 'UTF-8',
+                      invalid: :replace, undef: :replace, replace: '?')
+              .encode('UTF-8')
+          end
+        end
+      end
+    end
+  end
+end