rubocop 1.19.0 → 1.40.0

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

@@ -3,10 +3,30 @@
 module RuboCop
   module Cop
     module Style
-      # This cop can either enforce or forbid Yoda conditions,
+      # Enforces or forbids Yoda conditions,
       # i.e. comparison operations where the order of expression is reversed.
       # eg. `5 == x`
       #
+      # @safety
+      #   This cop is unsafe because comparison operators can be defined
+      #   differently on different classes, and are not guaranteed to
+      #   have the same result if reversed.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   class MyKlass
+      #     def ==(other)
+      #       true
+      #     end
+      #   end
+      #
+      #   obj = MyKlass.new
+      #   obj == 'string'   #=> true
+      #   'string' == obj   #=> false
+      #   ----
+      #
       # @example EnforcedStyle: forbid_for_all_comparison_operators (default)
       #   # bad
       #   99 == foo
@@ -58,14 +78,11 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Reverse the order of the operands `%<source>s`.'
-
         REVERSE_COMPARISON = { '<' => '>', '<=' => '>=', '>' => '<', '>=' => '<=' }.freeze
-
         EQUALITY_OPERATORS = %i[== !=].freeze
-
         NONCOMMUTATIVE_OPERATORS = %i[===].freeze
-
         PROGRAM_NAMES = %i[$0 $PROGRAM_NAME].freeze
+        RESTRICT_ON_SEND = RuboCop::AST::Node::COMPARISON_OPERATORS
 
         # @!method file_constant_equal_program_name?(node)
         def_node_matcher :file_constant_equal_program_name?, <<~PATTERN
@@ -74,7 +91,7 @@ module RuboCop
 
         def on_send(node)
           return unless yoda_compatible_condition?(node)
-          return if equality_only? && non_equality_operator?(node) ||
+          return if (equality_only? && non_equality_operator?(node)) ||
                     file_constant_equal_program_name?(node)
 
           valid_yoda?(node) || add_offense(node) do |corrector|
@@ -102,8 +119,8 @@ module RuboCop
           lhs = node.receiver
           rhs = node.first_argument
 
-          return true if lhs.literal? && rhs.literal? ||
-                         !lhs.literal? && !rhs.literal? ||
+          return true if (lhs.literal? && rhs.literal?) ||
+                         (!lhs.literal? && !rhs.literal?) ||
                          interpolation?(lhs)
 
           enforce_yoda? ? lhs.literal? : rhs.literal?

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

@@ -3,12 +3,18 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for numeric comparisons that can be replaced
+      # Checks for numeric comparisons that can be replaced
       # by a predicate method, such as receiver.length == 0,
       # receiver.length > 0, receiver.length != 0,
       # receiver.length < 1 and receiver.size == 0 that can be
       # replaced by receiver.empty? and !receiver.empty?.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   has an `empty?` method that is defined in terms of `length`. If there
+      #   is a non-standard class that redefines `length` or `empty?`, the cop
+      #   may register a false positive.
+      #
       # @example
       #   # bad
       #   [1, 2, 3].length == 0

data/lib/rubocop/cop/team.rb

@@ -38,18 +38,17 @@ module RuboCop
         new(cops, config, options)
       end
 
-      # @return [Array<Cop::Cop>]
+      # @return [Array<Cop::Base>]
       def self.mobilize_cops(cop_classes, config, options = {})
-        cop_classes = Registry.new(cop_classes.to_a) unless cop_classes.is_a?(Registry)
-        only = options.fetch(:only, [])
-        safe = options.fetch(:safe, false)
-        cop_classes.enabled(config, only, only_safe: safe).map do |cop_class|
+        cop_classes = Registry.new(cop_classes.to_a, options) unless cop_classes.is_a?(Registry)
+
+        cop_classes.enabled(config).map do |cop_class|
           cop_class.new(config, options)
         end
       end
 
       def autocorrect?
-        @options[:auto_correct]
+        @options[:autocorrect]
       end
 
       def debug?
