rubbycop 0.49.0

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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 RubbyCop.
+    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
+        to_a
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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 RubbyCop.
+    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, nil] 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
+        to_a
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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 RubbyCop.
+    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
+        to_a
+      end
+    end
+  end
+end

data/lib/rubbycop/ast/sexp.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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/rubbycop/ast/traversal.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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`
+    # if you want to recursively process descendant nodes.
+    module Traversal
+      def walk(node)
+        return if node.nil?
+        send(:"on_#{node.type}", node)
+        nil
+      end
+
+      NO_CHILD_NODES    = %i[true false nil int float complex
+                             rational str sym regopt self lvar
+                             ivar cvar gvar nth_ref back_ref cbase
+                             arg restarg blockarg shadowarg
+                             kwrestarg zsuper lambda redo retry].freeze
+      ONE_CHILD_NODE    = %i[splat kwsplat block_pass not break next
+                             preexe postexe match_current_line defined?
+                             arg_expr].freeze
+      MANY_CHILD_NODES  = %i[dstr dsym xstr regexp array hash pair
+                             irange erange mlhs masgn or_asgn and_asgn
+                             undef alias args super yield or and
+                             while_post until_post iflipflop eflipflop
+                             match_with_lvasgn begin kwbegin return].freeze
+      SECOND_CHILD_ONLY = %i[lvasgn ivasgn cvasgn gvasgn optarg kwarg
+                             kwoptarg].freeze
+
+      NO_CHILD_NODES.each do |type|
+        module_eval("def on_#{type}(node); end")
+      end
+
+      ONE_CHILD_NODE.each do |type|
+        module_eval(<<-END)
+          def on_#{type}(node)
+            if (child = node.children[0])
+              send(:"on_\#{child.type}", child)
+            end
+          end
+        END
+      end
+
+      MANY_CHILD_NODES.each do |type|
+        module_eval(<<-END)
+          def on_#{type}(node)
+            node.children.each { |child| send(:"on_\#{child.type}", child) }
+            nil
+          end
+        END
+      end
+
+      SECOND_CHILD_ONLY.each do |type|
+        # Guard clause is for nodes nested within mlhs
+        module_eval(<<-END)
+          def on_#{type}(node)
+            if (child = node.children[1])
+              send(:"on_\#{child.type}", child)
+            end
+          end
+        END
+      end
+
+      def on_const(node)
+        return unless (child = node.children[0])
+        send(:"on_#{child.type}", child)
+      end
+
+      def on_casgn(node)
+        children = node.children
+        if (child = children[0]) # always const???
+          send(:"on_#{child.type}", child)
+        end
+        return unless (child = children[2])
+        send(:"on_#{child.type}", child)
+      end
+
+      def on_class(node)
+        children = node.children
+        child = children[0] # always const???
+        send(:"on_#{child.type}", child)
+        if (child = children[1])
+          send(:"on_#{child.type}", child)
+        end
+        return unless (child = children[2])
+        send(:"on_#{child.type}", child)
+      end
+
+      def on_def(node)
+        children = node.children
+        on_args(children[1])
+        return unless (child = children[2])
+        send(:"on_#{child.type}", child)
+      end
+
+      def on_send(node)
+        node.children.each_with_index do |child, i|
+          next if i == 1
+          send(:"on_#{child.type}", child) if child
+        end
+        nil
+      end
+
+      alias on_csend on_send
+
+      def on_op_asgn(node)
+        children = node.children
+        child = children[0]
+        send(:"on_#{child.type}", child)
+        child = children[2]
+        send(:"on_#{child.type}", child)
+      end
+
+      def on_defs(node)
+        children = node.children
+        child = children[0]
+        send(:"on_#{child.type}", child)
+        on_args(children[2])
+        return unless (child = children[3])
+        send(:"on_#{child.type}", child)
+      end
+
+      def on_if(node)
+        children = node.children
+        child = children[0]
+        send(:"on_#{child.type}", child)
+        if (child = children[1])
+          send(:"on_#{child.type}", child)
+        end
+        return unless (child = children[2])
+        send(:"on_#{child.type}", child)
+      end
+
+      def on_while(node)
+        children = node.children
+        child = children[0]
+        send(:"on_#{child.type}", child)
+        return unless (child = children[1])
+        send(:"on_#{child.type}", child)
+      end
+
+      alias on_until  on_while
+      alias on_module on_while
+      alias on_sclass on_while
+
+      def on_block(node)
+        children = node.children
+        child = children[0]
+        send(:"on_#{child.type}", child) # can be send, zsuper...
+        on_args(children[1])
+        return unless (child = children[2])
+        send(:"on_#{child.type}", child)
+      end
+
+      def on_case(node)
+        node.children.each do |child|
+          send(:"on_#{child.type}", child) if child
+        end
+        nil
+      end
+
+      alias on_rescue  on_case
+      alias on_resbody on_case
+      alias on_ensure  on_case
+      alias on_for     on_case
+      alias on_when    on_case
+    end
+  end
+end

data/lib/rubbycop/cached_data.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module RubbyCop
+  # Converts RubbyCop objects to and from the serialization format JSON.
+  class CachedData
+    def initialize(filename)
+      @filename = filename
+    end
+
+    def from_json(text)
+      deserialize_offenses(JSON.parse(text))
+    end
+
+    def to_json(offenses)
+      JSON.dump(offenses.map { |o| serialize_offense(o) })
+    end
+
+    private
+
+    def serialize_offense(offense)
+      {
+        # Calling #to_s here ensures that the serialization works when using
+        # other json serializers such as Oj. Some of these gems do not call
+        # #to_s implicitly.
+        severity: offense.severity.to_s,
+        location: {
+          begin_pos: offense.location.begin_pos,
+          end_pos: offense.location.end_pos
+        },
+        message:  message(offense),
+        cop_name: offense.cop_name,
+        status:   offense.status
+      }
+    end
+
+    def message(offense)
+      # JSON.dump will fail if the offense message contains text which is not
+      # valid UTF-8
+      message = offense.message
+      if message.respond_to?(:scrub)
+        message.scrub
+      else
+        message.chars.select(&:valid_encoding?).join
+      end
+    end
+
+    # Restore an offense object loaded from a JSON file.
+    def deserialize_offenses(offenses)
+      source_buffer = Parser::Source::Buffer.new(@filename)
+      source_buffer.source = File.read(@filename, encoding: Encoding::UTF_8)
+      offenses.map! do |o|
+        location = Parser::Source::Range.new(source_buffer,
+                                             o['location']['begin_pos'],
+                                             o['location']['end_pos'])
+        Cop::Offense.new(o['severity'], location,
+                         o['message'],
+                         o['cop_name'], o['status'].to_sym)
+      end
+    end
+  end
+end

data/lib/rubbycop/cli.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  # The CLI is a class responsible of handling all the command line interface
+  # logic.
+  class CLI
+    include Formatter::TextUtil
+
+    class Finished < RuntimeError; end
+
+    attr_reader :options, :config_store
+
+    def initialize
+      @options = {}
+      @config_store = ConfigStore.new
+    end
+
+    # Entry point for the application logic. Here we
+    # do the command line arguments processing and inspect
+    # the target files
+    # @return [Integer] UNIX exit code
+    def run(args = ARGV)
+      @options, paths = Options.new.parse(args)
+      validate_options_vs_config
+      act_on_options
+      apply_default_formatter
+
+      execute_runner(paths)
+    rescue RubbyCop::Error => e
+      $stderr.puts Rainbow("Error: #{e.message}").red
+      return 2
+    rescue Finished
+      return 0
+    rescue StandardError, SyntaxError => e
+      $stderr.puts e.message
+      $stderr.puts e.backtrace
+      return 2
+    end
+
+    def trap_interrupt(runner)
+      Signal.trap('INT') do
+        exit!(1) if runner.aborting?
+        runner.abort
+        $stderr.puts
+        $stderr.puts 'Exiting... Interrupt again to exit immediately.'
+      end
+    end
+
+    private
+
+    def validate_options_vs_config
+      if @options[:parallel] &&
+         !@config_store.for(Dir.pwd).for_all_cops['UseCache']
+        raise ArgumentError, '-P/--parallel uses caching to speed up ' \
+                             'execution, so combining with AllCops: ' \
+                             'UseCache: false is not allowed.'
+      end
+    end
+
+    def act_on_options
+      handle_exiting_options
+
+      ConfigLoader.debug = @options[:debug]
+      ConfigLoader.auto_gen_config = @options[:auto_gen_config]
+
+      @config_store.options_config = @options[:config] if @options[:config]
+      @config_store.force_default_config! if @options[:force_default_config]
+
+      if @options[:color]
+        # color output explicitly forced on
+        Rainbow.enabled = true
+      elsif @options[:color] == false
+        # color output explicitly forced off
+        Rainbow.enabled = false
+      end
+    end
+
+    def execute_runner(paths)
+      runner = Runner.new(@options, @config_store)
+
+      trap_interrupt(runner)
+      all_passed = runner.run(paths)
+      display_warning_summary(runner.warnings)
+      display_error_summary(runner.errors)
+      maybe_print_corrected_source
+
+      all_passed && !runner.aborting? && runner.errors.empty? ? 0 : 1
+    end
+
+    def handle_exiting_options
+      return unless Options::EXITING_OPTIONS.any? { |o| @options.key? o }
+
+      puts RubbyCop::Version.version(false) if @options[:version]
+      puts RubbyCop::Version.version(true) if @options[:verbose_version]
+      print_available_cops if @options[:show_cops]
+      raise Finished
+    end
+
+    def apply_default_formatter
+      # This must be done after the options have already been processed,
+      # because they can affect how ConfigStore behaves
+      @options[:formatters] ||= begin
+        cfg = @config_store.for(Dir.pwd).for_all_cops
+        formatter = cfg['DefaultFormatter'] || 'progress'
+        [[formatter, @options[:output_path]]]
+      end
+
+      return unless @options[:auto_gen_config]
+
+      @options[:formatters] << [Formatter::DisabledConfigFormatter,
+                                ConfigLoader::AUTO_GENERATED_FILE]
+    end
+
+    def print_available_cops
+      # Load the configs so the require()s are done for custom cops
+      @config_store.for(Dir.pwd)
+      registry = Cop::Cop.registry
+      show_all = @options[:show_cops].empty?
+
+      if show_all
+        puts "# Available cops (#{registry.length}) + config for #{Dir.pwd}: "
+      end
+
+      registry.departments.sort!.each do |department|
+        print_cops_of_department(registry, department, show_all)
+      end
+    end
+
+    def print_cops_of_department(registry, department, show_all)
+      selected_cops = if show_all
+                        cops_of_department(registry, department)
+                      else
+                        selected_cops_of_department(registry, department)
+                      end
+
+      puts "# Department '#{department}' (#{selected_cops.length}):" if show_all
+
+      print_cop_details(selected_cops)
+    end
+
+    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)
+        puts
+      end
+    end
+
+    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_department(cops, department)
+      cops.with_department(department).sort!
+    end
+
+    def config_lines(cop)
+      cnf = @config_store.for(Dir.pwd).for_cop(cop)
+      cnf.to_yaml.lines.to_a.butfirst.map { |line| '  ' + line }
+    end
+
+    def display_warning_summary(warnings)
+      return if warnings.empty?
+
+      warn Rainbow("\n#{pluralize(warnings.size, 'warning')}:").yellow
+
+      warnings.each { |warning| warn warning }
+    end
+
+    def display_error_summary(errors)
+      return if errors.empty?
+
+      warn Rainbow("\n#{pluralize(errors.size, 'error')} occurred:").red
+
+      errors.each { |error| warn error }
+
+      warn <<-END.strip_indent
+        Errors are usually caused by RubbyCop bugs.
+        Please, report your problems to RubbyCop's issue tracker.
+        Mention the following information in the issue report:
+        #{RubbyCop::Version.version(true)}
+      END
+    end
+
+    def maybe_print_corrected_source
+      # If we are asked to autocorrect source code read from stdin, the only
+      # reasonable place to write it is to stdout
+      # Unfortunately, we also write other information to stdout
+      # So a delimiter is needed for tools to easily identify where the
+      # autocorrected source begins
+      return unless @options[:stdin] && @options[:auto_correct]
+      puts '=' * 20
+      print @options[:stdin]
+    end
+  end
+end