couch_photo 0.0.7 → 1.0.0.beta.1

data/README.markdown

@@ -4,15 +4,74 @@ A mixin for auto-generating image variations on Image documents with CouchDB.
 
 ##Installation
 
+```sh
     $ gem install couch_photo
-
+```
 ## Documentation
 
-Browse the documentation on rdoc.info: http://rdoc.info/github/moonmaster9000/couch_photo
+Browse the documentation on rdoc.info: http://rdoc.info/gems/couch_photo/frames
 
 ##How does it work?
 
-Just "include CouchPhoto" in your "CouchRest::Model::Base" classes and define some variations.
+Just "include CouchPhoto" in your "CouchRest::Model::Base" classes and you can start creating image documents and autogenerating variations with ease.
+
+### The original image
+
+Each image document is centered around the concept of the "original" image. This is the original, unpolluted image that forms the core of the document. 
+
+You can use the `load_original_from_file` method on an instance of your `Image` class to create an image document with an original image from your filesystem:
+
+```ruby
+class Image < CouchRest::Model::Base
+  include CouchPhoto
+end
+
+@image = Image.new
+@image.load_original_from_file "/path/to/my_file.jpg"
+@image.save
+```
+
+Here, we've created a new image instance, then added an "original" image to it via the `load_original_from_file` method by specifiying a file on the disk. Upon `save`, this file is read from disk and stored in CouchDB. We could now access our original image thusly:
+
+```ruby
+@image.original.original_filename # ==> "my_file.jpg"
+@image.original.path              # ==> "/your_image_database/8383830jlkfdjskalfjdirewio/variations/original.jpg"
+@image.original.url               # ==> "http://your_couch_server/your_image_database/8383830jlkfdjskalfjdirewio/variations/original.jpg"
+@image.original.extension         # ==> "jpg"
+@image.original.mimetype          # ==> "image/jpg"
+@image.original.data              # ==> BINARY BLOB
+@image.original.width             # ==> 720
+@image.original.height            # ==> 480
+```
+
+Suppose the original image isn't on file, but simply in memory (perhaps this was a form upload). You can use the `load_original` method to pass a raw binary blob via the `:data` parameter:
+
+```ruby
+@image.load_original :filename => "my_file.jpg", :data => File.read("/path/to/my_file.jpg")
+```
+
+
+### The `override_id!` method
+
+Instead of letting CouchDB generate a UUID for your image documents, you'll likely prefer that the basename of the "original" become the ID of your document. 
+
+You can accomplish this by simply calling the `override_id!` method inside your class definition:
+
+```ruby
+class Image < CouchRest::Model::Base
+  include CouchPhoto
+  override_id!
+end
+```
+
+Now, if you create a new image document with an original, you'll have a much more human readable path to the original image on your CouchDB server:
+
+```ruby
+@image = Image.new
+@image.load_original_from_file "/path/to/my_file.jpg"
+@image.save
+@image.original.url #==> http://your_couch_server/your_image_database/my_file.jpg/variations/original.jpg
+```
 
 ###Simple Variations
 
@@ -20,77 +79,64 @@ Let's imagine we want to auto-generate small, medium, and large variations of ou
 
 First, define an Image document and set the versions on it:
 
-    class Image < CouchRest::Model::Base
-      use_database IMAGE_DB
-      include CouchPhoto
+```ruby
+class Image < CouchRest::Model::Base
+  use_database IMAGE_DB
+  include CouchPhoto
 
-      override_id! # the id of the document will be the basename of the original image file
+  override_id! # the id of the document will be the basename of the original image file
 
-      variations do
-        small "20x20"
-        medium "100x100"
-        large "500x500"
-      end
-    end
+  variations do
+    small "20x20"
+    medium "100x100"
+    large "500x500"
+  end
+end
+```
 
 Next, create an instance of the image document and set the "original" image on it.
 