@@ -68,7 +67,7 @@ module RuboCop
 
         # The autocorrection process may have to be repeated multiple times
         # until there are no corrections left to perform
-        # To speed things up, run auto-correcting cops by themselves, and only
+        # To speed things up, run autocorrecting cops by themselves, and only
         # run the other cops when no corrections are left
         on_duty = roundup_relevant_cops(processed_source.file_path)
 
@@ -131,7 +130,7 @@ module RuboCop
           @options[:stdin] = new_source
         else
           filename = processed_source.buffer.name
-          File.open(filename, 'w') { |f| f.write(new_source) }
+          File.write(filename, new_source)
         end
         @updated_source_file = true
       end

data/lib/rubocop/cop/util.rb

@@ -30,8 +30,15 @@ module RuboCop
         node.loc.respond_to?(:end) && node.loc.end && node.loc.end.is?(')')
       end
 
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       def add_parentheses(node, corrector)
-        if !node.respond_to?(:arguments)
+        if node.args_type?
+          arguments_range = node.source_range
+          args_with_space = range_with_surrounding_space(arguments_range, side: :left)
+          leading_space = range_between(args_with_space.begin_pos, arguments_range.begin_pos)
+          corrector.replace(leading_space, '(')
+          corrector.insert_after(arguments_range, ')')
+        elsif !node.respond_to?(:arguments)
           corrector.wrap(node, '(', ')')
         elsif node.arguments.empty?
           corrector.insert_after(node, '()')
@@ -43,6 +50,7 @@ module RuboCop
           corrector.insert_after(args_end(node), ')')
         end
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
       def args_begin(node)
         loc = node.loc
@@ -113,11 +121,12 @@ module RuboCop
         if needs_escaping?(string) && compatible_external_encoding_for?(string)
           string.inspect
         else
-          "'#{string.gsub('\\') { '\\\\' }}'"
+          # In a single-quoted strings, double quotes don't need to be escaped
+          "'#{string.gsub('\\') { '\\\\' }.gsub('\"', '"')}'"
         end
       end
 
