rubocop 0.51.0 → 0.87.0

data/lib/rubocop/cop/rails/skips_model_validations.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for the use of methods which skip
-      # validations which are listed in
-      # http://guides.rubyonrails.org/active_record_validations.html#skipping-validations
-      #
-      # @example
-      #   # bad
-      #   Article.first.decrement!(:view_count)
-      #   DiscussionBoard.decrement_counter(:post_count, 5)
-      #   Article.first.increment!(:view_count)
-      #   DiscussionBoard.increment_counter(:post_count, 5)
-      #   person.toggle :active
-      #   product.touch
-      #   Billing.update_all("category = 'authorized', author = 'David'")
-      #   user.update_attribute(website: 'example.com')
-      #   user.update_columns(last_request_at: Time.current)
-      #   Post.update_counters 5, comment_count: -1, action_count: 1
-      #
-      #   # good
-      #   user.update_attributes(website: 'example.com')
-      #   FileUtils.touch('file')
-      class SkipsModelValidations < Cop
-        MSG = 'Avoid using `%s` because it skips validations.'.freeze
-
-        METHODS_WITH_ARGUMENTS = %w[decrement!
-                                    decrement_counter
-                                    increment!
-                                    increment_counter
-                                    toggle!
-                                    update_all
-                                    update_attribute
-                                    update_column
-                                    update_columns
-                                    update_counters].freeze
-
-        def_node_matcher :good_touch?, <<-PATTERN
-          (send (const nil? :FileUtils) :touch ...)
-        PATTERN
-
-        def on_send(node)
-          return unless blacklist.include?(node.method_name.to_s)
-
-          _receiver, method_name, *args = *node
-
-          if METHODS_WITH_ARGUMENTS.include?(method_name.to_s) && args.empty?
-            return
-          end
-
-          return if good_touch?(node)
-
-          add_offense(node, location: :selector)
-        end
-
-        private
-
-        def message(node)
-          format(MSG, node.method_name)
-        end
-
-        def blacklist
-          cop_config['Blacklist'] || []
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/rails/time_zone.rb

