citrusbyte-milton 0.1.8 → 0.1.9

data/lib/milton/attachment.rb

@@ -5,12 +5,18 @@ module Citrusbyte
   module Milton
     module Attachment
       def self.included(base)
+        base.class_inheritable_accessor :milton_options
+        base.milton_options = {}
         base.extend Citrusbyte::Milton::Attachment::AttachmentMethods
       end
       
       module AttachmentMethods
         def has_attachment_methods(options={})
-          raise "Milton requires a filename column on #{table_name} table" unless column_names.include?("filename")
+          begin
+            raise "Milton requires a filename column on #{class_name} table" unless column_names.include?("filename")
+          rescue ActiveRecord::StatementInvalid => i
+            # table doesn't exist yet, i.e. hasn't been migrated in...
+          end
           
           # character used to seperate a filename from its derivative options, this
           # character will be stripped from all incoming filenames and replaced by
@@ -25,7 +31,7 @@ module Citrusbyte
           # mode to set on stored files and created directories
           options[:chmod]            ||= 0755
           
-          AttachableFile.options = options
+          self.milton_options.merge!(options)
           
           validates_presence_of :filename
           
@@ -43,7 +49,7 @@ module Citrusbyte
         # TODO: change the filename on the underlying file system on save so as
         # not to orphan the file
         def filename=(name)
-          write_attribute :filename, AttachableFile.sanitize_filename(name)
+          write_attribute :filename, AttachableFile.sanitize_filename(name, self.milton_options)
         end
 
         # Simple helper, same as path except returns the directory from
@@ -87,23 +93,21 @@ module Citrusbyte
     # into your model, you get a reference to an AttachableFile (or something
     # that extends AttachableFile).
     class AttachableFile
-      class_inheritable_accessor :options
-
       class << self
-        # Sanitizes the given filename, removes pathnames and the special chars
-        # needed for options seperation for derivatives
-        def sanitize_filename(filename)
-          File.basename(filename, File.extname(filename)).gsub(/^.*(\\|\/)/, '').
-            gsub(/[^\w]|#{Regexp.escape(options[:separator])}/, options[:replacement]).
-            strip + File.extname(filename)
-        end
+      # Sanitizes the given filename, removes pathnames and the special chars
+      # needed for options seperation for derivatives
+      def sanitize_filename(filename, options)
+        File.basename(filename, File.extname(filename)).gsub(/^.*(\\|\/)/, '').
+          gsub(/[^\w]|#{Regexp.escape(options[:separator])}/, options[:replacement]).
+          strip + File.extname(filename)
+      end
 
-        # Creates the given directory and sets it to the mode given in
-        # options[:chmod]
-        def recreate_directory(directory)
-          FileUtils.mkdir_p(directory)
-          File.chmod(options[:chmod], directory)
-        end
+      # Creates the given directory and sets it to the mode given in
+      # options[:chmod]
+      def recreate_directory(directory, options)
+        FileUtils.mkdir_p(directory)
+        File.chmod(options[:chmod], directory)
+      end
         
         # Partitioner that takes an id, pads it up to 12 digits then splits
         # that into 4 folders deep, each 3 digits long.
@@ -132,6 +136,11 @@ module Citrusbyte
         @attachment = attachment
         @filename   = filename
       end
+      
+      # Returns the milton options on the associated attachment.
+      def milton_options
+        self.attachment.class.milton_options
+      end
 
       # Returns the full path and filename to the file with the given options.
       # If no options are given then returns the path and filename to the
@@ -170,12 +179,12 @@ module Citrusbyte
 
         # The full path to the root of where files will be stored on disk.
         def root_path
-          self.class.options[:file_system_path]
+          milton_options[:file_system_path]
         end
 
         # Recreates the directory this file will be stored in.
         def recreate_directory
-          self.class.recreate_directory(dirname) unless File.exists?(dirname)
+          self.class.recreate_directory(dirname, milton_options) unless File.exists?(dirname)
         end
         
         # Removes the containing directory from the filesystem (and hence the
@@ -217,13 +226,6 @@ module Citrusbyte
           }).flatten]
         end
 
-        # Merges the given options to build a derviative filename and returns
-        # the resulting filename.
-        def filename_for(filename, options={})
-          append = options.collect{ |k, v| "#{k}=#{v}" }.sort.join('_')
-          File.basename(filename, File.extname(filename)) + (append.blank? ? '' : "#{AttachableFile.options[:separator]}#{append}") + File.extname(filename)
-        end
-        
         # Given a filename (presumably with options embedded in it) parses out
         # the options and returns them as a hash.
         def extract_options_from(filename)
@@ -247,7 +249,12 @@ module Citrusbyte
       
       # The resulting filename of this Derivative with embedded options.
       def filename
-        self.class.filename_for(@file.path, options)
+        filename = @file.path
+        append   = options.collect{ |k, v| "#{k}=#{v}" }.sort.join('_')
+        
+        File.basename(filename, File.extname(filename)) + 
+        (append.blank? ? '' : "#{@file.milton_options[:separator]}#{append}") + 
+        File.extname(filename)
       end
       
       # The full path and filename to this Derivative.

data/lib/milton/is_resizeable.rb

@@ -11,8 +11,8 @@ module Citrusbyte
           
           ensure_attachment_methods options
 
-          ResizeableFile.options = AttachableFile.options.merge(options)
-          
+          self.milton_options.merge!(options)
+
           extend  Citrusbyte::Milton::IsResizeable::ClassMethods
           include Citrusbyte::Milton::IsResizeable::InstanceMethods
         end

data/lib/milton/is_uploadable.rb

@@ -6,20 +6,18 @@ module Citrusbyte
       end
 
       module IsMethods
