rubocop 0.29.1 → 0.30.0

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

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops checks the indentation of hanging closing parentheses in
+      # method calls, method definitions, and grouped expressions. A hanging
+      # closing parenthesis means `)` preceded by a line break.
+      #
+      # @example
+      #
+      #   # good: when x is on its own line, indent this way
+      #   func(
+      #     x,
+      #     y
+      #   )
+      #
+      #   # good: when x follows opening parenthesis, align parentheses
+      #   a = b * (x +
+      #            y
+      #           )
+      #
+      #   # bad
+      #   def func(
+      #     x,
+      #     y
+      #     )
+      class ClosingParenthesisIndentation < Cop
+        include AutocorrectAlignment
+        include OnMethodDef
+
+        MSG_INDENT =
+          'Indent `)` the same as the start of the line where `(` is.'
+        MSG_ALIGN = 'Align `)` with `(`.'
+
+        def on_send(node)
+          _receiver, _method_name, *args = *node
+          check(node, args)
+        end
+
+        def on_begin(node)
+          check(node, node.children)
+        end
+
+        private
+
+        def on_method_def(_node, _method_name, args, _body)
+          check(args, args.children)
+        end
+
+        def check(node, elements)
+          right_paren = node.loc.end
+          return unless right_paren
+          return unless begins_its_line?(right_paren)
+
+          left_paren = node.loc.begin
+
+          correct_column = if line_break_after_left_paren?(left_paren, elements)
+                             left_paren.source_line =~ /\S/
+                           else
+                             left_paren.column
+                           end
+          @column_delta = correct_column - right_paren.column
+          return if @column_delta == 0
+
+          msg = correct_column == left_paren.column ? MSG_ALIGN : MSG_INDENT
+          add_offense(node.loc.end, node.loc.end, msg)
+        end
+
+        def line_break_after_left_paren?(left_paren, elements)
+          elements.first && elements.first.loc.line > left_paren.line
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces using `` or %x around command literals.
+      #
+      # @example
+      #   # Good if EnforcedStyle is backticks or mixed, bad if percent_x.
+      #   folders = `find . -type d`.split
+      #
+      #   # Good if EnforcedStyle is percent_x, bad if backticks or mixed.
+      #   folders = %x(find . -type d).split
+      #
+      #   # Good if EnforcedStyle is backticks, bad if percent_x or mixed.
+      #   `
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   `
+      #
+      #   # Good if EnforcedStyle is percent_x or mixed, bad if backticks.
+      #   %x(
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   )
+      #
+      #   # Bad unless AllowInnerBackticks is true.
+      #   `echo \`ls\``
+      class CommandLiteral < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG_USE_BACKTICKS = 'Use backticks around command string.'
+        MSG_USE_PERCENT_X = 'Use `%x` around command string.'
+
+        def on_xstr(node)
+          return if heredoc_literal?(node)
+
+          if backtick_literal?(node)
+            check_backtick_literal(node)
+          else
+            check_percent_x_literal(node)
+          end
+        end
+
+        private
+
+        def check_backtick_literal(node)
+          return if style == :backticks && !contains_disallowed_backtick?(node)
+          return if style == :mixed &&
+                    single_line?(node) &&
+                    !contains_disallowed_backtick?(node)
+
+          add_offense(node, :expression, MSG_USE_PERCENT_X)
+        end
+
+        def check_percent_x_literal(node)
+          return if style == :backticks && contains_disallowed_backtick?(node)
+          return if style == :percent_x
+          return if style == :mixed && multi_line?(node)
+          return if style == :mixed && contains_disallowed_backtick?(node)
+
+          add_offense(node, :expression, MSG_USE_BACKTICKS)
+        end
+
+        def contains_disallowed_backtick?(node)
+          !allow_inner_backticks? && contains_backtick?(node)
+        end
+
+        def allow_inner_backticks?
+          cop_config['AllowInnerBackticks']
+        end
+
+        def contains_backtick?(node)
+          node_body(node) =~ /`/
+        end
+
+        def node_body(node)
+          loc = node.loc
+          loc.expression.source[loc.begin.length...-loc.end.length]
+        end
+
+        def heredoc_literal?(node)
+          node.loc.respond_to?(:heredoc_body)
+        end
+
+        def backtick_literal?(node)
+          node.loc.begin.source == '`'
+        end
+
+        def single_line?(node)
+          !multi_line?(node)
+        end
+
+        def multi_line?(node)
+          block_length(node) > 1
+        end
+
+        def preferred_delimiters
+          config.for_cop('Style/PercentLiteralDelimiters') \
+            ['PreferredDelimiters']['%x'].split(//)
+        end
+
+        def autocorrect(node)
+          fail CorrectionNotPossible if contains_backtick?(node)
+
+          if backtick_literal?(node)
+            replacement = ['%x', ''].zip(preferred_delimiters).map(&:join)
+          else
+            replacement = %w(` `)
+          end
+
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.begin, replacement.first)
+            corrector.replace(node.loc.end, replacement.last)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # Check that a copyright notice was given in each source file.
+      #
+      # The default regexp for an acceptable copyright notice can be found in
+      # config/default.yml.  The default can be changed as follows:
+      #
+      # Style/Copyright:
+      #   Notice: '^Copyright (\(c\) )?2\d{3} Acme Inc'
+      #
+      # This regex string is treated as an unanchored regex.  For each file
+      # that RuboCop scans, a comment that matches this regex must be found or
+      # an offense is reported.
+      #
+      class Copyright < Cop
+        def message
+          "Include a copyright notice matching /#{notice}/" \
+          'before any code.'
+        end
+
+        def notice
+          cop_config['Notice']
+        end
+
+        def autocorrect_notice
+          cop_config['AutocorrectNotice']
+        end
+
+        def investigate(processed_source)
+          return if notice.empty?
+          return if notice_found?(processed_source)
+          range = source_range(processed_source.buffer, 1, 0)
+          add_offense(insert_notice_before(processed_source), range, message)
+        end
+
+        def insert_notice_before(processed_source)
+          token_index = 0
+          token_index += 1 if shebang_token?(processed_source, token_index)
+          token_index += 1 if encoding_token?(processed_source, token_index)
+          processed_source.tokens[token_index]
+        end
+
+        def shebang_token?(processed_source, token_index)
+          return false if token_index >= processed_source.tokens.size
+          token = processed_source.tokens[token_index]
+          token.type == :tCOMMENT && token.text =~ /^#!.*$/
+        end
+
+        def encoding_token?(processed_source, token_index)
+          return false if token_index >= processed_source.tokens.size
+          token = processed_source.tokens[token_index]
+          token.type == :tCOMMENT &&
+            token.text =~ /^#.*coding\s?[:=]\s?(?:UTF|utf)-8/
+        end
+
+        def notice_found?(processed_source)
+          notice_found = false
+          notice_regexp = Regexp.new(notice)
+          processed_source.tokens.each do |token|
+            break unless token.type == :tCOMMENT
+            notice_found = !((token.text =~ notice_regexp).nil?)
+            break if notice_found
+          end
+          notice_found
+        end
+
+        def autocorrect(token)
+          fail 'An AutocorrectNotice must be defined in ' \
+            'your RuboCop config' if autocorrect_notice.empty?
+          fail "AutocorrectNotice '#{autocorrect_notice}' must match " \
+            "Notice /#{notice}/" unless autocorrect_notice =~ Regexp.new(notice)
+          @corrections << lambda do |corrector|
+            if token.nil?
+              range = Parser::Source::Range.new('', 0, 0)
+            else
+              range = token.pos
+            end
+            corrector.insert_before(range, "#{autocorrect_notice}\n")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,6 +7,10 @@ module RuboCop
       # classes and modules. Classes with no body are exempt from the
       # check and so are namespace modules - modules that have nothing in
       # their bodies except classes or other other modules.
