tvdeyen-fleximage 1.0.5

data/CHANGELOG.rdoc

@@ -0,0 +1,14 @@
+== fleximage 1.0.2 12-14-2009
+
+* Don't prepend Rails.root to absolute image directory path
+* Added support for an "image_format" magic database column
+* Fixed an issue with saving temp images in Windows
+* Fixed a temp image vulnerability with directory traversal
+
+== fleximage 1.0.1 12-13-2009
+
+* Now with completely passing tests
+
+== fleximage 1.0.0 12-13-2009
+
+* Initial gem release.

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 [name of plugin creator]
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,36 @@
+For all istructions refers to git://github.com/Squeegy/fleximage.
+I add a rails3_view.rb to manage template in rails3.
+
+#rails3_view.rb
+
+module ActionView
+  module TemplateHandlers
+    class Rails3View < TemplateHandler
+      include Compilable
+      class TemplateDidNotReturnImage < RuntimeError #:nodoc:
+      end
+
+      def compile(template)
+        <<-CODE
+        @template_format = :flexi
+        controller.response.content_type ||= Mime::JPG    
+        result = #{template.source}
+        requested_format = (params[:format] || :jpg).to_sym
+        begin
+          # Raise an error if object returned from template is not an image record
+          unless result.class.include?(Fleximage::Model::InstanceMethods)
+            raise TemplateDidNotReturnImage, ".flexi template was expected to return a model instance that acts_as_fleximage, but got an instance of instead."
+          end
+          # Figure out the proper format
+          raise 'Image must be requested with an image type format.  jpg, gif and png only are supported.' unless [:jpg, :gif, :png].include?(requested_format)
+          result.output_image(:format => requested_format)
+        rescue Exception => e
+          e
+        end
+        CODE
+      ensure
+        GC.start
+      end
+    end
+  end
+end

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rubygems'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the fleximage plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/unit/**/*_test.rb'
+  t.verbose = true
+end
+
+
+desc 'Generate documentation for the fleximage plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Fleximage'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "tvdeyen-fleximage"
+    gem.summary = <<EOF
+Rails plugin for uploading images as resources, with support for resizing, text
+stamping, and other special effects.
+EOF
+    gem.description = <<EOF
+Fleximage is a Rails plugin that tries to make image uploading and rendering
+super easy.
+EOF
+    gem.email = "tvdeyen@gmail.com"
+    gem.homepage = "http://github.com/tvdeyen/fleximage"
+    gem.authors = `git log --pretty=format:"%an"`.split("\n").uniq.sort
+    gem.add_dependency "rmagick"
+    gem.add_dependency "aws-s3"
+    gem.add_development_dependency "rails", ">=3.0.0"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available."
+  puts "Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.5

data/autotest.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby -wKU
+$stdout.sync = true
+IO.popen('rstakeout "rake test" lib/fleximage/* lib/fleximage/**/* test/unit/*') do |f|
+  puts f.gets until f.eof?
+end

data/init.rb

@@ -0,0 +1 @@
+require File.expand_path(File.join(File.dirname(__FILE__), %w(lib fleximage)))

data/lib/dsl_accessor.rb

@@ -0,0 +1,52 @@
+require 'active_support' unless defined?(ActiveSupport)
+
+class Class
+  def dsl_accessor(name, options = {})
+    raise TypeError, "DSL Error: options should be a hash. but got `#{options.class}'" unless options.is_a?(Hash)
+    writer = options[:writer] || options[:setter]
+    writer =
+      case writer
+      when NilClass then Proc.new{|value| value}
+      when Symbol   then Proc.new{|value| __send__(writer, value)}
+      when Proc     then writer
+      else raise TypeError, "DSL Error: writer should be a symbol or proc. but got `#{options[:writer].class}'"
+      end
+    write_inheritable_attribute(:"#{name}_writer", writer)
+
+    default =
+      case options[:default]
+      when NilClass then nil
+      when []       then Proc.new{[]}
+      when {}       then Proc.new{{}}
+      when Symbol   then Proc.new{__send__(options[:default])}
+      when Proc     then options[:default]
+      else Proc.new{options[:default]}
+      end
+    write_inheritable_attribute(:"#{name}_default", default)
+
+    self.class.class_eval do
+      define_method("#{name}=") do |value|
+        writer = read_inheritable_attribute(:"#{name}_writer")
+        value  = writer.call(value) if writer
+        write_inheritable_attribute(:"#{name}", value)
+      end
+
+      define_method(name) do |*values|
+        if values.empty?
+          # getter method
+          key = :"#{name}"
+          if !inheritable_attributes.has_key?(key)
+            default = read_inheritable_attribute(:"#{name}_default")
+            value   = default ? default.call(self) : nil
+            __send__("#{name}=", value)
+          end
+          read_inheritable_attribute(key)
+        else
+          # setter method
+          __send__("#{name}=", *values)
+        end
+      end
+    end
+  end
+end
+

