active_shrine 0.1.0 → 0.1.1

data/lib/active_shrine/attached/one.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module ActiveShrine
+  module Attached
+    # = ActiveShrine\Attached\One
+    #
+    # Representation of a single attachment to a model.
+    class One < Base
+      ##
+      # :method: purge
+      #
+      # Directly purges the attachment (i.e. destroys the blob and
+      # attachment and deletes the file on the service).
+      delegate :purge, to: :purge_one
+
+      ##
+      # :method: purge_later
+      #
+      # Purges the attachment through the queuing system.
+      delegate :purge_later, to: :purge_one
+
+      ##
+      # :method: detach
+      #
+      # Deletes the attachment without purging it, leaving its blob in place.
+      delegate :detach, to: :detach_one
+
+      delegate_missing_to :attachment, allow_nil: true
+
+      # Returns the associated attachment record.
+      #
+      # You don't have to call this method to access the attachment's methods as
+      # they are all available at the model level.
+      def attachment
+        change.present? ? change.attachment : record.public_send(:"#{name}_attachment")
+      end
+
+      # Returns +true+ if an attachment is not attached.
+      #
+      #   class User < ApplicationRecord
+      #     has_one_attached :avatar
+      #   end
+      #
+      #   User.new.avatar.blank? # => true
+      def blank?
+        !attached?
+      end
+
+      # Attaches an +attachable+ to the record.
+      #
+      # If the record is persisted and unchanged, the attachment is saved to
+      # the database immediately. Otherwise, it'll be saved to the DB when the
+      # record is next saved.
+      #
+      #   person.avatar.attach(params[:avatar]) # ActionDispatch::Http::UploadedFile object
+      #   person.avatar.attach(params[:signed_id]) # Signed reference to attachment
+      #
+      #   See https://shrinerb.com/docs/attacher#attaching for more
+      def attach(attachable)
+        record.public_send(:"#{name}=", attachable)
+        if record.persisted? && !record.changed?
+          return if !record.save
+        end
+
+        record.public_send(:"#{name}")
+      end
+
+      # Returns +true+ if an attachment has been made.
+      #
+      #   class User < ApplicationRecord
+      #     has_one_attached :avatar
+      #   end
+      #
+      #   User.new.avatar.attached? # => false
+      def attached?
+        attachment.present?
+      end
+
+      private
+
+      def purge_one
+        Attached::Changes::PurgeOne.new(name, record, attachment)
+      end
+
+      def detach_one
+        Attached::Changes::DetachOne.new(name, record, attachment)
+      end
+    end
+  end
+end

data/lib/active_shrine/attached.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ActiveShrine
+  module Attached # :nodoc:
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Base
+      autoload :Changes
+      autoload :Many
+      autoload :One
+    end
+  end
+end

