From 0040bc45a2b4c2c5dfbac76a4e4b5f0441a43f74 Mon Sep 17 00:00:00 2001 From: Dylan Knutson Date: Mon, 3 Mar 2025 22:59:07 +0000 Subject: [PATCH] firt tests forpost file thumbnail spec --- app/models/domain/post_file.rb | 3 +- app/models/domain/post_file_thumbnail.rb | 101 +- app/models/domain/thumbnail_type.rb | 50 + app/models/ip_address_role.rb | 10 + app/policies/state/ip_address_role_policy.rb | 2 +- config/blob_file_location.yml | 15 +- db/structure.sql | 141 ++ sorbet/rbi/dsl/application_controller.rbi | 2 +- sorbet/rbi/dsl/domain/perceptual_hash.rbi | 1407 +++++++++++++++++ sorbet/rbi/dsl/domain/post_file.rbi | 14 + .../domain/post_file/inkbunny_post_file.rbi | 14 + sorbet/rbi/dsl/domain/post_file_thumbnail.rbi | 1369 ++++++++++++++++ .../rbi/dsl/generated_path_helpers_module.rbi | 3 + .../rbi/dsl/generated_url_helpers_module.rbi | 3 + sorbet/rbi/dsl/ip_address_role.rbi | 36 - sorbet/rbi/shims/vips.rbi | 27 +- spec/factories/domain/post_file_thumbnail.rb | 7 + .../models/domain/post_file_thumbnail_spec.rb | 171 ++ .../thumb-036aaab6-content-container.jpeg | Bin 0 -> 200656 bytes 19 files changed, 3299 insertions(+), 76 deletions(-) create mode 100644 app/models/domain/thumbnail_type.rb create mode 100644 sorbet/rbi/dsl/domain/perceptual_hash.rbi create mode 100644 sorbet/rbi/dsl/domain/post_file_thumbnail.rbi create mode 100644 spec/factories/domain/post_file_thumbnail.rb create mode 100644 spec/models/domain/post_file_thumbnail_spec.rb create mode 100644 test/fixtures/files/images/thumb-036aaab6-content-container.jpeg diff --git a/app/models/domain/post_file.rb b/app/models/domain/post_file.rb index 8b8562c1..0bfb1ac3 100644 --- a/app/models/domain/post_file.rb +++ b/app/models/domain/post_file.rb @@ -13,7 +13,8 @@ class Domain::PostFile < ReduxApplicationRecord has_many :thumbnails, class_name: "::Domain::PostFileThumbnail", foreign_key: :post_file_id, - dependent: :destroy + dependent: :destroy, + inverse_of: :post_file attr_json :state, :string attr_json :url_str, :string diff --git a/app/models/domain/post_file_thumbnail.rb b/app/models/domain/post_file_thumbnail.rb index d9a9fb87..a6e78671 100644 --- a/app/models/domain/post_file_thumbnail.rb +++ b/app/models/domain/post_file_thumbnail.rb @@ -5,7 +5,8 @@ class Domain::PostFileThumbnail < ReduxApplicationRecord belongs_to :post_file, foreign_key: :post_file_id, - class_name: "::Domain::PostFile" + class_name: "::Domain::PostFile", + inverse_of: :thumbnails has_many :perceptual_hashes, class_name: "::Domain::PerceptualHash", @@ -18,30 +19,84 @@ class Domain::PostFileThumbnail < ReduxApplicationRecord scope: :post_file_id, }, inclusion: { - in: THUMBNAIL_TYPES.keys, + in: Domain::ThumbnailType.values.map(&:name), } - # Thumbnail types for different uses - THUMBNAIL_TYPES = + TMP_DIR = T.let(File.join(BlobFile::ROOT_DIR, "tmp-files"), String) + + THUMBNAIL_ROOT_DIR = + T.let(File.join(BlobFile::ROOT_DIR, "post_file_thumbnails"), String) + + THUMBNAIL_CONTENT_TYPES = T.let( - { - small: { - width: 128, - height: 128, - }, - medium: { - width: 256, - height: 256, - }, - large: { - width: 512, - height: 512, - }, - phash: { - width: 64, - height: 64, - }, # Special size for perceptual hashing - }, - T::Hash[Symbol, T::Hash[Symbol, Integer]], + [ + %r{image/jpeg}, + %r{image/jpg}, + %r{image/png}, + %r{image/gif}, + %r{image/webp}, + ], + T::Array[Regexp], ) + + sig { returns(T.nilable(String)) } + def absolute_file_path + return nil unless thumbnail_type = self.thumbnail_type + return nil unless post_file_id = self.post_file&.id + return nil unless sha256 = self.post_file&.blob_sha256 + sha256_hex = HexUtil.bin2hex(sha256) + path_segments = [ + THUMBNAIL_ROOT_DIR, + thumbnail_type, + *BlobFile.path_segments([2, 2, 1], sha256_hex), + ] + path_segments[-1] = "#{path_segments[-1]}.jpeg" + path_segments.join("/") + end + + sig do + params( + post_file: Domain::PostFile, + thumbnail_type: Domain::ThumbnailType, + ).returns(T.nilable(Domain::PostFileThumbnail)) + end + def self.find_or_create_from_post_file(post_file, thumbnail_type) + if t = find_by(post_file: post_file, thumbnail_type: thumbnail_type.name) + return t + end + return nil unless post_file.state_ok? + return nil unless log_entry = post_file.log_entry + unless THUMBNAIL_CONTENT_TYPES.any? { |regex| + regex.match?(log_entry.content_type) + } + return nil + end + + file_path = post_file.blob&.absolute_file_path + return nil unless file_path + + thumbnail = + Domain::PostFileThumbnail.new( + post_file: post_file, + thumbnail_type: thumbnail_type.name, + ) + + thumbnail_path = thumbnail.absolute_file_path.to_s + unless File.exist?(thumbnail_path) + FileUtils.mkdir_p(File.dirname(thumbnail_path)) + tmp_file_path = File.join(TMP_DIR, "thumbnail-#{SecureRandom.uuid}.jpeg") + image_data = + Vips::Image.thumbnail( + file_path, + thumbnail_type.width, + height: thumbnail_type.height, + size: :force, + ) + image_data.jpegsave(tmp_file_path, Q: thumbnail_type.quality, strip: true) + FileUtils.mv(tmp_file_path, thumbnail_path) + end + + thumbnail.save! + thumbnail + end end diff --git a/app/models/domain/thumbnail_type.rb b/app/models/domain/thumbnail_type.rb new file mode 100644 index 00000000..df1aadba --- /dev/null +++ b/app/models/domain/thumbnail_type.rb @@ -0,0 +1,50 @@ +# typed: strict +# Thumbnail types for different uses +class Domain::ThumbnailType < T::Enum + extend T::Sig + + enums do + Small = new + Medium = new + Large = new + PHash = new + end + + sig { returns(String) } + def name + case self + when Small + "small" + when Medium + "medium" + when Large + "large" + when PHash + "phash" + end + end + + sig { returns(Integer) } + def width + case self + when Small + 128 + when Medium + 256 + when Large + 512 + when PHash + 64 + end + end + + sig { returns(Integer) } + def height + width + end + + sig { returns(Integer) } + def quality + 70 + end +end diff --git a/app/models/ip_address_role.rb b/app/models/ip_address_role.rb index b7b725a2..2f8389e7 100644 --- a/app/models/ip_address_role.rb +++ b/app/models/ip_address_role.rb @@ -24,6 +24,16 @@ class IpAddressRole < ReduxApplicationRecord end end + sig { returns(T::Boolean) } + def admin? + false + end + + sig { returns(T::Boolean) } + def moderator? + false + end + private # Custom validation to prevent overlapping IP ranges diff --git a/app/policies/state/ip_address_role_policy.rb b/app/policies/state/ip_address_role_policy.rb index b4dc104b..da4da1bd 100644 --- a/app/policies/state/ip_address_role_policy.rb +++ b/app/policies/state/ip_address_role_policy.rb @@ -57,7 +57,7 @@ class State::IpAddressRolePolicy < ApplicationPolicy sig { returns(T.untyped) } def resolve - if @user&.admin? || @controller.current_ip_address_role&.admin? + if @user&.admin? @scope else @scope.where(id: nil) # Returns empty relation diff --git a/config/blob_file_location.yml b/config/blob_file_location.yml index f4c22528..f2370779 100644 --- a/config/blob_file_location.yml +++ b/config/blob_file_location.yml @@ -1,14 +1,9 @@ -test: - tmp/blob_files_test +test: tmp/blob_files_test -development: - /mnt/blob_files_development +development: /mnt/blob_files_development -staging: - /mnt/blob_files_production +staging: /mnt/blob_files_production -production: - /mnt/blob_files_production +production: /mnt/blob_files_production -worker: - /mnt/blob_files_production +worker: /mnt/blob_files_production diff --git a/db/structure.sql b/db/structure.sql index 9a4579cd..7a86a831 100644 --- a/db/structure.sql +++ b/db/structure.sql @@ -2696,6 +2696,71 @@ CREATE SEQUENCE public.domain_inkbunny_users_id_seq ALTER SEQUENCE public.domain_inkbunny_users_id_seq OWNED BY public.domain_inkbunny_users.id; +-- +-- Name: domain_perceptual_hashes; Type: TABLE; Schema: public; Owner: - +-- + +CREATE TABLE public.domain_perceptual_hashes ( + id bigint NOT NULL, + thumbnail_id bigint NOT NULL, + algorithm character varying NOT NULL, + hash_value public.vector, + created_at timestamp(6) without time zone NOT NULL, + updated_at timestamp(6) without time zone NOT NULL +); + + +-- +-- Name: domain_perceptual_hashes_id_seq; Type: SEQUENCE; Schema: public; Owner: - +-- + +CREATE SEQUENCE public.domain_perceptual_hashes_id_seq + START WITH 1 + INCREMENT BY 1 + NO MINVALUE + NO MAXVALUE + CACHE 1; + + +-- +-- Name: domain_perceptual_hashes_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: - +-- + +ALTER SEQUENCE public.domain_perceptual_hashes_id_seq OWNED BY public.domain_perceptual_hashes.id; + + +-- +-- Name: domain_post_file_thumbnails; Type: TABLE; Schema: public; Owner: - +-- + +CREATE TABLE public.domain_post_file_thumbnails ( + id bigint NOT NULL, + post_file_id bigint NOT NULL, + thumbnail_type character varying NOT NULL, + created_at timestamp(6) without time zone NOT NULL, + updated_at timestamp(6) without time zone NOT NULL +); + + +-- +-- Name: domain_post_file_thumbnails_id_seq; Type: SEQUENCE; Schema: public; Owner: - +-- + +CREATE SEQUENCE public.domain_post_file_thumbnails_id_seq + START WITH 1 + INCREMENT BY 1 + NO MINVALUE + NO MAXVALUE + CACHE 1; + + +-- +-- Name: domain_post_file_thumbnails_id_seq; Type: SEQUENCE OWNED BY; Schema: public; Owner: - +-- + +ALTER SEQUENCE public.domain_post_file_thumbnails_id_seq OWNED BY public.domain_post_file_thumbnails.id; + + SET default_tablespace = mirai; -- @@ -4588,6 +4653,20 @@ ALTER TABLE ONLY public.domain_inkbunny_tags ALTER COLUMN id SET DEFAULT nextval ALTER TABLE ONLY public.domain_inkbunny_users ALTER COLUMN id SET DEFAULT nextval('public.domain_inkbunny_users_id_seq'::regclass); +-- +-- Name: domain_perceptual_hashes id; Type: DEFAULT; Schema: public; Owner: - +-- + +ALTER TABLE ONLY public.domain_perceptual_hashes ALTER COLUMN id SET DEFAULT nextval('public.domain_perceptual_hashes_id_seq'::regclass); + + +-- +-- Name: domain_post_file_thumbnails id; Type: DEFAULT; Schema: public; Owner: - +-- + +ALTER TABLE ONLY public.domain_post_file_thumbnails ALTER COLUMN id SET DEFAULT nextval('public.domain_post_file_thumbnails_id_seq'::regclass); + + -- -- Name: domain_post_files id; Type: DEFAULT; Schema: public; Owner: - -- @@ -5370,6 +5449,22 @@ ALTER TABLE ONLY public.domain_inkbunny_users ADD CONSTRAINT domain_inkbunny_users_pkey PRIMARY KEY (id); +-- +-- Name: domain_perceptual_hashes domain_perceptual_hashes_pkey; Type: CONSTRAINT; Schema: public; Owner: - +-- + +ALTER TABLE ONLY public.domain_perceptual_hashes + ADD CONSTRAINT domain_perceptual_hashes_pkey PRIMARY KEY (id); + + +-- +-- Name: domain_post_file_thumbnails domain_post_file_thumbnails_pkey; Type: CONSTRAINT; Schema: public; Owner: - +-- + +ALTER TABLE ONLY public.domain_post_file_thumbnails + ADD CONSTRAINT domain_post_file_thumbnails_pkey PRIMARY KEY (id); + + SET default_tablespace = mirai; -- @@ -6971,6 +7066,34 @@ CREATE UNIQUE INDEX index_domain_inkbunny_users_on_ib_user_id ON public.domain_i CREATE INDEX index_domain_inkbunny_users_on_shallow_update_log_entry_id ON public.domain_inkbunny_users USING btree (shallow_update_log_entry_id); +-- +-- Name: index_domain_perceptual_hashes_on_algorithm; Type: INDEX; Schema: public; Owner: - +-- + +CREATE INDEX index_domain_perceptual_hashes_on_algorithm ON public.domain_perceptual_hashes USING btree (algorithm); + + +-- +-- Name: index_domain_perceptual_hashes_on_thumbnail_id; Type: INDEX; Schema: public; Owner: - +-- + +CREATE INDEX index_domain_perceptual_hashes_on_thumbnail_id ON public.domain_perceptual_hashes USING btree (thumbnail_id); + + +-- +-- Name: index_domain_post_file_thumbnails_on_post_file_id; Type: INDEX; Schema: public; Owner: - +-- + +CREATE INDEX index_domain_post_file_thumbnails_on_post_file_id ON public.domain_post_file_thumbnails USING btree (post_file_id); + + +-- +-- Name: index_domain_post_file_thumbnails_on_thumbnail_type; Type: INDEX; Schema: public; Owner: - +-- + +CREATE INDEX index_domain_post_file_thumbnails_on_thumbnail_type ON public.domain_post_file_thumbnails USING btree (thumbnail_type); + + SET default_tablespace = mirai; -- @@ -8434,6 +8557,14 @@ ALTER TABLE ONLY public.domain_fa_follows ADD CONSTRAINT fk_rails_175679b7a2 FOREIGN KEY (followed_id) REFERENCES public.domain_fa_users(id); +-- +-- Name: domain_perceptual_hashes fk_rails_1ae1a89060; Type: FK CONSTRAINT; Schema: public; Owner: - +-- + +ALTER TABLE ONLY public.domain_perceptual_hashes + ADD CONSTRAINT fk_rails_1ae1a89060 FOREIGN KEY (thumbnail_id) REFERENCES public.domain_post_file_thumbnails(id); + + -- -- Name: domain_post_group_joins fk_rails_22154fb920; Type: FK CONSTRAINT; Schema: public; Owner: - -- @@ -8722,6 +8853,14 @@ ALTER TABLE ONLY public.domain_e621_taggings ADD CONSTRAINT fk_rails_da3a488297 FOREIGN KEY (post_id) REFERENCES public.domain_e621_posts(id); +-- +-- Name: domain_post_file_thumbnails fk_rails_dde88b4af5; Type: FK CONSTRAINT; Schema: public; Owner: - +-- + +ALTER TABLE ONLY public.domain_post_file_thumbnails + ADD CONSTRAINT fk_rails_dde88b4af5 FOREIGN KEY (post_file_id) REFERENCES public.domain_post_files(id); + + -- -- Name: domain_inkbunny_follows fk_rails_dffb743e89; Type: FK CONSTRAINT; Schema: public; Owner: - -- @@ -8786,6 +8925,8 @@ SET search_path TO "$user", public; INSERT INTO "schema_migrations" (version) VALUES ('20250302074924'), +('20250301000002'), +('20250301000001'), ('20250226003653'), ('20250222035939'), ('20250206224121'), diff --git a/sorbet/rbi/dsl/application_controller.rbi b/sorbet/rbi/dsl/application_controller.rbi index 5d7bb2f3..51bb2820 100644 --- a/sorbet/rbi/dsl/application_controller.rbi +++ b/sorbet/rbi/dsl/application_controller.rbi @@ -65,7 +65,7 @@ class ApplicationController sig { params(scope: T.untyped).returns(T.untyped) } def pundit_policy_scope(scope); end - sig { returns(T.untyped) } + sig { returns(T.nilable(T.any(::IpAddressRole, ::User))) } def pundit_user; end end diff --git a/sorbet/rbi/dsl/domain/perceptual_hash.rbi b/sorbet/rbi/dsl/domain/perceptual_hash.rbi new file mode 100644 index 00000000..32accdcd --- /dev/null +++ b/sorbet/rbi/dsl/domain/perceptual_hash.rbi @@ -0,0 +1,1407 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `Domain::PerceptualHash`. +# Please instead update this file by running `bin/tapioca dsl Domain::PerceptualHash`. + + +class Domain::PerceptualHash + include GeneratedAssociationMethods + include GeneratedAttributeMethods + extend CommonRelationMethods + extend GeneratedRelationMethods + + sig { returns(ColorLogger) } + def logger; end + + private + + sig { returns(NilClass) } + def to_ary; end + + class << self + sig do + params( + name: Symbol, + type: T.any(Symbol, ActiveModel::Type::Value), + options: T.nilable(T::Hash[Symbol, T.untyped]) + ).void + end + def attr_json(name, type, options = nil); end + + sig do + params( + default_container_attribute: T.nilable(Symbol), + bad_cast: T.nilable(Symbol), + unknown_key: T.nilable(Symbol) + ).void + end + def attr_json_config(default_container_attribute: nil, bad_cast: nil, unknown_key: nil); end + + sig { returns(T::Array[Symbol]) } + def attr_json_registry; end + + sig { returns(ColorLogger) } + def logger; end + + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(::Domain::PerceptualHash) + end + def new(attributes = nil, &block); end + end + + module CommonRelationMethods + sig do + params( + block: T.nilable(T.proc.params(record: ::Domain::PerceptualHash).returns(T.untyped)) + ).returns(T::Boolean) + end + def any?(&block); end + + sig { params(column_name: T.any(String, Symbol)).returns(T.any(Integer, Float, BigDecimal)) } + def average(column_name); end + + sig do + params( + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(::Domain::PerceptualHash) + end + sig do + params( + attributes: T::Array[T.untyped], + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(T::Array[::Domain::PerceptualHash]) + end + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(::Domain::PerceptualHash) + end + def build(attributes = nil, &block); end + + sig { params(operation: Symbol, column_name: T.any(String, Symbol)).returns(T.any(Integer, Float, BigDecimal)) } + def calculate(operation, column_name); end + + sig { params(column_name: T.nilable(T.any(String, Symbol))).returns(Integer) } + sig { params(column_name: NilClass, block: T.proc.params(object: ::Domain::PerceptualHash).void).returns(Integer) } + def count(column_name = nil, &block); end + + sig do + params( + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(::Domain::PerceptualHash) + end + sig do + params( + attributes: T::Array[T.untyped], + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(T::Array[::Domain::PerceptualHash]) + end + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(::Domain::PerceptualHash) + end + def create(attributes = nil, &block); end + + sig do + params( + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(::Domain::PerceptualHash) + end + sig do + params( + attributes: T::Array[T.untyped], + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(T::Array[::Domain::PerceptualHash]) + end + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(::Domain::PerceptualHash) + end + def create!(attributes = nil, &block); end + + sig do + params( + attributes: T::Array[T.untyped], + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(T::Array[::Domain::PerceptualHash]) + end + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(::Domain::PerceptualHash) + end + def create_or_find_by(attributes, &block); end + + sig do + params( + attributes: T::Array[T.untyped], + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(T::Array[::Domain::PerceptualHash]) + end + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(::Domain::PerceptualHash) + end + def create_or_find_by!(attributes, &block); end + + sig { returns(T::Array[::Domain::PerceptualHash]) } + def destroy_all; end + + sig { params(conditions: T.untyped).returns(T::Boolean) } + def exists?(conditions = :none); end + + sig { returns(T.nilable(::Domain::PerceptualHash)) } + def fifth; end + + sig { returns(::Domain::PerceptualHash) } + def fifth!; end + + sig do + params( + args: T.any(String, Symbol, ::ActiveSupport::Multibyte::Chars, T::Boolean, BigDecimal, Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, Date, Time, ::ActiveSupport::Duration, T::Class[T.anything]) + ).returns(::Domain::PerceptualHash) + end + sig do + params( + args: T::Array[T.any(String, Symbol, ::ActiveSupport::Multibyte::Chars, T::Boolean, BigDecimal, Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, Date, Time, ::ActiveSupport::Duration, T::Class[T.anything])] + ).returns(T::Enumerable[::Domain::PerceptualHash]) + end + sig do + params( + args: NilClass, + block: T.proc.params(object: ::Domain::PerceptualHash).void + ).returns(T.nilable(::Domain::PerceptualHash)) + end + def find(args = nil, &block); end + + sig { params(args: T.untyped).returns(T.nilable(::Domain::PerceptualHash)) } + def find_by(*args); end + + sig { params(args: T.untyped).returns(::Domain::PerceptualHash) } + def find_by!(*args); end + + sig do + params( + start: T.untyped, + finish: T.untyped, + batch_size: Integer, + error_on_ignore: T.untyped, + order: Symbol, + block: T.proc.params(object: ::Domain::PerceptualHash).void + ).void + end + sig do + params( + start: T.untyped, + finish: T.untyped, + batch_size: Integer, + error_on_ignore: T.untyped, + order: Symbol + ).returns(T::Enumerator[::Domain::PerceptualHash]) + end + def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block); end + + sig do + params( + start: T.untyped, + finish: T.untyped, + batch_size: Integer, + error_on_ignore: T.untyped, + order: Symbol, + block: T.proc.params(object: T::Array[::Domain::PerceptualHash]).void + ).void + end + sig do + params( + start: T.untyped, + finish: T.untyped, + batch_size: Integer, + error_on_ignore: T.untyped, + order: Symbol + ).returns(T::Enumerator[T::Enumerator[::Domain::PerceptualHash]]) + end + def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block); end + + sig do + params( + attributes: T::Array[T.untyped], + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(T::Array[::Domain::PerceptualHash]) + end + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(::Domain::PerceptualHash) + end + def find_or_create_by(attributes, &block); end + + sig do + params( + attributes: T::Array[T.untyped], + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(T::Array[::Domain::PerceptualHash]) + end + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(::Domain::PerceptualHash) + end + def find_or_create_by!(attributes, &block); end + + sig do + params( + attributes: T::Array[T.untyped], + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(T::Array[::Domain::PerceptualHash]) + end + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(::Domain::PerceptualHash) + end + def find_or_initialize_by(attributes, &block); end + + sig { params(signed_id: T.untyped, purpose: T.untyped).returns(T.nilable(::Domain::PerceptualHash)) } + def find_signed(signed_id, purpose: nil); end + + sig { params(signed_id: T.untyped, purpose: T.untyped).returns(::Domain::PerceptualHash) } + def find_signed!(signed_id, purpose: nil); end + + sig { params(arg: T.untyped, args: T.untyped).returns(::Domain::PerceptualHash) } + def find_sole_by(arg, *args); end + + sig { returns(T.nilable(::Domain::PerceptualHash)) } + sig { params(limit: Integer).returns(T::Array[::Domain::PerceptualHash]) } + def first(limit = nil); end + + sig { returns(::Domain::PerceptualHash) } + def first!; end + + sig { returns(T.nilable(::Domain::PerceptualHash)) } + def forty_two; end + + sig { returns(::Domain::PerceptualHash) } + def forty_two!; end + + sig { returns(T.nilable(::Domain::PerceptualHash)) } + def fourth; end + + sig { returns(::Domain::PerceptualHash) } + def fourth!; end + + sig { returns(Array) } + def ids; end + + sig do + params( + of: Integer, + start: T.untyped, + finish: T.untyped, + load: T.untyped, + error_on_ignore: T.untyped, + order: Symbol, + use_ranges: T.untyped, + block: T.proc.params(object: PrivateRelation).void + ).void + end + sig do + params( + of: Integer, + start: T.untyped, + finish: T.untyped, + load: T.untyped, + error_on_ignore: T.untyped, + order: Symbol, + use_ranges: T.untyped + ).returns(::ActiveRecord::Batches::BatchEnumerator) + end + def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, order: :asc, use_ranges: nil, &block); end + + sig { params(record: T.untyped).returns(T::Boolean) } + def include?(record); end + + sig { returns(T.nilable(::Domain::PerceptualHash)) } + sig { params(limit: Integer).returns(T::Array[::Domain::PerceptualHash]) } + def last(limit = nil); end + + sig { returns(::Domain::PerceptualHash) } + def last!; end + + sig do + params( + block: T.nilable(T.proc.params(record: ::Domain::PerceptualHash).returns(T.untyped)) + ).returns(T::Boolean) + end + def many?(&block); end + + sig { params(column_name: T.any(String, Symbol)).returns(T.untyped) } + def maximum(column_name); end + + sig { params(record: T.untyped).returns(T::Boolean) } + def member?(record); end + + sig { params(column_name: T.any(String, Symbol)).returns(T.untyped) } + def minimum(column_name); end + + sig do + params( + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(::Domain::PerceptualHash) + end + sig do + params( + attributes: T::Array[T.untyped], + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(T::Array[::Domain::PerceptualHash]) + end + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::Domain::PerceptualHash).void) + ).returns(::Domain::PerceptualHash) + end + def new(attributes = nil, &block); end + + sig do + params( + block: T.nilable(T.proc.params(record: ::Domain::PerceptualHash).returns(T.untyped)) + ).returns(T::Boolean) + end + def none?(&block); end + + sig do + params( + block: T.nilable(T.proc.params(record: ::Domain::PerceptualHash).returns(T.untyped)) + ).returns(T::Boolean) + end + def one?(&block); end + + sig { params(column_names: T.untyped).returns(T.untyped) } + def pick(*column_names); end + + sig { params(column_names: T.untyped).returns(T.untyped) } + def pluck(*column_names); end + + sig { returns(T.nilable(::Domain::PerceptualHash)) } + def second; end + + sig { returns(::Domain::PerceptualHash) } + def second!; end + + sig { returns(T.nilable(::Domain::PerceptualHash)) } + def second_to_last; end + + sig { returns(::Domain::PerceptualHash) } + def second_to_last!; end + + sig { returns(::Domain::PerceptualHash) } + def sole; end + + sig { params(initial_value_or_column: T.untyped).returns(T.any(Integer, Float, BigDecimal)) } + sig do + type_parameters(:U) + .params( + initial_value_or_column: T.nilable(T.type_parameter(:U)), + block: T.proc.params(object: ::Domain::PerceptualHash).returns(T.type_parameter(:U)) + ).returns(T.type_parameter(:U)) + end + def sum(initial_value_or_column = nil, &block); end + + sig { returns(T.nilable(::Domain::PerceptualHash)) } + sig { params(limit: Integer).returns(T::Array[::Domain::PerceptualHash]) } + def take(limit = nil); end + + sig { returns(::Domain::PerceptualHash) } + def take!; end + + sig { returns(T.nilable(::Domain::PerceptualHash)) } + def third; end + + sig { returns(::Domain::PerceptualHash) } + def third!; end + + sig { returns(T.nilable(::Domain::PerceptualHash)) } + def third_to_last; end + + sig { returns(::Domain::PerceptualHash) } + def third_to_last!; end + end + + module GeneratedAssociationMethods + sig { params(args: T.untyped, blk: T.untyped).returns(::Domain::PostFileThumbnail) } + def build_thumbnail(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(::Domain::PostFileThumbnail) } + def create_thumbnail(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(::Domain::PostFileThumbnail) } + def create_thumbnail!(*args, &blk); end + + sig { returns(T.nilable(::Domain::PostFileThumbnail)) } + def reload_thumbnail; end + + sig { void } + def reset_thumbnail; end + + sig { returns(T.nilable(::Domain::PostFileThumbnail)) } + def thumbnail; end + + sig { params(value: T.nilable(::Domain::PostFileThumbnail)).void } + def thumbnail=(value); end + + sig { returns(T::Boolean) } + def thumbnail_changed?; end + + sig { returns(T::Boolean) } + def thumbnail_previously_changed?; end + end + + module GeneratedAssociationRelationMethods + sig { returns(PrivateAssociationRelation) } + def all; end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def and(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def annotate(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def arel_columns(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def create_with(*args, &blk); end + + sig { params(value: T::Boolean).returns(PrivateAssociationRelation) } + def distinct(value = true); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def eager_load(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def except(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def excluding(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def extending(*args, &blk); end + + sig { params(association: Symbol).returns(T::Array[T.untyped]) } + def extract_associated(association); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def from(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelationGroupChain) } + def group(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def having(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def in_order_of(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def includes(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def invert_where(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def joins(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def left_joins(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def left_outer_joins(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def limit(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def lock(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def merge(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def none(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def null_relation?(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def offset(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def only(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def optimizer_hints(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def or(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def order(*args, &blk); end + + sig do + params( + num: T.any(Integer, String) + ).returns(T.all(PrivateAssociationRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods)) + end + def page(num = nil); end + + sig do + params( + num: Integer + ).returns(T.all(PrivateAssociationRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods)) + end + def per(num); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def preload(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def readonly(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def references(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def regroup(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def reorder(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def reselect(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def reverse_order(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def rewhere(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def select(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def strict_loading(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def structurally_compatible?(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def uniq!(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def unscope(*args, &blk); end + + sig { returns(PrivateAssociationRelationWhereChain) } + sig { params(args: T.untyped).returns(PrivateAssociationRelation) } + def where(*args); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def with(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def with_recursive(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def without(*args, &blk); end + + sig do + returns(T.all(PrivateAssociationRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods)) + end + def without_count; end + end + + module GeneratedAttributeMethods + sig { returns(T.nilable(::String)) } + def algorithm; end + + sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) } + def algorithm=(value); end + + sig { returns(T::Boolean) } + def algorithm?; end + + sig { returns(T.nilable(::String)) } + def algorithm_before_last_save; end + + sig { returns(T.untyped) } + def algorithm_before_type_cast; end + + sig { returns(T::Boolean) } + def algorithm_came_from_user?; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def algorithm_change; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def algorithm_change_to_be_saved; end + + sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } + def algorithm_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::String)) } + def algorithm_in_database; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def algorithm_previous_change; end + + sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } + def algorithm_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::String)) } + def algorithm_previously_was; end + + sig { returns(T.nilable(::String)) } + def algorithm_was; end + + sig { void } + def algorithm_will_change!; end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def created_at; end + + sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def created_at=(value); end + + sig { returns(T::Boolean) } + def created_at?; end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def created_at_before_last_save; end + + sig { returns(T.untyped) } + def created_at_before_type_cast; end + + sig { returns(T::Boolean) } + def created_at_came_from_user?; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def created_at_change; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def created_at_change_to_be_saved; end + + sig do + params( + from: T.nilable(::ActiveSupport::TimeWithZone), + to: T.nilable(::ActiveSupport::TimeWithZone) + ).returns(T::Boolean) + end + def created_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def created_at_in_database; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def created_at_previous_change; end + + sig do + params( + from: T.nilable(::ActiveSupport::TimeWithZone), + to: T.nilable(::ActiveSupport::TimeWithZone) + ).returns(T::Boolean) + end + def created_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def created_at_previously_was; end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def created_at_was; end + + sig { void } + def created_at_will_change!; end + + sig { returns(T.untyped) } + def hash_value; end + + sig { params(value: T.untyped).returns(T.untyped) } + def hash_value=(value); end + + sig { returns(T::Boolean) } + def hash_value?; end + + sig { returns(T.untyped) } + def hash_value_before_last_save; end + + sig { returns(T.untyped) } + def hash_value_before_type_cast; end + + sig { returns(T::Boolean) } + def hash_value_came_from_user?; end + + sig { returns(T.nilable([T.untyped, T.untyped])) } + def hash_value_change; end + + sig { returns(T.nilable([T.untyped, T.untyped])) } + def hash_value_change_to_be_saved; end + + sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) } + def hash_value_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.untyped) } + def hash_value_in_database; end + + sig { returns(T.nilable([T.untyped, T.untyped])) } + def hash_value_previous_change; end + + sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) } + def hash_value_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.untyped) } + def hash_value_previously_was; end + + sig { returns(T.untyped) } + def hash_value_was; end + + sig { void } + def hash_value_will_change!; end + + sig { returns(T.nilable(::Integer)) } + def id; end + + sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) } + def id=(value); end + + sig { returns(T::Boolean) } + def id?; end + + sig { returns(T.nilable(::Integer)) } + def id_before_last_save; end + + sig { returns(T.untyped) } + def id_before_type_cast; end + + sig { returns(T::Boolean) } + def id_came_from_user?; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def id_change; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def id_change_to_be_saved; end + + sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) } + def id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::Integer)) } + def id_in_database; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def id_previous_change; end + + sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) } + def id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::Integer)) } + def id_previously_was; end + + sig { returns(T.nilable(::Integer)) } + def id_value; end + + sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) } + def id_value=(value); end + + sig { returns(T::Boolean) } + def id_value?; end + + sig { returns(T.nilable(::Integer)) } + def id_value_before_last_save; end + + sig { returns(T.untyped) } + def id_value_before_type_cast; end + + sig { returns(T::Boolean) } + def id_value_came_from_user?; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def id_value_change; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def id_value_change_to_be_saved; end + + sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) } + def id_value_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::Integer)) } + def id_value_in_database; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def id_value_previous_change; end + + sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) } + def id_value_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::Integer)) } + def id_value_previously_was; end + + sig { returns(T.nilable(::Integer)) } + def id_value_was; end + + sig { void } + def id_value_will_change!; end + + sig { returns(T.nilable(::Integer)) } + def id_was; end + + sig { void } + def id_will_change!; end + + sig { void } + def restore_algorithm!; end + + sig { void } + def restore_created_at!; end + + sig { void } + def restore_hash_value!; end + + sig { void } + def restore_id!; end + + sig { void } + def restore_id_value!; end + + sig { void } + def restore_thumbnail_id!; end + + sig { void } + def restore_updated_at!; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def saved_change_to_algorithm; end + + sig { returns(T::Boolean) } + def saved_change_to_algorithm?; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def saved_change_to_created_at; end + + sig { returns(T::Boolean) } + def saved_change_to_created_at?; end + + sig { returns(T.nilable([T.untyped, T.untyped])) } + def saved_change_to_hash_value; end + + sig { returns(T::Boolean) } + def saved_change_to_hash_value?; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def saved_change_to_id; end + + sig { returns(T::Boolean) } + def saved_change_to_id?; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def saved_change_to_id_value; end + + sig { returns(T::Boolean) } + def saved_change_to_id_value?; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def saved_change_to_thumbnail_id; end + + sig { returns(T::Boolean) } + def saved_change_to_thumbnail_id?; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def saved_change_to_updated_at; end + + sig { returns(T::Boolean) } + def saved_change_to_updated_at?; end + + sig { returns(T.nilable(::Integer)) } + def thumbnail_id; end + + sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) } + def thumbnail_id=(value); end + + sig { returns(T::Boolean) } + def thumbnail_id?; end + + sig { returns(T.nilable(::Integer)) } + def thumbnail_id_before_last_save; end + + sig { returns(T.untyped) } + def thumbnail_id_before_type_cast; end + + sig { returns(T::Boolean) } + def thumbnail_id_came_from_user?; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def thumbnail_id_change; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def thumbnail_id_change_to_be_saved; end + + sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) } + def thumbnail_id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::Integer)) } + def thumbnail_id_in_database; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def thumbnail_id_previous_change; end + + sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) } + def thumbnail_id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::Integer)) } + def thumbnail_id_previously_was; end + + sig { returns(T.nilable(::Integer)) } + def thumbnail_id_was; end + + sig { void } + def thumbnail_id_will_change!; end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def updated_at; end + + sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def updated_at=(value); end + + sig { returns(T::Boolean) } + def updated_at?; end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def updated_at_before_last_save; end + + sig { returns(T.untyped) } + def updated_at_before_type_cast; end + + sig { returns(T::Boolean) } + def updated_at_came_from_user?; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def updated_at_change; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def updated_at_change_to_be_saved; end + + sig do + params( + from: T.nilable(::ActiveSupport::TimeWithZone), + to: T.nilable(::ActiveSupport::TimeWithZone) + ).returns(T::Boolean) + end + def updated_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def updated_at_in_database; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def updated_at_previous_change; end + + sig do + params( + from: T.nilable(::ActiveSupport::TimeWithZone), + to: T.nilable(::ActiveSupport::TimeWithZone) + ).returns(T::Boolean) + end + def updated_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def updated_at_previously_was; end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def updated_at_was; end + + sig { void } + def updated_at_will_change!; end + + sig { returns(T::Boolean) } + def will_save_change_to_algorithm?; end + + sig { returns(T::Boolean) } + def will_save_change_to_created_at?; end + + sig { returns(T::Boolean) } + def will_save_change_to_hash_value?; end + + sig { returns(T::Boolean) } + def will_save_change_to_id?; end + + sig { returns(T::Boolean) } + def will_save_change_to_id_value?; end + + sig { returns(T::Boolean) } + def will_save_change_to_thumbnail_id?; end + + sig { returns(T::Boolean) } + def will_save_change_to_updated_at?; end + end + + module GeneratedRelationMethods + sig { returns(PrivateRelation) } + def all; end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def and(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def annotate(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def arel_columns(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def create_with(*args, &blk); end + + sig { params(value: T::Boolean).returns(PrivateRelation) } + def distinct(value = true); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def eager_load(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def except(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def excluding(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def extending(*args, &blk); end + + sig { params(association: Symbol).returns(T::Array[T.untyped]) } + def extract_associated(association); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def from(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelationGroupChain) } + def group(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def having(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def in_order_of(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def includes(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def invert_where(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def joins(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def left_joins(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def left_outer_joins(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def limit(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def lock(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def merge(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def none(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def null_relation?(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def offset(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def only(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def optimizer_hints(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def or(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def order(*args, &blk); end + + sig do + params( + num: T.any(Integer, String) + ).returns(T.all(PrivateRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods)) + end + def page(num = nil); end + + sig do + params( + num: Integer + ).returns(T.all(PrivateRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods)) + end + def per(num); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def preload(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def readonly(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def references(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def regroup(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def reorder(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def reselect(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def reverse_order(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def rewhere(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def select(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def strict_loading(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def structurally_compatible?(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def uniq!(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def unscope(*args, &blk); end + + sig { returns(PrivateRelationWhereChain) } + sig { params(args: T.untyped).returns(PrivateRelation) } + def where(*args); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def with(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def with_recursive(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def without(*args, &blk); end + + sig { returns(T.all(PrivateRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods)) } + def without_count; end + end + + class PrivateAssociationRelation < ::ActiveRecord::AssociationRelation + include CommonRelationMethods + include GeneratedAssociationRelationMethods + + Elem = type_member { { fixed: ::Domain::PerceptualHash } } + + sig { returns(T::Array[::Domain::PerceptualHash]) } + def to_a; end + + sig { returns(T::Array[::Domain::PerceptualHash]) } + def to_ary; end + end + + class PrivateAssociationRelationGroupChain < PrivateAssociationRelation + Elem = type_member { { fixed: ::Domain::PerceptualHash } } + + sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) } + def average(column_name); end + + sig do + params( + operation: Symbol, + column_name: T.any(String, Symbol) + ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) + end + def calculate(operation, column_name); end + + sig { params(column_name: T.untyped).returns(T::Hash[T.untyped, Integer]) } + def count(column_name = nil); end + + sig { params(args: T.untyped, blk: T.untyped).returns(T.self_type) } + def having(*args, &blk); end + + sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) } + def maximum(column_name); end + + sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) } + def minimum(column_name); end + + sig do + params( + column_name: T.nilable(T.any(String, Symbol)), + block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped)) + ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) + end + def sum(column_name = nil, &block); end + end + + class PrivateAssociationRelationWhereChain + Elem = type_member { { fixed: ::Domain::PerceptualHash } } + + sig { params(args: T.untyped).returns(PrivateAssociationRelation) } + def associated(*args); end + + sig { params(args: T.untyped).returns(PrivateAssociationRelation) } + def missing(*args); end + + sig { params(opts: T.untyped, rest: T.untyped).returns(PrivateAssociationRelation) } + def not(opts, *rest); end + end + + class PrivateCollectionProxy < ::ActiveRecord::Associations::CollectionProxy + include CommonRelationMethods + include GeneratedAssociationRelationMethods + + Elem = type_member { { fixed: ::Domain::PerceptualHash } } + + sig do + params( + records: T.any(::Domain::PerceptualHash, T::Enumerable[T.any(::Domain::PerceptualHash, T::Enumerable[::Domain::PerceptualHash])]) + ).returns(PrivateCollectionProxy) + end + def <<(*records); end + + sig do + params( + records: T.any(::Domain::PerceptualHash, T::Enumerable[T.any(::Domain::PerceptualHash, T::Enumerable[::Domain::PerceptualHash])]) + ).returns(PrivateCollectionProxy) + end + def append(*records); end + + sig { returns(PrivateCollectionProxy) } + def clear; end + + sig do + params( + records: T.any(::Domain::PerceptualHash, T::Enumerable[T.any(::Domain::PerceptualHash, T::Enumerable[::Domain::PerceptualHash])]) + ).returns(PrivateCollectionProxy) + end + def concat(*records); end + + sig { returns(T::Array[::Domain::PerceptualHash]) } + def load_target; end + + sig do + params( + records: T.any(::Domain::PerceptualHash, T::Enumerable[T.any(::Domain::PerceptualHash, T::Enumerable[::Domain::PerceptualHash])]) + ).returns(PrivateCollectionProxy) + end + def prepend(*records); end + + sig do + params( + records: T.any(::Domain::PerceptualHash, T::Enumerable[T.any(::Domain::PerceptualHash, T::Enumerable[::Domain::PerceptualHash])]) + ).returns(PrivateCollectionProxy) + end + def push(*records); end + + sig do + params( + other_array: T.any(::Domain::PerceptualHash, T::Enumerable[T.any(::Domain::PerceptualHash, T::Enumerable[::Domain::PerceptualHash])]) + ).returns(T::Array[::Domain::PerceptualHash]) + end + def replace(other_array); end + + sig { returns(PrivateAssociationRelation) } + def scope; end + + sig { returns(T::Array[::Domain::PerceptualHash]) } + def target; end + + sig { returns(T::Array[::Domain::PerceptualHash]) } + def to_a; end + + sig { returns(T::Array[::Domain::PerceptualHash]) } + def to_ary; end + end + + class PrivateRelation < ::ActiveRecord::Relation + include CommonRelationMethods + include GeneratedRelationMethods + + Elem = type_member { { fixed: ::Domain::PerceptualHash } } + + sig { returns(T::Array[::Domain::PerceptualHash]) } + def to_a; end + + sig { returns(T::Array[::Domain::PerceptualHash]) } + def to_ary; end + end + + class PrivateRelationGroupChain < PrivateRelation + Elem = type_member { { fixed: ::Domain::PerceptualHash } } + + sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) } + def average(column_name); end + + sig do + params( + operation: Symbol, + column_name: T.any(String, Symbol) + ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) + end + def calculate(operation, column_name); end + + sig { params(column_name: T.untyped).returns(T::Hash[T.untyped, Integer]) } + def count(column_name = nil); end + + sig { params(args: T.untyped, blk: T.untyped).returns(T.self_type) } + def having(*args, &blk); end + + sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) } + def maximum(column_name); end + + sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) } + def minimum(column_name); end + + sig do + params( + column_name: T.nilable(T.any(String, Symbol)), + block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped)) + ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) + end + def sum(column_name = nil, &block); end + end + + class PrivateRelationWhereChain + Elem = type_member { { fixed: ::Domain::PerceptualHash } } + + sig { params(args: T.untyped).returns(PrivateRelation) } + def associated(*args); end + + sig { params(args: T.untyped).returns(PrivateRelation) } + def missing(*args); end + + sig { params(opts: T.untyped, rest: T.untyped).returns(PrivateRelation) } + def not(opts, *rest); end + end +end diff --git a/sorbet/rbi/dsl/domain/post_file.rbi b/sorbet/rbi/dsl/domain/post_file.rbi index fc848950..1e8c4ccf 100644 --- a/sorbet/rbi/dsl/domain/post_file.rbi +++ b/sorbet/rbi/dsl/domain/post_file.rbi @@ -533,6 +533,20 @@ class Domain::PostFile sig { void } def reset_post; end + + sig { returns(T::Array[T.untyped]) } + def thumbnail_ids; end + + sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) } + def thumbnail_ids=(ids); end + + # This method is created by ActiveRecord on the `Domain::PostFile` class because it declared `has_many :thumbnails`. + # 🔗 [Rails guide for `has_many` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-association) + sig { returns(::Domain::PostFileThumbnail::PrivateCollectionProxy) } + def thumbnails; end + + sig { params(value: T::Enumerable[::Domain::PostFileThumbnail]).void } + def thumbnails=(value); end end module GeneratedAssociationRelationMethods diff --git a/sorbet/rbi/dsl/domain/post_file/inkbunny_post_file.rbi b/sorbet/rbi/dsl/domain/post_file/inkbunny_post_file.rbi index 1b11fa45..1bfa51db 100644 --- a/sorbet/rbi/dsl/domain/post_file/inkbunny_post_file.rbi +++ b/sorbet/rbi/dsl/domain/post_file/inkbunny_post_file.rbi @@ -516,6 +516,20 @@ class Domain::PostFile::InkbunnyPostFile sig { void } def reset_post; end + + sig { returns(T::Array[T.untyped]) } + def thumbnail_ids; end + + sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) } + def thumbnail_ids=(ids); end + + # This method is created by ActiveRecord on the `Domain::PostFile` class because it declared `has_many :thumbnails`. + # 🔗 [Rails guide for `has_many` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-association) + sig { returns(::Domain::PostFileThumbnail::PrivateCollectionProxy) } + def thumbnails; end + + sig { params(value: T::Enumerable[::Domain::PostFileThumbnail]).void } + def thumbnails=(value); end end module GeneratedAssociationRelationMethods diff --git a/sorbet/rbi/dsl/domain/post_file_thumbnail.rbi b/sorbet/rbi/dsl/domain/post_file_thumbnail.rbi new file mode 100644 index 00000000..e1bc50c7 --- /dev/null +++ b/sorbet/rbi/dsl/domain/post_file_thumbnail.rbi @@ -0,0 +1,1369 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for dynamic methods in `Domain::PostFileThumbnail`. +# Please instead update this file by running `bin/tapioca dsl Domain::PostFileThumbnail`. + + +class Domain::PostFileThumbnail + include GeneratedAssociationMethods + include GeneratedAttributeMethods + extend CommonRelationMethods + extend GeneratedRelationMethods + + sig { returns(ColorLogger) } + def logger; end + + private + + sig { returns(NilClass) } + def to_ary; end + + class << self + sig do + params( + name: Symbol, + type: T.any(Symbol, ActiveModel::Type::Value), + options: T.nilable(T::Hash[Symbol, T.untyped]) + ).void + end + def attr_json(name, type, options = nil); end + + sig do + params( + default_container_attribute: T.nilable(Symbol), + bad_cast: T.nilable(Symbol), + unknown_key: T.nilable(Symbol) + ).void + end + def attr_json_config(default_container_attribute: nil, bad_cast: nil, unknown_key: nil); end + + sig { returns(T::Array[Symbol]) } + def attr_json_registry; end + + sig { returns(ColorLogger) } + def logger; end + + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(::Domain::PostFileThumbnail) + end + def new(attributes = nil, &block); end + end + + module CommonRelationMethods + sig do + params( + block: T.nilable(T.proc.params(record: ::Domain::PostFileThumbnail).returns(T.untyped)) + ).returns(T::Boolean) + end + def any?(&block); end + + sig { params(column_name: T.any(String, Symbol)).returns(T.any(Integer, Float, BigDecimal)) } + def average(column_name); end + + sig do + params( + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(::Domain::PostFileThumbnail) + end + sig do + params( + attributes: T::Array[T.untyped], + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(T::Array[::Domain::PostFileThumbnail]) + end + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(::Domain::PostFileThumbnail) + end + def build(attributes = nil, &block); end + + sig { params(operation: Symbol, column_name: T.any(String, Symbol)).returns(T.any(Integer, Float, BigDecimal)) } + def calculate(operation, column_name); end + + sig { params(column_name: T.nilable(T.any(String, Symbol))).returns(Integer) } + sig do + params( + column_name: NilClass, + block: T.proc.params(object: ::Domain::PostFileThumbnail).void + ).returns(Integer) + end + def count(column_name = nil, &block); end + + sig do + params( + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(::Domain::PostFileThumbnail) + end + sig do + params( + attributes: T::Array[T.untyped], + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(T::Array[::Domain::PostFileThumbnail]) + end + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(::Domain::PostFileThumbnail) + end + def create(attributes = nil, &block); end + + sig do + params( + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(::Domain::PostFileThumbnail) + end + sig do + params( + attributes: T::Array[T.untyped], + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(T::Array[::Domain::PostFileThumbnail]) + end + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(::Domain::PostFileThumbnail) + end + def create!(attributes = nil, &block); end + + sig do + params( + attributes: T::Array[T.untyped], + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(T::Array[::Domain::PostFileThumbnail]) + end + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(::Domain::PostFileThumbnail) + end + def create_or_find_by(attributes, &block); end + + sig do + params( + attributes: T::Array[T.untyped], + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(T::Array[::Domain::PostFileThumbnail]) + end + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(::Domain::PostFileThumbnail) + end + def create_or_find_by!(attributes, &block); end + + sig { returns(T::Array[::Domain::PostFileThumbnail]) } + def destroy_all; end + + sig { params(conditions: T.untyped).returns(T::Boolean) } + def exists?(conditions = :none); end + + sig { returns(T.nilable(::Domain::PostFileThumbnail)) } + def fifth; end + + sig { returns(::Domain::PostFileThumbnail) } + def fifth!; end + + sig do + params( + args: T.any(String, Symbol, ::ActiveSupport::Multibyte::Chars, T::Boolean, BigDecimal, Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, Date, Time, ::ActiveSupport::Duration, T::Class[T.anything]) + ).returns(::Domain::PostFileThumbnail) + end + sig do + params( + args: T::Array[T.any(String, Symbol, ::ActiveSupport::Multibyte::Chars, T::Boolean, BigDecimal, Numeric, ::ActiveRecord::Type::Binary::Data, ::ActiveRecord::Type::Time::Value, Date, Time, ::ActiveSupport::Duration, T::Class[T.anything])] + ).returns(T::Enumerable[::Domain::PostFileThumbnail]) + end + sig do + params( + args: NilClass, + block: T.proc.params(object: ::Domain::PostFileThumbnail).void + ).returns(T.nilable(::Domain::PostFileThumbnail)) + end + def find(args = nil, &block); end + + sig { params(args: T.untyped).returns(T.nilable(::Domain::PostFileThumbnail)) } + def find_by(*args); end + + sig { params(args: T.untyped).returns(::Domain::PostFileThumbnail) } + def find_by!(*args); end + + sig do + params( + start: T.untyped, + finish: T.untyped, + batch_size: Integer, + error_on_ignore: T.untyped, + order: Symbol, + block: T.proc.params(object: ::Domain::PostFileThumbnail).void + ).void + end + sig do + params( + start: T.untyped, + finish: T.untyped, + batch_size: Integer, + error_on_ignore: T.untyped, + order: Symbol + ).returns(T::Enumerator[::Domain::PostFileThumbnail]) + end + def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block); end + + sig do + params( + start: T.untyped, + finish: T.untyped, + batch_size: Integer, + error_on_ignore: T.untyped, + order: Symbol, + block: T.proc.params(object: T::Array[::Domain::PostFileThumbnail]).void + ).void + end + sig do + params( + start: T.untyped, + finish: T.untyped, + batch_size: Integer, + error_on_ignore: T.untyped, + order: Symbol + ).returns(T::Enumerator[T::Enumerator[::Domain::PostFileThumbnail]]) + end + def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block); end + + sig do + params( + attributes: T::Array[T.untyped], + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(T::Array[::Domain::PostFileThumbnail]) + end + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(::Domain::PostFileThumbnail) + end + def find_or_create_by(attributes, &block); end + + sig do + params( + attributes: T::Array[T.untyped], + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(T::Array[::Domain::PostFileThumbnail]) + end + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(::Domain::PostFileThumbnail) + end + def find_or_create_by!(attributes, &block); end + + sig do + params( + attributes: T::Array[T.untyped], + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(T::Array[::Domain::PostFileThumbnail]) + end + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(::Domain::PostFileThumbnail) + end + def find_or_initialize_by(attributes, &block); end + + sig { params(signed_id: T.untyped, purpose: T.untyped).returns(T.nilable(::Domain::PostFileThumbnail)) } + def find_signed(signed_id, purpose: nil); end + + sig { params(signed_id: T.untyped, purpose: T.untyped).returns(::Domain::PostFileThumbnail) } + def find_signed!(signed_id, purpose: nil); end + + sig { params(arg: T.untyped, args: T.untyped).returns(::Domain::PostFileThumbnail) } + def find_sole_by(arg, *args); end + + sig { returns(T.nilable(::Domain::PostFileThumbnail)) } + sig { params(limit: Integer).returns(T::Array[::Domain::PostFileThumbnail]) } + def first(limit = nil); end + + sig { returns(::Domain::PostFileThumbnail) } + def first!; end + + sig { returns(T.nilable(::Domain::PostFileThumbnail)) } + def forty_two; end + + sig { returns(::Domain::PostFileThumbnail) } + def forty_two!; end + + sig { returns(T.nilable(::Domain::PostFileThumbnail)) } + def fourth; end + + sig { returns(::Domain::PostFileThumbnail) } + def fourth!; end + + sig { returns(Array) } + def ids; end + + sig do + params( + of: Integer, + start: T.untyped, + finish: T.untyped, + load: T.untyped, + error_on_ignore: T.untyped, + order: Symbol, + use_ranges: T.untyped, + block: T.proc.params(object: PrivateRelation).void + ).void + end + sig do + params( + of: Integer, + start: T.untyped, + finish: T.untyped, + load: T.untyped, + error_on_ignore: T.untyped, + order: Symbol, + use_ranges: T.untyped + ).returns(::ActiveRecord::Batches::BatchEnumerator) + end + def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, order: :asc, use_ranges: nil, &block); end + + sig { params(record: T.untyped).returns(T::Boolean) } + def include?(record); end + + sig { returns(T.nilable(::Domain::PostFileThumbnail)) } + sig { params(limit: Integer).returns(T::Array[::Domain::PostFileThumbnail]) } + def last(limit = nil); end + + sig { returns(::Domain::PostFileThumbnail) } + def last!; end + + sig do + params( + block: T.nilable(T.proc.params(record: ::Domain::PostFileThumbnail).returns(T.untyped)) + ).returns(T::Boolean) + end + def many?(&block); end + + sig { params(column_name: T.any(String, Symbol)).returns(T.untyped) } + def maximum(column_name); end + + sig { params(record: T.untyped).returns(T::Boolean) } + def member?(record); end + + sig { params(column_name: T.any(String, Symbol)).returns(T.untyped) } + def minimum(column_name); end + + sig do + params( + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(::Domain::PostFileThumbnail) + end + sig do + params( + attributes: T::Array[T.untyped], + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(T::Array[::Domain::PostFileThumbnail]) + end + sig do + params( + attributes: T.untyped, + block: T.nilable(T.proc.params(object: ::Domain::PostFileThumbnail).void) + ).returns(::Domain::PostFileThumbnail) + end + def new(attributes = nil, &block); end + + sig do + params( + block: T.nilable(T.proc.params(record: ::Domain::PostFileThumbnail).returns(T.untyped)) + ).returns(T::Boolean) + end + def none?(&block); end + + sig do + params( + block: T.nilable(T.proc.params(record: ::Domain::PostFileThumbnail).returns(T.untyped)) + ).returns(T::Boolean) + end + def one?(&block); end + + sig { params(column_names: T.untyped).returns(T.untyped) } + def pick(*column_names); end + + sig { params(column_names: T.untyped).returns(T.untyped) } + def pluck(*column_names); end + + sig { returns(T.nilable(::Domain::PostFileThumbnail)) } + def second; end + + sig { returns(::Domain::PostFileThumbnail) } + def second!; end + + sig { returns(T.nilable(::Domain::PostFileThumbnail)) } + def second_to_last; end + + sig { returns(::Domain::PostFileThumbnail) } + def second_to_last!; end + + sig { returns(::Domain::PostFileThumbnail) } + def sole; end + + sig { params(initial_value_or_column: T.untyped).returns(T.any(Integer, Float, BigDecimal)) } + sig do + type_parameters(:U) + .params( + initial_value_or_column: T.nilable(T.type_parameter(:U)), + block: T.proc.params(object: ::Domain::PostFileThumbnail).returns(T.type_parameter(:U)) + ).returns(T.type_parameter(:U)) + end + def sum(initial_value_or_column = nil, &block); end + + sig { returns(T.nilable(::Domain::PostFileThumbnail)) } + sig { params(limit: Integer).returns(T::Array[::Domain::PostFileThumbnail]) } + def take(limit = nil); end + + sig { returns(::Domain::PostFileThumbnail) } + def take!; end + + sig { returns(T.nilable(::Domain::PostFileThumbnail)) } + def third; end + + sig { returns(::Domain::PostFileThumbnail) } + def third!; end + + sig { returns(T.nilable(::Domain::PostFileThumbnail)) } + def third_to_last; end + + sig { returns(::Domain::PostFileThumbnail) } + def third_to_last!; end + end + + module GeneratedAssociationMethods + sig { params(args: T.untyped, blk: T.untyped).returns(::Domain::PostFile) } + def build_post_file(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(::Domain::PostFile) } + def create_post_file(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(::Domain::PostFile) } + def create_post_file!(*args, &blk); end + + sig { returns(T::Array[T.untyped]) } + def perceptual_hash_ids; end + + sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) } + def perceptual_hash_ids=(ids); end + + # This method is created by ActiveRecord on the `Domain::PostFileThumbnail` class because it declared `has_many :perceptual_hashes`. + # 🔗 [Rails guide for `has_many` association](https://guides.rubyonrails.org/association_basics.html#the-has-many-association) + sig { returns(::Domain::PerceptualHash::PrivateCollectionProxy) } + def perceptual_hashes; end + + sig { params(value: T::Enumerable[::Domain::PerceptualHash]).void } + def perceptual_hashes=(value); end + + sig { returns(T.nilable(::Domain::PostFile)) } + def post_file; end + + sig { params(value: T.nilable(::Domain::PostFile)).void } + def post_file=(value); end + + sig { returns(T::Boolean) } + def post_file_changed?; end + + sig { returns(T::Boolean) } + def post_file_previously_changed?; end + + sig { returns(T.nilable(::Domain::PostFile)) } + def reload_post_file; end + + sig { void } + def reset_post_file; end + end + + module GeneratedAssociationRelationMethods + sig { returns(PrivateAssociationRelation) } + def all; end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def and(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def annotate(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def arel_columns(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def create_with(*args, &blk); end + + sig { params(value: T::Boolean).returns(PrivateAssociationRelation) } + def distinct(value = true); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def eager_load(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def except(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def excluding(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def extending(*args, &blk); end + + sig { params(association: Symbol).returns(T::Array[T.untyped]) } + def extract_associated(association); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def from(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelationGroupChain) } + def group(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def having(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def in_order_of(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def includes(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def invert_where(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def joins(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def left_joins(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def left_outer_joins(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def limit(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def lock(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def merge(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def none(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def null_relation?(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def offset(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def only(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def optimizer_hints(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def or(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def order(*args, &blk); end + + sig do + params( + num: T.any(Integer, String) + ).returns(T.all(PrivateAssociationRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods)) + end + def page(num = nil); end + + sig do + params( + num: Integer + ).returns(T.all(PrivateAssociationRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods)) + end + def per(num); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def preload(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def readonly(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def references(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def regroup(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def reorder(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def reselect(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def reverse_order(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def rewhere(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def select(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def strict_loading(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def structurally_compatible?(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def uniq!(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def unscope(*args, &blk); end + + sig { returns(PrivateAssociationRelationWhereChain) } + sig { params(args: T.untyped).returns(PrivateAssociationRelation) } + def where(*args); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def with(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def with_recursive(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } + def without(*args, &blk); end + + sig do + returns(T.all(PrivateAssociationRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods)) + end + def without_count; end + end + + module GeneratedAttributeMethods + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def created_at; end + + sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def created_at=(value); end + + sig { returns(T::Boolean) } + def created_at?; end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def created_at_before_last_save; end + + sig { returns(T.untyped) } + def created_at_before_type_cast; end + + sig { returns(T::Boolean) } + def created_at_came_from_user?; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def created_at_change; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def created_at_change_to_be_saved; end + + sig do + params( + from: T.nilable(::ActiveSupport::TimeWithZone), + to: T.nilable(::ActiveSupport::TimeWithZone) + ).returns(T::Boolean) + end + def created_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def created_at_in_database; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def created_at_previous_change; end + + sig do + params( + from: T.nilable(::ActiveSupport::TimeWithZone), + to: T.nilable(::ActiveSupport::TimeWithZone) + ).returns(T::Boolean) + end + def created_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def created_at_previously_was; end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def created_at_was; end + + sig { void } + def created_at_will_change!; end + + sig { returns(T.nilable(::Integer)) } + def id; end + + sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) } + def id=(value); end + + sig { returns(T::Boolean) } + def id?; end + + sig { returns(T.nilable(::Integer)) } + def id_before_last_save; end + + sig { returns(T.untyped) } + def id_before_type_cast; end + + sig { returns(T::Boolean) } + def id_came_from_user?; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def id_change; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def id_change_to_be_saved; end + + sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) } + def id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::Integer)) } + def id_in_database; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def id_previous_change; end + + sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) } + def id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::Integer)) } + def id_previously_was; end + + sig { returns(T.nilable(::Integer)) } + def id_value; end + + sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) } + def id_value=(value); end + + sig { returns(T::Boolean) } + def id_value?; end + + sig { returns(T.nilable(::Integer)) } + def id_value_before_last_save; end + + sig { returns(T.untyped) } + def id_value_before_type_cast; end + + sig { returns(T::Boolean) } + def id_value_came_from_user?; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def id_value_change; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def id_value_change_to_be_saved; end + + sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) } + def id_value_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::Integer)) } + def id_value_in_database; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def id_value_previous_change; end + + sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) } + def id_value_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::Integer)) } + def id_value_previously_was; end + + sig { returns(T.nilable(::Integer)) } + def id_value_was; end + + sig { void } + def id_value_will_change!; end + + sig { returns(T.nilable(::Integer)) } + def id_was; end + + sig { void } + def id_will_change!; end + + sig { returns(T.nilable(::Integer)) } + def post_file_id; end + + sig { params(value: T.nilable(::Integer)).returns(T.nilable(::Integer)) } + def post_file_id=(value); end + + sig { returns(T::Boolean) } + def post_file_id?; end + + sig { returns(T.nilable(::Integer)) } + def post_file_id_before_last_save; end + + sig { returns(T.untyped) } + def post_file_id_before_type_cast; end + + sig { returns(T::Boolean) } + def post_file_id_came_from_user?; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def post_file_id_change; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def post_file_id_change_to_be_saved; end + + sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) } + def post_file_id_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::Integer)) } + def post_file_id_in_database; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def post_file_id_previous_change; end + + sig { params(from: T.nilable(::Integer), to: T.nilable(::Integer)).returns(T::Boolean) } + def post_file_id_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::Integer)) } + def post_file_id_previously_was; end + + sig { returns(T.nilable(::Integer)) } + def post_file_id_was; end + + sig { void } + def post_file_id_will_change!; end + + sig { void } + def restore_created_at!; end + + sig { void } + def restore_id!; end + + sig { void } + def restore_id_value!; end + + sig { void } + def restore_post_file_id!; end + + sig { void } + def restore_thumbnail_type!; end + + sig { void } + def restore_updated_at!; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def saved_change_to_created_at; end + + sig { returns(T::Boolean) } + def saved_change_to_created_at?; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def saved_change_to_id; end + + sig { returns(T::Boolean) } + def saved_change_to_id?; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def saved_change_to_id_value; end + + sig { returns(T::Boolean) } + def saved_change_to_id_value?; end + + sig { returns(T.nilable([T.nilable(::Integer), T.nilable(::Integer)])) } + def saved_change_to_post_file_id; end + + sig { returns(T::Boolean) } + def saved_change_to_post_file_id?; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def saved_change_to_thumbnail_type; end + + sig { returns(T::Boolean) } + def saved_change_to_thumbnail_type?; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def saved_change_to_updated_at; end + + sig { returns(T::Boolean) } + def saved_change_to_updated_at?; end + + sig { returns(T.nilable(::String)) } + def thumbnail_type; end + + sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) } + def thumbnail_type=(value); end + + sig { returns(T::Boolean) } + def thumbnail_type?; end + + sig { returns(T.nilable(::String)) } + def thumbnail_type_before_last_save; end + + sig { returns(T.untyped) } + def thumbnail_type_before_type_cast; end + + sig { returns(T::Boolean) } + def thumbnail_type_came_from_user?; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def thumbnail_type_change; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def thumbnail_type_change_to_be_saved; end + + sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } + def thumbnail_type_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::String)) } + def thumbnail_type_in_database; end + + sig { returns(T.nilable([T.nilable(::String), T.nilable(::String)])) } + def thumbnail_type_previous_change; end + + sig { params(from: T.nilable(::String), to: T.nilable(::String)).returns(T::Boolean) } + def thumbnail_type_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::String)) } + def thumbnail_type_previously_was; end + + sig { returns(T.nilable(::String)) } + def thumbnail_type_was; end + + sig { void } + def thumbnail_type_will_change!; end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def updated_at; end + + sig { params(value: T.nilable(::ActiveSupport::TimeWithZone)).returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def updated_at=(value); end + + sig { returns(T::Boolean) } + def updated_at?; end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def updated_at_before_last_save; end + + sig { returns(T.untyped) } + def updated_at_before_type_cast; end + + sig { returns(T::Boolean) } + def updated_at_came_from_user?; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def updated_at_change; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def updated_at_change_to_be_saved; end + + sig do + params( + from: T.nilable(::ActiveSupport::TimeWithZone), + to: T.nilable(::ActiveSupport::TimeWithZone) + ).returns(T::Boolean) + end + def updated_at_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def updated_at_in_database; end + + sig { returns(T.nilable([T.nilable(::ActiveSupport::TimeWithZone), T.nilable(::ActiveSupport::TimeWithZone)])) } + def updated_at_previous_change; end + + sig do + params( + from: T.nilable(::ActiveSupport::TimeWithZone), + to: T.nilable(::ActiveSupport::TimeWithZone) + ).returns(T::Boolean) + end + def updated_at_previously_changed?(from: T.unsafe(nil), to: T.unsafe(nil)); end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def updated_at_previously_was; end + + sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) } + def updated_at_was; end + + sig { void } + def updated_at_will_change!; end + + sig { returns(T::Boolean) } + def will_save_change_to_created_at?; end + + sig { returns(T::Boolean) } + def will_save_change_to_id?; end + + sig { returns(T::Boolean) } + def will_save_change_to_id_value?; end + + sig { returns(T::Boolean) } + def will_save_change_to_post_file_id?; end + + sig { returns(T::Boolean) } + def will_save_change_to_thumbnail_type?; end + + sig { returns(T::Boolean) } + def will_save_change_to_updated_at?; end + end + + module GeneratedRelationMethods + sig { returns(PrivateRelation) } + def all; end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def and(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def annotate(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def arel_columns(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def create_with(*args, &blk); end + + sig { params(value: T::Boolean).returns(PrivateRelation) } + def distinct(value = true); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def eager_load(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def except(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def excluding(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def extending(*args, &blk); end + + sig { params(association: Symbol).returns(T::Array[T.untyped]) } + def extract_associated(association); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def from(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelationGroupChain) } + def group(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def having(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def in_order_of(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def includes(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def invert_where(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def joins(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def left_joins(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def left_outer_joins(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def limit(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def lock(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def merge(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def none(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def null_relation?(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def offset(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def only(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def optimizer_hints(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def or(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def order(*args, &blk); end + + sig do + params( + num: T.any(Integer, String) + ).returns(T.all(PrivateRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods)) + end + def page(num = nil); end + + sig do + params( + num: Integer + ).returns(T.all(PrivateRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods)) + end + def per(num); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def preload(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def readonly(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def references(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def regroup(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def reorder(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def reselect(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def reverse_order(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def rewhere(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def select(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def strict_loading(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def structurally_compatible?(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def uniq!(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def unscope(*args, &blk); end + + sig { returns(PrivateRelationWhereChain) } + sig { params(args: T.untyped).returns(PrivateRelation) } + def where(*args); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def with(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def with_recursive(*args, &blk); end + + sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } + def without(*args, &blk); end + + sig { returns(T.all(PrivateRelation, Kaminari::PageScopeMethods, Kaminari::ActiveRecordRelationMethods)) } + def without_count; end + end + + class PrivateAssociationRelation < ::ActiveRecord::AssociationRelation + include CommonRelationMethods + include GeneratedAssociationRelationMethods + + Elem = type_member { { fixed: ::Domain::PostFileThumbnail } } + + sig { returns(T::Array[::Domain::PostFileThumbnail]) } + def to_a; end + + sig { returns(T::Array[::Domain::PostFileThumbnail]) } + def to_ary; end + end + + class PrivateAssociationRelationGroupChain < PrivateAssociationRelation + Elem = type_member { { fixed: ::Domain::PostFileThumbnail } } + + sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) } + def average(column_name); end + + sig do + params( + operation: Symbol, + column_name: T.any(String, Symbol) + ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) + end + def calculate(operation, column_name); end + + sig { params(column_name: T.untyped).returns(T::Hash[T.untyped, Integer]) } + def count(column_name = nil); end + + sig { params(args: T.untyped, blk: T.untyped).returns(T.self_type) } + def having(*args, &blk); end + + sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) } + def maximum(column_name); end + + sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) } + def minimum(column_name); end + + sig do + params( + column_name: T.nilable(T.any(String, Symbol)), + block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped)) + ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) + end + def sum(column_name = nil, &block); end + end + + class PrivateAssociationRelationWhereChain + Elem = type_member { { fixed: ::Domain::PostFileThumbnail } } + + sig { params(args: T.untyped).returns(PrivateAssociationRelation) } + def associated(*args); end + + sig { params(args: T.untyped).returns(PrivateAssociationRelation) } + def missing(*args); end + + sig { params(opts: T.untyped, rest: T.untyped).returns(PrivateAssociationRelation) } + def not(opts, *rest); end + end + + class PrivateCollectionProxy < ::ActiveRecord::Associations::CollectionProxy + include CommonRelationMethods + include GeneratedAssociationRelationMethods + + Elem = type_member { { fixed: ::Domain::PostFileThumbnail } } + + sig do + params( + records: T.any(::Domain::PostFileThumbnail, T::Enumerable[T.any(::Domain::PostFileThumbnail, T::Enumerable[::Domain::PostFileThumbnail])]) + ).returns(PrivateCollectionProxy) + end + def <<(*records); end + + sig do + params( + records: T.any(::Domain::PostFileThumbnail, T::Enumerable[T.any(::Domain::PostFileThumbnail, T::Enumerable[::Domain::PostFileThumbnail])]) + ).returns(PrivateCollectionProxy) + end + def append(*records); end + + sig { returns(PrivateCollectionProxy) } + def clear; end + + sig do + params( + records: T.any(::Domain::PostFileThumbnail, T::Enumerable[T.any(::Domain::PostFileThumbnail, T::Enumerable[::Domain::PostFileThumbnail])]) + ).returns(PrivateCollectionProxy) + end + def concat(*records); end + + sig { returns(T::Array[::Domain::PostFileThumbnail]) } + def load_target; end + + sig do + params( + records: T.any(::Domain::PostFileThumbnail, T::Enumerable[T.any(::Domain::PostFileThumbnail, T::Enumerable[::Domain::PostFileThumbnail])]) + ).returns(PrivateCollectionProxy) + end + def prepend(*records); end + + sig do + params( + records: T.any(::Domain::PostFileThumbnail, T::Enumerable[T.any(::Domain::PostFileThumbnail, T::Enumerable[::Domain::PostFileThumbnail])]) + ).returns(PrivateCollectionProxy) + end + def push(*records); end + + sig do + params( + other_array: T.any(::Domain::PostFileThumbnail, T::Enumerable[T.any(::Domain::PostFileThumbnail, T::Enumerable[::Domain::PostFileThumbnail])]) + ).returns(T::Array[::Domain::PostFileThumbnail]) + end + def replace(other_array); end + + sig { returns(PrivateAssociationRelation) } + def scope; end + + sig { returns(T::Array[::Domain::PostFileThumbnail]) } + def target; end + + sig { returns(T::Array[::Domain::PostFileThumbnail]) } + def to_a; end + + sig { returns(T::Array[::Domain::PostFileThumbnail]) } + def to_ary; end + end + + class PrivateRelation < ::ActiveRecord::Relation + include CommonRelationMethods + include GeneratedRelationMethods + + Elem = type_member { { fixed: ::Domain::PostFileThumbnail } } + + sig { returns(T::Array[::Domain::PostFileThumbnail]) } + def to_a; end + + sig { returns(T::Array[::Domain::PostFileThumbnail]) } + def to_ary; end + end + + class PrivateRelationGroupChain < PrivateRelation + Elem = type_member { { fixed: ::Domain::PostFileThumbnail } } + + sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) } + def average(column_name); end + + sig do + params( + operation: Symbol, + column_name: T.any(String, Symbol) + ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) + end + def calculate(operation, column_name); end + + sig { params(column_name: T.untyped).returns(T::Hash[T.untyped, Integer]) } + def count(column_name = nil); end + + sig { params(args: T.untyped, blk: T.untyped).returns(T.self_type) } + def having(*args, &blk); end + + sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) } + def maximum(column_name); end + + sig { params(column_name: T.any(String, Symbol)).returns(T::Hash[T.untyped, T.untyped]) } + def minimum(column_name); end + + sig do + params( + column_name: T.nilable(T.any(String, Symbol)), + block: T.nilable(T.proc.params(record: T.untyped).returns(T.untyped)) + ).returns(T::Hash[T.untyped, T.any(Integer, Float, BigDecimal)]) + end + def sum(column_name = nil, &block); end + end + + class PrivateRelationWhereChain + Elem = type_member { { fixed: ::Domain::PostFileThumbnail } } + + sig { params(args: T.untyped).returns(PrivateRelation) } + def associated(*args); end + + sig { params(args: T.untyped).returns(PrivateRelation) } + def missing(*args); end + + sig { params(opts: T.untyped, rest: T.untyped).returns(PrivateRelation) } + def not(opts, *rest); end + end +end diff --git a/sorbet/rbi/dsl/generated_path_helpers_module.rbi b/sorbet/rbi/dsl/generated_path_helpers_module.rbi index 62f52603..93135b08 100644 --- a/sorbet/rbi/dsl/generated_path_helpers_module.rbi +++ b/sorbet/rbi/dsl/generated_path_helpers_module.rbi @@ -213,6 +213,9 @@ module GeneratedPathHelpersModule sig { params(args: T.untyped).returns(String) } def stats_log_entries_path(*args); end + sig { params(args: T.untyped).returns(String) } + def toggle_state_ip_address_role_path(*args); end + sig { params(args: T.untyped).returns(String) } def turbo_recede_historical_location_path(*args); end diff --git a/sorbet/rbi/dsl/generated_url_helpers_module.rbi b/sorbet/rbi/dsl/generated_url_helpers_module.rbi index 208c5e00..af0717ea 100644 --- a/sorbet/rbi/dsl/generated_url_helpers_module.rbi +++ b/sorbet/rbi/dsl/generated_url_helpers_module.rbi @@ -213,6 +213,9 @@ module GeneratedUrlHelpersModule sig { params(args: T.untyped).returns(String) } def stats_log_entries_url(*args); end + sig { params(args: T.untyped).returns(String) } + def toggle_state_ip_address_role_url(*args); end + sig { params(args: T.untyped).returns(String) } def turbo_recede_historical_location_url(*args); end diff --git a/sorbet/rbi/dsl/ip_address_role.rbi b/sorbet/rbi/dsl/ip_address_role.rbi index 5ce3d6d8..131be8a4 100644 --- a/sorbet/rbi/dsl/ip_address_role.rbi +++ b/sorbet/rbi/dsl/ip_address_role.rbi @@ -393,18 +393,6 @@ class IpAddressRole end module EnumMethodsModule - sig { void } - def admin!; end - - sig { returns(T::Boolean) } - def admin?; end - - sig { void } - def moderator!; end - - sig { returns(T::Boolean) } - def moderator?; end - sig { void } def user!; end @@ -413,9 +401,6 @@ class IpAddressRole end module GeneratedAssociationRelationMethods - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def admin(*args, &blk); end - sig { returns(PrivateAssociationRelation) } def all; end @@ -485,18 +470,9 @@ class IpAddressRole sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } def merge(*args, &blk); end - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def moderator(*args, &blk); end - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } def none(*args, &blk); end - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def not_admin(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } - def not_moderator(*args, &blk); end - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateAssociationRelation) } def not_user(*args, &blk); end @@ -1082,9 +1058,6 @@ class IpAddressRole end module GeneratedRelationMethods - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def admin(*args, &blk); end - sig { returns(PrivateRelation) } def all; end @@ -1154,18 +1127,9 @@ class IpAddressRole sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } def merge(*args, &blk); end - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def moderator(*args, &blk); end - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } def none(*args, &blk); end - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def not_admin(*args, &blk); end - - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } - def not_moderator(*args, &blk); end - sig { params(args: T.untyped, blk: T.untyped).returns(PrivateRelation) } def not_user(*args, &blk); end diff --git a/sorbet/rbi/shims/vips.rbi b/sorbet/rbi/shims/vips.rbi index 287afecf..a82d5855 100644 --- a/sorbet/rbi/shims/vips.rbi +++ b/sorbet/rbi/shims/vips.rbi @@ -7,6 +7,27 @@ class Vips::Image sig { params(name: String, n: T.nilable(Integer)).returns(Vips::Image) } def self.gifload(name, n: nil) end + sig do + params( + filename: String, + width: Integer, + height: T.nilable(Integer), + # :up, :down, :both, :force + size: T.nilable(Symbol), + ).returns(Vips::Image) + end + def self.thumbnail(filename, width, height: nil, size: nil) + end + + sig do + params( + width: Integer, + height: T.nilable(Integer), + size: T.nilable(Symbol), + ).returns(Vips::Image) + end + def thumbnail_image(width, height: nil, size: nil) + end sig { params(scale: T.untyped).returns(Vips::Image) } def resize(scale) @@ -16,9 +37,7 @@ class Vips::Image def gifsave_buffer(**opts) end - sig do - params(width: Integer, height: T.nilable(Integer)).returns(Vips::Image) - end - def thumbnail_image(width, height: nil) + sig { params(filename: String, opts: T.untyped).returns(String) } + def jpegsave(filename, **opts) end end diff --git a/spec/factories/domain/post_file_thumbnail.rb b/spec/factories/domain/post_file_thumbnail.rb new file mode 100644 index 00000000..56094af9 --- /dev/null +++ b/spec/factories/domain/post_file_thumbnail.rb @@ -0,0 +1,7 @@ +# typed: false +FactoryBot.define do + factory :domain_post_file_thumbnail, class: "Domain::PostFileThumbnail" do + association :post_file, factory: :domain_post_file + thumbnail_type { Domain::ThumbnailType::Small.name } + end +end diff --git a/spec/models/domain/post_file_thumbnail_spec.rb b/spec/models/domain/post_file_thumbnail_spec.rb new file mode 100644 index 00000000..236091f5 --- /dev/null +++ b/spec/models/domain/post_file_thumbnail_spec.rb @@ -0,0 +1,171 @@ +# typed: false +require "rails_helper" + +RSpec.describe Domain::PostFileThumbnail do + describe ".find_or_create_from_post_file" do + let(:post) { create(:domain_post_fa_post) } + let(:blob_file) do + fixture_path = + Rails.root.join( + "test/fixtures/files/images/thumb-036aaab6-content-container.jpeg", + ) + create( + :blob_file, + contents: File.binread(fixture_path), + content_type: "image/jpeg", + ) + end + let(:log_entry) do + create(:http_log_entry, content_type: "image/jpeg", response: blob_file) + end + let(:post_file) do + create(:domain_post_file, post: post, state: "ok", log_entry: log_entry) + end + + before do + # Ensure directories exist + FileUtils.mkdir_p(Domain::PostFileThumbnail::TMP_DIR) + end + + it "creates a thumbnail for a valid post file" do + thumbnail = + described_class.find_or_create_from_post_file( + post_file, + Domain::ThumbnailType::Small, + ) + + expect(thumbnail).to be_a(Domain::PostFileThumbnail) + expect(thumbnail.post_file).to eq(post_file) + expect(thumbnail.thumbnail_type).to eq("small") + + # Verify the thumbnail file was created on disk + thumbnail_path = thumbnail.absolute_file_path + expect(thumbnail_path).not_to be_nil + expect(File.exist?(thumbnail_path)).to be true + end + + it "returns existing thumbnail if one already exists" do + # Create a thumbnail first + existing = + described_class.find_or_create_from_post_file( + post_file, + Domain::ThumbnailType::Small, + ) + expect(existing).not_to be_nil + + # Try to find or create again + thumbnail = + described_class.find_or_create_from_post_file( + post_file, + Domain::ThumbnailType::Small, + ) + + # Should return the existing one without creating a new one + expect(thumbnail).to eq(existing) + end + + it "returns nil for a post file that's not in 'ok' state" do + post_file.update!(state: "pending") + + thumbnail = + described_class.find_or_create_from_post_file( + post_file, + Domain::ThumbnailType::Small, + ) + + expect(thumbnail).to be_nil + end + + it "returns nil for a post file without a log entry" do + post_file.update!(log_entry: nil) + + thumbnail = + described_class.find_or_create_from_post_file( + post_file, + Domain::ThumbnailType::Small, + ) + + expect(thumbnail).to be_nil + end + + it "returns nil for a post file with an unsupported content type" do + # Create a new log entry with PDF content type since HttpLogEntry is immutable + pdf_blob = + create( + :blob_file, + content_type: "application/pdf", + contents: "fake pdf data", + ) + pdf_log_entry = + create( + :http_log_entry, + content_type: "application/pdf", + response: pdf_blob, + ) + pdf_post_file = + create( + :domain_post_file, + post: post, + state: "ok", + log_entry: pdf_log_entry, + ) + + thumbnail = + described_class.find_or_create_from_post_file( + pdf_post_file, + Domain::ThumbnailType::Small, + ) + + expect(thumbnail).to be_nil + end + + it "returns nil if the post file has no blob" do + allow(post_file).to receive(:blob).and_return(nil) + + thumbnail = + described_class.find_or_create_from_post_file( + post_file, + Domain::ThumbnailType::Small, + ) + + expect(thumbnail).to be_nil + end + end + + describe "#absolute_file_path" do + let(:post) { create(:domain_post_fa_post) } + let(:blob_file) do + create( + :blob_file, + content_type: "image/jpeg", + contents: "fake image data", + ) + end + let(:post_file) do + create(:domain_post_file, post: post, state: "ok", blob: blob_file) + end + let(:thumbnail) do + create( + :domain_post_file_thumbnail, + post_file: post_file, + thumbnail_type: "small", + ) + end + + it "constructs the correct file path" do + expect(thumbnail.absolute_file_path).to start_with( + Domain::PostFileThumbnail::THUMBNAIL_ROOT_DIR, + ) + end + + it "returns nil if thumbnail_type is nil" do + thumbnail.thumbnail_type = nil + expect(thumbnail.absolute_file_path).to be_nil + end + + it "returns nil if post_file is nil" do + thumbnail.post_file = nil + expect(thumbnail.absolute_file_path).to be_nil + end + end +end diff --git a/test/fixtures/files/images/thumb-036aaab6-content-container.jpeg b/test/fixtures/files/images/thumb-036aaab6-content-container.jpeg new file mode 100644 index 0000000000000000000000000000000000000000..d2550108ea2ac532c1f615573b5ad12fb7f45a37 GIT binary patch literal 200656 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
    ?&MBr3i=RGf%T$J@+n*Q*lzvJ|7yO&D^{MZ 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 OKf{~8c>dM@Zvp`C_joA) literal 0 HcmV?d00001