dragonfly 0.8.6 → 0.9.0

data/Gemfile.rails.2.3.5

@@ -1,20 +0,0 @@
-source :rubygems
-
-group :development, :test, :cucumber do
-  gem 'capybara'
-  gem 'cucumber', '0.8.5'
-  gem 'cucumber-rails'
-  gem 'database_cleaner', '>= 0.5.0'
-  gem 'gherkin', '2.1.4'
-  gem 'nokogiri', '1.5.0.beta.2'
-  gem 'rack-cache', :require => nil
-  gem 'rails', '2.3.5', :require => nil
-  gem 'rspec', '~> 1.3'
-  if RUBY_PLATFORM == "java"
-    gem "jdbc-sqlite3"
-    gem "activerecord-jdbcsqlite3-adapter"
-    gem "jruby-openssl"
-  else
-    gem 'sqlite3-ruby', '1.3.0' # 1.3.1 segfaults on Ruby 1.9.2
-  end
-end

data/features/3.0.3.feature

@@ -1,8 +0,0 @@
-Feature: champion uses dragonfly in his Rails 3.0.3 application
-  In order to be a champion
-  A user uses dragonfly in his Rails 3.0.3 application
-
-  Scenario: Set up dragonfly using initializer
-    Given a Rails 3.0.3 application set up for using dragonfly
-    Then the manage_album_images cucumber features in my Rails 3.0.3 app should pass
-    And the text_images cucumber features in my Rails 3.0.3 app should pass

data/features/rails_2.3.5.feature

@@ -1,7 +0,0 @@
-Feature: champion uses dragonfly in his Rails 2.3.5 application
-  In order to be a champion
-  A user uses dragonfly in his Rails 2.3.5 application
-
-  Scenario: Set up dragonfly using the provided initializer
-    Given a Rails 2.3.5 application set up for using dragonfly
-    Then the manage_album_images cucumber features in my Rails 2.3.5 app should pass

data/fixtures/files/app/models/album.rb

@@ -1,3 +0,0 @@
-class Album < ActiveRecord::Base
-  image_accessor :cover_image
-end

data/fixtures/files/app/views/albums/new.html.erb

@@ -1,4 +0,0 @@
-<% form_for @album, :html => {:multipart => true} do |f| %>
-  <%= f.file_field :cover_image %>
-  <%= f.submit :value => 'Create' %>
-<% end %>

data/fixtures/files/features/manage_album_images.feature

@@ -1,12 +0,0 @@
-Feature: champion adds cover images to his albums
-  In order to be a champion
-  A user adds an image to his album
-
-  Scenario: Add and view image
-    When I go to the new album page
-    And I attach the file "../../../samples/beach.png" to "album[cover_image]"
-    And I press "Create"
-    Then I should see "successfully created"
-    And I should see "Look at this cover image!"
-    When I look at the generated beach image
-    And I should see a PNG image of size 200x100

data/fixtures/rails_2.3.5/template.rb

@@ -1,10 +0,0 @@
-gem 'rack-cache', :lib => 'rack/cache'
-gem 'cucumber'
-generate 'cucumber'
-
-generate 'scaffold albums cover_image_uid: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}/** ."

data/lib/dragonfly/analysis/r_magick_analyser.rb

@@ -1,63 +0,0 @@
-require 'RMagick'
-
-module Dragonfly
-  module Analysis
-    class RMagickAnalyser
-
-      include RMagickUtils
-      include Configurable
-
-      configurable_attr :use_filesystem, true
-
-      def width(temp_object)
-        ping_rmagick_image(temp_object) do |image|
-          image.columns
-        end
-      end
-
-      def height(temp_object)
-        ping_rmagick_image(temp_object) do |image|
-          image.rows
-        end
-      end
-
-      def aspect_ratio(temp_object)
-        ping_rmagick_image(temp_object) do |image|
-          image.columns.to_f / image.rows
-        end
-      end
-
-      def portrait?(temp_object)
-        ping_rmagick_image(temp_object) do |image|
-          image.columns <= image.rows
-        end
-      end
-
-      def landscape?(temp_object)
-        ping_rmagick_image(temp_object) do |image|
-          image.columns >= image.rows
-        end
-      end
-
-      def depth(temp_object)
-        rmagick_image(temp_object) do |image|
-          image.depth
-        end
-      end
-
-      def number_of_colours(temp_object)
-        rmagick_image(temp_object) do |image|
-          image.number_colors
-        end
-      end
-      alias number_of_colors number_of_colours
-
-      def format(temp_object)
-        ping_rmagick_image(temp_object) do |image|
-          image.format.downcase.to_sym
-        end
-      end
-
-    end
-  end
-end

