attach 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bba016e24c62143435904ab7adec8d742dfc2cff
+  data.tar.gz: 7fd96092ed4196d2eb765788adf376bbb8caec46
+SHA512:
+  metadata.gz: 1728d88028c90ca2701943199a9fecfe5cbe4b6f3358a3533f617aa279942e05974f94d3bb7089e31e99af1082781a2f9979cb2857d617c07d6399f590ef2e09
+  data.tar.gz: abb0b019475de3fb68a433aa99a80facdd95c86701e76ba5fea90c7b097e0bb507337a1404f67571f2aceb9aae8cf1f2ef0248fedc87ca37764e007f7d5f33fa

data/lib/attach.rb

@@ -0,0 +1,23 @@
+require 'records_manipulator'
+require 'attach/processor'
+require 'attach/railtie' if defined?(Rails)
+
+module Attach
+
+  def self.backend
+    @backend ||= begin
+      require 'attach/backends/database'
+      Attach::Backends::Database.new
+    end
+  end
+
+  def self.backend=(backend)
+    @backend = backend
+  end
+
+  def self.use_filesystem!(config = {})
+    require 'attach/backends/file_system'
+    @backend = Attach::Backends::FileSystem.new(config)
+  end
+
+end

data/lib/attach/attachment.rb

@@ -0,0 +1,116 @@
+require 'securerandom'
+require 'digest/sha1'
+require 'attach/attachment_binary'
+
+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_accessor :uploaded_file
+    attr_writer :binary
+
+    # 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
+
+    # 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
+
+    # All attachments should have a token assigned to this
+    before_validation { self.token = SecureRandom.uuid if self.token.blank? }
+
+    # Copy values from the `uploaded_file` and set them as the appropriate
+    # fields on this model
+    before_validation do
+      if self.uploaded_file
+        self.binary = self.uploaded_file.tempfile.read
+        self.file_name = self.uploaded_file.original_filename
+        self.file_type = self.uploaded_file.content_type
+      end
+
+      self.digest = Digest::SHA1.hexdigest(self.binary)
+      self.file_size = self.binary.bytesize
+    end
+
+    # Write the binary to the backend storage
+    after_create do
+      Attach.backend.write(self, self.binary)
+    end
+
+    # 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
+
+    # 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
+
+    # Remove the file from the backends
+    after_destroy do
+      Attach.backend.delete(self)
+    end
+
+    # Return the attachment for a given role
+    def self.for(role)
+      self.where(:role => role).first
+    end
+
+    # Return the binary data for this attachment
+    def binary
+      @binary ||= persisted? ? Attach.backend.read(self) : nil
+    end
+
+    # Return the path to the attachment
+    def url
+      Attach.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] ||= begin
+        self.children.where(:role => role).first
+      end
+    end
+
+    # Add a child attachment
+    def add_child(role, &block)
+      attachment = self.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
+      block.call(attachment)
+      attachment.save!
+    end
+
+  end
+end

data/lib/attach/attachment_binary.rb

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

data/lib/attach/backends/abstract.rb

@@ -0,0 +1,36 @@
+module Attach
+  module Backends
+    class Abstract
+
+      def initialize(config = {})
+        @config = config
+      end
+
+      #
+      # Return the data for the given attachment
+      #
+      def read(attachment)
+      end
+
+      #
+      # Write data for the given attachment
+      #
+      def write(attachment, data)
+      end
+
+      #
+      # Delete the data for the given attachment
+      #
+      def delete(attachment)
+      end
+
+      #
+      # Return the URL that this attachment can be accessed at
+      #
+      def url(attachment)
+        "/attachment/#{attachment.token}/#{attachment.file_name}"
+      end
+
+    end
+  end
+end

data/lib/attach/backends/database.rb

@@ -0,0 +1,27 @@
+require 'attach/backends/abstract'
+
+module Attach
+  module Backends
+    class Database < Abstract
+
+      def read(attachment)
+        if binary = AttachmentBinary.find_by_attachment_id(attachment.id)
+          binary.data
+        else
+          nil
+        end
+      end
+
+      def write(attachment, data)
+        binary = AttachmentBinary.where(:attachment_id => attachment.id).first_or_initialize
+        binary.data = data
+        binary.save!
+      end
+
+      def delete(attachment)
+        AttachmentBinary.where(:attachment_id => attachment.id).destroy_all
+      end
+
+    end
+  end
+end

data/lib/attach/backends/file_system.rb

@@ -0,0 +1,37 @@
+require 'fileutils'
+require 'attach/backends/abstract'
+
+module Attach
+  module Backends
+    class FileSystem < Abstract
+
+      def read(attachment)
+        File.read(path_for_attachment(attachment))
+      end
+
+      def write(attachment, data)
+        path = path_for_attachment(attachment)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.open(path, 'wb') do |f|
+          f.write(data)
+        end
+      end
+
+      def delete(attachment)
+        path = path_for_attachment(attachment)
+        FileUtils.rm(path) if File.file?(path)
+      end
+
+      private
+
+      def root_dir
+        @config[:root] ||= Rails.root.join('attachments')
+      end
+
+      def path_for_attachment(attachment)
+        File.join(root_dir, attachment.token[0,2], attachment.token[2,2], attachment.token[4,40])
+      end
+
+    end
+  end
+end

