uploadcare-ruby 1.0.1.rc1

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/uploadcare.rb

@@ -0,0 +1,43 @@
+require 'faraday'
+require 'json'
+require 'ostruct'
+
+require 'uploadcare/api'
+require 'uploadcare/version'
+
+module Uploadcare
+  DEFAULT_SETTINGS = {
+      public_key: 'demopublickey',
+      private_key: 'demoprivatekey',
+      upload_url_base: 'https://upload.uploadcare.com',
+      api_url_base: 'https://api.uploadcare.com',
+      static_url_base: 'http://www.ucarecdn.com',
+      api_version: '0.3',
+      cache_files: true,
+    }
+
+  USER_AGENT = "uploadcare-ruby/#{Uploadcare::VERSION}"
+  
+
+  def self.default_settings
+    DEFAULT_SETTINGS
+  end
+
+  def self.user_agent
+    USER_AGENT
+  end
+
+  UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
+  
+  GROUP_UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}~(?<count>\d+)$/
+  
+  CDN_URL_FILE_REGEX = /
+     (?<uuid>[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})
+     (?:\/-\/(?<operations>.*?))?\/?$
+     /ix
+  
+  CDN_URL_GROUP_REGEX = /
+     (?<uuid>[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}~(?<count>\d+))
+     (?:\/-\/(?<operations>.*?))?\/?$
+     /ix
+end

data/lib/uploadcare/api.rb

@@ -0,0 +1,20 @@
+require 'json'
+require 'ostruct'
+
+Dir[File.dirname(__FILE__) + '/api/*.rb'].each {|file| require file }
+Dir[File.dirname(__FILE__) + '/resources/*.rb'].each {|file| require file }
+
+
+module Uploadcare
+  class Api
+    attr_reader :options
+    
+    include Uploadcare::RawApi
+    include Uploadcare::UploadingApi
+    include Uploadcare::FileApi
+    include Uploadcare::ProjectApi
+    include Uploadcare::FileListApi
+    include Uploadcare::GroupApi
+    include Uploadcare::GroupListApi
+  end
+end

data/lib/uploadcare/api/connections.rb

@@ -0,0 +1,32 @@
+require 'faraday'
+require 'faraday_middleware'
+
+module Uploadcare
+  class Connections
+    def self.api_connection options
+      connection = Faraday.new url: options[:api_url_base] do |frd|
+        frd.request :url_encoded
+        frd.use FaradayMiddleware::FollowRedirects, limit: 3
+        frd.adapter :net_http # actually, default adapter, just to be clear
+        frd.headers['Authorization'] = "Uploadcare.Simple #{options[:public_key]}:#{options[:private_key]}"
+        frd.headers['Accept'] = "application/vnd.uploadcare-v#{options[:api_version]}+json"
+        frd.headers['User-Agent'] = Uploadcare::user_agent
+      end
+
+      connection
+    end
+
+    def self.upload_connection options
+      ca_path = '/etc/ssl/certs' if File.exists?('/etc/ssl/certs')
+
+      connection = Faraday.new ssl: { ca_path: ca_path }, url: options[:upload_url_base] do |frd|
+        frd.request :multipart
+        frd.request :url_encoded
+        frd.adapter Faraday.default_adapter
+        frd.headers['User-Agent'] = Uploadcare::user_agent
+      end
+
+      connection
+    end
+  end
+end

data/lib/uploadcare/api/file_api.rb

@@ -0,0 +1,9 @@
+require "uri"
+
+module Uploadcare
+  module FileApi
+    def file uuid_or_cdn_url
+      file = Uploadcare::Api::File.new self, uuid_or_cdn_url
+    end
+  end
+end

data/lib/uploadcare/api/file_list_api.rb

@@ -0,0 +1,8 @@
+module Uploadcare
+  module FileListApi
+    def file_list page=1
+      data = get '/files/', {page: page}
+      list = Uploadcare::Api::FileList.new self, data
+    end
+  end
+end

data/lib/uploadcare/api/group_api.rb

@@ -0,0 +1,38 @@
+module Uploadcare
+  module GroupApi
+
+    def group uuid_or_cdn_url
+      group = Uploadcare::Api::Group.new self, uuid_or_cdn_url
+    end
+
+
+    def create_group ary
+      unless ary.kind_of?(Array)
+        raise ArgumentError.new "You should send and array of files or valid UUIDs"
+      else
+        if ary.select {|f| !!f.kind_of?(Uploadcare::Api::File) }.any?
+          files = Hash.new
+          ary.each_with_index do |file, i|
+            files["files[#{i}]"] = file.uuid
+          end
+        elsif ary.select {|f| !!f.kind_of?(String) }.any?
+          files = Hash.new
+          ary.each_with_index do |uuid, i|
+            files["files[#{i}]"] = uuid
+          end
+        else
+          raise ArgumentError.new "You should send and array of files or valid UUIDs"
+        end
+      end
+
+
+      data = {
+        pub_key: @options[:public_key],
+      }
+
+      data.merge! files
+      post = parse(upload_request :post, "/group/", data)
+      group = Uploadcare::Api::Group.new self, post["id"], post
+    end
+  end
+end

