fog-dragonfly 0.8.1

data/features/steps/common_steps.rb

@@ -0,0 +1,8 @@
+Then "debug" do
+  debugger
+  true
+end
+
+Then 'show "(.*)"' do |code|
+  eval "puts #{code}"
+end

data/features/steps/dragonfly_steps.rb

@@ -0,0 +1,66 @@
+require 'tempfile'
+
+Given /^we are using the app for (\w+)$/ do |app_name|
+  $app = Dragonfly[app_name.to_sym]
+end
+
+Given /^a stored file "(.+?)"$/ do |name|
+  file = File.new(File.dirname(__FILE__) + "/../../samples/#{name}")
+  uid = $app.store(file)
+  TEMP_FILES[name] = uid
+end
+
+Given /^a stored image "(.+?)" with dimensions (\d+)x(\d+)$/ do |name, width, height|
+  tempfile = Tempfile.new(name)
+  `convert -resize #{width}x#{height}! #{SAMPLE_IMAGE_PATH} #{tempfile.path}`
+  uid = $app.store(tempfile)
+  TEMP_FILES[name] = uid
+end
+
+When /^I go to the url for "(.+?)"$/ do |name|
+  uid = TEMP_FILES[name]
+  make_request $app.fetch(uid)
+end
+
+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, 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, geometry|
+  uid = TEMP_FILES[name]
+  make_request $app.fetch(uid).thumb(geometry)
+end
+
+Then "the response should be OK" do
+  @response.status.should == 200
+end
+
+Then /the response should have mime-type '(.+?)'/ do |mime_type|
+  @response.headers['Content-Type'].should == mime_type
+end
+
+Then /^the image should have width '(.+?)'$/ do |width|
+  @response.body.should have_width(width.to_i)
+end
+
+Then /^the image should have height '(.+?)'$/ do |height|
+  @response.body.should have_height(height.to_i)
+end
+
+Then /^the image should have format '(.+?)'$/ do |format|
+  @response.body.should have_format(format)
+end
+
+Then /^the response should have the same content as the file "([^\"]*)"$/ do |name|
+  if RUBY_VERSION =~ /^1\.8/
+    @response.body.should == $app.fetch(TEMP_FILES[name]).data
+  else
+    @response.body.force_encoding('BINARY').should == $app.fetch(TEMP_FILES[name]).data.force_encoding('BINARY')
+  end
+end

data/features/steps/rails_steps.rb

