fleximage 1.0.0

data/test/rails_root/public/robots.txt

@@ -0,0 +1,5 @@
+# See http://www.robotstxt.org/wc/norobots.html for documentation on how to use the robots.txt file
+#
+# To ban all spiders from the entire site uncomment the next two lines:
+# User-Agent: *
+# Disallow: /

data/test/rails_root/public/stylesheets/scaffold.css

@@ -0,0 +1,74 @@
+body { background-color: #fff; color: #333; }
+
+body, p, ol, ul, td {
+  font-family: verdana, arial, helvetica, sans-serif;
+  font-size:   13px;
+  line-height: 18px;
+}
+
+pre {
+  background-color: #eee;
+  padding: 10px;
+  font-size: 11px;
+}
+
+a { color: #000; }
+a:visited { color: #666; }
+a:hover { color: #fff; background-color:#000; }
+
+.fieldWithErrors {
+  padding: 2px;
+  background-color: red;
+  display: table;
+}
+
+#errorExplanation {
+  width: 400px;
+  border: 2px solid red;
+  padding: 7px;
+  padding-bottom: 12px;
+  margin-bottom: 20px;
+  background-color: #f0f0f0;
+}
+
+#errorExplanation h2 {
+  text-align: left;
+  font-weight: bold;
+  padding: 5px 5px 5px 15px;
+  font-size: 12px;
+  margin: -7px;
+  background-color: #c00;
+  color: #fff;
+}
+
+#errorExplanation p {
+  color: #333;
+  margin-bottom: 0;
+  padding: 5px;
+}
+
+#errorExplanation ul li {
+  font-size: 12px;
+  list-style: square;
+}
+
+div.uploadStatus {
+  margin: 5px;
+}
+
+div.progressBar {
+  margin: 5px;
+}
+
+div.progressBar div.border {
+  background-color: #fff;
+  border: 1px solid gray;
+  width: 100%;
+}
+
+div.progressBar div.background {
+  background-color: #333;
+  height: 18px;
+  width: 0%;
+}
+

data/test/rails_root/vendor/plugins/fleximage/init.rb

@@ -0,0 +1,2 @@
+init_path = "#{RAILS_ROOT}/../../init.rb"
+silence_warnings { eval(IO.read(init_path), binding, init_path) }

data/test/test_helper.rb

@@ -0,0 +1,81 @@
+# Load the environment
+ENV['RAILS_ENV'] ||= 'test'
+require File.dirname(__FILE__) + '/rails_root/config/environment.rb'
+ 
+# Load the testing framework
+require 'test_help'
+silence_warnings { RAILS_ENV = ENV['RAILS_ENV'] }
+ 
+# Run the migrations
+ActiveRecord::Migrator.migrate("#{RAILS_ROOT}/db/migrate")
+ 
+# Setup the fixtures path
+Test::Unit::TestCase.fixture_path = File.dirname(__FILE__) + "/fixtures/"
+$LOAD_PATH.unshift(Test::Unit::TestCase.fixture_path)
+ 
+require File.dirname(__FILE__) + '/mock_file'
+require 'open-uri'
+
+unless Magick::QuantumDepth == 16
+  puts "**** WARNING ****"
+  puts "* Tests expect a ImageMagick bit depth of 16, you have Magick::QuantumDepth == #{Magick::QuantumDepth}"
+  puts "* Color checking tests will likely fail"
+end
+
+class Test::Unit::TestCase #:nodoc:
+  def create_fixtures(*table_names)
+    if block_given?
+      Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names) { yield }
+    else
+      Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names)
+    end
+  end
+ 
+  self.use_transactional_fixtures = true
+  self.use_instantiated_fixtures  = false
+  
+  def files(name)
+    case name
+    when :photo
+      MockFile.new("#{RAILS_ROOT}/../fixtures/photo.jpg")
+      
+    when :not_a_photo
+      MockFile.new("#{RAILS_ROOT}/../fixtures/not_a_photo.xml")
+    
+    when :web_photo
+      'http://www.google.com/intl/en_ALL/images/logo.gif'
+    
+    when :cmyk
+      MockFile.new("#{RAILS_ROOT}/../fixtures/cmyk.jpg")
+    
+    when :i100x100
+      MockFile.new("#{RAILS_ROOT}/../fixtures/100x100.jpg")
+      
+    when :i1x100
+      MockFile.new("#{RAILS_ROOT}/../fixtures/1x100.jpg")
+      
+    when :i100x1
+      MockFile.new("#{RAILS_ROOT}/../fixtures/100x1.jpg")
+      
+    when :i1x1
+      MockFile.new("#{RAILS_ROOT}/../fixtures/1x1.jpg")
+    
+    end
+  end
+  
+  def color_at(image, coords)
+    image.load_image.pixel_color(*coords)
+  end
+  
+  def to_color(rgb)
+    Magick::Pixel.new(*rgb)
+  end
+  
+  def assert_color(expected, coords, image)
+    coords    = coords.split('x').collect(&:to_i)
+    expected  = to_color(expected)
+    actual    = color_at(image, coords)
+    
+    assert_equal(expected, actual, "Wrong color at (#{coords.join(',')}).  Expected #{expected}, Got #{actual}")
+  end
+end

