paperdragon 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a8aa8c4f218850c6ed7a5050642db8351df76d47
-  data.tar.gz: 04d4f324dfc84ebd85a42429555dc9ad2bd4d72c
+  metadata.gz: f827f261f58ce5b096178c2b90010e90a99b8e27
+  data.tar.gz: f6731a32d9779faab6b1f83da6df1006acab51a4
 SHA512:
-  metadata.gz: 28d1195ff612e638e39a8a7a26eb2f8e96b2bf0090e6d11dbdba1a81cf3a8a269f803786f9999677aadc7487d0b52da745bc8b361050e4f56b5901818a86dd04
-  data.tar.gz: b8b01e524efaa05b65c428cf1aeb47083ef880253bff8992786d8ecb9b0887a2d1e5186ece278260183b6b2fa51069048ae23508a35dd827e41b5b3744bb7b42
+  metadata.gz: 4481129325b2fa60b3034ae07e1cb4a9e636996f68fc4697c03356863e1e25136f272ae925c12e37ac09b7bff94ebd509d548fa07783df38c957a54e587234ee
+  data.tar.gz: a39824b4503ef45240a09a80845457194504b954cfe66ee4a865207589f5000be7d57dccbceddded4b328b6c2fb0cfaa387e62974999d2c3e8b7f465155a3866

data/README.md

@@ -8,22 +8,64 @@ Add this line to your application's Gemfile:
 
     gem 'paperdragon'
 
-And then execute:
 
-    $ bundle
+Paperdragon is completely decoupled from ActiveRecord. Attachment-related calls are delegated to paperdragon objects, the model is solely used for persisting file UIDs.
 
-Or install it yourself as:
+Where Paperclip or Carrierwave offer you a handy DSL to configure the processing, Paperdragon comes with an API. You _program_ what you wanna do. This is only a tiny little bit more code and gives you complete control over the entire task.
 
-    $ gem install paperdragon
 
-## Usage
 
-TODO: Write usage instructions here
+The goal is to make you _understand_ what is going on.
 
-## Contributing
+* you control processing and storage, e.g. first thumbnails and cropping, then process the rest. easy to sidekiq.
+error handling
+UID generation handled by you. also, updating (e.g. new fingerprint)
+* only process subset, e.g. in test.
 
-1. Fork it ( https://github.com/[my-github-username]/paperdragon/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
+
+File
+
+All process methods return Metadata hash
+yield Job, save it from the block if you need it
+override #default_metadata_for when you wanna change it
+last arg in process method gets merged into metadata hash
+
+Design
+Operations in File look like scripts per design. I could have abstracted various steps into higher level methods, however, as file processing _is_ a lot scripting, I decided to sacrifice redundancy for better understandable code.
+
+
+Paperclip Compatibility
+
+1. Stores file to same location as paperclip would do.
+2. `Photo#url` will return the same URL as paperclip.
+3. P::Model image.url(:thumb) still works, your rendering code will still work.
+4. Cleaner API for generating URLs. For example, we needed to copy images from production to staging. With paperclip, it was impossible to create paths for both environments.
+
+Paperclip uses several columns to compute the UID. Once this is done, it doesn't store that UID in the database but updates the respective fields, which makes it a bit awkward to maintain.
+
+Paperdragon simply dumps the image uid along with meta data into image_meta_data.
+
+You have to take care of updating image_fingerprint etc yourself when changing stuff and still using paperclip to compute urls.
+
+
+
+
+Original paperclip UID:
+it { pic.image(:original).should == "/system/test/pics/images/002/216/376/bc7b26d983db8ced792e38f0c34aba417f75c2e7_key/original-c5b7e624adc5b67e13435baf26e65bc8-1399980114/DSC_4876.jpg" }
+
+1) Uid
+     Failure/Error: should == "system/test/pics/images/002/216/376/bc7b26d983db8ced792e38f0c34aba417f75c2e7_key/original-c5b7e624adc5b67e13435baf26e65bc8-1399980114/DSC_4876.jpg" }
+       expected: "system/test/pics/images/002/216/376/bc7b26d983db8ced792e38f0c34aba417f75c2e7_key/original-c5b7e624adc5b67e13435baf26e65bc8-1399980114/DSC_4876.jpg"
+            got: "system/test/pics/images/002/216/376/bc7b26d983db8ced792e38f0c34aba417f75c2e7_key/original/DSC_4876.jpg" (using ==)
+
+Feel like a hacker reverse-engineering
+
+## Rails
+
+Dragonfly.app.configure do
+  plugin :imagemagick
+
+  datastore :file,
+    :server_root => 'public',
+    :root_path => 'public/images'
+end

data/Rakefile

@@ -1,2 +1,9 @@
 require "bundler/gem_tasks"
+require "rake/testtask"
 
