attach 1.1.2 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b8c3f1129d2c35650ecb7d9b0c137d20a6a2265f2304c5976b4d4dfc252ee15
-  data.tar.gz: ac3a03c541d799dcae47442d84fd47249ec257d2566da242d6e8d4d09ad8b0e2
+  metadata.gz: 67e480487c042fe887ff3c518fc372df0e9ed21890f25df6b15b7ac408ff63f9
+  data.tar.gz: 046166beef6d41bea1fe55927d5006ab7512aa57a2201b15abfcc8cca94a8832
 SHA512:
-  metadata.gz: 6195ce53ff7b626f3051448e00c8ebec9cbca5dd715c728bcc68052e1ec54753fc65d31c3f4cced08bfc04a0768672191921dbe3620299848b0a8688e82e082d
-  data.tar.gz: 8a877be8bac066f7fa36ab33f81481c38aa15f96f63df7f3c9462ee256ec97ed650c116b74a7598cd34d6be458e9fca2b1ba9c35c5fcbfa42a9933cbc6b543fe
+  metadata.gz: b8b1e30d31ef5782738cd01e4bc4ce6528472e014a77e7ef1e8be80407f787390be4cf422e7eee13f6baed150591fbc1e68a4a1f968a85a4109901d2d50e8c65
+  data.tar.gz: 8d74cb792d7a9981ca063cc1c9b0b667f2419d36368c600e56bfdb9f351b426d3fa49b0cdbbca98447d8086c0a287f194c2b2d03437d2a3a699a9669acc8c119

data/db/migrate/20170301120000_create_attachment_tables.rb

@@ -1,18 +1,23 @@
-class CreateAttachmentTables < ActiveRecord::Migration
+# frozen_string_literal: true
+
+class CreateAttachmentTables < ActiveRecord::Migration[6.0]
+
   def up
     create_table :attachments do |t|
-      t.integer :owner_id
-      t.string  :owner_type, :token, :digest, :role, :type, :file_name, :file_type, :cache_type, :cache_max_age, :disposition
-      t.integer :file_size
-      t.integer :parent_id
-      t.boolean :processed, :default => false
+      t.belongs_to :owner, polymorphic: true
+      t.string :token, :digest, :role, :type, :file_name, :file_type, :cache_type, :cache_max_age, :disposition
+      t.bigint :file_size
+      t.belongs_to :parent
+      t.boolean :processed, default: false
+      t.text :custom
+      t.boolean :serve, default: false
       t.timestamps
-      t.index :owner_id
+      t.index :token, length: 16
     end
 
     create_table :attachment_binaries do |t|
-      t.integer :attachment_id
-      t.binary :data, :limit => 10.megabytes
+      t.belongs_to :attachment
+      t.binary :data, limit: 10_485_760
       t.timestamps
     end
   end
@@ -21,4 +26,5 @@ class CreateAttachmentTables < ActiveRecord::Migration
     drop_table :attachments
     drop_table :attachment_binaries
   end
+
 end

data/lib/attach/attachment.rb

@@ -1,116 +1,173 @@
+# frozen_string_literal: true
+
 require 'securerandom'
 require 'digest/sha1'
 require 'attach/attachment_binary'
+require 'attach/processor'
+require 'attach/blob_types/raw'
+require 'attach/blob_types/file'
 
 module Attach
   class Attachment < ActiveRecord::Base
 
-    # Set the table name
     self.table_name = 'attachments'
     self.inheritance_column = 'sti_type'
 
-    # This will be the ActionDispatch::UploadedFile object which be diseminated
-    # by the class on save.
-    attr_writer :binary
+    attr_writer :backend
 
-    # Relationships
-    belongs_to :owner, :polymorphic => true
-    belongs_to :parent, :class_name => 'Attach::Attachment', :optional => true
-    has_many :children, :class_name => 'Attach::Attachment', :dependent => :destroy, :foreign_key => :parent_id
+    belongs_to :owner, polymorphic: true
+    belongs_to :parent, class_name: 'Attach::Attachment', optional: true
+    has_many :children, class_name: 'Attach::Attachment', dependent: :destroy, foreign_key: :parent_id
 
-    # Validations
-    validates :file_name, :presence => true
-    validates :file_type, :presence => true
-    validates :file_size, :presence => true
-    validates :digest, :presence => true
-    validates :token, :presence => true, :uniqueness => true
+    validates :file_name, presence: true
+    validates :file_type, presence: true
+    validates :file_size, presence: true
+    validates :digest, presence: true
+    validates :token, presence: true, uniqueness: { case_sensitive: false }
 
