attachment-san 0.0.1

data/LICENSE

@@ -0,0 +1,44 @@
+Copyright (c) 2008 Manfred Stienstra, Fingertips <manfred@fngtps.com>
+
+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.
+
+--------------------------------------------------------------------------------
+
+Some parts of attachment-san were originally included in ‘attachment_fu’ and
+‘acts_as_attachment’ under the following license:
+
+Copyright (c) 2005 Rick Olson
+
+Unless noted specifically, all plugins in this repository are MIT licensed:
+
+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

@@ -0,0 +1,10 @@
+Attachment-San
+
+  Plugin for easy and rich attachment manipulation.
+
+  Although the ideas behind Attachment-San are different, it borrows heavily on both attachment_fu and acts_as_attachment by Rick Olson. 
+
+Dependencies
+
+  General: A recent Rails (at least 2.0, though it's most often tested on Edge)
+  Development: test/spec and SQLite3

data/Rakefile

@@ -0,0 +1,31 @@
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+desc "Run all tests by default"
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name     = "attachment-san"
+    s.homepage = "http://github.com/Fingertips/attachment-san"
+    s.email    = ["eloy@fngtps.com", "manfred@fngtps.com"]
+    s.authors  = ["Eloy Duran", "Manfred Stienstra"]
+    s.summary  = s.description = "Rails plugin for easy and rich attachment manipulation."
+    s.files   -= %w{ .gitignore .kick }
+  end
+rescue LoadError
+end
+
+namespace :docs do
+  Rake::RDocTask.new(:generate) do |rd|
+    rd.main = "README"
+    rd.rdoc_files.include("README", "LICENSE", "lib/**/*.rb")
+    rd.options << "--all" << "--charset" << "utf-8"
+  end
+end

data/TODO

@@ -0,0 +1,6 @@
+* Make it actually work with more than one attachment class.
+  * has_attachment :watermark, :superclass => WatermarkSuperclass
+  * has_attachment :watermark, :class => WatermarkClass
+* Nest created classes under the superclass.
+* Do we need to sanitize the original filename, eg lowercase.
+* Make :filename_scheme => :record_identifier also use nesting under parent resources. Eg /resources/1/images/2/filename

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/attachment-san.gemspec

@@ -0,0 +1,73 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{attachment-san}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Eloy Duran", "Manfred Stienstra"]
+  s.date = %q{2009-11-19}
+  s.description = %q{Rails plugin for easy and rich attachment manipulation.}
+  s.email = ["eloy@fngtps.com", "manfred@fngtps.com"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README"
+  ]
+  s.files = [
+    "LICENSE",
+     "README",
+     "Rakefile",
+     "TODO",
+     "VERSION",
+     "examples/photo.rb",
+     "examples/photos_controller.rb",
+     "examples/post.rb",
+     "lib/attachment_san.rb",
+     "lib/attachment_san/has.rb",
+     "lib/attachment_san/test/helper.rb",
+     "lib/attachment_san/test/rails.png",
+     "lib/attachment_san/variant.rb",
+     "napkin.rb",
+     "rails/init.rb",
+     "test/attachment_san_test.rb",
+     "test/fixtures/models/attachment.rb",
+     "test/fixtures/models/document.rb",
+     "test/fixtures/models/options_stub.rb",
+     "test/has_test.rb",
+     "test/lib/schema.rb",
+     "test/test_helper.rb",
+     "test/variant_test.rb"
+  ]
+  s.homepage = %q{http://github.com/Fingertips/attachment-san}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Rails plugin for easy and rich attachment manipulation.}
+  s.test_files = [
+    "test/attachment_san_test.rb",
+     "test/fixtures/models/attachment.rb",
+     "test/fixtures/models/document.rb",
+     "test/fixtures/models/options_stub.rb",
+     "test/has_test.rb",
+     "test/lib/schema.rb",
+     "test/test_helper.rb",
+     "test/variant_test.rb",
+     "examples/photo.rb",
+     "examples/photos_controller.rb",
+     "examples/post.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/examples/photo.rb

@@ -0,0 +1,41 @@
+class Photo < ActiveRecord::Base
+  attachment_san
+  after_upload :make_black
+  
+  has_one :thumbnail, :class => 'Photo'
+  belongs_to :large_photo, :class => 'Photo'
+  before_create :do_create_thumbnail
+  
+  def do_create_thumbnail
+    unless large_photo
+      create_thumbnail :uploaded_data = uploaded_data, :size => "<300x400"
+    end
+  end
+end
+
+# ---
+
+class Photo < ActiveRecord::Base
+  has_one :thumbnail
+  has_one :full_size
+  
+  def uploaded_data=(data)
+    build_thumbnail :uploaded_data => data
+    build_full_size :uploaded_data => data
+  end
+end
+
+class Attachment < ActiveRecord::Base
+end
+
+class Thumbnail < Attachment
+  attachment_san
+  
+  def resize(image)
+    attachment.resize(image)
+  end
+end
+
+class FullSize < Attachment
+  attachment_san :keep_filenames => true
+end

data/examples/photos_controller.rb

@@ -0,0 +1,22 @@
+class PhotosController < ActionController::Base
+  before_filter :find_post
+
+  def new
+  end
+
+  def create
+    @photo = @post.photos.build params[:photo]
+    if @photo.save
+      flash[:hilight] = dom_id(@photo)
+      redirect_to @post
+    else
+      render :new
+    end
+  end
+
+  protected
+
+  def find_post
+    @post = Post.find params[:post_id]
+  end
+end

data/examples/post.rb

@@ -0,0 +1,3 @@
+class Post < ActiveRecord::Base
+  has_many :photos, :dependent => :destroy
+end

data/lib/attachment_san/has.rb

@@ -0,0 +1,49 @@
+module AttachmentSan
+  module Has
+    VALID_OPTIONS = [:name, :process, :class, :variants, :filename_scheme]
+    
+    def has_attachment(name, options = {})
+      define_attachment_association :has_one, name, options
+    end
+    
+    def has_attachments(name, options = {})
+      define_attachment_association :has_many, name, options
+    end
+    
+    private
+    
+    def define_attachment_association(macro, name, options)
+      define_variants(name, extract_variant_options!(options))
+      send(macro, name, options) unless reflect_on_association(name)
+    end
+    
+    def extract_variant_options!(options)
+      options.symbolize_keys!
+      variant_options = options.slice(*VALID_OPTIONS)
+      options.except!(*VALID_OPTIONS)
+      variant_options
+    end
+    
+    def define_variants(name, options)
+      model = create_model(name)
+      
+      original = { :class => Variant::Original }
+      original.merge!(options) unless options.has_key?(:variants)
+      model.send(:define_variant, :original, original)
+      
+      if variants = options[:variants]
+        variants.each do |name, options|
+          model.send(:define_variant, name, options)
+        end
+      end
+    end
+    
+    # TODO: Currently creates these classes in the top level namespace
+    def create_model(name)
+      name = name.to_s.classify
+      ::Object.const_get(name)
+    rescue NameError
+      ::Object.const_set name, Class.new(AttachmentSan.attachment_class)
+    end
+  end
+end

data/lib/attachment_san/test/helper.rb

@@ -0,0 +1,49 @@
+require 'test/unit'
+require 'tempfile'
+require 'fileutils'
+
+module AttachmentSan
+  module UploadHelpers
+    # Generates a Tempfile object similar to the object you'd get from the standard library CGI
+    # module in a multipart request.
+    #
+    # Borrowed from action_controller/test_process.
+    class FakeUploadFile
+      # The filename, *not* including the path, of the "uploaded" file
+      attr_reader :original_filename
+      
+      # The content type of the "uploaded" file
+      attr_reader :content_type
+      
+      def initialize(path, content_type = Mime::TEXT, binary = false)
+        path = path.to_s
+        raise "#{path} file does not exist" unless File.exist?(path)
+        @content_type = content_type
+        @original_filename = path.sub(/^.*#{File::SEPARATOR}([^#{File::SEPARATOR}]+)$/) { $1 }
+        @tempfile = Tempfile.new(@original_filename)
+        @tempfile.binmode if binary
+        FileUtils.copy_file(path, @tempfile.path)
+      end
+      
+      def path #:nodoc:
+        @tempfile.path
+      end
+      
+      alias local_path path
+      
+      def method_missing(method_name, *args, &block) #:nodoc:
+        @tempfile.send(method_name, *args, &block)
+      end
+    end
+    
+    def uploaded_file(filename, content_type)
+      FakeUploadFile.new(filename, content_type)
+    end
+    
+    def rails_icon
+      uploaded_file(File.expand_path('../rails.png', __FILE__), 'image/png')
+    end
+  end
+end
+
+Test::Unit::TestCase.send(:include, AttachmentSan::UploadHelpers)

data/lib/attachment_san/variant.rb

@@ -0,0 +1,153 @@
+require "digest"
+require "fileutils"
+
+module AttachmentSan
+  class Variant
+    module ClassMethods
+      def self.extended(model)
+        model.class_inheritable_accessor :variant_reflections
+        model.variant_reflections = []
+      end
+      
+      def reflect_on_variant(name)
+        variant_reflections.find { |r| r[:name] == name.to_sym }
+      end
+      
+      private
+      
+      def define_variant(name, options_or_class_or_proc)
+        return if reflect_on_variant(name)
+        
+        reflection =
+          case x = options_or_class_or_proc
+          when Hash
+            { :class => Variant }.merge(x.symbolize_keys)
+          when Class
+            { :class => x }
+          when Proc
+            { :class => Variant, :process => x }
+          when nil
+            { :class => const_get(name.to_s.camelize) }
+          else
+            raise TypeError, "Please specify a options hash, variant class, or process proc. Can't use `#{x.inspect}'."
+          end
+        
+        reflection[:name] = name = name.to_sym
+        variant_reflections << reflection
+        
+        # def original
+        #   @original ||= begin
+        #     reflection = self.class.reflect_on_variant(:original)
+        #     reflection.klass.new(self, reflection)
+        #   end
+        # end
+        class_eval <<-DEF, __FILE__, __LINE__ + 1
+          def #{name}
+            @#{name} ||= begin
+              reflection = self.class.reflect_on_variant(:#{name})
+              reflection[:class].new(self, reflection)
+            end
+          end
+        DEF
+      end
+    end
+  end
+  
+  class Variant
+    attr_reader :record, :reflection
+    
+    def initialize(record, reflection)
+      @record, @reflection = record, reflection
+    end
+    
+    def base_options
+      @record.class.attachment_san_options
+    end
+    
+    def base_path
+      base_options[:base_path]
+    end
+    
+    def public_base_path
+      base_options[:public_base_path]
+    end
+    
+    def filename_scheme
+      @reflection[:filename_scheme] || base_options[:filename_scheme]
+    end
+    
+    def original
+      @record.original
+    end
+    
+    def name
+      @reflection[:name]
+    end
+    
+    def extension
+      (ext = base_options[:extension]) == :keep_original ? @record.extension : ext
+    end
+    
+    def token
+      @record.token.scan(/.{2}/)
+    end
+    
+    def filename
+      unless @filename
+        @filename = 
+          case filename_scheme
+          when :variant_name
+            name.to_s
+          when :keep_original
+            @record.filename
+          when :record_identifier
+            @record_class_name ||= @record.class.name.underscore.pluralize
+            "/#{@record_class_name}/#{@record.to_param}/#{name}"
+          when :token
+            File.join(token, "#{@record.filename_without_extension}.#{name}")
+          else
+            raise ArgumentError, "The :filename_scheme option should be one of `:token', `:filename_scheme', `:record_identifier', or `:variant_name', it currently is `#{filename_scheme.inspect}'."
+          end
+        @filename << ".#{extension}" unless extension.blank?
+      end
+      @filename
+    end
+    
+    def file_path
+      File.join(base_path, filename)
+    end
+    
+    def public_path
+      File.join(public_base_path, filename)
+    end
+    
+    def dir_path
+      File.dirname(file_path)
+    end
+    
+    def mkdir!
+      FileUtils.mkdir_p(dir_path)
+    end
+    
+    def process!
+      mkdir!
+      @reflection[:process].call(self)
+    end
+    
+    class Original < Variant
+      def original
+        self
+      end
+      
+      def filename
+        @filename ||= (filename_scheme == :token ? File.join(token, @record.filename) : super)
+      end
+      
+      def process!
+        return super if @reflection[:process]
+        mkdir!
+        File.open(file_path, 'w') { |f| f.write @record.uploaded_file.read }
+      end
+    end
+  end
+end

data/lib/attachment_san.rb

@@ -0,0 +1,58 @@
+require "attachment_san/has"
+require "attachment_san/variant"
+
+module AttachmentSan
+  module Initializer
+    def attachment_san(options = {})
+      include AttachmentSan
+      
+      opt = self.attachment_san_options = {
+        :public_base_path => '',
+        :extension        => :keep_original,
+        :filename_scheme  => :variant_name
+      }.merge(options)
+      # Defaults :base_path to expanded :public_base_path.
+      opt[:base_path] ||= Rails.root + File.join('public', opt[:public_base_path])
+      opt
+    end
+  end
+  
+  mattr_accessor :attachment_class
+  
+  def self.included(model)
+    self.attachment_class = model
+    model.extend Variant::ClassMethods
+    
+    model.class_inheritable_accessor :attachment_san_options
+    model.define_callbacks :before_upload, :after_upload
+    model.after_create :process_variants!
+  end
+  
+  attr_reader :uploaded_file
+  
+  def uploaded_file=(uploaded_file)
+    callback :before_upload
+    
+    @uploaded_file    = uploaded_file
+    self.filename     = uploaded_file.original_filename
+    self.content_type = uploaded_file.content_type
+    
+    callback :after_upload
+  end
+  
+  def extension
+    filename.split('.').last if filename.include?('.')
+  end
+  
+  def filename_without_extension
+    filename.include?('.') ? filename.split('.')[0..-2].join('.') : filename
+  end
+  
+  def variants
+    self.class.variant_reflections.map { |reflection| send(reflection[:name]) }
+  end
+  
+  def process_variants!
+    variants.each(&:process!)
+  end
+end

data/napkin.rb

@@ -0,0 +1,41 @@
+# Variant:
+# * Returns path information
+# * /a2/e0/dd/fits_within_200x200.jpg - "many many files"
+# * /organizations/12/logos/main.jpg - "one or two files"
+# * /cant/guess/me/82734mhsdf923184jnshdf91238ukjhsdf.jpg - "secret location"
+
+
+member.avatar.medium # => member.avatar.image('fits_within_8x8')
+
+company.logo.original # => 
+
+{ :company => { :logo => { :data => IOWEETIKVEEL } } }
+
+# abstract model for data about a file, and has variants, defined by the model that has attachments
+class Attachment
+  belongs_to :attachable
+  
+  include Att # makes this an attachment model
+end
+
+class Member
+  extend Att::Has # adds declerative class methods
+  include Att::Variant # defines filters to handle variants
+  
+  attaches_one :avatar
+  attaches_many 
+  
+  has_attachment :avatar, :variants => {
+    'medium' => { ... }, # => Class.new(Att:Variant)
+    'fits_within_80x80' => { :fits_within => [80, 80] }
+  }
+end
+
+# TODO
+# * filters on a variant basis?
+# * actual sizes
+# * module Variants
+#     class Medium
+#       undef :foo
+#     end
+#   end

data/rails/init.rb

@@ -0,0 +1,4 @@
+require 'attachment_san'
+ActiveRecord::Base.extend AttachmentSan::Initializer
+
+require 'attachment_san/test/helper' if Rails.env == 'test'

data/test/attachment_san_test.rb

@@ -0,0 +1,148 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "AttachmentSan, concerning base options" do
+  default = OptionsStub.new_subclass do
+    attachment_san
+  end
+  
+  default_with_public_path = OptionsStub.new_subclass do
+    attachment_san :public_base_path => '/files/assets'
+  end
+  
+  specified = OptionsStub.new_subclass do
+    attachment_san :base_path => '/some/base/path', :public_base_path => '/files/assets', :extension => :png, :filename_scheme => :token
+  end
+  
+  it "should default the base_path to `public'" do
+    default.attachment_san_options[:base_path].should == Rails.root + 'public/'
+  end
+  
+  it "should use the specified base_path" do
+    specified.attachment_san_options[:base_path].should == '/some/base/path'
+  end
+  
+  it "should default the public_base_path to an empty string" do
+    default.attachment_san_options[:public_base_path].should == ''
+  end
+  
+  it "should use the specified public_base_path" do
+    specified.attachment_san_options[:public_base_path].should == '/files/assets'
+  end
+  
+  it "should default the base_path to `public' + public_base_path" do
+    default_with_public_path.attachment_san_options[:base_path].should == Rails.root + 'public/files/assets'
+  end
+  
+  it "should default to use the variant's name as the filename for variants" do
+    default.attachment_san_options[:filename_scheme].should == :variant_name
+  end
+  
+  it "should use a token version for variant filenames" do
+    specified.attachment_san_options[:filename_scheme].should == :token
+  end
+  
+  it "should use the unique records identifier for variant filenames" do
+    OptionsStub.new_subclass do
+      attachment_san :filename_scheme => :record_identifier
+    end.attachment_san_options[:filename_scheme].should == :record_identifier
+  end
+  
+  it "should default to use the original file's extension for variants" do
+    default.attachment_san_options[:extension].should == :keep_original  end
+  
+  it "should use the specified file extension for variants" do
+    specified.attachment_san_options[:extension].should == :png
+  end
+end
+
+describe "AttachmentSan, class methods" do
+  before do
+    @upload = rails_icon
+    @attachment = Attachment.new(:uploaded_file => @upload)
+  end
+  
+  it "should assign the base attachment class when attachment_san is called" do
+    AttachmentSan.attachment_class.should.be Attachment
+  end
+  
+  it "should call a before_upload filter chain before actually assigning the new uploaded file" do
+    new_upload = rails_icon
+    @attachment.uploaded_file = new_upload
+    @attachment.file_before_upload.should.be @upload
+  end
+  
+  it "should call an after_upload filter chain after assigning the new uploaded file" do
+    @attachment.file_after_upload.should.be @upload
+  end
+  
+  it "should define a variant with options" do
+    Logo.variant_reflections.map { |r| r[:name] }.should == [:original, :header]
+    Logo.new.header.should.be.instance_of MyVariant
+  end
+end
+
+describe "AttachmentSan, instance methods" do
+  before do
+    @upload = rails_icon
+    @attachment = Attachment.new(:uploaded_file => @upload)
+  end
+  
+  it "should make a model accept a file upload" do
+    @attachment.uploaded_file.should.be @upload
+  end
+  
+  it "should assign the original filename to the model" do
+    @attachment.filename.should == @upload.original_filename
+  end
+  
+  it "should assign the content type to the model" do
+    @attachment.content_type.should == @upload.content_type
+  end
+  
+  it "should return the original file's extension" do
+    @attachment.extension.should == 'png'
+    
+    @attachment.stubs(:filename).returns('Rakefile')
+    @attachment.extension.should.be nil
+  end
+  
+  it "should return the original filename without extension" do
+    @attachment.filename_without_extension.should == 'rails'
+    
+    @attachment.stubs(:filename).returns('Rakefile')
+    @attachment.filename_without_extension.should == 'Rakefile'
+    
+    @attachment.stubs(:filename).returns('some.dotted.spaced.file.txt')
+    @attachment.filename_without_extension.should == 'some.dotted.spaced.file'
+  end
+end
+
+describe "An AttachmentSan instance, concerning variants" do
+  before do
+    @upload = rails_icon
+    @document = Document.new
+    @document.build_logo :uploaded_file => @upload
+    @document.build_watermark :uploaded_file => @upload
+  end
+  
+  it "should call process on each of it's variants after create" do
+    @document.watermark.original.expects(:process!)
+    @document.logo.original.expects(:process!)
+    @document.logo.header.expects(:process!)
+    @document.save!
+  end
+  
+  it "should not call process when the model already exists" do
+    @document.save!
+    
+    @document.watermark.original.expects(:process!).never
+    @document.logo.original.expects(:process!).never
+    @document.logo.header.expects(:process!).never
+    @document.save!
+  end
+  
+  it "should return it's variants" do
+    @document.watermark.variants.map(&:name).should == [:original]
+    @document.logo.variants.map(&:name).should == [:original, :header]
+  end
+end

data/test/fixtures/models/attachment.rb

@@ -0,0 +1,20 @@
+class Attachment < ActiveRecord::Base
+  attachment_san :base_path => TMP_DIR, :public_base_path => '/files/assets'
+  
+  # Test code
+  
+  def self.reset!
+    FileUtils.rm_rf TMP_DIR
+    FileUtils.mkdir_p TMP_DIR
+  end
+  
+  # User code
+  
+  belongs_to :attachable, :polymorphic => true
+  
+  attr_accessor :file_before_upload
+  before_upload { |record| record.file_before_upload = record.uploaded_file }
+  
+  attr_accessor :file_after_upload
+  after_upload  { |record| record.file_after_upload  = record.uploaded_file }
+end

data/test/fixtures/models/document.rb

@@ -0,0 +1,39 @@
+class MyVariant < AttachmentSan::Variant
+  def process!
+  end
+end
+
+class MyProcessor
+  def initialize(variant)
+  end
+end
+
+class AddressCard < Attachment
+  class SmallCard < AttachmentSan::Variant
+    def process!
+      puts 'SMALL!'
+    end
+  end
+  
+  class BigCard < AttachmentSan::Variant
+    def process!
+      puts 'BIG!'
+    end
+  end
+end
+
+class Document < ActiveRecord::Base
+  extend AttachmentSan::Has
+  
+  has_attachment  :watermark
+  has_attachment  :logo, :variants => { :header => MyVariant }
+  
+  has_attachments :misc_files, :filename_scheme => :keep_original, :process => proc { :from_process_proc }
+  has_attachments :images, :variants => {
+    :thumbnail => proc { |v| MyProcessor.new(v) },
+    :medium_sized => proc {},
+    :download => proc {}
+  }
+  
+  has_attachments :address_cards, :variants => [:small_card, :big_card]
+end

data/test/fixtures/models/options_stub.rb

@@ -0,0 +1,20 @@
+class OptionsStub
+  def self.new_subclass(&block)
+    before = AttachmentSan.attachment_class
+    model = Class.new(self)
+    model.instance_eval(&block)
+    AttachmentSan.attachment_class = before
+    model
+  end
+  
+  def self.define_callbacks(*args)
+    # no we don't!
+  end
+  
+  def self.after_create(m)
+    # no we don't!
+  end
+  
+  class_inheritable_accessor :attachment_san_options
+  extend AttachmentSan::Initializer
+end

data/test/has_test.rb

@@ -0,0 +1,116 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "AttachmentSan::Has" do
+  it "should pass on any unknown options to the has_one macro" do
+    Document.expects(:has_one).with(:other_file, :as => :attachable, :order => :updated_at)
+    Document.expects(:define_variants).with(:other_file, :process => proc {}, :class => MyVariant, :filename_scheme => :token, :variants => [:hoge, :fuga])
+    
+    Document.has_attachment :other_file, :as => :attachable, :order => :updated_at,
+                                         :process => proc {}, :class => MyVariant, :filename_scheme => :token, :variants => [:hoge, :fuga]
+  end
+  
+  it "should pass on any unknown options to the has_many macro" do
+    Document.expects(:has_many).with(:other_files, :as => :attachable, :order => :updated_at)
+    Document.expects(:define_variants).with(:other_files, :process => proc {}, :class => MyVariant, :filename_scheme => :token, :variants => [:hoge, :fuga])
+    
+    Document.has_attachments :other_files, :as => :attachable, :order => :updated_at,
+                                           :process => proc {}, :class => MyVariant, :filename_scheme => :token, :variants => [:hoge, :fuga]
+  end
+  
+  it "should not define an association if an association for the given name exists" do
+    Document.expects(:has_one).never
+    Document.expects(:define_variants).with(:watermark, {})
+    
+    Document.expects(:has_many).never
+    Document.expects(:define_variants).with(:images, {})
+    
+    Document.has_attachment :watermark, :as => :attachable
+    Document.has_attachments :images, :as => :attachable
+  end
+end
+
+describe "AttachmentSan::Has, concerning a single associated attachment" do
+  before do
+    @document = Document.new
+    @document.build_logo :uploaded_file => rails_icon
+    @document.build_watermark :uploaded_file => rails_icon
+  end
+  
+  it "should create a model class and a has_one association" do
+    reflection = Document.reflect_on_association(:logo)
+    reflection.macro.should == :has_one
+    reflection.klass.should == Logo
+    Logo.superclass.should.be AttachmentSan.attachment_class
+  end
+  
+  it "should store the variant options on the new model class" do
+    Watermark.variant_reflections.length.should == 1
+    Watermark.variant_reflections.first[:name].should == :original
+    Watermark.variant_reflections.first[:class].should == AttachmentSan::Variant::Original
+    
+    Logo.variant_reflections.length.should == 2
+    Logo.variant_reflections.last[:name].should == :header
+    Logo.variant_reflections.last[:class].should == MyVariant
+  end
+  
+  it "should define only a default original variant if no other variants are given" do
+    variant = @document.watermark.original
+    variant.name.should == :original
+    variant.should.be.instance_of AttachmentSan::Variant::Original
+  end
+  
+  it "should define a default original variant and the ones specified" do
+    %w{ original header }.each do |name|
+      variant = @document.logo.send(name)
+      variant.name.to_s.should == name
+      variant.should.be.instance_of Logo.reflect_on_variant(name)[:class]
+    end
+  end
+end
+
+describe "AttachmentSan::Has, concerning a collection of associated attachments" do
+  before do
+    @document = Document.new
+    2.times { @document.images.build :uploaded_file => rails_icon }
+    2.times { @document.misc_files.build :uploaded_file => rails_icon }
+  end
+  
+  it "should create a model class and a has_many association" do
+    reflection = Document.reflect_on_association(:images)
+    reflection.macro.should == :has_many
+    reflection.klass.should == Image
+  end
+  
+  it "should define only a default original variant if no others are given" do
+    variants = @document.misc_files.map(&:original)
+    variants.should.all { |v| v.name == :original }
+    variants.should.all { |v| v.instance_of? AttachmentSan::Variant }
+  end
+  
+  it "should define a default original variant and the ones specified" do
+    %w{ original thumbnail medium_sized download }.each do |name|
+      variants = @document.images.map(&name.to_sym)
+      variants.should.all { |v| v.name == name }
+      variants.should.all { |v| v.instance_of? AttachmentSan::Variant }
+    end
+  end
+end
+
+describe "AttachmentSan::Has, concerning attachment definitions with only a default original variant" do
+  it "should pass the options hash on to the variant" do
+    MiscFile.variant_reflections.length.should == 1
+    MiscFile.variant_reflections.first[:name].should == :original
+    MiscFile.variant_reflections.first[:class].should == AttachmentSan::Variant::Original
+    MiscFile.variant_reflections.first[:filename_scheme].should == :keep_original
+    MiscFile.variant_reflections.first[:process].call.should == :from_process_proc
+  end
+end
+
+describe "AttachmentSan::Has, concerning attachment definitions with an array of variants" do
+  it "should simply assume the variant class exists" do
+    @document = Document.new
+    card = @document.address_cards.build(:uploaded_file => rails_icon)
+    card.small_card.should.be.instance_of AddressCard::SmallCard
+    card.big_card.should.be.instance_of AddressCard::BigCard
+  end
+end

data/test/lib/schema.rb

@@ -0,0 +1,14 @@
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Schema.define(:version => 1) do
+
+  create_table :attachments, :force => true do |t|
+    t.string  :filename
+    t.string  :content_type
+    t.string  :attachable_type
+    t.integer :attachable_id
+  end
+  
+  create_table :documents, :force => true do |t|
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,66 @@
+TEST_ROOT_DIR = File.expand_path(File.dirname(__FILE__))
+
+frameworks = %w(activesupport activerecord actionpack)
+
+rails = [
+  File.expand_path('../../../rails', TEST_ROOT_DIR),
+  File.expand_path('../../rails', TEST_ROOT_DIR)
+].detect do |possible_rails|
+  begin
+    entries = Dir.entries(possible_rails)
+    frameworks.all? { |framework| entries.include?(framework) }
+  rescue Errno::ENOENT
+    false
+  end
+end
+
+raise "Couldn't find Rails directory!" unless rails
+
+frameworks.each { |framework| $:.unshift(File.join(rails, framework, 'lib')) }
+$:.unshift File.join(TEST_ROOT_DIR, '/../lib')
+$:.unshift TEST_ROOT_DIR
+
+ENV['RAILS_ENV'] = 'test'
+
+# Rails libs
+begin
+  require 'active_support'
+  require 'active_record'
+  require 'action_controller'
+rescue LoadError
+  raise "Please install Attachment-San as Rails plugin before running the tests."
+end
+
+require "pathname"
+module Rails
+  def self.env
+    'test'
+  end
+  
+  def self.root
+    Pathname.new('/path/to/app')
+  end
+end
+
+require File.expand_path('../../rails/init', __FILE__)
+
+# Libraries for testing
+require 'rubygems' rescue LoadError
+require 'sqlite3'
+require 'test/spec'
+require 'mocha'
+require 'fileutils'
+
+logdir = File.join(TEST_ROOT_DIR, 'log')
+FileUtils.mkdir_p(logdir)
+ActiveRecord::Base.logger = Logger.new File.join(logdir, 'test.log')
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ":memory:")
+
+TMP_DIR = File.join(TEST_ROOT_DIR, 'tmp')
+
+# Classes and methods to aid testing
+require 'lib/schema'
+
+require 'fixtures/models/attachment'
+require 'fixtures/models/document'
+require 'fixtures/models/options_stub'

data/test/variant_test.rb

@@ -0,0 +1,167 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "AttachmentSan's variant class methods" do
+  it "should return the variant class to use" do
+    reflection = Logo.reflect_on_variant(:header)
+    reflection[:class].should.be MyVariant
+  end
+  
+  it "should by default use the AttachmentSan::Variant class" do
+    reflection = Image.reflect_on_variant(:thumbnail)
+    reflection[:class].should.be AttachmentSan::Variant
+  end
+  
+  it "should not define a variant twice" do
+    count_before = Logo.variant_reflections.length
+    Document.has_attachment :logo, :variants => { :header => MyVariant }
+    Logo.variant_reflections.length.should == count_before
+  end
+end
+
+describe "A AttachmentSan::Variant instance in general" do
+  before do
+    @upload = rails_icon
+    @document = Document.new
+    
+    @image = @document.images.build(:uploaded_file => @upload)
+    @thumbnail = @image.thumbnail
+    @medium_sized = @image.medium_sized
+  end
+  
+  it "should return the record it is a variant of" do
+    @image.original.record.should == @image
+  end
+  
+  it "should return the `original' variant" do
+    @image.original.should == @image.original
+    @thumbnail.original.should == @image.original
+  end
+  
+  it "should call the process proc" do
+    MyProcessor.expects(:new).with(@thumbnail)
+    @thumbnail.process!
+  end
+  
+  it "should return the base_path specified in the attachment_san_options" do
+    @thumbnail.base_path.should == Attachment.attachment_san_options[:base_path]
+  end
+  
+  it "should return the public_base_path specified in the attachment_san_options" do
+    @thumbnail.public_base_path.should == Attachment.attachment_san_options[:public_base_path]
+  end
+  
+  it "should return the extension of the original file" do
+    Image.attachment_san_options[:extension] = :keep_original
+    @thumbnail.extension.should == 'png'
+  end
+  
+  it "should use the extension specified in the attachment_san_options" do
+    Image.attachment_san_options[:extension] = :jpeg
+    @thumbnail.extension.should == :jpeg
+  end
+  
+  it "should create the directory that the file_path returns" do
+    Image.attachment_san_options[:filename_scheme] = :record_identifier
+    
+    @thumbnail.dir_path.should == File.dirname(@thumbnail.file_path)
+    File.should.not.exist @thumbnail.dir_path
+    @thumbnail.mkdir!
+    File.should.exist @thumbnail.dir_path
+  end
+  
+  it "should return a file_path without trailing dot if the original filename has no extension" do
+    variant = @document.misc_files.build(
+      :uploaded_file => uploaded_file(File.expand_path('../../Rakefile', __FILE__), 'text/plain')
+    ).original
+    
+    variant.file_path.should == File.join(variant.base_path, 'Rakefile')
+  end
+  
+  { :keep_original => 'png', :jpg => 'jpg' }.each do |setting, ext|
+    it "should return a filename named after the variant name plus #{setting}" do
+      Image.attachment_san_options[:filename_scheme] = :variant_name
+      Image.attachment_san_options[:extension] = setting
+      
+      @thumbnail.filename.should == "thumbnail.#{ext}"
+      @thumbnail.file_path.should == File.join(@thumbnail.base_path, "thumbnail.#{ext}")
+      @thumbnail.public_path.should == File.join(@thumbnail.public_base_path, "thumbnail.#{ext}")
+      
+      @medium_sized.filename.should == "medium_sized.#{ext}"
+      @medium_sized.file_path.should == File.join(@thumbnail.base_path, "medium_sized.#{ext}")
+      @medium_sized.public_path.should == File.join(@thumbnail.public_base_path, "medium_sized.#{ext}")
+    end
+    
+    it "should return a filename which should be a random token from the record and append #{setting}" do
+      Image.attachment_san_options[:filename_scheme] = :token
+      Image.attachment_san_options[:extension] = setting
+      @image.stubs(:token).returns('556d2e8e')
+      
+      @image.original.filename.should == "55/6d/2e/8e/rails.png"
+      @image.original.file_path.should == File.join(@thumbnail.base_path, "55/6d/2e/8e/rails.png")
+      @image.original.public_path.should == File.join(@thumbnail.public_base_path, "55/6d/2e/8e/rails.png")
+      
+      @thumbnail.filename.should == "55/6d/2e/8e/rails.thumbnail.#{ext}"
+      @thumbnail.file_path.should == File.join(@thumbnail.base_path, "55/6d/2e/8e/rails.thumbnail.#{ext}")
+      @thumbnail.public_path.should == File.join(@thumbnail.public_base_path, "55/6d/2e/8e/rails.thumbnail.#{ext}")
+    end
+    
+    it "should return a filename which is based on the record identifier and variant name plus #{setting}" do
+      Attachment.reset!
+      
+      Image.attachment_san_options[:extension] = setting
+      Image.attachment_san_options[:filename_scheme] = :record_identifier
+      @image.save!
+      
+      @thumbnail.filename.should == "/images/#{@image.id}/thumbnail.#{ext}"
+      @thumbnail.file_path.should == File.join(@thumbnail.base_path, "/images/#{@image.id}/thumbnail.#{ext}")
+      @thumbnail.public_path.should == File.join(@thumbnail.public_base_path, "/images/#{@image.id}/thumbnail.#{ext}")
+      
+      @medium_sized.filename.should == "/images/#{@image.id}/medium_sized.#{ext}"
+      @medium_sized.file_path.should == File.join(@thumbnail.base_path, "/images/#{@image.id}/medium_sized.#{ext}")
+      @medium_sized.public_path.should == File.join(@thumbnail.public_base_path, "/images/#{@image.id}/medium_sized.#{ext}")
+    end
+  end
+end
+
+describe "AttachmentSan::Variant, concerning a default variant without extra options" do
+  before do
+    @upload = rails_icon
+    @document = Document.new
+    @document.build_watermark :uploaded_file => @upload
+  end
+  
+  it "should use a custom variant for an `original'" do
+    @document.watermark.original.should.be.instance_of AttachmentSan::Variant::Original
+  end
+  
+  it "should simply copy the file to the file_path" do
+    Attachment.reset!
+    
+    file_path = @document.watermark.original.file_path
+    File.should.not.exist file_path
+    @document.save!
+    
+    File.should.exist file_path
+    File.read(file_path).should == File.read(@upload.path)
+  end
+end
+
+describe "AttachmentSan::Variant, concerning a default variant with extra options" do
+  before do
+    @upload = rails_icon
+    @document = Document.new
+    @variant = @document.misc_files.build(:uploaded_file => @upload).original
+  end
+  
+  it "should return the filename_scheme value that was specified" do
+    @variant.filename_scheme.should == :keep_original  end
+  
+  it "should return the original file's name" do
+    @variant.filename.should == @variant.record.filename
+  end
+  
+  it "should call the specified process proc" do
+    result = @variant.process!
+    result.should == :from_process_proc
+  end
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: attachment-san
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Eloy Duran
+- Manfred Stienstra
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-19 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Rails plugin for easy and rich attachment manipulation.
+email: 
+- eloy@fngtps.com
+- manfred@fngtps.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README
+files: 
+- LICENSE
+- README
+- Rakefile
+- TODO
+- VERSION
+- attachment-san.gemspec
+- examples/photo.rb
+- examples/photos_controller.rb
+- examples/post.rb
+- lib/attachment_san.rb
+- lib/attachment_san/has.rb
+- lib/attachment_san/test/helper.rb
+- lib/attachment_san/test/rails.png
+- lib/attachment_san/variant.rb
+- napkin.rb
+- rails/init.rb
+- test/attachment_san_test.rb
+- test/fixtures/models/attachment.rb
+- test/fixtures/models/document.rb
+- test/fixtures/models/options_stub.rb
+- test/has_test.rb
+- test/lib/schema.rb
+- test/test_helper.rb
+- test/variant_test.rb
+has_rdoc: true
+homepage: http://github.com/Fingertips/attachment-san
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Rails plugin for easy and rich attachment manipulation.
+test_files: 
+- test/attachment_san_test.rb
+- test/fixtures/models/attachment.rb
+- test/fixtures/models/document.rb
+- test/fixtures/models/options_stub.rb
+- test/has_test.rb
+- test/lib/schema.rb
+- test/test_helper.rb
+- test/variant_test.rb
+- examples/photo.rb
+- examples/photos_controller.rb
+- examples/post.rb