cloudconvert 0.0.3 → 1.0.2

data/lib/cloudconvert/base.rb

@@ -0,0 +1,173 @@
+module CloudConvert
+  class Base
+    extend Forwardable
+    include Memoizable
+    # @return [Hash]
+    attr_reader :attrs
+    alias to_h attrs
+    alias to_hash to_h
+
+    class << self
+      # Define methods that retrieve the value from attributes
+      #
+      # @param attrs [Array, Symbol]
+      def attr_reader(*attrs)
+        attrs.each do |attr|
+          define_attribute_method(attr)
+          define_predicate_method(attr)
+        end
+      end
+
+      # Define collection methods from attributes
+      #
+      # @param klass [Symbol]
+      # @param attrs [Array, Symbol]
+      def collection_attr_reader(klass, *attrs)
+        attrs.each do |attr|
+          define_collection_method(attr, klass)
+          define_predicate_method(attr)
+        end
+      end
+
+      # Define object methods from attributes
+      #
+      # @param klass [Symbol]
+      # @param attrs [Array, Symbol]
+      def object_attr_reader(klass, *attrs)
+        attrs.each do |attr|
+          define_object_method(attr, klass)
+          define_predicate_method(attr)
+        end
+      end
+
+      # Define predicate methods from attributes
+      #
+      # @param attrs [Array, Symbol]
+      def predicate_attr_reader(*attrs)
+        attrs.each do |attr|
+          define_predicate_method(attr)
+        end
+      end
+
+      # Define struct methods from attributes
+      #
+      # @param attrs [Array, Symbol]
+      def struct_attr_reader(*attrs)
+        attrs.each do |attr|
+          define_struct_method(attr)
+          define_predicate_method(attr)
+        end
+      end
+
+      # Define symbol methods from attributes
+      #
+      # @param attrs [Array, Symbol]
+      def symbol_attr_reader(*attrs)
+        attrs.each do |attr|
+          define_symbol_method(attr)
+        end
+      end
+
+      # Define time methods from attributes
+      #
+      # @param attrs [Array, Symbol]
+      def time_attr_reader(*attrs)
+        attrs.each do |attr|
+          define_time_method(attr)
+          define_predicate_method(attr.to_s.gsub(/_at$/, ""), attr)
+        end
+      end
+
+      private
+
+      # Dynamically define a method for an attribute
+      #
+      # @param key [Symbol]
+      # @param klass [Symbol]
+      def define_attribute_method(key)
+        define_method(key) do
+          @attrs[key]
+        end
+        memoize(key)
+      end
+
+      # Dynamically define a collection method for an attribute
+      #
+      # @param key [Symbol]
+      # @param klass [Symbol]
+      def define_collection_method(key, klass)
+        define_method(key) do
+          collection = @attrs[key] || []
+          entity = CloudConvert.const_get(klass)
+          Collection.new collection.map { |item| entity.new(item) }
+        end
+        memoize(key)
+      end
+
+      # Dynamically define a predicate method for an attribute
+      #
+      # @param key1 [Symbol]
+      # @param key2 [Symbol]
+      def define_predicate_method(key1, key2 = key1)
+        define_method(:"#{key1}?") do
+          !attr_falsey_or_empty?(key2)
+        end
+        memoize(:"#{key1}?")
+      end
+
+      # Dynamically define a object method for an attribute
+      #
+      # @param key [Symbol]
+      def define_object_method(key, klass)
+        define_method(key) do
+          CloudConvert.const_get(klass).new(@attrs[key]) unless @attrs[key].nil?
+        end
+        memoize(key)
+      end
+
+      # Dynamically define a struct method for an attribute
+      #
+      # @param key [Symbol]
+      def define_struct_method(key)
+        define_method(key) do
+          OpenStruct.new(@attrs[key]) unless @attrs[key].nil?
+        end
+        memoize(key)
+      end
+
+      # Dynamically define a symbol method for an attribute
+      #
+      # @param key [Symbol]
+      def define_symbol_method(key)
+        define_method(key) do
+          @attrs[key].to_sym unless @attrs[key].nil?
+        end
+        memoize(key)
+      end
+
+      # Dynamically define a time method for an attribute
+      #
+      # @param key [Symbol]
+      def define_time_method(key)
+        define_method(key) do
+          Time.parse(@attrs[key]).utc unless @attrs[key].nil?
+        end
+        memoize(key)
+      end
+    end
+
+    # Initializes a new object
+    #
+    # @param attrs [Hash]
+    # @return [CloudConvert::Base]
+    def initialize(attrs = {})
+      @attrs = attrs || {}
+    end
+
+    private
+
+    def attr_falsey_or_empty?(key)
+      !@attrs[key] || @attrs[key].respond_to?(:empty?) && @attrs[key].empty?
+    end
+  end
+end