-    # Allow custom data to be stored on the attachment
-    serialize :custom, Hash
+    serialize :custom, type: Hash, default: {}
 
-    # Set size and digest
-    before_validation do
-      self.token      ||= SecureRandom.uuid
-      self.digest     ||= self.binary.is_a?(String) ? Digest::SHA1.hexdigest(self.binary) : Attach.backend.digest(self.binary)
-      self.file_size  ||= self.binary.is_a?(String) ? self.binary.bytesize : Attach.backend.bytesize(self.binary)
-    end
+    before_validation :set_token
+    before_validation :set_digest
+    before_validation :set_file_size
 
-    # Write the binary to the backend storage
-    after_create do
-      if self.binary
-        Attach.backend.write(self, self.binary)
-      end
-    end
+    after_create :write_blob_to_backend
+    after_create :destroy_other_attachments_for_same_parent
 
-    # Remove any old images for this owner/role when this is added
-    after_create do
-      self.owner.attachments.where.not(:id => self).where(:parent_id => self.parent_id, :role => self.role).destroy_all
-    end
+    after_commit :queue_or_process_with_processor
 
-    # Run any post-upload processing after the record has been committed
-    after_commit do
-      unless self.processed? || self.parent_id
-        self.processor.queue_or_process
-      end
-    end
+    after_destroy :remove_from_backend
 
-    # Remove the file from the backends
-    after_destroy do
-      Attach.backend.delete(self)
-    end
+    def blob
+      return @blob if instance_variable_defined?('@blob')
+      return nil unless persisted?
 
-    # Return the attachment for a given role
-    def self.for(role)
-      self.where(:role => role).first
+      @blob = backend.read(self)
     end
 
-    # Return the binary data for this attachment
-    def binary
-      @binary ||= persisted? ? Attach.backend.read(self) : nil
-      @binary == :nil ? nil : @binary
+    def blob=(blob)
+      unless blob.nil? || blob.is_a?(BlobTypes::File) || blob.is_a?(BlobTypes::Raw)
+        raise ArgumentError, 'Only nil or a File/Raw blob type can be set as a blob for an attachment'
+      end
+
+      @blob = blob
     end
 
-    # Return the path to the attachment
     def url
-      Attach.backend.url(self)
+      backend.url(self)
     end
 
-    # Is the attachment an image?
     def image?
       file_type =~ /\Aimage\//
     end
 
-    # Return a processor for this attachment
     def processor
       @processor ||= Processor.new(self)
     end
 
-    # Return a child process
     def child(role)
       @cached_children ||= {}
-      @cached_children[role.to_sym] ||= self.children.where(:role => role).first || :nil
-      @cached_children[role.to_sym] == :nil ? nil : @cached_children[role.to_sym]
+      if @cached_children.key?(role.to_sym)
+        return @cached_children[role.to_sym]
+      end
+
+      @cached_children[role.to_sym] = children.where(role: role).first
     end
 
-    # Try to return a given otherwise revert to the parent
     def try(role)
       child(role) || self
     end
 
-    # Add a child attachment
+    # rubocop:disable Metrics/AbcSize
     def add_child(role, &block)
-      attachment = self.children.build
+      attachment = children.build
       attachment.role = role
-      attachment.owner = self.owner
-      attachment.file_name = self.file_name
-      attachment.file_type = self.file_type
-      attachment.disposition = self.disposition
-      attachment.cache_type = self.cache_type
-      attachment.cache_max_age = self.cache_max_age
-      attachment.type = self.type
+      attachment.owner = owner
+      attachment.file_name = file_name
+      attachment.file_type = file_type
+      attachment.disposition = disposition
+      attachment.cache_type = cache_type
+      attachment.cache_max_age = cache_max_age
+      attachment.serve = serve
+      attachment.type = type
       block.call(attachment)
       attachment.save!
     end
