saviour 0.2.0

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/saviour.rb

@@ -0,0 +1,170 @@
+require 'fileutils'
+require 'digest/md5'
+require 'active_support/concern'
+require 'active_support/core_ext'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'fog/aws'
+
+require 'saviour/processors/digest'
+
+require 'saviour/version'
+require 'saviour/base_uploader'
+require 'saviour/file'
+require 'saviour/local_storage'
+require 'saviour/s3_storage'
+require 'saviour/config'
+require 'saviour/string_source'
+require 'saviour/url_source'
+
+module Saviour
+  class ColumnNamer
+    def initialize(attached_as, version = nil)
+      @attached_as, @version = attached_as, version
+    end
+
+    def name
+      if @version
+        "#{@attached_as}_#{@version}"
+      else
+        @attached_as.to_s
+      end
+    end
+  end
+
+  class ModelHooks
+    def initialize(model)
+      @model = model
+    end
+
+    def delete!
+      attached_files.each do |column, versions|
+        (versions + [nil]).each { |version| @model.send(column, version).delete if @model.send(column, version).exists? }
+      end
+    end
+
+    def save!
+      attached_files.each do |column, versions|
+        base_file_changed = @model.send(column).changed?
+        original_content = @model.send(column).source_data if base_file_changed
+
+        versions.each do |version|
+          if @model.send(column, version).changed?
+            upload_file(column, version)
+          elsif base_file_changed
+            @model.send(column, version).assign(StringSource.new(original_content, default_version_filename(column, version)))
+            upload_file(column, version)
+          end
+        end
+
+        upload_file(column, nil) if base_file_changed
+      end
+    end
+
+    def validate!
+      validations.each do |column, method_or_blocks|
+        (attached_files[column] + [nil]).each do |version|
+          if @model.send(column, version).changed?
+            method_or_blocks.each { |method_or_block| run_validation(column, version, method_or_block) }
+          end
+        end
+      end
+    end
+
+    def default_version_filename(column, version)
+      filename = @model.send(column).filename_to_be_assigned
+      "#{::File.basename(filename, ".*")}_#{version}#{::File.extname(filename)}"
+    end
+
+    def upload_file(column, version)
+      name = ColumnNamer.new(column, version).name
+      Config.storage.delete(@model.read_attribute(name)) if @model.read_attribute(name)
+      new_path = @model.send(column, version).write
+      @model.update_column(name, new_path)
+    end
+
+    def attached_files
+      @model.class.attached_files || {}
+    end
+
+    def run_validation(column, version, method_or_block)
+      data = @model.send(column, version).source_data
+      filename = @model.send(column, version).filename_to_be_assigned
+      opts = {attached_as: column, version: version}
+
+      if method_or_block.respond_to?(:call)
+        if method_or_block.arity == 2
+          @model.instance_exec(data, filename, &method_or_block)
+        else
+          @model.instance_exec(data, filename, opts, &method_or_block)
+        end
+      else
+        if @model.method(method_or_block).arity == 2
+          @model.send(method_or_block, data, filename)
+        else
+          @model.send(method_or_block, data, filename, opts)
+        end
+      end
+    end
+
+    def validations
+      @model.class.__saviour_validations || {}
+    end
+  end
+
+  extend ActiveSupport::Concern
+
+  NoActiveRecordDetected = Class.new(StandardError)
+
+  included do
+    raise(NoActiveRecordDetected, "Error: ActiveRecord not detected in #{self}") unless self.ancestors.include?(ActiveRecord::Base)
+
+    class_attribute(:attached_files, :__saviour_validations)
+
+    after_destroy { ModelHooks.new(self).delete! }
+    after_save { ModelHooks.new(self).save! }
+    validate { ModelHooks.new(self).validate! }
+  end
+
+  def reload
+    self.class.attached_files.each do |attach_as, versions|
+      (versions + [nil]).each { |version| instance_variable_set("@__uploader_#{version}_#{attach_as}", nil) }
+    end
+    super
+  end
+
+  module ClassMethods
+    def attach_file(attach_as, uploader_klass)
+      self.attached_files ||= {}
+      versions = uploader_klass.versions || []
+
+      ([nil] + versions).each do |version|
+        column_name = ColumnNamer.new(attach_as, version).name
+
+        if self.table_exists? && !self.column_names.include?(column_name.to_s)
+          raise RuntimeError, "#{self} must have a database string column named '#{column_name}'"
+        end
+      end
+
+      define_method(attach_as) do |version = nil|
+        instance_variable_get("@__uploader_#{version}_#{attach_as}") ||
+            instance_variable_set("@__uploader_#{version}_#{attach_as}", ::Saviour::File.new(uploader_klass, self, attach_as, version))
+      end
+
+      define_method("#{attach_as}=") do |value|
+        send(attach_as).assign(value)
+      end
+
+      define_method("#{attach_as}_changed?") do
+        send(attach_as).changed?
+      end
+
+      self.attached_files[attach_as] ||= []
+      self.attached_files[attach_as] += versions
+    end
+
+    def attach_validation(attach_as, method_name = nil, &block)
+      self.__saviour_validations ||= Hash.new { [] }
+      self.__saviour_validations[attach_as] += [method_name || block]
+    end
+  end
+end