-    i = Image.new
-    i.original = "avatar.jpg"
-    i.save
-
-By calling the original method with a string, CouchPhoto will attempt to open a file with the same name and use that as the original image. If you don't have
-an actual file (e.g., maybe this was a form upload), then simply pass a blob as the second parameter. For example, 
+```ruby
+i = Image.new
+i.load_original_from_file "/path/to/avatar.jpg"
+i.save
+```
 
-    blob = File.read "avatar.jpg"
-    i.original = ["avatar.jpg", blob]
-
-Now, if you look in your image document in CouchDB, you'd see the following attachments:
+Now, if you look in your image document in CouchDB, you'll see the following attachments:
 
     http://your_couch_server/your_image_database/avatar.jpg/original.jpg
     http://your_couch_server/your_image_database/avatar.jpg/variations/small.jpg
     http://your_couch_server/your_image_database/avatar.jpg/variations/medium.jpg
     http://your_couch_server/your_image_database/avatar.jpg/variations/large.jpg
 
-Notice that, because we called the `override_id!` method, `CouchPhoto` set the ID of your image document to the basename of your original image.
 
 ###Complex Variations
 
 The previous variations were all simple image resizings. What if we wanted to do something a little more complex? Like grayscale the original image? Or create a watermark? No prob!
 
-    class Image < CouchRest::Model::Base
-      use_database IMAGE_DB
-      include CouchPhoto
+```ruby
+class Image < CouchRest::Model::Base
+  use_database IMAGE_DB
+  include CouchPhoto
 
-      override_id! # the id of the document will be the basename of the original image file
+  override_id! # the id of the document will be the basename of the original image file
 
-      variations do
-        grayscale do |original_image|
-          original_image.monochrome
-        end
+  variations do
+    grayscale do |original_image|
+      original_image.monochrome
+    end
 
-        watermark do |original_image|
-          original_image.composite(MiniMagick::Image.open("watermark.png", "jpg") do |c|
-            c.gravity "center"
-          end
-        end
+    watermark do |original_image|
+      original_image.composite(MiniMagick::Image.open("watermark.png", "jpg") do |c|
+        c.gravity "center"
       end
     end
+  end
+end
+```
 
 The `original_image` variable in the blocks is simply the MiniMagick::Image instance of your original image.
 
-### Accessing the Original Image
-
-How do you access the the original image? Let me count the ways: 
-
-    @image.original.original_filename # ==> "avatar.jpg"
-    @image.original.filename # ==> "original.jpg"
-    @image.original.path # ==> "/your_image_database/avatar.jpg/original.jpg"
-    @image.original.url # ==> "http://your_couch_server/your_image_database/avatar.jpg/original.jpg"
-    @image.original.basename # ==> "original.jpg"
-    @image.original.filetype # ==> "jpg"
-    @image.original.mimetype # ==> "image/jpg"
-    @image.original.data # ==> BINARY BLOB
 
 ### Accessing Variations
 
@@ -98,84 +144,136 @@ So, now that you've got some variations, how do you access them? Simple!
 
 Let's go back to our original image example: 
 
-    class Image < CouchRest::Model::Base
-      use_database IMAGE_DB
-      include CouchPhoto
+```ruby
+class Image < CouchRest::Model::Base
+  include CouchPhoto
 
-      override_id! # the id of the document will be the basename of the original image file
+  override_id!
 
-      variations do
-        small "20x20"
-        medium "100x100"
-        large "500x500"
-      end
-    end
+  variations do
+    small "20x20"
+    medium "100x100"
+    large "500x500"
+  end
+end
+
+i = Image.new
+i.load_original_from_file "/path/to/couchdb.jpg"
+i.save
+```
 
-    i = Image.new
-    i.original = "avatar.jpg"
-    i.save
+The `variations` method on our model is a hash of all the variations; the keys are the variation names, and the values are a variation object:
 
 We can access our variations in one of three ways: 
 - the `variations` method, which will allow you to iterate over the variation_name/variation pairs via the `each` method
 - the `variation.<variation_name>` method, which returns a specific variation