@@ -0,0 +1,39 @@
+RAILS_APP_NAME = 'tmp_app'
+FIXTURES_PATH = ROOT_PATH + "/fixtures"
+GEMFILES = {
+  '2.3.5' => ROOT_PATH + '/Gemfile.rails.2.3.5',
+  '3.0.3' => ROOT_PATH + '/Gemfile',
+}
+
+def fixture_path(version)
+  "#{FIXTURES_PATH}/rails_#{version}"
+end
+
+def app_path(version)
+  "#{fixture_path(version)}/#{RAILS_APP_NAME}"
+end
+
+##############################################################################
+
+{
+  '2.3.5' => "BUNDLE_GEMFILE=#{GEMFILES['2.3.5']} rails #{RAILS_APP_NAME} -m template.rb",
+  '3.0.3' => "BUNDLE_GEMFILE=#{GEMFILES['3.0.3']} 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 |filename, version|
+  puts "\n*** RUNNING FEATURES IN THE RAILS APP... ***\n"
+  path = File.join(fixture_path(version), RAILS_APP_NAME)
+  `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

@@ -0,0 +1,40 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'dragonfly'
+require 'spec/expectations'
+require 'test/unit/assertions'
+require File.dirname(__FILE__) + '/../../spec/image_matchers.rb'
+
+ROOT_PATH = File.expand_path(File.dirname(__FILE__) + "/../..")
+
+# A hash of <name for reference> => <dragonfly uid> pairs
+TEMP_FILES = {}
+
+Dragonfly[:images].configure_with(:imagemagick)
+Dragonfly[:files].configure do |c|
+  c.analyser.register(Dragonfly::Analysis::FileCommandAnalyser)
+end
+
+SAMPLE_IMAGE_PATH = File.dirname(__FILE__)+'/../../samples/beach.png'
+
+Before do
+  # Remove temporary images
+  TEMP_FILES.each do |name, uid|
+    $app.datastore.destroy(uid)
+    TEMP_FILES.delete(name)
+  end
+end
+
+AfterStep do |scenario|
+  Dir["#{ROOT_PATH}/Gemfile*.lock"].each{|f| FileUtils.rm_f(f) }
+end
+
+module MyHelpers
+  
+  def make_request(job)
+    request = Rack::MockRequest.new($app)
+    @response = request.get(job.url)
+  end
+  
+end
+
+World(MyHelpers)

data/fixtures/files/app/models/album.rb

@@ -0,0 +1,3 @@
+class Album < ActiveRecord::Base
+  image_accessor :cover_image
+end

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

@@ -0,0 +1,4 @@
+<% form_for @album, :html => {:multipart => true} do |f| %>
+  <%= f.file_field :cover_image %>
+  <%= f.submit :value => 'Create' %>
+<% end %>

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

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

data/fixtures/files/config/initializers/dragonfly.rb

@@ -0,0 +1,4 @@
+# This is a hack to get the generated rails apps to use the version of dragonfly being worked on.
+$:.unshift(File.expand_path(File.dirname(__FILE__)+'/../../../../../lib'))
+require 'dragonfly/rails/images'
+

data/fixtures/files/features/manage_album_images.feature

@@ -0,0 +1,12 @@
+Feature: champion adds cover images to his albums
+  In order to be a champion
+  A user adds an image to his album
+
+  Scenario: Add and view image
+    When I go to the new album page
+    And I attach the file "../../../samples/beach.png" to "album[cover_image]"
+    And I press "Create"
+    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 PNG image of size 200x100

data/fixtures/files/features/step_definitions/image_steps.rb

@@ -0,0 +1,15 @@
+When /^I look at the generated (.+) image$/ do |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 == format
+  output[2].should == size
+end

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

@@ -0,0 +1,15 @@
+module NavigationHelpers
+  def path_to(page_name)
+    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__}"
+    end
+  end
+end
+
+World(NavigationHelpers)

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_2.3.5/template.rb

@@ -0,0 +1,10 @@
+gem 'rack-cache', :lib => 'rack/cache'
+gem 'cucumber'
+generate 'cucumber'
+
+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}/** ."

data/fixtures/rails_3.0.3/template.rb

@@ -0,0 +1,20 @@
+gem 'rack-cache', :require => 'rack/cache'
+
+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

@@ -0,0 +1,17 @@
+require "rubygems"
+require "bundler/setup"
+require File.dirname(__FILE__) + '/lib/dragonfly'
+APP = Dragonfly[:images].configure_with(:imagemagick)
+
+# available_uids = `find #{APP.datastore.root_path} ! -type d`.split("\n").map do |file|
+#   file.sub("#{APP.datastore.root_path}/", '')
+# end
+
+puts "Loaded stuff from dragonfly irbrc"
+# puts "\nAvailable uids:\n"
+# puts available_uids
+puts "\nAvailable sample images:\n"
+puts Dir['samples/*']
+puts "\nAvailable constants:\n"
+puts "APP"
+puts

data/lib/dragonfly.rb

@@ -0,0 +1,45 @@
+# 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
+# All paths here are absolute
+def camelize(path)
+  # e.g. 'test/this_one' => Test::ThisOne
+  "#{path}".
+    chomp('/').
+    gsub('/','::').
+    gsub(/([^a-z])(\w)/){ "#{$1}#{$2.upcase}" }.
+    gsub('_','').
+    sub(/^(\w)/){ $1.upcase }
+end
+def autoload_files_in_dir(path, namespace)
+  # Define the module
+  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
+  # Recurse on subdirectories
+  Dir.glob("#{path}/*/").each do |dir|
+    sub_namespace = camelize( File.basename(dir) )
+    autoload_files_in_dir(dir, "#{namespace}::#{sub_namespace}")
+  end
+end
+
+autoload_files_in_dir("#{File.dirname(__FILE__)}/dragonfly", 'Dragonfly')
+
+require File.dirname(__FILE__) + '/dragonfly/core_ext/object'
+require File.dirname(__FILE__) + '/dragonfly/core_ext/string'
+require File.dirname(__FILE__) + '/dragonfly/core_ext/symbol'
+
+module Dragonfly
+  class << self
+
+    def [](*args)
+      App[*args]
+    end
+
+  end
+end

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,169 @@
+require 'forwardable'
+
+module Dragonfly
+  module ActiveModelExtensions
+
+    class Attachment
+
+      extend Forwardable
+      def_delegators :job,
+        :data, :to_file, :file, :tempfile, :path,
+        :process, :encode, :analyse,
+        :meta, :meta=,
+        :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 job.store(
+            :meta => {
+              :model_class => parent_model.class.name,
+              :model_attachment => attribute_name
+            }
+          )
+          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
+
+      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
+
+      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
+        @magic_attributes ||= parent_model.public_methods.select { |name|
+          name.to_s =~ /^#{attribute_name}_(.+)$/ && allowed_magic_attributes.include?($1.to_sym)
+        }.map{|name| name.to_s.sub("#{attribute_name}_", '').to_sym }
+      end
+
+      def set_magic_attribute(property, value)
+        parent_model.send("#{attribute_name}_#{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)
+        parent_model.send("#{attribute_name}_#{property}")
+      end
+
+    end
+  end
+end