Enable Style/DotPosition Rubocop :cop:

39 files changed, 228 insertions, 228 deletions

diff --git a/lib/api/access_requests.rb b/lib/api/access_requests.rb
index a5c9f0b509c..c9b5f58c557 100644
--- a/lib/api/access_requests.rb
+++ b/lib/api/access_requests.rb
@@ -68,8 +68,8 @@ module API
         delete ":id/access_requests/:user_id" do
           source = find_source(source_type, params[:id])
 
-          ::Members::DestroyService.new(source, current_user, params).
-            execute(:requesters)
+          ::Members::DestroyService.new(source, current_user, params)
+            .execute(:requesters)
         end
       end
     end
diff --git a/lib/api/branches.rb b/lib/api/branches.rb
index f35084a582a..3d816f8771d 100644
--- a/lib/api/branches.rb
+++ b/lib/api/branches.rb
@@ -102,8 +102,8 @@ module API
       post ":id/repository/branches" do
         authorize_push_project
 
-        result = CreateBranchService.new(user_project, current_user).
-                 execute(params[:branch], params[:ref])
+        result = CreateBranchService.new(user_project, current_user)
+                 .execute(params[:branch], params[:ref])
 
         if result[:status] == :success
           present result[:branch],
@@ -121,8 +121,8 @@ module API
       delete ":id/repository/branches/:branch", requirements: { branch: /.+/ } do
         authorize_push_project
 
-        result = DeleteBranchService.new(user_project, current_user).
-                 execute(params[:branch])
+        result = DeleteBranchService.new(user_project, current_user)
+                 .execute(params[:branch])
 
         if result[:status] != :success
           render_api_error!(result[:message], result[:return_code])
diff --git a/lib/api/entities.rb b/lib/api/entities.rb
index 675bc52a983..aa91451c9f4 100644
--- a/lib/api/entities.rb
+++ b/lib/api/entities.rb
@@ -484,9 +484,9 @@ module API
       expose :job_events
       # Expose serialized properties
       expose :properties do |service, options|
-        field_names = service.fields.
-          select { |field| options[:include_passwords] || field[:type] != 'password' }.
-          map { |field| field[:name] }
+        field_names = service.fields
+          .select { |field| options[:include_passwords] || field[:type] != 'password' }
+          .map { |field| field[:name] }
         service.properties.slice(*field_names)
       end
     end
diff --git a/lib/api/notes.rb b/lib/api/notes.rb
index e281e3230fd..01ca62b593f 100644
--- a/lib/api/notes.rb
+++ b/lib/api/notes.rb
@@ -33,8 +33,8 @@ module API
               # paginate() only works with a relation. This could lead to a
               # mismatch between the pagination headers info and the actual notes
               # array returned, but this is really a edge-case.
-              paginate(noteable.notes).
-              reject { |n| n.cross_reference_not_visible_for?(current_user) }
+              paginate(noteable.notes)
+              .reject { |n| n.cross_reference_not_visible_for?(current_user) }
             present notes, with: Entities::Note
           else
             not_found!("Notes")
diff --git a/lib/api/tags.rb b/lib/api/tags.rb
index c7b1efe0bfa..633a858f8c7 100644
--- a/lib/api/tags.rb
+++ b/lib/api/tags.rb
@@ -44,8 +44,8 @@ module API
       post ':id/repository/tags' do
         authorize_push_project
 
-        result = ::Tags::CreateService.new(user_project, current_user).
-          execute(params[:tag_name], params[:ref], params[:message], params[:release_description])
+        result = ::Tags::CreateService.new(user_project, current_user)
+          .execute(params[:tag_name], params[:ref], params[:message], params[:release_description])
 
         if result[:status] == :success
           present result[:tag],
@@ -63,8 +63,8 @@ module API
       delete ":id/repository/tags/:tag_name", requirements: { tag_name: /.+/ } do
         authorize_push_project
 
-        result = ::Tags::DestroyService.new(user_project, current_user).
-          execute(params[:tag_name])
+        result = ::Tags::DestroyService.new(user_project, current_user)
+          .execute(params[:tag_name])
 
         if result[:status] != :success
           render_api_error!(result[:message], result[:return_code])
@@ -81,8 +81,8 @@ module API
       post ':id/repository/tags/:tag_name/release', requirements: { tag_name: /.+/ } do
         authorize_push_project
 
-        result = CreateReleaseService.new(user_project, current_user).
-          execute(params[:tag_name], params[:description])
+        result = CreateReleaseService.new(user_project, current_user)
+          .execute(params[:tag_name], params[:description])
 
         if result[:status] == :success
           present result[:release], with: Entities::Release
@@ -101,8 +101,8 @@ module API
       put ':id/repository/tags/:tag_name/release', requirements: { tag_name: /.+/ } do
         authorize_push_project
 
-        result = UpdateReleaseService.new(user_project, current_user).
-          execute(params[:tag_name], params[:description])
+        result = UpdateReleaseService.new(user_project, current_user)
+          .execute(params[:tag_name], params[:description])
 
         if result[:status] == :success
           present result[:release], with: Entities::Release
diff --git a/lib/api/users.rb b/lib/api/users.rb
index bfb69d6dc18..c10e3364382 100644
--- a/lib/api/users.rb
+++ b/lib/api/users.rb
@@ -103,13 +103,13 @@ module API
         if user.persisted?
           present user, with: Entities::UserPublic
         else
-          conflict!('Email has already been taken') if User.
-              where(email: user.email).
-              count > 0
+          conflict!('Email has already been taken') if User
+              .where(email: user.email)
+              .count > 0
 
