imagery 0.0.6 → 0.2.0

data/lib/imagery/faking.rb

@@ -1,4 +1,4 @@
-module Imagery
+class Imagery
   module Faking
     def self.included(base)
       base.extend ClassMethods
@@ -73,7 +73,7 @@ module Imagery
 
     # Implement the stubbed version of save and skips actual operation
     # if Imagery::Model.mode == :fake
-    def save(io)
+    def save(io, key = nil)
       return true if self.class.mode == :fake
 
       super

data/lib/imagery/s3.rb

@@ -1,165 +1,106 @@
-require 'aws/s3'
+require "aws/s3"
 
-module Imagery
+class Imagery
   module S3
-    def self.included(base)
-      base.extend Configs
-      class << base
-        attr_writer :s3_bucket, :s3_distribution_domain, :s3_host
-      end
+    def self.included(imagery)
+      imagery.extend Config
+  
+      # Set the default host for amazon S3. You can also set this
+      # to https://s3.amazon.com if you want to force secure connections
+      # on a global scale.
+      imagery.s3_host "http://s3.amazonaws.com"
     end
 
-    module Configs
+    module Config
       def s3_bucket(bucket = nil)
-        @s3_bucket = bucket  if bucket
-        @s3_bucket || raise(UndefinedBucket, BUCKET_ERROR_MSG)
+        @s3_bucket = bucket if bucket
+        @s3_bucket
       end
 
-      BUCKET_ERROR_MSG = (<<-MSG).gsub(/^ {6}/, '')
-
-      You need to define a bucket name. Example:
-
-      class Imagery::Model
-        include Imagery::S3
-
-        s3_bucket 'my-bucket-name'
-      end
-      MSG
-
       def s3_distribution_domain(domain = nil)
-        @s3_distribution_domain = domain  if domain
+        @s3_distribution_domain = domain if domain
         @s3_distribution_domain
       end
-  
-      # Allows you to customize the S3 host. Usually happens when you use
-      # amazon S3 EU.
-      #
-      # @param [String] host the custom host you want to use instead.
-      # @return [String] the s3 host currently set.
+
       def s3_host(host = nil)
-        @s3_host = host  if host
-        @s3_host || S3_HOST
+        @s3_host = host if host
+        @s3_host
       end
     end
-  
-    UndefinedBucket = Class.new(StandardError)
 
-    S3_HOST = "http://s3.amazonaws.com"
+    # Convenience attribute which returns all size keys including `:original`.
+    attr :keys
 
-    # Returns a url publicly accessible. If a distribution domain is set,
-    # then the url will be based on that.
-    #
-    # @example
-    #   
-    #   class Imagery::Model
-    #     include Imagery::S3
-    #
-    #     s3_bucket 'bucket-name'
-    #   end
-    #   
-    #   Photo = Class.new(Struct.new(:id))
-    #   i = Imagery.new(Photo.new(1001))
-    #
-    #   i.url == 'http://s3.amazonaws.com/bucket-name/photo/1001/original.png'
-    #   # => true
-    #
-    #   Imagery::Model.s3_distribution_domain = 'assets.site.com'
-    #   i.url == 'http://assets.site.com/photo/1001/original.png'
-    #   # => true
-    #
-    #   # You may also subclass this of course since it's just a ruby object
-    #   # and configure them differently as needed.
-    #
-    #   class CloudFront < Imagery::Model
-    #     include Imagery::S3
-    #     s3_bucket 'cloudfront'
-    #     s3_distribution_domain 'assets.site.com'
-    #   end
-    #
-    #   class RegularS3 < Imagery::Model
-    #     include Imagery::S3
-    #     s3_bucket 'cloudfront'
-    #   end
+    def initialize(*args)
+      super
+
+      @keys = [@original] + sizes.keys
+    end
+    
+    # If you specify a distribution domain (i.e. a cloudfront domain,
+    # or even an S3 domain with a prefix), that distribution domain is
+    # used.
     #