@@ -1,198 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for the use of Time methods without zone.
-      #
-      # Built on top of Ruby on Rails style guide (https://github.com/bbatsov/rails-style-guide#time)
-      # and the article http://danilenko.org/2012/7/6/rails_timezones/ .
-      #
-      # Two styles are supported for this cop. When EnforcedStyle is 'strict'
-      # then only use of Time.zone is allowed.
-      #
-      # When EnforcedStyle is 'flexible' then it's also allowed
-      # to use Time.in_time_zone.
-      #
-      # @example
-      #   # always offense
-      #   Time.now
-      #   Time.parse('2015-03-02 19:05:37')
-      #
-      #   # no offense
-      #   Time.zone.now
-      #   Time.zone.parse('2015-03-02 19:05:37')
-      #
-      #   # no offense only if style is 'flexible'
-      #   Time.current
-      #   DateTime.strptime(str, "%Y-%m-%d %H:%M %Z").in_time_zone
-      #   Time.at(timestamp).in_time_zone
-      class TimeZone < Cop
-        include ConfigurableEnforcedStyle
-
-        MSG = 'Do not use `%s` without zone. Use `%s` instead.'.freeze
-
-        MSG_ACCEPTABLE = 'Do not use `%s` without zone. ' \
-                         'Use one of %s instead.'.freeze
-
-        MSG_LOCALTIME = 'Do not use `Time.localtime` without ' \
-                        'offset or zone.'.freeze
-
-        MSG_CURRENT = 'Do not use `%s`. Use `Time.zone.now` instead.'.freeze
-
-        TIMECLASS = %i[Time DateTime].freeze
-
-        GOOD_METHODS = %i[zone zone_default find_zone find_zone!].freeze
-
-        DANGEROUS_METHODS = %i[now local new strftime
-                               parse at current].freeze
-
-        ACCEPTED_METHODS = %i[in_time_zone utc getlocal
-                              iso8601 jisx0301 rfc3339
-                              to_i to_f].freeze
-
-        def on_const(node)
-          mod, klass = *node
-          # we should only check core class
-          # (`DateTime`/`Time` or `::Date`/`::DateTime`)
-          return unless (mod.nil? || mod.cbase_type?) && method_send?(node)
-
-          check_time_node(klass, node.parent) if TIMECLASS.include?(klass)
-        end
-
-        private
-
-        def check_time_node(klass, node)
-          chain = extract_method_chain(node)
-          return if danger_chain?(chain)
-
-          return check_localtime(node) if need_check_localtime?(chain)
-
-          method_name = (chain & DANGEROUS_METHODS).join('.')
-
-          return if offset_provided?(node)
-
-          message = build_message(klass, method_name, node)
-
-          add_offense(node, location: :selector, message: message)
-        end
-
-        def build_message(klass, method_name, node)
-          if acceptable?
-            format(MSG_ACCEPTABLE,
-                   "#{klass}.#{method_name}",
-                   acceptable_methods(klass, method_name, node).join(', '))
-          elsif method_name == 'current'
-            format(MSG_CURRENT,
-                   "#{klass}.#{method_name}")
-          else
-            safe_method_name = safe_method(method_name, node)
-            format(MSG,
-                   "#{klass}.#{method_name}",
-                   "Time.zone.#{safe_method_name}")
-          end
-        end
-
-        def extract_method_chain(node)
-          chain = []
-          while !node.nil? && node.send_type?
-            chain << extract_method(node) if method_from_time_class?(node)
-            node = node.parent
-          end
-          chain
-        end
-
-        def extract_method(node)
-          _receiver, method_name, *_args = *node
-          method_name
-        end
-
-        # Only add the method to the chain if the method being
-        # called is part of the time class.
-        def method_from_time_class?(node)
-          receiver, method_name, *_args = *node
-          if (receiver.is_a? RuboCop::AST::Node) && !receiver.cbase_type?
-            method_from_time_class?(receiver)
-          else
-            TIMECLASS.include? method_name
-          end
-        end
-
-        # checks that parent node of send_type
-        # and receiver is the given node
-        def method_send?(node)
-          return false unless node.parent && node.parent.send_type?
-
-          receiver, _method_name, *_args = *node.parent
-
-          receiver == node
-        end
-
-        def safe_method(method_name, node)
-          return method_name unless method_name == 'new'
-
-          if node.arguments?
-            'local'
-          else
-            'now'
-          end
-        end
-
-        def check_localtime(node)
-          selector_node = node
-
-          while node && node.send_type?
-            break if extract_method(node) == :localtime
-            node = node.parent
-          end
-
-          return if node.arguments?
-
-          add_offense(selector_node,
-                      location: :selector, message: MSG_LOCALTIME)
-        end
-
-        def danger_chain?(chain)
-          (chain & DANGEROUS_METHODS).empty? || !(chain & good_methods).empty?
-        end
-
-        def need_check_localtime?(chain)
-          acceptable? && chain.include?(:localtime)
-        end
-
-        def acceptable?
-          style == :flexible
-        end
-
-        def good_methods
-          if style == :strict
-            GOOD_METHODS
-          else
-            GOOD_METHODS + [:current] + ACCEPTED_METHODS
-          end
-        end
-
-        def acceptable_methods(klass, method_name, node)
-          acceptable = [
-            "`Time.zone.#{safe_method(method_name, node)}`",
-            "`#{klass}.current`"
-          ]
-
-          ACCEPTED_METHODS.each do |am|
-            acceptable << "`#{klass}.#{method_name}.#{am}`"
-          end
-
-          acceptable
-        end
-
-        # Time.new can be called with a time zone offset
-        # When it is, that should be considered safe
-        # Example:
-        # Time.new(1988, 3, 15, 3, 0, 0, "-05:00")
-        def offset_provided?(node)
-          node.arguments.size >= 7
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/rails/uniq_before_pluck.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Prefer the use of uniq (or distinct), before pluck instead of after.
-      #
-      # The use of uniq before pluck is preferred because it executes within
-      # the database.
-      #
-      # @example
-      #   # bad
-      #   Model.pluck(:id).uniq
-      #
-      #   # good
-      #   Model.uniq.pluck(:id)
-      #
-      # This cop has two different enforcement modes. When the EnforcedStyle
-      # is conservative (the default) then only calls to pluck on a constant
-      # (i.e. a model class) before uniq are added as offenses.
-      #
-      # When the EnforcedStyle is aggressive then all calls to pluck before
-      # uniq are added as offenses. This may lead to false positives as the cop
-      # cannot distinguish between calls to pluck on an ActiveRecord::Relation
-      # vs a call to pluck on an ActiveRecord::Associations::CollectionProxy.
-      #
-      # @example
-      #   # this will return a Relation that pluck is called on
-      #   Model.where(...).pluck(:id).uniq
-      #
-      #   # an association on an instance will return a CollectionProxy
-      #   instance.assoc.pluck(:id).uniq
-      #
-      # Autocorrect is disabled by default for this cop since it may generate
-      # false positives.
-      #
-      class UniqBeforePluck < RuboCop::Cop::Cop
-        include ConfigurableEnforcedStyle
-
-        MSG = 'Use `%s` before `pluck`.'.freeze
-        NEWLINE = "\n".freeze
-        PATTERN = '[!^block (send (send %s :pluck ...) ${:uniq :distinct} ...)]'
-                  .freeze
-
-        def_node_matcher :conservative_node_match,
-                         format(PATTERN, 'const')
-
-        def_node_matcher :aggressive_node_match,
-                         format(PATTERN, '_')
-
-        def on_send(node)
-          method = if style == :conservative
-                     conservative_node_match(node)
-                   else
-                     aggressive_node_match(node)
-                   end
-
-          return unless method
-
-          add_offense(node, location: :selector, message: format(MSG, method))
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            method = node.method_name
-
-            corrector.remove(dot_method_with_whitespace(method, node))
-            corrector.insert_before(node.receiver.loc.dot.begin, ".#{method}")
-          end
-        end
-
-        private
-
-        def style_parameter_name
-          'EnforcedStyle'
-        end
-
-        def dot_method_with_whitespace(method, node)
-          range_between(dot_method_begin_pos(method, node),
-                        node.loc.selector.end_pos)
-        end
-
-        def dot_method_begin_pos(method, node)
-          lines = node.source.split(NEWLINE)
-
-          if lines.last.strip == ".#{method}"
-            node.source.rindex(NEWLINE)
-          else
-            node.loc.dot.begin_pos
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/rails/unknown_env.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks that environments called with `Rails.env` predicates
-      # exist.
-      #
-      # @example
-      #   # bad
-      #   Rails.env.proudction?
-      #
-      #   # good
-      #   Rails.env.production?
-      class UnknownEnv < Cop
-        include NameSimilarity
-
-        MSG = 'Unknown environment `%<name>s`.'.freeze
-        MSG_SIMILAR = 'Unknown environment `%<name>s`. ' \
-                      'Did you mean `%<similar>s`?'.freeze
-
-        def_node_matcher :unknown_environment?, <<-PATTERN
-          (send
-            (send
-              {(const nil? :Rails) (const (cbase) :Rails)}
-              :env)
-            $#unknown_env_name?)
-        PATTERN
-
-        def on_send(node)
-          unknown_environment?(node) do |name|
-            add_offense(node, location: :selector, message: message(name))
-          end
-        end
-
-        private
-
-        def collect_variable_like_names(_scope)
-          environments.map { |env| env + '?' }
-        end
-
-        def message(name)
-          similar = find_similar_name(name.to_s, [])
-          if similar
-            format(MSG_SIMILAR, name: name, similar: similar)
-          else
-            format(MSG, name: name)
-          end
-        end
-
-        def unknown_env_name?(name)
-          name = name.to_s
-          name.end_with?('?') &&
-            !environments.include?(name[0..-2])
-        end
-
-        def environments
-          cop_config['Environments']
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/rails/validation.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for the use of old-style attribute validation macros.
-      class Validation < Cop
-        MSG = 'Prefer the new style validations `%s` over `%s`.'.freeze
-
-        TYPES = %w[
-          acceptance
-          confirmation
-          exclusion
-          format
-          inclusion
-          length
-          numericality
-          presence
-          size
-          uniqueness
-        ].freeze
-
-        BLACKLIST = TYPES.map { |p| "validates_#{p}_of".to_sym }.freeze
-        WHITELIST = TYPES.map { |p| "validates :column, #{p}: value" }.freeze
-
-        def on_send(node)
-          return unless !node.receiver && BLACKLIST.include?(node.method_name)
-
-          add_offense(node, location: :selector)
-        end
-
-        private
-
-        def message(node)
-          format(MSG, preferred_method(node.method_name), node.method_name)
-        end
-
-        def preferred_method(method)
-          WHITELIST[BLACKLIST.index(method.to_sym)]
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector, 'validates')
-            correct_validate_type(corrector, node)
-          end
-        end
-
-        def correct_validate_type(corrector, node)
-          options = node.arguments.find { |arg| !arg.sym_type? }
-          validate_type = node.method_name.to_s.split('_')[1]
-
-          if options
-            corrector.replace(options.loc.expression,
-                              "#{validate_type}: { #{options.source} }")
-          else
-            corrector.insert_after(node.loc.expression,
-                                   ", #{validate_type}: true")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for braces around the last parameter in a method call
-      # if the last parameter is a hash.
-      # It supports 3 styles:
-      #
-      # * The `braces` style enforces braces around all method
-      # parameters that are hashes.
-      #
-      #     ```
-      #     # bad
-      #     some_method(x, y, a: 1, b: 2)
-      #
-      #     # good
-      #     some_method(x, y, {a: 1, b: 2})
-      #     ```
-      #
-      # * The `no_braces` style checks that the last parameter doesn't
-      # have braces around it.
-      #
-      #     ```
-      #     # bad
-      #     some_method(x, y, {a: 1, b: 2})
-      #
-      #     # good
-      #     some_method(x, y, a: 1, b: 2)
-      #     ```
-      #
-      # * The `context_dependent` style checks that the last parameter
-      # doesn't have braces around it, but requires braces if the
-      # second to last parameter is also a hash literal.
-      #
-      #     ```
-      #     # bad
-      #     some_method(x, y, {a: 1, b: 2})
-      #     some_method(x, y, {a: 1, b: 2}, a: 1, b: 2)
-      #
-      #     # good
-      #     some_method(x, y, a: 1, b: 2)
-      #     some_method(x, y, {a: 1, b: 2}, {a: 1, b: 2})
-      #     ```
-      class BracesAroundHashParameters < Cop
-        include ConfigurableEnforcedStyle
-
-        MSG = '%s curly braces around a hash parameter.'.freeze
-
-        def on_send(node)
-          return if node.assignment_method? || node.operator_method?
-
-          return unless node.arguments? && node.last_argument.hash_type? &&
-                        !node.last_argument.empty?
-
-          check(node.last_argument, node.arguments)
-        end
-
-        private
-
-        def check(arg, args)
-          if style == :braces && !arg.braces?
-            add_arg_offense(arg, :missing)
-          elsif style == :no_braces && arg.braces?
-            add_arg_offense(arg, :redundant)
-          elsif style == :context_dependent
-            check_context_dependent(arg, args)
-          end
-        end
-
-        def check_context_dependent(arg, args)
-          braces_around_second_from_end = args.size > 1 && args[-2].hash_type?
-
-          if arg.braces?
-            unless braces_around_second_from_end
-              add_arg_offense(arg, :redundant)
-            end
-          elsif braces_around_second_from_end
-            add_arg_offense(arg, :missing)
-          end
-        end
-
-        def add_arg_offense(arg, type)
-          add_offense(arg.parent, location: arg.source_range,
-                                  message: format(MSG, type.to_s.capitalize))
-        end
-
-        # We let AutocorrectUnlessChangingAST#autocorrect work with the send
-        # node, because that context is needed. When parsing the code to see if
-        # the AST has changed, a braceless hash would not be parsed as a hash
-        # otherwise.
-        def autocorrect(send_node)
-          hash_node = send_node.last_argument
-
-          lambda do |corrector|
-            if hash_node.braces?
-              remove_braces_with_whitespace(corrector, hash_node)
-            else
-              add_braces(corrector, hash_node)
-            end
-          end
-        end
-
-        def remove_braces_with_whitespace(corrector, node)
-          right_brace_and_space = right_brace_and_space(node.loc.end)
-
-          if comment_on_line?(right_brace_and_space.line)
-            # Removing a line break between a comment and the closing
-            # parenthesis would cause a syntax error, so we only remove the
-            # braces in that case.
-            remove_braces(corrector, node)
-          else
-            left_brace_and_space = range_with_surrounding_space(node.loc.begin,
-                                                                :right)
-            corrector.remove(left_brace_and_space)
-            corrector.remove(right_brace_and_space)
-          end
-        end
-
-        def right_brace_and_space(loc_end)
-          brace_and_space = range_with_surrounding_space(loc_end, :left)
-          range_with_surrounding_comma(brace_and_space, :left)
-        end
-
-        def comment_on_line?(line)
-          processed_source.comments.any? { |c| c.loc.line == line }
-        end
-
-        def remove_braces(corrector, node)
-          corrector.remove(node.loc.begin)
-          corrector.remove(node.loc.end)
-        end
-
-        def add_braces(corrector, node)
-          corrector.insert_before(node.source_range, '{')
-          corrector.insert_after(node.source_range, '}')
-        end
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop looks for uses of flip flop operator
-      class FlipFlop < Cop
-        MSG = 'Avoid the use of flip flop operators.'.freeze
-
-        def on_iflipflop(node)
-          add_offense(node)
-        end
-
-        def on_eflipflop(node)
-          add_offense(node)
-        end
-      end
-    end
-  end
-end