rubbycop 0.49.0

data/lib/rubbycop/cop/rails/read_write_attribute.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Rails
+      # This cop checks for the use of the read_attribute or
+      # write_attribute methods.
+      #
+      # @example
+      #
+      #   # bad
+      #   x = read_attribute(:attr)
+      #   write_attribute(:attr, val)
+      #
+      #   # good
+      #   x = self[:attr]
+      #   self[:attr] = val
+      class ReadWriteAttribute < Cop
+        MSG = 'Prefer `%s` over `%s`.'.freeze
+
+        def_node_matcher :read_write_attribute?, <<-PATTERN
+          {
+            (send nil :read_attribute _)
+            (send nil :write_attribute _ _)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless read_write_attribute?(node)
+
+          add_offense(node, :selector)
+        end
+
+        private
+
+        def message(node)
+          if node.method?(:read_attribute)
+            format(MSG, 'self[:attr]', 'read_attribute(:attr)')
+          else
+            format(MSG, 'self[:attr] = val', 'write_attribute(:attr, val)')
+          end
+        end
+
+        def autocorrect(node)
+          case node.method_name
+          when :read_attribute
+            replacement = read_attribute_replacement(node)
+          when :write_attribute
+            replacement = write_attribute_replacement(node)
+          end
+
+          ->(corrector) { corrector.replace(node.source_range, replacement) }
+        end
+
+        def read_attribute_replacement(node)
+          "self[#{node.first_argument.source}]"
+        end
+
+        def write_attribute_replacement(node)
+          "self[#{node.first_argument.source}] = #{node.last_argument.source}"
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/rails/relative_date_constant.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Rails
+      # This cop checks whether constant value isn't relative date.
+      # Because the relative date will be evaluated only once.
+      #
+      # @example
+      #   # bad
+      #   class SomeClass
+      #     EXPIRED_AT = 1.week.since
+      #   end
+      #
+      #   # good
+      #   class SomeClass
+      #     def self.expired_at
+      #       1.week.since
+      #     end
+      #   end
+      class RelativeDateConstant < Cop
+        MSG = 'Do not assign %s to constants as it will be evaluated only ' \
+              'once.'.freeze
+
+        RELATIVE_DATE_METHODS = %i[ago from_now since until].freeze
+
+        def on_casgn(node)
+          _scope, _constant, rhs = *node
+
+          # rhs would be nil in a or_asgn node
+          return unless rhs
+
+          check_node(rhs)
+        end
+
+        def on_masgn(node)
+          lhs, rhs = *node
+
+          return unless rhs && rhs.array_type?
+
+          lhs.children.zip(rhs.children).each do |(name, value)|
+            check_node(value) if name.casgn_type?
+          end
+        end
+
+        def on_or_asgn(node)
+          lhs, rhs = *node
+
+          return unless lhs.casgn_type?
+
+          check_node(rhs)
+        end
+
+        private
+
+        def check_node(node)
+          return unless node.irange_type? ||
+                        node.erange_type? ||
+                        node.send_type?
+
+          # for range nodes we need to check both their boundaries
+          nodes = node.send_type? ? [node] : node.children
+
+          nodes.each do |n|
+            if relative_date_method?(n)
+              add_offense(node.parent, :expression, format(MSG, n.method_name))
+            end
+          end
+        end
+
+        def relative_date_method?(node)
+          node.send_type? &&
+            RELATIVE_DATE_METHODS.include?(node.method_name) &&
+            node.method_args.empty?
+        end
+
+        def autocorrect(node)
+          _scope, const_name, value = *node
+          indent = ' ' * node.loc.column
+          new_code = ["def self.#{const_name.downcase}",
+                      "#{indent}#{value.source}",
+                      'end'].join("\n#{indent}")
+          ->(corrector) { corrector.replace(node.source_range, new_code) }
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/rails/request_referer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Rails
+      # This cop checks for consistent uses of `request.referer` or
+      # `request.referrer`, depending on the cop's configuration.
+      #
+      # @example
+      #   # EnforcedStyle: referer
+      #   # bad
+      #   request.referrer
+      #
+      #   # good
+      #   request.referer
+      #
+      #   # EnforcedStyle: referrer
+      #   # bad
+      #   request.referer
+      #
+      #   # good
+      #   request.referrer
+      class RequestReferer < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Use `request.%s` instead of `request.%s`.'.freeze
+
+        def_node_matcher :referer?, <<-PATTERN
+          (send (send nil :request) {:referer :referrer})
+        PATTERN
+
+        def on_send(node)
+          referer?(node) do
+            return unless node.method?(wrong_method_name)
+
+            add_offense(node.source_range, node.source_range, message)
+          end
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node, "request.#{style}") }
+        end
+
+        private
+
+        def message
+          format(MSG, style, wrong_method_name)
+        end
+
+        def wrong_method_name
+          style == :referer ? :referrer : :referer
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/rails/reversible_migration.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Rails
+      # This cop checks whether the change method of the migration file is
+      # reversible.
+      #
+      # @example
+      #   # bad
+      #   def change
+      #     change_table :users do |t|
+      #       t.column :name, :string
+      #     end
+      #   end
+      #
+      #   # good
+      #   def change
+      #     create_table :users do |t|
+      #       t.string :name
+      #     end
+      #   end
+      #
+      #   # good
+      #   def change
+      #     reversible do |dir|
+      #       change_table :users do |t|
+      #         dir.up do
+      #           t.column :name, :string
+      #         end
+      #
+      #         dir.down do
+      #           t.remove :name
+      #         end
+      #       end
+      #     end
+      #   end
+      #
+      # @example
+      #   # drop_table
+      #
+      #   # bad
+      #   def change
+      #     drop_table :users
+      #   end
+      #
+      #   # good
+      #   def change
+      #     drop_table :users do |t|
+      #       t.string :name
+      #     end
+      #   end
+      #
+      # @example
+      #   # change_column_default
+      #
+      #   # bad
+      #   def change
+      #     change_column_default(:suppliers, :qualification, 'new')
+      #   end
+      #
+      #   # good
+      #   def change
+      #     change_column_default(:posts, :state, from: nil, to: "draft")
+      #   end
+      #
+      # @example
+      #   # remove_column
+      #
+      #   # bad
+      #   def change
+      #     remove_column(:suppliers, :qualification)
+      #   end
+      #
+      #   # good
+      #   def change
+      #     remove_column(:suppliers, :qualification, :string)
+      #   end
+      #
+      # @example
+      #   # remove_foreign_key
+      #
+      #   # bad
+      #   def change
+      #     remove_foreign_key :accounts, column: :owner_id
+      #   end
+      #
+      #   # good
+      #   def change
+      #     remove_foreign_key :accounts, :branches
+      #   end
+      #
+      # @see http://api.rubyonrails.org/classes/ActiveRecord/Migration/CommandRecorder.html
+      class ReversibleMigration < Cop
+        MSG = '%s is not reversible.'.freeze
+
+        def_node_matcher :irreversible_schema_statement_call, <<-END
+          (send nil ${:change_table :change_table_comment :execute :remove_belongs_to} ...)
+        END
+
+        def_node_matcher :drop_table_call, <<-END
+          (send nil :drop_table ...)
+        END
+
+        def_node_matcher :change_column_default_call, <<-END
+          (send nil :change_column_default _ _ $...)
+        END
+
+        def_node_matcher :remove_column_call, <<-END
+          (send nil :remove_column $...)
+        END
+
+        def_node_matcher :remove_foreign_key_call, <<-END
+          (send nil :remove_foreign_key _ $_)
+        END
+
+        def on_send(node)
+          return unless within_change_method?(node)
+          return if within_reversible_block?(node)
+
+          check_irreversible_schema_statement_node(node)
+          check_drop_table_node(node)
+          check_change_column_default_node(node)
+          check_remove_column_node(node)
+          check_remove_foreign_key_node(node)
+        end
+
+        private
+
+        def check_irreversible_schema_statement_node(node)
+          irreversible_schema_statement_call(node) do |method_name|
+            add_offense(node, :expression, format(MSG, method_name))
+          end
+        end
+
+        def check_drop_table_node(node)
+          drop_table_call(node) do
+            unless node.parent.block_type?
+              add_offense(
+                node, :expression,
+                format(MSG, 'drop_table(without block)')
+              )
+            end
+          end
+        end
+
+        def check_change_column_default_node(node)
+          change_column_default_call(node) do |args|
+            unless all_hash_key?(args.first, :from, :to)
+              add_offense(
+                node, :expression,
+                format(MSG, 'change_column_default(without :from and :to)')
+              )
+            end
+          end
+        end
+
+        def check_remove_column_node(node)
+          remove_column_call(node) do |args|
+            if args.to_a.size < 3
+              add_offense(
+                node, :expression,
+                format(MSG, 'remove_column(without type)')
+              )
+            end
+          end
+        end
+
+        def check_remove_foreign_key_node(node)
+          remove_foreign_key_call(node) do |arg|
+            if arg.hash_type?
+              add_offense(
+                node, :expression,
+                format(MSG, 'remove_foreign_key(without table)')
+              )
+            end
+          end
+        end
+
+        def within_change_method?(node)
+          parent = node.parent
+          while parent
+            if parent.def_type?
+              method_name, = *parent
+              return true if method_name == :change
+            end
+            parent = parent.parent
+          end
+          false
+        end
+
+        def within_reversible_block?(node)
+          parent = node.parent
+          while parent
+            if parent.block_type?
+              _, block_name = *parent.to_a.first
+              return true if block_name == :reversible
+            end
+            parent = parent.parent
+          end
+          false
+        end
+
+        def all_hash_key?(args, *keys)
+          return false unless args && args.hash_type?
+
+          hash_keys = args.to_a.map do |arg|
+            arg.to_a.first.children.first.to_sym
+          end
+
+          hash_keys & keys == keys
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/rails/safe_navigation.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Rails
+      # This cop converts usages of `try!` to `&.`. It can also be configured
+      # to convert `try`. It will convert code to use safe navigation if the
+      # target Ruby version is set to 2.3+
+      #
+      # @example
+      #   # ConvertTry: false
+      #     # bad
+      #     foo.try!(:bar)
+      #     foo.try!(:bar, baz)
+      #     foo.try!(:bar) { |e| e.baz }
+      #
+      #     foo.try!(:[], 0)
+      #
+      #     # good
+      #     foo.try(:bar)
+      #     foo.try(:bar, baz)
+      #     foo.try(:bar) { |e| e.baz }
+      #
+      #     foo&.bar
+      #     foo&.bar(baz)
+      #     foo&.bar { |e| e.baz }
+      #
+      #
+      #   # ConvertTry: true
+      #     # bad
+      #     foo.try!(:bar)
+      #     foo.try!(:bar, baz)
+      #     foo.try!(:bar) { |e| e.baz }
+      #     foo.try(:bar)
+      #     foo.try(:bar, baz)
+      #     foo.try(:bar) { |e| e.baz }
+      #
+      #     # good
+      #     foo&.bar
+      #     foo&.bar(baz)
+      #     foo&.bar { |e| e.baz }
+      class SafeNavigation < Cop
+        extend TargetRubyVersion
+
+        MSG = 'Use safe navigation (`&.`) instead of `%s`.'.freeze
+
+        def_node_matcher :try_call, <<-PATTERN
+          (send !nil ${:try :try!} $_ ...)
+        PATTERN
+
+        minimum_target_ruby_version 2.3
+
+        def on_send(node)
+          try_call(node) do |try_method, method_to_try|
+            return if try_method == :try && !cop_config['ConvertTry']
+            return unless method_to_try.sym_type?
+            method, = *method_to_try
+            return unless method =~ /\w+[=!?]?/
+            add_offense(node, :expression, format(MSG, try_method))
+          end
+        end
+
+        private
+
+        def autocorrect(node)
+          method_node, *params = *node.arguments
+          method = method_node.source[1..-1]
+
+          range = range_between(node.loc.dot.begin_pos,
+                                node.loc.expression.end_pos)
+
+          lambda do |corrector|
+            corrector.replace(range, replacement(method, params))
+          end
+        end
+
+        def replacement(method, params)
+          new_params = params.map(&:source).join(', ')
+
+          if method.end_with?('=')
+            "&.#{method[0...-1]} = #{new_params}"
+          elsif params.empty?
+            "&.#{method}"
+          else
+            "&.#{method}(#{new_params})"
+          end
+        end
+      end
+    end
+  end
+end