-    # @param [Symbol] size the preferred size you want for the url.
-    # @return [String] the size specific url.
-    def url(size = self.default_size)
-      if domain = self.class.s3_distribution_domain
-        [domain, namespace, key, filename(size)].join('/')
+    # Otherwise the default canonical S3 url is used.
+    def url(file = @original)
+      if self.class.s3_distribution_domain
+        "#{self.class.s3_distribution_domain}#{super}"
       else
-        [self.class.s3_host, self.class.s3_bucket, namespace, key, filename(size)].join('/')
+        "#{self.class.s3_host}/#{self.class.s3_bucket}#{super}"
       end
     end
-
-    # In addition to saving the files and resizing them locally, uploads all
-    # the different sizes to amazon S3.
-    def save(io)
-      if super
-        s3_object_keys.each do |key, size|
-          Gateway.store(key,
-            File.open(file(size)),
-            self.class.s3_bucket,
-            :access => :public_read,
-            :content_type => "image/png"
-          )
-        end
-      end
+  
+    # Returns the complete S3 key used for this object. The S3 key
+    # is simply composed of the prefix and filename, e.g.
+    #
+    # - photos/1001/original.jpg
+    # - photos/1001/small.jpg
+    # - photos/1001/tiny.jpg
+    #
+    def s3_key(file)
+      "#{prefix}/#{key}/#{ext(file)}"
     end
-
-    # Deletes all the files related to this Imagery instance and also
-    # all the S3 keys.
+  
+    # Deletes all keys defined for this object, which includes `:original`
+    # and all keys in `sizes`.
     def delete
       super
-      s3_object_keys.each do |key, size|
-        Gateway.delete key, self.class.s3_bucket
+
+      keys.each do |file|
+        Gateway.delete(s3_key(file), self.class.s3_bucket)
       end
     end
+  
+    # Save the object as we normall would, but also upload all resulting
+    # files to S3. We set the proper content type and Cache-Control setting
+    # optimized for a cloudfront setup.
+    def save(io, key = nil)
+      super
 
-  protected
-    def s3_object_keys
-      sizes.keys.map do |size|
-        [[namespace, key, filename(size)].join('/'), size]
+      keys.each do |file|
+        Gateway.store(s3_key(file),
+          File.open(root(ext(file))),
+          self.class.s3_bucket,
+          :access => :public_read,
+          :content_type => "image/jpeg",
+          "Cache-Control" => "max-age=315360000"
+        )
       end
     end
-
+  
+    # Provides a convenience wrapper around AWS::S3::S3Object and
+    # serves as an auto-connect module.
     module Gateway
-      # A wrapper for AWS::S3::S3Object.store. Basically auto-connects
-      # using the environment vars.
-      #
-      # @example
-      #   
-      #   AWS::S3::Base.connected?
-      #   # => false
-      #
-      #   Imagery::S3::Gateway.store(
-      #     'avatar', File.open('avatar.jpg'), 'bucket'
-      #   )
-      #   AWS::S3::Base.connected?
-      #   # => true
-      #       
-      def store(*args)
+      def self.store(*args)
         execute(:store, *args)
       end
-      module_function :store
       
-      # A wrapper for AWS::S3::S3Object.delete. Basically auto-connects
-      # using the environment vars.
-      #
-      # @example
-      #   
-      #   AWS::S3::Base.connected?
-      #   # => false
-      #
-      #   Imagery::S3::Gateway.delete('avatar', 'bucket')
-      #   AWS::S3::Base.connected?
-      #   # => true
-      def delete(*args)
+      def self.delete(*args)
         execute(:delete, *args)
       end
-      module_function :delete
     
     private
-      def execute(command, *args)
+      def self.execute(command, *args)
         begin
           AWS::S3::S3Object.__send__(command, *args)
         rescue AWS::S3::NoConnectionEstablished
@@ -170,7 +111,6 @@ module Imagery
           retry
         end
       end
-      module_function :execute
     end
   end
 end

data/lib/imagery/test.rb

@@ -1,16 +1,16 @@
-module Imagery
+class Imagery
   module Test
     def self.included(base)
-      Imagery::Model.send :include, Imagery::Faking
-      Imagery::Model.mode = :fake
+      Imagery.send :include, Imagery::Faking
+      Imagery.mode = :fake
     end
 
   protected
     def imagery
       if ENV["REAL_IMAGERY"]
