snapimage 0.1.1 → 0.2.0

data/README.md

@@ -20,9 +20,9 @@ Or install it yourself as:
 
 Generate a config file (default is "config/snapimage\_config.yml"). SnapImage comes with a script to do that.
 
-    $ snapimage_generate_config <local root>
+    $ snapimage_generate_config <adapter> [options]
 
-The local root argument is a path that tells SnapImage where to store the uploaded files. For other options, use the -h flag.
+For details, use the -h flag.
 
     $ snapimage_generate_config -h
 

data/bin/snapimage_generate_config

@@ -10,10 +10,10 @@ options = {
 }
 
 optparse = OptionParser.new do |opts|
-  opts.banner = "Usage: snapimage_generate_config local_root [options]"
+  opts.banner = "Usage: snapimage_generate_config <adapter> [options]"
 
   opts.separator ""
-  opts.separator "local_root\tPath to the directory where the images will be stored"
+  opts.separator "adapter\tStorage adapter to use (local, cloudinary)"
 
   opts.separator ""
   opts.separator "Options:"
@@ -26,6 +26,14 @@ optparse = OptionParser.new do |opts|
     options[:size] = size.to_i
   end
 
+  opts.on("-r", "--local_root PATH", "Path to the directory where the images will be stored (only for the local adapter and must be specified)") do |local_root|
+    options[:local_root] = local_root
+  end
+
+  opts.on("-u", "--public_url URL", "Public URL to where the images will be accessible (only for the local adapter and must be specified)") do |public_url|
+    options[:public_url] = public_url
+  end
+
   opts.on("--force", "Overwrites the file if it exists") do
     options[:force] = true
   end
@@ -38,11 +46,27 @@ end
 optparse.parse!
 
 unless ARGV.length == 1
+  puts "Missing adapter."
+  puts
   puts optparse.help
   exit
 end
+adapter = ARGV[0]
 
-local_root = ARGV[0]
+# Check for mandatory options.
+if adapter == "local"
+  if !options[:local_root] or !options[:public_url]
+    puts "When using the local adapter, local_root and public_url must be specified."
+    puts
+    puts optparse.help
+    exit
+  end
+elsif adapter == "cloudinary"
+  # Nothing to check for.
+else
+  puts optparse.help
+  exit
+end
 
 if !options[:force] && File.exists?(options[:file])
   puts "File '#{options[:file]}' already exists. Use --force if you want to overwrite."
@@ -54,10 +78,19 @@ end
 
 FileUtils.mkdir_p(File.dirname(options[:file]))
 File.open(options[:file], "w") do |f|
-  f.write(<<-EOF
-directory: "#{local_root}"
+  if adapter == "local"
+    f.write(<<-EOF
+adapter: "local"
+directory: "#{options[:local_root]}"
+public_url: "#{options[:public_url]}"
 max_file_size: #{options[:size]}
-EOF
-  )
+    EOF
+    )
+  elsif adapter == "cloudinary"
+    f.write(<<-EOF
+adapter: "cloudinary"
+    EOF
+    )
+  end
 end
 puts "Config file generated at '#{options[:file]}'."

data/lib/snapimage.rb

@@ -2,24 +2,16 @@ require "rack"
 require "yaml"
 require "json"
 require "fileutils"
-require "digest/sha1"
-#require "open-uri"
-#require "RMagick"
 require "snapimage/version"
 require "snapimage/exceptions"
 require "snapimage/rack/request_file"
 require "snapimage/rack/request"
 require "snapimage/rack/response"
-#require "snapimage/image/image"
-#require "snapimage/image/image_name_utils"
-#require "snapimage/storage/storage_server"
-#require "snapimage/storage/storage_server.local"
-#require "snapimage/storage/storage"
+require "snapimage/adapters/local/config"
+require "snapimage/adapters/local/storage"
+require "snapimage/adapters/cloudinary/config"
+require "snapimage/adapters/cloudinary/storage"
 require "snapimage/config"
-#require "snapimage/server_actions/server_actions.authorize"
-#require "snapimage/server_actions/server_actions.generate_image"
-#require "snapimage/server_actions/server_actions.sync_resource"
-#require "snapimage/server_actions/server_actions.delete_resource_images"
-#require "snapimage/server_actions/server_actions.list_resource_images"
+require "snapimage/storage"
 require "snapimage/server"
 require "snapimage/middleware"

