ncri_attachment_fu 0.1.8

data/lib/technoweenie/attachment_fu/processors.rb

@@ -0,0 +1 @@
+

data/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
+              temp_paths.unshift 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
+
+

data/lib/technoweenie/attachment_fu/processors/gd2_processor.rb

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'gd2'
+module Technoweenie # :nodoc:
+  module AttachmentFu # :nodoc:
+    module Processors
+      module Gd2Processor
+        def self.included(base)
+          base.send :extend, ClassMethods
+          base.alias_method_chain :process_attachment, :processing
+        end
+        
+        module ClassMethods
+          # Yields a block containing a GD2 Image for the given binary data.
+          def with_image(file, &block)
+            im = GD2::Image.import(file)
+            block.call(im)
+          end
+        end
+
+        protected
+          def process_attachment_with_processing
+            return unless process_attachment_without_processing && image?
+            with_image do |img|
+              resize_image_or_thumbnail! img
+              self.width  = img.width
+              self.height = img.height
+              callback_with_args :after_resize, img
+            end
+          end
+
+          # Performs the actual resizing operation for a thumbnail
+          def resize_image(img, size)
+            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)
+                # Borrowed from image science's #thumbnail method and adapted 
+                # for this.
+                scale = size.to_f / (img.width > img.height ? img.width.to_f : img.height.to_f)
+                img.resize!((img.width * scale).round(1), (img.height * scale).round(1), false)
+              else
+                img.resize!(size.first, size.last, false) 
+              end
+            else
+              w, h = [img.width, img.height] / size.to_s
+              img.resize!(w, h, false)
+            end
+            temp_paths.unshift random_tempfile_filename
+            self.size = img.export(self.temp_path)
+          end
+
+      end
+    end
+  end
+end

data/lib/technoweenie/attachment_fu/processors/image_science_processor.rb

@@ -0,0 +1,61 @@
+require 'image_science'
+module Technoweenie # :nodoc:
+  module AttachmentFu # :nodoc:
+    module Processors
+      module ImageScienceProcessor
+        def self.included(base)
+          base.send :extend, ClassMethods
+          base.alias_method_chain :process_attachment, :processing
+        end
+
+        module ClassMethods
+          # Yields a block containing an Image Science image for the given binary data.
+          def with_image(file, &block)
+            ::ImageScience.with_image file, &block
+          end
+        end
+
+        protected
+          def process_attachment_with_processing
+            return unless process_attachment_without_processing && image?
+            with_image do |img|
+              self.width  = img.width  if respond_to?(:width)
+              self.height = img.height if respond_to?(:height)
+              resize_image_or_thumbnail! img
+            end
+          end
+
+          # Performs the actual resizing operation for a thumbnail
+          def resize_image(img, size)
+            # create a dummy temp file to write to
+            # ImageScience doesn't handle all gifs properly, so it converts them to
+            # pngs for thumbnails.  It has something to do with trying to save gifs
+            # with a larger palette than 256 colors, which is all the gif format
+            # supports.
+            filename.sub! /gif$/, 'png'
+            content_type.sub!(/gif$/, 'png')
+            temp_paths.unshift write_to_temp_file(filename)
+            grab_dimensions = lambda do |img|
+              self.width  = img.width  if respond_to?(:width)
+              self.height = img.height if respond_to?(:height)
+              img.save self.temp_path
+              self.size = File.size(self.temp_path)
+              callback_with_args :after_resize, img
+            end
+
+            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)
+                img.thumbnail(size, &grab_dimensions)
+              else
+                img.resize(size[0], size[1], &grab_dimensions)
+              end
+            else
+              new_size = [img.width, img.height] / size.to_s
+              img.resize(new_size[0], new_size[1], &grab_dimensions)
+            end
+          end
+      end
+    end
+  end
+end

data/lib/technoweenie/attachment_fu/processors/mini_magick_processor.rb

