haveapi-client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 411ee5aebf1042dcb0532fcfde75bb90a71a6a99
+  data.tar.gz: 81323b4e42c302b2030b051308082dca268556a1
+SHA512:
+  metadata.gz: 8fde9de9cdd152dca98d07b1f6fd74dbeb599c202a3031df0158b803e213047ee648b38077f8270c86d8b0bc0272a03e57c57a3a06354f5a0b44556c582ba613
+  data.tar.gz: 4265a74df48c07c9dc3ae1a706f833cc2be1a9eb7be40fa54abedeb00808e1e588a98a1543d8da318c73dfe007dbf1bdd6d71f5d9dc64e46c806a67702ef8d5d

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,67 @@
+HaveAPI-Client
+--------------
+HaveAPI-Client is a Ruby CLI and client library for APIs built with
+[HaveAPI framework](https://github.com/vpsfreecz/haveapi).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'haveapi-client'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install haveapi-client
+
+## Usage
+### CLI
+    $ haveapi-cli -h
+    Usage: haveapi-cli [options] <resource> <action> [objects ids] [-- [parameters]]
+        -a, --api URL                    API URL
+            --list-versions              List all available API versions
+            --list-resources VERSION     List all resource in API version
+            --list-actions VERSION       List all resources and actions in API version
+        -r, --raw                        Print raw response as is
+        -u, --username USER              User name
+        -p, --password PASSWORD          Password
+        -v, --[no-]verbose               Run verbosely
+        -h, --help                       Show this message
+  
+Using the API example from
+[HaveAPI README](https://github.com/vpsfreecz/haveapi/blob/master/README.md#example),
+users would be listed with:
+
+    $ haveapi-cli -a https://your.api.tld user index -u yourname -p yourpassword
+    
+Nested resources and object IDs:
+
+    $ haveapi-cli -a https://your.api.tld user.invoice index 10 -u yourname -p yourpassword
+
+where `10` is user ID.
+ 
+### Client library
+```ruby
+require 'haveapi/client'
+
+api = HaveAPI::Client::Client.new('https://your.api.tld')
+api.login('yourname', 'yourpassword')
+
+response = api.user.index
+p response.ok?
+p response.response
+
+p api.user(10).invoice
+p api.user(10).delete
+p api.user(10).delete!
+p api.user.delete(10)
+
+p api.user.create({
+  login: 'mylogin',
+  full_name: 'Very Full Name',
+  role: 'user'
+})
+```

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler/gem_tasks'
+

data/bin/haveapi-cli

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'haveapi/cli'
+
+HaveAPI::CLI::Cli.run

data/haveapi-client.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'haveapi/client/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'haveapi-client'
+  spec.version       = HaveAPI::Client::VERSION
+  spec.authors       = ['Jakub Skokan']
+  spec.email         = ['jakub.skokan@vpsfree.cz']
+  spec.summary       =
+  spec.description   = 'Ruby API and CLI for HaveAPI'
+  spec.homepage      = ''
+  spec.license       = 'GPL'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake'
+
+  spec.add_runtime_dependency 'activesupport', '~> 4.1.0'
+  spec.add_runtime_dependency 'require_all', '~> 1.3.0'
+  spec.add_runtime_dependency 'rest_client', '~> 1.7.3'
+  spec.add_runtime_dependency 'json', '~> 1.8.1'
+  spec.add_runtime_dependency 'highline', '~> 1.6.21'
+  spec.add_runtime_dependency 'table_print', '~> 1.5.1'
+end

data/lib/haveapi/cli.rb

@@ -0,0 +1,2 @@
+require 'haveapi/client'
+require 'haveapi/cli/cli'

data/lib/haveapi/cli/cli.rb

@@ -0,0 +1,290 @@
+require 'optparse'
+require 'pp'
+require 'highline/import'
+require 'table_print'
+
+module HaveAPI
+  module CLI
+    class Cli
+      def self.run
+        c = new
+      end
+
+      def initialize
+        args, @opts = options
+        @api = HaveAPI::Client::Communicator.new(api_url)
+
+        if @action
+          method(@action.first).call( * @action[1..-1] )
+          exit
+        end
+
+        if @opts[:help] || args.empty?
+          puts @global_opt.help
+          exit(true)
+        end
+
+        resources = args[0].split('.')
+        action = translate_action(args[1].to_sym)
+
+        action = @api.get_action(resources, action, args[2..-1])
+
+        @input_params = parameters(action)
+
+        if action
+          unless params_valid?(action)
+            warn 'Missing required parameters'
+          end
+
+          ret = action.execute(@input_params, raw: @opts[:raw])
+
+          if ret[:status]
+            format_output(action, ret[:response])
+          else
+            warn "Action failed: #{ret[:message]}"
+
+            if ret[:errors].any?
+              puts 'Errors:'
+              ret[:errors].each do |param, e|
+                puts "\t#{param}: #{e.join('; ')}"
+              end
+            end
+          end
+
+        else
+          warn "Action #{ARGV[0]}##{ARGV[1]} not valid"
+          exit(false)
+        end
+      end
+
+      def api_url
+        @opts[:client]
+      end
+
+      def options
+        options = {
+            client: default_url,
+            verbose: false,
+        }
+
+        @global_opt = OptionParser.new do |opts|
+          opts.banner = "Usage: #{$0} [options] <resource> <action> [objects ids] [-- [parameters]]"
+
+          opts.on('-a', '--api URL', 'API URL') do |url|
+            options[:client] = url
+          end
+
+          opts.on('--list-versions', 'List all available API versions') do
+            @action = [:list_versions]
+          end
+
+          opts.on('--list-resources VERSION', 'List all resource in API version') do |v|
+            @action = [:list_resources, v.sub(/^v/, '')]
+          end
+
+          opts.on('--list-actions VERSION', 'List all resources and actions in API version') do |v|
+            @action = [:list_actions, v.sub(/^v/, '')]
+          end
+
+          opts.on('-r', '--raw', 'Print raw response as is') do
+            options[:raw] = true
+          end
+
+          opts.on('-u', '--username USER', 'User name') do |u|
+            options[:user] = u
+          end
+
+          opts.on('-p', '--password PASSWORD', 'Password') do |p|
+            options[:password] = p
+          end
+
+          opts.on('-v', '--[no-]verbose', 'Run verbosely') do |v|
+            options[:verbose] = v
+          end
+
+          opts.on('-h', '--help', 'Show this message') do
+            options[:help] = true
+          end
+        end
+
+        args = []
+
+        ARGV.each do |arg|
+          if arg == '--'
+            break
+          else
+            args << arg
+          end
+        end
+
+        @global_opt.parse!(args)
+
+        # p options
+        #p ARGV
+
+        [args, options]
+      end
+
+      def parameters(action)
+        options = {}
+        sep = ARGV.index('--')
+
+        @action_opt = OptionParser.new do |opts|
+          opts.banner = ''
+
+          action.input[:parameters].each do |name, p|
+            opts.on(param_option(name, p), p[:description] || p[:label] || '') do |*args|
+              options[name] = args.first
+            end
+          end
+
+          opts.on('-h', '--help', 'Show this message') do
+            @opts[:help] = true
+          end
+        end
+
+        if @opts[:help]
+          puts @global_opt.help
+          puts ''
+          print 'Action parameters:'
+          puts @action_opt.help
+          exit
+        end
+
+        return {} unless sep
+
+        @action_opt.parse!(ARGV[sep+1..-1])
+
+        options
+      end
+
+      def param_option(name, p)
+        ret = '--'
+        name = name.to_s.dasherize
+
+        if p[:type] == 'Boolean'
+          ret += "[no-]#{name}"
+
+        else
+          ret += "#{name} #{name.underscore.upcase}"
+        end
+
+        ret
+      end
+
+      def translate_action(action)
+        tr = {
+            list: :index,
+            new: :create,
+            change: :update
+        }
+
+        if tr.has_key?(action)
+          return tr[action]
+        end
+
+        action
+      end
+
+      def list_versions
+        desc = @api.describe_api
+
+        desc[:versions].each do |v, _|
+          next if v == :default
+
+          v_int = v.to_s.to_i
+
+          puts "#{v_int == desc[:default_version] ? '*' : ' '} v#{v}"
+        end
+      end
+
+      def list_resources(v)
+        @api.describe_api(v)[:resources].each do |resource, children|
+          nested_resource(resource, children, false)
+        end
+      end
+
+      def list_actions(v)
+        @api.describe_api(v)[:resources].each do |resource, children|
+          nested_resource(resource, children, true)
+        end
+      end
+
+      def nested_resource(prefix, children, actions=false)
+        if actions
+          children[:actions].each do |action, _|
+            puts "#{prefix}##{action}"
+          end
+        else
+          puts prefix
+        end
+
+        children[:resources].each do |resource, children|
+          nested_resource("#{prefix}.#{resource}", children, actions)
+        end
+      end
+
+      def format_output(action, response)
+        if @opts[:raw]
+          puts response
+          return
+        end
+
+        return if response.empty?
+
+        s = action.structure
+        namespace = action.namespace(:output).to_sym
+
+        case action.layout.to_sym
+          when :list
+            tp response[namespace]
+
+
+          when :object
+            response[namespace].each do |k, v|
+              puts "#{k}: #{v}"
+            end
+
+
+          when :custom
+            pp response[namespace]
+
+        end
+      end
+
+      def header_for(action, param)
+        params = action.params
+
+        if params.has_key?(param) && params[param][:label]
+          params[param][:label]
+        else
+          param.to_s.upcase
+        end
+      end
+
+      def params_valid?(action)
+        if action.auth?
+          @opts[:user] ||= ask('User name: ') { |q| q.default = nil }
+
+          @opts[:password] ||= ask('Password: ') do |q|
+            q.default = nil
+            q.echo = false
+          end
+        end
+
+        if action.auth? && !(@opts[:user] || @opts[:password])
+          return false
+        end
+
+        @api.login(@opts[:user], @opts[:password])
+
+        true
+      end
+
+      protected
+      def default_url
+        'http://localhost:4567'
+      end
+    end
+  end
+end

data/lib/haveapi/client.rb

@@ -0,0 +1,2 @@
+require 'require_all'
+require_rel 'client'

data/lib/haveapi/client/action.rb

@@ -0,0 +1,81 @@
+module HaveAPI
+  module Client
+    class Action
+      def initialize(api, name, spec, args)
+        @api = api
+        @name = name
+        @spec = spec
+
+        apply_args(args)
+      end
+
+      def execute(*args)
+        ret = @api.call(self, *args)
+        @prepared_url = nil
+        ret
+      end
+
+      def name
+        @name
+      end
+
+      def auth?
+        @spec[:auth]
+      end
+
+      def input
+        @spec[:input]
+      end
+
+      def output
+        @spec[:output]
+      end
+
+      def layout
+        @spec[:output][:layout]
+      end
+
+      def structure
+        @spec[:output][:format]
+      end
+
+      def namespace(src)
+        @spec[src][:namespace]
+      end
+
+      def params
+        @spec[:output][:parameters]
+      end
+
+      def url
+        @spec[:url]
+      end
+
+      # Url with resolved parameters.
+      def prepared_url
+        @prepared_url || @spec[:url]
+      end
+
+      def http_method
+        @spec[:method]
+      end
+
+      def unresolved_args?
+        prepared_url =~ /:[a-zA-Z\-_]+/
+      end
+
+      def provide_args(*args)
+        apply_args(args)
+      end
+
+      private
+        def apply_args(args)
+          @prepared_url ||= @spec[:url].dup
+
+          args.each do |arg|
+            @prepared_url.sub!(/:[a-zA-Z\-_]+/, arg.to_s)
+          end
+        end
+    end
+  end
+end

data/lib/haveapi/client/client.rb

@@ -0,0 +1,37 @@
+require 'pp'
+
+class HaveAPI::Client::Client
+  attr_reader :resources
+
+  def initialize(url, v=nil)
+    @version = v
+    @api = VpsAdmin::API::Communicator.new(url)
+
+    setup_api(@api.describe_api)
+  end
+
+  def login(*credentials)
+    @api.login(*credentials)
+  end
+
+  private
+  def setup_api(description)
+    v = @version || description[:default_version]
+
+    @resources = {}
+
+    description[:versions][v.to_s.to_sym][:resources].each do |name, desc|
+      r = VpsAdmin::API::Resource.new(@api, name)
+      r.setup(desc)
+
+      define_singleton_method(name) do |*args|
+        tmp = r.dup
+        tmp.prepared_args = args
+        tmp.setup_from_clone(r)
+        tmp
+      end
+
+      @resources[name] = r
+    end
+  end
+end

data/lib/haveapi/client/communicator.rb

@@ -0,0 +1,115 @@
+require 'rest_client'
+require 'json'
+require 'active_support/inflections'
+require 'active_support/inflector'
+require_rel '../../restclient_ext'
+
+module HaveAPI
+  module Client
+    class Communicator
+      def initialize(url)
+        @url = url
+        @rest = RestClient::Resource.new(@url)
+        @version = 1
+      end
+
+      def login(user, password)
+        @rest = RestClient::Resource.new(@url, user, password)
+      end
+
+      def describe_api(v=nil)
+        description_for(path_for(v))
+      end
+
+      def describe_action(v, r)
+
+      end
+
+      def get_action(resources, action, args)
+        @spec ||= describe_api(@version)
+
+        tmp = @spec
+
+        resources.each do |r|
+          tmp = tmp[:resources][r.to_sym]
+
+          return false unless tmp
+        end
+
+        a = tmp[:actions][action]
+
+        if a
+          Action.new(self, action, a, args)
+        else
+          false
+        end
+      end
+
+      def call(action, params, raw: false)
+        args = []
+        input_namespace = action.namespace(:input)
+
+        if %w(POST PUT).include?(action.http_method)
+          args << {input_namespace => params}.to_json
+          args << {:content_type => :json, :accept => :json}
+
+        elsif %w(GET DELETE).include?(action.http_method)
+          get_params = {}
+
+          params.each do |k, v|
+            get_params["#{input_namespace}[#{k}]"] = v
+          end
+
+          args << {params: get_params, accept: :json}
+        end
+
+        begin
+          response = parse(@rest[action.prepared_url].method(action.http_method.downcase.to_sym).call(*args))
+
+        rescue RestClient::Forbidden
+          return error('Access forbidden. Bad user name or password? Not authorized?')
+
+        rescue => e
+          return error("Fatal API error: #{e.inspect}")
+        end
+
+        if response[:status]
+          if raw
+            ok(JSON.pretty_generate(response[:response]))
+          else
+            ok(response[:response])
+          end
+
+        else
+          error(response[:message], response[:errors])
+        end
+      end
+
+      private
+        def ok(response)
+          {status: true, response: response}
+        end
+
+        def error(msg, errors={})
+          {status: false, message: msg, errors: errors}
+        end
+
+        def path_for(v=nil, r=nil)
+          ret = '/'
+
+          ret += "v#{v}/" if v
+          ret += r if r
+
+          ret
+        end
+
+        def description_for(path)
+          parse(@rest[path].get_options)
+        end
+
+        def parse(str)
+          JSON.parse(str, symbolize_names: true)
+        end
+    end
+  end
+end

data/lib/haveapi/client/exceptions.rb

@@ -0,0 +1,13 @@
+module HaveAPI
+  module Client
+    class ActionFailed < Exception
+      def initialize(response)
+        @response = response
+      end
+
+      def message
+        "#{@response.action.name} failed: #{@response.message}"
+      end
+    end
+  end
+end

data/lib/haveapi/client/inflections.rb

@@ -0,0 +1,3 @@
+ActiveSupport::Inflector.inflections(:en) do |inflect|
+  inflect.irregular 'vps', 'vpses'
+end

data/lib/haveapi/client/resource.rb

@@ -0,0 +1,78 @@
+class HaveAPI::Client::Resource
+  attr_reader :actions, :resources, :name
+  attr_accessor :prepared_args
+
+  def initialize(api, name)
+    @api = api
+    @name = name
+    @prepared_args = []
+  end
+
+  def setup(description)
+    @actions = {}
+    @resources = {}
+
+    description[:actions].each do |name, desc|
+      action = HaveAPI::Client::Action.new(@api, name, desc, [])
+      define_action(action)
+      @actions[name] = action
+    end
+
+    description[:resources].each do |name, desc|
+      r = HaveAPI::Client::Resource.new(@api, name)
+      r.setup(desc)
+      define_resource(r)
+      @resources[name] = r
+    end
+  end
+
+  def setup_from_clone(original)
+    original.actions.each_value do |action|
+      define_action(action)
+    end
+
+    original.resources.each_value do |resource|
+      define_resource(resource)
+    end
+  end
+
+  private
+  def define_action(action)
+    define_singleton_method(action.name) do |*args|
+      all_args = @prepared_args + args
+
+      if action.unresolved_args?
+        all_args.delete_if do |arg|
+          break unless action.unresolved_args?
+
+          action.provide_args(arg)
+          true
+        end
+
+        if action.unresolved_args?
+          raise ArgumentError.new('One or more object ids missing')
+        end
+      end
+
+      all_args << {} if all_args.empty?
+
+      HaveAPI::Client::Response.new(action, action.execute(*all_args))
+    end
+
+    define_singleton_method("#{action.name}!".to_sym) do |*args|
+      ret = method(action.name).call(*args)
+      raise HaveAPI::Client::ActionFailed.new(ret) unless ret.ok?
+
+      ret
+    end
+  end
+
+  def define_resource(resource)
+    define_singleton_method(resource.name) do |*args|
+      tmp = resource.dup
+      tmp.prepared_args = @prepared_args + args
+      tmp.setup_from_clone(resource)
+      tmp
+    end
+  end
+end

data/lib/haveapi/client/response.rb

@@ -0,0 +1,33 @@
+class HaveAPI::Client::Response
+  attr_reader :action
+
+  def initialize(action, response)
+    @action = action
+    @response = response
+  end
+
+  def ok?
+    @response[:status]
+  end
+
+  def failed?
+    !ok?
+  end
+
+  def response
+    case @action.layout.to_sym
+      when :object, :list
+        @response[:response][@action.namespace(:output).to_sym]
+      else
+        @response[:response]
+    end
+  end
+
+  def message
+    @response[:message]
+  end
+
+  def errors
+    @response[:errors]
+  end
+end

data/lib/haveapi/client/version.rb

@@ -0,0 +1,5 @@
+module HaveAPI
+  module Client
+    VERSION = '0.1.0'
+  end
+end

data/lib/restclient_ext/request.rb

@@ -0,0 +1,16 @@
+module RestClient
+  class Request
+    def self.execute_options(args, &block)
+      new(args).execute_options(&block)
+    end
+
+    def execute_options(&block)
+      uri = parse_url_with_auth(url)
+      http_request = Net::HTTPGenericRequest.new(method.to_s.upcase, false, true, uri.request_uri, processed_headers)
+
+      transmit uri, http_request, payload, & block
+    ensure
+      payload.close if payload
+    end
+  end
+end

data/lib/restclient_ext/resource.rb

@@ -0,0 +1,11 @@
+module RestClient
+  class Resource
+    def get_options(additional_headers={}, &block)
+      headers = (options[:headers] || {}).merge(additional_headers)
+      Request.execute_options(options.merge(
+                          :method => :options,
+                          :url => url,
+                          :headers => headers), &(block || @block))
+    end
+  end
+end

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification
+name: haveapi-client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jakub Skokan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+- !ruby/object:Gem::Dependency
+  name: require_all
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: rest_client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.7.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.7.3
+- !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: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.21
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.21
+- !ruby/object:Gem::Dependency
+  name: table_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+description: Ruby API and CLI for HaveAPI
+email:
+- jakub.skokan@vpsfree.cz
+executables:
+- haveapi-cli
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- Rakefile
+- bin/haveapi-cli
+- haveapi-client.gemspec
+- lib/haveapi/cli.rb
+- lib/haveapi/cli/cli.rb
+- lib/haveapi/client.rb
+- lib/haveapi/client/action.rb
+- lib/haveapi/client/client.rb
+- lib/haveapi/client/communicator.rb
+- lib/haveapi/client/exceptions.rb
+- lib/haveapi/client/inflections.rb
+- lib/haveapi/client/resource.rb
+- lib/haveapi/client/response.rb
+- lib/haveapi/client/version.rb
+- lib/restclient_ext/request.rb
+- lib/restclient_ext/resource.rb
+homepage: ''
+licenses:
+- GPL
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: Ruby API and CLI for HaveAPI
+test_files: []