pictrails 0.5.0

data/vendor/plugins/attachment_fu/lib/technoweenie/attachment_fu/backends/db_file_backend.rb

@@ -0,0 +1,39 @@
+module Technoweenie # :nodoc:
+  module AttachmentFu # :nodoc:
+    module Backends
+      # Methods for DB backed attachments
+      module DbFileBackend
+        def self.included(base) #:nodoc:
+          Object.const_set(:DbFile, Class.new(ActiveRecord::Base)) unless Object.const_defined?(:DbFile)
+          base.belongs_to  :db_file, :class_name => '::DbFile', :foreign_key => 'db_file_id'
+        end
+
+        # Creates a temp file with the current db data.
+        def create_temp_file
+          write_to_temp_file current_data
+        end
+        
+        # Gets the current data from the database
+        def current_data
+          db_file.data
+        end
+        
+        protected
+          # Destroys the file.  Called in the after_destroy callback
+          def destroy_file
+            db_file.destroy if db_file
+          end
+          
+          # Saves the data to the DbFile model
+          def save_to_storage
+            if save_attachment?
+              (db_file || build_db_file).data = temp_data
+              db_file.save!
+              self.class.update_all ['db_file_id = ?', self.db_file_id = db_file.id], ['id = ?', id]
+            end
+            true
+          end
+      end
+    end
+  end
+end

data/vendor/plugins/attachment_fu/lib/technoweenie/attachment_fu/backends/file_system_backend.rb

