oahu-dragonfly 0.8.2

data/lib/dragonfly/active_model_extensions.rb

@@ -0,0 +1,13 @@
+module Dragonfly
+
+  module ActiveModelExtensions
+
+    def self.extended(klass)
+      unless klass.include?(InstanceMethods)
+        klass.extend(ClassMethods)
+        klass.class_eval{ include InstanceMethods }
+      end
+    end
+
+  end
+end

data/lib/dragonfly/active_model_extensions/attachment.rb

@@ -0,0 +1,250 @@
+require 'forwardable'
+require 'dragonfly/active_model_extensions/attachment_class_methods'
+
+module Dragonfly
+  module ActiveModelExtensions
+
+    class Attachment
+
+      # Exceptions
+      class BadAssignmentKey < RuntimeError; end
+
+      extend Forwardable
+      def_delegators :job,
+        :data, :to_file, :file, :tempfile, :path,
+        :process, :encode, :analyse,
+        :meta, :meta=,
+        :name, :basename, :ext, :size,
+        :url
+
+      def initialize(model)
+        @model = model
+        self.uid = model_uid
+        update_from_uid if uid
+        @should_run_callbacks = true
+        self.class.ensure_uses_cached_magic_attributes
+      end
+
+      def app
+        self.class.app
+      end
+      
+      def attribute
+        self.class.attribute
+      end
+
+      def assign(value)
+        self.changed = true
+        destroy_retained! if retained?
+        set_uid_and_model_uid(nil)
+        if value.nil?
+          self.job = nil
+          reset_magic_attributes
+          self.class.run_callbacks(:after_unassign, model, self) if should_run_callbacks?
+        else
+          self.job = case value
+          when Job then value.dup
+          when self.class then value.job.dup
+          else app.new_job(value)
+          end
+          set_magic_attributes
+          update_meta
+          self.class.run_callbacks(:after_assign, model, self) if should_run_callbacks?
+        end
+        value
+      end
+
+      def changed?
+        !!@changed
+      end
+
+      def destroy!
+        destroy_previous!
+        destroy_content(uid) if uid
+      end
+
+      def save!
+        sync_with_model
+        store_job! if job && !uid
+        destroy_previous!
+        self.changed = false
+        self.retained = false
+      end
+
+      def to_value
+        self if job
+      end
+
+      def name=(name)
+        job.name = name
+        set_magic_attribute(:name, name) if has_magic_attribute_for?(:name)
+        name
+      end
+
+      def process!(*args)
+        assign(process(*args))
+        self
+      end
+
+      def encode!(*args)
+        assign(encode(*args))
+        self
+      end
+      
+      def remote_url(opts={})
+        app.remote_url_for(uid, opts) if uid
+      end
+      
+      def apply
+        job.apply
+        self
+      end
+
+      attr_writer :should_run_callbacks
+      
+      def should_run_callbacks?
+        @should_run_callbacks
+      end
+
+      # Retaining for avoiding uploading more than once
+
+      def retain!
+        if changed?
+          store_job!
+          self.retained = true
+        end
+      end
+
+      def retained?
+        !!@retained
+      end
+      
+      def destroy_retained!
+        destroy_content(retained_attrs[:uid])
+      end
+      
+      def retained_attrs
+        attribute_keys.inject({}) do |hash, key|
+          hash[key] = send(key)
+          hash
+        end if retained?
+      end
+      
+      def retained_attrs=(attrs)
+        if changed? # if already set, ignore and destroy this retained content
+          destroy_content(attrs[:uid])
+        else
+          attrs.each do |key, value|
+            unless attribute_keys.include?(key)
+              raise BadAssignmentKey, "trying to call #{attribute}_#{key} = #{value.inspect} via retained_#{attribute} but this is not allowed!"
+            end
+            model.send("#{attribute}_#{key}=", value)
+          end
+          sync_with_model
+          update_from_uid
+          self.retained = true
+        end
+      end
+      
+      def inspect
+        "<Dragonfly Attachment uid=#{uid.inspect}, app=#{app.inspect}>"
+      end
+
+      protected
+
+      attr_reader :job
+
+      private
+
+      attr_writer :changed, :retained
+
+      def attribute_keys
+        [:uid] + magic_attributes
+      end
+
+      def store_job!
+        opts = self.class.evaluate_storage_opts(model, self)
+        set_uid_and_model_uid job.store(opts)
+        self.job = job.to_fetched_job(uid)
+      end
+
+      def destroy_content(uid)
+        app.datastore.destroy(uid)
+      rescue DataStorage::DataNotFound => e
+        app.log.warn("*** WARNING ***: tried to destroy data with uid #{uid}, but got error: #{e}")
+      end
+
+      def destroy_previous!
+        if previous_uid
+          destroy_content(previous_uid)
+          self.previous_uid = nil
+        end
+      end
+
+      def sync_with_model
+        # If the model uid has been set manually
+        if uid != model_uid
+          self.uid = model_uid
+        end
+      end
+
+      def set_uid_and_model_uid(uid)
+        self.uid = uid
+        self.model_uid = uid
+      end
+
+      def model_uid=(uid)
+        model.send("#{attribute}_uid=", uid)
+      end
+
+      def model_uid
+        model.send("#{attribute}_uid")
+      end
+
+      attr_reader :model, :uid
+      attr_writer :job
+      attr_accessor :previous_uid
+
+      def uid=(uid)
+        self.previous_uid = @uid if @uid
+        @uid = uid
+      end
+
+      def update_meta
+        magic_attributes.each{|property| meta[property] = model.send("#{attribute}_#{property}") }
+        meta[:model_class] = model.class.name
+        meta[:model_attachment] = attribute
+      end
+
+      def update_from_uid
+        self.job = app.fetch(uid)
+        update_meta
+      end
+
+      def magic_attributes
+        self.class.magic_attributes
+      end
+
+      def set_magic_attribute(property, value)
+        model.send("#{attribute}_#{property}=", value)
+      end
+
+      def set_magic_attributes
+        magic_attributes.each{|property| set_magic_attribute(property, job.send(property)) }
+      end
+
+      def reset_magic_attributes
+        magic_attributes.each{|property| set_magic_attribute(property, nil) }
+      end
+
+      def has_magic_attribute_for?(property)
+        magic_attributes.include?(property.to_sym)
+      end
+
+      def magic_attribute_for(property)
+        model.send("#{attribute}_#{property}")
+      end
+
+    end
+  end
+end