data/test/unit/abstract_test.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/../../test/test_helper'
+
+class FleximageAbstractTest < Test::Unit::TestCase
+  
+  def test_should_generate_a_default_image
+    p = Abstract.new
+    assert p.save
+    
+    assert_equal 320, p.load_image.columns
+    assert_equal 240, p.load_image.rows
+    assert_color [65535, 0, 0], '160x120', p
+  end
+  
+  def test_should_delete_an_abstract_model
+    p = Abstract.new
+    assert p.save
+    assert_nothing_raised { p.destroy }
+  end
+  
+end

data/test/unit/basic_model_test.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/../../test/test_helper'
+
+class FleximageBasicModelTest < Test::Unit::TestCase
+  def test_should_have_correct_file_path_with_creation_date_based_storage
+    p = PhotoBare.create(:image_file => files(:photo))    
+    assert_equal "#{RAILS_ROOT}/public/uploads/#{Time.now.year}/#{Time.now.month}/#{Time.now.day}/#{p.id}.png", p.file_path
+  end
+  
+  def test_should_have_correct_directory_path_with_creation_date_based_storage
+    p = PhotoBare.create(:image_file => files(:photo))
+    assert_equal "#{RAILS_ROOT}/public/uploads/#{Time.now.year}/#{Time.now.month}/#{Time.now.day}", p.directory_path
+  end
+  
+  
+  def test_should_have_correct_file_path_without_creation_date_based_storage
+    PhotoBare.use_creation_date_based_directories = false
+    p = PhotoBare.create(:image_file => files(:photo))
+    assert_equal "#{RAILS_ROOT}/public/uploads/#{p.id}.png", p.file_path
+  ensure
+    PhotoBare.use_creation_date_based_directories = true
+  end
+  
+  def test_should_have_correct_directory_path_without_creation_date_based_storage
+    PhotoBare.use_creation_date_based_directories = false
+    p = PhotoBare.create(:image_file => files(:photo))
+    assert_equal "#{RAILS_ROOT}/public/uploads", p.directory_path
+  ensure
+    PhotoBare.use_creation_date_based_directories = true
+  end
+end

data/test/unit/blank_test.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/../../test/test_helper'
+
+class FleximageBlankTest < Test::Unit::TestCase
+  
+  def test_should_create_blank_image_of_proper_dimensions
+    p = Fleximage::Blank.new('320x480')
+    p.operate do |image|
+      assert_equal(320, image.width)
+      assert_equal(480, image.height)
+    end
+  end
+  
+  def test_should_be_transparent_by_default
+    p = Fleximage::Blank.new('320x480')
+    assert_color([0, 0, 0, 65535], '50x50', p)
+  end
+  
+  def test_should_color_image
+    p = Fleximage::Blank.new('320x480', :color => 'red')
+    assert_color([65535, 0, 0, 0], '50x50', p)
+  end
+  
+end

