parlement 0.2 → 0.3

data/vendor/plugins/file_column/test/magick_test.rb

@@ -0,0 +1,251 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+require 'RMagick'
+require File.dirname(__FILE__) + '/fixtures/entry'
+
+
+class AbstractRMagickTest < Test::Unit::TestCase
+  def teardown
+    FileUtils.rm_rf File.dirname(__FILE__)+"/public/entry/"
+  end
+
+  def test_truth
+    assert true
+  end
+
+  private
+
+  def read_image(path)
+    Magick::Image::read(path).first
+  end
+
+  def assert_max_image_size(img, s)
+    assert img.columns <= s, "img has #{img.columns} columns, expected: #{s}"
+    assert img.rows <= s, "img has #{img.rows} rows, expected: #{s}"
+    assert_equal s, [img.columns, img.rows].max
+  end
+end
+
+class RMagickSimpleTest < AbstractRMagickTest
+  def setup
+    Entry.file_column :image, :magick => { :geometry => "100x100" }
+  end
+
+  def test_simple_resize_without_save
+    e = Entry.new
+    e.image = upload("kerb.jpg")
+    
+    img = read_image(e.image)
+    assert_max_image_size img, 100
+  end
+
+  def test_simple_resize_with_save
+    e = Entry.new
+    e.image = upload("kerb.jpg")
+    assert e.save
+    e.reload
+    
+    img = read_image(e.image)
+    assert_max_image_size img, 100
+  end
+
+  def test_resize_on_saved_image
+    Entry.file_column :image, :magick => { :geometry => "100x100" }
+    
+    e = Entry.new
+    e.image = upload("skanthak.png")
+    assert e.save
+    e.reload
+    old_path = e.image
+    
+    e.image = upload("kerb.jpg")
+    assert e.save
+    assert "kerb.jpg", File.basename(e.image)
+    assert !File.exists?(old_path), "old image '#{old_path}' still exists"
+
+    img = read_image(e.image)
+    assert_max_image_size img, 100
+  end
+
+  def test_invalid_image
+    e = Entry.new
+    assert_nothing_raised { e.image = upload("invalid-image.jpg") }
+    assert !e.valid?
+  end
+
+  def test_serializable
+    e = Entry.new
+    e.image = upload("skanthak.png")
+    assert_nothing_raised {
+      flash = Marshal.dump(e)
+      e = Marshal.load(flash)
+    }
+    assert File.exists?(e.image)
+  end
+
+  def test_imagemagick_still_usable
+    e = Entry.new
+    assert_nothing_raised {
+      img = e.load_image_with_rmagick(file_path("skanthak.png"))
+      assert img.kind_of?(Magick::Image)
+    }
+  end
+end
+
+class RMagickVersionsTest < AbstractRMagickTest
+  def setup
+    Entry.file_column :image, :magick => {:geometry => "200x200",
+      :versions => {
+        :thumb => "50x50",
+        :medium => {:geometry => "100x100", :name => "100_100"},
+        :large => {:geometry => "150x150", :lazy => true}
+      }
+    }
+  end
+
+
+  def test_should_create_thumb
+    e = Entry.new("image" => upload("skanthak.png"))
+    
+    assert File.exists?(e.image("thumb")), "thumb-nail not created"
+    
+    assert_max_image_size read_image(e.image("thumb")), 50
+  end
+
+  def test_version_name_can_be_different_from_key
+    e = Entry.new("image" => upload("skanthak.png"))
+    
+    assert File.exists?(e.image("100_100"))
+    assert !File.exists?(e.image("medium"))
+  end
+
+  def test_should_not_create_lazy_versions
+    e = Entry.new("image" => upload("skanthak.png"))
+    assert !File.exists?(e.image("large")), "lazy versions should not be created unless needed"
+  end
+
+  def test_should_create_lazy_version_on_demand
+    e = Entry.new("image" => upload("skanthak.png"))
+    
+    e.send(:image_state).create_magick_version_if_needed(:large)
+    
+    assert File.exists?(e.image("large")), "lazy version should be created on demand"
+    
+    assert_max_image_size read_image(e.image("large")), 150
+  end
+
+  def test_generated_name_should_not_change
+    e = Entry.new("image" => upload("skanthak.png"))
+    
+    name1 = e.send(:image_state).create_magick_version_if_needed("50x50")
+    name2 = e.send(:image_state).create_magick_version_if_needed("50x50")
+    name3 = e.send(:image_state).create_magick_version_if_needed(:geometry => "50x50")
+    assert_equal name1, name2, "hash value has changed"
+    assert_equal name1, name3, "hash value has changed"
+  end
+
+  def test_should_create_version_with_string
+    e = Entry.new("image" => upload("skanthak.png"))
+    
+    name = e.send(:image_state).create_magick_version_if_needed("32x32")
+    
+    assert File.exists?(e.image(name))
+
+    assert_max_image_size read_image(e.image(name)), 32
+  end
+
+  def test_should_create_safe_auto_id
+    e = Entry.new("image" => upload("skanthak.png"))
+
+    name = e.send(:image_state).create_magick_version_if_needed("32x32")
+
+    assert_match /^[a-zA-Z0-9]+$/, name
+  end
+end
+
+class RMagickCroppingTest < AbstractRMagickTest
+  def setup
+    Entry.file_column :image, :magick => {:geometry => "200x200",
+      :versions => {
+        :thumb => {:crop => "1:1", :geometry => "50x50"}
+      }
+    }
+  end
+  
+  def test_should_crop_image_on_upload
+    e = Entry.new("image" => upload("skanthak.png"))
+    
+    img = read_image(e.image("thumb"))
+    
+    assert_equal 50, img.rows 
+    assert_equal 50, img.columns
+  end
+    
+end
+
+class UrlForImageColumnTest < AbstractRMagickTest
+  include FileColumnHelper
+
+  def setup
+    Entry.file_column :image, :magick => {
+      :versions => {:thumb => "50x50"} 
+    }
+    @request = RequestMock.new
+  end
+    
+  def test_should_use_version_on_symbol_option
+    e = Entry.new(:image => upload("skanthak.png"))
+    
+    url = url_for_image_column(e, "image", :thumb)
+    assert_match %r{^/entry/image/tmp/.+/thumb/skanthak.png$}, url
+  end
+
+  def test_should_use_string_as_size
+    e = Entry.new(:image => upload("skanthak.png"))
+
+    url = url_for_image_column(e, "image", "50x50")
+    
+    assert_match %r{^/entry/image/tmp/.+/.+/skanthak.png$}, url
+    
+    url =~ /\/([^\/]+)\/skanthak.png$/
+    dirname = $1
+    
+    assert_max_image_size read_image(e.image(dirname)), 50
+  end
+
+  def test_should_accept_version_hash
+    e = Entry.new(:image => upload("skanthak.png"))
+
+    url = url_for_image_column(e, "image", :size => "50x50", :crop => "1:1", :name => "small")
+
+    assert_match %r{^/entry/image/tmp/.+/small/skanthak.png$}, url
+
+    img = read_image(e.image("small"))
+    assert_equal 50, img.rows
+    assert_equal 50, img.columns
+  end
+end
+
+class RMagickPermissionsTest < AbstractRMagickTest
+  def setup
+    Entry.file_column :image, :magick => {:geometry => "200x200",
+      :versions => {
+        :thumb => {:crop => "1:1", :geometry => "50x50"}
+      }
+    }, :permissions => 0616
+  end
+  
+  def check_permissions(e)
+    assert_equal 0616, (File.stat(e.image).mode & 0777)
+    assert_equal 0616, (File.stat(e.image("thumb")).mode & 0777)
+  end
+
+  def test_permissions_with_rmagick
+    e = Entry.new(:image => upload("skanthak.png"))
+    
+    check_permissions e
+
+    assert e.save
+
+    check_permissions e
+  end
+end