@@ -0,0 +1,101 @@
+require 'ftools'
+module Technoweenie # :nodoc:
+  module AttachmentFu # :nodoc:
+    module Backends
+      # Methods for file system backed attachments
+      module FileSystemBackend
+        def self.included(base) #:nodoc:
+          base.before_update :rename_file
+        end
+      
+        # Gets the full path to the filename in this format:
+        #
+        #   # This assumes a model name like MyModel
+        #   # public/#{table_name} is the default filesystem path 
+        #   RAILS_ROOT/public/my_models/5/blah.jpg
+        #
+        # Overwrite this method in your model to customize the filename.
+        # The optional thumbnail argument will output the thumbnail's filename.
+        def full_filename(thumbnail = nil)
+          file_system_path = (thumbnail ? thumbnail_class : self).attachment_options[:path_prefix].to_s
+          File.join(RAILS_ROOT, file_system_path, *partitioned_path(thumbnail_name_for(thumbnail)))
+        end
+      
+        # Used as the base path that #public_filename strips off full_filename to create the public path
+        def base_path
+          @base_path ||= File.join(RAILS_ROOT, 'public')
+        end
+      
+        # The attachment ID used in the full path of a file
+        def attachment_path_id
+          ((respond_to?(:parent_id) && parent_id) || id).to_i
+        end
+      
+        # by default paritions files into directories e.g. 0000/0001/image.jpg
+        # to turn this off set :partition => false
+        def partitioned_path(*args)
+          if respond_to?(:attachment_options) && attachment_options[:partition] == false 
+            args
+          else 
+            ("%08d" % attachment_path_id).scan(/..../) + args
+          end
+        end
+      
+        # Gets the public path to the file
+        # The optional thumbnail argument will output the thumbnail's filename.
+        def public_filename(thumbnail = nil)
+          full_filename(thumbnail).gsub %r(^#{Regexp.escape(base_path)}), ''
+        end
+      
+        def filename=(value)
+          @old_filename = full_filename unless filename.nil? || @old_filename
+          write_attribute :filename, sanitize_filename(value)
+        end
+
+        # Creates a temp file from the currently saved file.
+        def create_temp_file
+          copy_to_temp_file full_filename
+        end
+
+        protected
+          # Destroys the file.  Called in the after_destroy callback
+          def destroy_file
+            FileUtils.rm full_filename
+            # remove directory also if it is now empty
+            Dir.rmdir(File.dirname(full_filename)) if (Dir.entries(File.dirname(full_filename))-['.','..']).empty?
+          rescue
+            logger.info "Exception destroying  #{full_filename.inspect}: [#{$!.class.name}] #{$1.to_s}"
+            logger.warn $!.backtrace.collect { |b| " > #{b}" }.join("\n")
+          end
+
+          # Renames the given file before saving
+          def rename_file
+            return unless @old_filename && @old_filename != full_filename
+            if save_attachment? && File.exists?(@old_filename)
+              FileUtils.rm @old_filename
+            elsif File.exists?(@old_filename)
+              FileUtils.mv @old_filename, full_filename
+            end
+            @old_filename =  nil
+            true
+          end
+          
+          # Saves the file to the file system
+          def save_to_storage
+            if save_attachment?
+              # TODO: This overwrites the file if it exists, maybe have an allow_overwrite option?
+              FileUtils.mkdir_p(File.dirname(full_filename))
+              File.cp(temp_path, full_filename)
+              File.chmod(attachment_options[:chmod] || 0644, full_filename)
+            end
+            @old_filename = nil
+            true
+          end
+          
+          def current_data
+            File.file?(full_filename) ? File.read(full_filename) : nil
+          end
+      end
+    end
+  end
+end

data/vendor/plugins/attachment_fu/lib/technoweenie/attachment_fu/backends/s3_backend.rb

@@ -0,0 +1,303 @@
+module Technoweenie # :nodoc:
+  module AttachmentFu # :nodoc:
+    module Backends
+      # = AWS::S3 Storage Backend
+      #
+      # Enables use of {Amazon's Simple Storage Service}[http://aws.amazon.com/s3] as a storage mechanism
+      #
+      # == Requirements
+      #
+      # Requires the {AWS::S3 Library}[http://amazon.rubyforge.org] for S3 by Marcel Molina Jr. installed either
+      # as a gem or a as a Rails plugin.
+      #
+      # == Configuration
+      #
+      # Configuration is done via <tt>RAILS_ROOT/config/amazon_s3.yml</tt> and is loaded according to the <tt>RAILS_ENV</tt>.
+      # The minimum connection options that you must specify are a bucket name, your access key id and your secret access key.
+      # If you don't already have your access keys, all you need to sign up for the S3 service is an account at Amazon.
+      # You can sign up for S3 and get access keys by visiting http://aws.amazon.com/s3.
+      #
+      # Example configuration (RAILS_ROOT/config/amazon_s3.yml)
+      # 
+      #   development:
+      #     bucket_name: appname_development
+      #     access_key_id: <your key>
+      #     secret_access_key: <your key>
+      #   
+      #   test:
+      #     bucket_name: appname_test
+      #     access_key_id: <your key>
+      #     secret_access_key: <your key>
+      #   
+      #   production:
+      #     bucket_name: appname
+      #     access_key_id: <your key>
+      #     secret_access_key: <your key>
+      #
+      # You can change the location of the config path by passing a full path to the :s3_config_path option.
+      #
+      #   has_attachment :storage => :s3, :s3_config_path => (RAILS_ROOT + '/config/s3.yml')
+      #
+      # === Required configuration parameters
+      #
+      # * <tt>:access_key_id</tt> - The access key id for your S3 account. Provided by Amazon.
+      # * <tt>:secret_access_key</tt> - The secret access key for your S3 account. Provided by Amazon.
+      # * <tt>:bucket_name</tt> - A unique bucket name (think of the bucket_name as being like a database name).
+      #
+      # If any of these required arguments is missing, a MissingAccessKey exception will be raised from AWS::S3.
+      #
+      # == About bucket names
+      #
+      # Bucket names have to be globaly unique across the S3 system. And you can only have up to 100 of them,
+      # so it's a good idea to think of a bucket as being like a database, hence the correspondance in this
+      # implementation to the development, test, and production environments.
+      #
+      # The number of objects you can store in a bucket is, for all intents and purposes, unlimited.
+      #
+      # === Optional configuration parameters
+      #
+      # * <tt>:server</tt> - The server to make requests to. Defaults to <tt>s3.amazonaws.com</tt>.
+      # * <tt>:port</tt> - The port to the requests should be made on. Defaults to 80 or 443 if <tt>:use_ssl</tt> is set.
+      # * <tt>:use_ssl</tt> - If set to true, <tt>:port</tt> will be implicitly set to 443, unless specified otherwise. Defaults to false.
+      #
+      # == Usage
+      #
+      # To specify S3 as the storage mechanism for a model, set the acts_as_attachment <tt>:storage</tt> option to <tt>:s3</tt>.
+      #
+      #   class Photo < ActiveRecord::Base
+      #     has_attachment :storage => :s3
+      #   end
+      #
+      # === Customizing the path
+      #
+      # By default, files are prefixed using a pseudo hierarchy in the form of <tt>:table_name/:id</tt>, which results
+      # in S3 urls that look like: http(s)://:server/:bucket_name/:table_name/:id/:filename with :table_name
+      # representing the customizable portion of the path. You can customize this prefix using the <tt>:path_prefix</tt>
+      # option:
+      #
+      #   class Photo < ActiveRecord::Base
+      #     has_attachment :storage => :s3, :path_prefix => 'my/custom/path'
+      #   end
+      #
+      # Which would result in URLs like <tt>http(s)://:server/:bucket_name/my/custom/path/:id/:filename.</tt>
+      #
+      # === Permissions
+      #
+      # By default, files are stored on S3 with public access permissions. You can customize this using
+      # the <tt>:s3_access</tt> option to <tt>has_attachment</tt>. Available values are 
+      # <tt>:private</tt>, <tt>:public_read_write</tt>, and <tt>:authenticated_read</tt>.
+      #
+      # === Other options
+      #
+      # Of course, all the usual configuration options apply, such as content_type and thumbnails:
+      #
+      #   class Photo < ActiveRecord::Base
+      #     has_attachment :storage => :s3, :content_type => ['application/pdf', :image], :resize_to => 'x50'
+      #     has_attachment :storage => :s3, :thumbnails => { :thumb => [50, 50], :geometry => 'x50' }
+      #   end
+      #
+      # === Accessing S3 URLs
+      #
+      # You can get an object's URL using the s3_url accessor. For example, assuming that for your postcard app
+      # you had a bucket name like 'postcard_world_development', and an attachment model called Photo:
+      #
+      #   @postcard.s3_url # => http(s)://s3.amazonaws.com/postcard_world_development/photos/1/mexico.jpg
+      #
+      # The resulting url is in the form: http(s)://:server/:bucket_name/:table_name/:id/:file.
+      # The optional thumbnail argument will output the thumbnail's filename (if any).
+      #
+      # Additionally, you can get an object's base path relative to the bucket root using
+      # <tt>base_path</tt>:
+      #
+      #   @photo.file_base_path # => photos/1
+      #
+      # And the full path (including the filename) using <tt>full_filename</tt>:
+      #
+      #   @photo.full_filename # => photos/
+      #
+      # Niether <tt>base_path</tt> or <tt>full_filename</tt> include the bucket name as part of the path.
+      # You can retrieve the bucket name using the <tt>bucket_name</tt> method.
+      module S3Backend
+        class RequiredLibraryNotFoundError < StandardError; end
+        class ConfigFileNotFoundError < StandardError; end
+
+        def self.included(base) #:nodoc:
+          mattr_reader :bucket_name, :s3_config
+          
+          begin
+            require 'aws/s3'
+            include AWS::S3
+          rescue LoadError
+            raise RequiredLibraryNotFoundError.new('AWS::S3 could not be loaded')
+          end
+
+          begin
+            @@s3_config_path = base.attachment_options[:s3_config_path] || (RAILS_ROOT + '/config/amazon_s3.yml')
+            @@s3_config = @@s3_config = YAML.load(ERB.new(File.read(@@s3_config_path)).result)[RAILS_ENV].symbolize_keys
+          #rescue
+          #  raise ConfigFileNotFoundError.new('File %s not found' % @@s3_config_path)
+          end
+
+          @@bucket_name = s3_config[:bucket_name]
+
+          Base.establish_connection!(s3_config.slice(:access_key_id, :secret_access_key, :server, :port, :use_ssl, :persistent, :proxy))
+
+          # Bucket.create(@@bucket_name)
+
+          base.before_update :rename_file
+        end
+
+        def self.protocol
+          @protocol ||= s3_config[:use_ssl] ? 'https://' : 'http://'
+        end
+        
+        def self.hostname
+          @hostname ||= s3_config[:server] || AWS::S3::DEFAULT_HOST
+        end
+        
+        def self.port_string
+          @port_string ||= (s3_config[:port].nil? || s3_config[:port] == (s3_config[:use_ssl] ? 443 : 80)) ? '' : ":#{s3_config[:port]}"
+        end
+
+        module ClassMethods
+          def s3_protocol
+            Technoweenie::AttachmentFu::Backends::S3Backend.protocol
+          end
+          
+          def s3_hostname
+            Technoweenie::AttachmentFu::Backends::S3Backend.hostname
+          end
+          
+          def s3_port_string
+            Technoweenie::AttachmentFu::Backends::S3Backend.port_string
+          end
+        end
+
+        # Overwrites the base filename writer in order to store the old filename
+        def filename=(value)
+          @old_filename = filename unless filename.nil? || @old_filename
+          write_attribute :filename, sanitize_filename(value)
+        end
+
+        # The attachment ID used in the full path of a file
+        def attachment_path_id
+          ((respond_to?(:parent_id) && parent_id) || id).to_s
+        end
+
+        # The pseudo hierarchy containing the file relative to the bucket name
+        # Example: <tt>:table_name/:id</tt>
+        def base_path
+          File.join(attachment_options[:path_prefix], attachment_path_id)
+        end
+
+        # The full path to the file relative to the bucket name
+        # Example: <tt>:table_name/:id/:filename</tt>
+        def full_filename(thumbnail = nil)
+          File.join(base_path, thumbnail_name_for(thumbnail))
+        end
+
+        # All public objects are accessible via a GET request to the S3 servers. You can generate a 
+        # url for an object using the s3_url method.
+        #
+        #   @photo.s3_url
+        #
+        # The resulting url is in the form: <tt>http(s)://:server/:bucket_name/:table_name/:id/:file</tt> where
+        # the <tt>:server</tt> variable defaults to <tt>AWS::S3 URL::DEFAULT_HOST</tt> (s3.amazonaws.com) and can be
+        # set using the configuration parameters in <tt>RAILS_ROOT/config/amazon_s3.yml</tt>.
+        #
+        # The optional thumbnail argument will output the thumbnail's filename (if any).
+        def s3_url(thumbnail = nil)
+          File.join(s3_protocol + s3_hostname + s3_port_string, bucket_name, full_filename(thumbnail))
+        end
+        alias :public_filename :s3_url
+
+        # All private objects are accessible via an authenticated GET request to the S3 servers. You can generate an 
+        # authenticated url for an object like this:
+        #
+        #   @photo.authenticated_s3_url
+        #
+        # By default authenticated urls expire 5 minutes after they were generated.
+        #
+        # Expiration options can be specified either with an absolute time using the <tt>:expires</tt> option,
+        # or with a number of seconds relative to now with the <tt>:expires_in</tt> option:
+        #
+        #   # Absolute expiration date (October 13th, 2025)
+        #   @photo.authenticated_s3_url(:expires => Time.mktime(2025,10,13).to_i)
+        #   
+        #   # Expiration in five hours from now
+        #   @photo.authenticated_s3_url(:expires_in => 5.hours)
+        #
+        # You can specify whether the url should go over SSL with the <tt>:use_ssl</tt> option.
+        # By default, the ssl settings for the current connection will be used:
+        #
+        #   @photo.authenticated_s3_url(:use_ssl => true)
+        #
+        # Finally, the optional thumbnail argument will output the thumbnail's filename (if any):
+        #
+        #   @photo.authenticated_s3_url('thumbnail', :expires_in => 5.hours, :use_ssl => true)
+        def authenticated_s3_url(*args)
+          thumbnail = args.first.is_a?(String) ? args.first : nil
+          options   = args.last.is_a?(Hash)    ? args.last  : {}
+          S3Object.url_for(full_filename(thumbnail), bucket_name, options)
+        end
+
+        def create_temp_file
+          write_to_temp_file current_data
+        end
+
+        def current_data
+          S3Object.value full_filename, bucket_name
+        end
+
+        def s3_protocol
+          Technoweenie::AttachmentFu::Backends::S3Backend.protocol
+        end
+        
+        def s3_hostname
+          Technoweenie::AttachmentFu::Backends::S3Backend.hostname
+        end
+          
+        def s3_port_string
+          Technoweenie::AttachmentFu::Backends::S3Backend.port_string
+        end
+
+        protected
+          # Called in the after_destroy callback
+          def destroy_file
+            S3Object.delete full_filename, bucket_name
+          end
+
+          def rename_file
+            return unless @old_filename && @old_filename != filename
+            
+            old_full_filename = File.join(base_path, @old_filename)
+
+            S3Object.rename(
+              old_full_filename,
+              full_filename,
+              bucket_name,
+              :access => attachment_options[:s3_access]
+            )
+
+            @old_filename = nil
+            true
+          end
+
+          def save_to_storage
+            if save_attachment?
+              S3Object.store(
+                full_filename,
+                (temp_path ? File.open(temp_path) : temp_data),
+                bucket_name,
+                :content_type => content_type,
+                :access => attachment_options[:s3_access]
+              )
+            end
+
+            @old_filename = nil
+            true
+          end
+      end
+    end
+  end
+end

data/vendor/plugins/attachment_fu/lib/technoweenie/attachment_fu/processors/core_image_processor.rb

@@ -0,0 +1,59 @@
+require 'red_artisan/core_image/processor'
+
+module Technoweenie # :nodoc:
+  module AttachmentFu # :nodoc:
+    module Processors
+      module CoreImageProcessor
+        def self.included(base)
+          base.send :extend, ClassMethods
+          base.alias_method_chain :process_attachment, :processing
+        end
+        
+        module ClassMethods
+          def with_image(file, &block)
+            block.call OSX::CIImage.from(file)
+          end
+        end
+                
+        protected
+          def process_attachment_with_processing
+            return unless process_attachment_without_processing
+            with_image do |img|
+              self.width  = img.extent.size.width  if respond_to?(:width)
+              self.height = img.extent.size.height if respond_to?(:height)
+              resize_image_or_thumbnail! img
+              callback_with_args :after_resize, img
+            end if image?
+          end
+
+          # Performs the actual resizing operation for a thumbnail
+          def resize_image(img, size)
+            processor = ::RedArtisan::CoreImage::Processor.new(img)
+            size = size.first if size.is_a?(Array) && size.length == 1
+            if size.is_a?(Fixnum) || (size.is_a?(Array) && size.first.is_a?(Fixnum))
+              if size.is_a?(Fixnum)
+                processor.fit(size)
+              else
+                processor.resize(size[0], size[1])
+              end
+            else
+              new_size = [img.extent.size.width, img.extent.size.height] / size.to_s
+              processor.resize(new_size[0], new_size[1])
+            end
+            
+            processor.render do |result|
+              self.width  = result.extent.size.width  if respond_to?(:width)
+              self.height = result.extent.size.height if respond_to?(:height)
+              
+              # Get a new temp_path for the image before saving
+              self.temp_path = Tempfile.new(random_tempfile_filename, Technoweenie::AttachmentFu.tempfile_path).path
+              result.save self.temp_path, OSX::NSJPEGFileType
+              self.size = File.size(self.temp_path)
+            end
+          end          
+      end
+    end
+  end
+end
+
+