+    # rubocop:enable Metrics/AbcSize
+
+    # rubocop:disable Metrics/AbcSize
+    def copy_attributes_from_file(file)
+      case file.class.name
+      when 'ActionDispatch::Http::UploadedFile'
+        self.blob = BlobTypes::File.new(file.tempfile)
+        self.file_name = file.original_filename
+        self.file_type = file.content_type
+      when 'Attach::File'
+        self.blob = BlobTypes::Raw.new(file.data)
+        self.file_name = file.name
+        self.file_type = file.type
+      else
+        self.blob = BlobTypes::Raw.new(file)
+        self.file_name = 'untitled'
+        self.file_type = 'application/octet-stream'
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    private
+
+    def backend
+      @backend || Attach.backend
+    end
+
+    def write_blob_to_backend
+      return if blob.blank?
+
+      backend.write(self, blob)
+    end
+
+    def destroy_other_attachments_for_same_parent
+      owner.attachments.where.not(id: self).where(parent_id: parent_id, role: role).destroy_all
+    end
+
+    def set_token
+      return if token.present?
+
+      self.token = SecureRandom.uuid
+    end
+
+    def set_digest
+      return if digest.present?
+      return if blob.blank?
+
+      self.digest = blob.digest
+    end
+
+    def set_file_size
+      return if file_size.present?
+      return if blob.blank?
+
+      self.file_size = blob.size
+    end
+
+    def remove_from_backend
+      backend.delete(self)
+    end
+
+    def queue_or_process_with_processor
+      return if processed?
+      return if parent_id
+
+      processor.queue_or_process
+    end
+
+    class << self
+
+      def for(role)
+        where(role: role).first
+      end
+
+    end
 
   end
 end

data/lib/attach/attachment_binary.rb

@@ -1,11 +1,11 @@
-require 'securerandom'
-require 'digest/sha1'
+# frozen_string_literal: true
 
 module Attach
   class AttachmentBinary < ActiveRecord::Base
 
-    # Set the table name
     self.table_name = 'attachment_binaries'
 
+    belongs_to :attachment
+
   end
 end

data/lib/attach/attachment_dsl.rb

@@ -1,15 +1,14 @@
+# frozen_string_literal: true
+
 module Attach
   class AttachmentDSL
 
-    attr_reader :processors
-    attr_reader :validators
+    attr_reader :processors, :validators
 
     def initialize(&block)
       @processors = []
       @validators = []
-      if block_given?
-        instance_eval(&block)
-      end
+      instance_eval(&block) if block_given?
     end
 
     def processor(*processors, &block)

data/lib/attach/backends/abstract.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Attach
   module Backends
     class Abstract
@@ -7,19 +9,19 @@ module Attach
       end
 
       #
-      # Return the data for the given attachment
+      #  Return the data for the given attachment
       #
       def read(attachment)
       end
 
       #
-      # Write data for the given attachment
+      #  Write data for the given attachment
       #
       def write(attachment, data)
       end
 
       #
-      # Delete the data for the given attachment
+      #  Delete the data for the given attachment
       #
       def delete(attachment)
       end
@@ -32,7 +34,7 @@ module Attach
       end
 
       #
-      # Return binaries for a set of files. They should be returned as a hash consisting
+      #  Return binaries for a set of files. They should be returned as a hash consisting
       # of the attachment ID followed by the data
       #
       def read_multi(attachments)

data/lib/attach/backends/database.rb

@@ -1,37 +1,29 @@
+# frozen_string_literal: true
+
+require 'attach/attachment_binary'
 require 'attach/backends/abstract'
+require 'attach/blob_types/raw'
 
 module Attach
   module Backends
     class Database < Abstract
 
       def read(attachment)
-        if binary = AttachmentBinary.find_by_attachment_id(attachment.id)
-          binary.data
-        else
-          nil
-        end
+        binary = AttachmentBinary.find_by(attachment_id: attachment.id)
+        return if binary.nil?
+
+        BlobTypes::Raw.new(binary.data)
       end
 
-      def write(attachment, binary)
-        binary_object = AttachmentBinary.where(:attachment_id => attachment.id).first_or_initialize
-        if binary.respond_to?(:path)
-          binary.rewind
-          binary_object.data = binary.read
-        else
-          binary_object.data = binary
-        end
+      def write(attachment, blob)
+        binary_object = AttachmentBinary.where(attachment_id: attachment.id).first_or_initialize
+        binary_object.data = blob.read
         binary_object.save!
         binary_object
       end
 
       def delete(attachment)
-        AttachmentBinary.where(:attachment_id => attachment.id).destroy_all
-      end
-
-      def read_multi(attachments)
-        AttachmentBinary.where(:attachment_id => attachments.map(&:id)).each_with_object({}) do |binary, hash|
-          hash[binary.attachment_id] = binary.data
-        end
+        AttachmentBinary.where(attachment_id: attachment.id).destroy_all
       end
 
     end

data/lib/attach/backends/file_system.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 require 'attach/backends/abstract'
 
@@ -6,24 +8,28 @@ module Attach
     class FileSystem < Abstract
 
       def read(attachment)
