dragonfly 0.9.15 → 1.0

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

@@ -1,17 +0,0 @@
-module NavigationHelpers
-  def path_to(page_name)
-    case page_name
-    when "the new album page"
-      '/albums/new'
-    when /^the page for album "(.+)"$/
-      album_path(Album.find_by_name($1))
-    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/rails/files/features/text_images.feature

@@ -1,7 +0,0 @@
-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/template.rb

@@ -1,20 +0,0 @@
-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 name: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,19 +0,0 @@
-require "rubygems"
-require "bundler/setup"
-$:.unshift(File.expand_path('../lib', __FILE__))
-require 'dragonfly'
-include Dragonfly::Serializer
-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/active_model_extensions/class_methods.rb

@@ -1,98 +0,0 @@
-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.json_decode(string, :symbolize_keys => true)
-                rescue Serializer::BadString => e
-                  app.log.warn("*** WARNING ***: 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_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

data/lib/dragonfly/analyser.rb

@@ -1,58 +0,0 @@
-module Dragonfly
-  class Analyser < FunctionManager
-    
-    configurable_attr :enable_cache, true
-    configurable_attr :cache_size, 100
-    
-    def initialize
-      super
-      analyser = self
-      @analysis_methods = Module.new do
-
-        define_method :analyser do
-          analyser
-        end
-        
-      end
-      @analysis_method_names = []
-    end
-    
-    attr_reader :analysis_methods, :analysis_method_names
-    
-    def analyse(temp_object, method, *args)
-      if enable_cache
-        key = [temp_object.unique_id, method, *args]
-        cache[key] ||= call_last(method, temp_object, *args)
-      else
-        call_last(method, temp_object, *args)
-      end
-    rescue NotDefined, UnableToHandle => e
-      log.warn(e.message)
-      nil
-    end
-    
-    # Each time a function is registered with the analyser,
-    # add a method to the analysis_methods module.
-    # Expects the object that is extended to define 'analyse(method, *args)'
-    def add(name, *args, &block)
-      analysis_methods.module_eval %(
-        def #{name}(*args)
-          analyse(:#{name}, *args)
-        end
-      )
-      analysis_method_names << name.to_sym
-      super
-    end
-    
-    def clear_cache!
-      @cache = nil
-    end
-    
-    private
-    
-    def cache
-      @cache ||= SimpleCache.new(cache_size)
-    end
-    
-  end
-end

data/lib/dragonfly/analysis/file_command_analyser.rb

@@ -1,33 +0,0 @@
-module Dragonfly
-  module Analysis
-    
-    class FileCommandAnalyser
-      
-      include Shell
-      include Configurable
-      
-      configurable_attr :file_command, "file"
-      configurable_attr :use_filesystem, true
-      configurable_attr :num_bytes_to_check, 255
-      
-      def mime_type(temp_object)
-        content_type = if use_filesystem
-          `#{file_command} -b --mime #{quote temp_object.path}`
-        else
-          IO.popen("#{file_command} -b --mime -", 'r+') do |io|
-            if num_bytes_to_check
-              io.write temp_object.data[0, num_bytes_to_check]
-            else
-              io.write temp_object.data 
-            end
-            io.close_write
-            io.read
-          end
-        end.split(';').first
-        content_type.strip if content_type
-      end
-      
-    end
-    
-  end
-end

data/lib/dragonfly/analysis/image_magick_analyser.rb

@@ -1,6 +0,0 @@
-module Dragonfly
-  module Analysis
-    puts "WARNING: Dragonfly::Analysis::ImageMagickAnalyser is DEPRECATED and will soon be removed. Please use Dragonfly::ImageMagick::Analyser instead."
-    ImageMagickAnalyser = ImageMagick::Analyser
-  end
-end

data/lib/dragonfly/config/heroku.rb

@@ -1,26 +0,0 @@
-module Dragonfly
-  module Config
-
-    module Heroku
-
-      def self.apply_configuration(app, bucket_name)
-        app.log.warn("""HEROKU CONFIGURATION IS NOW DEPRECATED - you should configure with the S3 Datastore directly, e.g.
-  c.datastore = Dragonfly::DataStorage::S3DataStore.new(
-    :bucket_name => '#{bucket_name}',
-    :access_key_id => 'XXX',
-    :secret_access_key => 'XXX'
-  )
-""")
-        app.configure do |c|
-          c.datastore = DataStorage::S3DataStore.new
-          c.datastore.configure do |d|
-            d.bucket_name = bucket_name
-            d.access_key_id = ENV['S3_KEY'] || raise("ENV variable 'S3_KEY' needs to be set - use\n\theroku config:add S3_KEY=XXXXXXXXX")
-            d.secret_access_key = ENV['S3_SECRET'] || raise("ENV variable 'S3_SECRET' needs to be set - use\n\theroku config:add S3_SECRET=XXXXXXXXX")
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/dragonfly/config/image_magick.rb

@@ -1,6 +0,0 @@
-module Dragonfly
-  module Config
-    puts "WARNING: Dragonfly::Config::ImageMagick is DEPRECATED and will soon be removed. Please use Dragonfly::ImageMagick::Config instead."
-    ImageMagick = Dragonfly::ImageMagick::Config
-  end
-end

data/lib/dragonfly/config/rails.rb

@@ -1,20 +0,0 @@
-module Dragonfly
-  module Config
-
-    module Rails
-
-      def self.apply_configuration(app)
-        app.configure do |c|
-          c.log = ::Rails.logger
-          if c.datastore.is_a?(DataStorage::FileDataStore)
-            c.datastore.root_path = ::Rails.root.join('public/system/dragonfly', ::Rails.env).to_s
-            c.datastore.server_root = ::Rails.root.join('public').to_s
-          end
-          c.url_format = '/media/:job/:basename.:format'
-          c.analyser.register(Analysis::FileCommandAnalyser)
-        end
-      end
-
-    end
-  end
-end

data/lib/dragonfly/data_storage.rb

@@ -1,11 +0,0 @@
-module Dragonfly
-  module DataStorage
-
-    # Exceptions
-    class BadUID < RuntimeError; end
-    class DataNotFound < RuntimeError; end
-    class UnableToStore < RuntimeError; end
-    class DestroyError < RuntimeError; end
-
-  end
-end

data/lib/dragonfly/data_storage/couch_data_store.rb

@@ -1,83 +0,0 @@
-require 'couchrest'
-
-module Dragonfly
-  module DataStorage
-    class CouchDataStore
-
-      include Configurable
-      include Serializer
-
-      configurable_attr :host, 'localhost'
-      configurable_attr :port, '5984'
-      configurable_attr :database, 'dragonfly'
-      configurable_attr :username
-      configurable_attr :password
-
-      def initialize(opts={})
-        self.host = opts[:host] if opts[:host]
-        self.port = opts[:port] if opts[:port]
-        self.database = opts[:database] if opts[:database]
-        self.username = opts[:username]
-        self.password = opts[:password]
-      end
-
-      def store(temp_object, opts={})
-        name = temp_object.name || 'file'
-        content_type = opts[:content_type] || opts[:mime_type] || 'application/octet-stream'
-        
-        temp_object.file do |f|
-          doc = CouchRest::Document.new(:meta => marshal_encode(temp_object.meta))
-          response = db.save_doc(doc)
-          doc.put_attachment(name, f.dup, :content_type => content_type)
-          form_uid(response['id'], name)
-        end
-      rescue RuntimeError => e
-        raise UnableToStore, "#{e} - #{temp_object.inspect}"
-      end
-
-      def retrieve(uid)
-        doc_id, attachment = parse_uid(uid)
-        doc = db.get(doc_id)
-        [doc.fetch_attachment(attachment), marshal_decode(doc['meta'])]
-      rescue RestClient::ResourceNotFound => e
-        raise DataNotFound, "#{e} - #{uid}"
-      end
-
-      def destroy(uid)
-        doc_id, attachment = parse_uid(uid)
-        doc = db.get(doc_id)
-        db.delete_doc(doc)
-      rescue RestClient::ResourceNotFound => e
-        raise DataNotFound, "#{e} - #{uid}"
-      end
-
-      def db
-        @db ||= begin
-          url = "http://#{auth}#{host}:#{port}"
-          CouchRest.new(url).database!(database)
-        end
-      end
-
-      def url_for(uid, opts={})
-        doc_id, attachment = parse_uid(uid)
-        "http://#{host}:#{port}/#{database}/#{doc_id}/#{attachment}"
-      end
-      
-      private
-      
-      def auth
-        username.blank? ? nil : "#{username}:#{password}@"
-      end
-      
-      def form_uid(doc_id, attachment)
-        "#{doc_id}/#{attachment}"
-      end
-      
-      def parse_uid(uid)
-        doc_id, attachment = uid.split('/')
-        [doc_id, (attachment || 'file')]
-      end
-
-    end
-  end
-end

data/lib/dragonfly/data_storage/file_data_store.rb

@@ -1,144 +0,0 @@
-require 'pathname'
-
-module Dragonfly
-  module DataStorage
-
-    class FileDataStore
-
-      # Exceptions
-      class UnableToFormUrl < RuntimeError; end
-
-      include Configurable
-
-      configurable_attr :root_path, '/var/tmp/dragonfly'
-      configurable_attr :server_root
-      configurable_attr :store_meta, true
-
-      def store(temp_object, opts={})
-        relative_path = if opts[:path]
-          opts[:path]
-        else
-          filename = temp_object.name || 'file'
-          relative_path = relative_path_for(filename)
-        end
-
-        begin
-          path = absolute(relative_path)
-          until !File.exist?(path)
-            path = disambiguate(path)
-          end
-          temp_object.to_file(path).close
-          store_meta_data(path, temp_object.meta) if store_meta
-        rescue Errno::EACCES => e
-          raise UnableToStore, e.message
-        end
-
-        relative(path)
-      end
-
-      def retrieve(relative_path)
-        validate_uid!(relative_path)
-        path = absolute(relative_path)
-        pathname = Pathname.new(path)
-        raise DataNotFound, "couldn't find file #{path}" unless pathname.exist?
-        [
-          pathname,
-          (store_meta ? retrieve_meta_data(path) : {})
-        ]
-      end
-
-      def destroy(relative_path)
-        validate_uid!(relative_path)
-        path = absolute(relative_path)
-        FileUtils.rm path
-        FileUtils.rm_f meta_data_path(path)
-        FileUtils.rm_f deprecated_meta_data_path(path)
-        purge_empty_directories(relative_path)
-      rescue Errno::ENOENT => e
-        raise DataNotFound, e.message
-      end
-
-      def url_for(relative_path, opts={})
-        if server_root.nil?
-          raise NotConfigured, "you need to configure server_root for #{self.class.name} in order to form urls"
-        else
-          _, __, path = absolute(relative_path).partition(server_root)
-          if path.empty?
-            raise UnableToFormUrl, "couldn't form url for uid #{relative_path.inspect} with root_path #{root_path.inspect} and server_root #{server_root.inspect}"
-          else
-            path
-          end
-        end
-      end
-
-      def disambiguate(path)
-        dirname = File.dirname(path)
-        basename = File.basename(path, '.*')
-        extname = File.extname(path)
-        "#{dirname}/#{basename}_#{(Time.now.usec*10 + rand(100)).to_s(32)}#{extname}"
-      end
-
-      private
-
-      def absolute(relative_path)
-        relative_path.to_s == '.' ? root_path : File.join(root_path, relative_path)
-      end
-
-      def relative(absolute_path)
-        absolute_path[/^#{Regexp.escape root_path}\/?(.*)$/, 1]
-      end
-
-      def directory_empty?(path)
-        Dir.entries(path) == ['.','..']
-      end
-      
-      def root_path?(dir)
-        root_path == dir
-      end
-
-      def meta_data_path(data_path)
-        "#{data_path}.meta"
-      end
-
-      def deprecated_meta_data_path(data_path)
-        "#{data_path}.extra"
-      end
-
-      def relative_path_for(filename)
-        time = Time.now
-        msec = time.usec / 1000
-        "#{time.strftime '%Y/%m/%d/%H_%M_%S'}_#{msec}_#{filename.gsub(/[^\w.]+/,'_')}"
-      end
-
-      def store_meta_data(data_path, meta)
-        File.open(meta_data_path(data_path), 'wb') do |f|
-          f.write Marshal.dump(meta)
-        end
-      end
-
-      def retrieve_meta_data(data_path)
-        path = meta_data_path(data_path)
-        if File.exist?(path)
-          File.open(path,'rb'){|f| Marshal.load(f.read) }
-        else
-          deprecated_path = deprecated_meta_data_path(data_path)
-          File.exist?(deprecated_path) ? File.open(deprecated_path,'rb'){|f| Marshal.load(f.read) } : {}
-        end
-      end
-
-      def purge_empty_directories(path)
-        containing_directory = Pathname.new(path).dirname
-        containing_directory.ascend do |relative_dir|
-          dir = absolute(relative_dir)
-          FileUtils.rmdir dir if directory_empty?(dir) && !root_path?(dir)
-        end
-      end
-
-      def validate_uid!(uid)
-        raise BadUID, "tried to retrieve uid #{uid.inspect}" if uid.blank? || uid['../']
-      end
-
-    end
-
-  end
-end