@@ -0,0 +1,132 @@
+require 'mini_magick'
+module Technoweenie # :nodoc:
+  module AttachmentFu # :nodoc:
+    module Processors
+      module MiniMagickProcessor
+        def self.included(base)
+          base.send :extend, ClassMethods
+          base.alias_method_chain :process_attachment, :processing
+        end
+ 
+        module ClassMethods
+          # Yields a block containing an MiniMagick Image for the given binary data.
+          def with_image(file, &block)
+            begin
+              binary_data = file.is_a?(MiniMagick::Image) ? file : MiniMagick::Image.from_file(file) unless !Object.const_defined?(:MiniMagick)
+            rescue
+              # Log the failure to load the image.
+              logger.debug("Exception working with image: #{$!}")
+              binary_data = nil
+            end
+            block.call binary_data if block && binary_data
+          ensure
+            !binary_data.nil?
+          end
+        end
+ 
+      protected
+        def process_attachment_with_processing
+          return unless process_attachment_without_processing
+          with_image do |img|
+            resize_image_or_thumbnail! img
+            self.width = img[:width] if respond_to?(:width)
+            self.height = img[:height] if respond_to?(:height)
+            callback_with_args :after_resize, img
+          end if image?
+        end
+ 
+        # Performs the actual resizing operation for a thumbnail
+        def resize_image(img, size)
+          size = size.first if size.is_a?(Array) && size.length == 1
+          img.combine_options do |commands|
+            commands.strip unless attachment_options[:keep_profile]
+
+            # gif are not handled correct, this is a hack, but it seems to work.
+            if img.output =~ / GIF /
+              img.format("png")
+            end           
+            
+            if size.is_a?(Fixnum) || (size.is_a?(Array) && size.first.is_a?(Fixnum))
+              if size.is_a?(Fixnum)
+                size = [size, size]
+                commands.resize(size.join('x'))
+              else
+                commands.resize(size.join('x') + '!')
+              end
+            # extend to thumbnail size
+            elsif size.is_a?(String) and size =~ /e$/
+              size = size.gsub(/e/, '')
+              commands.resize(size.to_s + '>')
+              commands.background('#ffffff')
+              commands.gravity('center')
+              commands.extent(size)
+            # crop thumbnail, the smart way
+            elsif size.is_a?(String) and size =~ /c$/
+               size = size.gsub(/c/, '')
+              
+              # calculate sizes and aspect ratio
+              thumb_width, thumb_height = size.split("x")
+              thumb_width   = thumb_width.to_f
+              thumb_height  = thumb_height.to_f
+              
+              thumb_aspect = thumb_width.to_f / thumb_height.to_f
+              image_width, image_height = img[:width].to_f, img[:height].to_f
+              image_aspect = image_width / image_height
+              
+              # only crop if image is not smaller in both dimensions
+              unless image_width < thumb_width and image_height < thumb_height
+                command = calculate_offset(image_width,image_height,image_aspect,thumb_width,thumb_height,thumb_aspect)
+
+                # crop image
+                commands.extract(command)
+              end
+
+              # don not resize if image is not as height or width then thumbnail
+              if image_width < thumb_width or image_height < thumb_height                   
+                  commands.background('#ffffff')
+                  commands.gravity('center')
+                  commands.extent(size)
+              # resize image
+              else
+                commands.resize("#{size.to_s}")
+              end
+            # crop end
+            else
+              commands.resize(size.to_s)
+            end
+          end
+          temp_paths.unshift img
+        end
+
+        def calculate_offset(image_width,image_height,image_aspect,thumb_width,thumb_height,thumb_aspect)
+        # only crop if image is not smaller in both dimensions
+
+          # special cases, image smaller in one dimension then thumbsize
+          if image_width < thumb_width
+            offset = (image_height / 2) - (thumb_height / 2)
+            command = "#{image_width}x#{thumb_height}+0+#{offset}"
+          elsif image_height < thumb_height
+            offset = (image_width / 2) - (thumb_width / 2)
+            command = "#{thumb_width}x#{image_height}+#{offset}+0"
+
+          # normal thumbnail generation
+          # calculate height and offset y, width is fixed                 
+          elsif (image_aspect <= thumb_aspect or image_width < thumb_width) and image_height > thumb_height
+            height = image_width / thumb_aspect
+            offset = (image_height / 2) - (height / 2)
+            command = "#{image_width}x#{height}+0+#{offset}"
+          # calculate width and offset x, height is fixed
+          else
+            width = image_height * thumb_aspect
+            offset = (image_width / 2) - (width / 2)
+            command = "#{width}x#{image_height}+#{offset}+0"
+          end
+          # crop image
+          command
+        end
+
+
+      end
+    end
+  end
+end

data/lib/technoweenie/attachment_fu/processors/rmagick_processor.rb