-      def trim_string_interporation_escape_character(str)
+      def trim_string_interpolation_escape_character(str)
         str.gsub(/\\\#\{(.*?)\}/) { "\#{#{Regexp.last_match(1)}}" }
       end
 
@@ -125,12 +134,22 @@ module RuboCop
         StringInterpreter.interpret(string)
       end
 
+      def line(node_or_range)
+        if node_or_range.respond_to?(:line)
+          node_or_range.line
+        elsif node_or_range.respond_to?(:loc)
+          node_or_range.loc.line
+        end
+      end
+
       def same_line?(node1, node2)
-        node1.respond_to?(:loc) && node2.respond_to?(:loc) && node1.loc.line == node2.loc.line
+        line1 = line(node1)
+        line2 = line(node2)
+        line1 && line2 && line1 == line2
       end
 
-      def indent(node)
-        ' ' * node.loc.column
+      def indent(node, offset: 0)
+        ' ' * (node.loc.column + offset)
       end
 
       def to_supported_styles(enforced_style)

data/lib/rubocop/cop/variable_force/assignment.rb

@@ -83,7 +83,7 @@ module RuboCop
         end
 
         def multiple_assignment_node
-          grandparent_node = node.parent ? node.parent.parent : nil
+          grandparent_node = node.parent&.parent
           return nil unless grandparent_node
           return nil unless grandparent_node.type == MULTIPLE_ASSIGNMENT_TYPE
           return nil unless node.parent.type == MULTIPLE_LEFT_HAND_SIDE_TYPE

data/lib/rubocop/cop/variable_force/branch.rb

@@ -127,7 +127,7 @@ module RuboCop
           alias_method :eql?, :==
 
           def hash
-            control_node.object_id.hash ^ child_node.object_id.hash
+            [control_node.object_id, control_node.object_id].hash
           end
 
           private

data/lib/rubocop/cop/variable_force/variable_table.rb

@@ -109,7 +109,7 @@ module RuboCop
         end
 
         def accessible_variables
-          scope_stack.reverse_each.each_with_object([]) do |scope, variables|
+          scope_stack.reverse_each.with_object([]) do |scope, variables|
             variables.concat(scope.variables.values)
             break variables unless scope.node.block_type?
           end

data/lib/rubocop/cop/variable_force.rb

@@ -108,34 +108,26 @@ module RuboCop
         :skip_children
       end
 
-      # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+      # rubocop:disable Layout/ClassStructure
+      NODE_HANDLER_METHOD_NAMES = [
+        [VARIABLE_ASSIGNMENT_TYPE, :process_variable_assignment],
+        [REGEXP_NAMED_CAPTURE_TYPE, :process_regexp_named_captures],
+        [MULTIPLE_ASSIGNMENT_TYPE, :process_variable_multiple_assignment],
+        [VARIABLE_REFERENCE_TYPE, :process_variable_referencing],
+        [RESCUE_TYPE, :process_rescue],
+        [ZERO_ARITY_SUPER_TYPE, :process_zero_arity_super],
+        [SEND_TYPE, :process_send],
+        *ARGUMENT_DECLARATION_TYPES.product([:process_variable_declaration]),
+        *OPERATOR_ASSIGNMENT_TYPES.product([:process_variable_operator_assignment]),
+        *LOOP_TYPES.product([:process_loop]),
+        *SCOPE_TYPES.product([:process_scope])
+      ].to_h.freeze
+      private_constant :NODE_HANDLER_METHOD_NAMES
+      # rubocop:enable Layout/ClassStructure
+
       def node_handler_method_name(node)
-        case node.type
-        when VARIABLE_ASSIGNMENT_TYPE
-          :process_variable_assignment
-        when REGEXP_NAMED_CAPTURE_TYPE
-          :process_regexp_named_captures
-        when MULTIPLE_ASSIGNMENT_TYPE
-          :process_variable_multiple_assignment
-        when VARIABLE_REFERENCE_TYPE
-          :process_variable_referencing
-        when RESCUE_TYPE
-          :process_rescue
-        when ZERO_ARITY_SUPER_TYPE
-          :process_zero_arity_super
-        when SEND_TYPE
-          :process_send
-        when *ARGUMENT_DECLARATION_TYPES
-          :process_variable_declaration
-        when *OPERATOR_ASSIGNMENT_TYPES
-          :process_variable_operator_assignment
-        when *LOOP_TYPES
-          :process_loop
-        when *SCOPE_TYPES
-          :process_scope
-        end
+        NODE_HANDLER_METHOD_NAMES[node.type]
       end
-      # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
 
       def process_variable_declaration(node)
         variable_name = node.children.first
@@ -186,11 +178,7 @@ module RuboCop
       end
 
       def regexp_captured_names(node)
-        regexp_string = node.children.select(&:str_type?).map do |child|
-          child.children.first
-        end.join || ''
-
-        regexp = Regexp.new(regexp_string)
+        regexp = node.to_regexp
 
         regexp.named_captures.keys
       end
@@ -362,13 +350,12 @@ module RuboCop
         end
       end
 
-      # Use Node#equal? for accurate check.
       def scanned_node?(node)
-        scanned_nodes.any? { |scanned_node| scanned_node.equal?(node) }
+        scanned_nodes.include?(node)
       end
 
       def scanned_nodes
-        @scanned_nodes ||= []
+        @scanned_nodes ||= Set.new.compare_by_identity
       end
 
       # Hooks invoked by VariableTable.

data/lib/rubocop/cops_documentation_generator.rb

@@ -33,17 +33,35 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     cops.with_department(department).sort!
   end
 
-  def cops_body(cop, description, examples_objects, pars)
+  def cops_body(cop, description, examples_objects, safety_objects, pars) # rubocop:disable Metrics/AbcSize
+    check_examples_to_have_the_default_enforced_style!(examples_objects, cop)
+
     content = h2(cop.cop_name)
     content << required_ruby_version(cop)
     content << properties(cop)
     content << "#{description}\n"
-    content << examples(examples_objects) if examples_objects.count.positive?
+    content << safety_object(safety_objects) if safety_objects.any? { |s| !s.text.blank? }
+    content << examples(examples_objects) if examples_objects.any?
     content << configurations(pars)
     content << references(cop)
     content
   end
 
+  def check_examples_to_have_the_default_enforced_style!(examples_object, cop)
+    return if examples_object.none?
+
+    examples_describing_enforced_style = examples_object.map(&:name).grep(/EnforcedStyle:/)
+    return if examples_describing_enforced_style.none?
+
+    if examples_describing_enforced_style.index { |name| name.match?('default') }.nonzero?
+      raise "Put the example with the default EnforcedStyle on top for #{cop.cop_name}"
+    end
+
+    return if examples_describing_enforced_style.any? { |name| name.match?('default') }
+
+    raise "Specify the default EnforcedStyle for #{cop.cop_name}"
+  end
+
   def examples(examples_object)
     examples_object.each_with_object(h3('Examples').dup) do |example, content|
       content << "\n" unless content.end_with?("\n\n")
@@ -52,6 +70,16 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     end
   end
 
+  def safety_object(safety_object_objects)
+    safety_object_objects.each_with_object(h3('Safety').dup) do |safety_object, content|
+      next if safety_object.text.blank?
+
+      content << "\n" unless content.end_with?("\n\n")
+      content << safety_object.text
+      content << "\n"
+    end
+  end
+
   def required_ruby_version(cop)
     return '' unless cop.respond_to?(:required_minimum_ruby_version)
 
@@ -61,8 +89,8 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
   # rubocop:disable Metrics/MethodLength
   def properties(cop)
     header = [
-      'Enabled by default', 'Safe', 'Supports autocorrection', 'VersionAdded',
-      'VersionChanged'
+      'Enabled by default', 'Safe', 'Supports autocorrection', 'Version Added',
+      'Version Changed'
     ]
     autocorrect = if cop.support_autocorrect?
                     "Yes#{' (Unsafe)' unless cop.new(config).safe_autocorrect?}"
@@ -157,7 +185,8 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
   def to_table(header, content)
     table = ['|===', "| #{header.join(' | ')}\n\n"].join("\n")
     marked_contents = content.map do |plain_content|
-      plain_content.map { |c| "| #{c}" }.join("\n")
+      # Escape `|` with backslash to prevent the regexp `|` is not used as a table separator.
+      plain_content.map { |c| "| #{c.gsub(/\|/, '\|')}" }.join("\n")
     end
     table << marked_contents.join("\n\n")
     table << "\n|===\n"
@@ -180,8 +209,8 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
 
   def wrap_backtick(value)
     if value.is_a?(String)
-      # Use `+` to prevent text like `**/*.gemspec` from being bold.
-      value.start_with?('*') ? "`+#{value}+`" : "`#{value}`"
+      # Use `+` to prevent text like `**/*.gemspec`, `spec/**/*` from being bold.
+      value.include?('*') ? "`+#{value}+`" : "`#{value}`"
     else
       "`#{value}`"
     end
@@ -217,12 +246,13 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
     ]
     pars = cop_config.reject { |k| non_display_keys.include? k }
     description = 'No documentation'
