class Issue
  has_many :comments, as: :commentable
end

class PullRequest
  has_many :comments, as: :commentable
end

class Comment
  belongs_to :commentable, polymorphic: true
end

class CommentsController < ApplicationController
  before_action :set_commentable

  def create
    @comment = @commentable.comments.new(comment_params)
    if @comment.save
      redirect_to comment_path(@comment)
    else
      render :new, status: :unprocessable_entity
    end
  end

  private

  def set_commentable
    commentable_type = params.require(:commentable_type).presence_in(%w[Comment PullRequest]) || raise ActionController::BadRequest
    @commentable = commentable_type.constantize.find(params.require(:commentable_id)
  end
end

gid = Issue.find(1).to_global_id.to_s
#=> "gid://app/Issue/1"

GlobalID::Locator.locate(gid)
# => #<Issue:0x007fae94bf6298 @id="1">

sgid = Issue.find(1).to_signed_global_id.to_s
#=> "BAhJIh5naWQ6Ly9pZGluYWlkaS9Vc2VyLzM5NTk5BjoGRVQ=--81d7358dd5ee2ca33189bb404592df5e8d11420e"

GlobalID::Locator.locate_signed(sgid)
# => #<Issue:0x007fae94bf6298 @id="1">

class CommentsController < ApplicationController
  def set_commentable
    @commentable = GlobalID::Locator.locate_signed(params[:commentable_signed_global_id]) || raise(ActiveRecord::RecordNotFound)
  end
end

# > https://guides.rubyonrails.org/configuring.html#config-i18n-raise-on-missing-translations
# > Determines whether an error should be raised for missing translations. This defaults to false.
config.i18n.raise_on_missing_translations = true

<%= t "key_that_does_not_exist" %>
#=> Translation missing: en.key_that_does_not_exist

def create
  redirect_to @post, notice: t("key_that_does_not_exist")
end
#=> Translation missing: en.key_that_does_not_exist

Post.human_attribute_name("title")
#=> "Title"

# https://github.com/rails/rails/blob/9f80efc79119037fc4421d06e94a0d7e076876a4/actioncable/lib/action_cable/engine.rb#L19-L23
initializer "action_cable.helpers" do
  ActiveSupport.on_load(:action_view) do
    include ActionCable::Helpers::ActionCableHelper
  end
end

# https://github.com/hotwired/turbo-rails/blob/b0e7ebf2c7e2925c4d5fee4bf7d527c53ff4c1e3/lib/turbo/engine.rb#L59-L64
initializer "turbo.helpers", before: :load_config_initializers do
  ActiveSupport.on_load(:action_controller_base) do
    include Turbo::Streams::TurboStreamsTagBuilder, Turbo::Frames::FrameRequest, Turbo::Native::Navigation
    helper Turbo::Engine.helpers
  end
end

# ActiveModel::Translation.raise_on_missing_translations = true
Post.human_attribute_name("title")
=> Translation missing. Options considered were: (I18n::MissingTranslationData)
    - en.activerecord.attributes.post.title
    - en.attributes.title

            raise exception.respond_to?(:to_exception) ? exception.to_exception : exception
                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

get posts_path
response.content_type                  #=> "text/html; charset=utf-8"
response.parsed_body                   #=> Nokogiri::HTML5::Document
response.parsed_body.at_css("#posts")  #=> #<Nokogiri::XML::Element:0xea24...

get posts_path, as: :json
response.content_type #=> "application/json; charset=utf-8"
response.parsed_body  #=> Array
response.parsed_body  #=> [{"id"=>42, "title"=>"Title"},...

get post_path(post), as: :json
response.content_type #=> "application/json; charset=utf-8"
response.parsed_body  #=> Hash
response.parsed_body  #=> {"id"=>42, "title"=>"Title"}

# https://github.com/rails/rails/blob/cc638d1c09f11ac1307ad887d5bb9e41d6be3aa5/actionpack/lib/action_dispatch/testing/request_encoder.rb#L57-L58
module ActionDispatch
  class RequestEncoder # :nodoc:
    register_encoder :html,
      response_parser: -> body { Rails::Dom::Testing.html_document.parse(body) }
    register_encoder :json,
      response_parser: -> body { JSON.parse(body, object_class: ActiveSupport::HashWithIndifferentAccess) }
  end
end

ActionDispatch::IntegrationTest.register_encoder :xml,
  param_encoder: -> params { params.to_xml },
  response_parser: -> body { REXML::Document.new(body) }

get posts_path, as: :xml
response.content_type                                  #=> "application/xml; charset=utf-8"
response.parsed_body                                   #=> REXML::Document
response.parsed_body.elements["posts/post[1]/id"].text #=> "42"

module MyApp
  class Application < Rails::Application
    config.session_store :cookie_store, key: "_my_app", domain: :all
  end
end

# https://github.com/rack/rack/blob/64ad26e3381da2ce1853638a2c4ea241c2ad3729/lib/rack/utils.rb#L223-L231
def parse_cookies_header(value)
  return {} unless value

  value.split(/; */n).each_with_object({}) do |cookie, cookies|
    next if cookie.empty?
    key, value = cookie.split('=', 2)
    # unless cookies.key?してるので、2つ目以降は無視される。
    cookies[key] = (unescape(value) rescue value) unless cookies.key?(key)
  end
end

class ActiveStorage::Blobs::RedirectController < ActiveStorage::BaseController
  def show
    redirect_to @blob.url
  end
end

class ActiveStorage::Blob < ActiveStorage::Record
  def url
    service.url key
  end
end

irb> User.new.build_avatar_blob.service
=> #<ActiveStorage::Service::DiskService:0x00007fbe6e1eff58 @name=:local, @public=false>

module ActiveStorage
  class Service::DiskService < Service
  end
end

irb> User.new.build_avatar_blob.service.method(:url).source_location
=> ["activestorage-7.1.3/lib/active_storage/service.rb", 119]

module ActiveStorage
  class Service
    def url(key, **options)
      if public?
        public_url(key, **options)
      else
        private_url(key, **options)
      end
    end

    def public_url(key, **)
      raise NotImplementedError
    end

    def private_url(key, **)
      raise NotImplementedError
    end
  end
end

module ActiveStorage
  class Service::DiskService < Service
    def private_url(key, expires_in:)
      generate_url(key, expires_in: expires_in)
    end

    def public_url(key, filename:)
      generate_url(key, expires_in: nil)
    end

    def generate_url(key, expires_in:)
      verified_key_with_expiration = ActiveStorage.verifier.generate(
        {
          key: key,
        },
        expires_in: expires_in,
      )

      url_helpers.rails_disk_service_url(verified_key_with_expiration)
    end
  end
end

get  "/disk/:encoded_key/*filename" => "active_storage/disk#show",
  as: :rails_disk_service

class ActiveStorage::DiskController < ActiveStorage::BaseController
  def show
    if key = decode_verified_key
      serve_file named_disk_service(key[:service_name]).path_for(key[:key]))
    else
      head :not_found
    end
  end

  private
    def named_disk_service(name)
      ActiveStorage::Blob.services.fetch(name) do
        ActiveStorage::Blob.service
      end
    end

    def decode_verified_key
      key = ActiveStorage.verifier.verified(params[:encoded_key])
      key&.deep_symbolize_keys
    end

    def serve_file(path)
      Rack::Files.new(nil).serving(request, path).tap do |(status, headers, body)|
        self.status = status
        self.response_body = body

        headers.each do |name, value|
          response.headers[name] = value
        end
      end
    end
