Redundant self

.rubocop.yml

 Style/FrozenStringLiteralComment:
   Enabled: false
 
-# Offense count: 1
-# Cop supports --auto-correct.
-# Configuration parameters: Strict.
-Style/NumericLiterals:
-  MinDigits: 15
-
-# Offense count: 85
-# Cop supports --auto-correct.
-Style/RedundantSelf:
-  Exclude:
-    - 'app/models/activity.rb'
-    - 'app/models/group.rb'
-    - 'app/models/member.rb'
-    - 'app/models/participant.rb'
-    - 'app/models/person.rb'
-    - 'app/models/subgroup.rb'
-    - 'app/models/token.rb'
-    - 'app/models/user.rb'
-
 # Offense count: 215
 # Cop supports --auto-correct.
 # Configuration parameters: EnforcedStyle, ConsistentQuotesInMultiline.

app/models/activity.rb

   # Get all people (not participants) that are organizers. Does not include
   # group leaders, although they may modify the activity as well.
   def organizers
-    self.participants.includes(:person).where(is_organizer: true)
+    participants.includes(:person).where(is_organizer: true)
   end
 
   def organizer_names
-    self.organizers.map { |o| o.person.full_name }
+    organizers.map { |o| o.person.full_name }
   end
 
   # Determine whether the passed Person participates in the activity.
   def participant?(person)
     Participant.exists?(
-      activity_id: self.id,
+      activity_id: id,
       person_id: person.id
     )
   end
   def organizer?(person)
     Participant.exists?(
       person_id: person.id,
-      activity_id: self.id,
+      activity_id: id,
       is_organizer: true
     )
   end
 
   # Query the database to determine the amount of participants that are present/absent/unknown
   def state_counts
-    self.participants.group(:attending).count
+    participants.group(:attending).count
   end
 
   # Return participants attending, absent, unknown
   def human_state_counts
-    c = self.state_counts
+    c = state_counts
     p = c[true]
     a = c[false]
     u = c[nil]
   # Determine whether the passed Person may change this activity.
   def may_change?(person)
     person.is_admin ||
-      self.organizer?(person) ||
-      self.group.leader?(person)
+      organizer?(person) ||
+      group.leader?(person)
   end
 
   # Create Participants for all People that
   #  1. are members of the group
   #  2. do not have Participants (and thus, no way to confirm) yet
   def create_missing_participants!
