attachs 0.4.5 → 4.0.0.0

data/lib/attachs/attachment.rb

@@ -1,118 +1,347 @@
 module Attachs
   class Attachment
+    include ActiveModel::Validations
 
-    attr_reader :record, :attribute, :filename, :content_type, :size, :updated_at, :upload, :options
+    attr_reader :record, :record_attribute, :options, :attributes, :value
 
-    delegate :basename, :extension, :image?, :url, :process, :destroy, :update, to: :type
-
-    def initialize(record, attribute, options, source=false)
+    def initialize(record, record_attribute, options={}, attributes={})
       @record = record
-      @attribute = attribute
+      @record_attribute = record_attribute
       @options = options
-      case source
-      when nil
-        %w(filename content_type size updated_at).each do |name|
-          record.send "#{attribute}_#{name}=", nil
+      @original_attributes = @attributes = normalize_attributes(attributes)
+    end
+
+    %i(id size filename content_type uploaded_at).each do |name|
+      define_method name do
+        attributes[name]
+      end
+    end
+
+    def basename
+      if filename
+        File.basename filename, extension
+      end
+    end
+
+    def extension
+      if filename
+        File.extname filename
+      end
+    end
+
+    def present?
+      filename.present? && content_type.present? && size.present?
+    end
+
+    def blank?
+      !present?
+    end
+
+    def persisted?
+      record.persisted? && paths.any? && uploaded_at
+    end
+
+    def changed?
+      @original_attributes != @attributes
+    end
+
+    def type
+      if content_type
+        if content_type.starts_with?('image/')
+          'image'
+        else
+          'file'
+        end
+      end
+    end
+
+    def url(style=:original)
+      paths = attributes[:paths]
+      if paths.has_key?(style)
+        storage.url paths[style]
+      elsif options.has_key?(:default_path)
+        template = options[:default_path]
+        path = generate_path(template, style)
+        storage.url path
+      end
+    end
+
+    def position
+      if options[:multiple]
+        attributes[:position]
+      end
+    end
+
+    def position=(value)
+      if options[:multiple]
+        attributes[:position] = value
+        write_record
+      end
+    end
+
+    def assign(value)
+      source, new_attributes = process_value(value)
+      if new_attributes
+        unless changed?
+          @original_attributes = attributes
         end
-      when false
-        %w(filename content_type size updated_at).each do |name|
-          instance_variable_set :"@#{name}", record.send("#{attribute}_#{name}")
+        @attributes = new_attributes
+        write_record
+        @source = source
+        @value = value
+      end
+    end
+    alias_method :value=, :assign
+
+    def _destroy=(value)
+      if ActiveRecord::Type::Boolean.new.type_cast_from_user(value)
+        assign nil
+      end
+    end
+
+    def save
+      if changed?
+        if original_attributes[:paths].any? || original_attributes[:old_paths].any?
+          Jobs::DeleteJob.perform_later(
+            original_attributes[:paths].values +
+            original_attributes[:old_paths]
+          )
+        end
+        case source.class.name
+        when 'Attachs::Attachment'
+          file = storage.get(source.paths[:original])
+          storage.process file, paths, styles
+        when 'Upload'
+          source.file.paths.each do |style, path|
+            storage.copy path, paths[style]
+          end
+        when 'ActionDispatch::Http::UploadedFile'
+          storage.process source, paths, styles
         end
+        @source = @value = nil
+        @original_attributes = @attributes
+      elsif present?
+        if paths != generate_paths
+          Jobs::UpdateJob.perform_later record, record_attribute.to_s
+        end
+      end
+    end
+
+    def update_paths
+      if changed?
+        raise 'Save attachment before update paths'
       else
-        load source
-        %w(filename content_type size updated_at).each do |name|
-          record.send "#{attribute}_#{name}=", send(name)
+        new_paths = generate_paths
+        if paths != new_paths
+          new_paths.each do |style, new_path|
+            original_path = paths[style]
+            if original_path != new_path
+              unless storage.exist?(new_path)
+                storage.copy original_path, new_path
+              end
+              attributes[:paths][style] = new_path
+              attributes[:old_paths] |= [original_path]
+            end
+          end
+          update_record
         end
       end
     end
 
-    def uploaded!
-      @upload = nil
+    def reprocess
+      if changed?
+        raise 'Save attachment before reprocess'
+      elsif present? && styles
+        file = storage.get(paths[:original])
+        paths.each do |style, path|
+          if storage.exist?(path)
+            storage.delete path
+          end
+          Rails.logger.info "Regenerating: #{style} => #{path}"
+        end
+        new_paths = generate_paths
+        storage.process file, new_paths, styles
+        attributes[:paths] = new_paths
+        update_record
+      end
     end
 
-    def styles
-      @styles ||= ((options[:styles] || []) | Attachs.config.global_styles)
+    def fix_missings
+      if changed?
+        raise 'Save attachment before fix missings'
+      elsif present? && styles
+        missings = paths.slice(:original)
+        paths.except(:original).each do |style, path|
+          unless storage.exist?(path)
+            missings[style] = path
+            Rails.logger.info "Generating: #{style} => #{path}"
+          end
+        end
+        if missings.size > 1
+          file = storage.get(paths[:original])
+          storage.process file, missings, styles
+        end
+      end
     end
 
-    def private?
-      @private ||= options[:private] == true
+    def destroy
+      assign nil
+      save
     end
 
-    def processors
-      @processors ||= (options[:processors] || Attachs.config.default_processors).map do |processor|
-        "Attachs::Processors::#{processor.to_s.classify}".constantize
+    def method_missing(name, *args, &block)
+      if attributes.has_key?(name)
+        attributes[name]
+      else
+        super
       end
     end
 
-    def public?
-      !private?
+    def respond_to_missing?(name, include_private=false)
+      attributes.has_key?(name) || super
     end
 
-    def upload?
-      !upload.nil?
+    def persist
+      if changed? && present?
+        new_paths = generate_paths
+        if paths != new_paths
+          attributes[:paths] = new_paths
+          attributes[:uploaded_at] = Time.now
+          write_record
+        end
+      end
     end
 
-    def processed?
-      exists? and record.persisted? and !(
-        record.send("#{attribute}_filename_changed?") or
-        record.send("#{attribute}_content_type_changed?") or
-        record.send("#{attribute}_size_changed?") or
-        record.send("#{attribute}_updated_at_changed?")
-      )
+    def unpersist
+      if changed? && present?
+        attributes[:paths] = original_attributes[:paths]
+        attributes[:uploaded_at] = original_attributes[:paths]
+        write_record
+      end
     end
 
-    def exists?
-      filename and content_type and size and updated_at
+    def styles
+      case value = options[:styles]
+      when Proc
+        value.call(record) || {}
+      when Hash
+        value
+      else
+        {}
+      end
     end
 
-    def blank?
-      !exists?
+    private
+
+    attr_reader :original_attributes, :source
+
+    def storage
+      Attachs.storage
     end
 
-    def default?
-      !options[:default_path].nil?
+    def normalize_attributes(attributes)
+      attributes.reverse_merge(paths: {}, old_paths: []).deep_symbolize_keys
     end
 
-    def url?
-      public? and (default? or processed?)
+    def write_record(value=nil)
+      unless record.destroyed?
+        record.send "#{record_attribute}_will_change!"
+        record.send :write_attribute, record_attribute, (value || raw_attributes)
+      end
     end
 
-    protected
+    def raw_attributes
+      if options[:multiple]
+        record.send(:read_attribute, record_attribute).reject{ |h| h['id'] == id }.append attributes
+      else
+        attributes
+      end
+    end
 
-    def load(source)
-      if source.is_a? URI
-        download = Tempfile.new('external')
-        File.open(download.path, 'wb') do |file|
-          Net::HTTP.start(source.host) do |http|
-            file.write http.get(source.path).body
-          end
+    def update_record(value=nil)
+      unless record.destroyed?
+        record.update_column record_attribute, (value || raw_attributes)
+      end
+    end
+
+    def generate_path(template, style)
+      if path = template.try(:dup)
+        path.gsub! ':style', style.to_s.gsub('_', '-')
+        path.scan(/:[a-z_]+/).each do |token|
+          name = token.from(1).to_sym
+          path.gsub! token, interpolate(name).to_s.parameterize
         end
