1 files changed, 22 insertions, 22 deletions

diff --git a/app/models/diff_note.rb b/app/models/diff_note.rb
index 805092e527a..ef6e6cfe120 100644
--- a/app/models/diff_note.rb
+++ b/app/models/diff_note.rb
@@ -9,13 +9,13 @@ class DiffNote < Note
   include Gitlab::Utils::StrongMemoize
 
   def self.noteable_types
-    %w(MergeRequest Commit)
+    %w[MergeRequest Commit]
   end
 
   validates :original_position, presence: true
   validates :position, presence: true
   validates :line_code, presence: true, line_code: true, if: :on_text?
-  validates :noteable_type, inclusion: { in: noteable_types }
+  validates :noteable_type, inclusion: {in: noteable_types}
   validate :positions_complete
   validate :verify_supported
   validate :diff_refs_match_commit, if: :for_commit?
@@ -32,7 +32,7 @@ class DiffNote < Note
     return unless should_create_diff_file?
 
     diff_file = fetch_diff_file
-    diff_line = diff_file.line_for_position(self.original_position)
+    diff_line = diff_file.line_for_position(original_position)
 
     creation_params = diff_file.diff.to_hash
       .except(:too_large)
@@ -58,27 +58,27 @@ class DiffNote < Note
   end
 
   def diff_line
-    @diff_line ||= diff_file&.line_for_position(self.original_position)
+    @diff_line ||= diff_file&.line_for_position(original_position)
   end
 
   def original_line_code
     return unless on_text?
 
-    self.diff_file.line_code(self.diff_line)
+    diff_file.line_code(diff_line)
   end
 
   def created_at_diff?(diff_refs)
     return false unless supported?
     return true if for_commit?
 
-    self.original_position.diff_refs == diff_refs
+    original_position.diff_refs == diff_refs
   end
 
   def supports_suggestion?
     return false unless noteable.supports_suggestion? && on_text?
     # We don't want to trigger side-effects of `diff_file` call.
     return false unless file = fetch_diff_file
-    return false unless line = file.line_for_position(self.original_position)
+    return false unless line = file.line_for_position(original_position)
 
     line&.suggestible?
   end
@@ -111,8 +111,8 @@ class DiffNote < Note
       if note_diff_file
         diff = Gitlab::Git::Diff.new(note_diff_file.to_hash)
         Gitlab::Diff::File.new(diff,
-                               repository: project.repository,
-                               diff_refs: original_position.diff_refs)
+          repository: project.repository,
+          diff_refs: original_position.diff_refs)
       elsif created_at_diff?(noteable.diff_refs)
         # We're able to use the already persisted diffs (Postgres) if we're
         # presenting a "current version" of the MR discussion diff.
@@ -122,7 +122,7 @@ class DiffNote < Note
         # `Diff::FileCollection::MergeRequestDiff`.
         noteable.diffs(original_position.diff_options).diff_files.first
       else
-        original_position.diff_file(self.project.repository)
+        original_position.diff_file(project.repository)
       end
 
     # Since persisted diff files already have its content "unfolded"
@@ -133,11 +133,11 @@ class DiffNote < Note
   end
 
   def supported?
-    for_commit? || self.noteable.has_complete_diff_refs?
+    for_commit? || noteable.has_complete_diff_refs?
   end
 
   def set_line_code
-    self.line_code = self.position.line_code(self.project.repository)
+    self.line_code = position.line_code(project.repository)
   end
 
   def verify_supported
@@ -147,28 +147,28 @@ class DiffNote < Note
   end
 
   def positions_complete
-    return if self.original_position.complete? && self.position.complete?
+    return if original_position.complete? && position.complete?
 
     errors.add(:position, "is invalid")
   end
 
   def diff_refs_match_commit
-    return if self.original_position.diff_refs == self.commit.diff_refs
+    return if original_position.diff_refs == commit.diff_refs
 
-    errors.add(:commit_id, 'does not match the diff refs')
+    errors.add(:commit_id, "does not match the diff refs")
   end
 
   def keep_around_commits
     shas = [
-      self.original_position.base_sha,
-      self.original_position.start_sha,
-      self.original_position.head_sha
+      original_position.base_sha,
+      original_position.start_sha,
+      original_position.head_sha,
     ]
 
-    if self.position != self.original_position
-      shas << self.position.base_sha
-      shas << self.position.start_sha
-      shas << self.position.head_sha
+    if position != original_position
+      shas << position.base_sha
+      shas << position.start_sha
+      shas << position.head_sha
     end
 
     project.repository.keep_around(*shas)