data/lib/fleximage.rb

@@ -0,0 +1,59 @@
+require 'open-uri'
+require 'base64'
+require 'digest/sha1'
+require 'aws/s3'
+
+require 'RMagick' unless defined?(Magick)
+
+# Apply a few RMagick patches
+require 'fleximage/rmagick_image_patch'
+
+# Load dsl_accessor from lib
+require 'dsl_accessor'
+
+# Load Operators
+require 'fleximage/operator/base'
+Dir.entries("#{File.dirname(__FILE__)}/fleximage/operator").each do |filename|
+  require "fleximage/operator/#{filename.gsub('.rb', '')}" if filename =~ /\.rb$/
+end
+
+# Setup Model
+require 'fleximage/model'
+ActiveRecord::Base.class_eval { include Fleximage::Model }
+
+# Image Creation
+require 'fleximage/blank'
+
+# Image Proxy
+require 'fleximage/image_proxy'
+
+# Setup View
+#ActionController::Base.exempt_from_layout :flexi
+if defined?(ActionView::Template)
+  # Rails >= 2.1
+  if Rails.version.to_f >= 3 
+    require 'fleximage/rails3_view'
+    ActionView::Template.register_template_handler :flexi, ActionView::TemplateHandlers::Rails3View
+  else
+    require 'fleximage/view'
+    ActionView::Template.register_template_handler :flexi, Fleximage::View
+  end
+else
+  # Rails < 2.1
+  require 'fleximage/legacy_view'
+  ActionView::Base.register_template_handler :flexi, Fleximage::LegacyView
+end
+
+# Setup Helper
+require 'fleximage/helper'
+ActionView::Base.class_eval { include Fleximage::Helper }
+
+# Setup Aviary Controller
+require 'fleximage/aviary_controller'
+ActionController::Base.class_eval{ include Fleximage::AviaryController }
+
+# Register mime types
+Mime::Type.register_alias "image/pjpeg", :jpg # IE6 sends jpg data as "image/pjpeg".  Silly IE6.
+Mime::Type.register "image/jpeg", :jpg
+Mime::Type.register "image/gif", :gif
+Mime::Type.register "image/png", :png

data/lib/fleximage/aviary_controller.rb

@@ -0,0 +1,75 @@
+module Fleximage
+  
+  module AviaryController
+    def self.api_key(value = nil)
+      value ? @api_key = value : @api_key
+    end
+    
+    def self.api_key=(value = nil)
+      api_key value
+    end
+    
+    # Include acts_as_fleximage class method
+    def self.included(base) #:nodoc:
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      
+      # Invoke this method to enable this controller to allow editing of images via Aviary
+      def editable_in_aviary(model_class, options = {})
+        unless options.has_key?(:secret)
+          raise ArgumentError, ":secret key in options is required.\nExample: editable_in_aviary(Photo, :secret => \"My-deep-dark-secret\")"
+        end
+        
+        # Don't verify authenticity for aviary callback
+        protect_from_forgery :except => :aviary_image_update 
+        
+        # Include the necesary instance methods
+        include Fleximage::AviaryController::InstanceMethods
+        
+        # Add before_filter to secure aviary actions
+        before_filter :aviary_image_security, :only => [:aviary_image, :aviary_image_update]
+        
+        # Allow the view access to the image hash generation method
+        helper_method :aviary_image_hash
+        
+        # Save the Fleximage model class
+        model_class = model_class.constantize if model_class.is_a?(String)
+        dsl_accessor :aviary_model_class, :default => model_class
+        dsl_accessor :aviary_secret, :default => options[:secret]
+      end
+      
+    end
+    
+    module InstanceMethods
+      
+      # Deliver the master image to aviary
+      def aviary_image
+        render :text => @model.load_image.to_blob,
+               :content_type => Mime::Type.lookup_by_extension(self.class.aviary_model_class.image_storage_format.to_s)
+      end
+      
+      # Aviary posts the edited image back to the controller here
+      def aviary_image_update
+        @model.image_file_url = params[:imageurl]
+        @model.save
+        render :text => 'Image Updated From Aviary'
+      end
+      
+      protected
+        def aviary_image_hash(model)
+          Digest::SHA1.hexdigest("fleximage-aviary-#{model.id}-#{model.created_at}-#{self.class.aviary_secret}")
+        end
+        
+        def aviary_image_security
+          @model = self.class.aviary_model_class.find(params[:id])
+          unless aviary_image_hash(@model) == params[:key]
+            render :text => '<h1>403 Not Authorized</h1>', :status => '403'
+          end
+        end
+      
+    end
+  end
+  
+end

data/lib/fleximage/blank.rb

@@ -0,0 +1,70 @@
+module Fleximage
+  
+  # The +Blank+ class allows easy creation of dynamic images for views which depends models that
+  # do not store images.  For example, perhaps you want a rendering of a text label, or a comment,
+  # or some other type of data that is not inherently image based.
+  #
+  # Your model doesn't need to know anything about Fleximage.  You can instantiate and operate on
+  # a new Fleximage::Blank object right in your view.
+  #
+  # Usage:
+  # 
+  #   Fleximage::Blank.new(size, options = {}).operate { |image| ... }
+  #
+  # Use the following keys in the +options+ hash:
+  #
+  # * color: the color the image will be.  Can be a named color or a Magick::Pixel object.
+  #   
+  # Example:
+  #
+  #   # app/views/comments/show.png.flexi
+  #   Fleximage::Blank.new('400x150')).operate do |image|
+  #     # Start with a chat bubble image as the background
+  #     image.image_overlay('public/images/comment_bubble.png')
+  #     
+  #     # Assuming that the user model acts_as_fleximage, this will draw the users image.
+  #     image.image_overlay(@comment.user.file_path,
+  #       :size => '50x50',
+  #       :alignment => :top_left,
+  #       :offset => '10x10'
+  #     )
+  #     
+  #     # Add the author name text
+  #     image.text(@comment.author,
+  #       :alignment => :top_left,
+  #       :offset => '10x10',
+  #       :color => 'black',
+  #       :font_size => 24,
+  #       :shadow => {
+  #         :blur => 1,
+  #         :opacity => 0.5,
+  #       }
+  #     )
+  #     
+  #     # Add the comment body text
+  #     image.text(@comment.body, 
+  #       :alignment => :top_left,
+  #       :offset => '10x90',
+  #       :color => color(128, 128, 128),
+  #       :font_size => 14
+  #     )
+  #   end
+  class Blank
+    include Fleximage::Model
+    acts_as_fleximage
+    
+    def initialize(size, options = {})
+      width, height = Fleximage::Operator::Base.size_to_xy(size)
+      
+      @uploaded_image = Magick::Image.new(width, height) do
+        self.colorspace = Magick::RGBColorspace
+        self.depth      = 8
+        self.density    = '72'
+        self.format     = 'PNG'
+        self.background_color = options[:color] || 'none'
+      end
+      
+      @output_image = @uploaded_image
+    end
+  end
+end

data/lib/fleximage/helper.rb