-    examples_object = []
+    examples_object = safety_object = []
     cop_code(cop) do |code_object|
       description = code_object.docstring unless code_object.docstring.blank?
       examples_object = code_object.tags('example')
+      safety_object = code_object.tags('safety')
     end
-    cops_body(cop, description, examples_object, pars)
+    cops_body(cop, description, examples_object, safety_object, pars)
   end
 
   def cop_code(cop)
@@ -234,7 +264,7 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
   end
 
   def table_of_content_for_department(department)
-    type_title = department[0].upcase + department[1..-1]
+    type_title = department[0].upcase + department[1..]
     filename = "#{department_to_basename(department)}.adoc"
     content = +"=== Department xref:#{filename}[#{type_title}]\n\n"
     cops_of_department(department).each do |cop|

data/lib/rubocop/ext/processed_source.rb

@@ -4,6 +4,8 @@ module RuboCop
   module Ext
     # Extensions to AST::ProcessedSource for our cached comment_config
     module ProcessedSource
+      attr_accessor :registry, :config
+
       def comment_config
         @comment_config ||= CommentConfig.new(self)
       end

data/lib/rubocop/ext/range.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Ext
+    # Extensions to Parser::Source::Range
+    module Range
+      # Adds `Range#single_line?` to parallel `Node#single_line?`
+      def single_line?
+        first_line == last_line
+      end
+    end
+  end
+end
+
+Parser::Source::Range.include RuboCop::Ext::Range

