rubbycop 0.49.0

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for END blocks in method definitions.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     END { do_something }
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     at_exit { do_something }
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   # outside defs
+      #   END { do_something }
+      class EndInMethod < Cop
+        MSG = '`END` found in method definition. Use `at_exit` instead.'.freeze
+
+        def on_postexe(node)
+          inside_of_method = node.each_ancestor(:def, :defs).count.nonzero?
+          add_offense(node, :keyword) if inside_of_method
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for *return* from an *ensure* block.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   begin
+      #     do_something
+      #   ensure
+      #     do_something_else
+      #     return
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     do_something
+      #   ensure
+      #     do_something_else
+      #   end
+      class EnsureReturn < Cop
+        MSG = 'Do not return from an `ensure` block.'.freeze
+
+        def on_ensure(node)
+          ensure_body = node.body
+
+          return unless ensure_body
+
+          ensure_body.each_node(:return) do |return_node|
+            add_offense(return_node, :expression)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop identifies Float literals which are, like, really really really
+      # really really really really really big. Too big. No-one needs Floats
+      # that big. If you need a float that big, something is wrong with you.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   float = 3.0e400
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   float = 42.9
+      class FloatOutOfRange < Cop
+        MSG = 'Float out of range.'.freeze
+
+        def on_float(node)
+          value, = *node
+          if value.infinite?
+            add_offense(node, :expression, MSG)
+          elsif value.zero? && node.source =~ /[1-9]/
+            add_offense(node, :expression, MSG)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This lint sees if there is a mismatch between the number of
+      # expected fields for format/sprintf/#% and what is actually
+      # passed as arguments.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   format('A value: %s and another: %i', a_value)
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   format('A value: %s and another: %i', a_value, another)
+      class FormatParameterMismatch < Cop
+        # http://rubular.com/r/CvpbxkcTzy
+        MSG = "Number of arguments (%i) to `%s` doesn't match the number of " \
+              'fields (%i).'.freeze
+        FIELD_REGEX =
+          /(%(([\s#+-0\*]*)(\d*)?(.\d+)?[bBdiouxXeEfgGaAcps]|%))/
+        NAMED_FIELD_REGEX = /%\{[_a-zA-Z][_a-zA-Z]+\}/
+        KERNEL = 'Kernel'.freeze
+        SHOVEL = '<<'.freeze
+        PERCENT = '%'.freeze
+        PERCENT_PERCENT = '%%'.freeze
+        STRING_TYPES = %i[str dstr].freeze
+        NAMED_INTERPOLATION = /%(?:<\w+>|\{\w+\})/
+
+        def on_send(node)
+          return unless offending_node?(node)
+
+          add_offense(node, :selector)
+        end
+
+        private
+
+        def offending_node?(node)
+          return false unless called_on_string?(node)
+          return false unless method_with_format_args?(node)
+          return false if named_mode?(node) || splat_args?(node)
+
+          num_of_format_args, num_of_expected_fields = count_matches(node)
+
+          return false if num_of_format_args == :unknown
+          matched_arguments_count?(num_of_expected_fields, num_of_format_args)
+        end
+
+        def matched_arguments_count?(expected, passed)
+          if passed < 0
+            expected < passed.abs
+          else
+            expected != passed
+          end
+        end
+
+        def called_on_string?(node)
+          receiver_node, _method, format_string, = *node
+          if receiver_node.nil? || receiver_node.const_type?
+            format_string && format_string.str_type?
+          else
+            receiver_node.str_type?
+          end
+        end
+
+        def method_with_format_args?(node)
+          sprintf?(node) || format?(node) || percent?(node)
+        end
+
+        def named_mode?(node)
+          receiver_node, _method_name, *args = *node
+
+          relevant_node = if sprintf?(node) || format?(node)
+                            args.first
+                          elsif percent?(node)
+                            receiver_node
+                          end
+
+          !relevant_node.source.scan(NAMED_FIELD_REGEX).empty?
+        end
+
+        def splat_args?(node)
+          return false if percent?(node)
+
+          node.arguments.butfirst.any?(&:splat_type?)
+        end
+
+        def heredoc?(node)
+          node.first_argument.source[0, 2] == SHOVEL
+        end
+
+        def count_matches(node)
+          receiver_node, _method_name, *args = *node
+
+          if (sprintf?(node) || format?(node)) && !heredoc?(node)
+            number_of_args_for_format = arguments_count(args) - 1
+            number_of_expected_fields = expected_fields_count(args.first)
+          elsif percent?(node) && args.first.array_type?
+            number_of_expected_fields = expected_fields_count(receiver_node)
+            number_of_args_for_format = arguments_count(args.first.child_nodes)
+          else
+            number_of_args_for_format = number_of_expected_fields = :unknown
+          end
+
+          [number_of_args_for_format, number_of_expected_fields]
+        end
+
+        def format_method?(name, node)
+          receiver, method_name, *args = *node
+
+          if receiver && receiver.const_type?
+            return false unless receiver.loc.name.is?(KERNEL)
+          end
+
+          return false unless method_name == name
+
+          args.size > 1 && args.first.str_type?
+        end
+
+        def expected_fields_count(node)
+          return :unknown unless node.str_type?
+          return 1 if node.source =~ NAMED_INTERPOLATION
+
+          node
+            .source
+            .scan(FIELD_REGEX)
+            .reject { |x| x.first == PERCENT_PERCENT }
+            .reduce(0) { |acc, elem| acc + (elem[2] =~ /\*/ ? 2 : 1) }
+        end
+
+        def arguments_count(args)
+          if args.empty?
+            0
+          elsif args.last.type == :splat
+            -(args.count - 1)
+          else
+            args.count
+          end
+        end
+
+        def format?(node)
+          format_method?(:format, node)
+        end
+
+        def sprintf?(node)
+          format_method?(:sprintf, node)
+        end
+
+        def percent?(node)
+          receiver = node.receiver
+
+          percent = node.method_name == :% &&
+                    (STRING_TYPES.include?(receiver.type) ||
+                     node.first_argument.array_type?)
+
+          if percent && STRING_TYPES.include?(receiver.type)
+            return false if heredoc?(node)
+          end
+
+          percent
+        end
+
+        def message(node)
+          num_args_for_format, num_expected_fields = count_matches(node)
+
+          method_name = if node.method_name.to_s == PERCENT
+                          'String#%'
+                        else
+                          node.method_name
+                        end
+
+          format(MSG, num_args_for_format, method_name, num_expected_fields)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for *rescue* blocks with no body.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   begin
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     handle_exception
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     do_something
+      #   rescue
+      #     handle_exception
+      #   end
+      class HandleExceptions < Cop
+        MSG = 'Do not suppress exceptions.'.freeze
+
+        def on_resbody(node)
+          add_offense(node, :expression) unless node.body
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Lint
+      # This cop checks for implicit string concatenation of string literals
+      # which are on the same line.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   array = ['Item 1' 'Item 2']
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   array = ['Item 1Item 2']
+      #   array = ['Item 1' + 'Item 2']
+      #   array = [
+      #     'Item 1' \
+      #     'Item 2'
+      #   ]
+      class ImplicitStringConcatenation < Cop
+        MSG = 'Combine %s and %s into a single string literal, rather than ' \
+              'using implicit string concatenation.'.freeze
+        FOR_ARRAY = ' Or, if they were intended to be separate array ' \
+                    'elements, separate them with a comma.'.freeze
+        FOR_METHOD = ' Or, if they were intended to be separate method ' \
+                     'arguments, separate them with a comma.'.freeze
+
+        def on_dstr(node)
+          each_bad_cons(node) do |child1, child2|
+            range   = child1.source_range.join(child2.source_range)
+            message = format(MSG, display_str(child1), display_str(child2))
+            if node.parent && node.parent.array_type?
+              message << FOR_ARRAY
+            elsif node.parent && node.parent.send_type?
+              message << FOR_METHOD
+            end
+            add_offense(node, range, message)
+          end
+        end
+
+        private
+
+        def each_bad_cons(node)
+          node.children.each_cons(2) do |child1, child2|
+            # `'abc' 'def'` -> (dstr (str "abc") (str "def"))
+            next unless string_literal?(child1) && string_literal?(child2)
+            next unless child1.loc.last_line == child2.loc.line
+
+            # Make sure we don't flag a string literal which simply has
+            # embedded newlines
+            # `"abc\ndef"` also -> (dstr (str "abc") (str "def"))
+            next unless child1.source[-1] == ending_delimiter(child1)
+
+            yield child1, child2
+          end
+        end
+
+        def ending_delimiter(str)
+          # implicit string concatenation does not work with %{}, etc.
+          if str.source[0] == "'"
+            "'"
+          elsif str.source[0] == '"'
+            '"'
+          end
+        end
+
+        def string_literal?(node)
+          node.str_type? ||
+            (node.dstr_type? && node.children.all? { |c| string_literal?(c) })
+        end
+
+        def display_str(node)
+          if node.source =~ /\n/
+            str_content(node).inspect
+          else
+            node.source
+          end
+        end
+
+        def str_content(node)
+          if node.str_type?
+            node.children[0]
+          else
+            node.children.map { |c| str_content(c) }.join
+          end
+        end
+      end
+    end
+  end
+end