dragonfly 0.6.2 → 0.7.0

data/features/images.feature

@@ -39,10 +39,9 @@ Feature: champion uses dragonfly to process images
     And the image should have format 'png'
 
   Scenario: use a parameters shortcut
-  # Note that this scenario makes use of the configured default format
-  When I go to the url for "beach.png", with shortcut '100x150!'
-  Then the response should be OK
-  And the response should have mime-type 'image/jpeg'
-  And the image should have width '100'
-  And the image should have height '150'
-  And the image should have format 'jpeg'
+    When I go to the url for "beach.png", with shortcut '100x150!'
+    Then the response should be OK
+    And the response should have mime-type 'image/png'
+    And the image should have width '100'
+    And the image should have height '150'
+    And the image should have format 'png'

data/features/no_processing.feature

@@ -12,9 +12,3 @@ Feature: winner uses dragonfly to serve different kinds of files
     Then the response should be OK
     And the response should have mime-type 'application/zip'
     And the response should have the same content as the file "sample.docx"
-
-  Scenario: Go to url for original, with extension
-    Given a stored file "sample.docx"
-    When I go to the url for "sample.docx", with format 'docx'
-    Then the response should be OK
-    And the response should have mime-type 'application/zip'

data/features/rails_2.3.5.feature

@@ -4,4 +4,4 @@ Feature: champion uses dragonfly in his Rails 2.3.5 application
 
   Scenario: Set up dragonfly using the provided initializer
     Given a Rails 2.3.5 application set up for using dragonfly
-    Then the cucumber features in my Rails 2.3.5 app should pass
+    Then the manage_album_images cucumber features in my Rails 2.3.5 app should pass

data/features/rails_3.0.0.rc.feature

@@ -0,0 +1,8 @@
+Feature: champion uses dragonfly in his Rails 3.0.0.rc application
+  In order to be a champion
+  A user uses dragonfly in his Rails 3.0.0.rc application
+
+  Scenario: Set up dragonfly using initializer
+    Given a Rails 3.0.0.rc application set up for using dragonfly
+    Then the manage_album_images cucumber features in my Rails 3.0.0.rc app should pass
+    And the text_images cucumber features in my Rails 3.0.0.rc app should pass

data/features/steps/dragonfly_steps.rb

@@ -1,5 +1,7 @@
+require 'tempfile'
+
 Given /^we are using the app for (\w+)$/ do |app_name|
-  $app = Dragonfly::App[app_name.to_sym]
+  $app = Dragonfly[app_name.to_sym]
 end
 
 Given /^a stored file "(.+?)"$/ do |name|
@@ -16,23 +18,23 @@ Given /^a stored image "(.+?)" with dimensions (\d+)x(\d+)$/ do |name, width, he
 end
 
 When /^I go to the url for "(.+?)"$/ do |name|
-  make_request name
+  uid = TEMP_FILES[name]
+  make_request $app.fetch(uid)
 end
 
-When /^I go to the url for "(.+?)", with format '([^']+?)'$/ do |name, ext|
-  make_request name, :format => ext
+When /^I go to the url for "(.+?)", with format '([^']+?)'$/ do |name, format|
+  uid = TEMP_FILES[name]
+  make_request $app.fetch(uid).encode(format)
 end
 
-When /^I go to the url for "(.+?)", with format '(.+?)' and resize geometry '(.+?)'$/ do |name, ext, geometry|
-  make_request(name,
-    :format => ext,
-    :processing_method => :resize,
-    :processing_options => {:geometry => geometry}
-  )
+When /^I go to the url for "(.+?)", with format '(.+?)' and resize geometry '(.+?)'$/ do |name, format, geometry|
+  uid = TEMP_FILES[name]
+  make_request $app.fetch(uid).process(:resize, geometry).encode(format)
 end
 
-When /^I go to the url for "(.+?)", with shortcut '([^']+?)'$/ do |name, arg1|
-  make_request name, arg1
+When /^I go to the url for "(.+?)", with shortcut '([^']+?)'$/ do |name, geometry|
+  uid = TEMP_FILES[name]
+  make_request $app.fetch(uid).thumb(geometry)
 end
 
 Then "the response should be OK" do

data/features/steps/rails_steps.rb

@@ -1,5 +1,9 @@
 RAILS_APP_NAME = 'tmp_app'
-FIXTURES_PATH = File.expand_path(File.dirname(__FILE__) + "/../../fixtures")
+FIXTURES_PATH = ROOT_PATH + "/fixtures"
+GEMFILES = {
+  '2.3.5' => ROOT_PATH + '/Gemfile.rails.2.3.5',
+  '3.0.0.rc' => ROOT_PATH + '/Gemfile',
+}
 
 def fixture_path(version)
   "#{FIXTURES_PATH}/rails_#{version}"
@@ -11,18 +15,25 @@ end
 
 ##############################################################################
 
-Given /^a Rails (.+) application set up for using dragonfly$/ do |version|
-  raise "Problem setting up Rails app" unless `
-    cd #{fixture_path(version)} &&
-    rm -rf #{RAILS_APP_NAME} &&
-    rails _#{version}_ #{RAILS_APP_NAME} -m template.rb`
+{
+  '2.3.5' => "BUNDLE_GEMFILE=#{GEMFILES['2.3.5']} rails #{RAILS_APP_NAME} -m template.rb",
+  '3.0.0.rc' => "BUNDLE_GEMFILE=#{GEMFILES['3.0.0.rc']} bundle exec rails new #{RAILS_APP_NAME} -m template.rb"
+}.each do |version, rails_command|
+
+  Given /^a Rails #{version} application set up for using dragonfly$/ do
+    raise "Problem setting up Rails app" unless `
+      cd #{fixture_path(version)} &&
+      rm -rf #{RAILS_APP_NAME} &&
+      #{rails_command}`
+  end
+  
 end
 
-Then /^the cucumber features in my Rails (.+) app should pass$/ do |version|
+Then /^the (.+) cucumber features in my Rails (.+) app should pass$/ do |filename, version|
   puts "\n*** RUNNING FEATURES IN THE RAILS APP... ***\n"
   path = File.join(fixture_path(version), RAILS_APP_NAME)
-  `cd #{path} && RAILS_ENV=cucumber rake db:migrate`
-  features_passed = system "cd #{path} && cucumber features"
+  `cd #{path} && BUNDLE_GEMFILE=#{GEMFILES[version]} RAILS_ENV=cucumber rake db:migrate`
+  features_passed = system "cd #{path} && BUNDLE_GEMFILE=#{GEMFILES[version]} cucumber features/#{filename}.feature"
   puts "\n*** FINISHED RUNNING FEATURES IN THE RAILS APP ***\n"
   raise "Features failed" unless features_passed
 end

data/features/support/env.rb

@@ -4,18 +4,14 @@ require 'spec/expectations'
 require 'test/unit/assertions'
 require File.dirname(__FILE__) + '/../../spec/image_matchers.rb'
 
-# A hack as system calls weren't using my path
-extra_paths = %w(/opt/local/bin)
-ENV['PATH'] ||= ''
-ENV['PATH'] += ':' + extra_paths.join(':')
+ROOT_PATH = File.expand_path(File.dirname(__FILE__) + "/../..")
 
 # A hash of <name for reference> => <dragonfly uid> pairs
 TEMP_FILES = {}
 
-Dragonfly::App[:images].configure_with(Dragonfly::Config::RMagickImages)
-Dragonfly::App[:files].configure do |c|
-  c.register_analyser(Dragonfly::Analysis::FileCommandAnalyser)
-  c.register_encoder(Dragonfly::Encoding::TransparentEncoder)
+Dragonfly[:images].configure_with(:rmagick)
+Dragonfly[:files].configure do |c|
+  c.analyser.register(Dragonfly::Analysis::FileCommandAnalyser)
 end
 
 SAMPLE_IMAGE_PATH = File.dirname(__FILE__)+'/../../samples/beach.png'
@@ -28,12 +24,15 @@ Before do
   end
 end
 
+AfterStep do |scenario|
+  FileUtils.rm_f("#{ROOT_PATH}/Gemfile.lock")
+end
+
 module MyHelpers
   
-  def make_request(name, *args)
+  def make_request(job)
     request = Rack::MockRequest.new($app)
-    url = $app.url_for(TEMP_FILES[name], *args)
-    @response = request.get(url)
+    @response = request.get(job.url)
   end
   
 end

data/fixtures/files/app/views/albums/new.html.erb

@@ -1,4 +1,4 @@
-<% form_for @album, :html => {:multipart => true} do |f| %>
-    <%= f.file_field :cover_image %>
-    <%= f.submit 'Create' %>
-<% end %>
+<form action="/albums" enctype="multipart/form-data" method="post">
+  <input name="album[cover_image]" type="file" /> 
+  <input type="submit" value="Create" /> 
+</form>

