rubocop 0.87.1

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  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
+      #   File.open('file') do |f|
+      #     # ...
+      #   end
+      class AutoResourceCleanup < Cop
+        MSG = 'Use the block version of `%<class>s.%<method>s`.'
+
+        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 cleanup?(node)
+
+            add_offense(node,
+                        message: format(MSG,
+                                        class: target_class,
+                                        method: target_method))
+          end
+        end
+
+        private
+
+        def cleanup?(node)
+          parent = node.parent
+          node.block_argument? ||
+            (parent && (parent.block_type? || !parent.lvasgn_type?))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks if usage of %() or %Q() matches configuration.
+      #
+      # @example EnforcedStyle: bare_percent (default)
+      #   # bad
+      #   %Q(He said: "#{greeting}")
+      #   %q{She said: 'Hi'}
+      #
+      #   # good
+      #   %(He said: "#{greeting}")
+      #   %{She said: 'Hi'}
+      #
+      # @example EnforcedStyle: percent_q
+      #   # bad
+      #   %|He said: "#{greeting}"|
+      #   %/She said: 'Hi'/
+      #
+      #   # good
+      #   %Q|He said: "#{greeting}"|
+      #   %q/She said: 'Hi'/
+      #
+      class BarePercentLiterals < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Use `%%%<good>s` instead of `%%%<bad>s`.'
+
+        def on_dstr(node)
+          check(node)
+        end
+
+        def on_str(node)
+          check(node)
+        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
+
+        private
+
+        def check(node)
+          return if node.heredoc?
+          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 && /^%[^\w]/.match?(source)
+        end
+
+        def requires_bare_percent?(source)
+          style == :bare_percent && source.start_with?('%Q')
+        end
+
+        def add_offense_for_wrong_style(node, good, bad)
+          add_offense(node, location: :begin, message: format(MSG,
+                                                              good: good,
+                                                              bad: bad))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      #
+      # This cop checks for BEGIN blocks.
+      #
+      # @example
+      #   # bad
+      #   BEGIN { test }
+      #
+      class BeginBlock < Cop
+        MSG = 'Avoid the use of `BEGIN` blocks.'
+
+        def on_preexe(node)
+          add_offense(node, location: :keyword)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/bisected_attr_accessor.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where `attr_reader` and `attr_writer`
+      # for the same method can be combined into single `attr_accessor`.
+      #
+      # @example
+      #   # bad
+      #   class Foo
+      #     attr_reader :bar
+      #     attr_writer :bar
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     attr_accessor :bar
+      #   end
+      #
+      class BisectedAttrAccessor < Cop
+        include VisibilityHelp
+
+        MSG = 'Combine both accessors into `attr_accessor %<name>s`.'
+
+        def on_class(class_node)
+          VISIBILITY_SCOPES.each do |visibility|
+            reader_names, writer_names = accessor_names(class_node, visibility)
+
+            accessor_macroses(class_node, visibility).each do |macro|
+              check(macro, reader_names, writer_names)
+            end
+          end
+        end
+        alias on_sclass on_class
+        alias on_module on_class
+
+        def autocorrect(node)
+          macro = node.parent
+
+          lambda do |corrector|
+            corrector.replace(macro, replacement(macro, node))
+          end
+        end
+
+        private
+
+        def accessor_names(class_node, visibility)
+          reader_names = Set.new
+          writer_names = Set.new
+
+          accessor_macroses(class_node, visibility).each do |macro|
+            names = macro.arguments.map(&:source)
+
+            names.each do |name|
+              if attr_reader?(macro)
+                reader_names.add(name)
+              else
+                writer_names.add(name)
+              end
+            end
+          end
+
+          [reader_names, writer_names]
+        end
+
+        def accessor_macroses(class_node, visibility)
+          class_def = class_node.body
+          return [] if !class_def || class_def.def_type?
+
+          send_nodes =
+            if class_def.send_type?
+              [class_def]
+            else
+              class_def.each_child_node(:send)
+            end
+
+          send_nodes.select { |node| attr_within_visibility_scope?(node, visibility) }
+        end
+
+        def attr_within_visibility_scope?(node, visibility)
+          node.macro? &&
+            (attr_reader?(node) || attr_writer?(node)) &&
+            node_visibility(node) == visibility
+        end
+
+        def attr_reader?(send_node)
+          send_node.method?(:attr_reader) || send_node.method?(:attr)
+        end
+
+        def attr_writer?(send_node)
+          send_node.method?(:attr_writer)
+        end
+
+        def check(macro, reader_names, writer_names)
+          macro.arguments.each do |arg_node|
+            name = arg_node.source
+
+            if (attr_reader?(macro) && writer_names.include?(name)) ||
+               (attr_writer?(macro) && reader_names.include?(name))
+              add_offense(arg_node, message: format(MSG, name: name))
+            end
+          end
+        end
+
+        def replacement(macro, node)
+          class_node = macro.each_ancestor(:class, :sclass, :module).first
+          reader_names, writer_names = accessor_names(class_node, node_visibility(macro))
+
+          rest_args = rest_args(macro.arguments, reader_names, writer_names)
+
+          if attr_reader?(macro)
+            attr_reader_replacement(macro, node, rest_args)
+          elsif rest_args.empty?
+            ''
+          else
+            "#{macro.method_name} #{rest_args.map(&:source).join(', ')}"
+          end
+        end
+
+        def rest_args(args, reader_names, writer_names)
+          args.reject do |arg|
+            name = arg.source
+            reader_names.include?(name) && writer_names.include?(name)
+          end
+        end
+
+        def attr_reader_replacement(macro, node, rest_args)
+          if rest_args.empty?
+            "attr_accessor #{node.source}"
+          else
+            "attr_accessor #{node.source}\n"\
+            "#{indent(macro)}#{macro.method_name} #{rest_args.map(&:source).join(', ')}"
+          end
+        end
+
+        def indent(node)
+          ' ' * node.loc.column
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for uses of block comments (=begin...=end).
+      #
+      # @example
+      #   # bad
+      #   =begin
+      #   Multiple lines
+      #   of comments...
+      #   =end
+      #
+      #   # good
+      #   # Multiple lines
+      #   # of comments...
+      #
+      class BlockComments < Cop
+        include RangeHelp
+
+        MSG = 'Do not use block comments.'
+        BEGIN_LENGTH = "=begin\n".length
+        END_LENGTH = "\n=end".length
+
+        def investigate(processed_source)
+          processed_source.each_comment do |comment|
+            next unless comment.document?
+
+            add_offense(comment)
+          end
+        end
+
+        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
+
+        private
+
+        def parts(comment)
+          expr = comment.loc.expression
+          eq_begin = expr.resize(BEGIN_LENGTH)
+          eq_end = eq_end_part(comment, expr)
+          contents = range_between(eq_begin.end_pos, eq_end.begin_pos)
+          [eq_begin, eq_end, contents]
+        end
+
+        def eq_end_part(comment, expr)
+          if comment.text.chomp == comment.text
+            range_between(expr.end_pos - END_LENGTH - 1, expr.end_pos - 2)
+          else
+            range_between(expr.end_pos - END_LENGTH, expr.end_pos)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,382 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Check for uses of braces or do/end around single line or
+      # multi-line blocks.
+      #
+      # @example EnforcedStyle: line_count_based (default)
+      #   # bad - single line block
+      #   items.each do |item| item / 5 end
+      #
+      #   # good - single line block
+      #   items.each { |item| item / 5 }
+      #
+      #   # bad - multi-line block
+      #   things.map { |thing|
+      #     something = thing.some_method
+      #     process(something)
+      #   }
+      #
+      #   # good - multi-line block
+      #   things.map do |thing|
+      #     something = thing.some_method
+      #     process(something)
+      #   end
+      #
+      # @example EnforcedStyle: semantic
+      #   # Prefer `do...end` over `{...}` for procedural blocks.
+      #
+      #   # return value is used/assigned
+      #   # bad
+      #   foo = map do |x|
+      #     x
+      #   end
+      #   puts (map do |x|
+      #     x
+      #   end)
+      #
+      #   # return value is not used out of scope
+      #   # good
+      #   map do |x|
+      #     x
+      #   end
+      #
+      #   # Prefer `{...}` over `do...end` for functional blocks.
+      #
+      #   # return value is not used out of scope
+      #   # bad
+      #   each { |x|
+      #     x
+      #   }
+      #
+      #   # return value is used/assigned
+      #   # good
+      #   foo = map { |x|
+      #     x
+      #   }
+      #   map { |x|
+      #     x
+      #   }.inspect
+      #
+      #   # The AllowBracesOnProceduralOneLiners option is ignored unless the
+      #   # EnforcedStyle is set to `semantic`. If so:
+      #
+      #   # If the AllowBracesOnProceduralOneLiners option is unspecified, or
+      #   # set to `false` or any other falsey value, then semantic purity is
+      #   # maintained, so one-line procedural blocks must use do-end, not
+      #   # braces.
+      #
+      #   # bad
+      #   collection.each { |element| puts element }
+      #
+      #   # good
+      #   collection.each do |element| puts element end
+      #
+      #   # If the AllowBracesOnProceduralOneLiners option is set to `true`, or
+      #   # any other truthy value, then one-line procedural blocks may use
+      #   # either style. (There is no setting for requiring braces on them.)
+      #
+      #   # good
+      #   collection.each { |element| puts element }
+      #
+      #   # also good
+      #   collection.each do |element| puts element end
+      #
+      # @example EnforcedStyle: braces_for_chaining
+      #   # bad
+      #   words.each do |word|
+      #     word.flip.flop
+      #   end.join("-")
+      #
+      #   # good
+      #   words.each { |word|
+      #     word.flip.flop
+      #   }.join("-")
+      #
+      # @example EnforcedStyle: always_braces
+      #   # bad
+      #   words.each do |word|
+      #     word.flip.flop
+      #   end
+      #
+      #   # good
+      #   words.each { |word|
+      #     word.flip.flop
+      #   }
+      #
+      # @example BracesRequiredMethods: ['sig']
+      #
+      #   # Methods listed in the BracesRequiredMethods list, such as 'sig'
+      #   # in this example, will require `{...}` braces. This option takes
+      #   # precedence over all other configurations except IgnoredMethods.
+      #
+      #   # bad
+      #   sig do
+      #     params(
+      #       foo: string,
+      #     ).void
+      #   end
+      #   def bar(foo)
+      #     puts foo
+      #   end
+      #
+      #   # good
+      #   sig {
+      #     params(
+      #       foo: string,
+      #     ).void
+      #   }
+      #   def bar(foo)
+      #     puts foo
+      #   end
+      #
+      class BlockDelimiters < Cop
+        include ConfigurableEnforcedStyle
+        include IgnoredMethods
+
+        ALWAYS_BRACES_MESSAGE = 'Prefer `{...}` over `do...end` for blocks.'
+
+        BRACES_REQUIRED_MESSAGE = 'Brace delimiters `{...}` required for ' \
+          "'%<method_name>s' method."
+
+        def on_send(node)
+          return unless node.arguments?
+          return if node.parenthesized?
+          return if node.operator_method? || node.assignment_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, location: :begin) unless proper_block_style?(node)
+        end
+
+        def autocorrect(node)
+          return if correction_would_break_code?(node)
+
+          if node.braces?
+            replace_braces_with_do_end(node.loc)
+          else
+            replace_do_end_with_braces(node.loc)
+          end
+        end
+
+        private
+
+        def line_count_based_message(node)
+          if node.multiline?
+            '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 node.multiline?
+            if node.chained?
+              '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 braces_required_message(node)
+          format(BRACES_REQUIRED_MESSAGE, method_name: node.method_name.to_s)
+        end
+
+        def message(node)
+          return braces_required_message(node) if braces_required_method?(node.method_name)
+
+          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)
+          when :always_braces       then ALWAYS_BRACES_MESSAGE
+          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?(range)
+          /\s/.match?(range.source_buffer.source[range.begin_pos - 1, 1])
+        end
+
+        def whitespace_after?(range, length = 1)
+          /\s/.match?(range.source_buffer.source[range.begin_pos + length, 1])
+        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.braces?
+
+            node.each_child_node { |child| get_blocks(child, &block) }
+          when :pair
+            node.each_child_node { |child| get_blocks(child, &block) }
+          end
+        end
+
+        def proper_block_style?(node)
+          return special_method_proper_block_style?(node) if special_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)
+          when :always_braces       then braces_style?(node)
+          end
+        end
+
+        def special_method?(method_name)
+          ignored_method?(method_name) || braces_required_method?(method_name)
+        end
+
+        def special_method_proper_block_style?(node)
+          method_name = node.method_name
+          return true if ignored_method?(method_name)
+          return node.braces? if braces_required_method?(method_name)
+        end
+
+        def braces_required_method?(method_name)
+          braces_required_methods.include?(method_name.to_s)
+        end
+
+        def braces_required_methods
+          cop_config.fetch('BracesRequiredMethods', [])
+        end
+
+        def line_count_based_block_style?(node)
+          node.multiline? ^ node.braces?
+        end
+
+        def semantic_block_style?(node)
+          method_name = node.method_name
+
+          if node.braces?
+            functional_method?(method_name) || functional_block?(node) ||
+              (procedural_oneliners_may_have_braces? && !node.multiline?)
+          else
+            procedural_method?(method_name) || !return_value_used?(node)
+          end
+        end
+
+        def braces_for_chaining_style?(node)
+          block_begin = node.loc.begin.source
+
+          block_begin == if node.multiline?
+                           (node.chained? ? '{' : 'do')
+                         else
+                           '{'
+                         end
+        end
+
+        def braces_style?(node)
+          node.loc.begin.source == '{'
+        end
+
+        def correction_would_break_code?(node)
+          return unless node.keywords?
+
+          node.send_node.arguments? && !node.send_node.parenthesized?
+        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_oneliners_may_have_braces?
+          cop_config['AllowBracesOnProceduralOneLiners']
+        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.range_type?
+        end
+      end
+    end
+  end
+end