+task :default => [:test]
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  test.test_files = FileList['test/**/*_test.rb']
+  test.verbose = true
+end

data/lib/paperdragon.rb

@@ -1,5 +1,13 @@
 require "paperdragon/version"
+require 'dragonfly'
 
 module Paperdragon
-  # Your code goes here...
+  class MissingUploadError < RuntimeError
+  end
 end
+
+require 'paperdragon/file'
+require 'paperdragon/metadata'
+require 'paperdragon/attachment'
+require 'paperdragon/task'
+require 'paperdragon/model'

data/lib/paperdragon/attachment.rb

@@ -0,0 +1,80 @@
+require 'uber/inheritable_attr'
+
+module Paperdragon
+  # Override #build_uid / #rebuild_uid.
+  # Note that we only encode the UID when computing it the first time. It is then stored encoded
+  # and no escaping happens at any time after that.
+  # You may use options.
+  # only saves metadata, does not know about model.
+  # Attachment is a builder for File and knows about metadata. It is responsible for creating UID if metadata is empty.
+  class Attachment
+    extend Uber::InheritableAttr
+    inheritable_attr :file_class #, strategy: ->{ tap{} }
+    self.file_class = ::Paperdragon::File # default value. # !!! be careful, this gets cloned in subclasses and thereby becomes a subclass of PD:File.
+
+
+    module InstanceMethods
+      def initialize(metadata, options={})
+        @metadata = Metadata.new(metadata)
+        @options  = options # to be used in #(re)build_uid for your convenience. # DISCUSS: we pass in the model here - is that what we want?
+      end
+      attr_reader :metadata # TODO: test me.
+
+      def [](style, file=nil) # not sure if i like passing file here, consider this method signature semi-public.
+        file_metadata = @metadata[style]
+
+        uid = file_metadata[:uid] || uid_from(style, file)
+        self.class.file_class.new(uid, file_metadata)
+      end
+
+      # DSL method providing the task instance.
+      # When called with block, it yields the task and returns the generated metadata.
+      def task(upload=nil, &block)
+        task = Task.new(self, upload, &block)
+
+        return task unless block_given?
+        task.metadata_hash
+      end
+
+      def rebuild_uid(file, fingerprint=nil) # the signature of this method is to be considered semi-private.
+        ext  = ::File.extname(file.uid)
+        name = ::File.basename(file.uid, ext)
+        file.uid.sub(name, "#{name}#{fingerprint}")
+      end
+
+      def exists? # should be #uploaded? or #stored?
+        # not sure if i like that kind of state here, so consider method semi-public.
+        @metadata.populated?
+      end
+
+    private
+      attr_reader :options
+
+      # Computes UID when File doesn't have one, yet. Called in #initialize.
+      def uid_from(*args)
+        build_uid(*args)
+      end
+
+      def build_uid(style, file)
+        # can we use Dragonfly's API here?
+        "#{style}-#{Dragonfly::TempObject.new(file).original_filename}"
+      end
+    end
+
+
+    module SanitizeUid
+      def uid_from(*args)
+        sanitize(super)
+      end
+
+      def sanitize(uid)
+        #URI::encode(uid) # this is wrong, we can't send %21 in path to S3!
+        uid.gsub(/(#|\?)/, "_") # escape # and ?, only.
+      end
+    end
+
+
+    include InstanceMethods
+    include SanitizeUid # overrides #uid_from.
+  end
+end

data/lib/paperdragon/file.rb

@@ -0,0 +1,46 @@
+module Paperdragon
+  # A physical file with a UID.
+  class File
+    def initialize(uid, options={})
+      @uid     = uid
+      @options = options
+      @data    = nil # DISCUSS: do we need that here?
+    end
+
+    attr_reader :uid, :options
+    alias_method :metadata, :options
+
+    def url(opts={})
+      Dragonfly.app.remote_url_for(uid, opts)
+    end
+
+    def data
+      puts "........................FETCH  (data): #{uid}, #{@data ? :cached : (:fetching)}"
+      @data ||= Dragonfly.app.fetch(uid).data
+    end
+
+    # attr_reader :meta_data
+
+    require 'paperdragon/file/operations'
+    include Process
+    include Delete
+    include Reprocess
+    include Rename
+
+
+  private
+    # replaces the UID.
+    def uid!(new_uid)
+      @uid = new_uid
+    end
+
+    # Override if you want to include/exclude properties in this file metadata.
+    def default_metadata_for(job)
+      {:width => job.width, :height => job.height, :uid => uid}#, :content_type => job.mime_type}
+    end
+
+    def metadata_for(job, additional={})
+      default_metadata_for(job).merge(additional)
+    end
+  end
+end

data/lib/paperdragon/file/operations.rb

@@ -0,0 +1,68 @@
+module Paperdragon
+  class File
+    # DISCUSS: allow the metadata passing here or not?
+    module Process
+      def process!(file, metadata={})
+        job = Dragonfly.app.new_job(file)
+
+        yield job if block_given?
+
+        puts "........................STORE  (process): #{uid}"
+        job.store(path: uid, :headers => {'x-amz-acl' => 'public-read', "Content-Type" => "image/jpeg"})
+
+        @data = nil
+        metadata_for(job, metadata)
+      end
+    end
+
+
+    module Delete
+      def delete!
+        puts "........................DELETE (delete): #{uid}"
+        Dragonfly.app.destroy(uid)
+      end
+    end
+
+
+    module Reprocess
+      def reprocess!(fingerprint, original, metadata={})
+        job = Dragonfly.app.new_job(original.data) # inheritance here somehow?
+
+        yield job if block_given?
+
+        old_uid = uid
+        uid!(fingerprint) # new UID is computed and set.
+
+        puts "........................STORE  (reprocess): #{uid}"
+        job.store(path: uid, headers: {'x-amz-acl' => 'public-read', "Content-Type" => "image/jpeg"}) # store with thumb url.
+
+        puts "........................DELETE (reprocess): #{old_uid}"
+        Dragonfly.app.destroy(old_uid)
+
+        @data = nil
+        metadata_for(job, metadata)
+      end
+    end
+
+
+    module Rename
+      def rename!(fingerprint, metadata={}) # fixme: we are currently ignoring the custom metadata.
+        old_uid = uid
+        uid!(fingerprint)
+
+        puts "........................MV:
+    #{old_uid}
+    #{uid}"
+        # dragonfly_s3 = Dragonfly.app.datastore
+        # Dragonfly.app.datastore.storage.copy_object(dragonfly_s3.bucket_name, old_uid, dragonfly_s3.bucket_name, uid, {'x-amz-acl' => 'public-read', "Content-Type" => "image/jpeg"})
+        yield old_uid, uid
+
+        puts "........................DELETE: #{old_uid}"
+        Dragonfly.app.destroy(old_uid)
+
+
+        self.metadata.merge(:uid => uid) # usually, metadata is already set to the old metadata when File was created via Attachment.
+      end
+    end
+  end
+end

data/lib/paperdragon/metadata.rb

@@ -0,0 +1,31 @@
+module Paperdragon
+  # 2-level meta data hash for a file. Returns empty string if not found.
+  # Metadata.new(nil)[:original][:width] => ""
+  # Holds metadata for an attachment. This is a hash keyed by versions, e.g. +:original+,
+  # +:thumb+, and so on.
+  class Metadata
+    def initialize(hash)
+      @hash = hash || {}
+    end
+
+    def [](name)
+      @hash[name] || {}
+    end
+
+    def populated?
+      @hash.size > 0
+    end
+
+    def merge!(hash)
+      @hash.merge!(hash)
+    end
+
+    def dup
+      self.class.new(@hash.dup)
+    end
+
+    def to_hash
+      @hash
+    end
+  end
+end

data/lib/paperdragon/model.rb

@@ -0,0 +1,23 @@
+module Paperdragon
+  module Model
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def processable(name, attachment_class=Attachment)
+        include attachment_accessor_for(name, attachment_class)
+      end
+
+    private
+      # Creates Avatar#image that returns a Paperdragon::File instance.
+      def attachment_accessor_for(name, attachment_class)
+        mod = Module.new do # TODO: abstract that into Uber, we use it everywhere.
+          define_method name do
+            attachment_class.new(self.image_meta_data, {:model => self})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/paperdragon/paperclip.rb

@@ -0,0 +1,68 @@
+module Paperdragon
+  class Paperclip
+
+    # Compute a UID to be compatible with paperclip. This class is meant to be subclassed so you can write
+    # your specific file path.
+    # Immutable
+    class Uid
+      def self.from(options)
+        new(options).call
+      end
+
+      # "/system/:class/:attachment/:id_partition/:style/:filename"
+      def initialize(options)
+        @class_name  = options[:class_name]
+        @attachment  = options[:attachment]
+        @id          = options[:id]
+        @style       = options[:style]
+        @updated_at  = options[:updated_at]
+        @file_name   = options[:file_name]
+        @hash_secret = options[:hash_secret]
+        @fingerprint = options[:fingerprint] # not used in default.
+      end
+
+      def call
+        # default:
+        # system/:class/:attachment/:id_partition/:style/:filename
+        "#{root}/#{class_name}/#{attachment}/#{id_partition}/#{hash}/#{style}/#{file_name}"
+      end
+
+    private
+      attr_reader :class_name, :attachment, :id, :style, :file_name, :hash_secret, :updated_at, :fingerprint
+
+      def root
+        "system"
+      end
+
+      def id_partition
+        IdPartition.call(id)
+      end
+
+      def hash
+        HashKey.call(hash_secret, class_name, attachment, id, style, updated_at)
+      end
+
+
+      class IdPartition
+        def self.call(id)
+          ("%09d" % id).scan(/\d{3}/).join("/") # FIXME: only works with integers.
+        end
+      end
+
+
+      # ":class/:attachment/:id/:style/:updated_at"
+      class HashKey
+        require 'openssl' unless defined?(OpenSSL)
+
+        # cover_girls/images/4841/thumb/1402617353
+        def self.call(secret, class_name, attachment, id, style, updated_at)
+          data = "#{class_name}/#{attachment}/#{id}/#{style}/#{updated_at}"
+          # puts "[Paperdragon] HashKey <--------------------- #{data}"
+          OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA1.new, secret, data)
+        end
+      end
+    end
+  end
+end
+
+require 'paperdragon/paperclip/model'

data/lib/paperdragon/paperclip/model.rb

@@ -0,0 +1,40 @@
+module Paperdragon
+  class Paperclip
+    # DISCUSS: I want to remove this module.
+    module Model
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def processable(name, attachment_class)
+          # this overrides #image (or whatever the name is) from Paperclip::Model::processable.
+          # This allows using both paperclip's `image.url(:thumb)` and the new paperdragon style
+          # `image(:thumb).url`.
+          mod = Module.new do # TODO: merge with attachment_accessor_for.
+            define_method name do # e.g. Avatar#image
+              Proxy.new(self, attachment_class)  # provide paperclip DSL.
+            end
+          end
+          include mod
+        end
+      end
+
+
+      # Needed to expose Paperclip's DSL, like avatar.image.url(:thumb).
+      class Proxy
+        def initialize(model, attachment_class)
+          @attachment = attachment_class.new(model.image_meta_data, {:model => model})
+        end
+
+        def url(style)
+          @attachment[style].url # Avatar::Photo.new(avatar, :thumb).url
+        end
+
+        def method_missing(name, *args)
+          @attachment.send(name, *args)
+        end
+      end
+    end
+  end
+end

data/lib/paperdragon/task.rb

@@ -0,0 +1,51 @@
+module Paperdragon
+  # Gives a simple API for processing multiple versions of a single attachment.
+  class Task
+    def initialize(attachment, upload=nil)
+      @attachment = attachment
+      @upload     = upload
+      @metadata   = attachment.metadata.dup # DISCUSS: keep this dependency?
+
+      yield self if block_given?
+    end
+
+    attr_reader :metadata
+    def metadata_hash # semi-private, might be removed.
+      metadata.to_hash
+    end
+
+    # process!(style, [*args,] &block) :
+    #   version = CoverGirl::Photo.new(@model, style, *args)
+    #   metadata = version.process!(upload, &block)
+    #   merge! {style => metadata}
+    def process!(style, &block)
+      @metadata.merge!(style => file(style, upload).process!(upload, &block))
+    end
+
+    # fingerprint optional => filename is gonna remain the same
+    # original nil => use [:original]
+    def reprocess!(style, fingerprint=nil, original=nil, &block)
+      original ||= file(:original)
+      version    = file(style)
+      new_uid    = @attachment.rebuild_uid(version, fingerprint)
+
+      @metadata.merge!(style => version.reprocess!(new_uid, original, &block))
+    end
+
+    def rename!(style, fingerprint, &block)
+      version = file(style)
+      new_uid = @attachment.rebuild_uid(version, fingerprint)
+
+      @metadata.merge!(style => version.rename!(new_uid, &block))
+    end
+
+  private
+    def file(style, upload=nil)
+      @attachment[style, upload]
+    end
+
+    def upload
+      @upload or raise MissingUploadError.new("You called #process! but didn't pass an uploaded file to Attachment#task.")
+    end
+  end
+end

data/lib/paperdragon/version.rb

@@ -1,3 +1,3 @@
 module Paperdragon
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/paperdragon.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = Paperdragon::VERSION
   spec.authors       = ["Nick Sutterer"]
   spec.email         = ["apotonick@gmail.com"]
-  spec.summary       = %q{Simple but explicit dragonfly attachments.}
-  spec.description   = %q{Simple but explicit dragonfly attachments.}
+  spec.summary       = %q{Explicit image processing based on Dragonfly with Paperclip compatibility.}
+  spec.description   = %q{Explicit image processing based on Dragonfly with Paperclip compatibility.}
   spec.homepage      = ""
   spec.license       = "MIT"
 
@@ -18,6 +18,10 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "dragonfly"
+  spec.add_dependency "uber"
+
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
 end

data/test/attachment_test.rb

@@ -0,0 +1,91 @@
+require 'test_helper'
+
+class AttachmentSpec < MiniTest::Spec
+  class Attachment < Paperdragon::Attachment
+  private
+    def uid_from(style)
+      "/uid/#{style}"
+    end
+  end
+
+  describe "existing" do
+    subject { Attachment.new({:original => {:uid=>"/uid/1234.jpg", :width => 99}}) }
+
+    it { subject[:original].uid.must_equal "/uid/1234.jpg" }
+    it { subject[:original].options.must_equal({:uid=>"/uid/1234.jpg", :width => 99}) }
+    it { subject.exists?.must_equal true }
+  end
+
+  describe "new" do
+    subject { Attachment.new(nil) }
+
+    it { subject[:original].uid.must_equal "/uid/original" }
+    it { subject[:original].options.must_equal({}) }
+    it { subject.exists?.must_equal false }
+  end
+
+  describe "new with empty metadata hash" do
+    subject { Attachment.new({}) }
+
+    it { subject[:original].uid.must_equal "/uid/original" }
+    it { subject[:original].options.must_equal({}) }
+    it { subject.exists?.must_equal false }
+  end
+
+  # #metadata
+  it { Attachment.new({}).metadata.to_hash.must_equal( {}) }
+
+
+  # test passing options into Attachment and use that in #build_uid.
+  class AttachmentUsingOptions < Paperdragon::Attachment
+  private
+    def build_uid(style, file)
+      "uid/#{style}/#{options[:filename]}"
+    end
+  end
+
+  # use in new --> build_uid.
+  it { AttachmentUsingOptions.new(nil, {:filename => "apotomo.png"})[:original].uid.must_equal "uid/original/apotomo.png" }
+
+
+  # test using custom File class in Attachment.
+  class OverridingAttachment < Paperdragon::Attachment
+    class File < Paperdragon::File
+      def uid
+        "from/file"
+      end
+    end
+    self.file_class= File
+  end
+
+  it { OverridingAttachment.new(nil)[:original, Pathname.new("not-considered.JPEG")].uid.must_equal "from/file" }
+
+
+  # test UID sanitising. this happens only when computing the UID with a new attachment!
+  describe "insane filename" do
+    it { AttachmentUsingOptions.new(nil, {:filename => "(use)? apotomo #1#.png"})[:original].uid.must_equal "uid/original/(use)_ apotomo _1_.png" }
+  end
+end
+
+
+class AttachmentModelSpec < MiniTest::Spec
+  class Attachment < Paperdragon::Attachment
+  private
+    def build_uid(style, file)
+      "#{options[:model].class}/uid/#{style}/#{options[:filename]}"
+    end
+  end
+
+  describe "existing" do
+    let (:existing) { OpenStruct.new(:image_meta_data => {:original => {:uid=>"/uid/1234.jpg"}}) }
+    subject { Attachment.new(existing.image_meta_data, :model => existing) }
+
+    it { subject[:original].uid.must_equal "/uid/1234.jpg" } # notice that #uid_from is not called.
+  end
+
+  describe "new" do
+    subject { Attachment.new(nil, :filename => "apotomo.png", :model => OpenStruct.new) } # you can pass options into Attachment::new that may be used in #build_uid
+
+    it { subject[:original].uid.must_equal "OpenStruct/uid/original/apotomo.png" }
+  end
+end

data/test/file_test.rb

@@ -0,0 +1,138 @@
+require 'test_helper'
+
+Dragonfly.app.configure do
+  plugin :imagemagick
+
+  #url_host 'http://some.domain.com:4000'
+
+  datastore :file,
+    :server_root => 'public',
+    :root_path => 'public/paperdragon'
+end
+
+class PaperdragonFileTest < MiniTest::Spec
+  it { Paperdragon::File.new("123").uid.must_equal "123" }
+  it { Paperdragon::File.new("123").url.must_equal "/paperdragon/123" } # FIXME: how to add host?
+  it { Paperdragon::File.new("123") }
+
+  describe "#metadata" do
+    it { Paperdragon::File.new("123").metadata.must_equal({}) }
+    it { Paperdragon::File.new("123", :width => 16).metadata.must_equal({:width => 16}) }
+  end
+
+  describe "#data" do
+    it do
+      Paperdragon::File.new(uid).process!(logo)
+      Paperdragon::File.new(uid).data.size.must_equal 9632
+    end
+  end
+
+  let (:logo) { Pathname("test/fixtures/apotomo.png") }
+
+  # process! saves file
+  # TODO: remote storage, server root, etc.
+  let (:uid) { generate_uid }
+
+
+  describe "#process!" do
+    let (:file) { file = Paperdragon::File.new(uid) }
+
+    it do
+      metadata = file.process!(logo)
+
+      metadata.must_equal({:width=>216, :height=>63, :uid=>uid})
+      exists?(uid).must_equal true
+    end
+
+    # block
+    it do
+      # puts file.data.size # 9632 bytes
+      file.process!(logo) do |job|
+        job.thumb!("16x16")
+      end
+
+      assert file.data.size <= 457 # smaller after thumb!
+    end
+
+    # additional metadata
+    it do
+      file.process!(logo, :cropping => "16x16") do |job|
+        job.thumb!("16x16")
+      end.must_equal({:width=>16, :height=>5, :uid=>uid, :cropping=>"16x16"})
+    end
+  end
+
+
+  describe "#delete!" do
+    it do
+      file = Paperdragon::File.new(uid)
+      file.process!(logo)
+      exists?(uid).must_equal true
+
+      job = Paperdragon::File.new(uid).delete!
+
+      job.must_equal nil
+      exists?(uid).must_equal false
+    end
+  end
+
+
+  describe "#reprocess!" do
+    # existing:
+    let (:file)     { Paperdragon::File.new(uid) }
+    let (:original) { Paperdragon::File.new("original/#{uid}") }
+    let (:new_uid) { generate_uid }
+
+    before do
+      original.process!(logo) # original/uid exists.
+      exists?(original.uid).must_equal true
+      file.process!(logo)
+      exists?(file.uid).must_equal true # file to be reprocessed exists (to test delete).
+    end
+
+    it do
+      metadata = file.reprocess!(new_uid, original)
+
+      # it
+      metadata.must_equal({:width=>216, :height=>63, :uid=>new_uid})
+      # it
+      exists?(uid).must_equal false # deleted
+      exists?(new_uid).must_equal true
+    end
+
+    it do
+      job = file.reprocess!(new_uid, original) do |j|
+        j.thumb!("16x16")
+
+      end
+
+      assert file.data.size <= 457
+    end
+  end
+
+
+  describe "#rename!" do
+    # existing:
+    let (:file)     { Paperdragon::File.new(uid, :size => 99) }
+    let (:original) { Paperdragon::File.new(uid) }
+    let (:new_uid) { generate_uid }
+
+    before do
+      original.process!(logo)
+      exists?(uid).must_equal true
+    end
+
+    it do
+      metadata = file.rename!(new_uid) do |uid, new_uid|
+        File.rename("public/paperdragon/"+uid, "public/paperdragon/"+new_uid) # DISCUSS: should that be simpler?
+      end
+
+      # it
+      # metadata.must_equal({:width=>216, :height=>63, :uid=>new_uid, :content_type=>"application/octet-stream", :size=>9632})
+      metadata.must_equal(:uid=>new_uid, :size => 99) # we DON'T fetch original metadata here anymore.
+
+      exists?(uid).must_equal false # deleted
+      exists?(new_uid).must_equal true
+    end
+  end
+end

data/test/metadata_test.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+
+class MetadataTest < MiniTest::Spec
+  describe "valid" do
+    let (:valid) {
+      {
+        :original=>{:width=>960, :height=>960, :uid=>"403661339/kristylee-38.jpg", :content_type=>"image/jpeg", :size=>198299},
+        :thumb   =>{:width=>191, :height=>191, :uid=>"ds3661339/kristylee-38.jpg", :content_type=>"image/jpeg", :size=>18132}
+      }
+    }
+
+    subject { Paperdragon::Metadata.new(valid) }
+
+    it { subject.populated?.must_equal true }
+    it { subject[:original][:width].must_equal 960 }
+    it { subject[:original][:uid].must_equal "403661339/kristylee-38.jpg" }
+    it { subject[:thumb][:uid].must_equal "ds3661339/kristylee-38.jpg" }
+
+    it { subject[:page].must_equal({}) }
+    it { subject[:page][:width].must_equal nil }
+  end
+
+
+  describe "nil" do
+    subject { Paperdragon::Metadata.new(nil) }
+
+    it { subject.populated?.must_equal false }
+    it { subject[:page].must_equal({}) }
+    it { subject[:page][:width].must_equal nil }
+  end
+
+  describe "empty hash" do
+    subject { Paperdragon::Metadata.new({}) }
+
+    it { subject.populated?.must_equal false }
+    it { subject[:page].must_equal({}) }
+    it { subject[:page][:width].must_equal nil }
+  end
+
+  let (:original) { {:original => {}} }
+
+  # #dup
+  # don't change original hash.
+  it do
+    Paperdragon::Metadata.new(original).dup.merge!(:additional => {})
+    original[:additional].must_equal nil
+  end
+
+  # #merge!
+  it { Paperdragon::Metadata.new(original).merge!(:additional => {}).to_hash.must_equal({:original=>{}, :additional=>{}}) }
+
+  # #to_hash
+  it { Paperdragon::Metadata.new(original).to_hash.must_equal({:original=>{}}) }
+end

data/test/model_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class PaperdragonModelTest < MiniTest::Spec
+  class Avatar
+    class Photo < Paperdragon::File
+    end
+
+    class Attachment < Paperdragon::Attachment
+      self.file_class = Photo
+    end
+
+    include Paperdragon::Model
+    processable :image, Attachment
+
+
+    def image_meta_data
+      {:thumb => {:uid => "Avatar-thumb"}}
+    end
+  end
+
+  it { Avatar.new.image[:thumb].url.must_equal "/paperdragon/Avatar-thumb" }
+
+
+  # minimum setup
+  class Image
+    include Paperdragon::Model
+    processable :image
+
+    def image_meta_data
+      {:thumb => {:uid => "Avatar-thumb"}}
+    end
+  end
+
+  it { Image.new.image[:thumb].url.must_equal "/paperdragon/Avatar-thumb" }
+end

data/test/paperclip_uid_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+require 'paperdragon/paperclip'
+
+class PaperclipUidTest < MiniTest::Spec
+  Uid = Paperdragon::Paperclip::Uid
+
+  let (:options) { {:class_name => :avatars, :attachment => :image, :id => 1234,
+    :style => :original, :updated_at => Time.parse("20-06-2014 9:40:59").to_i,
+    :file_name => "kristylee.jpg", :hash_secret => "secret"} }
+
+  it { Uid.from(options).
+    must_equal "system/avatars/image/000/001/234/9bf15e5874b3234c133f7500e6d615747f709e64/original/kristylee.jpg" }
+
+
+  class UidWithFingerprint < Paperdragon::Paperclip::Uid
+    def call
+      "#{root}/#{class_name}/#{attachment}/#{id_partition}/#{hash}/#{style}/#{fingerprint}-#{file_name}"
+    end
+  end
+
+  it { UidWithFingerprint.from(options.merge(:fingerprint => 8675309)).
+    must_equal "system/avatars/image/000/001/234/9bf15e5874b3234c133f7500e6d615747f709e64/original/8675309-kristylee.jpg" }
+end
+
+
+class PaperclipModelTest < MiniTest::Spec
+  class Avatar
+    class Photo < Paperdragon::File
+    end
+
+    class Attachment < Paperdragon::Attachment
+      self.file_class = Photo
+
+      def exists?
+        "Of course!"
+      end
+    end
+
+    include Paperdragon::Paperclip::Model
+    processable :image, Attachment
+
+
+    def image_meta_data
+      {:thumb => {:uid => "Avatar-thumb"}}
+    end
+  end
+
+  # old paperclip style
+  it { Avatar.new.image.url(:thumb).must_equal "/paperdragon/Avatar-thumb" }
+
+  # paperdragon style
+  it { Avatar.new.image[:thumb].url.must_equal "/paperdragon/Avatar-thumb" }
+
+  # delegates all unknown methods back to Attachment.
+  it { Avatar.new.image.exists?.must_equal "Of course!" }
+end

data/test/task_test.rb

@@ -0,0 +1,105 @@
+require 'test_helper'
+
+class TaskSpec < MiniTest::Spec
+  class Attachment < Paperdragon::Attachment
+    class File < Paperdragon::File
+    end
+    self.file_class= File
+  end
+
+  let (:logo) { Pathname("test/fixtures/apotomo.png") }
+
+
+  # #task allows block and returns metadata hash.
+  describe "#task" do
+    it do
+      Attachment.new(nil).task(logo) do |t|
+        t.process!(:original)
+        t.process!(:thumb) { |j| j.thumb!("16x16") }
+      end.must_equal({:original=>{:width=>216, :height=>63, :uid=>"original-apotomo.png"}, :thumb=>{:width=>16, :height=>5, :uid=>"thumb-apotomo.png"}})
+    end
+  end
+
+  # task without block
+  let (:subject) { Attachment.new(nil).task(logo) }
+
+  describe "#process!" do
+    it do
+      subject.process!(:original)
+      subject.process!(:thumb) { |j| j.thumb!("16x16") }
+
+      subject.metadata_hash.must_equal({:original=>{:width=>216, :height=>63, :uid=>"original-apotomo.png"}, :thumb=>{:width=>16, :height=>5, :uid=>"thumb-apotomo.png"}})
+    end
+
+    it do
+      assert_raises Paperdragon::MissingUploadError do
+        Attachment.new(nil).task.process!(:original)
+      end
+    end
+  end
+
+
+  describe "#reprocess!" do
+    let (:original) { Paperdragon::File.new("original/pic.jpg") }
+
+    before do
+      original.process!(logo) # original/uid exists.
+      exists?(original.uid).must_equal true
+    end
+
+    subject { Attachment.new({
+      :original=>{:uid=>"original/pic.jpg"}, :thumb=>{:uid=>"original/thumb.jpg"}}).task
+    }
+
+    # FIXME: fingerprint should be added before .png suffix, idiot!
+    it do
+      subject.reprocess!(:original, "-1", original)
+      subject.reprocess!(:thumb,    "-1",    original) { |j| j.thumb!("16x16") }
+
+      # it
+      subject.metadata_hash.must_equal({:original=>{:width=>216, :height=>63, :uid=>"original/pic-1.jpg"}, :thumb=>{:width=>16, :height=>5, :uid=>"original/thumb-1.jpg"}})
+      # it
+      # exists?(original.uri).must_equal false # deleted
+      # exists?(new_uid).must_equal true
+    end
+
+    # don't pass in fingerprint+original.
+    it do
+      subject.reprocess!(:thumb) { |j| j.thumb!("24x24") }
+      subject.metadata_hash.must_equal({:original=>{:uid=>"original/pic.jpg"}, :thumb=>{:width=>24, :height=>7, :uid=>"original/thumb.jpg"}})
+    end
+
+    # only process one, should return entire metadata hash
+    it do
+      subject.reprocess!(:thumb, "-new") { |j| j.thumb!("24x24") }
+      subject.metadata_hash.must_equal({:original=>{:uid=>"original/pic.jpg"}, :thumb=>{:width=>24, :height=>7, :uid=>"original/thumb-new.jpg"}})
+
+      # original must be unchanged
+      exists?(Attachment.new(subject.metadata_hash)[:original].uid).must_equal true
+    end
+  end
+
+
+  describe "#rename!" do
+    before do
+      attachment = Paperdragon::Attachment.new(nil)
+      @upload_task = attachment.task(logo)
+      metadata = @upload_task.process!(:original).must_equal({:original=>{:width=>216, :height=>63, :uid=>"original-apotomo.png"}})
+
+      # we do not update the attachment from task.
+      attachment = Paperdragon::Attachment.new(@upload_task.metadata)
+      exists?(attachment[:original].uid).must_equal true
+    end
+
+    let (:metadata) { @upload_task.metadata }
+
+    # let (:subject) { Attachment.new(nil).task }
+    it do
+      attachment = Paperdragon::Attachment.new(metadata) # {:original=>{:width=>216, :height=>63, :uid=>"uid/original", :size=>9632}}
+      task = attachment.task
+      task.rename!(:original, "-new") { |uid, new_uid|
+        File.rename("public/paperdragon/"+uid, "public/paperdragon/"+new_uid)
+      }.must_equal({:original=>{:width=>216, :height=>63, :uid=>"original-apotomo-new.png"}})
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+require 'paperdragon'
+require 'minitest/autorun'
+
+MiniTest::Spec.class_eval do
+  def exists?(uid)
+    File.exists?("public/paperdragon/" + uid)
+  end
+
+  def generate_uid
+    Dragonfly.app.datastore.send(:relative_path_for, "aptomo.png")
+  end
+end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: paperdragon
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-17 00:00:00.000000000 Z
+date: 2014-08-25 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: dragonfly
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: uber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -38,7 +66,21 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Simple but explicit dragonfly attachments.
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Explicit image processing based on Dragonfly with Paperclip compatibility.
 email:
 - apotonick@gmail.com
 executables: []
@@ -51,8 +93,24 @@ files:
 - README.md
 - Rakefile
 - lib/paperdragon.rb
+- lib/paperdragon/attachment.rb
+- lib/paperdragon/file.rb
+- lib/paperdragon/file/operations.rb
+- lib/paperdragon/metadata.rb
+- lib/paperdragon/model.rb
+- lib/paperdragon/paperclip.rb
+- lib/paperdragon/paperclip/model.rb
+- lib/paperdragon/task.rb
 - lib/paperdragon/version.rb
 - paperdragon.gemspec
+- test/attachment_test.rb
+- test/file_test.rb
+- test/fixtures/apotomo.png
+- test/metadata_test.rb
+- test/model_test.rb
+- test/paperclip_uid_test.rb
+- test/task_test.rb
+- test/test_helper.rb
 homepage: ''
 licenses:
 - MIT
@@ -76,6 +134,14 @@ rubyforge_project:
 rubygems_version: 2.2.1
 signing_key: 
 specification_version: 4
-summary: Simple but explicit dragonfly attachments.
-test_files: []
+summary: Explicit image processing based on Dragonfly with Paperclip compatibility.
+test_files:
+- test/attachment_test.rb
+- test/file_test.rb
+- test/fixtures/apotomo.png
+- test/metadata_test.rb
+- test/model_test.rb
+- test/paperclip_uid_test.rb
+- test/task_test.rb
+- test/test_helper.rb
 has_rdoc: