rubbycop 0.49.0

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Rails
+      # This cop looks for delegations, that could have been created
+      # automatically with delegate method.
+      #
+      # @example
+      #   # bad
+      #   def bar
+      #     foo.bar
+      #   end
+      #
+      #   # good
+      #   delegate :bar, to: :foo
+      #
+      #   # bad
+      #   def foo_bar
+      #     foo.bar
+      #   end
+      #
+      #   # good
+      #   delegate :bar, to: :foo, prefix: true
+      #
+      #   # good
+      #   private
+      #   def bar
+      #     foo.bar
+      #   end
+      class Delegate < Cop
+        MSG = 'Use `delegate` to define delegations.'.freeze
+
+        def on_def(node)
+          method_name, args, body = *node
+          return unless trivial_delegate?(method_name, args, body)
+          return if private_or_protected_delegation(node)
+          add_offense(node, :keyword, MSG)
+        end
+
+        private
+
+        def autocorrect(node)
+          method_name, _args, body = *node
+          delegation = ["delegate :#{body.children[1]}",
+                        "to: :#{body.children[0].children[1]}"]
+          if method_name == prefixed_method_name(body)
+            delegation << ['prefix: true']
+          end
+
+          lambda do |corrector|
+            corrector.replace(node.source_range, delegation.join(', '))
+          end
+        end
+
+        def trivial_delegate?(method_name, args, body)
+          body && delegate?(body) &&
+            method_name_matches?(method_name, body) &&
+            arguments_match?(args, body)
+        end
+
+        def delegate?(body)
+          receiver, = *body
+          receiver.respond_to?(:type) && receiver.send_type? &&
+            receiver.child_nodes.empty?
+        end
+
+        def arguments_match?(args, body)
+          _receiver, _method_name, *arguments = *body
+          arg_array = Array(args)
+          argument_array = Array(arguments)
+          arg_array.size == argument_array.size && (
+            arg_array == argument_array ||
+            arg_array.map(&:children) == argument_array.map(&:children)
+          )
+        end
+
+        def method_name_matches?(method_name, body)
+          _receiver, property_name, *_args = *body
+          method_name == property_name ||
+            method_name == prefixed_method_name(body)
+        end
+
+        def prefixed_method_name(body)
+          receiver, property_name, *_args = *body
+          _receiver, target, *_args = *receiver
+          [target, property_name].join('_').to_sym
+        end
+
+        def private_or_protected_delegation(node)
+          line = node.loc.line
+          private_or_protected_before(line) ||
+            private_or_protected_inline(line)
+        end
+
+        def private_or_protected_before(line)
+          (processed_source[0..line].map(&:strip) & %w[private protected]).any?
+        end
+
+        def private_or_protected_inline(line)
+          processed_source[line - 1].strip =~ /\A(private )|(protected )/
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Rails
+      # This cop looks for delegations that pass :allow_blank as an option
+      # instead of :allow_nil. :allow_blank is not a valid option to pass
+      # to ActiveSupport#delegate.
+      #
+      # @example
+      #   # bad
+      #   delegate :foo, to: :bar, allow_blank: true
+      #
+      #   # good
+      #   delegate :foo, to: :bar, allow_nil: true
+      class DelegateAllowBlank < Cop
+        MSG = '`allow_blank` is not a valid option, use `allow_nil`.'.freeze
+
+        def_node_matcher :delegate_options, <<-PATTERN
+          (send nil :delegate _ $hash)
+        PATTERN
+
+        def_node_matcher :allow_blank_option?, <<-PATTERN
+          (pair (sym :allow_blank) true)
+        PATTERN
+
+        def on_send(node)
+          offending_node = allow_blank_option(node)
+
+          return unless offending_node
+
+          add_offense(offending_node, :expression)
+        end
+
+        private
+
+        def autocorrect(pair_node)
+          lambda do |corrector|
+            corrector.replace(pair_node.key.source_range, 'allow_nil')
+          end
+        end
+
+        def allow_blank_option(node)
+          delegate_options(node) do |hash|
+            hash.pairs.find { |opt| allow_blank_option?(opt) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Rails
+      # This cop checks dynamic `find_by_*` methods.
+      # Use `find_by` instead of dynamic method.
+      # See. https://github.com/searls/rails-style-guide#find_by
+      #
+      # @example
+      #   # bad
+      #   User.find_by_name(name)
+      #
+      #   # bad
+      #   User.find_by_name_and_email(name)
+      #
+      #   # bad
+      #   User.find_by_email!(name)
+      #
+      #   # good
+      #   User.find_by(name: name)
+      #
+      #   # good
+      #   User.find_by(name: name, email: email)
+      #
+      #   # good
+      #   User.find_by!(email: email)
+      class DynamicFindBy < Cop
+        MSG = 'Use `%s` instead of dynamic `%s`.'.freeze
+        METHOD_PATTERN = /^find_by_(.+?)(!)?$/
+
+        def on_send(node)
+          method_name = node.method_name.to_s
+
+          return if whitelist.include?(method_name)
+
+          static_name = static_method_name(method_name)
+
+          return unless static_name
+
+          add_offense(node, :expression,
+                      format(MSG, static_name, node.method_name))
+        end
+
+        def autocorrect(node)
+          _receiver, method, *args = *node
+          static_name = static_method_name(method.to_s)
+          keywords = column_keywords(method)
+
+          return if keywords.size != args.size
+
+          lambda do |corrector|
+            corrector.replace(node.loc.selector, static_name)
+            keywords.each.with_index do |keyword, idx|
+              corrector.insert_before(args[idx].loc.expression, keyword)
+            end
+          end
+        end
+
+        private
+
+        def whitelist
+          cop_config['Whitelist']
+        end
+
+        def column_keywords(method)
+          keyword_string = method.to_s[METHOD_PATTERN, 1]
+          keyword_string.split('_and_').map { |keyword| "#{keyword}: " }
+        end
+
+        # Returns static method name.
+        # If code isn't wrong, returns nil
+        def static_method_name(method_name)
+          match = METHOD_PATTERN.match(method_name)
+          return nil unless match
+          match[2] ? 'find_by!' : 'find_by'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Rails
+      # This cop looks for duplicate values in enum declarations.
+      #
+      # @example
+      #   # bad
+      #   enum status: { active: 0, archived: 0 }
+      #
+      #   # good
+      #   enum status: { active: 0, archived: 1 }
+      #
+      #   # bad
+      #   enum status: [:active, :archived, :active]
+      #
+      #   # good
+      #   enum status: [:active, :archived]
+      class EnumUniqueness < Cop
+        include Duplication
+
+        MSG = 'Duplicate value `%s` found in `%s` enum declaration.'.freeze
+
+        def_node_matcher :enum_declaration, <<-END
+          (send nil :enum (hash (pair (_ $_) ${array hash})))
+        END
+
+        def on_send(node)
+          enum_declaration(node) do |name, args|
+            items = args.values
+
+            return unless duplicates?(items)
+
+            consecutive_duplicates(items).each do |item|
+              add_offense(item, :expression, format(MSG, item.source, name))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Rails
+      # This cop enforces that 'exit' calls are not used within a rails app.
+      # Valid options are instead to raise an error, break, return or some
+      # other form of stopping execution of current request.
+      #
+      # There are two obvious cases where 'exit' is particularly harmful:
+      #
+      # - Usage in library code for your application. Even though rails will
+      # rescue from a SystemExit and continue on, unit testing that library
+      # code will result in specs exiting (potentially silently if exit(0)
+      # is used.)
+      # - Usage in application code outside of the web process could result in
+      # the program exiting, which could result in the code failing to run and
+      # do its job.
+      class Exit < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Do not use `exit` in Rails applications.'.freeze
+        TARGET_METHODS = %i[exit exit!].freeze
+        EXPLICIT_RECEIVERS = %i[Kernel Process].freeze
+
+        def on_send(node)
+          add_offense(node, :selector) if offending_node?(node)
+        end
+
+        private
+
+        def offending_node?(node)
+          right_method_name?(node.method_name) &&
+            right_argument_count?(node.arguments) &&
+            right_receiver?(node.receiver)
+        end
+
+        def right_method_name?(method_name)
+          TARGET_METHODS.include?(method_name)
+        end
+
+        # More than 1 argument likely means it is a different
+        # `exit` implementation than the one we are preventing.
+        def right_argument_count?(arg_nodes)
+          arg_nodes.size <= 1
+        end
+
+        # Only register if exit is being called explicitly on
+        # Kernel or Process or if receiver node is nil for plain
+        # `exit` calls.
+        def right_receiver?(receiver_node)
+          return true unless receiver_node
+
+          _a, receiver_node_class, _c = *receiver_node
+
+          EXPLICIT_RECEIVERS.include?(receiver_node_class)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Rails
+      # This cop is used to identify usages of file path joining process
+      # to use `Rails.root.join` clause.
+      #
+      # @example
+      #  # bad
+      #  Rails.root.join('app/models/goober')
+      #  File.join(Rails.root, 'app/models/goober')
+      #  "#{Rails.root}/app/models/goober"
+      #
+      #  # good
+      #  Rails.root.join('app', 'models', 'goober')
+      class FilePath < Cop
+        MSG = 'Please use `Rails.root.join(\'path\', \'to\')` instead.'.freeze
+
+        def_node_matcher :file_join_nodes?, <<-PATTERN
+          (send (const nil :File) :join ...)
+        PATTERN
+
+        def_node_search :rails_root_nodes?, <<-PATTERN
+          (send (const nil :Rails) :root)
+        PATTERN
+
+        def_node_matcher :rails_root_join_nodes?, <<-PATTERN
+          (send (send (const nil :Rails) :root) :join ...)
+        PATTERN
+
+        def on_dstr(node)
+          return unless rails_root_nodes?(node)
+          register_offense(node)
+        end
+
+        def on_send(node)
+          check_for_file_join_with_rails_root(node)
+          check_for_rails_root_join_with_slash_separated_path(node)
+        end
+
+        private
+
+        def check_for_file_join_with_rails_root(node)
+          return unless file_join_nodes?(node)
+          return unless node.method_args.any? { |e| rails_root_nodes?(e) }
+
+          register_offense(node)
+        end
+
+        def check_for_rails_root_join_with_slash_separated_path(node)
+          return unless rails_root_nodes?(node)
+          return unless rails_root_join_nodes?(node)
+          return unless node.method_args.any? { |arg| string_with_slash?(arg) }
+
+          register_offense(node)
+        end
+
+        def string_with_slash?(node)
+          node.type == :str && node.source =~ %r{/}
+        end
+
+        def register_offense(node)
+          line_range = node.loc.column...node.loc.last_column
+
+          add_offense(
+            node,
+            source_range(processed_source.buffer, node.loc.line, line_range),
+            MSG
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Rails
+      # This cop is used to identify usages of `where.first` and
+      # change them to use `find_by` instead.
+      #
+      # @example
+      #   # bad
+      #   User.where(name: 'Bruce').first
+      #   User.where(name: 'Bruce').take
+      #
+      #   # good
+      #   User.find_by(name: 'Bruce')
+      class FindBy < Cop
+        MSG = 'Use `find_by` instead of `where.%s`.'.freeze
+        TARGET_SELECTORS = %i[first take].freeze
+
+        def_node_matcher :where_first?, <<-PATTERN
+          (send (send _ :where ...) {:first :take})
+        PATTERN
+
+        def on_send(node)
+          return unless where_first?(node)
+
+          range = range_between(node.receiver.loc.selector.begin_pos,
+                                node.loc.selector.end_pos)
+
+          add_offense(node, range, format(MSG, node.method_name))
+        end
+
+        def autocorrect(node)
+          # Don't autocorrect where(...).first, because it can return different
+          # results from find_by. (They order records differently, so the
+          # 'first' record can be different.)
+          return if node.method?(:first)
+
+          where_loc = node.receiver.loc.selector
+          first_loc = range_between(node.loc.dot.begin_pos,
+                                    node.loc.selector.end_pos)
+
+          lambda do |corrector|
+            corrector.replace(where_loc, 'find_by')
+            corrector.replace(first_loc, '')
+          end
+        end
+      end
+    end
+  end
+end