+      #
+      # The documentation requirement is annulled if the class or module has
+      # a "#:nodoc:" comment next to it. Likewise, "#:nodoc: all" does the
+      # same for all its children.
       class Documentation < Cop
         include AnnotationComment
 
@@ -38,6 +42,7 @@ module RuboCop
             next if node.type == :class && !body
             next if namespace?(body)
             next if associated_comment?(node, ast_with_comments)
+            next if nodoc?(node, ast_with_comments)
             add_offense(node, :keyword, format(MSG, node.type.to_s))
           end
         end
@@ -65,11 +70,38 @@ module RuboCop
           preceding_comment = ast_with_comments[node].last
           distance = node.loc.keyword.line - preceding_comment.loc.line
           return false if distance > 1
+          return false unless comment_line_only?(preceding_comment)
 
           # As long as there's at least one comment line that isn't an
           # annotation, it's OK.
           ast_with_comments[node].any? { |comment| !annotation?(comment) }
         end
+
+        def comment_line_only?(comment)
+          source_buffer = comment.loc.expression.source_buffer
+          comment_line = source_buffer.source_line(comment.loc.line)
+          comment_line =~ /^\s*#/
+        end
+
+        # The :nodoc: comment is not actually associated with the class/module
+        # ifself but its first commentable child node. Unless the element is
+        # tagged with :nodoc:, the search proceeds to check its ancestors for
+        # :nodoc: all.
+        def nodoc?(node, ast_with_comments, require_all = false)
+          return false unless node
+          nodoc_node = node.children.last
+          return false unless nodoc_node
+
+          nodoc_node = nodoc_node.children.first while nodoc_node.type == :begin
+          comment = ast_with_comments[nodoc_node].first
+
+          if comment && comment.loc.line == node.loc.line
+            regex = /^#\s*:nodoc:#{"\s+all\s*$" if require_all}/
+            return true if comment.text =~ regex
+          end
+
+          nodoc?(node.ancestors.first, ast_with_comments, true)
+        end
       end
     end
   end

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