@@ -0,0 +1,41 @@
+module Fleximage
+  module Helper
+    
+    # Creates an image tag that links directly to image data.  Recommended for displays of a
+    # temporary upload that is not saved to a record in the databse yet.
+    def embedded_image_tag(model, options = {})
+      model.load_image
+      format  = options[:format] || :jpg
+      mime    = Mime::Type.lookup_by_extension(format.to_s).to_s
+      image   = model.output_image(:format => format)
+      data    = Base64.encode64(image)
+      
+      options = { :alt => model.class.to_s }.merge(options)
+      
+      result = image_tag("data:#{mime};base64,#{data}", options)
+      result.gsub(%r{src=".*/images/data:}, 'src="data:')
+      
+    rescue Fleximage::Model::MasterImageNotFound => e
+      nil
+    end
+    
+    # Creates a link that opens an image for editing in Aviary.
+    #
+    # Options:
+    # 
+    # * image_url: url to the master image used by Aviary for editing.  Defauls to <tt>url_for(:action => 'aviary_image', :id => model, :only_path => false)</tt>
+    # * post_url:  url where Aviary will post the updated image.  Defauls to <tt>url_for(:action => 'aviary_image_update', :id => model, :only_path => false)</tt>
+    #
+    # All other options are passed directly to the @link_to@ helper.
+    def link_to_edit_in_aviary(text, model, options = {})
+      key       = aviary_image_hash(model)
+      image_url = options.delete(:image_url)        || url_for(:action => 'aviary_image',        :id => model, :only_path => false, :key => key)
+      post_url  = options.delete(:image_update_url) || url_for(:action => 'aviary_image_update', :id => model, :only_path => false, :key => key)
+      api_key   = Fleximage::AviaryController.api_key
+      url       = "http://aviary.com/flash/aviary/index.aspx?tid=1&phoenix&apil=#{api_key}&loadurl=#{CGI.escape image_url}&posturl=#{CGI.escape post_url}"
+      
+      link_to text, url, { :target => 'aviary' }.merge(options)
+    end
+    
+  end
+end

data/lib/fleximage/image_proxy.rb

@@ -0,0 +1,69 @@
+module Fleximage
+  
+  # An instance of this class is yielded when Model#operate is called.  It enables image operators
+  # to be called to transform the image.  You should never need to directly deal with this class.
+  # You simply call image operators on this object when inside an Model#operate block
+  #
+  #   @photo.operate do |image|
+  #     image.resize '640x480'
+  #   end
+  #
+  # In this example, +image+ is an instance of ImageProxy
+  class ImageProxy
+    
+    class OperatorNotFound < NameError #:nodoc:
+    end
+    
+    # The image to be manipulated by operators.
+    attr_accessor :image
+    
+    # Create a new image operator proxy.
+    def initialize(image, model_obj)
+      @image = image
+      @model = model_obj
+    end
+
+    # Shortcut for accessing current image width
+    def width
+      @image.columns
+    end
+
+    # Shortcut for accessing current image height
+    def height
+      @image.rows
+    end
+    
+    # A call to an unknown method will look for an Operator by that method's name.
+    # If it finds one, it will execute that operator.
+    def method_missing(method_name, *args)
+      # Find the operator class
+      class_name = method_name.to_s.camelcase
+      operator_class = "Fleximage::Operator::#{class_name}".constantize
+      
+      # Define a method for this operator so future calls to this operation are faster
+      self.class.module_eval <<-EOF
+        def #{method_name}(*args)
+          @image = execute_operator(#{operator_class}, *args)
+        end
+      EOF
+      
+      # Call the method that was just defined to perform its functionality.
+      send(method_name, *args)
+    
+    rescue NameError => e
+      if e.to_s =~ /uninitialized constant Fleximage::Operator::#{class_name}/
+        raise OperatorNotFound, "No operator Fleximage::Operator::#{class_name} found for the method \"#{method_name}\""
+      else
+        raise e
+      end
+    end
+    
+    private
+      # Instantiate and execute the requested image Operator.
+      def execute_operator(operator_class, *args)
+        operator_class.new(self, @image, @model).execute(*args)
+      end
+    
+  end
+  
+end