docraptor 0.0.1 → 0.0.2

data/lib/docraptor/configuration.rb

@@ -1,14 +1,7 @@
 require 'uri'
-require 'singleton'
 
 module DocRaptor
   class Configuration
-
-    include Singleton
-
-    # Default api client
-    attr_accessor :api_client
-
     # Defines url scheme
     attr_accessor :scheme
 
@@ -44,6 +37,9 @@ module DocRaptor
     # @return [String]
     attr_accessor :password
 
+    # Defines the access token (Bearer) used with OAuth2.
+    attr_accessor :access_token
+
     # Set this to enable/disable debugging. When enabled (set to true), HTTP request/response
     # details will be logged with `logger.debug` (see the `logger` attribute).
     # Default to false.
@@ -64,6 +60,10 @@ module DocRaptor
     # @return [String]
     attr_accessor :temp_folder_path
 
+    # The time limit for HTTP request in seconds.
+    # Default to 0 (never times out).
+    attr_accessor :timeout
+
     ### TLS/SSL
     # Set this to false to skip verifying SSL certificate when calling API from https server.
     # Default to true.
@@ -91,23 +91,13 @@ module DocRaptor
 
     attr_accessor :force_ending_format
 
-    class << self
-      def method_missing(method_name, *args, &block)
-        config = Configuration.instance
-        if config.respond_to?(method_name)
-          config.send(method_name, *args, &block)
-        else
-          super
-        end
-      end
-    end
-
     def initialize
-      @scheme = 'http'
-      @host = 'localhost:3000'
+      @scheme = 'https'
+      @host = 'docraptor.com'
       @base_path = '/'
       @api_key = {}
       @api_key_prefix = {}
+      @timeout = 0
       @verify_ssl = true
       @cert_file = nil
       @key_file = nil
@@ -115,10 +105,17 @@ module DocRaptor
       @inject_format = false
       @force_ending_format = false
       @logger = defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
+
+      yield(self) if block_given?
+    end
+
+    # The default Configuration object.
+    def self.default
+      @@default ||= Configuration.new
     end
 
-    def api_client
-      @api_client ||= ApiClient.new
+    def configure
+      yield(self) if block_given?
     end
 
     def scheme=(scheme)

data/lib/docraptor/models/async_doc.rb

@@ -1,18 +1,20 @@
+require 'date'
+
 module DocRaptor
-  # 
-  class AsyncDoc < BaseObject
+  class AsyncDoc
+    # The identifier used to get the status of the document using the status api.
     attr_accessor :status_id
-    # attribute mapping from ruby-style variable name to JSON key
+
+    # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
         
-        # The identifier used to get the status of the document using the status api.
         :'status_id' => :'status_id'
         
       }
     end
 
-    # attribute type
+    # Attribute type mapping.
     def self.swagger_types
       {
         :'status_id' => :'String'
@@ -21,7 +23,7 @@ module DocRaptor
     end
 
     def initialize(attributes = {})
-      return if !attributes.is_a?(Hash) || attributes.empty?
+      return unless attributes.is_a?(Hash)
 
       # convert string to symbol for hash key
       attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
@@ -33,5 +35,113 @@ module DocRaptor
       
     end
 
+    # Check equality by comparing each attribute.
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          status_id == o.status_id
+    end
+
+    # @see the `==` method
+    def eql?(o)
+      self == o
+    end
+
+    # Calculate hash code according to all attributes.
+    def hash
+      [status_id].hash
+    end
+
+    # build the object from hash
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.swagger_types.each_pair do |key, type|
+        if type =~ /^Array<(.*)>/i
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+          else
+            #TODO show warning in debug mode
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        else
+          # data not found in attributes(hash), not an issue as the data can be optional
+        end
+      end
+
+      self
+    end
+
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value =~ /^(true|t|yes|y|1)$/i
+          true
+        else
+          false
+        end
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        _model = DocRaptor.const_get(type).new
+        _model.build_from_hash(value)
+      end
+    end
+
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_body (backward compatibility))
+    def to_body
+      to_hash
+    end
+
+    # return the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Method to output non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map{ |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
   end
 end

data/lib/docraptor/models/async_doc_status.rb

@@ -1,33 +1,45 @@
+require 'date'
+
 module DocRaptor
-  # 
-  class AsyncDocStatus < BaseObject
-    attr_accessor :status, :download_url, :download_id, :message, :number_of_pages, :validation_errors
-    # attribute mapping from ruby-style variable name to JSON key
+  class AsyncDocStatus
+    # The present status of the document. Can be queued, working, completed, and failed.
+    attr_accessor :status
+
+    # The URL where the document can be retrieved. This URL may only be used a few times.
+    attr_accessor :download_url
+
+    # The identifier for downloading the document with the download api.
+    attr_accessor :download_id
+
+    # Additional information.
+    attr_accessor :message
+
+    # Number of PDF pages in document.
+    attr_accessor :number_of_pages
+
+    # Error information.
+    attr_accessor :validation_errors
+
+    # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
         
-        # The present status of the document. Can be queued, working, completed, and failed.
         :'status' => :'status',
         
-        # The URL where the document can be retrieved. This URL may only be used a few times.
         :'download_url' => :'download_url',
         
-        # The identifier for downloading the document with the download api.
         :'download_id' => :'download_id',
         
-        # Additional information.
         :'message' => :'message',
         
-        # Number of PDF pages in document.
         :'number_of_pages' => :'number_of_pages',
         
-        # Error information.
         :'validation_errors' => :'validation_errors'
         
       }
     end
 
-    # attribute type
+    # Attribute type mapping.
     def self.swagger_types
       {
         :'status' => :'String',
@@ -41,7 +53,7 @@ module DocRaptor
     end
 
     def initialize(attributes = {})
-      return if !attributes.is_a?(Hash) || attributes.empty?
+      return unless attributes.is_a?(Hash)
 
       # convert string to symbol for hash key
       attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
@@ -73,5 +85,118 @@ module DocRaptor
       
     end
 
+    # Check equality by comparing each attribute.
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          status == o.status &&
+          download_url == o.download_url &&
+          download_id == o.download_id &&
+          message == o.message &&
+          number_of_pages == o.number_of_pages &&
+          validation_errors == o.validation_errors
+    end
+
+    # @see the `==` method
+    def eql?(o)
+      self == o
+    end
+
+    # Calculate hash code according to all attributes.
+    def hash
+      [status, download_url, download_id, message, number_of_pages, validation_errors].hash
+    end
+
+    # build the object from hash
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.swagger_types.each_pair do |key, type|
+        if type =~ /^Array<(.*)>/i
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+          else
+            #TODO show warning in debug mode
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        else
+          # data not found in attributes(hash), not an issue as the data can be optional
+        end
+      end
+
+      self
+    end
+
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value =~ /^(true|t|yes|y|1)$/i
+          true
+        else
+          false
+        end
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        _model = DocRaptor.const_get(type).new
+        _model.build_from_hash(value)
+      end
+    end
+
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_body (backward compatibility))
+    def to_body
+      to_hash
+    end
+
+    # return the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Method to output non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map{ |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
   end
 end

data/lib/docraptor/models/doc.rb

@@ -1,51 +1,74 @@
+require 'date'
+
 module DocRaptor
-  # 
-  class Doc < BaseObject
-    attr_accessor :name, :document_type, :document_content, :document_url, :test, :strict, :tag, :help, :javascript, :referrer, :callback_url, :prince_options
-    # attribute mapping from ruby-style variable name to JSON key
+  class Doc
+    # A name for identifying your document.
+    attr_accessor :name
+
+    # The type of document being created.
+    attr_accessor :document_type
+
+    # The HTML data to be transformed into a document.\nYou must supply content using document_content or document_url.
+    attr_accessor :document_content
+
+    # The URL to fetch the HTML data to be transformed into a document.\nYou must supply content using document_content or document_url.
+    attr_accessor :document_url
+
+    # Enable test mode for this document. Test documents are not charged for but include a watermark.
+    attr_accessor :test
+
+    # Force strict HTML validation.
+    attr_accessor :strict
+
+    # A field for storing a small amount of metadata with this document.
+    attr_accessor :tag
+
+    # Request support help with this request if it succeeds.
+    attr_accessor :help
+
+    # Enable DocRaptor JavaScript parsing. PrinceXML JavaScript parsing is also available elsewhere.
+    attr_accessor :javascript
+
+    # Set HTTP referrer when generating this document.
+    attr_accessor :referrer
+
+    # A URL that will receive a POST request after successfully completing an asynchronous document.\nThe POST data will include download_url and download_id similar to status api responses.\nWARNING: this only works on asynchronous documents.
+    attr_accessor :callback_url
+
+    attr_accessor :prince_options
+
+    # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
         