@@ -4,11 +4,72 @@ module RuboCop
   module Cop
     module Style
       # Checks for empty else-clauses, possibly including comments and/or an
-      # explicit `nil`.
+      # explicit `nil` depending on the EnforcedStyle.
+      #
+      # SupportedStyles:
+      #
+      # @example
+      #   # good for all styles
+      #   if condition
+      #     statement
+      #   else
+      #     statement
+      #   end
+      #
+      #   # good for all styles
+      #   if condition
+      #     statement
+      #   end
+      #
+      # empty - warn only on empty else
+      #   @example
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     nil
+      #   end
+      #
+      # nil - warn on else with nil in it
+      #   @example
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #     nil
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #   end
+      #
+      # both - warn on empty else and else with nil in it
+      #   @example
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #     nil
+      #   end
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   else
+      #   end
       class EmptyElse < Cop
         include OnNormalIfUnless
+        include ConfigurableEnforcedStyle
 
-        MSG = 'Redundant empty `else`-clause.'
+        MSG = 'Redundant `else`-clause.'
 
         def on_normal_if_unless(node)
           check(node, if_else_clause(node))
@@ -21,25 +82,33 @@ module RuboCop
         private
 
         def check(node, else_clause)
-          return unless node.loc.else
-          return if else_clause && else_clause.type != :nil
+          case style
+          when :empty
+            empty_check(node, else_clause)
+          when :nil
+            nil_check(node, else_clause)
+          when :both
+            both_check(node, else_clause)
+          end
+        end
 
-          add_offense(node, :else, MSG)
+        def empty_check(node, else_clause)
+          add_offense(node, :else, MSG) if node.loc.else && else_clause.nil?
         end
 
-        def if_else_clause(node)
-          keyword = node.loc.keyword
-          if keyword.is?('if')
-            node.children[2]
-          elsif keyword.is?('elsif')
-            node.children[2]
-          elsif keyword.is?('unless')
-            node.children[1]
-          end
+        def nil_check(node, else_clause)
+          return unless else_clause && else_clause.type == :nil
+          add_offense(node, node.location, MSG)
         end
 
-        def case_else_clause(node)
-          node.children.last
+        def both_check(node, else_clause)
+          return if node.loc.else.nil?
+
+          if else_clause.nil?
+            add_offense(node, :else, MSG)
+          elsif else_clause.type == :nil
+            add_offense(node, :else, MSG)
+          end
         end
       end
     end