-        type = `file --mime-type -b '#{download.path}'`.strip
-        source = ActionDispatch::Http::UploadedFile.new(
-          tempfile: download,
-          filename: File.basename(source.path),
-          type: type
-        )
-      end
-      if source.is_a? Attachs::Attachment
-        @filename = source.filename
-        @updated_at = source.updated_at
+        path.squeeze! '-'
+        path.squeeze! '/'
+        path.gsub! '-.', '.'
+        path.gsub! '/-', '/'
+        path.gsub! '-/', '/'
+        path.sub! /^\//, ''
+        path
+      end
+    end
+
+    def generate_paths
+      template = options[:path]
+      paths = { original: generate_path(template, :original) }
+      styles.each do |style, geometry|
+        paths[style] = generate_path(template, style)
+      end
+      paths
+    end
+
+    def interpolate(name)
+      if %i(basename extension).include?(name)
+        send name
+      elsif name == :attribute
+        record_attribute
+      elsif attributes.except(:upload_at, :paths, :old_paths).has_key?(name)
+        attributes[name]
       else
-        @upload = source
-        @filename = source.original_filename.downcase
-        @updated_at = Time.zone.now
+        Attachs.interpolations.find(name).call record
       end
-      @content_type = source.content_type
-      @size = source.size
     end
 
-    def type
-      @type ||= begin
-        if exists?
-          Attachs::Types::Regular.new(self)
-        else
-          Attachs::Types::Default.new(self)
+    def generate_id
+      SecureRandom.uuid.gsub '-', ''
+    end
+
+    def process_value(value)
+      case value.class.name
+      when 'NilClass'
+        [nil, {}]
+      when 'Attachs::Attachment'
+        attributes = value.attributes.merge(id: generate_id)
+        [value, attributes]
+      when 'Upload'
+        attributes = value.file.attributes.merge(id: generate_id)
+        [value.file, attributes]
+      when 'String','Fixnum','Bignum'
+        if Rails.configuration.cache_classes == false
+          Rails.application.eager_load!
+        end
+        if defined?(Upload)
+          upload = Upload.find(value)
+          attributes = upload.file.attributes.merge(id: generate_id)
+          [upload, attributes]
+        end
+      when 'ActionDispatch::Http::UploadedFile'
+        attributes = {
+          id: generate_id,
+          filename: value.original_filename,
+          content_type: value.content_type,
+          size: value.size.to_i,
+          uploaded_at: Time.now,
+          paths: {},
+          old_paths: []
+        }
+        if value.content_type.starts_with?('image/')
+          width, height = Console.find_dimensions(value.path)
+          attributes[:width] = width
+          attributes[:height] = height
+          attributes[:ratio] = (height.to_d / width.to_d).to_f
         end
+        [value, attributes]
       end
     end
 

data/lib/attachs/builder.rb

@@ -0,0 +1,78 @@
+module Attachs
+  class Builder
+
+    attr_reader :model, :concern
+
+    def initialize(model)
+      @model = model
+      @concern = Module.new
+    end
+
+    def define(attribute, options={})
+      unless options.has_key?(:path)
+        raise 'Path required'
+      end
+      model.include Attachs::Concern
+      model.attachments[attribute] = options
+      define_writer attribute
+      define_reader attribute, options
+      define_attributes_writer attribute, options
+      model.include concern
+    end
+
+    private
+
+    def define_writer(attribute)
+      concern.class_eval do
+        define_method "#{attribute}=" do |value|
+          send(attribute).assign value
+        end
+      end
+    end
+
+    def define_reader(attribute, options)
+      concern.class_eval do
+        define_method attribute do
+          variable = "@#{attribute}"
+          if instance = instance_variable_get(variable)
+            instance
+          else
+            if options[:multiple] == true
+              klass = Attachs::Collection
+            else
+              klass = Attachs::Attachment
+            end
+            instance_variable_set(
+              variable,
+              klass.new(self, attribute, options, super())
+            )
+          end
+        end
+      end
+    end
+
+    def define_attributes_writer(attribute, options)
+      concern.class_eval do
+        define_method "#{attribute}_attributes=" do |collection_or_attributes|
+          if options[:multiple] == true
+            collection_or_attributes.each do |attributes|
+              if id = attributes.delete(:id)
+                attachment = send(attribute).find(id)
+              else
+                attachment = send(attribute).new
+              end
+              attributes.each do |name, value|
+                attachment.send "#{name}=", value
+              end
+            end
+          else
+            collection_or_attributes.each do |name, value|
+              send(attribute).send "#{name}=", value
+            end
+          end
+        end
+      end
+    end
+
+  end
+end