data/lib/rubocop/feature_loader.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # This class handles loading files (a.k.a. features in Ruby) specified
+  # by `--require` command line option and `require` directive in the config.
+  #
+  # Normally, the given string is directly passed to `require`. If a string
+  # beginning with `.` is given, it is assumed to be relative to the given
+  # directory.
+  #
+  # If a string containing `-` is given, it will be used as is, but if we
+  # cannot find the file to load, we will replace `-` with `/` and try it
+  # again as when Bundler loads gems.
+  #
+  # @api private
+  class FeatureLoader
+    class << self
+      # @param [String] config_directory_path
+      # @param [String] feature
+      def load(config_directory_path:, feature:)
+        new(config_directory_path: config_directory_path, feature: feature).load
+      end
+    end
+
+    # @param [String] config_directory_path
+    # @param [String] feature
+    def initialize(config_directory_path:, feature:)
+      @config_directory_path = config_directory_path
+      @feature = feature
+    end
+
+    def load
+      # Don't use `::Kernel.require(target)` to prevent the following error:
+      # https://github.com/rubocop/rubocop/issues/10893
+      require(target)
+    rescue ::LoadError => e
+      raise if e.path != target
+
+      begin
+        # Don't use `::Kernel.require(target)` to prevent the following error:
+        # https://github.com/rubocop/rubocop/issues/10893
+        require(namespaced_target)
+      rescue ::LoadError => error_for_namespaced_target
+        # NOTE: This wrap is necessary due to JRuby 9.3.4.0 incompatibility:
+        # https://github.com/jruby/jruby/issues/7316
+        raise LoadError, e if error_for_namespaced_target.path == namespaced_target
+
+        raise error_for_namespaced_target
+      end
+    end
+
+    private
+
+    # @return [String]
+    def namespaced_feature
+      @feature.tr('-', '/')
+    end
+
+    # @return [String]
+    def namespaced_target
+      if relative?
+        relative(namespaced_feature)
+      else
+        namespaced_feature
+      end
+    end
+
+    # @param [String]
+    # @return [String]
+    def relative(feature)
+      ::File.join(@config_directory_path, feature)
+    end
+
+    # @return [Boolean]
+    def relative?
+      @feature.start_with?('.')
+    end
+
+    # @param [LoadError] error
+    # @return [Boolean]
+    def seems_cannot_load_such_file_error?(error)
+      error.path == target
+    end
+
+    # @return [String]
+    def target
+      if relative?
+        relative(@feature)
+      else
+        @feature
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/clang_style_formatter.rb

@@ -41,7 +41,7 @@ module RuboCop
       def report_line(location)
         source_line = location.source_line
 
-        if location.first_line == location.last_line
+        if location.single_line?
           output.puts(source_line)
         else
           output.puts("#{source_line} #{yellow(ELLIPSES)}")

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -65,18 +65,26 @@ module RuboCop
         @options.fetch(:offense_counts, true)
       end
 
+      def auto_gen_enforced_style?
+        @options.fetch(:auto_gen_enforced_style, true)
+      end
+
       def command
         command = 'rubocop --auto-gen-config'
 
         command += ' --auto-gen-only-exclude' if @options[:auto_gen_only_exclude]
 
-        if @exclude_limit_option
+        if no_exclude_limit?
+          command += ' --no-exclude-limit'
+        elsif @exclude_limit_option
           command += format(' --exclude-limit %<limit>d', limit: Integer(@exclude_limit_option))
         end
         command += ' --no-offense-counts' unless show_offense_counts?
 
         command += ' --no-auto-gen-timestamp' unless show_timestamp?
 
