rubbycop 0.49.0

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for uses of Module#attr.
+      class Attr < Cop
+        MSG = 'Do not use `attr`. Use `%s` instead.'.freeze
+
+        def on_send(node)
+          return unless node.command?(:attr) && node.arguments?
+
+          add_offense(node, :selector)
+        end
+
+        private
+
+        def autocorrect(node)
+          attr_name, setter = *node.arguments
+
+          node_expr = node.source_range
+          attr_expr = attr_name.source_range
+
+          if setter && (setter.true_type? || setter.false_type?)
+            remove = range_between(attr_expr.end_pos, node_expr.end_pos)
+          end
+
+          lambda do |corrector|
+            corrector.replace(node.loc.selector, replacement_method(node))
+            corrector.remove(remove) if remove
+          end
+        end
+
+        def message(node)
+          format(MSG, replacement_method(node))
+        end
+
+        def replacement_method(node)
+          setter = node.last_argument
+
+          if setter && (setter.true_type? || setter.false_type?)
+            setter.true_type? ? 'attr_accessor' : 'attr_reader'
+          else
+            'attr_reader'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for cases when you could use a block
+      # accepting version of a method that does automatic
+      # resource cleanup.
+      #
+      # @example
+      #
+      #   # bad
+      #   f = File.open('file')
+      #
+      #   # good
+      #   f = File.open('file') do
+      #     ...
+      #   end
+      class AutoResourceCleanup < Cop
+        MSG = 'Use the block version of `%s.%s`.'.freeze
+
+        TARGET_METHODS = {
+          File: :open
+        }.freeze
+
+        def on_send(node)
+          TARGET_METHODS.each do |target_class, target_method|
+            target_receiver = s(:const, nil, target_class)
+
+            next if node.receiver != target_receiver
+            next if node.method_name != target_method
+            next if node.parent && node.parent.block_type?
+            next if node.block_argument?
+
+            add_offense(node, :expression,
+                        format(MSG, target_class, target_method))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks if usage of %() or %Q() matches configuration.
+      class BarePercentLiterals < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Use `%%%s` instead of `%%%s`.'.freeze
+
+        def on_dstr(node)
+          check(node)
+        end
+
+        def on_str(node)
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          return if node.loc.respond_to?(:heredoc_body)
+          return unless node.loc.respond_to?(:begin)
+          return unless node.loc.begin
+
+          source = node.loc.begin.source
+          if requires_percent_q?(source)
+            add_offense_for_wrong_style(node, 'Q', '')
+          elsif requires_bare_percent?(source)
+            add_offense_for_wrong_style(node, '', 'Q')
+          end
+        end
+
+        def requires_percent_q?(source)
+          style == :percent_q && source =~ /^%[^\w]/
+        end
+
+        def requires_bare_percent?(source)
+          style == :bare_percent && source =~ /^%Q/
+        end
+
+        def add_offense_for_wrong_style(node, good, bad)
+          add_offense(node, :begin, format(MSG, good, bad))
+        end
+
+        def autocorrect(node)
+          src = node.loc.begin.source
+          replacement = src.start_with?('%Q') ? '%' : '%Q'
+          lambda do |corrector|
+            corrector.replace(node.loc.begin, src.sub(/%Q?/, replacement))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for BEGIN blocks.
+      class BeginBlock < Cop
+        MSG = 'Avoid the use of `BEGIN` blocks.'.freeze
+
+        def on_preexe(node)
+          add_offense(node, :keyword)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop looks for uses of block comments (=begin...=end).
+      class BlockComments < Cop
+        MSG = 'Do not use block comments.'.freeze
+        BEGIN_LENGTH = "=begin\n".length
+        END_LENGTH = "\n=end".length
+
+        def investigate(processed_source)
+          processed_source.comments.each do |comment|
+            add_offense(comment, :expression) if comment.document?
+          end
+        end
+
+        private
+
+        def autocorrect(comment)
+          eq_begin, eq_end, contents = parts(comment)
+
+          lambda do |corrector|
+            corrector.remove(eq_begin)
+            unless contents.length.zero?
+              corrector.replace(contents,
+                                contents.source
+                                  .gsub(/\A/, '# ')
+                                  .gsub(/\n\n/, "\n#\n")
+                                  .gsub(/\n(?=[^#])/, "\n# "))
+            end
+            corrector.remove(eq_end)
+          end
+        end
+
+        def parts(comment)
+          expr = comment.loc.expression
+          eq_begin = expr.resize(BEGIN_LENGTH)
+          eq_end = range_between(expr.end_pos - END_LENGTH, expr.end_pos)
+          contents = range_between(eq_begin.end_pos, eq_end.begin_pos)
+          [eq_begin, eq_end, contents]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # Check for uses of braces or do/end around single line or
+      # multi-line blocks.
+      class BlockDelimiters < Cop
+        include ConfigurableEnforcedStyle
+
+        def on_send(node)
+          return unless node.arguments?
+          return if node.parenthesized? || node.operator_method?
+
+          node.arguments.each do |arg|
+            get_blocks(arg) do |block|
+              # If there are no parentheses around the arguments, then braces
+              # and do-end have different meaning due to how they bind, so we
+              # allow either.
+              ignore_node(block)
+            end
+          end
+        end
+
+        def on_block(node)
+          return if ignored_node?(node)
+
+          add_offense(node, :begin) unless proper_block_style?(node)
+        end
+
+        private
+
+        def line_count_based_message(node)
+          if block_length(node) > 0
+            'Avoid using `{...}` for multi-line blocks.'
+          else
+            'Prefer `{...}` over `do...end` for single-line blocks.'
+          end
+        end
+
+        def semantic_message(node)
+          block_begin = node.loc.begin.source
+
+          if block_begin == '{'
+            'Prefer `do...end` over `{...}` for procedural blocks.'
+          else
+            'Prefer `{...}` over `do...end` for functional blocks.'
+          end
+        end
+
+        def braces_for_chaining_message(node)
+          if block_length(node) > 0
+            if return_value_chaining?(node)
+              'Prefer `{...}` over `do...end` for multi-line chained blocks.'
+            else
+              'Prefer `do...end` for multi-line blocks without chaining.'
+            end
+          else
+            'Prefer `{...}` over `do...end` for single-line blocks.'
+          end
+        end
+
+        def message(node)
+          case style
+          when :line_count_based    then line_count_based_message(node)
+          when :semantic            then semantic_message(node)
+          when :braces_for_chaining then braces_for_chaining_message(node)
+          end
+        end
+
+        def autocorrect(node)
+          return if correction_would_break_code?(node)
+
+          if node.loc.begin.is?('{')
+            replace_braces_with_do_end(node.loc)
+          else
+            replace_do_end_with_braces(node.loc)
+          end
+        end
+
+        def replace_braces_with_do_end(loc)
+          b = loc.begin
+          e = loc.end
+
+          lambda do |corrector|
+            corrector.insert_before(b, ' ') unless whitespace_before?(b)
+            corrector.insert_before(e, ' ') unless whitespace_before?(e)
+            corrector.insert_after(b, ' ') unless whitespace_after?(b)
+            corrector.replace(b, 'do')
+            corrector.replace(e, 'end')
+          end
+        end
+
+        def replace_do_end_with_braces(loc)
+          b = loc.begin
+          e = loc.end
+
+          lambda do |corrector|
+            corrector.insert_after(b, ' ') unless whitespace_after?(b, 2)
+            corrector.replace(b, '{')
+            corrector.replace(e, '}')
+          end
+        end
+
+        def whitespace_before?(node)
+          node.source_buffer.source[node.begin_pos - 1, 1] =~ /\s/
+        end
+
+        def whitespace_after?(node, length = 1)
+          node.source_buffer.source[node.begin_pos + length, 1] =~ /\s/
+        end
+
+        def get_blocks(node, &block)
+          case node.type
+          when :block
+            yield node
+          when :send
+            get_blocks(node.receiver, &block) if node.receiver
+          when :hash
+            # A hash which is passed as method argument may have no braces
+            # In that case, one of the K/V pairs could contain a block node
+            # which could change in meaning if do...end replaced {...}
+            return if node.loc.begin
+            node.each_child_node { |child| get_blocks(child, &block) }
+          when :pair
+            node.each_child_node { |child| get_blocks(child, &block) }
+          end
+          nil
+        end
+
+        def proper_block_style?(node)
+          return true if ignored_method?(node.method_name)
+
+          case style
+          when :line_count_based    then line_count_based_block_style?(node)
+          when :semantic            then semantic_block_style?(node)
+          when :braces_for_chaining then braces_for_chaining_style?(node)
+          end
+        end
+
+        def line_count_based_block_style?(node)
+          block_begin = node.loc.begin.source
+
+          (block_length(node) > 0) ^ (block_begin == '{')
+        end
+
+        def semantic_block_style?(node)
+          method_name = node.method_name
+          block_begin = node.loc.begin.source
+
+          if block_begin == '{'
+            functional_method?(method_name) || functional_block?(node)
+          else
+            procedural_method?(method_name) || !return_value_used?(node)
+          end
+        end
+
+        def braces_for_chaining_style?(node)
+          block_length = block_length(node)
+          block_begin = node.loc.begin.source
+
+          block_begin == if block_length > 0
+                           (return_value_chaining?(node) ? '{' : 'do')
+                         else
+                           '{'
+                         end
+        end
+
+        def return_value_chaining?(node)
+          node.parent && node.parent.send_type? && node.parent.dot?
+        end
+
+        def correction_would_break_code?(node)
+          return unless node.loc.begin.is?('do')
+
+          # Converting `obj.method arg do |x| end` to use `{}` would cause
+          # a syntax error.
+          send = node.children.first
+
+          send.arguments? && !send.parenthesized?
+        end
+
+        def ignored_method?(method_name)
+          cop_config['IgnoredMethods'].map(&:to_sym).include?(method_name)
+        end
+
+        def functional_method?(method_name)
+          cop_config['FunctionalMethods'].map(&:to_sym).include?(method_name)
+        end
+
+        def functional_block?(node)
+          return_value_used?(node) || return_value_of_scope?(node)
+        end
+
+        def procedural_method?(method_name)
+          cop_config['ProceduralMethods'].map(&:to_sym).include?(method_name)
+        end
+
+        def return_value_used?(node)
+          return unless node.parent
+
+          # If there are parentheses around the block, check if that
+          # is being used.
+          if node.parent.begin_type?
+            return_value_used?(node.parent)
+          else
+            node.parent.assignment? || node.parent.send_type?
+          end
+        end
+
+        def return_value_of_scope?(node)
+          return unless node.parent
+
+          conditional?(node.parent) || array_or_range?(node.parent) ||
+            node.parent.children.last == node
+        end
+
+        def conditional?(node)
+          node.if_type? || node.or_type? || node.and_type?
+        end
+
+        def array_or_range?(node)
+          node.array_type? || node.irange_type? || node.erange_type?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for braces around the last parameter in a method call
+      # if the last parameter is a hash.
+      # It supports 3 styles:
+      #
+      # * The `braces` style enforces braces around all method
+      # parameters that are hashes.
+      #
+      # @example
+      #   # bad
+      #   some_method(x, y, a: 1, b: 2)
+      #
+      #   # good
+      #   some_method(x, y, {a: 1, b: 2})
+      #
+      # * The `no_braces` style checks that the last parameter doesn't
+      # have braces around it.
+      #
+      # @example
+      #   # bad
+      #   some_method(x, y, {a: 1, b: 2})
+      #
+      #   # good
+      #   some_method(x, y, a: 1, b: 2)
+      #
+      # * The `context_dependent` style checks that the last parameter
+      # doesn't have braces around it, but requires braces if the
+      # second to last parameter is also a hash literal.
+      #
+      # @example
+      #   # bad
+      #   some_method(x, y, {a: 1, b: 2})
+      #   some_method(x, y, {a: 1, b: 2}, a: 1, b: 2)
+      #
+      #   # good
+      #   some_method(x, y, a: 1, b: 2)
+      #   some_method(x, y, {a: 1, b: 2}, {a: 1, b: 2})
+      class BracesAroundHashParameters < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = '%s curly braces around a hash parameter.'.freeze
+
+        def on_send(node)
+          return if node.assignment_method? || node.operator_method?
+
+          return unless node.arguments? && node.last_argument.hash_type? &&
+                        !node.last_argument.empty?
+
+          check(node.last_argument, node.arguments)
+        end
+
+        private
+
+        def check(arg, args)
+          if style == :braces && !arg.braces?
+            add_arg_offense(arg, :missing)
+          elsif style == :no_braces && arg.braces?
+            add_arg_offense(arg, :redundant)
+          elsif style == :context_dependent
+            check_context_dependent(arg, args)
+          end
+        end
+
+        def check_context_dependent(arg, args)
+          braces_around_second_from_end = args.size > 1 && args[-2].hash_type?
+
+          if arg.braces?
+            unless braces_around_second_from_end
+              add_arg_offense(arg, :redundant)
+            end
+          elsif braces_around_second_from_end
+            add_arg_offense(arg, :missing)
+          end
+        end
+
+        def add_arg_offense(arg, type)
+          add_offense(arg.parent, arg.source_range,
+                      format(MSG, type.to_s.capitalize))
+        end
+
+        # We let AutocorrectUnlessChangingAST#autocorrect work with the send
+        # node, because that context is needed. When parsing the code to see if
+        # the AST has changed, a braceless hash would not be parsed as a hash
+        # otherwise.
+        def autocorrect(send_node)
+          hash_node = send_node.last_argument
+
+          lambda do |corrector|
+            if hash_node.braces?
+              remove_braces_with_whitespace(corrector, hash_node)
+            else
+              add_braces(corrector, hash_node)
+            end
+          end
+        end
+
+        def remove_braces_with_whitespace(corrector, node)
+          right_brace_and_space = right_brace_and_space(node.loc.end)
+
+          if comment_on_line?(right_brace_and_space.line)
+            # Removing a line break between a comment and the closing
+            # parenthesis would cause a syntax error, so we only remove the
+            # braces in that case.
+            remove_braces(corrector, node)
+          else
+            left_brace_and_space = range_with_surrounding_space(node.loc.begin,
+                                                                :right)
+            corrector.remove(left_brace_and_space)
+            corrector.remove(right_brace_and_space)
+          end
+        end
+
+        def right_brace_and_space(loc_end)
+          brace_and_space = range_with_surrounding_space(loc_end, :left)
+          range_with_surrounding_comma(brace_and_space, :left)
+        end
+
+        def comment_on_line?(line)
+          processed_source.comments.any? { |c| c.loc.line == line }
+        end
+
+        def remove_braces(corrector, node)
+          corrector.remove(node.loc.begin)
+          corrector.remove(node.loc.end)
+        end
+
+        def add_braces(corrector, node)
+          corrector.insert_before(node.source_range, '{')
+          corrector.insert_after(node.source_range, '}')
+        end
+      end
+    end
+  end
+end