rubocop 0.46.0 → 0.47.0

data/lib/rubocop/ast/node/mixin/conditional_node.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Common functionality for nodes that have conditions:
+    # `if`, `while`, `until`, `case`.
+    # This currently doesn't include `when` nodes, because they have multiple
+    # conditions, and need to be checked for that.
+    module ConditionalNode
+      # Checks whether the condition of the node is written on a single line.
+      #
+      # @return [Boolean] whether the condition is on a single line
+      def single_line_condition?
+        loc.keyword.line == condition.source_range.line
+      end
+
+      # Checks whether the condition of the node is written on more than
+      # one line.
+      #
+      # @return [Boolean] whether the condition is on more than one line
+      def multiline_condition?
+        !single_line_condition?
+      end
+
+      # Returns the condition of the node. This works together with each node's
+      # custom destructuring method to select the correct part of the node.
+      #
+      # @return [Node, nil] the condition of the node
+      def condition
+        node_parts[0]
+      end
+
+      # Returns the body associated with the condition. This works together with
+      # each node's custom destructuring method to select the correct part of
+      # the node.
+      #
+      # @note For `if` nodes, this is the truthy branch.
+      #
+      # @return [Node, nil] the body of the node
+      def body
+        node_parts[1]
+      end
+    end
+  end
+end

data/lib/rubocop/ast/node/mixin/hash_element_node.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Common functionality for nodes that can be used as hash elements:
+    # `pair`, `kwsplat`
+    module HashElementNode
+      # Returns the key of this `hash` element.
+      #
+      # @note For keyword splats, this returns the whole node
+      #
+      # @return [Node] the key of the hash element
+      def key
+        node_parts[0]
+      end
+
+      # Returns the value of this `hash` element.
+      #
+      # @note For keyword splats, this returns the whole node
+      #
+      # @return [Node] the value of the hash element
+      def value
+        node_parts[1]
+      end
+
+      # Checks whether this `hash` element is on the same line as `other`.
+      #
+      # @note A multiline element is considered to be on the same line if it
+      #       shares any of its lines with `other`
+      #
+      # @return [Boolean] whether this element is on the same line as `other`
+      def same_line?(other)
+        loc.last_line == other.loc.line || loc.line == other.loc.last_line
+      end
+
+      # Returns the delta between this pair's key and the argument pair's.
+      #
+      # @note Keys on the same line always return a delta of 0
+      # @note Keyword splats always return a delta of 0 for right alignment
+      #
+      # @param [Symbol] alignment whether to check the left or right side
+      # @return [Integer] the delta between the two keys
+      def key_delta(other, alignment = :left)
+        HashElementDelta.new(self, other).key_delta(alignment)
+      end
+
+      # Returns the delta between this element's value and the argument's.
+      #
+      # @note Keyword splats always return a delta of 0
+      #
+      # @return [Integer] the delta between the two values
+      def value_delta(other)
+        HashElementDelta.new(self, other).value_delta
+      end
+
+      # Returns the delta between this element's delimiter and the argument's.
+      #
+      # @note Pairs with different delimiter styles return a delta of 0
+      #
+      # @return [Integer] the delta between the two delimiters
+      def delimiter_delta(other)
+        HashElementDelta.new(self, other).delimiter_delta
+      end
+
+      # A helper class for comparing the positions of different parts of a
+      # `pair` node.
+      class HashElementDelta
+        def initialize(first, second)
+          @first = first
+          @second = second
+
+          raise ArgumentError unless valid_argument_types?
+        end
+
+        def key_delta(alignment = :left)
+          return 0 if first.same_line?(second)
+          return 0 if keyword_splat? && alignment == :right
+
+          delta(first.key.loc, second.key.loc, alignment)
+        end
+
+        def value_delta
+          return 0 if first.same_line?(second)
+          return 0 if keyword_splat?
+
+          delta(first.value.loc, second.value.loc)
+        end
+
+        def delimiter_delta
+          return 0 if first.same_line?(second)
+          return 0 if first.delimiter != second.delimiter
+
+          delta(first.loc.operator, second.loc.operator)
+        end
+
+        private
+
+        attr_reader :first, :second
+
+        def valid_argument_types?
+          [first, second].all? do |argument|
+            argument.pair_type? || argument.kwsplat_type?
+          end
+        end
+
+        def delta(first, second, alignment = :left)
+          case alignment
+          when :left
+            first.column - second.column
+          when :right
+            first.last_column - second.last_column
+          else
+            0
+          end
+        end
+
+        def keyword_splat?
+          [first, second].any?(&:kwsplat_type?)
+        end
+      end
+
+      private_constant :HashElementDelta
+    end
+  end
+end