data/lib/cloudconvert/client.rb

@@ -0,0 +1,107 @@
+module CloudConvert
+  class Client
+    attr_reader :api_key, :sandbox
+
+    # Initializes a new Client object
+    #
+    # @param options [Hash]
+    # @return [CloudConvert::Client]
+    def initialize(options = {})
+      schema = Schemacop::Schema.new do
+        req! :api_key, :string
+        opt! :sandbox, :boolean, default: false
+      end
+
+      schema.validate! options.reverse_merge!({
+        api_key: ENV["CLOUDCONVERT_API_KEY"],
+        sandbox: ENV["CLOUDCONVERT_SANDBOX"].to_s.downcase == "true",
+      })
+
+      @api_key = options[:api_key]
+      @sandbox = options[:sandbox]
+    end
+
+    # @return [Resources::Jobs]
+    def jobs
+      @jobs ||= Resources::Jobs.new(self)
+    end
+
+    # @return [Resources::Tasks]
+    def tasks
+      @tasks ||= Resources::Tasks.new(self)
+    end
+
+    # @return [Resources::Users]
+    def users
+      @users ||= Resources::Users.new(self)
+    end
+
+    # @param method [Symbol]
+    # @param path [String]
+    # @param params [Hash]
+    # @return [OpenStruct]
+    def request(method, path, params = {}, &block)
+      response = connection.send(method, path, params, &block)
+      raise CloudConvert::Error.from_response(response) unless response.success?
+      response.body unless response.body.blank?
+    end
+
+    # @param path [String]
+    # @param params [Hash]
+    # @return [OpenStruct]
+    def get(path, params = {}, &block)
+      request(:get, path, params, &block)
+    end
+
+    # @param path [String]
+    # @param params [Hash]
+    # @return [OpenStruct]
+    def post(path, params = {}, &block)
+      request(:post, path, params, &block)
+    end
+
+    # @param path [String]
+    # @param params [Hash]
+    # @return [OpenStruct]
+    def delete(path, params = {}, &block)
+      request(:delete, path, params, &block)
+    end
+
+    # @param url [String]
+    # @return [Tempfile]
+    def download(url, *args, **options)
+      options[:headers] ||= {}
+      options[:headers]["User-Agent"] = USER_AGENT
+      Down.download(url, *args, **options)
+    end
+
+    private
+
+    # @return [String]
+    def api_host
+      @api_host ||= sandbox ? SANDBOX_URL : API_URL
+    end
+
+    # @return [Faraday::Client]
+    def connection
+      @connection ||= Faraday.new(url: api_host, headers: headers) do |f|
+        f.adapter Faraday.default_adapter
+        f.request :json
+        f.request :multipart
+        f.use CloudConvert::Middleware::ParseJson, content_type: /\bjson$/
+        f.use FaradayMiddleware::FollowRedirects, callback: lambda { |response, redirect|
+          redirect.request_headers.delete("Content-Length")
+          redirect.request_headers.delete("Content-Type")
+        }
+      end
+    end
+
+    # @return [Hash]
+    def headers
+      @headers ||= {
+        "Authorization": "Bearer #{api_key}",
+        "User-Agent": USER_AGENT,
+      }
+    end
+  end
+end

data/lib/cloudconvert/collection.rb

@@ -0,0 +1,15 @@
+module CloudConvert
+  class Collection < Array
+    attr_reader :links, :meta
+
+    def initialize(items = [], links = {}, meta = {})
+      super(items)
+      @links = links
+      @meta = meta
+    end
+
+    def where(attrs)
+      self.class.new select { |item| attrs.map { |k, v| item.send(k) == v ? true : nil }.compact.length == attrs.length }
+    end
+  end
+end

data/lib/cloudconvert/entity.rb

@@ -0,0 +1,21 @@
+module CloudConvert
+  class Entity < Base
+    attr_reader :id
+
+    include Equalizer.new(:id)
+
+    class << self
+      def collection(response)
+        CloudConvert::Collection.new(
+          response.data.collect { |item| new(item) },
+          response.links,
+          response.meta,
+        )
+      end
+
+      def result(response)
+        new response.data
+      end
+    end
+  end
+end

data/lib/cloudconvert/error.rb