data/lib/active_shrine/attachment.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "shrine"
+
+# == Schema Information
+#
+# Table name: active_shrine_attachments
+#
+#  id          :bigint           not null, primary key
+#  file_data   :jsonb            not null
+#  metadata    :jsonb            not null
+#  name        :string           not null
+#  record_type :string
+#  type        :string           default("ActiveShrine::Attachment"), not null
+#  created_at  :datetime         not null
+#  updated_at  :datetime         not null
+#  record_id   :bigint
+#
+# Indexes
+#
+#  active_shrine_attachments_on_file_data  (file_data) USING gin
+#  active_shrine_attachments_on_metadata   (metadata) USING gin
+#  active_shrine_attachments_on_name       (name)
+#  active_shrine_attachments_on_record     (record_type,record_id)
+#
+module ActiveShrine
+  class Attachment < ActiveRecord::Base
+    include Shrine::Attachment(:file)
+    include ActiveModel::Serializers::JSON
+
+    self.table_name = "active_shrine_attachments"
+
+    belongs_to :record, polymorphic: true, optional: true
+
+    validates :name, presence: true
+    validates :file_data, presence: true
+
+    before_save :maybe_store_record
+
+    def url
+      file_url
+    end
+
+    def content_type
+      file.mime_type
+    end
+
+    def filename
+      file.original_filename
+    end
+
+    def extension
+      file.extension
+    end
+
+    def representable?
+      %r{image/.*}.match? content_type
+    end
+
+    def signed_id
+      # add the id to ensure uniqueness
+      value = ({id:, file: file.to_json} if file.present?) || {}
+      Rails.application.message_verifier(:active_shrine_attachment).generate value
+    end
+
+    def file=(value)
+      # It is the same file. we are good to go.
+      return if value == signed_id
+
+      if value.is_a?(String)
+        # it is an already uploaded file. either
+        # - via direct upload so the form is sending us a json hash to set
+        # - or was set because a previous submission failed, so the form is sending us the signed_id
+        begin
+          # attempt to parse as a json hash
+          value = JSON.parse value
+        rescue JSON::ParserError
+          # this is not a valid json hash, let's check if it is a valid signed_id
+          unsigned = Rails.application.message_verifier(:active_shrine_attachment).verify value
+          value = JSON.parse unsigned["file"]
+        end
+      end
+
+      super(value)
+    rescue ActiveSupport::MessageVerifier::InvalidSignature
+      errors.add(:file, "is invalid")
+    end
+
+    def purge
+      file_attacher.destroy_block { destroy } if file_attacher.respond_to?(:destroy_block)
+      destroy
+    end
+
+    def purge_later
+      file_attacher.destroy_background
+      file_attacher.instance_variable_set :@file, nil # prevent shrine from attempting to destroy the file again
+      destroy
+    rescue NoMethodError
+      raise NotImplementedError, ("You need to enable Shrine backgrounding to use purge_later: " \
+                                  "https://shrinerb.com/docs/plugins/backgrounding")
+    end
+
+    private
+
+    def maybe_store_record
+      return unless record.present?
+
+      metadata.merge! record_type:, record_id:
+    end
+  end
+end

data/lib/active_shrine/job/destroy_shrine_attachment.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "shrine"
+
+module ActiveShrine
+  module Job
+    module DestroyShrineAttachment
+      private
+
+      def perform(attacher_class, data)
+        attacher_class = attacher_class.constantize
+
+        attacher = attacher_class.from_data(data)
+        attacher.destroy
+      end
+    end
+  end
+end

data/lib/active_shrine/job/promote_shrine_attachment.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "shrine"
+
+module ActiveShrine
+  module Job
+    module PromoteShrineAttachment
+      private
+
+      def perform(attacher_class, record_class, record_id, name, file_data)
+        attacher_class = attacher_class.constantize
+        record = record_class.constantize.find(record_id)
+
+        attacher = attacher_class.retrieve(model: record, name:, file: file_data)
+        attacher.atomic_promote
+      rescue Shrine::AttachmentChanged, ActiveRecord::RecordNotFound
+        # attachment has changed or record has been deleted, nothing to do
+      end
+    end
+  end
+end

data/lib/active_shrine/job.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ActiveShrine
+  module Job # :nodoc:
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :PromoteShrineAttachment
+      autoload :DestroyShrineAttachment
+    end
+  end
+end