-        Imagery::Model.real { yield true }
+        Imagery.real { yield true }
       else
-        Imagery::Model.faked { yield false }
+        Imagery.faked { yield false }
       end
     end
   end

data/test/faking.rb

@@ -0,0 +1,71 @@
+require File.expand_path("helper", File.dirname(__FILE__))
+require "stringio"
+
+# Imagery::Test hooks
+scope do
+  setup do
+    Object.send :include, Imagery::Test
+  end
+
+  test "auto-includes Imagery::Faking upon inclusion" do
+    assert Imagery.ancestors.include?(Imagery::Faking)
+  end
+
+  test "auto-sets mode to :fake" do
+    assert_equal :fake, Imagery.mode
+  end
+end
+
+
+class Imagery
+  include Faking
+end
+
+test "skips saving when faked" do
+  Imagery.mode = :fake
+
+  i = Imagery.new(:avatar, "1001")
+  i.save(StringIO.new)
+
+  assert ! File.exist?(Imagery.root("avatar", "1001"))
+end
+
+test "skips deleting when faked" do
+  Imagery.mode = :fake
+  
+  FileUtils.mkdir_p(Imagery.root("avatar", "1001"))
+
+  i = Imagery.new(:avatar, "1001")
+  i.delete
+
+  assert File.exist?(Imagery.root("avatar", "1001"))
+end
+
+# Imagery::Test
+scope do
+  extend Imagery::Test
+
+  test "yields true when REAL_IMAGERY is set" do
+    ENV["REAL_IMAGERY"] = "true"
+  
+    enabled = nil
+
+    imagery do |e|
+      enabled = e  
+    end
+
+    assert enabled
+  end
+
+  test "yields false when REAL_IMAGERY is not set" do
+    ENV["REAL_IMAGERY"] = nil
+  
+    enabled = nil
+
+    imagery do |e|
+      enabled = e  
+    end
+
+    assert_equal false, enabled
+  end
+end

data/test/helper.rb

@@ -1,12 +1,31 @@
-require 'rubygems'
-require 'test/unit'
-require 'contest'
-require 'mocha'
+$:.unshift(File.expand_path("../lib", File.dirname(__FILE__)))
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'imagery'
+require "cutest"
+require "imagery"
 
-class Test::Unit::TestCase
-  FIXTURES = File.dirname(__FILE__) + '/fixtures'
+def fixture(filename)
+  File.expand_path("fixtures/#{filename}", File.dirname(__FILE__))
+end
+
+def resolution(file)
+  `gm identify #{file}`[/(\d+x\d+)/, 1]
+end
+
+prepare do
+  FileUtils.rm_rf(File.expand_path("../public", File.dirname(__FILE__)))
+  Imagery::S3::Gateway.commands.clear
+end
+
+class Imagery
+  module S3
+    module Gateway
+      def self.execute(command, *args)
+        commands << [command, *args.select { |a| a.respond_to?(:to_str) }]
+      end
+
+      def self.commands
+        @commands ||= []
+      end
+    end
+  end
 end

data/test/imagery.rb