data/lib/dragonfly/config/r_magick.rb

@@ -1,46 +0,0 @@
-module Dragonfly
-  module Config
-
-    # RMagick is a saved configuration for Dragonfly apps, which does the following:
-    # - registers an rmagick analyser
-    # - registers an rmagick processor
-    # - registers an rmagick encoder
-    # - adds thumb shortcuts like '280x140!', etc.
-    # Look at the source code for apply_configuration to see exactly how it configures the app.
-    module RMagick
-
-      def self.apply_configuration(app, opts={})
-        use_filesystem = opts.has_key?(:use_filesystem) ? opts[:use_filesystem] : true
-        app.configure do |c|
-          c.analyser.register(Analysis::RMagickAnalyser) do |a|
-            a.use_filesystem = use_filesystem
-          end
-          c.processor.register(Processing::RMagickProcessor) do |p|
-            p.use_filesystem = use_filesystem
-          end
-          c.encoder.register(Encoding::RMagickEncoder) do |e|
-            e.use_filesystem = use_filesystem
-          end
-          c.generator.register(Generation::RMagickGenerator) do |g|
-            g.use_filesystem = use_filesystem
-          end
-          c.job :thumb do |geometry, format|
-            process :thumb, geometry
-            encode format if format
-          end
-          c.job :gif do
-            encode :gif
-          end
-          c.job :jpg do
-            encode :jpg
-          end
-          c.job :png do
-            encode :png
-          end
-        end
-
-      end
-
-    end
-  end
-end

data/lib/dragonfly/generation/hash_with_css_style_keys.rb

@@ -1,23 +0,0 @@
-module Dragonfly
-  module Generation
-    
-    # HashWithCssStyleKeys is solely for being able to access a hash
-    # which has css-style keys (e.g. 'font-size') with the underscore
-    # symbol version
-    # @example
-    #   opts = {'font-size' => '23px', :color => 'white'}
-    #   opts = HashWithCssStyleKeys[opts]
-    #   opts[:font_size]   # ===> '23px'
-    #   opts[:color]       # ===> 'white'
-    class HashWithCssStyleKeys < Hash
-      def [](key)
-        super || (
-          str_key = key.to_s
-          css_key = str_key.gsub('_','-')
-          super(str_key) || super(css_key) || super(css_key.to_sym)
-        )
-      end
-    end
-
-  end
-end

data/lib/dragonfly/generation/r_magick_generator.rb