-          conflict!('Username has already been taken') if User.
-              where(username: user.username).
-              count > 0
+          conflict!('Username has already been taken') if User
+              .where(username: user.username)
+              .count > 0
 
           render_validation_error!(user)
         end
@@ -133,12 +133,12 @@ module API
         not_found!('User') unless user
 
         conflict!('Email has already been taken') if params[:email] &&
-            User.where(email: params[:email]).
-                where.not(id: user.id).count > 0
+            User.where(email: params[:email])
+                .where.not(id: user.id).count > 0
 
         conflict!('Username has already been taken') if params[:username] &&
-            User.where(username: params[:username]).
-                where.not(id: user.id).count > 0
+            User.where(username: params[:username])
+                .where.not(id: user.id).count > 0
 
         user_params = declared_params(include_missing: false)
         identity_attrs = user_params.slice(:provider, :extern_uid)
@@ -517,9 +517,9 @@ module API
       get "activities" do
         authenticated_as_admin!
 
-        activities = User.
-          where(User.arel_table[:last_activity_on].gteq(params[:from])).
-          reorder(last_activity_on: :asc)
+        activities = User
+          .where(User.arel_table[:last_activity_on].gteq(params[:from]))
+          .reorder(last_activity_on: :asc)
 
         present paginate(activities), with: Entities::UserActivity
       end
diff --git a/lib/api/v3/branches.rb b/lib/api/v3/branches.rb
index 0a877b960f6..81b13249892 100644
--- a/lib/api/v3/branches.rb
+++ b/lib/api/v3/branches.rb
@@ -26,8 +26,8 @@ module API
         delete ":id/repository/branches/:branch", requirements: { branch: /.+/ } do
           authorize_push_project
 
-          result = DeleteBranchService.new(user_project, current_user).
-                   execute(params[:branch])
+          result = DeleteBranchService.new(user_project, current_user)
+                   .execute(params[:branch])
 
           if result[:status] == :success
             status(200)
@@ -55,8 +55,8 @@ module API
         end
         post ":id/repository/branches" do
           authorize_push_project
-          result = CreateBranchService.new(user_project, current_user).
-            execute(params[:branch_name], params[:ref])
+          result = CreateBranchService.new(user_project, current_user)
+            .execute(params[:branch_name], params[:ref])
 
           if result[:status] == :success
             present result[:branch],
diff --git a/lib/api/v3/entities.rb b/lib/api/v3/entities.rb
index 7c5065dee90..c848f52723b 100644
--- a/lib/api/v3/entities.rb
+++ b/lib/api/v3/entities.rb
@@ -245,9 +245,9 @@ module API
         expose :job_events, as: :build_events
         # Expose serialized properties
         expose :properties do |service, options|
-          field_names = service.fields.
-            select { |field| options[:include_passwords] || field[:type] != 'password' }.
-            map { |field| field[:name] }
+          field_names = service.fields
+            .select { |field| options[:include_passwords] || field[:type] != 'password' }
+            .map { |field| field[:name] }
           service.properties.slice(*field_names)
         end
       end
diff --git a/lib/api/v3/notes.rb b/lib/api/v3/notes.rb
index 009ec5c6bbd..23fe95e42e4 100644
--- a/lib/api/v3/notes.rb
+++ b/lib/api/v3/notes.rb
@@ -34,8 +34,8 @@ module API
                 # paginate() only works with a relation. This could lead to a
                 # mismatch between the pagination headers info and the actual notes
                 # array returned, but this is really a edge-case.
-                paginate(noteable.notes).
-                reject { |n| n.cross_reference_not_visible_for?(current_user) }
+                paginate(noteable.notes)
+                .reject { |n| n.cross_reference_not_visible_for?(current_user) }
               present notes, with: ::API::V3::Entities::Note
             else
               not_found!("Notes")
diff --git a/lib/api/v3/tags.rb b/lib/api/v3/tags.rb
index c2541de2f50..7e5875cd030 100644
--- a/lib/api/v3/tags.rb
+++ b/lib/api/v3/tags.rb
@@ -22,8 +22,8 @@ module API
         delete ":id/repository/tags/:tag_name", requirements: { tag_name: /.+/ } do
           authorize_push_project
 
-          result = ::Tags::DestroyService.new(user_project, current_user).
-            execute(params[:tag_name])
+          result = ::Tags::DestroyService.new(user_project, current_user)
+            .execute(params[:tag_name])
 
           if result[:status] == :success
             status(200)
diff --git a/lib/api/v3/users.rb b/lib/api/v3/users.rb
index f4cda3b2eba..37020019e07 100644
--- a/lib/api/v3/users.rb
+++ b/lib/api/v3/users.rb
@@ -50,13 +50,13 @@ module API
           if user.persisted?
             present user, with: ::API::Entities::UserPublic
           else
-            conflict!('Email has already been taken') if User.
-                where(email: user.email).
-                count > 0
+            conflict!('Email has already been taken') if User
+                .where(email: user.email)
+                .count > 0
 
-            conflict!('Username has already been taken') if User.
-                where(username: user.username).
-                count > 0
+            conflict!('Username has already been taken') if User
+                .where(username: user.username)
+                .count > 0
 
             render_validation_error!(user)
           end
@@ -137,11 +137,11 @@ module API
           user = User.find_by(id: params[:id])
           not_found!('User') unless user
 
-          events = user.events.
-            merge(ProjectsFinder.new(current_user: current_user).execute).
-            references(:project).
-            with_associations.
-            recent
+          events = user.events
+            .merge(ProjectsFinder.new(current_user: current_user).execute)
+            .references(:project)
+            .with_associations
+            .recent
 
           present paginate(events), with: ::API::V3::Entities::Event
         end
diff --git a/lib/banzai/reference_extractor.rb b/lib/banzai/reference_extractor.rb
index 8e3b0c4db79..7e6357f8a00 100644
--- a/lib/banzai/reference_extractor.rb
+++ b/lib/banzai/reference_extractor.rb
@@ -10,8 +10,8 @@ module Banzai
     end
 
     def references(type, project, current_user = nil)
-      processor = Banzai::ReferenceParser[type].
-        new(project, current_user)
+      processor = Banzai::ReferenceParser[type]
+        .new(project, current_user)
 
       processor.process(html_documents)
     end
diff --git a/lib/banzai/reference_parser/issue_parser.rb b/lib/banzai/reference_parser/issue_parser.rb
index 89ec715ddf6..9fd4bd68d43 100644
--- a/lib/banzai/reference_parser/issue_parser.rb
+++ b/lib/banzai/reference_parser/issue_parser.rb
@@ -9,8 +9,8 @@ module Banzai
 
         issues = issues_for_nodes(nodes)
 
-        readable_issues = Ability.
-          issues_readable_by_user(issues.values, user).to_set
+        readable_issues = Ability
+          .issues_readable_by_user(issues.values, user).to_set
 
         nodes.select do |node|
           readable_issues.include?(issues[node])
diff --git a/lib/banzai/reference_parser/user_parser.rb b/lib/banzai/reference_parser/user_parser.rb
index 3efbd2fd631..4d336068861 100644
--- a/lib/banzai/reference_parser/user_parser.rb
+++ b/lib/banzai/reference_parser/user_parser.rb
@@ -99,8 +99,8 @@ module Banzai
       def find_users_for_projects(ids)
         return [] if ids.empty?
 
-        collection_objects_for_ids(Project, ids).
-          flat_map { |p| p.team.members.to_a }
+        collection_objects_for_ids(Project, ids)
+          .flat_map { |p| p.team.members.to_a }
       end
 
       def can_read_reference?(user, ref_project, node)
diff --git a/lib/ci/charts.rb b/lib/ci/charts.rb
index 3decc3b1a26..6063d6f45e8 100644
--- a/lib/ci/charts.rb
+++ b/lib/ci/charts.rb
@@ -2,10 +2,10 @@ module Ci
   module Charts
     module DailyInterval
       def grouped_count(query)
-        query.
-          group("DATE(#{Ci::Build.table_name}.created_at)").
-          count(:created_at).
-          transform_keys { |date| date.strftime(@format) }
+        query
+          .group("DATE(#{Ci::Build.table_name}.created_at)")
+          .count(:created_at)
+          .transform_keys { |date| date.strftime(@format) }
       end
 
       def interval_step
@@ -16,14 +16,14 @@ module Ci
     module MonthlyInterval
       def grouped_count(query)
         if Gitlab::Database.postgresql?
-          query.
-            group("to_char(#{Ci::Build.table_name}.created_at, '01 Month YYYY')").
-            count(:created_at).
-            transform_keys(&:squish)
+          query
+            .group("to_char(#{Ci::Build.table_name}.created_at, '01 Month YYYY')")
+            .count(:created_at)
+            .transform_keys(&:squish)
         else
-          query.
-            group("DATE_FORMAT(#{Ci::Build.table_name}.created_at, '01 %M %Y')").
-            count(:created_at)
+          query
+            .group("DATE_FORMAT(#{Ci::Build.table_name}.created_at, '01 %M %Y')")
+            .count(:created_at)
         end
       end
 
@@ -46,8 +46,8 @@ module Ci
       end
 
       def collect
-        query = project.builds.
-          where("? > #{Ci::Build.table_name}.created_at AND #{Ci::Build.table_name}.created_at > ?", @to, @from)
+        query = project.builds
+          .where("? > #{Ci::Build.table_name}.created_at AND #{Ci::Build.table_name}.created_at > ?", @to, @from)
 
         totals_count  = grouped_count(query)
         success_count = grouped_count(query.success)
diff --git a/lib/gitlab/background_migration.rb b/lib/gitlab/background_migration.rb
index 914a3b72abd..d95ecd7b291 100644
--- a/lib/gitlab/background_migration.rb
+++ b/lib/gitlab/background_migration.rb
@@ -5,8 +5,8 @@ module Gitlab
     #
     # steal_class - The name of the class for which to steal jobs.
     def self.steal(steal_class)
-      queue = Sidekiq::Queue.
-        new(BackgroundMigrationWorker.sidekiq_options['queue'])
+      queue = Sidekiq::Queue
+        .new(BackgroundMigrationWorker.sidekiq_options['queue'])
 
       queue.each do |job|
         migration_class, migration_args = job.args
diff --git a/lib/gitlab/cache/ci/project_pipeline_status.rb b/lib/gitlab/cache/ci/project_pipeline_status.rb
index 4fc9a075edc..9c2e09943b0 100644
--- a/lib/gitlab/cache/ci/project_pipeline_status.rb
+++ b/lib/gitlab/cache/ci/project_pipeline_status.rb
@@ -50,8 +50,8 @@ module Gitlab
             ref: pipeline.ref
           }
 
-          new(pipeline.project, pipeline_info: pipeline_info).
-            store_in_cache_if_needed
+          new(pipeline.project, pipeline_info: pipeline_info)
+            .store_in_cache_if_needed
         end
 
         def initialize(project, pipeline_info: {}, loaded_from_cache: nil)
diff --git a/lib/gitlab/ci/pipeline_duration.rb b/lib/gitlab/ci/pipeline_duration.rb
index a210e76acaa..3208cc2bef6 100644
--- a/lib/gitlab/ci/pipeline_duration.rb
+++ b/lib/gitlab/ci/pipeline_duration.rb
@@ -87,8 +87,8 @@ module Gitlab
 
       def from_pipeline(pipeline)
         status = %w[success failed running canceled]
-        builds = pipeline.builds.latest.
-          where(status: status).where.not(started_at: nil).order(:started_at)
+        builds = pipeline.builds.latest
+          .where(status: status).where.not(started_at: nil).order(:started_at)
 
         from_builds(builds)
       end
diff --git a/lib/gitlab/conflict/file_collection.rb b/lib/gitlab/conflict/file_collection.rb
index 6e73361cad1..1611eba31da 100644
--- a/lib/gitlab/conflict/file_collection.rb
+++ b/lib/gitlab/conflict/file_collection.rb
@@ -16,9 +16,9 @@ module Gitlab
           project = merge_request.source_project
 
           new(merge_request, project).tap do |file_collection|
-            project.
-              repository.
-              with_repo_branch_commit(merge_request.target_project.repository, merge_request.target_branch) do
+            project
+              .repository
+              .with_repo_branch_commit(merge_request.target_project.repository, merge_request.target_branch) do
 
               yield file_collection
             end
diff --git a/lib/gitlab/contributions_calendar.rb b/lib/gitlab/contributions_calendar.rb
index 060e013183f..bf557103cfd 100644
--- a/lib/gitlab/contributions_calendar.rb
+++ b/lib/gitlab/contributions_calendar.rb
@@ -16,14 +16,14 @@ module Gitlab
       # Can't use Event.contributions here because we need to check 3 different
       # project_features for the (currently) 3 different contribution types
       date_from = 1.year.ago
-      repo_events = event_counts(date_from, :repository).
-        having(action: Event::PUSHED)
-      issue_events = event_counts(date_from, :issues).
-        having(action: [Event::CREATED, Event::CLOSED], target_type: "Issue")
-      mr_events = event_counts(date_from, :merge_requests).
-        having(action: [Event::MERGED, Event::CREATED, Event::CLOSED], target_type: "MergeRequest")
-      note_events = event_counts(date_from, :merge_requests).
-        having(action: [Event::COMMENTED], target_type: "Note")
+      repo_events = event_counts(date_from, :repository)
+        .having(action: Event::PUSHED)
+      issue_events = event_counts(date_from, :issues)
+        .having(action: [Event::CREATED, Event::CLOSED], target_type: "Issue")
+      mr_events = event_counts(date_from, :merge_requests)
+        .having(action: [Event::MERGED, Event::CREATED, Event::CLOSED], target_type: "MergeRequest")
+      note_events = event_counts(date_from, :merge_requests)
+        .having(action: [Event::COMMENTED], target_type: "Note")
 
       union = Gitlab::SQL::Union.new([repo_events, issue_events, mr_events, note_events])
       events = Event.find_by_sql(union.to_sql).map(&:attributes)
@@ -34,9 +34,9 @@ module Gitlab
     end
 
     def events_by_date(date)
-      events = Event.contributions.where(author_id: contributor.id).
-        where(created_at: date.beginning_of_day..date.end_of_day).
-        where(project_id: projects)
+      events = Event.contributions.where(author_id: contributor.id)
+        .where(created_at: date.beginning_of_day..date.end_of_day)
+        .where(project_id: projects)
 
       # Use visible_to_user? instead of the complicated logic in activity_dates
       # because we're only viewing the events for a single day.
@@ -60,20 +60,20 @@ module Gitlab
       # use IN(project_ids...) instead. It's the intersection of two users so
       # the list will be (relatively) short
       @contributed_project_ids ||= projects.uniq.pluck(:id)
-      authed_projects = Project.where(id: @contributed_project_ids).
-        with_feature_available_for_user(feature, current_user).
-        reorder(nil).
-        select(:id)
+      authed_projects = Project.where(id: @contributed_project_ids)
+        .with_feature_available_for_user(feature, current_user)
+        .reorder(nil)
+        .select(:id)
 
-      conditions = t[:created_at].gteq(date_from.beginning_of_day).
-        and(t[:created_at].lteq(Date.today.end_of_day)).
-        and(t[:author_id].eq(contributor.id))
+      conditions = t[:created_at].gteq(date_from.beginning_of_day)
+        .and(t[:created_at].lteq(Date.today.end_of_day))
+        .and(t[:author_id].eq(contributor.id))
 
-      Event.reorder(nil).
-        select(t[:project_id], t[:target_type], t[:action], 'date(created_at) AS date', 'count(id) as total_amount').
-        group(t[:project_id], t[:target_type], t[:action], 'date(created_at)').
-        where(conditions).
-        having(t[:project_id].in(Arel::Nodes::SqlLiteral.new(authed_projects.to_sql)))
+      Event.reorder(nil)
+        .select(t[:project_id], t[:target_type], t[:action], 'date(created_at) AS date', 'count(id) as total_amount')
+        .group(t[:project_id], t[:target_type], t[:action], 'date(created_at)')
+        .where(conditions)
+        .having(t[:project_id].in(Arel::Nodes::SqlLiteral.new(authed_projects.to_sql)))
     end
   end
 end
diff --git a/lib/gitlab/cycle_analytics/base_query.rb b/lib/gitlab/cycle_analytics/base_query.rb
index d560dca45c8..58729d3ced8 100644
--- a/lib/gitlab/cycle_analytics/base_query.rb
+++ b/lib/gitlab/cycle_analytics/base_query.rb
@@ -12,17 +12,17 @@ module Gitlab
       end
 
       def stage_query