@@ -0,0 +1,172 @@
+require File.expand_path("helper", File.dirname(__FILE__))
+
+test "defining with a prefix" do
+  i = Imagery.new(:avatar)
+
+  assert_equal "avatar", i.prefix
+end
+
+test "defining with a key" do
+  i = Imagery.new(:avatar, "1001")
+
+  assert_equal "avatar", i.prefix
+  assert_equal "1001", i.key
+end
+
+test "defining with sizes" do
+  i = Imagery.new(:avatar, "1001", small: ["100x100"])
+
+  assert_equal "avatar", i.prefix
+  assert_equal "1001", i.key
+  assert_equal({ small: ["100x100"] }, i.sizes)
+end
+
+test "root defined to be Dir.pwd/public" do
+  assert_equal File.join(Dir.pwd, "public"), Imagery.root
+end
+
+test "root accepts arguments" do
+  assert_equal File.join(Dir.pwd, "public", "tmp"), Imagery.root("tmp")
+end
+
+test "allows override of the default Dir.pwd" do
+  begin
+    tmp = File.expand_path("tmp", File.dirname(__FILE__))
+
+    Imagery.root = tmp
+    assert_equal tmp, Imagery.root
+
+  ensure
+    Imagery.root = File.join(Dir.pwd, "public")
+  end
+end
+
+test "url when missing key" do
+  i = Imagery.new(:avatar)
+
+  assert_equal "/missing/avatar/original.jpg", i.url
+end
+
+test "url with a key" do
+  i = Imagery.new(:avatar, "1001")
+  assert_equal "/avatar/1001/original.jpg", i.url
+end
+
+test "url with a key and a file" do
+  i = Imagery.new(:avatar, "1001")
+  assert_equal "/avatar/1001/small.jpg", i.url(:small)
+end
+
+# basic persistence
+scope do
+  setup do
+    imagery = Imagery.new(:avatar, "1001")
+    io = File.open(fixture("r8.jpg"), "rb")
+
+    [imagery, io]
+  end
+
+  test "saving without any sizes defined" do |im, io|
+    assert im.save(io)
+
+    assert File.exist?(im.root("original.jpg"))
+    assert_equal "1024x768", resolution(im.root("original.jpg"))
+  end
+
+  test "saving and specifying the key" do |im, io|
+    assert im.save(io, "GUID")
+    assert File.exist?(Imagery.root("avatar/GUID/original.jpg"))
+  end
+
+  test "saving with an already existing image" do |im, io|
+    im.save(io)
+
+    assert im.save(io, "GUID")
+    assert File.exist?(Imagery.root("avatar/GUID/original.jpg"))
+    assert ! File.exist?(Imagery.root("avatar/1001/original.jpg"))
+  end
+end
+
+# basic resizing
+scope do
+  setup do
+    imagery = Imagery.new(:avatar, 1, small: ["100x100"], tiny: ["30x30"])
+    io = File.open(fixture("r8.jpg"), "rb")
+
+    [imagery, io]
+  end
+
+  test "saves the different sizes" do |im, io|
+    assert im.save(io)
+
+    assert File.exist?(im.root("original.jpg"))
+    assert File.exist?(im.root("small.jpg"))
+    assert File.exist?(im.root("tiny.jpg"))
+
+    assert_equal "1024x768", resolution(im.root("original.jpg"))
+
+    # Since there was no extent or geometry specified, this will
+    # be resized by fitting the image proportionally within 100x100.
+    assert_equal "100x75", resolution(im.root("small.jpg"))
+
+    # Like small.jpg, it will be resized to fit within 30x30
+    assert_equal "30x23", resolution(im.root("tiny.jpg"))
+  end
+end
+
+# resizing with extent
+scope do
+  setup do
+    imagery = Imagery.new(:avatar, 1, small: ["100x100^", "100x100"])
+    io = File.open(fixture("r8.jpg"), "rb")
+
+    [imagery, io]
+  end
+
+  test "saves an image maximized within the extent" do |im, io|
+    im.save(io)
+
+    assert_equal "100x100", resolution(im.root("small.jpg"))
+  end
+end
+
+# saving a corrupted / unrecognized file
+scope do
+  setup do
+    imagery = Imagery.new(:avatar, 1, small: ["100x100^", "100x100"])
+    io = File.open(fixture("r8.jpg"), "rb")
+
+    [imagery, io]
+  end
+
+  test "creating a new image" do |im, io|
+    ex = nil
+
+    begin
+      im.save(File.open(fixture("broken.jpg"), "rb"))
+    rescue Imagery::InvalidImage => e
+      ex = e
+    end
+
+    assert ex
+
+    o, s = im.root("original.jpg"), im.root("small.jpg")
+
+    assert ! File.exist?(o)
+    assert ! File.exist?(s)
+  end
+
+  test "trying to save over an existing image" do |im, io|
+    im.save(io)
+
+    o, s = im.root("original.jpg"), im.root("small.jpg")
+
+    begin
+      im.save(File.open(fixture("broken.jpg"), "rb"), 2)
+    rescue Imagery::InvalidImage
+    end
+
+    assert File.exist?(o)
+    assert File.exist?(s)
+  end
+end