data/lib/attach/middleware.rb

@@ -0,0 +1,29 @@
+require 'attach/attachment'
+
+module Attach
+  class Middleware
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      if env['PATH_INFO'] =~ /\A\/attachment\/([a-f0-9\-]{36})\/(.*)/
+        if attachment = Attach::Attachment.find_by_token($1)
+          [200, {
+            'Content-Length' => attachment.file_size.to_s,
+            'Content-Type' => attachment.file_type,
+            'Cache-Control' => "#{attachment.cache_type || 'private'}, immutable, maxage=#{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)
+      end
+    end
+
+  end
+end

data/lib/attach/model_extension.rb

@@ -0,0 +1,126 @@
+require 'attach/attachment'
+require 'attach/processor'
+
+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
+
+        if @pending_attachments
+          @pending_attachments.each do |pa|
+            attachment = self.attachments.build(:uploaded_file => pa[:file], :role => pa[:role])
+            if pa[:options]
+              pa[:options].each do |key, value|
+                attachment.send("#{key}=", value)
+              end
+            end
+            attachment.save!
+          end
+          @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
+            else
+              options = options.each_with_object({}) do |role, hash|
+                hash[role.to_sym] = []
+              end
+            end
+
+            options.keys.each do |key|
+              if options[key].is_a?(Symbol)
+                options[key] = [options[key]]
+              end
+            end
+
+            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
+            end
+
+            child_attachments = {}
+            child_roles = options.values.flatten
+            Attachment.where(:parent_id => root_attachments.values.map(&:id), :role => child_roles).each do |attachment|
+              child_attachments[[attachment.id, attachment.role]] = attachment
+            end
+
+            root_attachments.values.each do |attachment|
+              options[attachment.role.to_sym].each do |role|
+                attachment.instance_variable_set("@cached_children", {}) if attachment.instance_variable_get("@cached_children").nil?
+                attachment.instance_variable_get("@cached_children")[role.to_sym] = attachment
+              end
+            end
+
+            records.each do |record|
+              options.keys.each do |role|
+                if a = root_attachments[[record.id, role.to_s]]
+                  record.instance_variable_set("@#{role}", a)
+                end
+              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
+
+        if block_given?
+          Processor.register(self, name, &block)
+        end
+
+        define_method name do
+          instance_variable_get("@#{name}") || begin
+            attachment = self.attachments.where(:role => name, :parent_id => nil).first
+            instance_variable_set("@#{name}", attachment)
+          end
+        end
+
+        define_method "#{name}_file" do
+          instance_variable_get("@#{name}_file")
+        end
+
+        define_method "#{name}_file=" do |file|
+          instance_variable_set("@#{name}_file", file)
+          if file.is_a?(ActionDispatch::Http::UploadedFile)
+            @pending_attachments ||= []
+            @pending_attachments << {:role => name, :file => file, :options => options}
+          else
+            nil
+          end
+        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
+
+    end
+
+  end
+end

data/lib/attach/processor.rb

@@ -0,0 +1,48 @@
+module Attach
+  class Processor
+
+    def self.background(&block)
+      @background_block = block
+    end
+
+    def self.background_block
+      @background_block
+    end
+
+    def self.register(model, attribute, &block)
+      @processors ||= {}
+      @processors[[model.to_s, attribute.to_s]] ||= []
+      @processors[[model.to_s, attribute.to_s]] = 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.update_column(:processed, true)
+    end
+
+    def queue_or_process
+      if self.class.background_block
+        self.class.background_block.call(@attachment)
+      else
+        process
+      end
+    end
+
+    private
+
+    def call_processors(attachment)
+      if p = self.class.processor(attachment.owner_type, attachment.role)
+        p.call(attachment)
+      end
+    end
+
+  end
+end

data/lib/attach/railtie.rb

@@ -0,0 +1,19 @@
+module Attach
+  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
+      end
+
+    end
+
+  end
+end

data/lib/attach/version.rb

@@ -0,0 +1,3 @@
+module Attach
+  VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: attach
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Adam Cooke
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: records_manipulator
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Attach documents & files to Active Record models
+email:
+- me@adamcooke.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/attach.rb
+- lib/attach/attachment.rb
+- lib/attach/attachment_binary.rb
+- lib/attach/backends/abstract.rb
+- lib/attach/backends/database.rb
+- lib/attach/backends/file_system.rb
+- lib/attach/middleware.rb
+- lib/attach/model_extension.rb
+- lib/attach/processor.rb
+- lib/attach/railtie.rb
+- lib/attach/version.rb
+homepage: https://github.com/adamcooke/attach
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Attach documents & files to Active Record models
+test_files: []