translationApiClient 1.0.3

data/lib/translationApi_client/models/translation_response.rb

@@ -0,0 +1,62 @@
+module TranslationApiClient
+  # 
+  class TranslationResponse < BaseObject
+    attr_accessor :warning, :error, :request_id, :outputs
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # Warning at request level
+        :'warning' => :'warning',
+        
+        # Error at request level
+        :'error' => :'error',
+        
+        # Request identifier to use to get the status, the result of the request and to cancel it in asynchronous mode
+        :'request_id' => :'requestId',
+        
+        # Outputs of translation
+        :'outputs' => :'outputs'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'warning' => :'string',
+        :'error' => :'string',
+        :'request_id' => :'string',
+        :'outputs' => :'array[TranslationOutput]'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'warning']
+        @warning = attributes[:'warning']
+      end
+      
+      if attributes[:'error']
+        @error = attributes[:'error']
+      end
+      
+      if attributes[:'requestId']
+        @request_id = attributes[:'requestId']
+      end
+      
+      if attributes[:'outputs']
+        if (value = attributes[:'outputs']).is_a?(Array)
+          @outputs = value
+        end
+      end
+      
+    end
+  end
+end

data/lib/translationApi_client/models/translation_status.rb

@@ -0,0 +1,100 @@
+module TranslationApiClient
+  # 
+  class TranslationStatus < BaseObject
+    attr_accessor :error, :cancelled, :created_at, :description, :expire_at, :finished_at, :finished_steps, :status, :total_steps
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # Error of the request
+        :'error' => :'error',
+        
+        # Is the request cancelled
+        :'cancelled' => :'cancelled',
+        
+        # Creation time of the request (ms since the Epoch)
+        :'created_at' => :'createdAt',
+        
+        # Description
+        :'description' => :'description',
+        
+        # Expiration time of the request (ms since the Epoch)
+        :'expire_at' => :'expireAt',
+        
+        # Completion time of the request (ms since the Epoch)
+        :'finished_at' => :'finishedAt',
+        
+        # Number of finished steps
+        :'finished_steps' => :'finishedSteps',
+        
+        # Status of the request
+        :'status' => :'status',
+        
+        # Number of steps to complete
+        :'total_steps' => :'totalSteps'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'error' => :'string',
+        :'cancelled' => :'boolean',
+        :'created_at' => :'number',
+        :'description' => :'string',
+        :'expire_at' => :'number',
+        :'finished_at' => :'number',
+        :'finished_steps' => :'int',
+        :'status' => :'string',
+        :'total_steps' => :'int'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'error']
+        @error = attributes[:'error']
+      end
+      
+      if attributes[:'cancelled']
+        @cancelled = attributes[:'cancelled']
+      end
+      
+      if attributes[:'createdAt']
+        @created_at = attributes[:'createdAt']
+      end
+      
+      if attributes[:'description']
+        @description = attributes[:'description']
+      end
+      
+      if attributes[:'expireAt']
+        @expire_at = attributes[:'expireAt']
+      end
+      
+      if attributes[:'finishedAt']
+        @finished_at = attributes[:'finishedAt']
+      end
+      
+      if attributes[:'finishedSteps']
+        @finished_steps = attributes[:'finishedSteps']
+      end
+      
+      if attributes[:'status']
+        @status = attributes[:'status']
+      end
+      
+      if attributes[:'totalSteps']
+        @total_steps = attributes[:'totalSteps']
+      end
+      
+    end
+  end
+end

data/lib/translationApi_client/monkey.rb

