openapi 0.9.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4e366b43db91509db13581198cbabd097e4d92af
+  data.tar.gz: 64548818655ac85cdb45735daf9fb3d6a9a38d50
+SHA512:
+  metadata.gz: c020ed786a7d6c4722a674af7c9bac4da8c812e11adfca9fbc3e42f37434172566de174b5f2658896176bbd1939b9781613d471df03bafe228f9d133b020147e
+  data.tar.gz: a9e3649c95ba73b23f4eadd6821661665ed1216266edec63a4a6f734b6d6e78b7a1500e6ac79d529591763bc66c69275198a84a8326c48a1a83fe9dabcf35ba5

data/Changelog

@@ -0,0 +1,7 @@
+- 0.0.2
+ * Gem build
+-- Antoine Legrand <antoine.legrand@ubudu.com>  27/07/2013
+
+- 0.0.1
+ * Initial version
+-- Antoine Legrand <antoine.legrand@ubudu.com>  27/07/2013

data/License

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Antoine Legrand (ant.legrand@gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,2 @@
+UbuduScout
+==========

data/Rakefile

@@ -0,0 +1,8 @@
+desc 'Run all the tests'
+task :default => :spec
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ['-c', '-f progress', '-r ./spec/spec_helper.rb']
+  t.pattern = 'spec/**/*_spec.rb'
+end

data/lib/openapi/auth_token.rb

@@ -0,0 +1,115 @@
+module OpenAPI
+  class AuthToken
+    attr_accessor :header, :key, :options,  :header_format, :expires_at, :expires, :expires_in, :token, :refresh_token
+
+    class << self
+      attr_accessor :key
+
+      def fetch_or_create(key, opts)
+        auth_token = fetch(key)
+        if auth_token.nil? || auth_token.renew?
+          self.class.new(opts)
+        else
+          auth_token
+        end
+      end
+
+      def fetch(key)
+        if OpenAPI.cache
+          begin
+            puts "fetch new: #{OpenAPI.cache.get(key)}"
+            return self.new(JSON.parse(OpenAPI.cache.get(key)))
+          rescue => e
+            puts e.message
+          end
+        end
+      end
+
+      def key
+        @key ||= self.name
+      end
+    end
+
+    def key
+      @key ||= self.class.key
+    end
+
+    def update(opts={}, save=false)
+      @options = @options.merge(opts)
+      @options.each do |k, v|
+        instance_variable_set("@#{k}", v)
+      end
+      @token ||= @options.delete("access_token")
+      @options["token"] = @token
+      if opts.has_key?("expires_at") && !opts["expires_at"].nil?
+        @expires_at = opts["expires_at"].to_i
+      elsif opts.has_key?("expires_in") && !opts["expires_in"].nil?
+        @options.delete("expires_in")
+        @expires_at = Time.now.utc.to_i + opts["expires_in"]
+        @options["expires_at"] = @expires_at
+      end
+      self.save if save
+    end
+
+    def [](key)
+      @options[key.to_s]
+    end
+
+    def initialize(opts={}, save=false)
+      @options = {}
+      opts = {"token" => nil,
+        "refresh_token" => nil,
+        "expires_at" => nil,
+        "expires_in" => nil,
+        "key" => nil,
+        "header" => "Authorization",
+        "header_format" => "Bearer %s"}.merge(opts)
+      update(opts, save)
+    end
+
+    def headers
+      {header => header_format % @token}
+    end
+
+    def expires_in
+      (expires_at.to_i - Time.now.utc.to_i).abs
+    end
+
+    def save
+      if OpenAPI.cache
+        OpenAPI.cache.set(key, to_hash.to_json, expires_in + 2.hours)
+      end
+    end
+
+    def to_hash
+      @options
+    end
+
+    def token(force_renew=false)
+      if renew? || force_renew
+        renew_token
+      end
+      @token
+    end
+
+    def renew?
+      @token == nil || @expires_at.to_i < Time.now.utc.to_i
+    end
+
+    def new_auth_token()
+      raise NotImplementedError
+    end
+
+
+    def renew_token
+      new_token = self.class.fetch(self.key)
+      if new_token.nil? || new_token.renew?
+        self.new_auth_token
+        self.save
+      else
+        update(new_token.to_hash)
+      end
+    end
+
+  end
+end

data/lib/openapi/client.rb

@@ -0,0 +1,136 @@
+require 'net/https'
+require 'time'
+require 'base64'
+require 'oauth2'
+
+require File.join(File.dirname(__FILE__), 'response')
+
+module OpenAPI
+  begin
+    require 'system_timer'
+    Timer = SystemTimer
+  rescue LoadError
+    require 'timeout'
+    Timer = Timeout
+  end
+
+  module ClassMethods
+    attr_accessor :application_key, :application_secret, :max_retry,
+    :logger, :request_timeout, :client_id, :site, :auth_token, :api_version, :api_methods, :use_ssl, :cache
+
+    def api_methods
+      @api_methods ||= []
+    end
+
+    def create_method(name, callback)
+      metaclass.instance_eval do
+        define_method(name, callback)
+      end
+    end
+
+    def call_api(request)
+      Timer.timeout(request_timeout) do
+        start_time = Time.now
+        response = http_client.request(request)
+        log_request_and_response(request, response, Time.now - start_time)
+
+        response = OpenAPI::Response.wrap(response)
+        return response
+      end
+    rescue Timeout::Error
+      unless logger.nil?
+        logger.error "OpenAPI request timed out after #{request_timeout} seconds: [#{request.path} #{request.body}]"
+      end
+      OpenAPI::Response.wrap(nil, :body => {:error => 'Request timeout'}, :code => '503')
+    end
+
+    def build_path(path, params=nil)
+      uri = URI("/#{api_v}/#{path.gsub(/:client_id/, client_id)}")
+      if params != nil
+        uri.query = URI.encode_www_form(params)
+      end
+      return uri
+    end
+
+    def auth_token
+      raise NotImplementedError
+    end
+
+    def do_request(http_method, path, options = {}, retried=0)
+      path = build_path(path, options[:params])
+
+      klass = Net::HTTP.const_get(http_method.to_s.capitalize)
+      request = klass.new(path.to_s)
+      request.add_field "Content-Type", options[:content_type] || "application/json"
+      if !auth_token.nil? && options[:skip_auth] != true
+        request.add_field "Authorization", (options[:access_token] || auth_token.token)
+      end
+      request.add_field "Accept", options[:accept] || "application/json"
+      #Authorization: Basic dWJ1ZHUtYXBpOmZHWTI4aypOZTh2YzA=
+      #Authorization: Bearer
+      request.body = options[:body] if options[:body]
+      response = call_api(request)
+      return response
+    end
+
+    def verify_configuration_values(*symbols)
+      absent_values = symbols.select{|symbol| instance_variable_get("@#{symbol}").nil? }
+      raise("Must configure #{absent_values.join(", ")} before making this request.") unless absent_values.empty?
+    end
+
+    def site
+      @site
+    end
+
+    def http_client
+      Net::HTTP.new(site, 443).tap{|http| http.use_ssl = true}
+    end
+
+    def log_request_and_response(request, response, time)
+      return if logger.nil?
+      time = (time * 1000).to_i
+      http_method = request.class.to_s.split('::')[-1]
+      logger.info "#{self.class.name} (#{time}ms): [#{http_method} #{request.path} #{request.to_hash}, #{request.body}], [#{response.code}, #{response.body}]"
+      logger.flush if logger.respond_to?(:flush)
+    end
+
+    def format_time(time)
+      time = Time.parse(time) if time.is_a?(String)
+      time.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+    end
+
+    def request_timeout
+      @request_timeout || 5.0
+    end
+
+    def api_v()
+      @api_version || "v1"
+    end
+
+    def logger
+      @logger ||= OpenAPI.logger
+    end
+
+  end
+
+  class << self
+    include ClassMethods
+  end
+
+  class Client
+    class << self
+      include ClassMethods
+    end
+    include ClassMethods
+
+    def initialize(options={})
+      @api_version = options[:api_version] || OpenAPI.api_version
+      @logger = options[:logger] || OpenAPI.logger
+      @application_key = options[:application_key] || OpenAPI.application_key
+      @application_secret = options[:application_secret] || OpenAPI.application_secret
+      @site = options[:site] || OpenAPI.site
+      @request_timeout = options[:request_timeout] || OpenAPI.request_timeout || 5
+      @max_retry = options[:max_retry] || OpenAPI.max_retry || 2
+    end
+  end
+end

data/lib/openapi/exceptions.rb

@@ -0,0 +1,6 @@
+module OpenAPI
+  module Exceptions
+    class AuthError < StandardError
+    end
+  end
+end

data/lib/openapi/handlers/array.rb

@@ -0,0 +1,44 @@
+require 'active_support'
+require File.join(File.dirname(__FILE__), '../models')
+module OpenAPI
+  module Handlers
+    class Array < OpenAPI::Handler
+      class << self
+
+
+        def method_missing(method_symbol, *arguments) #:nodoc:
+          method_name = method_symbol.to_s
+          if method_name =~ /^(\w+)_array$/
+            return self.send :construct_array, $1, *arguments
+          else
+            super
+          end
+        end
+
+        def raw_array(response, options)
+          array = []
+          response.each do |model_attr|
+            array << model_attr
+          end
+          array = OpenAPI::Handlers::Response.wrap(array, response)
+          return array
+        end
+
+        private
+
+        def construct_array(snake_name, response, options)
+          return self.failed(response) if not response.success?
+          array = []
+          klass_name = ActiveSupport::Inflector.camelize(snake_name, true)
+          klass = OpenAPI::Models.const_get(klass_name)
+          response.each do |model_attr|
+            array << klass.new.from_json(model_attr.to_json)
+          end
+          array = OpenAPI::Handlers::Response.wrap(array, response)
+          return array
+        end
+
+      end
+    end
+  end
+end

data/lib/openapi/handlers/dummy.rb

@@ -0,0 +1,31 @@
+require File.join(File.dirname(__FILE__), '../handlers')
+
+module OpenAPI
+  module Handlers
+
+    class Dummy < OpenAPI::Handler
+      class << self
+        def titi(id, name)
+          puts "id:#{id.to_s[0..10]}, name:#{name}"
+        end
+      end
+    end
+
+    class Campaigns < OpenAPI::Handler
+      class << self
+        def stats(response, options)
+          return response, options
+        end
+      end
+    end
+
+    class Offers < OpenAPI::Handler
+      class << self
+        def index(response, options)
+          return response, options
+        end
+      end
+    end
+
+  end
+end

data/lib/openapi/handlers/model.rb

@@ -0,0 +1,30 @@
+require 'active_support'
+require File.join(File.dirname(__FILE__), '../models')
+module OpenAPI
+  module Handlers
+    class Model < OpenAPI::Handler
+      class << self
+        def method_missing(method_symbol, *arguments) #:nodoc:
+          method_name = method_symbol.to_s
+          if method_name =~ /^(\w+)_model$/
+            return self.send :construct_model, $1, *arguments
+          else
+            super
+          end
+        end
+
+        private
+
+        def construct_model(snake_name, response, options)
+          return self.failed(response) if not response.success?
+          klass_name = ActiveSupport::Inflector.camelize(snake_name, true)
+          klass = OpenAPI::Models.const_get(klass_name)
+          model = klass.new.from_json(response.raw)
+          model = OpenAPI::Handlers::Response.wrap(model, response)
+          return model
+        end
+
+      end
+    end
+  end
+end

data/lib/openapi/handlers/raw.rb

@@ -0,0 +1,15 @@
+require 'active_support'
+require File.join(File.dirname(__FILE__), '../models')
+module OpenAPI
+  module Handlers
+    class Raw < OpenAPI::Handler
+      class << self
+
+        def text(response, options)
+          return self.failed(response) if not response.success?
+          return response
+        end
+      end
+    end
+  end
+end

data/lib/openapi/handlers/response.rb

@@ -0,0 +1,23 @@
+module OpenAPI
+  module Handlers
+    module Response
+      module InstanceMethods
+        attr_accessor :response
+
+        def code
+          response.code
+        end
+
+        def success?
+          response.success?
+        end
+      end
+
+      def self.wrap(obj, response)
+        obj.extend(OpenAPI::Handlers::Response::InstanceMethods)
+        obj.response = response
+        return obj
+      end
+    end
+  end
+end

data/lib/openapi/handlers.rb

@@ -0,0 +1,13 @@
+module OpenAPI
+  class Handler
+    def self.failed(response)
+      #      error =  OpenAPI::Models::Error.new().from_json(response.raw)
+      model =  OpenAPI::Handlers::Response.wrap(response.raw, response)
+      return model
+    end
+  end
+end
+
+dir = File.dirname(__FILE__)
+handlers_dir = File.join(dir, "handlers")
+Dir[handlers_dir + "/*.rb"].each {|file| require  file }

data/lib/openapi/metaclass.rb

@@ -0,0 +1,11 @@
+class Object
+  def metaclass
+    class << self; self; end
+  end
+  def make_callback(obj, meth)
+    metaclass = class << self; self; end
+    metaclass.send(:define_method, :callback) do
+      obj.send(meth)
+    end
+  end
+end

data/lib/openapi/models/base.rb

@@ -0,0 +1,16 @@
+require 'simplemodel'
+module OpenAPI
+  module Models
+    class Base < SimpleModel::Base
+      include SimpleModel::Association
+
+      attr_accessor :raw_json
+
+      def initialize(opts={})
+        super(opts)
+      end
+
+
+    end
+  end
+end

data/lib/openapi/models.rb

@@ -0,0 +1,11 @@
+require 'simplemodel'
+require 'active_model'
+$:.unshift(File.dirname(__FILE__))
+module OpenAPI
+  module Models
+    class << self
+      attr_accessor :active_record
+    end
+    autoload :Base, "models/base"
+  end
+end

data/lib/openapi/response.rb

@@ -0,0 +1,34 @@
+module OpenAPI
+  module Response
+    module InstanceMethods
+      attr_accessor :response, :options, :raw
+
+      def code
+        response.code.to_s
+      end
+
+      def success?
+        !!(code =~ /^2/)
+      end
+    end
+
+    def self.wrap(response)
+      OpenAPI.logger.debug(response.body)
+      if !response.to_hash["content-type"].find{|a| a.match /.*json.*/}
+        output = response.body
+      else
+        begin
+          output = JSON.parse(response.body || '{}')
+        rescue JSON::ParserError => e
+          OpenAPI.logger.error(e.message)
+          OpenAPI.logger.error(e.backtrace.join("\n"))
+          output = {}
+        end
+      end
+      output.extend(OpenAPI::Response::InstanceMethods)
+      output.response = response
+      output.raw = response.body
+      return output
+    end
+  end
+end

data/lib/openapi/route.rb

@@ -0,0 +1,136 @@
+require 'active_support'
+module OpenAPI
+  module Route
+    # def static
+    #   match '/track_coupon/:source/:id' => 'mobile_banner#track_coupon', :as_ => :track_coupon, :defaults => { :format => 'png' }
+    module ClassMethods
+
+      def check_params(path, params, model=nil)
+        keys = {}
+        parts = path.split("/")
+        parts.each do |part|
+          if part.start_with?(":")
+            keys[part] = true
+            name = part[1..-1].to_sym
+            if !params.has_key?(name)
+              if model.respond_to?(name)
+                params[name] = model.send name
+              else
+                # @todo raise real errors
+                raise "Missing params: set '#{part}' to complete '#{path}' request"
+              end
+            end
+          end
+        end
+        return keys
+      end
+
+
+
+      def create_proc(klass, kmethod, path, options, client=nil)
+        proc = Proc.new() do |arg1=nil, arg2={}, p=nil|
+          if p != nil
+            uri_path = p.clone()
+          else
+            uri_path = path.clone()
+          end
+          if client == nil
+            client = OpenAPI::Route.get_client()
+          end
+          model = nil
+          if options.has_key?(:body) && !arg1.instance_of?(Hash)
+            model = arg1
+            params = arg2
+            if !model.instance_of?(options[:body])
+              raise "Expected #{options[:body]} class, got #{model.class} instead"
+            end
+          elsif arg1.instance_of?(Hash) && options.has_key?(:body) && arg1[:body] == nil
+            raise "No body provided"
+          else
+            if arg1 == nil || arg1.instance_of?(Hash)
+              params = arg1 || {}
+            end
+          end
+
+          if model != nil
+            to_json_options = nil
+            if params.has_key?(:to_json)
+              to_json_options = params[:to_json]
+            elsif options.has_key?(:to_json)
+              to_json_options = options[:to_json]
+            end
+            if to_json_options
+              params[:body] = model.send :to_json, to_json_options
+            else
+              params[:body] = model.to_json
+            end
+          end
+
+          if params.has_key?(:display_help) && params[:display_help]
+            return options
+          end
+
+          parameters = params[:params] || {}
+          params.each do |key,v|
+            if options.has_key?(:params) && options[:params].has_key?(key)
+              parameters[key] = v
+            end
+          end
+          params[:params] = parameters
+
+          if options.has_key?(:extra)
+            options[:extra].each do |k,v|
+              if !params.has_key?(k)
+                params[k] = v
+              end
+            end
+          end
+
+          OpenAPI.logger.debug params
+          if not params.has_key?(:client_id)
+            params[:client_id] = client.client_id
+          end
+          OpenAPI::Route.check_params(uri_path, params, model)
+
+          #1. soon.wrap = do_request opts[:body] => postjson
+          new_path = uri_path.clone()
+          params.each do |key, v|
+            r = Regexp.compile(":" + key.to_s)
+            new_path.gsub!(r, v.to_s)
+          end
+          OpenAPI.logger.debug(new_path)
+          response = client.do_request(options[:via], new_path, params)
+          #2. callback
+          return klass.send kmethod.to_s.to_sym, response, params
+        end
+        return proc
+      end
+
+      def match(path, callback, name, options={:via => :get}, client=nil)
+        klass_name, klass_method = callback.split("#")
+        klass_name = klass_name.classify
+        klass = Object.const_get(klass_name)
+        if client == nil
+          client = get_client()
+        end
+        proc = create_proc(klass, klass_method, path, options , client)
+        client.api_methods << name
+        client.create_method(name.to_s, proc)
+        return true
+      end
+
+      def get_client
+        @client ||= OpenAPI::Client
+      end
+
+      def draw(client=nil, &block)
+        @client = client
+        class_eval &block
+      end
+    end
+
+    class << self
+      include ClassMethods
+    end
+  end
+end

data/lib/openapi/utils.rb

@@ -0,0 +1,52 @@
+require 'securerandom'
+
+module OpenAPI
+  module Utils
+    class Random
+      class << self
+        def hex(n=16)
+          SecureRandom.hex(n)
+        end
+      end
+    end
+
+    class Date
+      class << self
+
+        def format(date)
+          date.strftime("%Y%m%d")
+        end
+
+        def now()
+          format(Time.now.utc())
+        end
+      end
+
+      def to_s()
+        @date_str
+      end
+
+      def date()
+        @date
+      end
+
+      def inititialize(t = nil)
+        if t == nil
+          t = Time.now.utc()
+        end
+        @date_str = OpenAPI::Utils::Date.format(t)
+        @date = t.dup()
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module SecureRandom
+    class << self
+      def hex(n=16)
+        OpenAPI::Utils::Random.hex(n)
+      end
+    end
+  end
+end

data/lib/openapi/validators.rb

@@ -0,0 +1,19 @@
+module OpenAPI
+  module Models
+    module Validation
+      class UrlValidator < ActiveModel::EachValidator
+        def validate_each(record, attribute, value)
+          begin
+            uri = URI.parse(value)
+            resp = uri.kind_of?(URI::HTTP)
+          rescue URI::InvalidURIError
+            resp = false
+          end
+          unless resp == true
+            record.errors[attribute] << (options[:message] || "is not an url")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openapi/version.rb

@@ -0,0 +1,3 @@
+module OpenAPI
+  VERSION = '0.9.7'
+end

data/lib/openapi.rb

@@ -0,0 +1,19 @@
+require "active_support/core_ext/numeric/time"
+require 'openapi/exceptions'
+require 'openapi/utils'
+require 'openapi/client'
+require 'openapi/response'
+require 'openapi/metaclass'
+require 'openapi/handlers'
+require 'openapi/route'
+require 'openapi/models'
+require 'openapi/auth_token'
+
+
+
+## MOVE TO APP ""
+require 'logger'
+OpenAPI.logger = Logger.new(STDOUT)
+OpenAPI.request_timeout = 5 # default
+OpenAPI.max_retry=2
+OpenAPI.cache = nil

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: openapi
+version: !ruby/object:Gem::Version
+  version: 0.9.7
+platform: ruby
+authors:
+- Antoine Legrand
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: simplemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakeweb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A lots of service expose a more or less complex API. The library provides
+  common tasks to easily build a ruby wrapper
+email:
+- ant.legrand@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Changelog
+- License
+- README.md
+- Rakefile
+- lib/openapi.rb
+- lib/openapi/auth_token.rb
+- lib/openapi/client.rb
+- lib/openapi/exceptions.rb
+- lib/openapi/handlers.rb
+- lib/openapi/handlers/array.rb
+- lib/openapi/handlers/dummy.rb
+- lib/openapi/handlers/model.rb
+- lib/openapi/handlers/raw.rb
+- lib/openapi/handlers/response.rb
+- lib/openapi/metaclass.rb
+- lib/openapi/models.rb
+- lib/openapi/models/base.rb
+- lib/openapi/response.rb
+- lib/openapi/route.rb
+- lib/openapi/utils.rb
+- lib/openapi/validators.rb
+- lib/openapi/version.rb
+homepage: http://github.com/antlegrand/openapi
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A Ruby library to build api wrapper
+test_files: []
+has_rdoc: