Rebase to current 4.3.0-alpha-glitch-soc, update theming files

app/controllers/api/v1/conversations_controller.rb.orig

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+class Api::V1::ConversationsController < Api::BaseController
+  LIMIT = 20
+
+  before_action -> { doorkeeper_authorize! :read, :'read:statuses' }, only: :index
+  before_action -> { doorkeeper_authorize! :write, :'write:conversations' }, except: :index
+  before_action :require_user!
+  before_action :set_conversation, except: :index
+  after_action :insert_pagination_headers, only: :index
+
+  def index
+    @conversations = paginated_conversations
+    render json: @conversations, each_serializer: REST::ConversationSerializer, relationships: StatusRelationshipsPresenter.new(@conversations.map(&:last_status), current_user&.account_id)
+  end
+
+  def read
+    @conversation.update!(unread: false)
+    render json: @conversation, serializer: REST::ConversationSerializer
+  end
+
+  def unread
+    @conversation.update!(unread: true)
+    render json: @conversation, serializer: REST::ConversationSerializer
+  end
+
+  def destroy
+    @conversation.destroy!
+    render_empty
+  end
+
+  private
+
+  def set_conversation
+    @conversation = AccountConversation.where(account: current_account).find(params[:id])
+  end
+
+  def paginated_conversations
+    AccountConversation.where(account: current_account)
+                       .includes(
+                         account: :account_stat,
+                         last_status: [
+                           :media_attachments,
+                           :preview_cards,
+                           :status_stat,
+                           :tags,
+                           {
+                             active_mentions: [account: :account_stat],
+                             account: :account_stat,
+                           },
+                         ]
+                       )
+<<<<<<< HEAD
+                       .to_a_paginated_by_id(limit_param(LIMIT), params_slice(:max_id, :since_id, :min_id))
+=======
+                       .to_a_paginated_by_id(limit_param(LIMIT), **params_slice(:max_id, :since_id, :min_id))
+>>>>>>> 3e1724e97 (Fix multiple N+1s in ConversationsController (#25134))
+  end
+
+  def insert_pagination_headers
+    set_pagination_headers(next_path, prev_path)
+  end
+
+  def next_path
+    api_v1_conversations_url pagination_params(max_id: pagination_max_id) if records_continue?
+  end
+
+  def prev_path
+    api_v1_conversations_url pagination_params(min_id: pagination_since_id) unless @conversations.empty?
+  end
+
+  def pagination_max_id
+    @conversations.last.last_status_id
+  end
+
+  def pagination_since_id
+    @conversations.first.last_status_id
+  end
+
+  def records_continue?
+    @conversations.size == limit_param(LIMIT)
+  end
+
+  def pagination_params(core_params)
+    params.slice(:limit).permit(:limit).merge(core_params)
+  end
+end

app/controllers/api/v1/statuses/histories_controller.rb.orig

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Api::V1::Statuses::HistoriesController < Api::BaseController
+  include Authorization
+
+  before_action -> { authorize_if_got_token! :read, :'read:statuses' }
+  before_action :set_status
+
+  def show
+<<<<<<< HEAD
+    cache_if_unauthenticated!
+=======
+>>>>>>> f8930a67a (Change /api/v1/statuses/:id/history to always return at least one item (#25510))
+    render json: status_edits, each_serializer: REST::StatusEditSerializer
+  end
+
+  private
+
+  def status_edits
+    @status.edits.includes(:account, status: [:account]).to_a.presence || [@status.build_snapshot(at_time: @status.edited_at || @status.created_at)]
+  end
+
+  def set_status
+    @status = Status.find(params[:status_id])
+    authorize @status, :show?
+  rescue Mastodon::NotPermittedError
+    not_found
+  end
+end

app/controllers/api/v1/statuses/reblogs_controller.rb.orig

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+class Api::V1::Statuses::ReblogsController < Api::BaseController
+  include Authorization
+  include Redisable
+  include Lockable
+
+  before_action -> { doorkeeper_authorize! :write, :'write:statuses' }
+  before_action :require_user!
+  before_action :set_reblog, only: [:create]
+
+  override_rate_limit_headers :create, family: :statuses
+
+  def create
+<<<<<<< HEAD
+    with_redis_lock("reblog:#{current_account.id}:#{@reblog.id}") do
+=======
+    with_lock("reblog:#{current_account.id}:#{@reblog.id}") do
+>>>>>>> 1301af60e (Fix race condition when reblogging a status (#25016))
+      @status = ReblogService.new.call(current_account, @reblog, reblog_params)
+    end
+
+    render json: @status, serializer: REST::StatusSerializer
+  end
+
+  def destroy
+    @status = current_account.statuses.find_by(reblog_of_id: params[:status_id])
+
+    if @status
+      authorize @status, :unreblog?
+      @reblog = @status.reblog
+      count = [@reblog.reblogs_count - 1, 0].max
+      @status.discard
+      RemovalWorker.perform_async(@status.id)
+    else
+      @reblog = Status.find(params[:status_id])
+      count = @reblog.reblogs_count
+      authorize @reblog, :show?
+    end
+
+    relationships = StatusRelationshipsPresenter.new([@status], current_account.id, reblogs_map: { @reblog.id => false }, attributes_map: { @reblog.id => { reblogs_count: count } })
+    render json: @reblog, serializer: REST::StatusSerializer, relationships: relationships
+  rescue Mastodon::NotPermittedError
+    not_found
+  end
+
+  private
+
+  def set_reblog
+    @reblog = Status.find(params[:status_id])
+    authorize @reblog, :show?
+  rescue Mastodon::NotPermittedError
+    not_found
+  end
+
+  def reblog_params
+    params.permit(:visibility)
+  end
+end

app/controllers/backups_controller.rb.orig

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class BackupsController < ApplicationController
+  include RoutingHelper
+
+  skip_before_action :check_self_destruct!
+  skip_before_action :require_functional!
+
+  before_action :authenticate_user!
+  before_action :set_backup
+
+  def download
+    case Paperclip::Attachment.default_options[:storage]
+    when :s3, :azure
+      redirect_to @backup.dump.expiring_url(10), allow_other_host: true
+    when :fog
+      if Paperclip::Attachment.default_options.dig(:fog_credentials, :openstack_temp_url_key).present?
+<<<<<<< HEAD
+        redirect_to @backup.dump.expiring_url(Time.now.utc + 10), allow_other_host: true
+=======
+        redirect_to @backup.dump.expiring_url(Time.now.utc + 10)
+>>>>>>> bc8592627 (Fix user archive takeouts when using OpenStack Swift (#24431))
+      else
+        redirect_to full_asset_url(@backup.dump.url), allow_other_host: true
+      end
+    when :filesystem
+      redirect_to full_asset_url(@backup.dump.url), allow_other_host: true
+    end
+  end
+
+  private
+
+  def set_backup
+    @backup = current_user.backups.find(params[:id])
+  end
+end

app/controllers/media_controller.rb.orig

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+class MediaController < ApplicationController
+  include Authorization
+
+  skip_before_action :require_functional!, unless: :limited_federation_mode?
+
+  before_action :authenticate_user!, if: :limited_federation_mode?
+  before_action :set_media_attachment
+  before_action :verify_permitted_status!
+  before_action :check_playable, only: :player
+  before_action :allow_iframing, only: :player
+  before_action :set_pack, only: :player
+
+  content_security_policy only: :player do |policy|
+    policy.frame_ancestors(false)
+  end
+
+  def show
+    redirect_to @media_attachment.file.url(:original)
+  end
+
+  def player
+    @body_classes = 'player'
+  end
+
+  private
+
+  def set_media_attachment
+    id = params[:id] || params[:medium_id]
+    return if id.nil?
+
+    scope = MediaAttachment.local.attached
+    # If id is 19 characters long, it's a shortcode, otherwise it's an identifier
+    @media_attachment = id.size == 19 ? scope.find_by!(shortcode: id) : scope.find(id)
+  end
+
+  def verify_permitted_status!
+    authorize @media_attachment.status, :show?
+  rescue Mastodon::NotPermittedError
+    not_found
+  end
+
+  def check_playable
+    not_found unless @media_attachment.larger_media_format?
+  end
+
+  def allow_iframing
+    response.headers.delete('X-Frame-Options')
+<<<<<<< HEAD
+  end
+
+  def set_pack
+    use_pack 'public'
+=======
+>>>>>>> 72d96bf17 (Remove invalid X-Frame-Options: ALLOWALL (#25070))
+  end
+end

app/controllers/oauth/authorized_applications_controller.rb.orig

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+class Oauth::AuthorizedApplicationsController < Doorkeeper::AuthorizedApplicationsController
+  skip_before_action :authenticate_resource_owner!
+
+  before_action :store_current_location
+  before_action :authenticate_resource_owner!
+  before_action :set_pack
+  before_action :require_not_suspended!, only: :destroy
+  before_action :set_body_classes
+  before_action :set_cache_headers
+
+  before_action :set_last_used_at_by_app, only: :index, unless: -> { request.format == :json }
+
+  before_action :set_last_used_at_by_app, only: :index, unless: -> { request.format == :json }
+
+  skip_before_action :require_functional!
+
+  include Localized
+
+  def destroy
+    Web::PushSubscription.unsubscribe_for(params[:id], current_resource_owner)
+    super
+  end
+
+  private
+
+  def set_body_classes
+    @body_classes = 'admin'
+  end
+
+  def store_current_location
+    store_location_for(:user, request.url)
+  end
+
+  def set_pack
+    use_pack 'settings'
+  end
+
+  def require_not_suspended!
+    forbidden if current_account.suspended?
+  end
+
+<<<<<<< HEAD
+  def set_cache_headers
+    response.cache_control.replace(private: true, no_store: true)
+  end
+
+=======
+>>>>>>> b3cbcd744 (Fix “Authorized applications” inefficiently and incorrectly getting last use date (#25060))
+  def set_last_used_at_by_app
+    @last_used_at_by_app = Doorkeeper::AccessToken
+                           .select('DISTINCT ON (application_id) application_id, last_used_at')
+                           .where(resource_owner_id: current_resource_owner.id)
+                           .where.not(last_used_at: nil)
+                           .order(application_id: :desc, last_used_at: :desc)
+                           .pluck(:application_id, :last_used_at)
+                           .to_h
+  end
+end

app/controllers/well_known/webfinger_controller.rb.orig

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module WellKnown
+  class WebfingerController < ActionController::Base # rubocop:disable Rails/ApplicationController
+    include RoutingHelper
+
+    before_action :set_account
+    before_action :check_account_suspension
+
+    rescue_from ActiveRecord::RecordNotFound, with: :not_found
+    rescue_from ActionController::ParameterMissing, WebfingerResource::InvalidRequest, with: :bad_request
+
+    def show
+      expires_in 3.days, public: true
+      render json: @account, serializer: WebfingerSerializer, content_type: 'application/jrd+json'
+    end
+
+    private
+
+    def set_account
+      username = username_from_resource
+<<<<<<< HEAD
+
+=======
+>>>>>>> 2779bce9a (Add fallback redirection when getting a webfinger query `LOCAL_DOMAIN@LOCAL_DOMAIN` (#23600))
+      @account = begin
+        if username == Rails.configuration.x.local_domain
+          Account.representative
+        else
+          Account.find_local!(username)
+        end
+      end
+    end
+
+    def username_from_resource
+      resource_user    = resource_param
+      username, domain = resource_user.split('@')
+      resource_user    = "#{username}@#{Rails.configuration.x.local_domain}" if Rails.configuration.x.alternate_domains.include?(domain)
+
+      WebfingerResource.new(resource_user).username
+    end
+
+    def resource_param
+      params.require(:resource)
+    end
+
+    def check_account_suspension
+      gone if @account.suspended_permanently?
+    end
+
+    def gone
+      expires_in(3.minutes, public: true)
+      head 410
+    end
+
+    def bad_request
+      expires_in(3.minutes, public: true)
+      head 400
+    end
+
+    def not_found
+      expires_in(3.minutes, public: true)
+      head 404
+    end
+  end
+end