bulldog 0.0.3 → 0.0.4

data/CHANGELOG

@@ -1,3 +1,7 @@
+== 0.0.4 2009-11-16
+
+ * Fix destroying the original file when the record is destroyed.
+
 == 0.0.3 2009-11-16
 
  * Add a way to respond to processing errors:

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.4

data/bulldog.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{bulldog}
-  s.version = "0.0.3"
+  s.version = "0.0.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["George Ogata"]

data/lib/bulldog/attachment/maybe.rb

@@ -120,7 +120,6 @@ module Bulldog
       def interpolate_path(style_name, params={})
         template = reflection.path_template
         style = reflection.styles[style_name]
-        params[:extension] ||= style[:format]
         Interpolation.interpolate(template, record, name, style, params)
       end
 
@@ -135,7 +134,6 @@ module Bulldog
       def interpolate_url(style_name, params={})
         template = reflection.url_template
         style = reflection.styles[style_name]
-        params[:extension] ||= style[:format]
         Interpolation.interpolate(template, record, name, style, params)
       end
 

data/lib/bulldog/interpolation.rb

@@ -3,10 +3,12 @@ module Bulldog
     Error = Class.new(Bulldog::Error)
 
     def self.interpolate(template, record, name, style, overrides={})
-      # TODO: would be nice if this wasn't such a special case.
-      if overrides[:basename]
-        extension = File.extname(overrides[:basename]).sub(/\A./, '')
-        overrides[:extension] ||= extension
+      unless overrides[:extension]
+        overrides = overrides.dup
+        overrides[:extension] ||= style[:format]
+        if overrides[:basename]
+          overrides[:extension] ||= File.extname(overrides[:basename]).sub(/\A./, '')
+        end
       end
       template.gsub(/:(?:(\w+)|\{(\w+?)\})/) do
         key = ($1 || $2).to_sym

data/spec/unit/interpolation_spec.rb

@@ -3,8 +3,8 @@ require 'spec_helper'
 describe Interpolation do
   use_model_class(:Thing, :photo_file_name => :string)
 
-  def interpolate(template)
-    Interpolation.interpolate(template, @thing, :photo, @style)
+  def interpolate(template, overrides={})
+    Interpolation.interpolate(template, @thing, :photo, @style, overrides)
   end
 
   describe ".to_interpolate" do
@@ -36,73 +36,108 @@ describe Interpolation do
     end
   end
 
-  describe "when the file name is not being stored" do
-    before do
-      Thing.has_attachment :photo do
-        style :small, {}
-        store_attributes :file_name => nil
+  describe ".interpolate" do
+    describe "when the file name is not being stored" do
+      before do
+        Thing.has_attachment :photo do
+          style :small
+          store_attributes :file_name => nil
+        end
+        @thing = Thing.new(:photo => test_image_file('test.jpg'))
+        @style = Thing.attachment_reflections[:photo].styles[:small]
       end
-      @thing = Thing.new(:photo => test_image_file('test.jpg'))
-      @style = Thing.attachment_reflections[:photo].styles[:small]
-    end
 
-    it "should interpolate :class as the plural class name" do
-      interpolate("a/:class/b").should == "a/things/b"
-    end
+      it "should interpolate :class as the plural class name" do
+        interpolate("a/:class/b").should == "a/things/b"
+      end
 
-    it "should interpolate :id as the record ID" do
-      @thing.stubs(:id).returns(123)
-      interpolate("a/:id/b").should == "a/123/b"
-    end
+      it "should interpolate :id as the record ID" do
+        @thing.stubs(:id).returns(123)
+        interpolate("a/:id/b").should == "a/123/b"
+      end
 
-    it "should interpolate :id_partition as the record ID split into 3 3-digit partitions, 0-padded" do
-      @thing.stubs(:id).returns(12345)
-      interpolate("a/:id_partition/b").should == "a/000/012/345/b"
-    end
+      it "should interpolate :id_partition as the record ID split into 3 3-digit partitions, 0-padded" do
+        @thing.stubs(:id).returns(12345)
+        interpolate("a/:id_partition/b").should == "a/000/012/345/b"
+      end
 
-    it "should interpolate :attachment as the attachment name" do
-      interpolate("a/:attachment/b").should == "a/photo/b"
-    end
+      it "should interpolate :attachment as the attachment name" do
+        interpolate("a/:attachment/b").should == "a/photo/b"
+      end
 