data/lib/snapimage/adapters/cloudinary/config.rb

@@ -0,0 +1,13 @@
+module SnapImage
+  module Cloudinary
+    class Config
+      def initialize(config)
+        @config = config
+      end
+
+      def validate_config
+        # Nothing to validate.
+      end
+    end
+  end
+end

data/lib/snapimage/adapters/cloudinary/storage.rb

@@ -0,0 +1,22 @@
+module SnapImage
+  module Cloudinary
+    class Storage
+      def initialize(config)
+        @config = config
+      end
+
+      # Stores the file in the given directory and returns the publicly
+      # accessible URL.
+      # Options:
+      # * directory - directory to store the file in
+      def store(filename, file, options = {})
+        ext = File.extname(filename)
+        basename = File.basename(filename, ext)
+        public_id = "#{basename}_#{rand(9999)}"
+        public_id = File.join(options[:directory], public_id) if options[:directory]
+        response = ::Cloudinary::Uploader.upload(file, public_id: public_id)
+        ::Cloudinary::Utils.cloudinary_url(public_id + ext)
+      end
+    end
+  end
+end

data/lib/snapimage/adapters/local/config.rb

@@ -0,0 +1,14 @@
+module SnapImage
+  module Local
+    class Config
+      def initialize(config)
+        @config = config
+      end
+
+      def validate_config
+        raise SnapImage::InvalidConfig, 'Missing "directory"' unless @config["directory"]
+        raise SnapImage::InvalidConfig, 'Missing "public_url"' unless @config["public_url"]
+      end
+    end
+  end
+end

data/lib/snapimage/adapters/local/storage.rb

@@ -0,0 +1,48 @@
+module SnapImage
+  module Local
+    class Storage
+      def initialize(config)
+        @config = config
+        @directory = config["directory"]
+        @public_url = config["public_url"]
+      end
+
+      # Stores the file in the given directory and returns the publicly
+      # accessible URL.
+      # Options:
+      # * directory - directory to store the file in
+      def store(filename, file, options = {})
+        file_directory = File.join(@directory, options[:directory])
+        file_path = get_file_path(file_directory, filename)
+        # Make sure the directory exists.
+        FileUtils.mkdir_p(file_directory)
+        # Save the file.
+        File.open(file_path, "wb") { |f| f.write(file.read) } unless File.exists?(file_path)
+        # Return the public URL.
+        File.join(@public_url, options[:directory], File.basename(file_path))
+      end
+
+      private
+
+      # Gets the file path from the given directory and filename.
+      # If the file path already exists, appends a (1) to the basename.
+      # If there are already multiple files, appends the next (num) in the
+      # sequence.
+      def get_file_path(directory, filename)
+        file_path = File.join(directory, filename)
+        if File.exists?(file_path)
+          ext = File.extname(filename)
+          basename = File.basename(filename, ext)
+          files = Dir.glob(File.join(directory, "#{basename}([0-9]*)#{ext}"))
+          if files.size == 0
+            num = 1
+          else
+            num = files.map { |f| f.match(/\((\d+)\)/)[1].to_i }.sort.last + 1
+          end
+          file_path = "#{File.join(directory, basename)}(#{num})#{ext}"
+        end
+        file_path
+       end
+    end
+  end
+end

data/lib/snapimage/config.rb

@@ -9,7 +9,9 @@ module SnapImage
     end
 
     def validate_config
-      raise SnapImage::InvalidConfig, 'Missing "directory"' unless @config["directory"]
+      raise SnapImage::InvalidConfig, 'Missing "adapter"' unless @config["adapter"]
+      raise SnapImage::InvalidConfig, "Unknown adapter type. Expecting local or cloudinary: #{@config["adapter"]}" unless @config["adapter"]
+      SnapImage.const_get(@config["adapter"].capitalize).const_get("Config").new(@config).validate_config
     end
 
     def set_config_defaults

data/lib/snapimage/exceptions.rb

@@ -4,19 +4,13 @@ module SnapImage
   class UnknownConfigType < StandardError; end
   class MissingConfig < StandardError; end
 
-  # Authorization.
-  #class AuthorizationRequired < StandardError; end
-  #class AuthorizationFailed < StandardError; end
-
   # Request.
   class BadRequest < StandardError; end
