admin_assistant 2.0.1 → 2.1.0

data/rails_2_test/vendor/plugins/file_column/test/fixtures/mysql.sql

@@ -1,25 +0,0 @@
--- MySQL dump 9.11
---
--- Host: localhost    Database: file_column_test
--- ------------------------------------------------------
--- Server version	4.0.24
-
---
--- Table structure for table `entries`
---
-
-DROP TABLE IF EXISTS entries;
-CREATE TABLE entries (
-  id int(11) NOT NULL auto_increment,
-  image varchar(200) default NULL,
-  file varchar(200) NOT NULL,
-  PRIMARY KEY  (id)
-) TYPE=MyISAM;
-
-DROP TABLE IF EXISTS movies;
-CREATE TABLE movies (
-  id int(11) NOT NULL auto_increment,
-  movie varchar(200) default NULL,
-  PRIMARY KEY  (id)
-) TYPE=MyISAM;
-

data/rails_2_test/vendor/plugins/file_column/test/fixtures/schema.rb

@@ -1,10 +0,0 @@
-ActiveRecord::Schema.define do
-  create_table :entries, :force => true do |t|
-    t.column :image, :string, :null => true
-    t.column :file, :string, :null => false
-  end
-  
-  create_table :movies, :force => true do |t|
-    t.column :movie, :string
-  end
-end

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