data/lib/saviour/base_uploader.rb

@@ -0,0 +1,81 @@
+require_relative 'uploader/element'
+require_relative 'uploader/store_dir_extractor'
+require_relative 'uploader/processors_runner'
+
+module Saviour
+  class BaseUploader
+    attr_reader :version_name
+
+    def initialize(opts = {})
+      @version_name = opts[:version]
+      @data = opts.fetch(:data, {})
+    end
+
+    def method_missing(name, *args, &block)
+      if @data.key?(name)
+        @data[name]
+      else
+        super
+      end
+    end
+
+    def respond_to?(name, *)
+      @data.key?(name) || super
+    end
+
+    def write(contents, filename)
+      store_dir = Uploader::StoreDirExtractor.new(self).store_dir
+      raise RuntimeError, "Please use `store_dir` before trying to write" unless store_dir
+
+      contents, filename = Uploader::ProcessorsRunner.new(self, @version_name).run!(contents, filename) if Config.processing_enabled
+
+      path = ::File.join(store_dir, filename)
+      Config.storage.write(contents, path)
+      path
+    end
+
+    class << self
+      def store_dirs
+        @store_dirs ||= []
+      end
+
+      def processors
+        @processors ||= []
+      end
+
+      def versions
+        @versions ||= []
+      end
+
+      def process(name = nil, opts = {}, type = :memory, &block)
+        element = Uploader::Element.new(@current_version, name || block)
+
+        if block_given?
+          processors.push({element: element, type: type})
+        else
+          processors.push({element: element, type: type, opts: opts})
+        end
+      end
+
+      def process_with_file(name = nil, opts = {}, &block)
+        process(name, opts, :file, &block)
+      end
+
+
+      def store_dir(name = nil, &block)
+        element = Uploader::Element.new(@current_version, name || block)
+        store_dirs.push(element)
+      end
+
+      def version(name, &block)
+        versions.push(name)
+
+        if block
+          @current_version = name
+          instance_eval(&block)
+          @current_version = nil
+        end
+      end
+    end
+  end
+end

data/lib/saviour/config.rb

@@ -0,0 +1,13 @@
+module Saviour
+  module Config
+    extend self
+
+    attr_writer :storage
+    def storage
+      @storage || raise(RuntimeError, "You need to provide a storage! Set Saviour::Config.storage = xxx")
+    end
+
+    attr_accessor :processing_enabled
+    @processing_enabled = true
+  end
+end

data/lib/saviour/file.rb