-- the `variation("<variation_name>")`, which also returns a specific variation
+- the `variation[:<variation_name>]`, which also returns a specific variation
 
 For example: 
-  
-    i.variations.each do |variation_name, variation_image|
-      puts variation_name
-      puts variation.name
-      puts variation.filename
-      # etc...
-    end
     
-    i.variation.small
-    i.variation "large"
+```ruby
+# iterate over all variations
+i.variations.each do |variation_name, variation_image|
+  puts variation_name
+  puts variation.filename
+  # etc...
+end
+
+# access the "small" variation
+i.variations.small
+
+# access the "large" variation
+i.variations["large"]
+#or...
+i.variations[:large]
+```
 
 Once you've got a variation, you can call several methods on it: 
 
-    i.variation.small.name # ==> "small"
-    i.variation.small.path # ==> "http://your_couch_server/your_image_database/avatar.jpg/variations/small.jpg"
-    i.variation.small.filename # ==> "variations/small.jpg"
-    i.variation.small.basename # ==> "small.jpg"
-    i.variation.small.filetype # ==> "jpg"
-    i.variation.small.mimetype # ==> "image/jpg"
-    i.variation.small.data # ==> BINARY BLOB
+```ruby
+i.variations[:small].name        # ==> "small"
+i.variations[:small].path        # ==> "/your_image_database/avatar.jpg/variations/small.jpg"
+i.variations[:small].url         # ==> "http://your.couch.server/your_image_database/avatar.jpg/variations/small.jpg"
+i.variations[:small].width       # ==> 50
+i.variations[:small].height      # ==> 50
+i.variations[:small].basename    # ==> "small.jpg"
+i.variations[:small].filetype    # ==> "jpg"
+i.variations[:small].mimetype    # ==> "image/jpg"
+i.variations[:small].data        # ==> BINARY BLOB
+```
 
 ## Creating Custom Variations
 
-If you'd like to add a variation to your image document that's not predefined / autogenerated, you can use the add_variation method:
+If you'd like to add a variation to your image document that's not predefined / autogenerated, you can use the `load_custom_variation` and `load_custom_variation_from_file` methods:
 
-    i = Image.new
-    i.original = "somefile.jpg"
-    i.add_variation "variation_name.jpg", :file => "filename.jpg"
-    i.add_variation "variation/name.jpg", :blob => File.read("filename.jpg")
+```ruby
+i = Image.new
+i.load_original_from_file "/path/to/somefile.jpg"
+i.load_custom_variation_from_file "/path/to/small_watermark.jpg"
+i.load_custom_variation :filename => "large_greyscale.jpg", :data => File.read("/path/to/some_image.jpg")
+i.save
+```
 
-These images would be accessible via the following urls :
+These images would be accessible via the following urls:
 
-    http://your_couch_server/your_image_database/somefile.jpg/original.jpg
-    http://your_couch_server/your_image_database/somefile.jpg/variations/variation_name.jpg
-    http://your_couch_server/your_image_database/somefile.jpg/variations/variation/name.jpg
+
+    http://your_couch_server/your_image_database/somefile.jpg/variations/original.jpg
+    http://your_couch_server/your_image_database/somefile.jpg/variations/small_watermark.jpg
+    http://your_couch_server/your_image_database/somefile.jpg/variations/large_watermark.jpg
     
+
 ## XMP Metadata
-Need to access XMP Metadata?  It's as simple as adding xmp_metadata! into your document definition.
 
-    class Image < CouchRest::Model::Base
-      use_database IMAGE_DB
-      include CouchPhoto
+Need to access the XMP Metadata on your original?  It's as simple as adding `extract_xmp_metadata!` into your document definition.
 