data/lib/uploadcare/api/group_list_api.rb

@@ -0,0 +1,8 @@
+module Uploadcare
+  module GroupListApi
+    def group_list from=nil, limit=nil
+      data = get '/groups/', {from: from, limit: limit}
+      list = Uploadcare::Api::GroupList.new self, data
+    end
+  end
+end

data/lib/uploadcare/api/parser.rb

@@ -0,0 +1,42 @@
+require 'ostruct'
+
+module Uploadcare
+  module Parser
+
+    META_URL = /
+        (?<uuid>[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12} # base uuid
+        ~?(?<count>\d+)?) # optional count
+        (?:\/-\/(?<operations>.*?))?\/?$ # optional operations
+      /ix
+
+    def self.parse string
+      matched = META_URL.match(string)
+
+      # just a simple hash - easy to pass next
+      captured = Hash[ matched.names.zip( matched.captures ) ]
+
+      # raise an error if no uuid was given in the sting
+      raise "Invalid UUID or url was given" if captured["uuid"].nil?
+
+      # operations sring to array of operations
+      if captured["operations"]
+        captured["operations"] = captured["operations"].split("/-/")
+      else
+        captured["operations"] = []
+      end
+
+      # if count was given - it is a group
+      if captured["count"]
+        obj = Group.new captured
+      else
+        obj = File.new captured
+      end
+    end
+
+    class File < OpenStruct
+    end
+
+    class Group < OpenStruct
+    end
+  end
+end

data/lib/uploadcare/api/project_api.rb

@@ -0,0 +1,9 @@
+require "uri"
+
+module Uploadcare
+  module ProjectApi
+    def project
+      @project ||= Uploadcare::Api::Project.new self 
+    end
+  end
+end

data/lib/uploadcare/api/raw_api.rb

@@ -0,0 +1,73 @@
+require 'json'
+
+require 'uploadcare/api/connections'
+
+module Uploadcare
+  module RawApi
+
+    def initialize options={}
+      @options = Uploadcare::default_settings.merge(options)  
+    end
+
+
+    # basic request method 
+    def request method = :get, path = "/files/", params = {}
+      response = send_request(method, path, params)
+      parse(response)
+    end
+    alias_method :api_request, :request
+
+
+    # request with GET verb
+    def get path= "/files/", params={}
+      request :get, path, params
+    end
+
+
+    # request with POST verb
+    def post path= "/files/", params={}
+      request :post, path, params 
+    end
+
+    # request with PUT verb
+    def put path= "/files/", params={}
+      request :put, path, params
+    end
+
+
+    # request with DELETE verb
+    def delete path= "/files/", params={}
+      request :delete, path, params
+    end
+
+
+    protected
+      def send_request method, path, params={}
+        connection = Uploadcare::Connections.api_connection(@options)
+        response = connection.send method, path, params
+      end
+
+
+      def parse response
+        begin
+          object = JSON.parse(response.body)
+        rescue JSON::ParserError
+          object = false
+        end
+
+        # and returning the object (file actually) or raise new error
+        if response.status < 300
+          object
+        else
+          message = "HTTP code #{response.status}"
+          if object # add active_support god damn it
+            message += ": #{object["detail"]}"
+          else
+            message += ": unknown error occured."
+          end
+
+          raise ArgumentError.new(message)
+        end
+      end
+  end
+end

data/lib/uploadcare/api/uploading_api.rb

@@ -0,0 +1,122 @@
+require "uri"
+require 'mime/types'
+
+module Uploadcare
+  module UploadingApi
+    # intelegent guess for file or url uploading
+    def upload object
+      # if object is file - uploading it as file
+      if object.kind_of?(File)
+        upload_file(object)
+
+      # if a string - try to upload as url
+      elsif object.kind_of?(String)
+        upload_url(object)
+
+      # array of files
+      elsif object.kind_of?(Array)
+        upload_files(object)
+
+      else
+        raise ArgumentError.new "you should give File object, array of files or valid url string"
+      end
+    end
+
+
+    def upload_files files
+      if files.select {|f| !f.kind_of?(File)}.any?
+        raise ArgumentError.new "one or more of given files is not actually files"
+      else
+        data = {
+          UPLOADCARE_PUB_KEY: @options[:public_key],
+        }
+
+        files.each_with_index do |f, i|
+          data["file[#{i}]"] = Faraday::UploadIO.new(f.path, extract_mime_type(f))
+        end
+
+        response = upload_request :post, '/base/', data
+        uuids = upload_parse(response)
+
+        files = uuids.values.map! {|f| Uploadcare::Api::File.new self, f }
+      end
+    end
+
+
+    # upload file to servise
+    def upload_file file
+      if file.kind_of?(File)
+        mime_type = extract_mime_type(file)
+        
+        response = upload_request :post, '/base/', {
+          UPLOADCARE_PUB_KEY: @options[:public_key],
+          file: Faraday::UploadIO.new(file.path, mime_type)
+        }
+        uuid = upload_parse(response)["file"]
+        Uploadcare::Api::File.new self, uuid
+      else
+        raise ArgumentError.new 'expecting File object'
+      end
+    end
+    
+    # create file is the same as uplaod file
+    alias_method :create_file, :upload_file
+
+
+    #upload from url
+    def upload_url url
+      uri = URI.parse(url)
+      
+      if uri.kind_of?(URI::HTTP) # works both for HTTP and HTTPS as HTTPS inherits from HTTP
+        token = get_token(url)
+
+        while (response = get_status_response(token))['status'] == 'unknown'
+          sleep 0.5
+        end
+        
+        raise ArgumentError.new(response['error']) if response['status'] == 'error'
+        uuid = response['file_id']
+        Uploadcare::Api::File.new self, uuid
+      else
+        raise ArgumentError.new 'invalid url was given'
+      end
+    end
+    alias_method :upload_from_url, :upload_url
+
+
+
+
+    protected
+      def upload_request method, path, params = {}
+        connection = Uploadcare::Connections.upload_connection(@options)
+        response = connection.send method, path, params
+      end
+
+
+      def upload_parse response
+        raise ArgumentError.new(response.body) if response.status > 200
+        begin
+          JSON.parse(response.body)
+        rescue JSON::ParserError
+          response.body
+        end
+      end
+
+
+    private
+      def get_status_response token
+        upload_parse(upload_request(:post, '/from_url/status/', {token: token}))
+      end
+
+
+      def get_token url
+        response = upload_request :post, '/from_url/', { source_url: url, pub_key: @options[:public_key] }
+        token = upload_parse(response)["token"]
+      end
+
+      def extract_mime_type file
+        types = MIME::Types.of(file.path)
+        types[0].content_type
+      end
+  end
+end