-    people = self.group.people
-    people = people.where('people.id NOT IN (?)', self.people.ids) unless self.participants.empty?
+    people = group.people
+    people = people.where('people.id NOT IN (?)', self.people.ids) unless participants.empty?
 
     people.each do |p|
       Participant.create(
 
   # Create Subgroups from the defaults set using DefaultSubgroups
   def copy_default_subgroups!
-    defaults = self.group.default_subgroups
+    defaults = group.default_subgroups
 
     # If there are no subgroups, there cannot be subgroup division.
-    self.update_attribute(:subgroup_division_enabled, false) if defaults.none?
+    update_attribute(:subgroup_division_enabled, false) if defaults.none?
 
     defaults.each do |dsg|
       sg = Subgroup.new(activity: self)
   # response to 'attending'.
   def send_reminder
     # Sanity check that the reminder date didn't change while queued.
-    return unless !self.reminder_done && self.reminder_at
-    return if self.reminder_at > Time.zone.now
+    return unless !reminder_done && reminder_at
+    return if reminder_at > Time.zone.now
 
     participants = self.participants.where(attending: nil)
     participants.each(&:send_reminder)
 
     self.reminder_done = true
-    self.save
+    save
   end
 
   def schedule_reminder
-    return if self.reminder_at.nil? || self.reminder_done
+    return if reminder_at.nil? || reminder_done
 
-    self.delay(run_at: self.reminder_at).send_reminder
+    delay(run_at: reminder_at).send_reminder
   end
 
   def schedule_subgroup_division
-    return if self.deadline.nil? || self.subgroup_division_done
+    return if deadline.nil? || subgroup_division_done
 
-    self.delay(run_at: self.deadline).assign_subgroups!(mail: true)
+    delay(run_at: deadline).assign_subgroups!(mail: true)
   end
 
   # Assign a subgroup to all attending participants without one.
   def assign_subgroups!(mail = false)
     # Sanity check: we need subgroups to divide into.
-    return unless self.subgroups.any?
+    return unless subgroups.any?
 
     # Get participants in random order
-    ps = self
-         .participants
-         .where(attending: true)
-         .where(subgroup: nil)
-         .to_a
+    ps =
+      participants
+      .where(attending: true)
+      .where(subgroup: nil)
+      .to_a
 
     ps.shuffle!
 
     # Get groups, link to participant count
-    groups = self
-             .subgroups
-             .where(is_assignable: true)
-             .to_a
-             .map { |sg| [sg.participants.count, sg] }
+    groups =
+      subgroups
+      .where(is_assignable: true)
+      .to_a
+      .map { |sg| [sg.participants.count, sg] }
 
     ps.each do |p|
       # Sort groups so the group with the least participants gets the following participant
       groups.first[0] += 1
     end
 
-    self.notify_subgroups! if mail
+    notify_subgroups! if mail
   end
 
   def clear_subgroups!(only_assignable = true)
-    sgs = self
-          .subgroups
+    sgs =
+      subgroups
 
     if only_assignable
       sgs = sgs
             .where(is_assignable: true)
     end
 
-    ps = self
-         .participants
-         .where(subgroup: sgs)
+    ps =
+      participants
+      .where(subgroup: sgs)
 
     ps.each do |p|
       p.subgroup = nil
 
   # Notify participants of the current subgroups, if any.
   def notify_subgroups!
-    ps = self
-         .participants
-         .joins(:person)
-         .where.not(subgroup: nil)
+    ps =
+      participants
+      .joins(:person)
+      .where.not(subgroup: nil)
 
     ps.each(&:send_subgroup_notification)
   end
   # Assert that the deadline for participants to change the deadline, if any,
   # is set before the event starts.
   def deadline_before_start
-    errors.add(:deadline, I18n.t('activities.errors.must_be_before_start')) if self.deadline > self.start
+    errors.add(:deadline, I18n.t('activities.errors.must_be_before_start')) if deadline > start
   end
 
   # Assert that the activity's end, if any, occurs after the event's start.
   def end_after_start
-    errors.add(:end, I18n.t('activities.errors.must_be_after_start')) if self.end < self.start
+    errors.add(:end, I18n.t('activities.errors.must_be_after_start')) if self.end < start
   end
 
   # Assert that the reminder for non-response is sent while participants still
   # can change their response.
   def reminder_before_deadline
-    errors.add(:reminder_at, I18n.t('activities.errors.must_be_before_deadline')) if self.reminder_at > self.deadline
+    errors.add(:reminder_at, I18n.t('activities.errors.must_be_before_deadline')) if reminder_at > deadline
   end
 
   # Assert that there is at least one divisible subgroup.
   def subgroups_for_division_present
-    errors.add(:subgroup_division_enabled, I18n.t('activities.errors.cannot_divide_without_subgroups')) if self.subgroups.where(is_assignable: true).none? && subgroup_division_enabled?
+    errors.add(:subgroup_division_enabled, I18n.t('activities.errors.cannot_divide_without_subgroups')) if subgroups.where(is_assignable: true).none? && subgroup_division_enabled?
   end
 end

app/models/group.rb

 
   # @return [Array<Member>] the members in the group who are also group leaders.
   def leaders
-    self.members.includes(:person).where(is_leader: true)
+    members.includes(:person).where(is_leader: true)
   end
 
   # @return [Array<Activity>] the activities that haven't started yet.
   def future_activities
-    self.activities.where('start > ?', Time.now)
+    activities.where('start > ?', Time.now)
   end
 
   # @return [Array<Activity>]

app/models/member.rb

   # Create Participants for this Member for all the group's future activities, where the member isn't enrolled yet.
   # Intended to be called after the member is added to the group.
   def create_future_participants!
-    activities = self.group.future_activities
+    activities = group.future_activities
 
-    unless self.person.activities.empty?
+    unless person.activities.empty?
       activities = activities.where(
-        'activities.id NOT IN (?)', self.person.activities.ids
+        'activities.id NOT IN (?)', person.activities.ids
       )
     end
 
     activities.each do |a|
       Participant.create!(
         activity: a,
-        person: self.person
+        person: person
       )
     end
   end
   # Intended to be called before the member is deleted.
   def delete_future_participants!
     participants = Participant.where(
-      person_id: self.person.id,
-      activity: self.group.future_activities
+      person_id: person.id,
+      activity: group.future_activities
     )
 
     participants.each(&:destroy!)

app/models/participant.rb

   # @return [String]
   #   the name for the Participant's current state in the current locale.
   def human_attending
-    HUMAN_ATTENDING[self.attending]
+    HUMAN_ATTENDING[attending]
   end
 
   ICAL_ATTENDING = {
   # @return [String]
   #   the ICal attending response.
   def ical_attending
-    ICAL_ATTENDING[self.attending]
+    ICAL_ATTENDING[attending]
   end
 
   # TODO: Move to a more appropriate place
   # @return [String]
   #   the class for a row containing this activity.
   def row_class
-    if self.attending
+    if attending
       "success"
-    elsif self.attending == false
+    elsif attending == false
       "danger"
     else
       "warning"
   end
 
   def may_change?(person)
-    self.activity.may_change?(person) ||
+    activity.may_change?(person) ||
       self.person == person
   end
 
   # Set attending to true if nil, and notify the Person via email.
   def send_reminder
-    return unless self.attending.nil?
+    return unless attending.nil?
 
-    self.attending = self.activity.no_response_action
+    self.attending = activity.no_response_action
     notes = self.notes || ""
     notes << '[auto]'
     self.notes = notes
-    self.save
+    save
 
-    return unless self.person.send_attendance_reminder
+    return unless person.send_attendance_reminder
 
-    ParticipantMailer.attendance_reminder(self.person, self.activity).deliver_later
+    ParticipantMailer.attendance_reminder(person, activity).deliver_later
   end
 
   # Send subgroup information email if person is attending.
   def send_subgroup_notification
-    return unless self.attending && self.subgroup
+    return unless attending && subgroup
 
-    ParticipantMailer.subgroup_notification(self.person, self.activity, self).deliver_later
+    ParticipantMailer.subgroup_notification(person, activity, self).deliver_later
   end
 
   # Clear subgroup if person is set to 'not attending'.

app/models/person.rb

 
   # The person's full name.
   def full_name
-    if self.infix&.present?
-      [self.first_name, self.infix, self.last_name].join(' ')
+    if infix&.present?
+      [first_name, infix, last_name].join(' ')
     else
-      [self.first_name, self.last_name].join(' ')
+      [first_name, last_name].join(' ')
     end
   end
 
   # The person's reversed name, to sort by surname.
   def reversed_name
-    if self.infix
-      [self.last_name, self.infix, self.first_name].join(', ')
+    if infix
+      [last_name, infix, first_name].join(', ')
     else
-      [self.last_name, self.first_name].join(', ')
+      [last_name, first_name].join(', ')
     end
   end
 
   # All activities where this person is an organizer.
   def organized_activities
-    self.participants.includes(:activity).where(is_organizer: true)
+    participants.includes(:activity).where(is_organizer: true)
   end
 
   # Create multiple Persons from data found in a csv file, return those.
   # @return [String]
   #   the URL to access this person's calendar.
   def calendar_url
-    person_calendar_url self.calendar_token
+    person_calendar_url calendar_token
   end
 
   # @return [Icalendar::Calendar]
 
     tzid = 1.seconds.since.time_zone.tzinfo.name
 
-    selection = self
-                .participants
-                .joins(:activity)
-                .where('"end" > ?', 3.months.ago)
+    selection =
+      participants
+      .joins(:activity)
+      .where('"end" > ?', 3.months.ago)
 
     if skip_absent
       selection = selection
 
   # Assert that the person's birth date, if any, lies in the past.
   def birth_date_cannot_be_in_future
-    errors.add(:birth_date, I18n.t('person.errors.cannot_future')) if self.birth_date && self.birth_date > Date.today
+    errors.add(:birth_date, I18n.t('person.errors.cannot_future')) if birth_date && birth_date > Date.today
   end
 
   # Explicitly force nil to false in the admin field.
   # Ensure the person's user email is updated at the same time as the person's
   # email.
   def update_user_email
-    self.user&.update!(email: self.email)
+    user&.update!(email: email)
   end
 end

app/models/session.rb

 
   # @return [String] a BCrypt digest of the given string.
   def self.digest(string)
-    cost = ActiveModel::SecurePassword.min_cost ? BCrypt::Engine::MIN_COST :
-                                                  BCrypt::Engine.cost
+    cost = ActiveModel::SecurePassword.min_cost ? BCrypt::Engine::MIN_COST : BCrypt::Engine.cost
     BCrypt::Password.create(string, cost: cost)
   end
 end

app/models/subgroup.rb

   validates :activity, presence: true
 
   def participant_names
-    self
-      .participants
+    participants
       .joins(:person)
       .map { |p| p.person.full_name }
       .sort

app/models/token.rb

 
   # Defines the default expiry for the expiring tokens.
   def generate_expiry
-    case self.tokentype
+    case tokentype
     when TYPES[:password_reset]
       self.expires = 1.days.since
     when TYPES[:account_confirmation]

app/models/user.rb

   # Assert that the user's email address is the same as the email address of
   # the associated Person.
   def email_same_as_person
-    errors.add(:email, I18n.t('authentication.user_person_mail_mismatch')) if self.person && (self.email != self.person.email)
+    errors.add(:email, I18n.t('authentication.user_person_mail_mismatch')) if person && (email != person.email)
   end
 end