-      xmp_metadata!
-      override_id! # the id of the document will be the basename of the original image file
+```ruby
+class Image < CouchRest::Model::Base
+  use_database IMAGE_DB
+  include CouchPhoto
 
-      variations do
-        small "20x20"
-        medium "100x100"
-        large "500x500"
-      end
+  extract_xmp_metadata!
+  override_id! # the id of the document will be the basename of the original image file
+
+  variations do
+    small "20x20"
+    medium "100x100"
+    large "500x500"
+  end
+end
+
+i = Image.new
+i.load_original_from_file "avatar.jpg"
+i.save
+```
+
+Now you can access your image's XMP metadata as a hash by calling `i.xmp_metadata`.
+
+
+## Adding extra properties to your variations
+
+Perhaps you'd like to add some extra properties that you can save for each of your image variations, like "alt" text, or captions. Simply use the `metadata` hash on your variations.
+
+For example, given the following definition:
+
+```ruby
+class Image < CouchRest::Model::Base
+  use_database IMAGE_DB
+  include CouchPhoto
+
+  variations do
+    thumbnail "20x20"
+    grayscale do |original_image|
+      original_image.monochrome
     end
-  
-    i = Image.new
-    i.original = "avatar.jpg"
-    i.save
-  
-Now you can access your image's XMP metadata by calling i.metadata.
+  end
+end
+```
+
+You could now set any metadata properties you desire on your variations:
+
+```ruby
+@image = Image.first
+@image.variations[:small].metadata["alt"] = "alt text"
+@image.variations[:grayscale].metadata["caption"] = "Grayscale version of: #{@image.original.url}"
+@image.save
+```

data/VERSION

@@ -1 +1 @@
-0.0.7
+1.0.0.beta.1

data/couch_photo.gemspec

@@ -16,4 +16,5 @@ Gem::Specification.new do |s|
   s.add_dependency             "couchrest",       "1.0.1"
   s.add_dependency             "mini_magick"
   s.add_dependency             "couchrest_model", "~> 1.0.0"
+  s.add_dependency             "activesupport", "~> 3.0.0"
 end

data/lib/couch_photo.rb

@@ -1,5 +1,10 @@
 require 'mini_magick'
 require 'couchrest_model'
-require 'couch_photo/variations'
-require 'couch_photo/attachment'
+require 'couch_photo/variation_metadata'
+require 'couch_photo/custom_variation'
 require 'couch_photo/couch_photo'
+require 'couch_photo/fake_file'
+require 'couch_photo/original'
+require 'couch_photo/variation_definition'
+require 'couch_photo/variation_config'
+require 'couch_photo/variation'

data/lib/couch_photo/couch_photo.rb

@@ -1,119 +1,114 @@
 module CouchPhoto
   def self.included(base)
-    base.extend ClassMethods
     base.property :original_filename
+    base.property :variation_metadata, Hash, :default => {}
+    base.extend ClassMethods
+    base.before_create :generate_variations
   end
 
-  def update_or_create_attachment(attachment)
-    if self.has_attachment? attachment[:name]
-      self.update_attachment attachment
-    else
-      self.create_attachment attachment
+  module ClassMethods
+    def override_id!
+      self.before_create :set_id_to_original_filename
+    end
+
+    def extract_xmp_metadata!
+      @extract_xmp_metadata = true
+      self.property :xmp_metadata, Hash, :default => nil
+    end
+
+    def variations(&block)
+      @variation_config ||= CouchPhoto::VariationConfig.new
+      @variation_config.instance_eval &block if block
+      @variation_config
+    end
+
+    def extract_xmp_metadata?
+      @extract_xmp_metadata
     end
   end
 
-  def variations
-    @variations = Variations.new self 
+  def load_original_from_file(filepath)
+    original.create_attachment File.basename(filepath), File.read(filepath)
   end
 