end

module ActiveStorage
  class Service::DiskService < Service
    def path_for(key)
      File.join root, folder_for(key), key
    end

    def folder_for(key)
      [ key[0..1], key[2..3] ].join("/")
    end
  end
end

class User < ApplicationRecord
  has_one_attached :avatar
end

irb> User.first.avatar
#<ActiveStorage::Attached::One:0x00007ff680e052a8
 @name="avatar",
 @record=
  #<User:0x00007ff68104ab58>

module ActiveStorage
  class Attached
  end

  class Attached::One < Attached
  end
end

class Post # ApplicationRecordから継承してないことに注意。
end

module ActiveStorage
  class Attached::One < Attached
    delegate_missing_to :attachment
  end
end

irb> User.first.avatar.attachment
=> #<ActiveStorage::Attachment:0x00007f8f12b568e8 id: 1, name: "avatar", record_type: "User", record_id: 1, blob_id: 1>

class ActiveStorage::Attachment < ActiveStorage::Record
end

class ActiveStorage::Record < ActiveRecord::Base
  self.abstract_class = true
end

resolve("ActiveStorage::Attachment") do |attachment, options|
  route_for(:rails_storage_redirect, attachment.blob, options)
end

direct :rails_storage_redirect do |model, options|
  route_for(:rails_service_blob, model.signed_id)