@@ -1,380 +0,0 @@
-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(f("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(f("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(f("skanthak.png"))
-    assert e.save
-    e.reload
-    old_path = e.image
-    
-    e.image = upload(f("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(f("invalid-image.jpg")) }
-    assert !e.valid?
-  end
-
-  def test_serializable
-    e = Entry.new
-    e.image = upload(f("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 RMagickRequiresImageTest < AbstractRMagickTest
-  def setup
-    Entry.file_column :image, :magick => { 
-      :size => "100x100>",
-      :image_required => false,
-      :versions => {
-        :thumb => "80x80>",
-        :large => {:size => "200x200>", :lazy => true}
-      }
-    }
-  end
-
-  def test_image_required_with_image
-    e = Entry.new(:image => upload(f("skanthak.png")))
-    assert_max_image_size read_image(e.image), 100
-    assert e.valid?
-  end
-
-  def test_image_required_with_invalid_image
-    e = Entry.new(:image => upload(f("invalid-image.jpg")))
-    assert e.valid?, "did not ignore invalid image"
-    assert FileUtils.identical?(e.image, f("invalid-image.jpg")), "uploaded file has not been left alone"
-  end
-
-  def test_versions_with_invalid_image
-    e = Entry.new(:image => upload(f("invalid-image.jpg")))
-    assert e.valid?
-
-    image_state = e.send(:image_state)
-    assert_nil image_state.create_magick_version_if_needed(:thumb)
-    assert_nil image_state.create_magick_version_if_needed(:large)
-    assert_nil image_state.create_magick_version_if_needed("300x300>")
-  end
-end
-
-class RMagickCustomAttributesTest < AbstractRMagickTest
-  def assert_image_property(img, property, value, text = nil)
-    assert File.exists?(img), "the image does not exist"
-    assert_equal value, read_image(img).send(property), text
-  end
-
-  def test_simple_attributes
-    Entry.file_column :image, :magick => { :attributes => { :quality => 20 } }
-    e = Entry.new("image" => upload(f("kerb.jpg")))
-    assert_image_property e.image, :quality, 20, "the quality was not set"
-  end
-
-  def test_version_attributes
-    Entry.file_column :image, :magick => {
-      :versions => {
-        :thumb => { :attributes => { :quality => 20 } }
-      }
-    }
-    e = Entry.new("image" => upload(f("kerb.jpg")))
-    assert_image_property e.image("thumb"), :quality, 20, "the quality was not set"
-  end
-  
-  def test_lazy_attributes
-    Entry.file_column :image, :magick => {
-      :versions => {
-        :thumb => { :attributes => { :quality => 20 }, :lazy => true }
-      }
-    }
-    e = Entry.new("image" => upload(f("kerb.jpg")))
-    e.send(:image_state).create_magick_version_if_needed(:thumb)
-    assert_image_property e.image("thumb"), :quality, 20, "the quality was not set"
-  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(f("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(f("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(f("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(f("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(f("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(f("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(f("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(f("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(f("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(f("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(f("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(f("skanthak.png")))
-    
-    check_permissions e
-
-    assert e.save
-
-    check_permissions e
-  end
-end
-
-class Entry 
-  def transform_grey(img)
-    img.quantize(256, Magick::GRAYColorspace)
-  end
-end
-
-class RMagickTransformationTest < AbstractRMagickTest
-  def assert_transformed(image)
-    assert File.exists?(image), "the image does not exist"
-    assert 256 > read_image(image).number_colors, "the number of colors was not changed"
-  end
-  
-  def test_simple_transformation
-    Entry.file_column :image, :magick => { :transformation => Proc.new { |image| image.quantize(256, Magick::GRAYColorspace) } }
-    e = Entry.new("image" => upload(f("skanthak.png")))
-    assert_transformed(e.image)
-  end
-  
-  def test_simple_version_transformation
-    Entry.file_column :image, :magick => {
-      :versions => { :thumb => Proc.new { |image| image.quantize(256, Magick::GRAYColorspace) } }
-    }
-    e = Entry.new("image" => upload(f("skanthak.png")))
-    assert_transformed(e.image("thumb"))
-  end
-  
-  def test_complex_version_transformation
-    Entry.file_column :image, :magick => {
-      :versions => {
-        :thumb => { :transformation => Proc.new { |image| image.quantize(256, Magick::GRAYColorspace) } }
-      }
-    }
-    e = Entry.new("image" => upload(f("skanthak.png")))
-    assert_transformed(e.image("thumb"))
-  end
-  
-  def test_lazy_transformation
-    Entry.file_column :image, :magick => {
-      :versions => {
-        :thumb => { :transformation => Proc.new { |image| image.quantize(256, Magick::GRAYColorspace) }, :lazy => true }
-      }
-    }
-    e = Entry.new("image" => upload(f("skanthak.png")))
-    e.send(:image_state).create_magick_version_if_needed(:thumb)
-    assert_transformed(e.image("thumb"))
-  end
-
-  def test_simple_callback_transformation
-    Entry.file_column :image, :magick => :transform_grey
-    e = Entry.new(:image => upload(f("skanthak.png")))
-    assert_transformed(e.image)
-  end
-
-  def test_complex_callback_transformation
-    Entry.file_column :image, :magick => { :transformation => :transform_grey }
-    e = Entry.new(:image => upload(f("skanthak.png")))
-    assert_transformed(e.image)
-  end
-end

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

@@ -1,21 +0,0 @@
-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(f("skanthak.png")))
-    
-    assert_nothing_raised { url_for_image_column e, "image", "50x50" }
-  end
-end

data/rails_3_test/app/controllers/admin/appointments2_controller.rb

@@ -1,15 +0,0 @@
-class Admin::Appointments2Controller < ApplicationController
-  layout 'admin'
-
-  admin_assistant_for Appointment do |a|
-    a.form.multi = true
-  end
-  
-  protected
-  
-  def time_from_form(time)
-    time['1-3i'] =~ /(\d{4})-(\d{2})-(\d{2})/
-    utc_args = [$1, $2, $3, time['4i'], time['5i']]
-    Time.utc(*(utc_args.map(&:to_i))) unless utc_args.any?(&:blank?)
-  end
-end

data/rails_3_test/app/controllers/admin/appointments_controller.rb

@@ -1,11 +0,0 @@
-class Admin::AppointmentsController < ApplicationController
-  layout 'admin'
-
-  admin_assistant_for Appointment do |a|
-    a.form.multi = true
-    a.index.search do |search|
-      search.columns :subject, :time, :user
-      search[:time].compare_to_range = true
-    end
-  end
-end

data/rails_3_test/app/controllers/admin/blog_posts2_controller.rb

@@ -1,138 +0,0 @@
-class Admin::BlogPosts2Controller < ApplicationController
-  layout 'admin'
-
-  admin_assistant_for BlogPost do |a|
-    a[:user].label = 'Author'
-    
-    # When showing the textile field, say 'Yes' and 'No' instead of 'true'
-    # and 'false'
-    a[:textile].boolean_labels = %w(Yes No)
-        
-    # For the index view:
-    a.index do |index|
-      # Only show these columns
-      index.columns :user, :title, :tags, :published_at, :textile
-      
-      # Add the link 'All' to the top-right corner
-      index.actions['All'] = {:all => '1'}
-      
-      # Sort by published_at descending, then updated_at descending
-      index.sort_by "published_at desc, updated_at desc"
-      
-      # Show only 10 blog posts per page
-      index.per_page 10
-      
-      # Let's have specific fields for searching
-      index.search :id, :title, :body, :textile, :user
-      
-      # Make the author field a link
-      index[:user].link_to_args do |blog_post|
-        { :controller => 'admin/users', :action => 'edit',
-          :id => blog_post.user_id }
-      end
-
-      index.header do |params|
-        if params[:all]
-          "Blog posts (all)"
-        else
-          "Blog posts (unpublished)"
-        end
-      end
-    end
-    
-    # For any form page:
-    a.form do |form|
-      # Only show inputs for these fields
-      form.columns :user, :title, :body, :tags, :textile, :publish
-      
-      # 'publish' isn't defined on BlogPost, we have to specify that it's a
-      # check box
-      form[:publish].input = :check_box
-      
-      # In addition to the 'Create'/'Update' button at the bottom, we also have
-      # a 'Preview' button
-      form.submit_buttons << 'Preview'
-      
-      form[:publish].description =
-          "Click this and published_at will be set automatically"
-        
-      form[:user].select_options = {:include_blank => false}
-      
-      form[:body].text_area_options = {:cols => 20, :rows => 40}
-    end
-    
-    # Only show some columns on the show page
-    a.show.columns :user, :title, :body, :tags, :textile, :published_at
-  end
-  
-  protected
-  
-  # This is run after all saves, whether they're creates or updates
-  def after_save(blog_post)
-    unless blog_post.tags.empty?
-      blog_post.update_attribute(:tags_string, blog_post.tags.map(&:tag).join(','))
-    end
-  end
-  
-  # This is run before all saves, whether they're creates or updates
-  def before_save(blog_post)
-    if params[:blog_post][:publish] == '1' && blog_post.published_at.nil?
-      blog_post.published_at = Time.now.utc
-    end
-  end
-  
-  # This is run in the controller context, just before render is called
-  def before_render_for_index
-    if @index.records.any?
-      @var_set_by_before_render_for_index_hook = 'Confirmed that we have some records'
-    end
-  end
-  
-  # By default, only show unpublished blog posts unless params[:all] is
-  # passed in
-  def conditions_for_index
-    "published_at is null" unless params[:all]
-  end
-
-  # After a successful save, redirect to the edit page with preview=1 to show
-  # the preview pane. The HTML for the preview pane is generated in
-  # app/views/admin/blog_posts2/_after_form.html.erb
-  def destination_after_save(blog_post, params)
-    if params[:commit] == 'Preview'
-      {:action => 'edit', :id => blog_post.id, :preview => '1',
-       :origin => params[:origin]}
-    end
-  end
-  
-  # Preprocesses the 'tags' string from the form to an array of Tag objects.
-  # That way admin_assistant can say
-  #
-  #   blog_post.tags = params[:tags]
-  #
-  # and this will work fine with the BlogPost#tags association
-  def tags_from_form(tags_string, record_params, errors)
-    tags = tags_string.split(/\s+/).map { |tag_str|
-      Tag.find_by_tag(tag_str) || Tag.create(:tag => tag_str)
-    }
-    bad_tags = tags.select { |t| !t.valid? }
-    unless bad_tags.empty?
-      error_str = if bad_tags.size == 1
-        "contain invalid string '#{bad_tags.first.tag}'"
-      else
-        "contain invalid strings " +
-            bad_tags.map { |t| "'#{t.tag}'" }.join(',')
-      end
-      errors.add(:tags, error_str)
-    end
-    tags
-  end
-  
-  def validate(blog_post)
-    pub_str = params[:blog_post][:publish]
-    unless pub_str.nil? or [true, false, '0', '1'].include?(pub_str)
-      blog_post.errors.add(
-        :publish, "can't be \"#{params[:blog_post][:publish]}\""
-      )
-    end
-  end
-end

data/rails_3_test/app/controllers/admin/blog_posts3_controller.rb

@@ -1,76 +0,0 @@
-class Admin::BlogPosts3Controller < ApplicationController
-  layout 'admin'
-
-  admin_assistant_for BlogPost do |a|
-    a.model_class_name = 'post'
-    
-    a[:has_short_title].boolean_labels = %w(Yes No)
-    a[:published?].boolean_labels = %w(Yes No)
-
-    a.index do |index|
-      index.columns :id, :title, :created_at, :updated_at, :body, :textile,
-                    :published?, :user
-                    
-      index[:textile].ajax_toggle = false
-      
-      index.actions['All'] = {:all => '1'}
-      index.actions['Short title'] = {:short_title => '1'}
-      index.actions['Blank body'] = {:blank_body => '1'}
-      
-      # By default, only show unpublished blog posts unless params[:all] is
-      # passed in. This needs to work with or without use of the field search
-      # feature
-      index.conditions do |params|
-        if params[:all]
-        elsif params[:blank_body]
-          "(body is null or body = '')"
-        elsif params[:short_title]
-          "length(title) < 10"
-        else
-          'published_at is null'
-        end
-      end
-      
-      index.cache_total_entries 12.hours
-      
-      # Extended search configuration
-      index.search do |search|
-        search.columns :id, :title, :body, :textile, :user, :has_short_title
-        search[:body].blank_checkbox = true
-        search[:has_short_title].field_type = :boolean
-        search[:has_short_title].conditions do |has_short_title|
-          if has_short_title
-            "length(title) < 10"
-          elsif has_short_title == false
-            "length(title) >= 10"
-          end
-        end
-        search[:id].comparators = false
-        search[:user].match_text_fields_for_association
-      end
-      
-      # sort by user by default
-      index.sort_by :user
-    end
-    
-    a.form do |form|
-      form.columns_for_new  :title, :user, :published_at
-      form.columns_for_edit :title, :user, :published_at, :body, :merged_into
-      form[:published_at].datetime_select_options =
-          {:include_blank => false, :start_year => 2009}
-      form[:published_at].default do |controller|
-        controller.time_now_utc
-      end
-    end
-  end
-  
-  def time_now_utc
-    Time.now.utc
-  end
-  
-  protected
-  
-  def before_validation(blog_post)
-    blog_post.title = '(draft)' if blog_post.title.blank?
-  end
-end