@@ -0,0 +1,124 @@
+require 'securerandom'
+
+module Saviour
+  class File
+    class SourceFilenameExtractor
+      def initialize(source)
+        @source = source
+      end
+
+      def detected_filename
+        original_filename || path_filename
+      end
+
+      def original_filename
+        @source.respond_to?(:original_filename) && @source.original_filename.present? && @source.original_filename
+      end
+
+      def path_filename
+        @source.respond_to?(:path) && @source.path.present? && ::File.basename(@source.path)
+      end
+    end
+
+
+    def initialize(uploader_klass, model, attached_as, version = nil)
+      @uploader_klass, @model, @attached_as = uploader_klass, model, attached_as
+      @version = version
+
+      @persisted = !!persisted_path
+      @source_was = @source = nil
+    end
+
+    def exists?
+      persisted? && Config.storage.exists?(persisted_path)
+    end
+
+    def read
+      persisted? && exists? && Config.storage.read(persisted_path)
+    end
+
+    def delete
+      persisted? && exists? && Config.storage.delete(persisted_path)
+    end
+
+    def public_url
+      persisted? && Config.storage.public_url(persisted_path)
+    end
+
+    alias_method :url, :public_url
+
+    def assign(object)
+      raise(RuntimeError, "must respond to `read`") if object && !object.respond_to?(:read)
+
+      @source_data = nil
+      @source = object
+      @persisted = !object
+
+      object
+    end
+
+    def persisted?
+      @persisted
+    end
+
+    def changed?
+      @source_was != @source
+    end
+
+    def filename
+      persisted? && ::File.basename(persisted_path)
+    end
+
+    def with_copy
+      raise "must be persisted" unless persisted?
+
+      Tempfile.open([::File.basename(filename, ".*"), ::File.extname(filename)]) do |file|
+        begin
+          file.binmode
+          file.write(read)
+          file.flush
+          file.rewind
+
+          yield(file)
+        ensure
+          file.close
+          file.delete
+        end
+      end
+    end
+
+    def filename_to_be_assigned
+      changed? ? (SourceFilenameExtractor.new(@source).detected_filename || SecureRandom.hex) : nil
+    end
+
+    def write
+      raise(RuntimeError, "You must provide a source to read from first") unless @source
+
+      path = uploader.write(source_data, filename_to_be_assigned)
+      @source_was = @source
+      @persisted = true
+      path
+    end
+
+    def source_data
+      @source_data ||= @source.read
+    end
+
+    def blank?
+      !@source && !persisted?
+    end
+
+
+    private
+
+    def uploader
+      @uploader ||= @uploader_klass.new(version: @version, data: {model: @model, attached_as: @attached_as})
+    end
+
+    def persisted_path
+      if @model.persisted? || @model.destroyed?
+        @model.read_attribute(ColumnNamer.new(@attached_as, @version).name)
+      end
+    end
+  end
+end

data/lib/saviour/local_storage.rb

@@ -0,0 +1,72 @@
+require 'fileutils'
+
+module Saviour
+  class LocalStorage
+    def initialize(opts = {})
+      @local_prefix = opts[:local_prefix]
+      @public_url_prefix = opts[:public_url_prefix]
+      @overwrite_protection = opts.fetch(:overwrite_protection, true)
+    end
+
+    def write(contents, path)
+      raise(RuntimeError, "The path you're trying to write already exists!") if @overwrite_protection && exists?(path)
+
+      dir = ::File.dirname(real_path(path))
+      FileUtils.mkdir_p(dir) unless ::File.directory?(dir)
+
+      ::File.open(real_path(path), "w") do |f|
+        f.binmode
+        f.write(contents)
+      end
+    end
+
+    def read(path)
+      assert_exists(path)
+      ::File.open(real_path(path)).read
+    end
+
+    def delete(path)
+      assert_exists(path)
+      ::File.delete(real_path(path))
+      ensure_removed_empty_dir(path)
+    end
+
+    def exists?(path)
+      ::File.file?(real_path(path))
+    end
+
+    def public_url(path)
+      raise(RuntimeError, "You must provide a `public_url_prefix`") unless public_url_prefix
+      ::File.join(public_url_prefix, path)
+    end
+
+
+    private
+
+    def public_url_prefix
+      if @public_url_prefix.respond_to?(:call)
+        @public_url_prefix.call
+      else
+        @public_url_prefix
+      end
+    end
+
+    def real_path(path)
+      @local_prefix ? ::File.join(@local_prefix, path) : path
+    end
+
+    def assert_exists(path)
+      raise(RuntimeError, "File does not exists: #{path}") unless ::File.file?(real_path(path))
+    end
+
+    def ensure_removed_empty_dir(path)
+      basedir = ::File.dirname(path)
+      return if basedir == "."
+
+      while basedir != "/" && Dir.entries(real_path(basedir)) == [".", ".."]
+        Dir.rmdir(real_path(basedir))
+        basedir = ::File.dirname(basedir)
+      end
+    end
+  end
+end