-  #class ActionNotImplemented < StandardError; end
   class InvalidFilename < StandardError; end
   class InvalidDirectory < StandardError; end
   class FileTooLarge < StandardError; end
 
   # Files.
   class UnknownFileType < StandardError; end
-  #class FileDoesNotExist < StandardError; end
 
 end

data/lib/snapimage/middleware.rb

@@ -12,12 +12,13 @@ module SnapImage
       @app = app
       @path = options[:path] || "/snapimage_api"
       @config = SnapImage::Config.new(options[:config] || "config/snapimage_config.yml")
+      @storage = SnapImage::Storage.new(@config)
     end
 
     def call(env)
       request = SnapImage::Request.new(env)
       if request.path_info == @path
-        SnapImage::Server.new(request, @config).call
+        SnapImage::Server.new(request, @config, @storage).call
       else
         @app.call(env)
       end

data/lib/snapimage/rack/request.rb

@@ -1,7 +1,7 @@
 module SnapImage
   class Request < Rack::Request
     def bad_request?
-      !(self.post? && self.POST["file"] && self.POST["directory"])
+      !(self.post? && self.POST["file"])
     end
 
     # Returns a SnapImage::RequestFile which encapsulates the file that Rack

data/lib/snapimage/rack/response.rb

@@ -6,7 +6,7 @@ module SnapImage
       @content_type = options[:content_type] || "text/json"
       @template = options[:template] || "{{json}}"
       @json = {}
-      super
+      super()
     end
 
     def set_success(info = {})
@@ -18,14 +18,6 @@ module SnapImage
       @json = { status_code: 400, message: "Bad Request" }
     end
 
-    #def set_authorization_required
-      #@json = { status_code: 401, message: "Authorization Required" }
-    #end
-
-    #def set_authorization_failed
-      #@json = { status_code: 402, message: "Authorization Failed" }
-    #end
-
     def set_invalid_filename
       @json = { status_code: 403, message: "Invalid Filename" }
     end
@@ -43,7 +35,7 @@ module SnapImage
     end
 
     def finish
-      self.body = [@template.gsub(/{{json}}/, @json.to_json)]
+      write(@template.gsub(/{{json}}/, @json.to_json))
       self["Content-Type"] = @content_type
       super
     end

data/lib/snapimage/server.rb

@@ -1,44 +1,39 @@
 module SnapImage
   class Server
     DIRECTORY_REGEXP = /^[a-z0-9_-]+(\/[a-z0-9_-]+)*$/
-    FILENAME_REGEXP = /^[a-z0-9_-]+[.](gif|jpg|jpeg|png)$/
+    FILENAME_REGEXP = /^[^\/]+[.](gif|jpg|jpeg|png)$/
 
     # Arguments:
     # * request:: Rack::Request
-    def initialize(request, config)
+    def initialize(request, config, storage)
       @request = request
       @config = config
+      @storage = storage
     end
 
     # Handles the request and returns a Rack::Response.
     def call
-      @response = SnapImage::Response.new
+      # If the request is not an XHR, the response type should be text/html or
+      # text/plain. This affects browsers like IE8/9 when performing uploads
+      # through an iframe transport. If we return using text/json, the browser
+      # attempts to download the file instead.
+      @response = SnapImage::Response.new(content_type: @request.xhr? ? "text/json" : "text/html")
       begin
         raise SnapImage::BadRequest if @request.bad_request?
         raise SnapImage::InvalidFilename unless @request.file.filename =~ SnapImage::Server::FILENAME_REGEXP
-        raise SnapImage::InvalidDirectory unless @request["directory"] =~ SnapImage::Server::DIRECTORY_REGEXP
+        directory = @request["directory"] || "uncategorized"
+        raise SnapImage::InvalidDirectory unless directory =~ SnapImage::Server::DIRECTORY_REGEXP
         raise SnapImage::FileTooLarge if @request.file.tempfile.size > @config["max_file_size"]
-        directory = File.join(@config["directory"], @request["directory"])
-        file_path = File.join(directory, @request.file.filename)
-        # Make sure the directory exists.
-        FileUtils.mkdir_p(directory)
-        # Save the file.
-        File.open(file_path, "wb") { |f| f.write(@request.file.tempfile.read) } unless File.exists?(file_path)
-        @response.set_success
+        url = @storage.store(@request.file.filename, @request.file.tempfile, directory: directory)
+        @response.set_success(url: url)
       rescue SnapImage::BadRequest
         @response.set_bad_request