-        query = mr_closing_issues_table.join(issue_table).on(issue_table[:id].eq(mr_closing_issues_table[:issue_id])).
-          join(issue_metrics_table).on(issue_table[:id].eq(issue_metrics_table[:issue_id])).
-          where(issue_table[:project_id].eq(@project.id)).
-          where(issue_table[:deleted_at].eq(nil)).
-          where(issue_table[:created_at].gteq(@options[:from]))
+        query = mr_closing_issues_table.join(issue_table).on(issue_table[:id].eq(mr_closing_issues_table[:issue_id]))
+          .join(issue_metrics_table).on(issue_table[:id].eq(issue_metrics_table[:issue_id]))
+          .where(issue_table[:project_id].eq(@project.id))
+          .where(issue_table[:deleted_at].eq(nil))
+          .where(issue_table[:created_at].gteq(@options[:from]))
 
         # Load merge_requests
-        query = query.join(mr_table, Arel::Nodes::OuterJoin).
-          on(mr_table[:id].eq(mr_closing_issues_table[:merge_request_id])).
-          join(mr_metrics_table).
-          on(mr_table[:id].eq(mr_metrics_table[:merge_request_id]))
+        query = query.join(mr_table, Arel::Nodes::OuterJoin)
+          .on(mr_table[:id].eq(mr_closing_issues_table[:merge_request_id]))
+          .join(mr_metrics_table)
+          .on(mr_table[:id].eq(mr_metrics_table[:merge_request_id]))
 
         query
       end
diff --git a/lib/gitlab/database/median.rb b/lib/gitlab/database/median.rb
index 23890e5f493..059054ac9ff 100644
--- a/lib/gitlab/database/median.rb
+++ b/lib/gitlab/database/median.rb
@@ -29,10 +29,10 @@ module Gitlab
       end
 
       def mysql_median_datetime_sql(arel_table, query_so_far, column_sym)