-  def original
-    raise "You do not have an original attachment" unless original_attachment_name
-    @original ||= Variation.new self, original_attachment_name
+  def load_original(options)
+    raise "You must provide a :filename parameter" unless options[:filename]
+    raise "You must provide a :data parameter" unless options[:data]
+
+    original.create_attachment options[:filename], options[:data]
   end
 
-  def original_attachment_name
-    @original_attachment_name ||= self["_attachments"].keys.select {|a| a.match /original\.[^\.]+/}.first
+  def load_custom_variation_from_file(filepath)
+    variation_name = File.basename filepath
+    variations[variation_name] = CouchPhoto::CustomVariation.new self, variation_name
+    variations[variation_name].create_attachment File.read(filepath)
   end
 
-  def variation(variation_name=nil)
-    variation_name ? variations.send(variation_name) : variations
+  def load_custom_variation(variation_name, blob)
+    variations[variation_name] = CouchPhoto::CustomVariation.new self, variation_name
+    variations[variation_name].create_attachment blob
   end
 
-  def original=(*args)#filepath, blob=nil
-    if args[0].kind_of?(Array)
-      filepath, blob = args[0].first, args[0].last
-    else
-      filepath = args[0]
-      blob = nil
-    end
-    image_format = filetype(filepath)
-    filename = File.basename filepath
-    basename = File.basename(filepath, "." + "#{image_format}")
-
-    if self.class.xmp_metadata?
-      if blob
-        File.open("/tmp/#{filename}", 'w') { |f| f.write blob } if !blob.nil?
-        `convert /tmp/#{filename} /tmp/#{basename}.xmp`
-      else
-        `convert #{filepath} /tmp/#{basename}.xmp`
-      end
-      self.metadata = Hash.from_xml File.read("/tmp/#{basename}.xmp")
-      File.delete("/tmp/#{basename}.xmp")
-    end
+  def original
+    @original ||= CouchPhoto::Original.new self
+  end
 
-    self["_id"] = filename if self.class.override_id?
-    self.original_filename = filename
-    blob ||= File.read filepath
-    attachment_name = "original.#{image_format}"
-    attachment = {:name => attachment_name, :file => Attachment.new(blob, attachment_name)}
-    update_or_create_attachment attachment
-    self.class.variation_definitions.run_variations(blob).each do |variation_name, variation_blob|
-      update_or_create_attachment :name => "variations/#{variation_name}.#{image_format}", :file => Attachment.new(variation_blob, attachment_name) 
-    end
+  def variations
+    @variations ||= load_variations
   end
-  
-  def add_variation(variation_name, opt={})
-    if opt[:file]
-      blob = File.read("#{opt[:file]}")
-    elsif opt[:blob]
-      blob = opt[:blob]
+
+  private
+  def load_variations
+    all_variations = {}
+
+    # setup defined variations
+    defined_variation_names.each do |defined_variation_name|
+      all_variations[defined_variation_name.to_sym] = CouchPhoto::Variation.new self, defined_variation_name
+    end
+
+    # setup custom variations
+    custom_variation_names.each do |custom_variation_name|
+      all_variations[custom_variation_name] = CouchPhoto::CustomVariation.new self, custom_variation_name
     end
-    update_or_create_attachment :name => "variations/#{variation_name}", :file => Attachment.new(blob, variation_name)
-    variations.add_variation variation_name
+
+    all_variations
   end
   
-  def filetype(filename)
-    filename.match(/^.*\.([^\.]*)$/)[1]
+  def defined_variation_names
+    self.class.variations.variation_definitions.keys.map(&:to_s)
   end
 
-  module ClassMethods
-    def variations(&block)
-      raise "You must pass a block to the `variations' method." unless block
-      variation_definitions.instance_eval(&block)
-    end
-    
-    def override_id!
-      @override_id = true
-    end
-    
-    def xmp_metadata!
-      @xmp_metadata = true
-      self.property :metadata, Hash
-    end
-    
-    def xmp_metadata?
-      @xmp_metadata
-    end
-
-    def override_id?
-      @override_id
+  def custom_variation_names
+    all_variation_names.select do |variation_name| 
+      !defined_variation_names.include?(strip_extension(variation_name))
     end