-        ::File.read(path_for_attachment(attachment))
+        file = File.new(path_for_attachment(attachment))
+        BlobTypes::File.new(file)
       end
 
-      def write(attachment, data)
+      def write(attachment, blob)
         path = path_for_attachment(attachment)
         FileUtils.mkdir_p(::File.dirname(path))
-        if data.respond_to?(:path)
-          FileUtils.mv(data.path, path)
-        else
-          ::File.open(path, 'wb') do |f|
-            f.write(data)
-          end
+
+        if blob.is_a?(BlobTypes::File)
+          FileUtils.mv(blob.file.path, path)
+          return path
         end
+
+        ::File.binwrite(path, blob.read)
+
+        path
       end
 
       def delete(attachment)
         path = path_for_attachment(attachment)
         FileUtils.rm(path) if ::File.file?(path)
+        path
       end
 
       private
@@ -33,7 +39,7 @@ module Attach
       end
 
       def path_for_attachment(attachment)
-        ::File.join(root_dir, attachment.token[0,2], attachment.token[2,2], attachment.token[4,40])
+        ::File.join(root_dir, attachment.token[0, 2], attachment.token[2, 2], attachment.token[4, 40])
       end
 
     end

data/lib/attach/blob_types/file.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Attach
+  module BlobTypes
+    class File
+
+      attr_reader :file
+
+      def initialize(file)
+        @file = file
+      end
+
+      def read
+        @file.rewind
+        @file.read
+      end
+
+      def size
+        @file.size
+      end
+
+      def digest
+        Digest::SHA1.file(@file.path).to_s
+      end
+
+    end
+  end
+end

data/lib/attach/blob_types/raw.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Attach
+  module BlobTypes
+    class Raw
+
+      def initialize(data)
+        @data = data
+      end
+
+      def read
+        @data
+      end
+
+      def size
+        @data.bytesize
+      end
+
+      def digest
+        Digest::SHA1.hexdigest(@data)
+      end
+
+    end
+  end
+end

data/lib/attach/file.rb

@@ -1,11 +1,11 @@
+# frozen_string_literal: true
+
 module Attach
   class File
 
-    attr_accessor :data
-    attr_accessor :name
-    attr_accessor :type
+    attr_accessor :data, :name, :type
 
-    def initialize(data, name = "untitled", type = "application/octet-stream")
+    def initialize(data, name = 'untitled', type = 'application/octet-stream')
       @data = data
       @name = name
       @type = type

data/lib/attach/middleware.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'attach/attachment'
 
 module Attach
@@ -8,21 +10,28 @@ module Attach
     end
 
     def call(env)
-      if env['PATH_INFO'] =~ /\A\/attachment\/([a-f0-9\-]{36})\/(.*)/
-        if attachment = Attach::Attachment.where(:serve => true).find_by_token($1)
-          [200, {
-            'Content-Length' => attachment.file_size.to_s,
-            'Content-Type' => attachment.file_type,
-            'Cache-Control' => "#{attachment.cache_type || 'private'}, immutable, max-age=#{attachment.cache_max_age || 30.days.to_i}",
-            'Content-Disposition' => "#{attachment.disposition || 'attachment'}; filename=\"#{attachment.file_name}\""
-            },
-          [attachment.binary]]
-        else
-          [404, {}, ["Attachment not found"]]
-        end
-      else
-        @app.call(env)
+      unless env['PATH_INFO'] =~ /\A\/attachment\/([a-f0-9-]{36})\/(.*)/
+        return @app.call(env)
+      end
+
+      attachment = Attach::Attachment.where(serve: true).find_by(token: Regexp.last_match(1))
+      if attachment.nil?
+        return [404, {}, ['Attachment not found']]
       end
+
+      [200, headers_for_attachment(attachment), [attachment.blob.read]]
+    end
+
+    private
+
+    def headers_for_attachment(attachment)
+      max_age = attachment.cache_max_age || 30.days.to_i
+      {
+        'Content-Length' => attachment.file_size.to_s,
+        'Content-Type' => attachment.file_type,
+        'Cache-Control' => "#{attachment.cache_type || 'private'}, immutable, max-age=#{max_age}",
+        'Content-Disposition' => "#{attachment.disposition || 'attachment'}; filename=\"#{attachment.file_name}\""
+      }
     end
 
   end