data/vendor/plugins/file_column/test/magick_view_only_test.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/abstract_unit'
+require File.dirname(__FILE__) + '/fixtures/entry'
+
+class RMagickViewOnlyTest < Test::Unit::TestCase
+  include FileColumnHelper
+
+  def setup
+    Entry.file_column :image
+    @request = RequestMock.new
+  end
+
+  def teardown
+    FileUtils.rm_rf File.dirname(__FILE__)+"/public/entry/"
+  end
+
+  def test_url_for_image_column_without_model_versions
+    e = Entry.new(:image => upload("skanthak.png"))
+    
+    assert_nothing_raised { url_for_image_column e, "image", "50x50" }
+  end
+end

data/vendor/plugins/guid/README.TXT

@@ -0,0 +1,19 @@
+ This plugin for ActiveRecord makes the "ID" field into a URL-safe GUID
+# It is a mashup by Andy Singleton <andy@assembla.com> that includes 
+# * the UUID class from Bob Aman.
+# * the plugin skeleton from Demetrius Nunes
+# * the 22 character URL-safe format from Andy Singleton
+# You can get standard 36 char UUID formats instead
+# TODO: Auto-detect a character ID field and use a GUID in this case (DRY principle)
+# 
+# This library is free software; you can redistribute it and/or modify it
+# under the terms of the MIT license.
+# 
+# TO USE
+# Install as a plugin in the rails directory vendor/plugin/guid
+# define ID as char(22)
+# call "usesguid" in ActiveRecord class declaration, like
+# class Mymodel < ActiveRecord::Base
+#	usesguid			
+#
+# if your ID field is not called "ID", call "usesguid :column =>'IdColumnName' "