data/test/unit/default_image_path_option_test.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/../../test/test_helper'
+
+class FleximageDefaultImagePathOptionTest < Test::Unit::TestCase
+  def test_should_use_a_default_image
+    PhotoBare.require_image = false
+    PhotoBare.default_image_path = "../fixtures/photo.jpg"
+    
+    p = PhotoBare.new
+    assert p.save
+    assert_equal 1024, p.load_image.rows
+    assert_equal 768,  p.load_image.columns
+  ensure
+    PhotoBare.require_image = true
+    PhotoBare.default_image_path = nil
+  end
+end

data/test/unit/dsl_accessor_test.rb

@@ -0,0 +1,120 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class DslAccessorTest < Test::Unit::TestCase
+  class CoolActiveRecord
+    dsl_accessor :primary_key
+    dsl_accessor :table_name
+  end
+
+  class Item < CoolActiveRecord
+  end
+
+  class LegacyItem < CoolActiveRecord
+    primary_key :itcd
+    table_name  :item
+  end
+
+
+  def test_accessor_without_initialization
+    assert_equal nil, Item.primary_key
+    assert_equal nil, Item.table_name
+
+    Item.primary_key :itcd
+    Item.table_name  :item
+
+    assert_equal :itcd, Item.primary_key
+    assert_equal :item, Item.table_name
+  end
+
+  def test_accessor_with_initialization
+    assert_equal :itcd, LegacyItem.primary_key
+    assert_equal :item, LegacyItem.table_name
+
+    LegacyItem.primary_key :item_id
+    LegacyItem.table_name  :item_table
+
+    assert_equal :item_id,    LegacyItem.primary_key
+    assert_equal :item_table, LegacyItem.table_name
+  end
+end
+
+
+class DslDefaultAccessorTest < Test::Unit::TestCase
+
+  class CoolActiveRecord
+    dsl_accessor :primary_key, :default=>"id"
+    dsl_accessor :table_name,  :default=>proc{|klass| klass.name.demodulize.underscore.pluralize}
+  end
+
+  class Item < CoolActiveRecord
+  end
+
+  class User < CoolActiveRecord
+  end
+
+  class Folder
+    dsl_accessor :array_folder, :default=>[]
+    dsl_accessor :hash_folder,  :default=>{}
+  end
+
+  class SubFolder < Folder
+  end
+
+  def test_default_accessor_with_string
+    assert_equal "id", Item.primary_key
+    assert_equal "id", User.primary_key
+  end
+
+  def test_default_accessor_with_proc
+    assert_equal "items", Item.table_name
+    assert_equal "users", User.table_name
+  end
+
+  def test_default_accessor_should_duplicate_empty_array_or_hash
+    Folder.array_folder << 1
+    Folder.hash_folder[:name] = "maiha"
+
+    assert_equal([1], Folder.array_folder)
+    assert_equal({:name=>"maiha"}, Folder.hash_folder)
+
+    assert_equal([], SubFolder.array_folder)
+    assert_equal({}, SubFolder.hash_folder)
+  end
+end
+
+
+class DslOverwritenDefaultAccessorTest < Test::Unit::TestCase
+  class CoolActiveRecord
+    dsl_accessor :primary_key, :default=>"id"
+    dsl_accessor :table_name,  :default=>proc{|klass| klass.name.demodulize.underscore.pluralize}
+  end
+
+  class Item < CoolActiveRecord
+    primary_key :item_id
+    table_name  :item_table
+  end
+
+  def test_overwrite_default_accessor
+    assert_equal :item_id,    Item.primary_key
+    assert_equal :item_table, Item.table_name
+  end
+end
+
+
+class DslWriterAccessorTest < Test::Unit::TestCase
+  class Item
+    dsl_accessor :primary_key, :writer=>proc{|value| value.to_s}
+  end
+
+  def test_string_writer
+    assert_equal "", Item.primary_key
+
+    Item.primary_key :id
+    assert_equal "id", Item.primary_key
+
+    Item.primary_key "id"
+    assert_equal "id", Item.primary_key
+  end
+end
+
+