+  end
 
-    def variation_definitions
-      @variation_definitions ||= VariationDefinitions.new
+  def all_variation_names
+    if self["_attachments"]
+      self["_attachments"].keys.
+        select {|attachment_name| attachment_name.match /variations\/.*/}.
+        map {|attachment_name| attachment_name.gsub(/^variations\/(.*)$/) { $1 }}
+    else
+      []
     end
   end
-  
-  module_function
-  def variation_short_name(variation_path)
-    variation_path.gsub(/(?:variations\/)?(.+)\.[^\.]+/) {$1}
+
+  def strip_extension(filename)
+    filename.gsub(/\.[^.]*/, '')
   end
-  
-  def variation_short_name_from_path(variation_path)
-    variation_path.gsub(/(?:variations\/)?(.+)/) {$1}
+
+  def set_id_to_original_filename
+    if self.original_filename.blank?
+      self.errors.add :original, "must be set before create"
+    else
+      self.id = self.original_filename
+    end
   end
-  
-  def variation_file_extension(variation_path)
-    variation_path.gsub(/(?:variations\/)?.+\.([^\.]+)/) {$1}
+
+  def generate_variations
+    self.class.variations.variation_definitions.each do |variation_name, variation_definition|
+      variation_definition.generate_variation self
+    end
   end
 end

data/lib/couch_photo/custom_variation.rb

@@ -0,0 +1,20 @@
+module CouchPhoto
+  class CustomVariation
+    include VariationMetadata
+
+    def initialize(document, variation_name)
+      @document       = document
+      @variation_name = variation_name
+    end
+
+    def create_attachment(blob)
+      @data = blob
+      @document.create_attachment :name => attachment_name, :file => FakeFile.new(@data)
+    end
+
+    private 
+    def attachment_name
+      "variations/#{@variation_name}"
+    end
+  end
+end

data/lib/couch_photo/{attachment.rb → fake_file.rb}

@@ -1,5 +1,5 @@
 module CouchPhoto
-  class Attachment #:nodoc:
+  class FakeFile
     attr_reader :read, :path
     def initialize(data, path=nil)
       @read = data

data/lib/couch_photo/original.rb

@@ -0,0 +1,32 @@
+module CouchPhoto
+  class Original
+    include VariationMetadata
+
+    def initialize(document)
+      @document = document
+    end
+
+    def create_attachment(filename, data)
+      extension = File.extname filename
+      @data = data
+      @attachment_name = "variations/original#{extension}"
+      @document.create_attachment :name => @attachment_name, :file => FakeFile.new(@data)
+      @document.original_filename = File.basename(filename)
+      @document.xmp_metadata = xmp_metadata if @document.class.extract_xmp_metadata?
+    end
+
+    def original_filename
+      if exists?
+        @document.original_filename
+      end
+    end
+
+    private
+    def attachment_name
+      @attachment_name ||= 
+        @document["_attachments"].keys.select do |attachment_name| 
+          attachment_name.match /variations\/original\.[^.]*/
+        end.first
+    end
+  end
+end

data/lib/couch_photo/variation.rb

@@ -0,0 +1,10 @@
+module CouchPhoto
+  class Variation
+    include VariationMetadata
+
+    def initialize(document, variation_name)
+      @document       = document
+      @variation_name = variation_name
+    end
+  end
+end

data/lib/couch_photo/variation_config.rb

@@ -0,0 +1,19 @@
+module CouchPhoto
+  class VariationConfig
+    attr_reader :variation_definitions
+    
+    def initialize
+      @variation_definitions = {} 
+    end
+
+    def method_missing(variation_name, *args, &block)
+      variation_name = variation_name.to_sym
+      resize_definition = args.first
+      @variation_definitions[variation_name.to_sym] = CouchPhoto::VariationDefinition.new(
+        variation_name, 
+        resize_definition, 
+        &block
+      )
+    end
+  end
+end