-      #rescue SnapImage::AuthorizationRequired
-        #@response.set_authorization_required
-      #rescue SnapImage::AuthorizationFailed
-        #@response.set_authorization_failed
       rescue SnapImage::InvalidFilename
         @response.set_invalid_filename
       rescue SnapImage::InvalidDirectory
         @response.set_invalid_directory
       rescue SnapImage::FileTooLarge
         @response.set_file_too_large
-      rescue
-        @response.set_internal_server_error
       end
       @response.finish
     end

data/lib/snapimage/storage.rb

@@ -0,0 +1,10 @@
+module SnapImage
+  class Storage
+    extend Forwardable
+    def_delegators :@storage, :store
+
+    def initialize(config)
+      @storage = SnapImage.const_get(config["adapter"].capitalize).const_get("Storage").new(config)
+    end
+  end
+end

data/lib/snapimage/version.rb

@@ -1,3 +1,3 @@
 module SnapImage
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/snapimage.gemspec

@@ -16,7 +16,6 @@ Gem::Specification.new do |gem|
   gem.version       = SnapImage::VERSION
 
   gem.add_dependency("rack")
-  gem.add_dependency("rmagick")
   gem.add_dependency("sinatra")
   gem.add_dependency("thin")
   gem.add_dependency("rake")

data/spec/acceptance/upload_spec.rb

@@ -23,7 +23,12 @@ describe "Upload" do
       SnapImage::Middleware.new(
         app,
         path: "/snapimage_api",
-        config: { "directory" => File.join(RSpec.root, "storage"), "max_file_size" => 600 }
+        config: {
+          "adapter" => "local",
+          "directory" => File.join(RSpec.root, "storage"),
+          "public_url" => "http://snapimage.com/public",
+          "max_file_size" => 600
+        }
       )
     end
 
@@ -34,10 +39,11 @@ describe "Upload" do
 
       it "is successful" do
         last_response.should be_successful
-        last_response["Content-Type"].should eq "text/json"
+        last_response["Content-Type"].should eq "text/html"
         json = JSON.parse(last_response.body)
         json["status_code"].should eq 200
         json["message"].should eq "Success"
+        json["url"].should eq "http://snapimage.com/public/abc/123/stub-300x200.png"
       end
 
       it "stores the image" do
@@ -46,6 +52,42 @@ describe "Upload" do
       end
     end
 
+    context "upload duplicate files" do
+      before do
+        @times = 12
+      end
+
+      it "is successful" do
+        @times.times do |i|
+          post "/snapimage_api", "file" => Rack::Test::UploadedFile.new(@image_path, "image/png"), "directory" => @directory
+          last_response.should be_successful
+          last_response["Content-Type"].should eq "text/html"
+          json = JSON.parse(last_response.body)
+          json["status_code"].should eq 200
+          json["message"].should eq "Success"
+          if i == 0
+            json["url"].should eq "http://snapimage.com/public/abc/123/stub-300x200.png"
+          else
+            json["url"].should eq "http://snapimage.com/public/abc/123/stub-300x200(#{i}).png"
+          end
+        end
+      end
+
+      it "stores the images" do
+        ext = File.extname(@image_path)
+        basename = File.basename(@image_path, ext)
+        @times.times do |i|
+          post "/snapimage_api", "file" => Rack::Test::UploadedFile.new(@image_path, "image/png"), "directory" => @directory
+          if i == 0
+            path = File.join(@local_root, @directory, "#{basename}#{ext}")
+          else
+            path = File.join(@local_root, @directory, "#{basename}(#{i})#{ext}")
+          end
+          File.exist?(path).should be_true
+        end
+      end
+    end
+
     context "upload too large" do
       before do
         post "/snapimage_api", "file" => Rack::Test::UploadedFile.new(@large_image_path, "image/png"), "directory" => @directory
@@ -53,7 +95,7 @@ describe "Upload" do
 
       it "fails" do
         last_response.should be_successful
-        last_response["Content-Type"].should eq "text/json"
+        last_response["Content-Type"].should eq "text/html"
         json = JSON.parse(last_response.body)
         json["status_code"].should eq 405
         json["message"].should eq "File Too Large"