@@ -1,155 +0,0 @@
-require 'RMagick'
-
-module Dragonfly
-  module Generation
-    class RMagickGenerator
-
-      FONT_STYLES = {
-        'normal' => Magick::NormalStyle,
-        'italic' => Magick::ItalicStyle,
-        'oblique' => Magick::ObliqueStyle
-      }
-
-      FONT_STRETCHES = {
-        'normal'          => Magick::NormalStretch,
-        'semi-condensed'  => Magick::SemiCondensedStretch,
-        'condensed'       => Magick::CondensedStretch,
-        'extra-condensed' => Magick::ExtraCondensedStretch,
-        'ultra-condensed' => Magick::UltraCondensedStretch,
-        'semi-expanded'   => Magick::SemiExpandedStretch,
-        'expanded'        => Magick::ExpandedStretch,
-        'extra-expanded'  => Magick::ExtraExpandedStretch,
-        'ultra-expanded'  => Magick::UltraExpandedStretch
-      }
-
-      FONT_WEIGHTS = {
-        'normal'  => Magick::NormalWeight,
-        'bold'    => Magick::BoldWeight,
-        'bolder'  => Magick::BolderWeight,
-        'lighter' => Magick::LighterWeight,
-        '100'     => 100,
-        '200'     => 200,
-        '300'     => 300,
-        '400'     => 400,
-        '500'     => 500,
-        '600'     => 600,
-        '700'     => 700,
-        '800'     => 800,
-        '900'     => 900
-      }
-
-      include RMagickUtils
-      include Configurable
-      configurable_attr :use_filesystem, true
-
-      def plasma(width, height, format='png')
-        image = Magick::Image.read("plasma:fractal"){self.size = "#{width}x#{height}"}.first
-        image.format = format.to_s
-        content = use_filesystem ? write_to_tempfile(image) : image.to_blob
-        image.destroy!
-        [
-          content,
-          {:format => format.to_sym, :name => "plasma.#{format}"}
-        ]
-      end
-
-      def text(text_string, opts={})
-        opts = HashWithCssStyleKeys[opts]
-
-        draw = Magick::Draw.new
-        draw.gravity = Magick::CenterGravity
-        draw.text_antialias = true
-
-        # Font size
-        font_size = (opts[:font_size] || 12).to_i
-
-        # Scale up the text for better quality -
-        #  it will be reshrunk at the end
-        s = scale_factor_for(font_size)
-
-        # Settings
-        draw.pointsize    = font_size * s
-        draw.font         = opts[:font] if opts[:font]
-        draw.font_family  = opts[:font_family] if opts[:font_family]
-        draw.fill         = opts[:color] if opts[:color]
-        draw.stroke       = opts[:stroke_color] if opts[:stroke_color]
-        draw.font_style   = FONT_STYLES[opts[:font_style]] if opts[:font_style]
-        draw.font_stretch = FONT_STRETCHES[opts[:font_stretch]] if opts[:font_stretch]
-        draw.font_weight  = FONT_WEIGHTS[opts[:font_weight]] if opts[:font_weight]
-
-        # Padding
-        # NB the values are scaled up by the scale factor
-        pt, pr, pb, pl = parse_padding_string(opts[:padding]) if opts[:padding]
-        padding_top    = (opts[:padding_top]    || pt || 0) * s
-        padding_right  = (opts[:padding_right]  || pr || 0) * s
-        padding_bottom = (opts[:padding_bottom] || pb || 0) * s
-        padding_left   = (opts[:padding_left]   || pl || 0) * s
-
-        # Calculate (scaled up) dimensions
-        metrics = draw.get_type_metrics(text_string)
-        width, height = metrics.width, metrics.height
-
-        scaled_up_width = padding_left + width + padding_right
-        scaled_up_height = padding_top + height + padding_bottom
-
-        # Draw the background
-        image = Magick::Image.new(scaled_up_width, scaled_up_height){
-          self.background_color = opts[:background_color] || 'transparent'
-        }
-        # Draw the text
-        draw.annotate(image, width, height, padding_left, padding_top, text_string)
-
-        # Scale back down again
-        image.scale!(1/s)
-
-        format = opts[:format] || :png
-        image.format = format.to_s
-
-        # Output image either as a string or a tempfile
-        content = use_filesystem ? write_to_tempfile(image) : image.to_blob
-        image.destroy!
-        [
-          content,
-          {:format => format, :name => "text.#{format}"}
-        ]
-      end
-
-      private
-
-      # Use css-style padding declaration, i.e.
-      # 10        (all sides)
-      # 10 5      (top/bottom, left/right)
-      # 10 5 10   (top, left/right, bottom)
-      # 10 5 10 5 (top, right, bottom, left)
-      def parse_padding_string(str)
-        padding_parts = str.gsub('px','').split(/\s+/).map{|px| px.to_i}
-        case padding_parts.size
-        when 1
-          p = padding_parts.first
-          [p,p,p,p]
-        when 2
-          p,q = padding_parts
-          [p,q,p,q]
-        when 3
-          p,q,r = padding_parts
-          [p,q,r,q]
-        when 4
-          padding_parts
-        else raise ArgumentError, "Couldn't parse padding string '#{str}' - should be a css-style string"
-        end
-      end
-
-      def scale_factor_for(font_size)
-        # Scale approximately to 64 if below
-        min_size = 64
-        if font_size < min_size
-          (min_size.to_f / font_size).ceil
-        else
-          1
-        end.to_f
-      end
-
-    end
-
-  end
-end

data/lib/dragonfly/processing/r_magick_processor.rb

