dragonfly 0.9.15 → 1.0

data/lib/dragonfly/job_endpoint.rb

@@ -1,3 +1,5 @@
+require 'dragonfly/response'
+
 module Dragonfly
   class JobEndpoint
 

data/lib/dragonfly/memory_data_store.rb

@@ -0,0 +1,34 @@
+module Dragonfly
+  class MemoryDataStore
+
+    def initialize
+      @content_store = {}
+    end
+
+    def write(content, opts={})
+      uid = opts[:uid] || generate_uid
+      content_store[uid] = {:content => content.data, :meta => content.meta.dup}
+      uid
+    end
+
+    def read(uid)
+      data = content_store[uid]
+      [data[:content], data[:meta]] if data
+    end
+
+    def destroy(uid)
+      content_store.delete(uid)
+    end
+
+    private
+
+    attr_reader :content_store
+
+    def generate_uid
+      @uid_count ||= 0
+      @uid_count += 1
+      @uid_count.to_s
+    end
+
+  end
+end

data/lib/dragonfly/middleware.rb

@@ -1,14 +1,15 @@
+require 'dragonfly'
+
 module Dragonfly
   class Middleware
 
-    def initialize(app, dragonfly_app_name, deprecated_arg=nil)
-      raise ArgumentError, "mounting Dragonfly::Middleware with a mount point is deprecated - just use Dragonfly::Middleware, #{dragonfly_app_name.inspect}" if deprecated_arg
+    def initialize(app, dragonfly_app_name=nil)
       @app = app
       @dragonfly_app_name = dragonfly_app_name
     end
 
     def call(env)
-      response = Dragonfly[@dragonfly_app_name].call(env)
+      response = Dragonfly.app(@dragonfly_app_name).call(env)
       if response[1]['X-Cascade'] == 'pass'
         @app.call(env)
       else
@@ -18,3 +19,4 @@ module Dragonfly
 
   end
 end
+

data/lib/dragonfly/{active_model_extensions.rb → model.rb}

@@ -1,6 +1,8 @@
-module Dragonfly
+require 'dragonfly/model/instance_methods'
+require 'dragonfly/model/class_methods'
 
-  module ActiveModelExtensions
+module Dragonfly
+  module Model
 
     def self.extended(klass)
       unless klass.include?(InstanceMethods)
@@ -10,4 +12,4 @@ module Dragonfly
     end
 
   end
-end
+end

data/lib/dragonfly/{active_model_extensions → model}/attachment.rb

@@ -1,9 +1,10 @@
 require 'forwardable'
-require 'dragonfly/active_model_extensions/attachment_class_methods'
+require 'dragonfly/has_filename'
+require 'dragonfly/job'
+require 'dragonfly/model/attachment_class_methods'
 
 module Dragonfly
-  module ActiveModelExtensions
-
+  module Model
     class Attachment
 
       # Exceptions
@@ -11,8 +12,9 @@ module Dragonfly
 
       extend Forwardable
       def_delegators :job,
-        :data, :b64_data, :to_file, :file, :tempfile, :path,
-        :process, :encode, :analyse,
+        :to_file, :file, :tempfile, :path,
+        :data, :b64_data, :mime_type,
+        :process, :analyse, :shell_eval,
         :meta, :meta=,
         :name, :size,
         :url
@@ -46,13 +48,10 @@ module Dragonfly
           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
+          self.job = app.new_job(value)
           set_magic_attributes
-          job.url_attrs = all_extra_attributes
+          job.update_url_attributes(magic_attributes_hash)
+          meta.merge!(standard_meta_attributes)
           self.class.run_callbacks(:after_assign, model, self) if should_run_callbacks?
           retain! if should_retain?
         end
@@ -64,6 +63,10 @@ module Dragonfly
         !!@changed
       end
 
+      def stored?
+        uid?
+      end
+
       def destroy!
         destroy_previous!
         destroy_content(uid) if uid?
@@ -78,7 +81,7 @@ module Dragonfly
       end
 
       def to_value
-        self if job
+        (self if job) || self.class.default_job
       end
 
       def name=(name)
@@ -91,11 +94,6 @@ module Dragonfly
         self
       end
 
-      def encode!(*args)
-        assign(encode(*args))
-        self
-      end
-
       def remote_url(opts={})
         app.remote_url_for(uid, opts) if uid?
       end
@@ -131,7 +129,7 @@ module Dragonfly
       end
 
       def destroy_retained!
-        destroy_content(retained_attrs[:uid])
+        destroy_content(retained_attrs['uid'])
       end
 
       def retained_attrs
@@ -143,7 +141,7 @@ module Dragonfly
 
       def retained_attrs=(attrs)
         if changed? # if already set, ignore and destroy this retained content
-          destroy_content(attrs[:uid])
+          destroy_content(attrs['uid'])
         else
           attrs.each do |key, value|
             unless attribute_keys.include?(key)
@@ -157,6 +155,11 @@ module Dragonfly
         end
       end
 
+      def add_meta(meta)
+        job.add_meta(meta)
+        self
+      end
+
       def inspect
         "<Dragonfly Attachment uid=#{uid.inspect}, app=#{app.name.inspect}>"
       end
@@ -170,20 +173,17 @@ module Dragonfly
       attr_writer :changed, :retained
 
       def attribute_keys
-        [:uid] + magic_attributes
+        @attribute_keys ||= ['uid'] + magic_attributes.map{|attribute| attribute.to_s }
       end
 
       def store_job!