data/vendor/plugins/guid/init.rb

@@ -0,0 +1,23 @@
+# Copyright (c) 2005 Assembla, Inc.
+#
+# This plugin for ActiveRecord makes the "ID" field into a URL-safe GUID
+# It is a mashup by Andy Singleton <andy@assembla.com> that includes 
+# * the UUID class from Bob Aman.
+# * the plugin skeleton from Demetrius Nunes
+# * the 22 character URL-safe format from Andy Singleton
+# You can get standard 36 char UUID formats instead
+# TODO: Auto-detect a character ID field and use a GUID in this case (DRY principle)
+# 
+# This library is free software; you can redistribute it and/or modify it
+# under the terms of the MIT license.
+# 
+# TO USE
+# Install as a plugin in the rails directory vendor/plugin/guid
+# define ID as char(22)
+# call "usesguid" in ActiveRecord class declaration, like
+# class Mymodel < ActiveRecord::Base
+#	usesguid			
+#
+# if your ID field is not called "ID", call "usesguid :column =>'IdColumnName' "
+
+require 'usesguid'

data/vendor/plugins/guid/lib/usesguid.rb

@@ -0,0 +1,37 @@
+# from Demetrio Nunes
+# Modified by Andy Singleton to use different GUID generator
+#
+# MIT License
+
+require 'uuid22'
+
+module ActiveRecord
+  module Usesguid #:nodoc:
+  
+    def self.append_features(base)
+      super
+      base.extend(ClassMethods)  
+    end
+
+    
+    module ClassMethods
+      
+      def usesguid(options = {})
+                
+        class_eval do
+          set_primary_key options[:column] if options[:column]
+          
+          def after_initialize
+            self.id ||= UUID.timestamp_create().to_s22
+          end
+        end        
+        
+      end
+      
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  include ActiveRecord::Usesguid
+end

data/vendor/plugins/guid/lib/uuid22.rb

@@ -0,0 +1,43 @@
+# Copyright (c) 2005 Assembla, Inc.
+# MIT License
+
+require 'uuidtools'
+
+class UUID
+
+  # Make an array of 64 URL-safe characters
+  @@chars64=('a'..'z').to_a + ('A'..'Z').to_a + ('0'..'9').to_a + ['-','_']
+    #return a 22 byte URL-safe string, encoded six bits at a time using 64 characters
+  def to_s22
+  	integer=self.to_i
+  	rval=''
+    22.times do
+      c=(integer & 0x3F)
+      rval+=@@chars64[c]
+      integer =integer >> 6
+    end
+    return rval.reverse
+  end
+  	# Create a new UUID from a 22char string
+  def self.parse22(s)
+    	# get the integer representation
+    integer=0
+    s.each_byte {|c|
+    	integer = integer << 6
+      pos=@@chars64.index(c.chr)
+      integer+=pos
+    }
+
+    time_low = (integer >> 96) & 0xFFFFFFFF
+    time_mid = (integer >> 80) & 0xFFFF
+    time_hi_and_version = (integer >> 64) & 0xFFFF
+    clock_seq_hi_and_reserved = (integer >> 56) & 0xFF
+    clock_seq_low = (integer >> 48) & 0xFF
+    nodes = []
+    for i in 0..5 do
+      nodes << ((integer >> (40 - (i * 8))) & 0xFF)
+    end
+    return new(time_low, time_mid, time_hi_and_version,
+      clock_seq_hi_and_reserved, clock_seq_low, nodes)
+  end	
+end