-    it "should interpolate :style as the style name" do
-      interpolate("a/:style/b").should == "a/small/b"
-    end
+      it "should interpolate :style as the style name" do
+        interpolate("a/:style/b").should == "a/small/b"
+      end
 
-    it "should raise an error for :basename" do
-      lambda{interpolate("a/:basename/b")}.should raise_error(Interpolation::Error)
-    end
+      it "should raise an error for :basename by default" do
+        lambda{interpolate("a/:basename/b")}.should raise_error(Interpolation::Error)
+      end
 
-    it "should raise an error for :extension" do
-      lambda{interpolate("a/:extension/b")}.should raise_error(Interpolation::Error)
-    end
+      it "should raise an error for :extension by default" do
+        lambda{interpolate("a/:extension/b")}.should raise_error(Interpolation::Error)
+      end
 
-    it "should allow using braces for interpolating between symbol characters" do
-      @thing.stubs(:id).returns(5)
-      interpolate("a/x:{id}x/b").should == "a/x5x/b"
-    end
+      it "should allow overriding the basename to use to avoid an error" do
+        interpolate("a/:basename/b", :basename => 'BASENAME').should == 'a/BASENAME/b'
+      end
 
-    it "should raise an error for an unrecognized interpolation key" do
-      lambda{interpolate(":invalid")}.should raise_error(Interpolation::Error)
-    end
-  end
+      it "should allow overriding the extension to use to avoid an error" do
+        interpolate("a/:extension/b", :extension => 'EXT').should == 'a/EXT/b'
+      end
 
-  describe "when the file name is being stored" do
-    before do
-      Thing.has_attachment :photo do
-        style :small, {}
-        store_attributes :file_name => :photo_file_name
+      it "should take the extension from the style format, if given" do
+        @style[:format] = 'FMT'
+        Interpolation.interpolate("a/:extension/b", @thing, :photo, @style).should == 'a/FMT/b'
       end
 
-      @thing = Thing.new(:photo => test_image_file('test.jpg'))
-      @style = Thing.attachment_reflections[:photo].styles[:small]
-    end
+      it "should take the extension from the overridden basename, if given" do
+        interpolate("a/:extension/b", :basename => 'BASENAME.EXT').should == 'a/EXT/b'
+      end
+
+      it "should use an extension override over the style format if both are present" do
+        @style[:format] = 'FMT'
+        interpolate("a/:extension/b", :extension => 'EXT').should == 'a/EXT/b'
+      end
 
-    it "should interpolate :basename as the basename of the uploaded file" do
-      interpolate("a/:basename/b").should == "a/test.jpg/b"
+      it "should use the style format over the basename override if both are present" do
+        @style[:format] = 'FMT'
+        interpolate("a/:extension/b", :basename => 'BASENAME.EXT').should == 'a/FMT/b'
+      end
+
+      it "should not modify the hash of overrides, if given" do
+        overrides = {:basename => 'BASENAME.EXT'}
+        interpolate("a/:extension/b", overrides).should == 'a/EXT/b'
+        overrides.should == {:basename => 'BASENAME.EXT'}
+      end
+
+      it "should allow using braces for interpolating between symbol characters" do
+        @thing.stubs(:id).returns(5)
+        interpolate("a/x:{id}x/b").should == "a/x5x/b"
+      end
+
+      it "should raise an error for an unrecognized interpolation key" do
+        lambda{interpolate(":invalid")}.should raise_error(Interpolation::Error)
+      end
     end
 
-    it "should interpolate :extension as the extension of the uploaded file" do
-      interpolate("a/:extension/b").should == "a/jpg/b"
+    describe "when the file name is being stored" do
+      before do
+        Thing.has_attachment :photo do
+          style :small, {}
+          store_attributes :file_name => :photo_file_name
+        end
+
+        @thing = Thing.new(:photo => test_image_file('test.jpg'))
+        @style = Thing.attachment_reflections[:photo].styles[:small]
+      end
+
+      it "should interpolate :basename as the basename of the uploaded file" do
+        interpolate("a/:basename/b").should == "a/test.jpg/b"
+      end
+
+      it "should interpolate :extension as the extension of the uploaded file" do
+        interpolate("a/:extension/b").should == "a/jpg/b"
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bulldog
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors: 
 - George Ogata