@@ -1,126 +0,0 @@
-require 'RMagick'
-
-module Dragonfly
-  module Processing
-    class RMagickProcessor
-
-      GRAVITIES = {
-        'nw' => Magick::NorthWestGravity,
-        'n'  => Magick::NorthGravity,
-        'ne' => Magick::NorthEastGravity,
-        'w'  => Magick::WestGravity,
-        'c'  => Magick::CenterGravity,
-        'e'  => Magick::EastGravity,
-        'sw' => Magick::SouthWestGravity,
-        's'  => Magick::SouthGravity,
-        'se' => Magick::SouthEastGravity
-      }
-
-      # Geometry string patterns
-      RESIZE_GEOMETRY         = /^\d*x\d*[><%^!]?$|^\d+@$/ # e.g. '300x200!'
-      CROPPED_RESIZE_GEOMETRY = /^(\d+)x(\d+)#(\w{1,2})?$/ # e.g. '20x50#ne'
-      CROP_GEOMETRY           = /^(\d+)x(\d+)([+-]\d+)?([+-]\d+)?(\w{1,2})?$/ # e.g. '30x30+10+10'
-      THUMB_GEOMETRY = Regexp.union RESIZE_GEOMETRY, CROPPED_RESIZE_GEOMETRY, CROP_GEOMETRY
-
-      include RMagickUtils
-      include Configurable
-      
-      configurable_attr :use_filesystem, true
-
-      def crop(temp_object, opts={})
-        x       = opts[:x].to_i
-        y       = opts[:y].to_i
-        gravity = GRAVITIES[opts[:gravity]] || Magick::ForgetGravity
-        width   = opts[:width].to_i
-        height  = opts[:height].to_i
-
-        rmagick_image(temp_object) do |image|
-          # RMagick throws an error if the cropping area is bigger than the image,
-          # when the gravity is something other than nw
-          width  = image.columns - x if x + width  > image.columns
-          height = image.rows    - y if y + height > image.rows
-          image.crop(gravity, x, y, width, height)
-        end
-      end
-
-      def flip(temp_object)
-        rmagick_image(temp_object) do |image|
-          image.flip!
-        end
-      end
-
-      def flop(temp_object)
-        rmagick_image(temp_object) do |image|
-          image.flop!
-        end
-      end
-
-      def greyscale(temp_object, opts={})
-        depth = opts[:depth] || 256
-        rmagick_image(temp_object) do |image|
-          image.quantize(depth, Magick::GRAYColorspace)
-        end
-      end
-      alias grayscale greyscale
-
-      def resize(temp_object, geometry)
-        rmagick_image(temp_object) do |image|
-          image.change_geometry!(geometry) do |cols, rows, img|
-           img.resize!(cols, rows)
-          end
-        end
-      end
-
-      def resize_and_crop(temp_object, opts={})
-        rmagick_image(temp_object) do |image|
-
-          width   = opts[:width] ? opts[:width].to_i : image.columns
-          height  = opts[:height] ? opts[:height].to_i : image.rows
-          gravity = GRAVITIES[opts[:gravity]] || Magick::CenterGravity
-
-          image.crop_resized(width, height, gravity)
-        end
-      end
-
-      def rotate(temp_object, amount, opts={})
-        args = [amount.to_f]
-        args << opts[:qualifier] if opts[:qualifier]
-        rmagick_image(temp_object) do |image|
-          image.background_color = opts[:background_colour] if opts[:background_colour]
-          image.background_color = opts[:background_color] if opts[:background_color]
-          image.rotate(*args) || temp_object
-        end
-      end
-
-      def thumb(temp_object, geometry)
-        case geometry
-        when RESIZE_GEOMETRY
-          resize(temp_object, geometry)
-        when CROPPED_RESIZE_GEOMETRY
-          resize_and_crop(temp_object, :width => $1, :height => $2, :gravity => $3)
-        when CROP_GEOMETRY
-          crop(temp_object,
-            :width => $1,
-            :height => $2,
-            :x => $3,
-            :y => $4,
-            :gravity => $5
-          )
-        else raise ArgumentError, "Didn't recognise the geometry string #{geometry}"
-        end
-      end
-
-      def vignette(temp_object, opts={})
-        x      = opts[:x].to_f      || temp_object.width  * 0.1
-        y      = opts[:y].to_f      || temp_object.height * 0.1
-        radius = opts[:radius].to_f ||  0.0
-        sigma  = opts[:sigma].to_f  || 10.0
-
-        rmagick_image(temp_object) do |image|
-          image.vignette(x, y, radius, sigma)
-        end
-      end
-
-    end
-  end
-end