-        # A name for identifying your document.
         :'name' => :'name',
         
-        # The type of document being created.
         :'document_type' => :'document_type',
         
-        # The HTML data to be transformed into a document.\nYou must supply content using document_content or document_url.
         :'document_content' => :'document_content',
         
-        # The URL to fetch the HTML data to be transformed into a document.\nYou must supply content using document_content or document_url.
         :'document_url' => :'document_url',
         
-        # Enable test mode for this document. Test documents are not charged for but include a watermark.
         :'test' => :'test',
         
-        # Force strict HTML validation.
         :'strict' => :'strict',
         
-        # A field for storing a small amount of metadata with this document.
         :'tag' => :'tag',
         
-        # Request support help with this request if it succeeds.
         :'help' => :'help',
         
-        # Enable DocRaptor JavaScript parsing. PrinceXML JavaScript parsing is also available elsewhere.
         :'javascript' => :'javascript',
         
-        # Set HTTP referrer when generating this document.
         :'referrer' => :'referrer',
         
-        # A URL that will receive a POST request after successfully completing an asynchronous document.\nThe POST data will include download_url and download_id similar to status api responses.\nWARNING: this only works on asynchronous documents.
         :'callback_url' => :'callback_url',
         
-        # 
         :'prince_options' => :'prince_options'
         
       }
     end
 
-    # attribute type
+    # Attribute type mapping.
     def self.swagger_types
       {
         :'name' => :'String',
@@ -65,7 +88,7 @@ module DocRaptor
     end
 
     def initialize(attributes = {})
-      return if !attributes.is_a?(Hash) || attributes.empty?
+      return unless attributes.is_a?(Hash)
 
       # convert string to symbol for hash key
       attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
@@ -89,10 +112,14 @@ module DocRaptor
       
       if attributes[:'test']
         self.test = attributes[:'test']
+      else
+        self.test = true
       end
       
       if attributes[:'strict']
         self.strict = attributes[:'strict']
+      else
+        self.strict = "none"
       end
       
       if attributes[:'tag']
@@ -101,10 +128,14 @@ module DocRaptor
       
       if attributes[:'help']
         self.help = attributes[:'help']
+      else
+        self.help = false
       end
       
       if attributes[:'javascript']
         self.javascript = attributes[:'javascript']
+      else
+        self.javascript = false
       end
       
       if attributes[:'referrer']
@@ -121,6 +152,7 @@ module DocRaptor
       
     end
 
+    # Custom attribute writer method checking allowed values (enum).
     def document_type=(document_type)
       allowed_values = ["pdf", "xls", "xlsx"]
       if document_type && !allowed_values.include?(document_type)
@@ -129,6 +161,7 @@ module DocRaptor
       @document_type = document_type
     end
 
+    # Custom attribute writer method checking allowed values (enum).
     def strict=(strict)
       allowed_values = ["none"]
       if strict && !allowed_values.include?(strict)
@@ -137,5 +170,124 @@ module DocRaptor
       @strict = strict
     end
 
+    # Check equality by comparing each attribute.
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          name == o.name &&
+          document_type == o.document_type &&
+          document_content == o.document_content &&
+          document_url == o.document_url &&
+          test == o.test &&
+          strict == o.strict &&
+          tag == o.tag &&
+          help == o.help &&
+          javascript == o.javascript &&
+          referrer == o.referrer &&
+          callback_url == o.callback_url &&
+          prince_options == o.prince_options
+    end
+
+    # @see the `==` method
+    def eql?(o)
+      self == o
+    end
+
+    # Calculate hash code according to all attributes.
+    def hash
+      [name, document_type, document_content, document_url, test, strict, tag, help, javascript, referrer, callback_url, prince_options].hash
+    end
+
+    # build the object from hash
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.swagger_types.each_pair do |key, type|
+        if type =~ /^Array<(.*)>/i
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+          else
+            #TODO show warning in debug mode
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        else
+          # data not found in attributes(hash), not an issue as the data can be optional
+        end
+      end
+
+      self
+    end
+
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value =~ /^(true|t|yes|y|1)$/i
+          true
+        else
+          false
+        end
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        _model = DocRaptor.const_get(type).new
+        _model.build_from_hash(value)
+      end
+    end
+
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_body (backward compatibility))
+    def to_body
+      to_hash
+    end
+
+    # return the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Method to output non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map{ |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
   end
 end