data/lib/dragonfly/active_model_extensions/attachment_class_methods.rb

@@ -0,0 +1,148 @@
+module Dragonfly
+  module ActiveModelExtensions
+    class Attachment
+      class << self
+    
+        class ConfigProxy
+      
+          def initialize(spec, block)
+            @spec = spec
+            instance_eval(&block)
+          end
+      
+          private
+      
+          attr_reader :spec
+      
+          def after_assign(*callbacks, &block)
+            add_callbacks(:after_assign, *callbacks, &block)
+          end
+      
+          def after_unassign(*callbacks, &block)
+            add_callbacks(:after_unassign, *callbacks, &block)
+          end
+      
+          def copy_to(accessor, &block)
+            after_assign do |a|
+              self.send "#{accessor}=", (block_given? ? instance_exec(a, &block) : a)
+            end
+            after_unassign{|a| self.send("#{accessor}=", nil) }
+          end
+      
+          def retain
+            after_assign{|a| a.retain! }
+          end
+      
+          def storage_opts(opts=nil, &block)
+            spec.storage_opts_specs << (opts || block)
+          end
+
+          def storage_opt(key, value, &block)
+            if value.is_a? Symbol
+              storage_opts{|a| {key => send(value)} }
+            elsif block_given?
+              storage_opts{|a| {key => instance_exec(a, &block)} }
+            else
+              storage_opts{|a| {key => value} }
+            end
+          end
+      
+          def add_callbacks(name, *callbacks, &block)
+            if block_given?
+              spec.callbacks[name] << block
+            else
+              spec.callbacks[name].push(*callbacks)
+            end
+          end
+      
+          def method_missing(meth, *args, &block)
+            if meth.to_s =~ /^storage_(.*)$/
+              storage_opt($1.to_sym, args.first, &block)
+            else
+              super
+            end
+          end
+      
+        end
+    
+        def init(model_class, attribute, app, config_block)
+          @model_class, @attribute, @app, @config_block = model_class, attribute, app, config_block
+          include app.analyser.analysis_methods
+          include app.job_definitions
+          define_method :format do
+            job.format
+          end
+          define_method :mime_type do
+            job.mime_type
+          end
+          ConfigProxy.new(self, config_block) if config_block
+          self
+        end
+
+        attr_reader :model_class, :attribute, :app, :config_block
+
+        # Callbacks
+        def callbacks
+          @callbacks ||= Hash.new{|h,k| h[k] = [] }
+        end
+    
+        def run_callbacks(name, model, attachment)
+          attachment.should_run_callbacks = false
+          callbacks[name].each do |callback|
+            case callback
+            when Symbol then model.send(callback)
+            when Proc then model.instance_exec(attachment, &callback)
+            end
+          end
+          attachment.should_run_callbacks = true
+        end
+
+        # Magic attributes
+        def allowed_magic_attributes
+          app.analyser.analysis_method_names + [:size, :basename, :name, :ext, :meta]
+        end
+
+        def magic_attributes
+          @magic_attributes ||= begin
+            prefix = attribute.to_s + '_'
+            model_class.public_instance_methods.inject([]) do |attrs, name|
+              _, __, suffix  = name.to_s.partition(prefix)
+              if !suffix.empty? && allowed_magic_attributes.include?(suffix.to_sym)
+                attrs << suffix.to_sym
+              end
+              attrs
+            end
+          end
+        end
+
+        def ensure_uses_cached_magic_attributes
+          return if @uses_cached_magic_attributes
+          magic_attributes.each do |attr|
+            define_method attr do
+              magic_attribute_for(attr)
+            end
+          end
+          @uses_cached_magic_attributes = true
+        end
+
+        # Storage options
+        def storage_opts_specs
+          @storage_opts_specs ||= []
+        end
+    
+        def evaluate_storage_opts(model, attachment)
+          storage_opts_specs.inject({}) do |opts, spec|
+            options = case spec
+            when Proc then model.instance_exec(attachment, &spec)
+            when Symbol then model.send(spec)
+            else spec
+            end
+            opts.merge!(options)
+            opts
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/dragonfly/active_model_extensions/class_methods.rb