-        query = arel_table.
-                from(arel_table.project(Arel.sql('*')).order(arel_table[column_sym]).as(arel_table.table_name)).
-                project(average([arel_table[column_sym]], 'median')).
-                where(
+        query = arel_table
+                .from(arel_table.project(Arel.sql('*')).order(arel_table[column_sym]).as(arel_table.table_name))
+                .project(average([arel_table[column_sym]], 'median'))
+                .where(
                   Arel::Nodes::Between.new(
                     Arel.sql("(select @row_id := @row_id + 1)"),
                     Arel::Nodes::And.new(
@@ -67,8 +67,8 @@ module Gitlab
         cte_table = Arel::Table.new("ordered_records")
         cte = Arel::Nodes::As.new(
           cte_table,
-          arel_table.
-            project(
+          arel_table
+            .project(
               arel_table[column_sym].as(column_sym.to_s),
               Arel::Nodes::Over.new(Arel::Nodes::NamedFunction.new("row_number", []),
                                     Arel::Nodes::Window.new.order(arel_table[column_sym])).as('row_id'),
@@ -79,8 +79,8 @@ module Gitlab
         # From the CTE, select either the middle row or the middle two rows (this is accomplished
         # by 'where cte.row_id between cte.ct / 2.0 AND cte.ct / 2.0 + 1'). Find the average of the
         # selected rows, and this is the median value.
-        cte_table.project(average([extract_epoch(cte_table[column_sym])], "median")).
-          where(
+        cte_table.project(average([extract_epoch(cte_table[column_sym])], "median"))
+          .where(
             Arel::Nodes::Between.new(
               cte_table[:row_id],
               Arel::Nodes::And.new(
@@ -88,9 +88,9 @@ module Gitlab
                  (cte_table[:ct] / Arel.sql('2.0') + 1)]
               )
             )
-          ).
-          with(query_so_far, cte).
-          to_sql
+          )
+          .with(query_so_far, cte)
+          .to_sql
       end
 
       private
diff --git a/lib/gitlab/database/migration_helpers.rb b/lib/gitlab/database/migration_helpers.rb
index 9181202a091..60cce9c6d9e 100644
--- a/lib/gitlab/database/migration_helpers.rb
+++ b/lib/gitlab/database/migration_helpers.rb
@@ -245,19 +245,19 @@ module Gitlab
         start_id = exec_query(start_arel.to_sql).to_hash.first['id'].to_i
 
         loop do
-          stop_arel = table.project(table[:id]).
-            where(table[:id].gteq(start_id)).
-            order(table[:id].asc).
-            take(1).
-            skip(batch_size)
+          stop_arel = table.project(table[:id])
+            .where(table[:id].gteq(start_id))
+            .order(table[:id].asc)
+            .take(1)
+            .skip(batch_size)
 
           stop_arel = yield table, stop_arel if block_given?
           stop_row = exec_query(stop_arel.to_sql).to_hash.first
 
-          update_arel = Arel::UpdateManager.new(ActiveRecord::Base).
-            table(table).
-            set([[table[column], value]]).
-            where(table[:id].gteq(start_id))
+          update_arel = Arel::UpdateManager.new(ActiveRecord::Base)
+            .table(table)
+            .set([[table[column], value]])
+            .where(table[:id].gteq(start_id))
 
           if stop_row
             stop_id = stop_row['id'].to_i
@@ -586,15 +586,15 @@ module Gitlab
         quoted_replacement = Arel::Nodes::Quoted.new(replacement.to_s)
 
         if Database.mysql?
-          locate = Arel::Nodes::NamedFunction.
-            new('locate', [quoted_pattern, column])
-          insert_in_place = Arel::Nodes::NamedFunction.
-            new('insert', [column, locate, pattern.size, quoted_replacement])
+          locate = Arel::Nodes::NamedFunction
+            .new('locate', [quoted_pattern, column])
+          insert_in_place = Arel::Nodes::NamedFunction
+            .new('insert', [column, locate, pattern.size, quoted_replacement])
 
           Arel::Nodes::SqlLiteral.new(insert_in_place.to_sql)
         else
-          replace = Arel::Nodes::NamedFunction.
-            new("regexp_replace", [column, quoted_pattern, quoted_replacement])
+          replace = Arel::Nodes::NamedFunction
+            .new("regexp_replace", [column, quoted_pattern, quoted_replacement])
           Arel::Nodes::SqlLiteral.new(replace.to_sql)
         end
       end
diff --git a/lib/gitlab/database/rename_reserved_paths_migration/v1/rename_base.rb b/lib/gitlab/database/rename_reserved_paths_migration/v1/rename_base.rb
index d60fd4bb551..d8163d7da11 100644
--- a/lib/gitlab/database/rename_reserved_paths_migration/v1/rename_base.rb
+++ b/lib/gitlab/database/rename_reserved_paths_migration/v1/rename_base.rb
@@ -27,8 +27,8 @@ module Gitlab
             new_full_path = join_routable_path(namespace_path, new_path)
 
             # skips callbacks & validations
-            routable.class.where(id: routable).
-              update_all(path: new_path)
+            routable.class.where(id: routable)
+              .update_all(path: new_path)
 
             rename_routes(old_full_path, new_full_path)
 
diff --git a/lib/gitlab/database/rename_reserved_paths_migration/v1/rename_namespaces.rb b/lib/gitlab/database/rename_reserved_paths_migration/v1/rename_namespaces.rb
index 2958ad4b8e5..da7e2cb2e85 100644
--- a/lib/gitlab/database/rename_reserved_paths_migration/v1/rename_namespaces.rb
+++ b/lib/gitlab/database/rename_reserved_paths_migration/v1/rename_namespaces.rb
@@ -18,8 +18,8 @@ module Gitlab
                          when :top_level
                            MigrationClasses::Namespace.where(parent_id: nil)
                          end
-            with_paths = MigrationClasses::Route.arel_table[:path].
-                           matches_any(path_patterns)
+            with_paths = MigrationClasses::Route.arel_table[:path]
+                           .matches_any(path_patterns)
             namespaces.joins(:route).where(with_paths)
           end
 
@@ -52,15 +52,15 @@ module Gitlab
           end
 
           def repo_paths_for_namespace(namespace)
-            projects_for_namespace(namespace).distinct.select(:repository_storage).
-              map(&:repository_storage_path)
+            projects_for_namespace(namespace).distinct.select(:repository_storage)
+              .map(&:repository_storage_path)
           end
 
           def projects_for_namespace(namespace)
             namespace_ids = child_ids_for_parent(namespace, ids: [namespace.id])
-            namespace_or_children = MigrationClasses::Project.
-                                      arel_table[:namespace_id].
-                                      in(namespace_ids)
+            namespace_or_children = MigrationClasses::Project
+                                      .arel_table[:namespace_id]
+                                      .in(namespace_ids)
             MigrationClasses::Project.where(namespace_or_children)
           end
 
diff --git a/lib/gitlab/downtime_check.rb b/lib/gitlab/downtime_check.rb
index ab9537ed7d7..941244694e2 100644
--- a/lib/gitlab/downtime_check.rb
+++ b/lib/gitlab/downtime_check.rb
@@ -50,8 +50,8 @@ module Gitlab
 
     # Returns the class for the given migration file path.
     def class_for_migration_file(path)
-      File.basename(path, File.extname(path)).split('_', 2).last.camelize.
-        constantize
+      File.basename(path, File.extname(path)).split('_', 2).last.camelize
+        .constantize
     end
 
     # Returns true if the given migration can be performed without downtime.
diff --git a/lib/gitlab/group_hierarchy.rb b/lib/gitlab/group_hierarchy.rb
index 357c076e874..5a31e56cb30 100644
--- a/lib/gitlab/group_hierarchy.rb
+++ b/lib/gitlab/group_hierarchy.rb
@@ -67,11 +67,11 @@ module Gitlab
       union = SQL::Union.new([model.unscoped.from(ancestors_table),
                               model.unscoped.from(descendants_table)])
 
-      model.
-        unscoped.
-        with.
-        recursive(ancestors.to_arel, descendants.to_arel).
-        from("(#{union.to_sql}) #{model.table_name}")
+      model
+        .unscoped
+        .with
+        .recursive(ancestors.to_arel, descendants.to_arel)
+        .from("(#{union.to_sql}) #{model.table_name}")
     end
 
     private
@@ -82,10 +82,10 @@ module Gitlab
       cte << ancestors_base.except(:order)
 
       # Recursively get all the ancestors of the base set.
-      cte << model.
-        from([groups_table, cte.table]).
-        where(groups_table[:id].eq(cte.table[:parent_id])).
-        except(:order)
+      cte << model
+        .from([groups_table, cte.table])
+        .where(groups_table[:id].eq(cte.table[:parent_id]))
+        .except(:order)
 
       cte
     end
@@ -96,10 +96,10 @@ module Gitlab
       cte << descendants_base.except(:order)
 
       # Recursively get all the descendants of the base set.
-      cte << model.
-        from([groups_table, cte.table]).
-        where(groups_table[:parent_id].eq(cte.table[:id])).
-        except(:order)
+      cte << model
+        .from([groups_table, cte.table])
+        .where(groups_table[:parent_id].eq(cte.table[:id]))
+        .except(:order)
 
       cte
     end
diff --git a/lib/gitlab/highlight.rb b/lib/gitlab/highlight.rb
index 6b24da030df..5408a1a6838 100644
--- a/lib/gitlab/highlight.rb
+++ b/lib/gitlab/highlight.rb
@@ -1,8 +1,8 @@
 module Gitlab
   class Highlight
     def self.highlight(blob_name, blob_content, repository: nil, plain: false)
-      new(blob_name, blob_content, repository: repository).
-        highlight(blob_content, continue: false, plain: plain)
+      new(blob_name, blob_content, repository: repository)
+        .highlight(blob_content, continue: false, plain: plain)
     end
 
     attr_reader :blob_name
diff --git a/lib/gitlab/ldap/user.rb b/lib/gitlab/ldap/user.rb
index 5e299e26c54..39180dc17d9 100644
--- a/lib/gitlab/ldap/user.rb
+++ b/lib/gitlab/ldap/user.rb
@@ -10,9 +10,9 @@ module Gitlab
       class << self
         def find_by_uid_and_provider(uid, provider)
           # LDAP distinguished name is case-insensitive
-          identity = ::Identity.
-            where(provider: provider).
-            iwhere(extern_uid: uid).last
+          identity = ::Identity
+            .where(provider: provider)
+            .iwhere(extern_uid: uid).last
           identity && identity.user
         end
       end
diff --git a/lib/gitlab/metrics/influx_db.rb b/lib/gitlab/metrics/influx_db.rb
index 3a39791edbf..d7c56463aac 100644
--- a/lib/gitlab/metrics/influx_db.rb
+++ b/lib/gitlab/metrics/influx_db.rb
@@ -157,8 +157,8 @@ module Gitlab
                 host = settings[:host]
                 port = settings[:port]
 
-                InfluxDB::Client.
-                  new(udp: { host: host, port: port })
+                InfluxDB::Client
+                  .new(udp: { host: host, port: port })
               end
             end
           end
diff --git a/lib/gitlab/metrics/system.rb b/lib/gitlab/metrics/system.rb
index 3aaebb3e9c3..aba3e0df382 100644
--- a/lib/gitlab/metrics/system.rb
+++ b/lib/gitlab/metrics/system.rb
@@ -34,13 +34,13 @@ module Gitlab
       # THREAD_CPUTIME is not supported on OS X
       if Process.const_defined?(:CLOCK_THREAD_CPUTIME_ID)
         def self.cpu_time
-          Process.
-            clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID, :millisecond)
+          Process
+            .clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID, :millisecond)
         end
       else
         def self.cpu_time
-          Process.
-            clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID, :millisecond)
+          Process
+            .clock_gettime(Process::CLOCK_PROCESS_CPUTIME_ID, :millisecond)
         end
       end
 
diff --git a/lib/gitlab/other_markup.rb b/lib/gitlab/other_markup.rb
index 31a24460f0f..fc3f21233dd 100644
--- a/lib/gitlab/other_markup.rb
+++ b/lib/gitlab/other_markup.rb
@@ -6,8 +6,8 @@ module Gitlab
     # input         - the source text in a markup format
     #
     def self.render(file_name, input, context)
-      html = GitHub::Markup.render(file_name, input).
-        force_encoding(input.encoding)
+      html = GitHub::Markup.render(file_name, input)
+        .force_encoding(input.encoding)
       context[:pipeline] = :markup
 
       html = Banzai.render(html, context)
diff --git a/lib/gitlab/performance_bar/peek_query_tracker.rb b/lib/gitlab/performance_bar/peek_query_tracker.rb
index 7ab80f5ee0f..574ae8731a5 100644
--- a/lib/gitlab/performance_bar/peek_query_tracker.rb
+++ b/lib/gitlab/performance_bar/peek_query_tracker.rb
@@ -3,8 +3,8 @@ module Gitlab
   module PerformanceBar
     module PeekQueryTracker
       def sorted_queries
-        PEEK_DB_CLIENT.query_details.
-          sort { |a, b| b[:duration] <=> a[:duration] }
+        PEEK_DB_CLIENT.query_details
+          .sort { |a, b| b[:duration] <=> a[:duration] }
       end
 
       def results
diff --git a/lib/gitlab/project_authorizations/with_nested_groups.rb b/lib/gitlab/project_authorizations/with_nested_groups.rb
index bb0df1e3dad..15b8beacf60 100644
--- a/lib/gitlab/project_authorizations/with_nested_groups.rb
+++ b/lib/gitlab/project_authorizations/with_nested_groups.rb
@@ -28,34 +28,34 @@ module Gitlab
 
           # Projects that belong directly to any of the groups the user has
           # access to.
-          Namespace.
-            unscoped.
-            select([alias_as_column(projects[:id], 'project_id'),
-                    cte_alias[:access_level]]).
-            from(cte_alias).
-            joins(:projects),
+          Namespace
+            .unscoped
+            .select([alias_as_column(projects[:id], 'project_id'),
+                     cte_alias[:access_level]])
+            .from(cte_alias)
+            .joins(:projects),
 
           # Projects shared with any of the namespaces the user has access to.
-          Namespace.
-            unscoped.
-            select([links[:project_id],
-                    least(cte_alias[:access_level],
-                          links[:group_access],
-                          'access_level')]).
-            from(cte_alias).
-            joins('INNER JOIN project_group_links ON project_group_links.group_id = namespaces.id').
-            joins('INNER JOIN projects ON projects.id = project_group_links.project_id').
-            joins('INNER JOIN namespaces p_ns ON p_ns.id = projects.namespace_id').
-            where('p_ns.share_with_group_lock IS FALSE')
+          Namespace
+            .unscoped
+            .select([links[:project_id],
+                     least(cte_alias[:access_level],
+                           links[:group_access],
+                           'access_level')])
+            .from(cte_alias)
+            .joins('INNER JOIN project_group_links ON project_group_links.group_id = namespaces.id')
+            .joins('INNER JOIN projects ON projects.id = project_group_links.project_id')
+            .joins('INNER JOIN namespaces p_ns ON p_ns.id = projects.namespace_id')
+            .where('p_ns.share_with_group_lock IS FALSE')
         ]
 
         union = Gitlab::SQL::Union.new(relations)
 
-        ProjectAuthorization.
-          unscoped.
-          with.
-          recursive(cte.to_arel).
-          select_from_union(union)
+        ProjectAuthorization
+          .unscoped
+          .with
+          .recursive(cte.to_arel)
+          .select_from_union(union)
       end
 
       private
@@ -68,17 +68,17 @@ module Gitlab
         namespaces = Namespace.arel_table
 
         # Namespaces the user is a member of.
-        cte << user.groups.
-          select([namespaces[:id], members[:access_level]]).
-          except(:order)
+        cte << user.groups
+          .select([namespaces[:id], members[:access_level]])
+          .except(:order)
 
         # Sub groups of any groups the user is a member of.
         cte << Group.select([namespaces[:id],
                              greatest(members[:access_level],
-                                      cte.table[:access_level], 'access_level')]).
-          joins(join_cte(cte)).
-          joins(join_members).
-          except(:order)
+                                      cte.table[:access_level], 'access_level')])
+          .joins(join_cte(cte))
+          .joins(join_members)
+          .except(:order)
 
         cte
       end
