class RuboCop::Cop::Rails::LexicallyScopedActionFilter

end
end
@content = Article.find(params)
def load_article
private
end
super
def update
# in the superclass, so needs to invoke ‘super`
# the cop requires this method, but it relies on behaviour defined
before_action :load_article, only: [:update]
class ArticlesController < ContentController
end
end
@content.update(content_attributes)
def update
class ContentController < ApplicationController
@example
end
end
# something
def foo
end
before_action proc { authenticate }, only: :foo
included do
extend ActiveSupport::Concern
module FooMixin
# good
end
end
before_action proc { authenticate }, only: :foo
included do
extend ActiveSupport::Concern
module FooMixin
# bad
@example
end
end
def logout
end
def settings
end
def index
before_action :require_login, only: %i[index settings logout]
class LoginController < ApplicationController
# good
end
end
def index
before_action :require_login, only: %i[index settings logout]
class LoginController < ApplicationController
# bad
@example
remember to invoke `super` in the subclass actions.
If you rely on behaviour defined in the superclass actions, you must
define the filter in that class or module.
methods that are defined in other classes or modules, you should
mixins on the filter, but these can confuse developers. If you specify
You can technically specify methods of superclass or methods added by
`except` options are defined within the same class or module.
This cop checks that methods specified in the filter’s ‘only` or

def array_values(node) # rubocop:disable Metrics/MethodLength

Returns:
  • (Array) -

Parameters:
  • node (RuboCop::AST::Node) -- 
def array_values(node) # rubocop:disable Metrics/MethodLength
  case node.type
  when :str
    [node.str_content.to_sym]
  when :sym
    [node.value]
  when :array
    node.values.map do |v|
      case v.type
      when :str
        v.str_content.to_sym
      when :sym
        v.value
      end
    end.compact
  else
    []
  end
end

def message(methods, parent)

Returns:
  • (String) -

Parameters:
  • parent (RuboCop::AST::Node) --
  • methods (Array) -- 
def message(methods, parent)
  if methods.size == 1
    format(MSG,
           action: "`#{methods[0]}` is",
           type: parent.type)
  else
    format(MSG,
           action: "`#{methods.join('`, `')}` are",
           type: parent.type)
  end
end

def on_send(node) 

def on_send(node)
  methods_node = only_or_except_filter_methods(node)
  return unless methods_node
  parent = node.each_ancestor(:class, :module).first
  return unless parent
  block = parent.each_child_node(:begin).first
  return unless block
  defined_methods = block.each_child_node(:def).map(&:method_name)
  methods = array_values(methods_node).reject do |method|
    defined_methods.include?(method)
  end
  message = message(methods, parent)
  add_offense(node, message: message) unless methods.empty?
end