-        meta.merge!(all_extra_attributes)
-        opts = self.class.evaluate_storage_opts(model, self)
+        opts = self.class.evaluate_storage_options(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, DataStorage::DestroyError => e
-        app.log.warn("*** WARNING ***: tried to destroy data with uid #{uid}, but got error: #{e}")
       end
 
       def destroy_previous!
@@ -244,7 +244,15 @@ module Dragonfly
       end
 
       def set_magic_attributes
-        magic_attributes.each{|property| set_magic_attribute(property, job.send(property)) }
+        magic_attributes.each do |property|
+          value = begin
+            job.send(property)
+          rescue RuntimeError => e
+            Dragonfly.warn("setting magic attribute for #{property} to nil in #{self.inspect} because got error #{e}")
+            nil
+          end
+          set_magic_attribute(property, value)
+        end
       end
 
       def reset_magic_attributes
@@ -261,27 +269,24 @@ module Dragonfly
 
       def magic_attributes_hash
         magic_attributes.inject({}) do |attrs, property|
-          attrs[property] = model.send("#{attribute}_#{property}")
+          attrs[property.to_s] = model.send("#{attribute}_#{property}")
           attrs
         end
       end
 
-      def extra_attributes
-        @extra_attributes ||= {
-          :model_class => model.class.name,
-          :model_attachment => attribute
+      def standard_meta_attributes
+        @standard_meta_attributes ||= {
+          'model_class' => model.class.name,
+          'model_attachment' => attribute.to_s
         }
       end
 
-      def all_extra_attributes
-        magic_attributes_hash.merge(extra_attributes)
-      end
-
       def set_job_from_uid
         self.job = app.fetch(uid)
-        job.url_attrs = all_extra_attributes
+        job.update_url_attributes(magic_attributes_hash)
       end
 
     end
   end
 end
+

data/lib/dragonfly/{active_model_extensions → model}/attachment_class_methods.rb

@@ -1,48 +1,42 @@
 module Dragonfly
-  module ActiveModelExtensions
+  module Model
     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 storage_opts(opts=nil, &block)
-            spec.storage_opts_specs << (opts || block)
+
+          def default(path)
+            spec.default_path = path.to_s
           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
+          def storage_options(opts=nil, &block)
+            spec.storage_options_specs << (opts || block)
           end
-      
+
           def add_callbacks(name, *callbacks, &block)
             if block_given?
               spec.callbacks[name] << block
@@ -50,38 +44,40 @@ module Dragonfly
               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)
+              raise NoMethodError, "#{meth} is deprecated - use storage_options instead"
             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
+          include app.job_methods
           ConfigProxy.new(self, config_block) if config_block
           self
         end
 
-        attr_reader :model_class, :attribute, :app, :config_block
+        attr_reader :model_class, :attribute, :app, :config_block, :default_path
+
+        def default_path=(path)
+          @default_path = path
+          app.fetch_file_whitelist.push(path)
+        end
+
+        def default_job
+          app.fetch_file(default_path) if default_path
+        end
 
         # 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|
@@ -95,7 +91,7 @@ module Dragonfly
 
         # Magic attributes
         def allowed_magic_attributes
-          app.analyser.analysis_method_names + [:size, :name]
+          app.analyser_methods + [:size, :name]
         end
 
         def magic_attributes
@@ -122,12 +118,12 @@ module Dragonfly
         end
 
         # Storage options
-        def storage_opts_specs
-          @storage_opts_specs ||= []
+        def storage_options_specs
+          @storage_options_specs ||= []
         end
-    
-        def evaluate_storage_opts(model, attachment)
-          storage_opts_specs.inject({}) do |opts, spec|
+
+        def evaluate_storage_options(model, attachment)
+          storage_options_specs.inject({}) do |opts, spec|
             options = case spec
             when Proc then model.instance_exec(attachment, &spec)
             when Symbol then model.send(spec)

data/lib/dragonfly/model/class_methods.rb

@@ -0,0 +1,109 @@
+require 'dragonfly'
+require 'dragonfly/serializer'
+require 'dragonfly/utils'
+require 'dragonfly/model/attachment'
+
+module Dragonfly
+  module Model
+    module ClassMethods
+
+      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
+
+      private
+
+      def dragonfly_accessor(attribute, opts={}, &config_block)
+        app = case opts[:app]
+        when Symbol, nil then Dragonfly.app(opts[:app])
+        else opts[:app]
+        end
+
+        # Add callbacks
+        before_save :save_dragonfly_attachments if respond_to?(:before_save)
+        before_destroy :destroy_dragonfly_attachments if respond_to?(:before_destroy)
+
+        # Register the new attribute
+        dragonfly_attachment_classes << new_dragonfly_attachment_class(attribute, app, config_block)
+
+        # Define an anonymous module for all of the attribute-specific instance
+        # methods.
+        instance_methods = Module.new do
+          # 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 xxx_stored? method
+          define_method "#{attribute}_stored?" do
+            dragonfly_attachments[attribute].stored?
+          end
+
+          # Define the URL setter
+          define_method "#{attribute}_url=" do |url|
+            unless Utils.blank?(url)
+              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 Utils.blank?(string)
+              begin
+                dragonfly_attachments[attribute].retained_attrs = Serializer.json_b64_decode(string)
+              rescue Serializer::BadString => e
+                Dragonfly.warn("couldn't update attachment with serialized retained_#{attribute} string #{string.inspect}")
+              end
+            end
+            dragonfly_attachments[attribute].should_retain = true
+            dragonfly_attachments[attribute].retain!
+            string
+          end
+
+          # Define the retained getter
+          define_method "retained_#{attribute}" do
+            attrs = dragonfly_attachments[attribute].retained_attrs
+            Serializer.json_b64_encode(attrs) if attrs
+          end
+        end
+
+        include instance_methods
+      end
+
+      def new_dragonfly_attachment_class(attribute, app, config_block)
+        Class.new(Attachment).init(self, attribute, app, config_block)
+      end
+
+    end
+  end
+end