data/lib/couch_photo/variation_definition.rb

@@ -0,0 +1,34 @@
+module CouchPhoto
+  class VariationDefinition
+    def initialize(variation_name, resize_definition=nil, &custom_definition)
+      @variation_name    = variation_name
+      @resize_definition = resize_definition
+      @custom_definition = custom_definition
+    end
+
+    def generate_variation(document)
+      attachment_name = "variations/#{@variation_name}.#{document.original.extension}"
+      variation = manipulate document.original.data
+
+      if document.has_attachment?(attachment_name)
+        document.update_attachment :name => attachment_name, :file => FakeFile.new(variation)
+      else
+        document.create_attachment :name => attachment_name, :file => FakeFile.new(variation)
+      end
+    end
+
+    private
+
+    def manipulate(image_blob)
+      mini_magick_image = MiniMagick::Image.read(image_blob)
+      
+      if @resize_definition
+        mini_magick_image.resize @resize_definition 
+      elsif @custom_definition
+        @custom_definition.call mini_magick_image
+      end
+
+      mini_magick_image.to_blob
+    end
+  end
+end

data/lib/couch_photo/variation_metadata.rb

@@ -0,0 +1,70 @@
+module CouchPhoto
+  module VariationMetadata
+    def path
+      if exists?
+        "/#{@document.database.name}/#{@document.id}/#{attachment_name}"
+      end
+    end
+
+    def extension
+      if exists?
+        @extension ||= File.extname(attachment_name).gsub(/\./, '')
+      end
+    end
+
+    def mime_type
+      if exists?
+        @mime_type ||= @document["_attachments"][attachment_name]["content_type"]
+      end
+    end
+
+    def data
+      if exists?
+        @data ||= @document.read_attachment attachment_name
+      end
+    end
+
+    def width
+      mini_magick[:width] 
+    end
+
+    def metadata
+      @document.variation_metadata[@variation_name.to_s] ||= {}
+    end
+
+    def height
+      mini_magick[:height]
+    end
+
+    def xmp_metadata
+      tmp_image_uuid = `uuidgen`.strip
+      tmp_image_file_name = "/tmp/#{tmp_image_uuid}.#{extension}" 
+      tmp_xmp_file_name = "/tmp/#{tmp_image_uuid}.xmp" 
+      mini_magick.write tmp_image_file_name 
+      `convert #{tmp_image_file_name} #{tmp_xmp_file_name} 2> /dev/null` 
+      Hash.from_xml File.read(tmp_xmp_file_name)
+    end
+
+    def url
+      if exists?
+        "#{@document.database.root}/#{@document.id}/#{attachment_name}"
+      end
+    end
+
+    private
+    def exists?
+      !@document["_attachments"][attachment_name].nil?
+    end
+
+    def mini_magick
+      if exists?
+        @mini_magick ||= MiniMagick::Image.read(self.data)
+      end
+    end
+
+    def attachment_name
+      "variations/#{@variation_name}.#{@document.original.extension}"
+    end
+  end
+end
+

metadata

@@ -1,13 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: couch_photo
 version: !ruby/object:Gem::Version 
-  hash: 17
-  prerelease: 
+  hash: 62196353
+  prerelease: 6
   segments: 
+  - 1
   - 0
   - 0
-  - 7
-  version: 0.0.7
+  - beta
+  - 1
+  version: 1.0.0.beta.1
 platform: ruby
 authors: 
 - Matt Parker
@@ -15,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-20 00:00:00 Z
+date: 2011-09-25 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: cucumber
@@ -105,6 +107,22 @@ dependencies:
         version: 1.0.0
   type: :runtime
   version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id007
 description: Manage an image and all of its variations and xmp metadata in a single document.
 email: moonmaster9000@gmail.com
 executables: []