data/lib/attach/model_extension/class_methods.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'attach/attachment_dsl'
+require 'attach/attachment'
+require 'attach/model_extension/inclusion'
+
+require 'records_manipulator/relation_extension'
+ActiveRecord::Relation.include RecordsManipulator::RelationExtension
+
+require 'records_manipulator/base_extension'
+ActiveRecord::Base.include RecordsManipulator::BaseExtension
+
+module Attach
+  module ModelExtension
+    module ClassMethods
+
+      def attachment_validators
+        @attachment_validators ||= {}
+      end
+
+      def attachment_processors
+        @attachment_processors ||= {}
+      end
+
+      def attachment(name, **options, &block)
+        setup_model
+        parse_dsl(name, &block)
+
+        define_method name do
+          get_attachment(name)
+        end
+
+        define_method "#{name}=" do |file|
+          set_attachment(name, file, **options)
+        end
+
+        define_method "#{name}_delete" do
+          instance_variable_get("@#{name}_delete")
+        end
+
+        define_method "#{name}_delete=" do |delete|
+          delete = delete.to_i
+          instance_variable_set("@#{name}_delete", delete)
+          if delete == 1
+            @pending_attachment_deletions ||= []
+            @pending_attachment_deletions << name
+          end
+        end
+      end
+
+      def includes_attachment(*args, **options)
+        manipulate do |scope|
+          inclusion = Inclusion.new(scope, *args, **options)
+          inclusion.prepare
+        end
+      end
+
+      private
+
+      def setup_model
+        return if reflect_on_all_associations(:has_many).map(&:name).include?(:attachments)
+
+        has_many :attachments, as: :owner, dependent: :destroy, class_name: 'Attach::Attachment'
+        validate :validate_attachments
+        after_save :process_pending_attachments
+      end
+
+      def parse_dsl(name, &block)
+        dsl = AttachmentDSL.new(&block)
+        attachment_validators[name.to_sym] = dsl.validators
+        attachment_processors[name.to_sym] = dsl.processors
+      end
+
+    end
+  end
+end

data/lib/attach/model_extension/inclusion.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Attach
+  module ModelExtension
+    class Inclusion
+
+      def initialize(scope, *options)
+        @scope = scope
+        @options = options
+        @fields = {}
+      end
+
+      def prepare
+        return if @scope.empty?
+
+        prepare_fields
+        find_all_attachments
+        find_child_attachments
+        add_attachments_to_records
+      end
+
+      private
+
+      def prepare_fields
+        @options.each do |field|
+          case field
+          when Symbol
+            @fields[field] = []
+          when Hash
+            field.each do |k, v|
+              case v
+              when Array
+                @fields.merge!(field)
+              when Symbol
+                @fields[k] = [v]
+              end
+            end
+          end
+        end
+      end
+
+      def find_all_attachments
+        @attachment_ids = []
+        @attachments_map = Attachment.where(
+          owner_id: @scope.map(&:id),
+          owner_type: @scope.first.class.name,
+          role: @fields.keys
+        ).each_with_object({}) do |attachment, hash|
+          hash[attachment.owner_id] ||= {}
+          hash[attachment.owner_id][attachment.role] = attachment
+          @attachment_ids << attachment.id
+        end
+      end
+
+      def find_child_attachments
+        @child_attachments = Attachment.where(
+          parent: @attachment_ids,
+          role: @fields.values.flatten.compact
+        ).each_with_object({}) do |attachment, hash|
+          hash[attachment.parent_id] ||= {}
+          hash[attachment.parent_id][attachment.role] = attachment
+        end
+      end
+
+      def add_attachments_to_records
+        @scope.each do |record|
+          preloaded_attachments = @attachments_map[record.id] || {}
+          @fields.each_key do |role|
+            cache_attachment(
+              record,
+              role,
+              preloaded_attachments[role.to_s]
+            )
+          end
+        end
+      end
+
+      def cache_attachment(record, role, attachment)
+        record.instance_variable_set("@#{role}", attachment)
+        return if attachment.nil?
+
+        @fields[role.to_sym].each do |child_role|
+          child_attachment = @child_attachments.dig(attachment.id, child_role.to_s)
+          if attachment.instance_variable_get('@cached_children').nil?
+            attachment.instance_variable_set('@cached_children', {})
+          end
+          attachment.instance_variable_get('@cached_children')[child_role] = child_attachment
+        end
+      end
+
+    end
+  end
+end