@@ -88,11 +88,11 @@ module Gitlab
         members = Member.arel_table
         namespaces = Namespace.arel_table
 
-        cond = members[:source_id].
-          eq(namespaces[:id]).
-          and(members[:source_type].eq('Namespace')).
-          and(members[:requested_at].eq(nil)).
-          and(members[:user_id].eq(user.id))
+        cond = members[:source_id]
+          .eq(namespaces[:id])
+          .and(members[:source_type].eq('Namespace'))
+          .and(members[:requested_at].eq(nil))
+          .and(members[:user_id].eq(user.id))
 
         Arel::Nodes::OuterJoin.new(members, Arel::Nodes::On.new(cond))
       end
diff --git a/lib/gitlab/project_authorizations/without_nested_groups.rb b/lib/gitlab/project_authorizations/without_nested_groups.rb
index 627e8c5fba2..ad87540e6c2 100644
--- a/lib/gitlab/project_authorizations/without_nested_groups.rb
+++ b/lib/gitlab/project_authorizations/without_nested_groups.rb
@@ -26,9 +26,9 @@ module Gitlab
 
         union = Gitlab::SQL::Union.new(relations)
 
-        ProjectAuthorization.
-          unscoped.
-          select_from_union(union)
+        ProjectAuthorization
+          .unscoped
+          .select_from_union(union)
       end
     end
   end
