class RuboCop::Cop::ThreadSafety::InstanceVariableInClassMethod

end
end
end
instance_variable_set(“@#{key}”, value)
define_singleton_method(“#{key}=”) do |value|
%i[uri port].each do |key|
class Host
end
end
end
@table_name = name
def table_name(name)
class << self
class Model
end
end
Notifier.new(@info).deliver
@info = validate(info)
def self.notify(info)
class User
# bad
@example
Avoid instance variables in class methods.

def class_method_definition?(node) 

def class_method_definition?(node)
  in_defs?(node) ||
    in_def_sclass?(node) ||
    singleton_method_definition?(node)
end

def in_def_sclass?(node) 

def in_def_sclass?(node)
  defn = node.ancestors.find do |ancestor|
    ancestor.type == :def
  end
  defn&.ancestors&.any? do |ancestor|
    ancestor.type == :sclass
  end
end

def in_defs?(node) 

def in_defs?(node)
  node.ancestors.any? do |ancestor|
    ancestor.type == :defs
  end
end

def instance_variable_call?(node) 

def instance_variable_call?(node)
  instance_variable_set_call?(node) || instance_variable_get_call?(node)
end

def on_ivar(node) 

def on_ivar(node)
  return unless class_method_definition?(node)
  return if synchronized?(node)
  add_offense(node, location: :name, message: MSG)
end

def on_send(node) 

def on_send(node)
  return unless instance_variable_call?(node)
  return unless class_method_definition?(node)
  return if synchronized?(node)
  add_offense(node, message: MSG)
end

def singleton_method_definition?(node) 

def singleton_method_definition?(node)
  node.ancestors.any? do |ancestor|
    next unless ancestor.children.first.is_a? AST::SendNode
    ancestor.children.first.command? :define_singleton_method
  end
end

def synchronized?(node) 

def synchronized?(node)
  node.ancestors.find do |ancestor|
    next unless ancestor.block_type?
    s = ancestor.children.first
    s.send_type? && s.children.last == :synchronize
  end
end