data/lib/attach/model_extension/instance_methods.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'attach/attachment'
+
+module Attach
+  module ModelExtension
+    module InstanceMethods
+
+      def process_pending_attachments
+        attachments.where(role: @pending_attachment_deletions).destroy_all if @pending_attachment_deletions
+
+        return if @pending_attachments.nil? || @pending_attachments.empty?
+
+        @pending_attachments.each_value(&:save!)
+        @pending_attachments = nil
+      end
+
+      private
+
+      def get_attachment(name)
+        iv_name = "@#{name}"
+        return instance_variable_get(iv_name) if instance_variable_defined?(iv_name)
+
+        if attachment = attachments.where(role: name, parent_id: nil).first
+          return instance_variable_set(iv_name, attachment)
+        end
+
+        instance_variable_set(iv_name, nil)
+      end
+
+      def set_attachment(name, file, **options)
+        attachment = Attachment.new({ owner: self, role: name }.merge(options))
+        attachment.copy_attributes_from_file(file)
+        @pending_attachments ||= {}
+        @pending_attachments[name] = attachment
+        instance_variable_set("@#{name}", attachment)
+      end
+
+      def validate_attachments
+        return if @pending_attachments.nil? || @pending_attachments.empty?
+
+        @pending_attachments.each_value do |attachment|
+          validators = self.class.attachment_validators[attachment.role.to_sym]
+          next if validators.blank?
+
+          validators.each do |validator|
+            validator.call(attachment, errors)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/attach/model_extension.rb

@@ -1,192 +1,16 @@
-require 'attach/attachment'
-require 'attach/processor'
-require 'attach/attachment_dsl'
+# frozen_string_literal: true
+
+require 'attach/model_extension/class_methods'
+require 'attach/model_extension/instance_methods'
 
 module Attach
   module ModelExtension
 
-    def self.included(base)
-      base.extend ClassMethods
-      base.after_save do
-        if @pending_attachment_deletions
-          self.attachments.where(:role => @pending_attachment_deletions).destroy_all
-        end
-
-        @replaced_attachment&.destroy
-
-        if @pending_attachments
-          @pending_attachments.values.each(&:save!)
-          @pending_attachments = nil
-        end
-      end
-    end
-
-    module ClassMethods
-
-      def includes_attachments(*options)
-        manipulate do |records|
-          if records.empty?
-            # Nothing to do
-          else
-
-            if options.first.is_a?(Hash)
-              options = options.first
-              binaries_to_include = options.delete(:_include_binaries) || {}
-            else
-              binaries_to_include = {}
-              options = options.each_with_object({}) do |opt, hash|
-                if opt.is_a?(Symbol) || opt.is_a?(String)
-                  hash[opt.to_sym] = []
-                elsif opt.is_a?(Hash)
-                  opt.each do |key, value|
-                    if key == :_include_binaries
-                      binaries_to_include = value
-                    else
-                      hash[key.to_sym] = value
-                    end
-                  end
-                end
-              end
-
-            end
-
-            options.keys.each do |key|
-              if options[key].is_a?(Symbol)
-                options[key] = [options[key]]
-              elsif options[key] == true
-                options[key] = []
-              end
-            end
-
-            attachments_for_binary_preload = []
-            root_attachments = {}
-            Attachment.where(:owner_id => records.map(&:id), :owner_type => records.first.class.to_s, :role => options.keys).each do |attachment|
-              root_attachments[[attachment.owner_id, attachment.role]] = attachment
-              if binaries_to_include[attachment.role.to_sym] && binaries_to_include[attachment.role.to_sym].include?(:_self)
-                attachments_for_binary_preload << attachment
-              end
-            end
-
-            child_roles = options.values.flatten
-            unless child_roles.empty?
-              child_attachments = {}
-              Attachment.where(:parent_id => root_attachments.values.map(&:id), :role => child_roles).each do |attachment|
-                child_attachments[[attachment.parent_id, attachment.role]] = attachment
-              end
-
-              root_attachments.values.each do |attachment|
-                options[attachment.role.to_sym].each do |role|
-                  child_attachment = child_attachments[[attachment.id, role.to_s]]
-
-                  if child_attachment && binaries_to_include[attachment.role.to_sym] && binaries_to_include[attachment.role.to_sym].include?(role)
-                    attachments_for_binary_preload << child_attachment
-                  end
-
-                  attachment.instance_variable_set("@cached_children", {}) if attachment.instance_variable_get("@cached_children").nil?
-                  attachment.instance_variable_get("@cached_children")[role.to_sym] = child_attachments[[attachment.id, role.to_s]] || :nil
-                end
-              end
-            end
-
-            if binaries = Attach.backend.read_multi(attachments_for_binary_preload)
-              attachments_for_binary_preload.each do |attachment|
-                attachment.instance_variable_set("@binary", binaries[attachment.id] || :nil)
-              end
-            else
-              # Preloading binaries isn't supported by the backend
-            end
-
-            records.each do |record|
-              options.keys.each do |role|
-                record.instance_variable_set("@#{role}", root_attachments[[record.id, role.to_s]] || :nil)
-              end
-            end
-          end
-        end
-      end
-
-      def attachment(name, options = {}, &block)
-        unless self.reflect_on_all_associations(:has_many).map(&:name).include?(:attachments)
-          has_many :attachments, :as => :owner, :dependent => :destroy, :class_name => 'Attach::Attachment'
-        end
-
-        dsl = AttachmentDSL.new(&block)
-
-        dsl.processors.each do |processor|
-          Processor.register(self, name, &processor)
-        end
-
-        if dsl.validators.size > 0
-          validate do
-            attachment = @pending_attachments && @pending_attachments[name] ? @pending_attachments[name] : send(name)
-            file_errors = []
-            dsl.validators.each do |validator|
-              validator.call(attachment, file_errors)
-            end
-            file_errors.each { |e| errors.add("#{name}_file", e) }
-          end
-        end
-
-        define_method name do
-          var = instance_variable_get("@#{name}")
-          if var
-            var == :nil ? nil : var
-          else
-            if attachment = self.attachments.where(:role => name, :parent_id => nil).first
-              instance_variable_set("@#{name}", attachment)
-            else
-              instance_variable_set("@#{name}", :nil)
-              nil
-            end
-          end
-        end
-
-        define_method "#{name}=" do |file|
-          if file.is_a?(Attach::Attachment)
-            @replaced_attachment = self.try(name)
-            attachment = file
-            attachment.owner = self
-            attachment.role = name
-            attachment.processed = false
-          elsif file
-            attachment = Attachment.new({:owner => self, :role => name}.merge(options))
-            case file
-            when ActionDispatch::Http::UploadedFile
-              attachment.binary = file.tempfile
-              attachment.file_name = file.original_filename
-              attachment.file_type = file.content_type
-            when Attach::File
-              attachment.binary = file.data
-              attachment.file_name = file.name
-              attachment.file_type = file.type
-            else
-              attachment.binary = file
-              attachment.file_name = "untitled"
-              attachment.file_type = "application/octet-stream"
-            end
-          end
-
-          if attachment
-            @pending_attachments ||= {}
-            @pending_attachments[name] = attachment
-          end
-          instance_variable_set("@#{name}", attachment)
-        end
-
-        define_method "#{name}_delete" do
-          instance_variable_get("@#{name}_delete")
-        end
-
-        define_method "#{name}_delete=" do |delete|
-          delete = delete.to_i
-          instance_variable_set("@#{name}_delete", delete)
-          if delete == 1
-            @pending_attachment_deletions ||= []
-            @pending_attachment_deletions << name
-          end
-        end
-      end
+    extend ActiveSupport::Concern
 