data/fixtures/files/app/views/albums/show.html.erb

@@ -1,4 +1,4 @@
 <%= flash[:notice] %>
 Look at this cover image!
-<%= image_tag @album.cover_image.url('200x100!') %>
+<%= image_tag @album.cover_image.thumb('200x100!').url %>
 <%= link_to 'Index', albums_path %>

data/fixtures/files/features/manage_album_images.feature

@@ -9,4 +9,4 @@ Feature: champion adds cover images to his albums
     Then I should see "successfully created"
     And I should see "Look at this cover image!"
     When I look at the generated beach image
-    And I should see a JPEG image of size 200x100
+    And I should see a PNG image of size 200x100

data/fixtures/files/features/step_definitions/{album_steps.rb → image_steps.rb}

@@ -1,14 +1,15 @@
 When /^I look at the generated (.+) image$/ do |image_name|
-  page.body =~ /src="(.+?#{image_name}.+?)"/
+  page.body =~ %r{src="(/media[^"]+?)"}
   url = $1
   visit(url)
 end
 
 Then /^I should see a (.+) image of size (.+)$/ do |format, size|
   tempfile = Tempfile.new('wicked')
+  page.body.force_encoding('UTF-8').encode! if page.body.respond_to?(:force_encoding) # For some reason need this on Ruby 1.9.2
   tempfile.write page.body
   tempfile.close
   output = `identify #{tempfile.path}`.split(' ')
-  output[1].should == 'JPEG'
-  output[2].should == '200x100'
+  output[1].should == format
+  output[2].should == size
 end

data/fixtures/files/features/support/paths.rb

@@ -3,6 +3,8 @@ module NavigationHelpers
     case page_name
     when "the new album page"
       '/albums/new'
+    when /^the image for text "(.+)", size "(.+)"$/
+      "/text/#{$1}/#{$2}"
     else
       raise "Can't find mapping from \"#{page_name}\" to a path.\n" +
         "Now, go and add a mapping in #{__FILE__}"

data/fixtures/files/features/text_images.feature

@@ -0,0 +1,7 @@
+Feature: champion adds text images to his app
+  In order to be a champion
+  A user adds text images to his app
+
+  Scenario: View text image
+    When I go to the image for text "Hello", size "300x150!"
+    Then I should see a PNG image of size 300x150

data/fixtures/rails_3.0.0.rc/template.rb

@@ -0,0 +1,21 @@
+gem 'rack-cache', :require => 'rack/cache'
+gem 'rmagick', '2.12.2', :require => 'RMagick'
+
+gem 'capybara'
+gem 'cucumber-rails'
+gem 'cucumber', '0.8.5'
+
+generate 'cucumber:install'
+
+generate 'scaffold albums cover_image_uid:string'
+rake 'db:migrate'
+
+# Copy over all files from the template dir
+files_dir = File.expand_path(File.dirname(__FILE__) + '/../files')
+run "cp -r #{files_dir}/** ."
+
+route <<ROUTES
+  match '/text/:text/:size' => Dragonfly[:images].endpoint{|params, app|
+    app.generate(:text, params[:text]).thumb(params[:size])
+  }
+ROUTES

data/irbrc.rb

@@ -1,4 +1,5 @@
-require File.dirname(__FILE__) + '/config'
+require File.dirname(__FILE__) + '/lib/dragonfly'
+APP = Dragonfly[:images].configure_with(:rmagick)
 
 available_uids = `find #{APP.datastore.root_path} ! -type d`.split("\n").map do |file|
   file.sub("#{APP.datastore.root_path}/", '')

data/lib/dragonfly.rb

@@ -1,4 +1,4 @@
-# AUTOLOAD EVERYTHING IN THE IMAGETASTIC DIRECTORY TREE
+# AUTOLOAD EVERYTHING IN THE DRAGONFLY DIRECTORY TREE
 
 # The convention is that dirs are modules
 # so declare them here and autoload any modules/classes inside them
@@ -17,6 +17,7 @@ def autoload_files_in_dir(path, namespace)
   eval("module #{namespace}; end")
   # Autoload modules/classes in that module
   Dir.glob("#{path}/*.rb").each do |file|
+    file = File.expand_path(file)
     sub_const_name = camelize( File.basename(file, '.rb') )
     eval("#{namespace}.autoload('#{sub_const_name}', '#{file}')")
   end