+        command += ' --no-auto-gen-enforced-style' unless auto_gen_enforced_style?
+
         command
       end
 
@@ -121,9 +129,14 @@ module RuboCop
         output_buffer.puts "# Offense count: #{offense_count}" if show_offense_counts?
 
         cop_class = Cop::Registry.global.find_by_cop_name(cop_name)
-        output_buffer.puts '# Cop supports --auto-correct.' if cop_class&.support_autocorrect?
-
         default_cfg = default_config(cop_name)
+
+        if supports_safe_autocorrect?(cop_class, default_cfg)
+          output_buffer.puts '# This cop supports safe autocorrection (--autocorrect).'
+        elsif supports_unsafe_autocorrect?(cop_class, default_cfg)
+          output_buffer.puts '# This cop supports unsafe autocorrection (--autocorrect-all).'
+        end
+
         return unless default_cfg
 
         params = cop_config_params(default_cfg, cfg)
@@ -132,6 +145,14 @@ module RuboCop
         output_cop_param_comments(output_buffer, params, default_cfg)
       end
 
+      def supports_safe_autocorrect?(cop_class, default_cfg)
+        cop_class&.support_autocorrect? && (default_cfg.nil? || safe_autocorrect?(default_cfg))
+      end
+
+      def supports_unsafe_autocorrect?(cop_class, default_cfg)
+        cop_class&.support_autocorrect? && !safe_autocorrect?(default_cfg)
+      end
+
       def cop_config_params(default_cfg, cfg)
         default_cfg.keys -
           %w[Description StyleGuide Reference Enabled Exclude Safe
@@ -148,7 +169,7 @@ module RuboCop
           next unless value.is_a?(Array)
           next if value.empty?
 
-          output_buffer.puts "# #{param}: #{value.join(', ')}"
+          output_buffer.puts "# #{param}: #{value.uniq.join(', ')}"
         end
       end
 
@@ -157,24 +178,29 @@ module RuboCop
       end
 
       def output_cop_config(output_buffer, cfg, cop_name)
-        # 'Enabled' option will be put into file only if exclude
-        # limit is exceeded.
-        cfg_without_enabled = cfg.reject { |key| key == 'Enabled' }
-
+        filtered_cfg = filtered_config(cfg)
         output_buffer.puts "#{cop_name}:"
-        cfg_without_enabled.each do |key, value|
+        filtered_cfg.each do |key, value|
           value = value[0] if value.is_a?(Array)
           output_buffer.puts "  #{key}: #{value}"
         end
 
-        output_offending_files(output_buffer, cfg_without_enabled, cop_name)
+        output_offending_files(output_buffer, filtered_cfg, cop_name)
+      end
+
+      def filtered_config(cfg)
+        # 'Enabled' option will be put into file only if exclude
+        # limit is exceeded.
+        rejected_keys = ['Enabled']
+        rejected_keys << 'EnforcedStyle' unless auto_gen_enforced_style?
+        cfg.reject { |key| rejected_keys.include?(key) }
       end
 
       def output_offending_files(output_buffer, cfg, cop_name)
         return unless cfg.empty?
 
         offending_files = @files_with_offenses[cop_name].sort
-        if offending_files.count > @exclude_limit
+        if !no_exclude_limit? && offending_files.count > @exclude_limit
           output_buffer.puts '  Enabled: false'
         else
           output_exclude_list(output_buffer, offending_files, cop_name)
@@ -228,6 +254,14 @@ module RuboCop
         regexp = exclude_path
         output_buffer.puts "    - !ruby/regexp /#{regexp.source}/"
       end
+
+      def safe_autocorrect?(config)
+        config.fetch('Safe', true) && config.fetch('SafeAutoCorrect', true)
+      end
+
+      def no_exclude_limit?
+        @options[:no_exclude_limit] == false
+      end
     end
   end
 end