diff --git a/lib/gitlab/shell.rb b/lib/gitlab/shell.rb
index b1d6ea665b7..22554236c38 100644
--- a/lib/gitlab/shell.rb
+++ b/lib/gitlab/shell.rb
@@ -30,8 +30,8 @@ module Gitlab
       end
 
       def version_required
-        @version_required ||= File.read(Rails.root.
-                                        join('GITLAB_SHELL_VERSION')).strip
+        @version_required ||= File.read(Rails.root
+                                        .join('GITLAB_SHELL_VERSION')).strip
       end
 
       def strip_key(key)
diff --git a/lib/gitlab/sherlock/line_profiler.rb b/lib/gitlab/sherlock/line_profiler.rb
index aa1468bff6b..b5f9d040047 100644
--- a/lib/gitlab/sherlock/line_profiler.rb
+++ b/lib/gitlab/sherlock/line_profiler.rb
@@ -77,8 +77,8 @@ module Gitlab
             line_samples << LineSample.new(duration, events)
           end
 
-          samples << FileSample.
-            new(file, line_samples, total_duration, total_events)
+          samples << FileSample
+            .new(file, line_samples, total_duration, total_events)
         end
 
         samples
diff --git a/lib/gitlab/sherlock/query.rb b/lib/gitlab/sherlock/query.rb
index 99e56e923eb..948bf5e6528 100644
--- a/lib/gitlab/sherlock/query.rb
+++ b/lib/gitlab/sherlock/query.rb
@@ -105,10 +105,10 @@ module Gitlab
       end
 
       def format_sql(query)
-        query.each_line.
-          map { |line| line.strip }.
-          join("\n").
-          gsub(PREFIX_NEWLINE) { "\n#{$1} " }
+        query.each_line
+          .map { |line| line.strip }
+          .join("\n")
+          .gsub(PREFIX_NEWLINE) { "\n#{$1} " }
       end
     end
   end
diff --git a/lib/gitlab/sql/recursive_cte.rb b/lib/gitlab/sql/recursive_cte.rb
index 5b1b03820a3..16ec002f139 100644
--- a/lib/gitlab/sql/recursive_cte.rb
+++ b/lib/gitlab/sql/recursive_cte.rb
@@ -52,10 +52,10 @@ module Gitlab
       # Applies the CTE to the given relation, returning a new one that will
       # query from it.
       def apply_to(relation)
-        relation.except(:where).
-          with.
-          recursive(to_arel).
-          from(alias_to(relation.model.arel_table))
+        relation.except(:where)
+          .with
+          .recursive(to_arel)
+          .from(alias_to(relation.model.arel_table))
       end
     end
   end