@@ -36,21 +37,8 @@ require File.dirname(__FILE__) + '/dragonfly/core_ext/symbol'
 module Dragonfly
   class << self
 
-    def const_missing(const)
-      case const
-      when :RMagickConfiguration
-        puts "WARNING: RMagickConfiguration is deprecated and will be removed in future "+
-             "versions of Dragonfly. Please change to Dragonfly::Config::RMagickImages"
-        const_set(:RMagickConfiguration, Config::RMagickImages)
-      else
-        super
-      end
-    end
-
-    def active_record_macro(prefix, app)
-      already_extended = (class << ActiveRecord::Base; self; end).included_modules.include?(ActiveRecordExtensions)
-      ActiveRecord::Base.extend(ActiveRecordExtensions) unless already_extended
-      ActiveRecord::Base.register_dragonfly_app(prefix, app)
+    def [](*args)
+      App[*args]
     end
 
   end

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

@@ -1,6 +1,6 @@
 module Dragonfly
 
-  module ActiveRecordExtensions
+  module ActiveModelExtensions
 
     def self.extended(klass)
       unless klass.include?(InstanceMethods)

data/lib/dragonfly/active_model_extensions/attachment.rb

@@ -0,0 +1,146 @@
+require 'forwardable'
+
+module Dragonfly
+  module ActiveModelExtensions
+
+    class Attachment
+
+      extend Forwardable
+      def_delegators :job,
+        :data, :to_file, :file, :tempfile, :path,
+        :process, :encode, :analyse,
+        :url
+
+      def initialize(app, parent_model, attribute_name)
+        @app, @parent_model, @attribute_name = app, parent_model, attribute_name
+        self.extend app.analyser.analysis_methods
+        self.extend app.job_definitions
+        self.uid = parent_uid
+        self.job = app.fetch(uid) if uid
+      end
+
+      def assign(value)
+        if value.nil?
+          self.job = nil
+          reset_magic_attributes
+        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
+        end
+        set_uid_and_parent_uid(nil)
+        value
+      end
+
+      def destroy!
+        destroy_previous!
+        destroy_content(uid) if uid
+      end
+
+      def save!
+        sync_with_parent!
+        destroy_previous!
+        if job && !uid
+          set_uid_and_parent_uid app.store(job.result)
+          self.job = job.to_fetched_job(uid)
+        end
+      end
+
+      def to_value
+        self if job
+      end
+
+      def analyse(meth, *args)
+        has_magic_attribute_for?(meth) ? magic_attribute_for(meth) : job.send(meth)
+      end
+
+      [:size, :ext, :name].each do |meth|
+        define_method meth do
+          analyse(meth)
+        end
+      end
+
+      protected
+
+      attr_reader :job
+
+      private
+
+      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_parent!
+        # If the parent uid has been set manually
+        if uid != parent_uid
+          self.uid = parent_uid
+        end
+      end
+
+      def set_uid_and_parent_uid(uid)
+        self.uid = uid
+        self.parent_uid = uid
+      end
+
+      def parent_uid=(uid)
+        parent_model.send("#{attribute_name}_uid=", uid)
+      end
+
+      def parent_uid
+        parent_model.send("#{attribute_name}_uid")
+      end
+
+      attr_reader :app, :parent_model, :attribute_name
+      attr_writer :job
+      attr_accessor :previous_uid
+      attr_reader :uid
+
+      def uid=(uid)
+        self.previous_uid = @uid if @uid
+        @uid = uid
+      end
+
+      def allowed_magic_attributes
+        app.analyser.analysis_method_names + [:size, :ext, :name]
+      end
+
+      def magic_attributes
+        parent_model.public_methods.select { |name|
+          name.to_s =~ /^#{attribute_name}_(.+)$/ && allowed_magic_attributes.include?($1.to_sym)
+        }
+      end
+
+      def set_magic_attributes
+        magic_attributes.each do |attribute|
+          method = attribute.to_s.sub("#{attribute_name}_", '')
+          parent_model.send("#{attribute}=", job.send(method))
+        end
+      end
+
+      def reset_magic_attributes
+        magic_attributes.each{|attribute| parent_model.send("#{attribute}=", nil) }
+      end
+
+      def has_magic_attribute_for?(property)
+        magic_attributes.include?("#{attribute_name}_#{property}".to_method_name)
+      end
+
+      def magic_attribute_for(property)
+        parent_model.send("#{attribute_name}_#{property}")
+      end
+
+    end
+  end
+end