@@ -0,0 +1,95 @@
+module Dragonfly
+  module ActiveModelExtensions
+    module ClassMethods
+
+      include Validations
+
+      def register_dragonfly_app(macro_name, app)
+        (class << self; self; end).class_eval do
+    
+          # Defines e.g. 'image_accessor' for any activemodel class body
+          define_method macro_name do |attribute, &config_block|
+
+            # Add callbacks
+            before_save :save_dragonfly_attachments
+            before_destroy :destroy_dragonfly_attachments
+      
+            # Register the new attribute
+            dragonfly_attachment_classes << new_dragonfly_attachment_class(attribute, app, config_block)
+            
+            # Define the setter for the attribute
+            define_method "#{attribute}=" do |value|
+              dragonfly_attachments[attribute].assign(value)
+            end
+      
+            # Define the getter for the attribute
+            define_method attribute do
+              dragonfly_attachments[attribute].to_value
+            end
+      
+            # Define the URL setter
+            define_method "#{attribute}_url=" do |url|
+              unless url.blank?
+                dragonfly_attachments[attribute].assign(app.fetch_url(url))
+              end
+            end
+      
+            # Define the URL getter
+            define_method "#{attribute}_url" do
+              nil
+            end
+
+            # Define the remove setter
+            define_method "remove_#{attribute}=" do |value|
+              unless [0, "0", false, "false", "", nil].include?(value)
+                dragonfly_attachments[attribute].assign(nil)
+                instance_variable_set("@remove_#{attribute}", true)
+              end
+            end
+
+            # Define the remove getter
+            attr_reader "remove_#{attribute}"
+
+            # Define the retained setter
+            define_method "retained_#{attribute}=" do |string|
+              unless string.blank?
+                begin
+                  dragonfly_attachments[attribute].retained_attrs = Serializer.marshal_decode(string)
+                rescue Serializer::BadString => e
+                  app.log.warn("*** WARNING ***: couldn't update attachment with serialized retained_#{attribute} string #{string.inspect}")              
+                end
+              end
+            end
+            
+            # Define the retained getter
+            define_method "retained_#{attribute}" do
+              attrs = dragonfly_attachments[attribute].retained_attrs
+              Serializer.marshal_encode(attrs) if attrs
+            end
+            
+          end
+    
+        end
+        app
+      end
+      
+      def dragonfly_attachment_classes
+        @dragonfly_attachment_classes ||= begin
+          parent_class = ancestors.select{|a| a.is_a?(Class) }[1]
+          if parent_class.respond_to?(:dragonfly_attachment_classes)
+            parent_class.dragonfly_attachment_classes.map do |klass|
+              new_dragonfly_attachment_class(klass.attribute, klass.app, klass.config_block)
+            end
+          else
+            []
+          end
+        end
+      end
+      
+      def new_dragonfly_attachment_class(attribute, app, config_block)
+        Class.new(Attachment).init(self, attribute, app, config_block)
+      end
+      
+    end
+  end
+end