@@ -0,0 +1,90 @@
+# module Swagger
+  class Object 
+  
+    unless Object.method_defined? :blank?
+      def blank?
+        respond_to?(:empty?) ? empty? : !self
+      end
+    end
+  
+    unless Object.method_defined? :present?
+      def present?
+        !blank?
+      end
+    end
+
+  end
+
+  class String
+
+    unless String.method_defined? :underscore
+      def underscore
+        self.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+      end
+    end
+  
+    unless String.method_defined? :camelize
+      def camelize(first_letter_in_uppercase = true)
+        if first_letter_in_uppercase != :lower
+          self.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+        else
+          self.to_s[0].chr.downcase + camelize(self)[1..-1]
+        end
+      end
+    end
+
+  end
+
+  class Hash
+
+    unless Hash.method_defined? :stringify_keys    
+      def stringify_keys
+        inject({}) do |options, (key, value)|
+          options[key.to_s] = value
+          options
+        end
+      end
+    end
+    
+    unless Hash.method_defined? :stringify_keys!
+      def stringify_keys!
+        self.replace(self.stringify_keys)
+      end
+    end
+
+    unless Hash.method_defined? :symbolize_keys
+      def symbolize_keys
+        inject({}) do |options, (key, value)|
+          options[(key.to_sym rescue key) || key] = value
+          options
+        end
+      end
+    end
+  
+    unless Hash.method_defined? :symbolize_keys!
+      def symbolize_keys!
+        self.replace(self.symbolize_keys)
+      end
+    end
+
+    unless Hash.method_defined? :symbolize_and_underscore_keys
+      def symbolize_and_underscore_keys
+        inject({}) do |options, (key, value)|
+          options[(key.to_s.underscore.to_sym rescue key) || key] = value
+          options
+        end
+      end
+    end
+
+    unless Hash.method_defined? :symbolize_and_underscore_keys!
+      def symbolize_and_underscore_keys!
+        self.replace(self.symbolize_and_underscore_keys)
+      end
+    end
+  
+  end
+# end

data/lib/translationApi_client/swagger.rb