-        def is_uploadable(options = {})
-          raise "Milton's is_uploadable requires a filename column on #{class_name} table" unless column_names.include?("filename")
-
+        def is_uploadable(options = {})          
           # TODO: implement size validations
           # options[:min_size]      ||= 1
           # options[:max_size]      ||= 4.megabytes
           # options[:size]          ||= (options[:min_size]..options[:max_size])
           
-          options[:tempfile_path] ||= File.join(RAILS_ROOT, "tmp", "milton")
-
           ensure_attachment_methods options
-
-          UploadableFile.options = AttachableFile.options.merge(options)
           
+          options[:tempfile_path] ||= File.join(RAILS_ROOT, "tmp", "milton")
+          
+          self.milton_options.merge!(options)
+
           after_create :save_uploaded_file
 
           extend  Citrusbyte::Milton::IsUploadable::ClassMethods
@@ -77,10 +75,10 @@ module Citrusbyte
       attr_reader :content_type, :filename, :size
 
       class << self
-        def write_to_temp_file(data_or_path)
-          FileUtils.mkdir_p(self.options[:tempfile_path]) unless File.exists?(self.options[:tempfile_path])
+        def write_to_temp_file(data_or_path, options)
+          FileUtils.mkdir_p(options[:tempfile_path]) unless File.exists?(options[:tempfile_path])
           
-          tempfile = Tempfile.new("#{rand(Time.now.to_i)}", self.options[:tempfile_path])
+          tempfile = Tempfile.new("#{rand(Time.now.to_i)}", options[:tempfile_path])
           
           if data_or_path.is_a?(StringIO)
             tempfile.binmode
@@ -98,8 +96,8 @@ module Citrusbyte
       def initialize(attachment, data_or_path)
         @has_been_saved = false
         @content_type   = data_or_path.content_type
-        @filename       = AttachableFile.sanitize_filename(data_or_path.original_filename) if respond_to?(:filename)
-        @tempfile       = UploadableFile.write_to_temp_file(data_or_path)
+        @filename       = AttachableFile.sanitize_filename(data_or_path.original_filename, attachment.class.milton_options) if respond_to?(:filename)
+        @tempfile       = UploadableFile.write_to_temp_file(data_or_path, attachment.class.milton_options)
         @size           = File.size(self.temp_path)
 
         super attachment, filename
@@ -113,7 +111,7 @@ module Citrusbyte
         return true if self.saved?
         recreate_directory
         File.cp(temp_path, path)
-        File.chmod(self.class.options[:chmod], path)
+        File.chmod(milton_options[:chmod], path)
         @has_been_saved = true
       end
 

data/spec/milton/attachment_spec.rb

@@ -1,6 +1,21 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
 describe Attachment do
+  describe "setting options" do
+    before :each do
+      Attachment.class_eval("is_uploadable :file_system_path => 'foo'")
+      Image.class_eval("is_uploadable :file_system_path => 'bar'")
+    end
+    
+    it "should not overwrite Attachment's file_system_path setting with Image's" do
+      Attachment.milton_options[:file_system_path].should eql('foo')
+    end
+
+    it "should not overwrite Image's file_system_path setting with Attachment's" do
+      Image.milton_options[:file_system_path].should eql('bar')
+    end
+  end
+  
   describe "being destroyed" do
     before :each do
       @attachment = Attachment.create :file => upload('milton.jpg')

data/spec/milton/is_uploadable_spec.rb

@@ -4,28 +4,31 @@ describe Citrusbyte::Milton::IsUploadable do
   class NotUploadable < ActiveRecord::Base
   end
   
+  class NoTable < ActiveRecord::Base
+  end
+  
   describe "filename column" do
+    it 'should not raise an exception if there is a filename column' do
+      lambda { Attachment.class_eval("is_uploadable") }.should_not raise_error
+    end
+
     it "should raise an exception if there is no filename column" do
       lambda { NotUploadable.class_eval("is_uploadable") }.should raise_error
     end
-
-    it 'should not raise an exception if there is a filename column' do
-      lambda { Attachment.class_eval("is_uploadable") }.should_not raise_error
+    
+    it 'should not raise an exception if the underlying table doesn\'t exist' do
+      lambda { NoTable.class_eval('is_uploadable') }.should_not raise_error
     end
   end
   
   describe "setting :file_system_path" do
     it "should allow options to be accessed" do
-      Citrusbyte::Milton::UploadableFile.options.should be_kind_of(Hash)
+      Attachment.milton_options.should be_kind_of(Hash)
     end
     
     it "should be able to overwrite file_system_path from is_uploadable call" do
       Attachment.class_eval("is_uploadable(:file_system_path => 'foo')")
-      Citrusbyte::Milton::UploadableFile.options[:file_system_path].should eql('foo')
-    end
-    
-    after :all do
-      Citrusbyte::Milton::UploadableFile.options[:file_system_path] = File.join(File.dirname(__FILE__), '..', 'output')
+      Attachment.milton_options[:file_system_path].should eql('foo')
     end
   end
     
@@ -70,7 +73,7 @@ describe Citrusbyte::Milton::IsUploadable do
       end
 
       it "should use set file_system_path" do
-        @attachment.path.should =~ /^#{Citrusbyte::Milton::AttachableFile.options[:file_system_path]}.*$/
+        @attachment.path.should =~ /^#{@attachment.milton_options[:file_system_path]}.*$/
       end
       
       it "should use uploaded filename" do

data/spec/schema.rb

@@ -7,4 +7,7 @@ ActiveRecord::Schema.define :version => 0 do
     t.string :filename
     t.string :content_type
   end
+  
+  create_table :not_uploadables, :force => true do |t|
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: citrusbyte-milton
 version: !ruby/object:Gem::Version 
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors: 
 - Ben Alavi