data/lib/rubocop/ast/node/mixin/modifier_node.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Common functionality for nodes that can be used as modifiers:
+    # `if`, `while`, `until`
+    module ModifierNode
+      # Checks whether the node is in a modifier form, i.e. a condition
+      # trailing behind an expression.
+      #
+      # @return [Boolean] whether the node is a modifier
+      def modifier_form?
+        loc.end.nil?
+      end
+    end
+  end
+end

data/lib/rubocop/ast/node/pair_node.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `pair` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `pair` nodes within RuboCop.
+    class PairNode < Node
+      include HashElementNode
+
+      HASH_ROCKET = '=>'.freeze
+      SPACED_HASH_ROCKET = ' => '.freeze
+      COLON = ':'.freeze
+      SPACED_COLON = ': '.freeze
+
+      # Checks whether the `pair` uses a hash rocket delimiter.
+      #
+      # @return [Boolean] whether this `pair` uses a hash rocket delimiter
+      def hash_rocket?
+        loc.operator.is?(HASH_ROCKET)
+      end
+
+      # Checks whether the `pair` uses a colon delimiter.
+      #
+      # @return [Boolean] whether this `pair` uses a colon delimiter
+      def colon?
+        loc.operator.is?(COLON)
+      end
+
+      # Returns the delimiter of the `pair` as a string. Returns `=>` for a
+      # colon delimited `pair`, and `:` for a hash rocket delimited `pair`.
+      #
+      # @param [Boolean] with_spacing whether to include spacing
+      # @return [String] the delimiter of the `pair`
+      def delimiter(with_spacing = false)
+        if with_spacing
+          hash_rocket? ? SPACED_HASH_ROCKET : SPACED_COLON
+        else
+          hash_rocket? ? HASH_ROCKET : COLON
+        end
+      end
+
+      # Returns the inverse delimiter of the `pair` as a string.
+      #
+      # @param [Boolean] with_spacing whether to include spacing
+      # @return [String] the inverse delimiter of the `pair`
+      def inverse_delimiter(with_spacing = false)
+        if with_spacing
+          hash_rocket? ? SPACED_COLON : SPACED_HASH_ROCKET
+        else
+          hash_rocket? ? COLON : HASH_ROCKET
+        end
+      end
+
+      # Custom destructuring method. This is used to normalize the branches
+      # for `pair` and `kwsplat` nodes, to add duck typing to `hash` elements.
+      #
+      # @return [Array<Node>] the different parts of the `pair`
+      def node_parts
+        [*self]
+      end
+    end
+  end
+end

data/lib/rubocop/ast/node/until_node.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `until` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `until` nodes within RuboCop.
+    class UntilNode < Node
+      include ConditionalNode
+      include ModifierNode
+
+      # Returns the keyword of the `until` statement as a string.
+      #
+      # @return [String] the keyword of the `until` statement
+      def keyword
+        'until'
+      end
+
+      # Returns the inverse keyword of the `until` node as a string.
+      # Returns `while` for `until` nodes and vice versa.
+      #
+      # @return [String] the inverse keyword of the `until` statement
+      def inverse_keyword
+        'while'
+      end
+
+      # Checks whether the `until` node has a `do` keyword.
+      #
+      # @return [Boolean] whether the `until` node has a `do` keyword
+      def do?
+        loc.begin && loc.begin.is?('do')
+      end
+
+      # Custom destructuring method. This can be used to normalize
+      # destructuring for different variations of the node.
+      #
+      # @return [Array<Node>] the different parts of the `until` statement
+      def node_parts
+        [*self]
+      end
+    end
+  end
+end

data/lib/rubocop/ast/node/when_node.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `when` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `when` nodes within RuboCop.
+    class WhenNode < Node
+      # Returns an array of all the conditions in the `when` branch.
+      #
+      # @return [Array<Node>] an array of condition nodes
+      def conditions
+        node_parts[0...-1]
+      end
+
+      # Calls the given block for each condition node in the `when` branch.
+      # If no block is given, an `Enumerator` is returned.
+      #
+      # @return [self] if a block is given
+      # @return [Enumerator] if no block is given
+      def each_condition
+        return conditions.to_enum(__method__) unless block_given?
+
+        conditions.each do |condition|
+          yield condition
+        end
+
+        self
+      end
+
+      # Returns the index of the `when` branch within the `case` statement.
+      #
+      # @return [Integer] the index of the `when` branch
+      def branch_index
+        parent.when_branches.index(self)
+      end
+
+      # Checks whether the `when` node has a `then` keyword.
+      #
+      # @return [Boolean] whether the `when` node has a `then` keyword
+      def then?
+        loc.begin && loc.begin.is?('then')
+      end
+
+      # Returns the body of the `when` node.
+      #
+      # @return [Node] the body of the `when` node
+      def body
+        node_parts[-1]
+      end
+
+      # Custom destructuring method. This can be used to normalize
+      # destructuring for different variations of the node.
+      #
+      # @return [Array<Node>] the different parts of the `until` statement
+      def node_parts
+        [*self]
+      end
+    end
+  end
+end