data/lib/uploadcare/resources/file.rb

@@ -0,0 +1,136 @@
+require 'ostruct'
+
+module Uploadcare
+  class Api
+    class File < OpenStruct
+      def initialize api, uuid_or_cdn_url, data=nil
+        result = Uploadcare::Parser.parse(uuid_or_cdn_url)
+
+        unless result.is_a?(Uploadcare::Parser::File)
+          msg = "invalid CDN URL or UUID was given for file: #{uuid_or_cdn_url}."
+          if result.is_a?(Uploadcare::Parser::Group)
+            msg = msg + "\n Group UUID was given. Try call @api.group if it is what you intended."
+          end
+          raise msg
+        end
+        
+        file = {uuid: result["uuid"], operations: result["operations"]}
+
+        @api = api
+
+        super file
+
+        set_data(data) if data
+      end
+
+      def cdn_url add_operations=false
+        if add_operations
+          cdn_url_with_operations
+        else
+          cdn_url_without_operations
+        end
+      end
+      alias_method :public_url, :cdn_url
+
+
+      def cdn_url_without_operations
+        @api.options[:static_url_base] + "/#{@table[:uuid]}/"
+      end
+      alias_method :public_url_without_operations, :cdn_url_without_operations
+
+
+      def cdn_url_with_operations
+        url = cdn_url_without_operations
+        unless operations.empty?
+          ops = operations.join("/-/")
+          url = url + "-/#{ops}/"
+        end
+        url
+      end
+      alias_method :public_url_with_operations, :cdn_url_with_operations
+
+
+      def load_data
+        load_data! unless is_loaded?
+        self
+      end
+      alias_method :load, :load_data
+
+      def load_data!
+        data = @api.get "/files/#{uuid}/"
+        set_data(data)
+
+        self
+      end
+      alias_method :load!, :load_data!
+
+      def is_loaded?
+        !send(:datetime_uploaded).nil?
+      end
+      alias_method :loaded?, :is_loaded?
+
+
+      def store
+        data = @api.put "/files/#{uuid}/storage/"
+        set_data data
+        self 
+      end
+
+      # nil is returning if there is no way to say for sure
+      def is_stored?
+        return nil unless is_loaded?
+        !send(:datetime_stored).nil?
+      end
+      alias_method :stored?, :is_stored?
+
+
+      def delete
+        data = @api.delete "/files/#{uuid}/storage/"
+        set_data data
+        self
+      end
+
+      # nil is returning if there is no way to say for sure
+      def is_deleted?
+        return nil unless is_loaded?
+        !send(:datetime_removed).nil?
+      end
+      alias_method :deleted?, :is_deleted?
+      alias_method :removed?, :is_deleted?
+      alias_method :is_removed?, :is_deleted?
+
+
+      # Datetime methods
+      # practicly try and parse the string to date objects
+      ["original", "uploaded", "stored", "removed"].each do |dt|
+        define_method "datetime_#{dt}" do
+          date = @table["datetime_#{dt}".to_sym]
+          if date.is_a?(String)
+            begin
+              parsed = DateTime.parse(date)
+              self.send("datetime_#{dt}=", parsed)
+              parsed
+            rescue Exception => e
+              date
+            end
+          else
+            date
+          end
+        end
+      end
+      alias_method :datetime_deleted, :datetime_removed
+
+
+      private
+        def set_data data
+          if data.respond_to? :each
+            data.each do |key, value|
+              self.send "#{key}=", value
+            end
+          else
+            self.data = data
+          end
+        end
+    end
+  end
+end