@@ -0,0 +1,78 @@
+require 'logger'
+require 'json'
+
+module TranslationApiClient
+  module Swagger
+    class << self
+      attr_accessor :logger
+
+      # A Swagger configuration object. Must act like a hash and return sensible
+      # values for all Swagger configuration options. See Swagger::Configuration.
+      attr_accessor :configuration
+
+      attr_accessor :resources
+
+      # Call this method to modify defaults in your initializers.
+      #
+      # @example
+      #   Swagger.configure do |config|
+      #     config.api_key['api_key'] = '1234567890abcdef'     # api key authentication
+      #     config.username = 'wordlover'           # http basic authentication
+      #     config.password = 'i<3words'            # http basic authentication
+      #     config.format = 'json'                  # optional, defaults to 'json'
+      #   end
+      #
+      def configure
+        yield(configuration) if block_given?
+
+        # Configure logger.  Default to use Rails
+        self.logger ||= configuration.logger || (defined?(Rails) ? Rails.logger : Logger.new(STDOUT))
+
+        # remove :// from scheme
+        configuration.scheme.sub!(/:\/\//, '')
+
+        # remove http(s):// and anything after a slash
+        configuration.host.sub!(/https?:\/\//, '')
+        configuration.host = configuration.host.split('/').first
+
+        # Add leading and trailing slashes to base_path
+        configuration.base_path = "/#{configuration.base_path}".gsub(/\/+/, '/')
+        configuration.base_path = "" if configuration.base_path == "/"
+      end
+
+      def authenticated?
+        Swagger.configuration.auth_token.present?
+      end
+
+      def de_authenticate
+        Swagger.configuration.auth_token = nil
+      end
+
+      def authenticate
+        return if Swagger.authenticated?
+
+        if Swagger.configuration.username.blank? || Swagger.configuration.password.blank?
+          raise ClientError, "Username and password are required to authenticate."
+        end
+
+        request = Swagger::Request.new(
+          :get,
+          "account/authenticate/{username}",
+          :params => {
+            :username => Swagger.configuration.username,
+            :password => Swagger.configuration.password
+          }
+        )
+
+        response_body = request.response.body
+        Swagger.configuration.auth_token = response_body['token']
+      end
+    end
+  end
+
+  class ServerError < StandardError
+  end
+
+  class ClientError < StandardError
+  end
+end

data/lib/translationApi_client/swagger/configuration.rb

@@ -0,0 +1,29 @@
+module TranslationApiClient
+  module Swagger
+    class Configuration
+      attr_accessor :format, :key, :key_prefix, :username, :password, :auth_token, :scheme, :host, :base_path, :user_agent, :logger, :inject_format, :force_ending_format, :camelize_params, :user_agent, :verify_ssl
+
+      # Defaults go in here..
+      def initialize
+        @format = 'json'
+        @scheme = 'https'
+        @host = 'api-platform.systran.net'
+        @base_path = '/'
+        @user_agent = "ruby-swagger-#{Swagger::VERSION}"
+        @inject_format = false
+        @force_ending_format = false
+        @camelize_params = true
+
+        # keys for API key authentication (param-name => api-key)
+        @key = {}
+        # api-key prefix for API key authentication, e.g. "Bearer" (param-name => api-key-prefix)
+        @key_prefix = {}
+
+        # whether to verify SSL certificate, default to true
+        # Note: do NOT set it to false in production code, otherwise you would
+        #   face multiple types of cryptographic attacks
+        @verify_ssl = true
+      end
+    end
+  end
+end

data/lib/translationApi_client/swagger/request.rb

@@ -0,0 +1,272 @@
+module TranslationApiClient
+    module Swagger
+      class Request
+        require 'uri'
+        require 'addressable/uri'
+        require 'typhoeus'
+
+        attr_accessor :host, :path, :format, :params, :body, :http_method, :headers, :form_params, :auth_names
+
+        # All requests must have an HTTP method and a path
+        # Optionals parameters are :params, :headers, :body, :format, :host
+        def initialize(http_method, path, attributes={})
+          attributes[:format] ||= Swagger.configuration.format
+          attributes[:params] ||= {}
+
+          # Set default headers
+          default_headers = {
+              'Content-Type' => "application/#{attributes[:format].downcase}",
+              'User-Agent' => Swagger.configuration.user_agent
+          }
+
+          # Merge argument headers into defaults
+          attributes[:headers] = default_headers.merge(attributes[:headers] || {})
+
+          # Stick in the auth token if there is one
+          if Swagger.authenticated?
+            attributes[:headers].merge!({:auth_token => Swagger.configuration.auth_token})
+          end
+
+          self.http_method = http_method.to_sym
+          self.path = path
+          attributes.each do |name, value|
+            send("#{name.to_s.underscore.to_sym}=", value)
+          end
+
+          update_params_for_auth!
+        end
+
+        # Update hearder and query params based on authentication settings.
+        def update_params_for_auth!
+          (@auth_names || []).each do |auth_name|
+            case auth_name
+              when 'apiKey'
+                @params ||= {}
+                @params['key'] = get_key_with_prefix('key')
+              when 'accessToken'
+                @headers ||= {}
+                @headers['Authorization'] = get_key_with_prefix('Authorization')
+
+            end
+          end
+        end
+
+        # Get API key (with prefix if set).
+        # @param [String] param_name the parameter name of API key auth
+        def get_key_with_prefix(param_name)
+          Swagger.configuration.key
+        end
+
+        # Construct a base URL
+        def url(options = {})
+          u = Addressable::URI.new(
+              :scheme => Swagger.configuration.scheme,
+              :host => Swagger.configuration.host,
+              :path => self.interpreted_path,
+              :query => self.query_string.sub(/\?/, '')
+          ).to_s
+          puts ' url'
+
+          puts u
+          # Drop trailing question mark, if present
+          u.sub! /\?$/, ''
+          u
+        end
+
+        # Iterate over the params hash, injecting any path values into the path string
+        # e.g. /word.{format}/{word}/entries => /word.json/cat/entries
+        def interpreted_path
+          p = self.path.dup
+
+          # Stick a .{format} placeholder into the path if there isn't
+          # one already or an actual format like json or xml
+          # e.g. /words/blah => /words.{format}/blah
+          if Swagger.configuration.inject_format
+            unless ['.json', '.xml', '{format}'].any? {|s| p.downcase.include? s }
+              p = p.sub(/^(\/?\w+)/, "\\1.#{format}")
+            end
+          end
+
+          # Stick a .{format} placeholder on the end of the path if there isn't
+          # one already or an actual format like json or xml
+          # e.g. /words/blah => /words/blah.{format}
+          if Swagger.configuration.force_ending_format
+            unless ['.json', '.xml', '{format}'].any? {|s| p.downcase.include? s }
+              p = "#{p}.#{format}"
+            end
+          end
+
+          p = p.sub("{format}", self.format.to_s)
+
+          URI.encode [Swagger.configuration.base_path, p].join("/").gsub(/\/+/, '/')
+        end
+
+        # Massage the request body into a state of readiness
+        # If body is a hash, camelize all keys then convert to a json string
+        def body=(value)
+          if value.is_a?(Hash)
+            value = value.inject({}) do |memo, (k,v)|
+              memo[k.to_s.camelize(:lower).to_sym] = v
+              memo
+            end
+          end
+          @body = value
+        end
+
+        # If body is an object, JSONify it before making the actual request.
+        # For form parameters, remove empty value
+        def outgoing_body
+          # http form
+          if headers['Content-Type'] == 'application/x-www-form-urlencoded' || headers['Content-Type'] == 'multipart/form-data'
+            data = form_params.dup
+            data.each do |key, value|
+              data[key] = value.to_s if value && !value.is_a?(File) # remove emtpy form parameter
+            end
+            data
+          elsif @body # http body is JSON
+            @body.is_a?(String) ? @body : @body.to_json
+          else
+            nil
+          end
+        end
+
+        # Construct a query string from the query-string-type params
+        def query_string
+          # Iterate over all params,
+          # .. removing the ones that are part of the path itself.
+          # .. stringifying values so Addressable doesn't blow up.
+          query_values = {}
+          self.params.each_pair do |key, value|
+            next if self.path.include? "{#{key}}"                                   # skip path params
+            next if value.blank? && value.class != FalseClass                       # skip empties
+            if Swagger.configuration.camelize_params
+              key = key.to_s.camelize(:lower).to_sym
+            end
+            query_values[key] = value.to_s
+          end
+
+          # We don't want to end up with '?' as our query string
+          # if there aren't really any params
+          return "" if query_values.blank?
+
+          # Addressable requires query_values to be set after initialization..
+          qs = Addressable::URI.new
+          qs.query_values = query_values
+          qs.to_s
+        end
+
+        def make
+          #TODO use configuration setting to determine if debugging
+          #logger = Logger.new STDOUT
+          #logger.debug self.url
+          if self.outgoing_body.nil? || self.outgoing_body.empty?
+            self.headers['Content-Type'] = 'application/json'
+          end
+          request_options = {
+              :ssl_verifypeer => Swagger.configuration.verify_ssl,
+              :headers => self.headers.stringify_keys
+          }
+          response = case self.http_method.to_sym
+                       when :get,:GET
+                         Typhoeus::Request.get(
+                             self.url,
+                             #request_options,
+                             request_options.merge(:body => self.outgoing_body)
+                         )
+                       when :post,:POST
+                         Typhoeus::Request.post(
+                             self.url,
+                             request_options.merge(:body => self.outgoing_body)
+                         )
+
+                       when :patch,:PATCH
+                         Typhoeus::Request.patch(
+                             self.url,
+                             request_options.merge(:body => self.outgoing_body)
+                         )
+
+                       when :put,:PUT
+                         Typhoeus::Request.put(
+                             self.url,
+                             request_options.merge(:body => self.outgoing_body)
+                         )
+
+                       when :delete,:DELETE
+                         Typhoeus::Request.delete(
+                             self.url,
+                             request_options.merge(:body => self.outgoing_body)
+                         )
+                     end
+          Response.new(response)
+        end
+
+        def response
+          self.make
+        end
+
+        def response_code_pretty
+          return unless @response.present?
+          @response.code.to_s
+        end
+
+        def response_headers_pretty
+          return unless @response.present?
+          # JSON.pretty_generate(@response.headers).gsub(/\n/, '<br/>') # <- This was for RestClient
+          @response.headers.gsub(/\n/, '<br/>') # <- This is for Typhoeus
+        end
+
+        # return 'Accept' based on an array of accept provided
+        # @param [Array] header_accept_array Array fo 'Accept'
+        # @return String Accept (e.g. application/json)
+        def self.select_header_accept header_accept_array
+          if header_accept_array.empty?
+            return
+          elsif header_accept_array.any?{ |s| s.casecmp('application/json')==0 }
+            'application/json' # look for json data by default
+          else
+            header_accept_array.join(',')
+          end
+        end
+
+        # return the content type based on an array of content-type provided
+        # @param [Array] content_type_array Array fo content-type
+        # @return String Content-Type (e.g. application/json)
+        def self.select_header_content_type content_type_array
+          if content_type_array.empty?
+            'application/json' # use application/json by default
+
+          elsif content_type_array.any?{ |s| s.casecmp('application/json')==0 }
+            'application/json' # use application/json if it's included
+          else
+            content_type_array[0]; # otherwise, use the first one
+          end
+        end
+
+        # static method to convert object (array, hash, object, etc) to JSON string
+        # @param model object to be converted into JSON string
+        # @return string JSON string representation of the object
+        def self.object_to_http_body model
+          return if model.nil?
+          _body = nil
+          if model.is_a?(Array)
+            _body = model.map{|m| object_to_hash(m) }
+          else
+            _body = object_to_hash(model)
+          end
+          _body.to_json
+        end
+
+        # static method to convert object(non-array) to hash
+        # @param obj object to be converted into JSON string
+        # @return string JSON string representation of the object
+        def self.object_to_hash obj
+          if obj.respond_to?(:to_hash)
+            obj.to_hash
+          else
+            obj
+          end
+        end
+
+      end
+    end
+    end