data/lib/active_shrine/model.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module ActiveShrine
+  # Provides the class-level DSL for declaring an Active Record model's attachments.
+  module Model
+    extend ActiveSupport::Concern
+    include ActiveShrine::Reflection::ActiveRecordExtensions
+
+    ##
+    # :method: *_attachment
+    #
+    # Returns the attachment for the +has_one_attached+.
+    #
+    #   User.last.avatar_attachment
+
+    ##
+    # :method: *_attachments
+    #
+    # Returns the attachments for the +has_many_attached+.
+    #
+    #   Gallery.last.photos_attachments
+
+    ##
+    # :method: with_attached_*
+    #
+    # Includes the attachments in your query to avoid N+1 queries.
+    #
+    #   User.with_attached_avatar
+    #
+    # Use the plural form for +has_many_attached+:
+    #
+    #   Gallery.with_attached_photos
+
+    class_methods do
+      # Specifies the relation between a single attachment and the model.
+      #
+      #   class User < ApplicationRecord
+      #     has_one_attached :avatar
+      #   end
+      #
+      # There is no column defined on the model side, Active Storage takes
+      # care of the mapping between your records and the attachment.
+      #
+      # To avoid N+1 queries, you can include the attachments in your query like so:
+      #
+      #   User.with_attached_avatar
+      #
+      # Under the covers, this relationship is implemented as a +has_one+ association to a
+      # ActiveShrine::Attachment record. These associations are available as +avatar_attachment+.
+      # But you shouldn't need to work with these associations directly in most circumstances.
+      #
+      # The system has been designed to having you go through the One
+      # proxy that provides the dynamic proxy to the associations and factory methods, like +attach+.
+      #
+      # If the +:dependent+ option isn't set, the attachment will be destroyed
+      # (i.e. deleted from the database and file storage) whenever the record is destroyed.
+      #
+      # If you need to enable +strict_loading+ to prevent lazy loading of attachment,
+      # pass the +:strict_loading+ option. You can do:
+      #
+      #   class User < ApplicationRecord
+      #     has_one_attached :avatar, strict_loading: true
+      #   end
+      #
+      # Note: ActiveShrine relies on polymorphic associations, which in turn store class names in the database.
+      # When renaming classes that use <tt>has_many</tt>, make sure to also update the class names in the
+      # <tt>active_shrine_attachments.record_type</tt> polymorphic type column of
+      # the corresponding rows.
+      def has_one_attached(name, class_name: "::ActiveShrine::Attachment", dependent: :destroy, strict_loading: false)
+        generated_association_methods.class_eval <<-CODE, __FILE__, __LINE__ + 1
+          # frozen_string_literal: true
+          def #{name}
+            @active_shrine_attached ||= {}
+            @active_shrine_attached[:#{name}] ||= Attached::One.new("#{name}", self)
+          end
+
+          def #{name}=(attachable)
+            shrine_attachment_changes["#{name}"] =
+              if attachable.presence.nil?
+                Attached::Changes::DeleteOne.new("#{name}", self)
+              else
+                Attached::Changes::CreateOne.new("#{name}", self, attachable)
+              end
+          end
+        CODE
+
+        has_one(:"#{name}_attachment", -> { where(name:) }, class_name:, as: :record, inverse_of: :record,
+          dependent:, strict_loading:)
+
+        scope :"with_attached_#{name}", -> { includes(:"#{name}_attachment") }
+
+        after_save { shrine_attachment_changes[name.to_s]&.save }
+
+        after_commit(on: %i[create update]) { shrine_attachment_changes.delete(name.to_s) }
+
+        reflection = ActiveRecord::Reflection.create(
+          :has_one_attached,
+          name,
+          nil,
+          {dependent:, source: :active_shrine},
+          self
+        )
+        yield reflection if block_given?
+        ActiveRecord::Reflection.add_shrine_attachment_reflection(self, name, reflection)
+      end
+
+      # Specifies the relation between multiple attachments and the model.
+      #
+      #   class Gallery < ApplicationRecord
+      #     has_many_attached :photos
+      #   end
+      #
+      # There are no columns defined on the model side, Active Storage takes
+      # care of the mapping between your records and the attachments.
+      #
+      # To avoid N+1 queries, you can include the attachments in your query like so:
+      #
+      #   Gallery.where(user: Current.user).with_attached_photos
+      #
+      # Under the covers, this relationship is implemented as a +has_many+ association to a
+      # ActiveShrine::Attachment record. These associations are available as +photos_attachments+.
+      # But you shouldn't need to work with these associations directly in most circumstances.
+      #
+      # The system has been designed to having you go through the Many
+      # proxy that provides the dynamic proxy to the associations and factory methods, like +#attach+.
+      #
+      # If the +:dependent+ option isn't set, all the attachments will be destroyed
+      # (i.e. deleted from the database and file storage) whenever the record is destroyed.
+      #
+      # If you need to enable +strict_loading+ to prevent lazy loading of attachment,
+      # pass the +:strict_loading+ option. You can do:
+      #
+      #   class Gallery < ApplicationRecord
+      #     has_many_attached :photos, strict_loading: true
+      #   end
+      #
+      # Note: ActiveShrine relies on polymorphic associations, which in turn store class names in the database.
+      # When renaming classes that use <tt>has_many</tt>, make sure to also update the class names in the
+      # <tt>active_shrine_attachments.record_type</tt> polymorphic type column of
+      # the corresponding rows.
+      def has_many_attached(name, class_name: "::ActiveShrine::Attachment", dependent: :destroy, strict_loading: false)
+        generated_association_methods.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        # frozen_string_literal: true
+        def #{name}
+          @active_shrine_attached ||= {}
+          @active_shrine_attached[:#{name}] ||= Attached::Many.new("#{name}", self)
+        end
+
+        def #{name}=(attachables)
+          attachables = Array(attachables).compact_blank
+          pending_uploads = shrine_attachment_changes["#{name}"].try(:pending_uploads)
+
+          shrine_attachment_changes["#{name}"] = if attachables.none?
+            Attached::Changes::DeleteMany.new("#{name}", self)
+          else
+            Attached::Changes::CreateMany.new("#{name}", self, attachables, pending_uploads: pending_uploads)
+          end
+        end
+        CODE
+
+        has_many(:"#{name}_attachments", -> { where(name:) }, class_name:, as: :record, inverse_of: :record,
+          dependent:, strict_loading:)
+
+        scope :"with_attached_#{name}", -> { includes(:"#{name}_attachments") }
+
+        after_save { shrine_attachment_changes[name.to_s]&.save }
+
+        after_commit(on: %i[create update]) { shrine_attachment_changes.delete(name.to_s) }
+
+        reflection = ActiveRecord::Reflection.create(
+          :has_many_attached,
+          name,
+          nil,
+          {dependent:, source: :active_shrine},
+          self
+        )
+        yield reflection if block_given?
+        ActiveRecord::Reflection.add_shrine_attachment_reflection(self, name, reflection)
+      end
+    end
+
+    def shrine_attachment_changes # :nodoc:
+      @shrine_attachment_changes ||= {}
+    end
+
+    def changed_for_autosave? # :nodoc:
+      super || shrine_attachment_changes.any?
+    end
+
+    def initialize_dup(*) # :nodoc:
+      super
+      @active_shrine_attached = nil
+      @shrine_attachment_changes = nil
+    end
+
+    def reload(*) # :nodoc:
+      super.tap { @shrine_attachment_changes = nil }
+    end
+  end
+end

data/lib/active_shrine/railtie.rb

@@ -0,0 +1,11 @@
+require "rails"
+
+module ActiveShrine
+  class Railtie < ::Rails::Railtie
+    initializer "active_shrine.active_record" do
+      ActiveSupport.on_load(:active_record) do
+        ActiveRecord::Reflection.singleton_class.prepend(ActiveShrine::Reflection::ReflectionExtension)
+      end
+    end
+  end
+end

data/lib/active_shrine/reflection.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module ActiveShrine
+  module Reflection
+    class HasAttachedReflection < ActiveRecord::Reflection::MacroReflection # :nodoc:
+      # def variant(name, transformations)
+      #   named_variants[name] = NamedVariant.new(transformations)
+      # end
+
+      # def named_variants
+      #   @named_variants ||= {}
+      # end
+    end
+
+    # Holds all the metadata about a has_one_attached attachment as it was
+    # specified in the Active Record class.
+    class HasOneAttachedReflection < HasAttachedReflection # :nodoc:
+      def macro
+        :has_one_attached
+      end
+    end
+
+    # Holds all the metadata about a has_many_attached attachment as it was
+    # specified in the Active Record class.
+    class HasManyAttachedReflection < HasAttachedReflection # :nodoc:
+      def macro
+        :has_many_attached
+      end
+    end
+
+    module ReflectionExtension # :nodoc:
+      def add_shrine_attachment_reflection(model, name, reflection)
+        model.shrine_attachment_reflections[name.to_s] = reflection
+      end
+
+      private
+
+      def reflection_class_for(macro)
+        case macro
+        when :has_one_attached
+          HasOneAttachedReflection
+        when :has_many_attached
+          HasManyAttachedReflection
+        else
+          super
+        end
+      end
+    end
+
+    module ActiveRecordExtensions
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def shrine_attachment_reflections
+          @shrine_attachment_reflections ||= {}
+        end
+
+        # Returns an array of reflection objects for all the attachments in the
+        # class.
+        def reflect_on_all_attachments
+          shrine_attachment_reflections.values
+        end
+
+        # Returns the reflection object for the named +attachment+.
+        #
+        #    User.reflect_on_attachment(:avatar)
+        #    # => the avatar reflection
+        #
+        def reflect_on_attachment(attachment)
+          shrine_attachment_reflections[attachment.to_s]
+        end
+      end
+    end
+  end
+end

data/lib/active_shrine/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActiveShrine
+  VERSION = "0.1.1"
+end

data/lib/active_shrine.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "active_shrine/version"
+require_relative "active_shrine/railtie"
+
+module ActiveShrine
+  extend ActiveSupport::Autoload
+
+  class Error < StandardError; end
+
+  eager_autoload do
+    autoload :Attached
+    autoload :Attachment
+    autoload :Job
+    autoload :Model
+    autoload :Reflection
+  end
+end

data/lib/generators/active_shrine/install/install_generator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+# require "rails/generators/active_record/migration"
+
+module ActiveShrine
+  class InstallGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    source_root File.expand_path("templates", __dir__)
+
+    desc "Install ActiveShrine"
+
+    def start
+      directory "app"
+      directory "config"
+      migration_template "db/migrate/create_active_shrine_attachments.rb", "db/migrate/create_active_shrine_attachments.rb"
+
+      Bundler.with_unbundled_env do
+        run "bundle add fastimage"
+      end
+    end
+
+    def self.next_migration_number(dirname)
+      next_migration_number = current_migration_number(dirname) + 1
+      [Time.now.utc.strftime("%Y%m%d%H%M%S"), format("%.14d", next_migration_number)].max
+    end
+  end
+end

data/lib/generators/active_shrine/install/templates/app/jobs/destroy_shrine_attachment_job.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class DestroyShrineAttachmentJob < ApplicationJob
+  include ActiveShrine::Job::DestroyShrineAttachment
+end

data/lib/generators/active_shrine/install/templates/app/jobs/promote_shrine_attachment_job.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class PromoteShrineAttachmentJob < ApplicationJob
+  include ActiveShrine::Job::PromoteShrineAttachment
+end

data/lib/generators/active_shrine/install/templates/config/initializers/shrine.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Be sure to restart your server when you modify this file.
+
+require "shrine"
+require "shrine/storage/file_system"
+
+Shrine.logger = Rails.logger
+
+# upload files to the public dir
+Shrine.storages = {
+  cache: Shrine::Storage::FileSystem.new("public", prefix: "uploads/cache"), # temporary
+  store: Shrine::Storage::FileSystem.new("public", prefix: "uploads") # permanent
+}
+
+Shrine.plugin :activerecord
+Shrine.plugin :determine_mime_type, analyzer: lambda { |io, analyzers|
+  mime_type = analyzers[:marcel].call(io)
+  mime_type = analyzers[:file].call(io) if mime_type == "application/octet-stream" || mime_type.nil?
+  mime_type = analyzers[:mime_types].call(io) if mime_type == "text/plain"
+  mime_type
+}
+Shrine.plugin :instrumentation
+Shrine.plugin :infer_extension, force: true
+Shrine.plugin :store_dimensions
+Shrine.plugin :pretty_location
+Shrine.plugin :refresh_metadata
+
+Shrine.plugin :backgrounding
+
+Shrine::Attacher.promote_block do
+  if PromoteShrineAttachmentJob.respond_to? :perform_async
+    # sidekiq
+    PromoteShrineAttachmentJob.perform_async(self.class.name, record.class.name, record.id, name.to_s, file_data)
+  else
+    # activejob
+    PromoteShrineAttachmentJob.perform_later(self.class.name, record.class.name, record.id, name.to_s, file_data)
+  end
+end
+
+Shrine::Attacher.destroy_block do
+  if PromoteShrineAttachmentJob.respond_to? :perform_async
+    # sidekiq
+    DestroyShrineAttachmentJob.perform_async(self.class.name, data)
+  else
+    # activejob
+    DestroyShrineAttachmentJob.perform_later(self.class.name, data)
+  end
+end
+
+Shrine.plugin :upload_endpoint, url: true