end

irb> User.first.avatar.attachment.blob.signed_id
#=> "eyJfcmFpbHMiOnsiZGF0YSI6MSwicHVyIjoiYmxvYl9pZCJ9fQ==--22989801b78c27abf7bc8c8b023cac322a42fbea"

get "/blobs/redirect/:signed_id/*filename" => "active_storage/blobs/redirect#show", as: :rails_service_blob

class User < ApplicationRecord
  has_one :profile, dependent: :destroy
end

user = User.create(profile: Profile.new)
# INSERT INTO users;
# INSERT INTO profiles (user_id) VALUES (1);

user.profile = Profile.new
# DELETE FROM profiles WHERE id = 1;
# INSERT INTO profiles (user_id) VALUES (1);

module YourRailsApp
  class Application < Rails::Application
    config.sandbox_by_default = true
  end
end

# https://github.com/rails/rails/blob/6e7ef7d61c7146ca03b173abc32f7ed97e3d949a/railties/test/application/console_test.rb
class ConsoleTest < ActiveSupport::TestCase
  include ActiveSupport::Testing::Isolation

  def setup
    build_app
  end

  def teardown
    teardown_app
  end

  def test_sandbox_by_default
    add_to_config <<-RUBY
      config.sandbox_by_default = true
    RUBY

    options = "-e production -- --verbose"
    spawn_console(options)

    write_prompt "puts Rails.application.sandbox", "puts Rails.application.sandbox\r\ntrue"
    @primary.puts "quit"
  end
end

# https://github.com/rails/rails/blob/6e7ef7d61c7146ca03b173abc32f7ed97e3d949a/railties/test/isolation/abstract_unit.rb
module TestHelpers
  module Generation
    def build_app(options = {})
      FileUtils.rm_rf(app_path)
      FileUtils.cp_r(app_template_path, app_path)
    end

    def teardown_app
      FileUtils.rm_rf(tmp_path)
    end
end

class Admin::UsersController < ApplicationController
  def index
    @users = User.search(conditions)

    respond_to.csv |format|
      format.html
      format.csv { send_file(generate_csv(@users)) }
    end
  end
end

class Admin::UserExportJob
  def perform(conditions)
    csv = generate_csv(User.search(conditions))
    bucket.create_file(csv)
  end

  private

  def bucket
    @bucket = storage.bucket("my-bucket")
  end

  def storage
    @storage ||= Google::Cloud::Storage.new(
      project_id: "my-project",
      credentials: "/path/to/keyfile.json"
    )
  end
end

class Admin::UserExport < ApplicationRecord
  belongs_to :exported_by, class_name: "User"

  has_one_attached :csv

  store_accessor :conditions

  after_create -> { LaterJob.perform_later(self, :generate_and_notify) }

  def generate_and_notify
    csv.attach(generate_and_csv(User.search(conditions)))
    UserMailer.exported(exported_by, csv).deliver_later
  end
end

class LaterJob < ApplicationJob
  def perform(object, method) = object.public_send(method)
end

class Admin::UsersController < ApplicationController
  def create
    @export = UserExport.new(export_params)
    if @export.save
      redirect_to @export, notice: "エクスポートを開始しました"
    else
      render :new, status: :unprocessable_entity
    end
  end

  private

  def export_params
    params.
    require(:user_export).
    permit(conditions: {}).
    merge(exported_by: current_user)
end

class Admin::UserExportTest < ActiveSupport::TestCase
  test "作成後にjobをenqueueする" do
    export = Admin::UserExport.new(...)

    assert_enqueued_with job: LaterJob, args: [export, :generate_and_notify] do
      export.save!
    end
  end

  test "csvを作成する" do
    export = Admin::UserExport.create(...)

    assert_changes -> { export.csv.attached? }, from: false, to: true do
      export.generate_and_notify
    end
  end
end