@@ -114,9 +132,14 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/couch_photo/attachment.rb
 - lib/couch_photo/couch_photo.rb
-- lib/couch_photo/variations.rb
+- lib/couch_photo/custom_variation.rb
+- lib/couch_photo/fake_file.rb
+- lib/couch_photo/original.rb
+- lib/couch_photo/variation.rb
+- lib/couch_photo/variation_config.rb
+- lib/couch_photo/variation_definition.rb
+- lib/couch_photo/variation_metadata.rb
 - lib/couch_photo.rb
 - VERSION
 - README.markdown
@@ -141,12 +164,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 25
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: 

data/lib/couch_photo/variations.rb

@@ -1,103 +0,0 @@
-module CouchPhoto
-
-  
-  class VariationDefinitions
-    attr_reader :variations
-    
-    def initialize
-      @variations = {}
-    end
-
-    def method_missing(method_name, *args, &block)
-      if block
-        @variations[method_name.to_sym] = VariationDefinition.new method_name, *args, &block
-      else
-        @variations[method_name.to_sym] = VariationDefinition.new method_name, *args
-      end
-    end
-
-    def run_variations(blob)
-      results = {}
-      @variations.each do |variation_name, variation|
-        results[variation_name] = variation.create_variation blob
-      end
-      results
-    end
-  end
-
-  class VariationDefinition
-    def initialize(name, format=nil, &block)
-      raise "A variation can not have both a format and a block. Choose one." if format and block
-      raise "A variation must have either a format (e.g., '20x20>') or a block." if !format and !block
-      @name = name
-      @format = format
-      @block = block
-    end
-
-    def create_variation(blob)
-      image = MiniMagick::Image.read(blob)
-      @format ? image.resize(@format) : @block.call(image)
-      image.to_blob
-    end
-  end
-
-  class Variations
-    attr_reader :variations, :document
-
-    def initialize(document)
-      @document = document
-      @variations = {}
-      attachments = document["_attachments"] || {}
-      attachments.keys.select {|name| name.match /variations\//}.each do |variation_name|
-        if document.class.variation_definitions.variations.keys.include?(CouchPhoto.variation_short_name(variation_name).to_sym)
-          variation_key = CouchPhoto.variation_short_name(variation_name)
-        else
-          variation_key = CouchPhoto.variation_short_name_from_path(variation_name)
-        end
-        @variations[variation_key] = Variation.new document, variation_name
-      end
-    end
-    
-    def each(&block)
-      @variations.each &block
-    end
-    
-    def count
-      attachments = self.document["_attachments"] || {}
-      attachments.keys.count {|name| name.match /variations\//}
-    end
-
-    def method_missing(method_name, *args, &block)
-      raise "Unknown variation '#{method_name}'" unless @variations[method_name.to_s]
-      @variations[method_name.to_s]
-    end
-    
-    def add_variation(variation_name)
-      @variations[variation_name] = Variation.new document, "variations/#{variation_name}"
-    end
-  end
-
-  class Variation
-    attr_reader :name, :url, :path, :filename, :basename, :filetype, :mimetype
-
-    def initialize(document, attachment_name)
-      @path = "/" + [document.database.name, document.id, attachment_name].join("/")
-      @url = [document.database.to_s, document.id, attachment_name].join "/"
-      @attachment_name = attachment_name
-      @name = CouchPhoto.variation_short_name attachment_name
-      @filename = attachment_name
-      @basename = File.basename attachment_name 
-      @document = document
-      @filetype = CouchPhoto.variation_file_extension attachment_name
-      @mimetype = document["_attachments"][attachment_name]["content_type"]
-    end
-
-    def data
-      @document.read_attachment @attachment_name
-    end
-
-    def original_filename
-      @document.original_filename
-    end
-  end
-end