@@ -0,0 +1,108 @@
+module CloudConvert
+  class Error < StandardError
+    # @return [Integer]
+    attr_reader :code
+
+    # @return [OpenStruct]
+    attr_reader :errors
+
+    # Raised when CloudConvert returns a 4xx HTTP status code
+    ClientError = Class.new(self)
+
+    # Raised when CloudConvert returns the HTTP status code 400
+    BadRequest = Class.new(ClientError)
+
+    # Raised when CloudConvert returns the HTTP status code 401
+    Unauthorized = Class.new(ClientError)
+
+    # Raised when CloudConvert returns the HTTP status code 402
+    PaymentRequired = Class.new(ClientError)
+
+    # Raised when CloudConvert returns the HTTP status code 403
+    Forbidden = Class.new(ClientError)
+
+    # Raised when CloudConvert returns the HTTP status code 413
+    RequestEntityTooLarge = Class.new(ClientError)
+
+    # Raised when CloudConvert returns the HTTP status code 404
+    NotFound = Class.new(ClientError)
+
+    # Raised when CloudConvert returns the HTTP status code 406
+    NotAcceptable = Class.new(ClientError)
+
+    # Raised when CloudConvert returns the HTTP status code 422
+    UnprocessableEntity = Class.new(ClientError)
+
+    # Raised when CloudConvert returns the HTTP status code 429
+    TooManyRequests = Class.new(ClientError)
+
+    # Raised when CloudConvert returns a 5xx HTTP status code
+    ServerError = Class.new(self)
+
+    # Raised when CloudConvert returns the HTTP status code 500
+    InternalServerError = Class.new(ServerError)
+
+    # Raised when CloudConvert returns the HTTP status code 502
+    BadGateway = Class.new(ServerError)
+
+    # Raised when CloudConvert returns the HTTP status code 503
+    ServiceUnavailable = Class.new(ServerError)
+
+    # Raised when CloudConvert returns the HTTP status code 504
+    GatewayTimeout = Class.new(ServerError)
+
+    # Raised when CloudConvert returns a media related error
+    MediaError = Class.new(self)
+
+    # Raised when CloudConvert returns an InvalidMedia error
+    InvalidMedia = Class.new(MediaError)
+
+    # Raised when CloudConvert returns a media InternalError error
+    MediaInternalError = Class.new(MediaError)
+
+    # Raised when CloudConvert returns an UnsupportedMedia error
+    UnsupportedMedia = Class.new(MediaError)
+
+    # Raised when an operation subject to timeout takes too long
+    TimeoutError = Class.new(self)
+
+    ERRORS = {
+      400 => CloudConvert::Error::BadRequest,
+      401 => CloudConvert::Error::Unauthorized,
+      402 => CloudConvert::Error::PaymentRequired,
+      403 => CloudConvert::Error::Forbidden,
+      404 => CloudConvert::Error::NotFound,
+      406 => CloudConvert::Error::NotAcceptable,
+      413 => CloudConvert::Error::RequestEntityTooLarge,
+      422 => CloudConvert::Error::UnprocessableEntity,
+      429 => CloudConvert::Error::TooManyRequests,
+      500 => CloudConvert::Error::InternalServerError,
+      502 => CloudConvert::Error::BadGateway,
+      503 => CloudConvert::Error::ServiceUnavailable,
+      504 => CloudConvert::Error::GatewayTimeout,
+    }.freeze
+
+    class << self
+      # Create a new error from an HTTP response
+      #
+      # @param response [Faraday::Response]
+      # @return [CloudConvert::Error]
+      def from_response(response)
+        klass = ERRORS[response.status] || self
+        klass.new(response.body.message, response.body.code, response.body.errors)
+      end
+    end
+
+    # Initializes a new Error object
+    #
+    # @param message [Exception, String]
+    # @param code [Integer]
+    # @return [CloudConvert::Error]
+    def initialize(message = "", code = nil, errors = {})
+      super(message)
+
+      @code = code
+      @errors = errors
+    end
+  end
+end

data/lib/cloudconvert/event.rb

@@ -0,0 +1,14 @@
+module CloudConvert
+  class Event < Entity
+    include Equalizer.new(:event, :job)
+
+    # @return [String]
+    attr_reader :event
+
+    # @return [String]
+    alias_method :name, :event
+
+    # @return [Boolean]
+    object_attr_reader :Job, :job
+  end
+end

data/lib/cloudconvert/file.rb

@@ -0,0 +1,9 @@
+module CloudConvert
+  class File < Faraday::FilePart
+    def initialize(file, content_type = nil, *parts)
+      content_type ||= "text/plain" if file.is_a? StringIO
+      content_type ||= Marcel::Magic.by_magic(file) || Marcel::Magic.by_path(file)
+      super(file, content_type, *parts)
+    end
+  end
+end