+    included do
+      extend ClassMethods
+      include InstanceMethods
     end
 
   end

data/lib/attach/processor.rb

@@ -1,49 +1,50 @@
+# frozen_string_literal: true
+
 module Attach
   class Processor
 
-    def self.background(&block)
-      @background_block = block
-    end
+    class << self
 
-    def self.background_block
-      @background_block
-    end
+      attr_reader :background_block
 
-    def self.register(model, attribute, &block)
-      @processors ||= {}
-      @processors[[model.to_s, attribute.to_s]] ||= []
-      @processors[[model.to_s, attribute.to_s]] = block
-    end
+      def background(&block)
+        @background_block = block
+      end
 
-    def self.processor(model, attribute)
-      @processors && @processors[[model.to_s, attribute.to_s]]
     end
-
     def initialize(attachment)
       @attachment = attachment
     end
 
     def process
-      call_processors(@attachment)
-      @attachment.processed = true
-      @attachment.save(:validate => false)
+      call_processors
+      mark_as_processed
     end
 
     def queue_or_process
-      if self.class.background_block
-        self.class.background_block.call(@attachment)
-      else
-        process
-      end
+      return self.class.background_block.call(@attachment) if self.class.background_block
+
+      process
     end
 
     private
 
-    def call_processors(attachment)
-      if p = self.class.processor(attachment.owner_type, attachment.role)
-        p.call(attachment)
+    def call_processors
+      return if @attachment.role.blank?
+      return if @attachment.owner.nil?
+
+      processors = @attachment.owner.class.attachment_processors[@attachment.role.to_sym]
+      return if processors.nil? || processors.empty?
+
+      processors.each do |processor|
+        processor.call(@attachment)
       end
     end
 