@@ -0,0 +1,57 @@
+require 'RMagick' unless defined?(Magick)
+module Technoweenie # :nodoc:
+  module AttachmentFu # :nodoc:
+    module Processors
+      module RmagickProcessor
+        def self.included(base)
+          base.send :extend, ClassMethods
+          base.alias_method_chain :process_attachment, :processing
+        end
+
+        module ClassMethods
+          # Yields a block containing an RMagick Image for the given binary data.
+          def with_image(file, &block)
+            begin
+              binary_data = file.is_a?(Magick::Image) ? file : Magick::Image.read(file).first unless !Object.const_defined?(:Magick)
+            rescue
+              # Log the failure to load the image.  This should match ::Magick::ImageMagickError
+              # but that would cause acts_as_attachment to require rmagick.
+              logger.debug("Exception working with image: #{$!}")
+              binary_data = nil
+            end
+            block.call binary_data if block && binary_data
+          ensure
+            !binary_data.nil?
+          end
+        end
+
+      protected
+        def process_attachment_with_processing
+          return unless process_attachment_without_processing
+          with_image do |img|
+            resize_image_or_thumbnail! img
+            self.width  = img.columns if respond_to?(:width)
+            self.height = img.rows    if respond_to?(:height)
+            callback_with_args :after_resize, img
+          end if image?
+        end
+
+        # Performs the actual resizing operation for a thumbnail
+        def resize_image(img, size)
+          size = size.first if size.is_a?(Array) && size.length == 1 && !size.first.is_a?(Fixnum)
+          if size.is_a?(Fixnum) || (size.is_a?(Array) && size.first.is_a?(Fixnum))
+            size = [size, size] if size.is_a?(Fixnum)
+            img.thumbnail!(*size)
+          elsif size.is_a?(String) && size =~ /^c.*$/ # Image cropping - example geometry string: c75x75
+            dimensions = size[1..size.size].split("x")
+            img.crop_resized!(dimensions[0].to_i, dimensions[1].to_i)
+          else
+            img.change_geometry(size.to_s) { |cols, rows, image| image.resize!(cols<1 ? 1 : cols, rows<1 ? 1 : rows) }
+          end
+          img.strip! unless attachment_options[:keep_profile]
+          temp_paths.unshift write_to_temp_file(img.to_blob)
+        end
+      end
+    end
+  end
+end

data/rackspace_cloudfiles.yml.tpl

@@ -0,0 +1,14 @@
+development:
+    container_name: appname_development
+    username:
+    api_key: 
+
+test:
+    container_name: appname_test
+    username: 
+    api_key: 
+
+production:
+    container_name: appname_production
+    username: 
+    api_key: 

data/rails/install.rb

@@ -0,0 +1,7 @@
+require 'fileutils'
+
+s3_config = File.dirname(__FILE__) + '/../../../config/amazon_s3.yml'
+FileUtils.cp File.dirname(__FILE__) + '/amazon_s3.yml.tpl', s3_config unless File.exist?(s3_config)
+cloudfiles_config = File.dirname(__FILE__) + '/../../../config/rackspace_cloudfiles.yml'
+FileUtils.cp File.dirname(__FILE__) + '/rackspace_cloudfiles.yml.tpl', cloudfiles_config unless File.exist?(cloudfiles_config)
+puts IO.read(File.join(File.dirname(__FILE__), 'README'))

data/vendor/red_artisan/core_image/filters/color.rb

@@ -0,0 +1,27 @@
+module RedArtisan
+  module CoreImage
+    module Filters
+      module Color
+        
+        def greyscale(color = nil, intensity = 1.00)
+          create_core_image_context(@original.extent.size.width, @original.extent.size.height)
+          
+          color = OSX::CIColor.colorWithString("1.0 1.0 1.0 1.0") unless color
+          
+          @original.color_monochrome :inputColor => color, :inputIntensity => intensity do |greyscale|
+            @target = greyscale
+          end
+        end
+        
+        def sepia(intensity = 1.00)
+          create_core_image_context(@original.extent.size.width, @original.extent.size.height)
+          
+          @original.sepia_tone :inputIntensity => intensity do |sepia|
+            @target = sepia
+          end
+        end
+        
+      end
+    end
+  end
+end

data/vendor/red_artisan/core_image/filters/effects.rb

@@ -0,0 +1,31 @@
+module RedArtisan
+  module CoreImage
+    module Filters
+      module Effects
+        
+        def spotlight(position, points_at, brightness, concentration, color)
+          create_core_image_context(@original.extent.size.width, @original.extent.size.height)
+          
+          @original.spot_light :inputLightPosition => vector3(*position), :inputLightPointsAt => vector3(*points_at), 
+                               :inputBrightness => brightness, :inputConcentration => concentration, :inputColor => color do |spot|
+            @target = spot
+          end
+        end
+        
+        def edges(intensity = 1.00)
+          create_core_image_context(@original.extent.size.width, @original.extent.size.height)
+          
+          @original.edges :inputIntensity => intensity do |edged|
+            @target = edged
+          end
+        end
+        
+        private
+        
+          def vector3(x, y, w)
+            OSX::CIVector.vectorWithX_Y_Z(x, y, w)
+          end
+      end
+    end
+  end
+end