data/test/unit/file_upload_from_local_test.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/../../test/test_helper'
+
+class FleximageFileUploadFromLocalTest < Test::Unit::TestCase
+  def test_should_be_valid_with_image
+    p = PhotoBare.new(:image_file => files(:photo))
+    assert p.save, 'Record expected to be allowed to save'
+  end
+  
+  def test_should_require_an_image
+    p = PhotoBare.new
+    assert !p.save, 'Record expected to not be allowed to save'
+    assert_equal 1, p.errors.size
+    assert_equal 'is required', p.errors.on(:image_file)
+  end
+  
+  def test_should_require_an_valid_image
+    p = PhotoBare.new(:image_file => files(:not_a_photo))
+    assert !p.save, 'Record expected to not be allowed to save'
+    assert_equal 1, p.errors.size
+    assert_equal 'was not a readable image', p.errors.on(:image_file)
+  end
+  
+  def test_should_correct_colorspace_and_dpi
+    p = PhotoBare.new(:image_file => files(:cmyk))
+    image = p.load_image
+    assert_equal Magick::RGBColorspace, image.colorspace
+    assert_equal '72x72', image.density
+    assert_equal 300, image.columns
+    assert_equal 300, image.rows
+  end
+end

data/test/unit/file_upload_from_strings_test.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/../../test/test_helper'
+
+class FleximageFileUploadFromStringsTest < Test::Unit::TestCase
+  def test_should_accept_file_as_string
+    data = files(:photo).read
+    
+    p = PhotoBare.new
+    p.image_file_string = data
+    p.save
+    assert p.save, 'Record expected to be allowed to save'
+    assert p.has_image?
+  end
+  
+  def test_should_accept_file_as_base64
+    data = Base64.encode64(files(:photo).read)
+    
+    p = PhotoBare.new
+    p.image_file_base64 = data
+    p.save
+    assert p.save, 'Record expected to be allowed to save'
+    assert p.has_image?
+  end
+end

data/test/unit/file_upload_from_url_test.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/../../test/test_helper'
+
+class FleximageFileUploadFromUrlTest < Test::Unit::TestCase
+  def test_should_be_valid_with_image_from_url
+    p = PhotoBare.new(:image_file_url => files(:web_photo))
+    assert p.save, 'Record expected to be valid after upload via URL'
+  rescue SocketError
+    print '!'
+  end
+  
+  def test_should_be_invalid_with_nonimage_from_url
+    p = PhotoBare.new(:image_file_url => 'http://www.google.com/')
+    assert !p.save, 'Record expected to be invalid after upload via URL'
+    assert_equal 1, p.errors.size
+    assert_equal 'was not a readable image', p.errors.on(:image_file_url)
+  rescue SocketError
+    print '!'
+  end
+  
+  def test_should_be_invalid_with_invalid_url
+    p = PhotoBare.new(:image_file_url => 'foo')
+    assert !p.save, 'Record expected to be invalid after upload via URL'
+    assert_equal 1, p.errors.size
+    assert_equal 'was not a readable image', p.errors.on(:image_file_url)
+  rescue SocketError
+    print '!'
+  end
+  
+  def test_should_have_an_original_filename
+    p = PhotoFile.new(:image_file_url => files(:web_photo))
+    assert_equal p.image_filename, files(:web_photo)
+  rescue SocketError
+    print '!'
+  end
+end