+    def mark_as_processed
+      @attachment.processed = true
+      @attachment.save!
+    end
+
   end
 end

data/lib/attach/railtie.rb

@@ -1,18 +1,18 @@
+# frozen_string_literal: true
+
 module Attach
-  class Railtie < Rails::Engine #:nodoc:
+  class Railtie < Rails::Engine # :nodoc:
 
     engine_name 'attach'
 
     initializer 'attach.initialize' do |app|
-
       require 'attach/middleware'
       app.config.middleware.use Attach::Middleware
 
       ActiveSupport.on_load(:active_record) do
         require 'attach/model_extension'
-        ::ActiveRecord::Base.send :include, Attach::ModelExtension
+        ::ActiveRecord::Base.include Attach::ModelExtension
       end
-
     end
 
   end

data/lib/attach/version.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
 module Attach
-  VERSION = '1.1.2'.freeze
+
+  VERSION = '2.0.3'
+
 end

data/lib/attach.rb

@@ -1,32 +1,26 @@
-require 'records_manipulator'
-require 'attach/processor'
-require 'attach/file'
+# frozen_string_literal: true
+
 require 'attach/railtie' if defined?(Rails)
 
 module Attach
 
-  def self.backend
-    @backend ||= begin
-      require 'attach/backends/database'
-      Attach::Backends::Database.new
-    end
-  end
+  class << self
 
-  def self.backend=(backend)
-    @backend = backend
-  end
+    attr_writer :backend
+    attr_accessor :asset_host
 
-  def self.asset_host
-    @asset_host
-  end
+    def backend
+      @backend ||= begin
+        require 'attach/backends/database'
+        Attach::Backends::Database.new
+      end
+    end
 
-  def self.asset_host=(host)
-    @asset_host = host
-  end
+    def use_filesystem!(config = {})
+      require 'attach/backends/file_system'
+      @backend = Attach::Backends::FileSystem.new(config)
+    end
 
-  def self.use_filesystem!(config = {})
-    require 'attach/backends/file_system'
-    @backend = Attach::Backends::FileSystem.new(config)
   end
 
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: attach
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 2.0.3
 platform: ruby
 authors:
 - Adam Cooke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-30 00:00:00.000000000 Z
+date: 2023-11-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: records_manipulator
   requirement: !ruby/object:Gem::Requirement
@@ -38,8 +52,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - db/migrate/20170301120000_create_attachment_tables.rb
-- db/migrate/20170314113014_add_custom_data_to_attachments.rb
-- db/migrate/20181123160000_add_index_to_attachment_binaries.rb
 - lib/attach.rb
 - lib/attach/attachment.rb
 - lib/attach/attachment_binary.rb
@@ -47,13 +59,18 @@ files:
 - lib/attach/backends/abstract.rb
 - lib/attach/backends/database.rb
 - lib/attach/backends/file_system.rb
+- lib/attach/blob_types/file.rb
+- lib/attach/blob_types/raw.rb
 - lib/attach/file.rb
 - lib/attach/middleware.rb
 - lib/attach/model_extension.rb
+- lib/attach/model_extension/class_methods.rb
+- lib/attach/model_extension/inclusion.rb
+- lib/attach/model_extension/instance_methods.rb
 - lib/attach/processor.rb
 - lib/attach/railtie.rb
 - lib/attach/version.rb
-homepage: https://github.com/adamcooke/attach
+homepage: https://github.com/krystal/attach
 licenses:
 - MIT
 metadata: {}
@@ -65,14 +82,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
 summary: Attach documents & files to Active Record models

data/db/migrate/20170314113014_add_custom_data_to_attachments.rb

@@ -1,15 +0,0 @@
-class AddCustomDataToAttachments < ActiveRecord::Migration
-
-  def up
-    add_column :attachments, :custom, :text
-    add_column :attachments, :serve, :boolean, :default => true
-    add_index :attachments, :token, :length => 10
-  end
-
-  def down
-    remove_index :attachments, :token
-    remove_column :attachments, :custom
-    remove_column :attachments, :serve
-  end
-
-end

data/db/migrate/20181123160000_add_index_to_attachment_binaries.rb

@@ -1,11 +0,0 @@
-class AddIndexToAttachmentBinaries < ActiveRecord::Migration
-
-  def up
-    add_index :attachment_binaries, :attachment_id
-  end
-
-  def down
-    remove_index :attachment_binaries, :attachment_id
-  end
-
-end