lipsiadmin 2.9

data/lib/data_base/attachment/geometry.rb

@@ -0,0 +1,117 @@
+module Lipsiadmin
+  module Attachment
+
+    # Defines the geometry of an image.
+    class Geometry
+      attr_accessor :height, :width, :modifier
+
+      # Gives a Geometry representing the given height and width
+      def initialize(width = nil, height = nil, modifier = nil)
+        @height = height.to_f
+        @width  = width.to_f
+        @modifier = modifier
+      end
+
+      # Uses ImageMagick to determing the dimensions of a file, passed in as either a
+      # File or path.
+      def self.from_file(file)
+        file = file.path if file.respond_to? "path"
+        geometry = begin
+                     Attachment.run("identify", %Q[-format "%wx%h" "#{file}"[0]])
+                   rescue AttachmentCommandLineError
+                     ""
+                   end
+        parse(geometry) ||
+          raise(NotIdentifiedByImageMagickError.new("#{file} is not recognized by the 'identify' command."))
+      end
+
+      # Parses a "WxH" formatted string, where W is the width and H is the height.
+      def self.parse(string)
+        if match = (string && string.match(/\b(\d*)x?(\d*)\b([\>\<\#\@\%^!])?/))
+          Geometry.new(*match[1,3])
+        end
+      end
+
+      # True if the dimensions represent a square
+      def square?
+        height == width
+      end
+
+      # True if the dimensions represent a horizontal rectangle
+      def horizontal?
+        height < width
+      end
+
+      # True if the dimensions represent a vertical rectangle
+      def vertical?
+        height > width
+      end
+
+      # The aspect ratio of the dimensions.
+      def aspect
+        width / height
+      end
+
+      # Returns the larger of the two dimensions
+      def larger
+        [height, width].max
+      end
+
+      # Returns the smaller of the two dimensions
+      def smaller
+        [height, width].min
+      end
+
+      # Returns the width and height in a format suitable to be passed to Geometry.parse
+      def to_s
+        s = ""
+        s << width.to_i.to_s if width > 0
+        s << "x#{height.to_i}" if height > 0
+        s << modifier.to_s
+        s
+      end
+
+      # Same as to_s
+      def inspect
+        to_s
+      end
+
+      # Returns the scaling and cropping geometries (in string-based ImageMagick format) 
+      # neccessary to transform this Geometry into the Geometry given. If crop is true, 
+      # then it is assumed the destination Geometry will be the exact final resolution. 
+      # In this case, the source Geometry is scaled so that an image containing the 
+      # destination Geometry would be completely filled by the source image, and any 
+      # overhanging image would be cropped. Useful for square thumbnail images. The cropping 
+      # is weighted at the center of the Geometry.
+      def transformation_to(dst, crop = false)
+        if crop
+          ratio = Geometry.new( dst.width / self.width, dst.height / self.height )
+          scale_geometry, scale = scaling(dst, ratio)
+          crop_geometry         = cropping(dst, ratio, scale)
+        else
+          scale_geometry        = dst.to_s
+        end
+
+        [ scale_geometry, crop_geometry ]
+      end
+
+      private
+
+      def scaling(dst, ratio)
+        if ratio.horizontal? || ratio.square?
+          [ "%dx" % dst.width, ratio.width ]
+        else
+          [ "x%d" % dst.height, ratio.height ]
+        end
+      end
+
+      def cropping(dst, ratio, scale)
+        if ratio.horizontal? || ratio.square?
+          "%dx%d+%d+%d" % [ dst.width, dst.height, 0, (self.height * scale - dst.height) / 2 ]
+        else
+          "%dx%d+%d+%d" % [ dst.width, dst.height, (self.width * scale - dst.width) / 2, 0 ]
+        end
+      end
+    end
+  end
+end

data/lib/data_base/attachment/iostream.rb

@@ -0,0 +1,62 @@
+module Lipsiadmin
+  module Attachment
+    # Provides method that can be included on File-type objects (IO, StringIO, Tempfile, etc) to allow stream copying
+    # and Tempfile conversion.
+    module IOStream
+
+      # Returns a Tempfile containing the contents of the readable object.
+      def to_tempfile
+        tempfile = Tempfile.new("stream")
+        tempfile.binmode
+        self.stream_to(tempfile)
+      end
+
+      # Copies one read-able object from one place to another in blocks, obviating the need to load
+      # the whole thing into memory. Defaults to 8k blocks. If this module is included in both
+      # StringIO and Tempfile, then either can have its data copied anywhere else without typing
+      # worries or memory overhead worries. Returns a File if a String is passed in as the destination
+      # and returns the IO or Tempfile as passed in if one is sent as the destination.
+      def stream_to(path_or_file, in_blocks_of = 8192)
+        dstio = case path_or_file
+                when String   then File.new(path_or_file, "wb+")
+                when IO       then path_or_file
+                when Tempfile then path_or_file
+                end
+        buffer = ""
+        self.rewind
+        while self.read(in_blocks_of, buffer) do
+          dstio.write(buffer)
+        end
+        dstio.rewind    
+        dstio
+      end
+    end
+  end
+end
+
+class IO #:nodoc:
+  include Lipsiadmin::Attachment::IOStream
+end
+
+%w( Tempfile StringIO ).each do |klass|
+  if Object.const_defined? klass
+    Object.const_get(klass).class_eval do
+      include Lipsiadmin::Attachment::IOStream
+    end
+  end
+end
+
+# Corrects a bug in Windows when asking for Tempfile size.
+if defined? Tempfile
+  class Tempfile#:nodoc:
+    def size
+      if @tmpfile
+        @tmpfile.fsync
+        @tmpfile.flush
+        @tmpfile.stat.size
+      else
+        0
+      end
+    end
+  end
+end

data/lib/data_base/attachment/processor.rb

@@ -0,0 +1,49 @@
+module Lipsiadmin
+  module Attachment
+    # Attachment processors allow you to modify attached files when they are
+    # attached in any way you are able. Attachment itself uses command-line
+    # programs for its included Thumbnail processor, but custom processors
+    # are not required to follow suit.
+    #
+    # Processors are required to be defined inside the Attachment module and
+    # are also required to be a subclass of Attachment::Processor. There are
+    # only two methods you must implement to properly be a subclass: 
+    # #initialize and #make. Initialize's arguments are the file that will
+    # be operated on (which is an instance of File), and a hash of options
+    # that were defined in has_attached_file's style hash.
+    #
+    # All #make needs to do is return an instance of File (Tempfile is
+    # acceptable) which contains the results of the processing.
+    #
+    # See Attachment.run for more information about using command-line
+    # utilities from within Processors.
+    class Processor
+      attr_accessor :file, :options
+
+      def initialize(file, options = {})
+        @file = file
+        @options = options
+      end
+
+      def make
+      end
+
+      def self.make(file, options = {})
+        new(file, options).make
+      end
+    end
+
+    # Due to how ImageMagick handles its image format conversion and how Tempfile
+    # handles its naming scheme, it is necessary to override how Tempfile makes
+    # its names so as to allow for file extensions. Idea taken from the comments
+    # on this blog post:
+    # http://marsorange.com/archives/of-mogrify-ruby-tempfile-dynamic-class-definitions
+    class Tempfile < ::Tempfile
+      # Replaces Tempfile's +make_tmpname+ with one that honors file extensions.
+      def make_tmpname(basename, n)
+        extension = File.extname(basename)
+        sprintf("%s,%d,%d%s", File.basename(basename, extension), $$, n, extension)
+      end
+    end
+  end
+end

data/lib/data_base/attachment/storage.rb

@@ -0,0 +1,223 @@
+module Lipsiadmin
+  module Attachment
+    module Storage
+
+      # The default place to store attachments is in the filesystem. Files on the local
+      # filesystem can be very easily served by Apache without requiring a hit to your app.
+      # They also can be processed more easily after they've been saved, as they're just
+      # normal files. There is one Filesystem-specific option for has_attached_file.
+      # * +path+: The location of the repository of attachments on disk. This can (and, in
+      #   almost all cases, should) be coordinated with the value of the +url+ option to
+      #   allow files to be saved into a place where Apache can serve them without
+      #   hitting your app. Defaults to 
+      #   ":rails_root/public/:attachment/:id/:style/:basename.:extension"
+      #   By default this places the files in the app's public directory which can be served 
+      #   directly. If you are using capistrano for deployment, a good idea would be to 
+      #   make a symlink to the capistrano-created system directory from inside your app's 
+      #   public directory.
+      #   See Attachment::Attachment#interpolate for more information on variable interpolaton.
+      #     :path => "/var/app/attachments/:class/:id/:style/:basename.:extension"
+      module Filesystem
+        def self.extended base
+        end
+
+        def exists?(style = default_style)
+          if original_filename
+            File.exist?(path(style))
+          else
+            false
+          end
+        end
+
+        # Returns representation of the data of the file assigned to the given
+        # style, in the format most representative of the current storage.
+        def to_file(style = default_style)
+          @queued_for_write[style] || (File.new(path(style), 'rb') if exists?(style))
+        end
+        alias_method :to_io, :to_file
+
+        def flush_writes #:nodoc:
+          logger.info("[Attachment] Writing files for #{name}")
+          @queued_for_write.each do |style, file|
+            file.close
+            logger.info "[Attachment] Directory for file is #{File.dirname(path(style))}"
+            FileUtils.mkdir_p(File.dirname(path(style)))
+            logger.info("[Attachment] -> #{path(style)}")
+            FileUtils.mv(file.path, path(style))
+            FileUtils.chmod(0644, path(style))
+          end
+          @queued_for_write = {}
+        end
+
+        def flush_deletes #:nodoc:
+          logger.info("[Attachment] Deleting files for #{name}")
+          @queued_for_delete.each do |path|
+            begin
+              logger.info("[Attachment] -> #{path}")
+              FileUtils.rm(path) if File.exist?(path)
+            rescue Errno::ENOENT => e
+              # ignore file-not-found, let everything else pass
+            end
+            begin
+              while(true)
+                path = File.dirname(path)
+                FileUtils.rmdir(path)
+              end
+            rescue Errno::ENOTEMPTY, Errno::ENOENT, Errno::EINVAL, Errno::ENOTDIR
+              # Stop trying to remove parent directories
+            rescue SystemCallError => e
+              logger.info("[Attachment] There was an unexpected error while deleting directories: #{e.class}")
+              # Ignore it
+            end
+          end
+          @queued_for_delete = []
+        end
+      end
+
+      # Amazon's S3 file hosting service is a scalable, easy place to store files for
+      # distribution. You can find out more about it at http://aws.amazon.com/s3
+      # There are a few S3-specific options for has_attached_file:
+      # * +s3_credentials+: Takes a path, a File, or a Hash. The path (or File) must point
+      #   to a YAML file containing the +access_key_id+ and +secret_access_key+ that Amazon
+      #   gives you. You can 'environment-space' this just like you do to your
+      #   database.yml file, so different environments can use different accounts:
+      #     development:
+      #       access_key_id: 123...
+      #       secret_access_key: 123... 
+      #     test:
+      #       access_key_id: abc...
+      #       secret_access_key: abc... 
+      #     production:
+      #       access_key_id: 456...
+      #       secret_access_key: 456... 
+      #   This is not required, however, and the file may simply look like this:
+      #     access_key_id: 456...
+      #     secret_access_key: 456... 
+      #   In which case, those access keys will be used in all environments. You can also
+      #   put your bucket name in this file, instead of adding it to the code directly.
+      #   This is useful when you want the same account but a different bucket for 
+      #   development versus production.
+      # * +s3_permissions+: This is a String that should be one of the "canned" access
+      #   policies that S3 provides (more information can be found here:
+      #   http://docs.amazonwebservices.com/AmazonS3/2006-03-01/RESTAccessPolicy.html#RESTCannedAccessPolicies)
+      #   The default for Attachment is "public-read".
+      # * +s3_protocol+: The protocol for the URLs generated to your S3 assets. Can be either 
+      #   'http' or 'https'. Defaults to 'http' when your :s3_permissions are 'public-read' (the
+      #   default), and 'https' when your :s3_permissions are anything else.
+      # * +s3_headers+: A hash of headers such as {'Expires' => 1.year.from_now.httpdate}
+      # * +bucket+: This is the name of the S3 bucket that will store your files. Remember
+      #   that the bucket must be unique across all of Amazon S3. If the bucket does not exist
+      #   Attachment will attempt to create it. The bucket name will not be interpolated.
+      # * +url+: There are two options for the S3 url. You can choose to have the bucket's name
+      #   placed domain-style (bucket.s3.amazonaws.com) or path-style (s3.amazonaws.com/bucket).
+      #   Normally, this won't matter in the slightest and you can leave the default (which is
+      #   path-style, or :s3_path_url). But in some cases paths don't work and you need to use
+      #   the domain-style (:s3_domain_url). Anything else here will be treated like path-style.
+      # * +path+: This is the key under the bucket in which the file will be stored. The
+      #   URL will be constructed from the bucket and the path. This is what you will want
+      #   to interpolate. Keys should be unique, like filenames, and despite the fact that
+      #   S3 (strictly speaking) does not support directories, you can still use a / to
+      #   separate parts of your file name.
+      module S3
+        def self.extended base
+          require 'right_aws'
+          base.instance_eval do
+            @s3_credentials = parse_credentials(@options[:s3_credentials])
+            @bucket         = @options[:bucket]         || @s3_credentials[:bucket]
+            @s3_options     = @options[:s3_options]     || {}
+            @s3_permissions = @options[:s3_permissions] || 'public-read'
+            @s3_protocol    = @options[:s3_protocol]    || (@s3_permissions == 'public-read' ? 'http' : 'https')
+            @s3_headers     = @options[:s3_headers]     || {}
+            @url            = ":s3_path_url" unless @url.to_s.match(/^:s3.*url$/)
+          end
+          base.class.interpolations[:s3_path_url] = lambda do |attachment, style|
+            "#{attachment.s3_protocol}://s3.amazonaws.com/#{attachment.bucket_name}/#{attachment.path(style).gsub(%r{^/}, "")}"
+          end
+          base.class.interpolations[:s3_domain_url] = lambda do |attachment, style|
+            "#{attachment.s3_protocol}://#{attachment.bucket_name}.s3.amazonaws.com/#{attachment.path(style).gsub(%r{^/}, "")}"
+          end
+          ActiveRecord::Base.logger.info("[Attachment] S3 Storage Initalized.")
+        end
+
+        def s3
+          @s3 ||= RightAws::S3.new(@s3_credentials[:access_key_id],
+                                   @s3_credentials[:secret_access_key],
+                                   @s3_options)
+        end
+
+        def s3_bucket
+          @s3_bucket ||= s3.bucket(@bucket, true, @s3_permissions)
+        end
+
+        def bucket_name
+          @bucket
+        end
+
+        def parse_credentials(creds)
+          creds = find_credentials(creds).stringify_keys
+          (creds[ENV['RAILS_ENV']] || creds).symbolize_keys
+        end
+
+        def exists?(style = default_style)
+          s3_bucket.key(path(style)) ? true : false
+        end
+
+        def s3_protocol
+          @s3_protocol
+        end
+
+        # Returns representation of the data of the file assigned to the given
+        # style, in the format most representative of the current storage.
+        def to_file(style = default_style)
+          @queued_for_write[style] || s3_bucket.key(path(style))
+        end
+        alias_method :to_io, :to_file
+
+        def flush_writes #:nodoc:
+          logger.info("[Attachment] Writing files for #{name}")
+          @queued_for_write.each do |style, file|
+            begin
+              logger.info("[Attachment] -> #{path(style)}")
+              key = s3_bucket.key(path(style))
+              key.data = file
+              key.put(nil, @s3_permissions, {'Content-type' => instance_read(:content_type)}.merge(@s3_headers))
+            rescue RightAws::AwsError => e
+              raise
+            end
+          end
+          @queued_for_write = {}
+        end
+
+        def flush_deletes #:nodoc:
+          logger.info("[Attachment] Writing files for #{name}")
+          @queued_for_delete.each do |path|
+            begin
+              logger.info("[Attachment] -> #{path}")
+              if file = s3_bucket.key(path)
+                file.delete
+              end
+            rescue RightAws::AwsError
+              # Ignore this.
+            end
+          end
+          @queued_for_delete = []
+        end
+
+        def find_credentials(creds)
+          case creds
+          when File:
+            YAML.load_file(creds.path)
+          when String:
+            YAML.load_file(creds)
+          when Hash:
+            creds
+          else
+            raise ArgumentError, "Credentials are not a path, file, or hash."
+          end
+        end
+        private :find_credentials
+
+      end
+    end
+  end
+end