data/lib/rubocop/ast/node/while_node.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `while` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `while` nodes within RuboCop.
+    class WhileNode < Node
+      include ConditionalNode
+      include ModifierNode
+
+      # Returns the keyword of the `while` statement as a string.
+      #
+      # @return [String] the keyword of the `while` statement
+      def keyword
+        'while'
+      end
+
+      # Returns the inverse keyword of the `while` node as a string.
+      # Returns `until` for `while` nodes and vice versa.
+      #
+      # @return [String] the inverse keyword of the `while` statement
+      def inverse_keyword
+        'until'
+      end
+
+      # Checks whether the `until` node has a `do` keyword.
+      #
+      # @return [Boolean] whether the `until` node has a `do` keyword
+      def do?
+        loc.begin && loc.begin.is?('do')
+      end
+
+      # Custom destructuring method. This can be used to normalize
+      # destructuring for different variations of the node.
+      #
+      # @return [Array<Node>] the different parts of the `while` statement
+      def node_parts
+        [*self]
+      end
+    end
+  end
+end

data/lib/rubocop/ast/sexp.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # This module provides a shorthand method to create a {Node} like
+    # `Parser::AST::Sexp`.
+    #
+    # @see http://rubydoc.info/gems/ast/AST/Sexp
+    module Sexp
+      # Creates a {Node} with type `type` and children `children`.
+      def s(type, *children)
+        Node.new(type, children)
+      end
+    end
+  end
+end

data/lib/rubocop/{ast_node → ast}/traversal.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module RuboCop
-  class Node
+  module AST
     # Provides methods for traversing an AST.
     # Does not transform an AST; for that, use Parser::AST::Processor.
     # Override methods to perform custom processing. Remember to call `super`

data/lib/rubocop/cli.rb

@@ -104,28 +104,32 @@ module RuboCop
     def print_available_cops
       # Load the configs so the require()s are done for custom cops
       @config_store.for(Dir.pwd)
-      cops = Cop::Cop.all
+      registry = Cop::Cop.registry
       show_all = @options[:show_cops].empty?
 
       if show_all
-        puts "# Available cops (#{cops.length}) + config for #{Dir.pwd}: "
+        puts "# Available cops (#{registry.length}) + config for #{Dir.pwd}: "
       end
 
-      cops.types.sort!.each { |type| print_cops_of_type(cops, type, show_all) }
+      registry.departments.sort!.each do |department|
+        print_cops_of_department(registry, department, show_all)
+      end
     end
 
-    def print_cops_of_type(cops, type, show_all)
+    def print_cops_of_department(registry, department, show_all)
       selected_cops = if show_all
-                        cops_of_type(cops, type)
+                        cops_of_department(registry, department)
                       else
-                        selected_cops_of_type(cops, type)
+                        selected_cops_of_department(registry, department)
                       end
 
-      if show_all
-        puts "# Type '#{type.to_s.capitalize}' (#{selected_cops.size}):"
-      end
+      puts "# Department '#{department}' (#{selected_cops.length}):" if show_all
+
+      print_cop_details(selected_cops)
+    end
 
-      selected_cops.each do |cop|
+    def print_cop_details(cops)
+      cops.each do |cop|
         puts '# Supports --auto-correct' if cop.new.support_autocorrect?
         puts "#{cop.cop_name}:"
         puts config_lines(cop)
@@ -133,14 +137,14 @@ module RuboCop
       end
     end
 
-    def selected_cops_of_type(cops, type)
-      cops_of_type(cops, type).select do |cop|
+    def selected_cops_of_department(cops, department)
+      cops_of_department(cops, department).select do |cop|
         @options[:show_cops].include?(cop.cop_name)
       end
     end
 
-    def cops_of_type(cops, type)
-      cops.with_type(type).sort_by!(&:cop_name)
+    def cops_of_department(cops, department)
+      cops.with_department(department).sort!
     end
 
     def config_lines(cop)