apipie-bindings 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f00c3378b7cf3f91734f1a97d241da813a71e53d
+  data.tar.gz: 9530ae0e0a9a00c5c73986bdde9f072064c0bcb8
+SHA512:
+  metadata.gz: f54f73e6605fa985aa4fc17f68776184eae491ba1cdfc277756182106e21bc57e202402f13d522643a274e5ba4f268e4bb86861c141c0ea7a46fd79d4ad83cc4
+  data.tar.gz: acbb649416de9369c3905173bbc3477dac2a05883cc85b5713413bea0bd83cd6fc3741c2f65050086880fd0c02a0e3289808fa257dd3ec7c06a45eb5e89c8f32

data/LICENSE

@@ -0,0 +1,5 @@
+This program and entire repository is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

data/README.md

@@ -0,0 +1,83 @@
+Apipie Bindings
+===============
+
+The Ruby bindings for Apipie documented APIs.
+
+Features
+--------
+
+#### Caching
+The bindings cache the apidoc from the server. It has separated caches for each server it connects to. If the server sends apidoc hash in the headers ```Apipie-Apidoc-Hash: <md5>``` , the bindings can expire the cache and reload updated version before next request. If the server does not send the hashes, the cache does not expire and has to be deleted manually when necessary.
+
+Sample patch for the server can be found here https://github.com/mbacovsky/foreman/commit/d35d76b9032bb3d3de2da7fb1dc780600eb08bdd
+
+#### API introspection
+It is possible to list available resources, actions, params, routes and its attributes
+
+##### Getting started
+```
+$ rake install
+$ irb
+irb(main):003:0> require 'apipie-bindings'
+
+irb(main):001:0> api = ApipieBindings::API.new({:uri => 'http://localhost:3000/', :username => 'admin', :password => :changeme})
+```
+
+##### Listing resources
+
+```
+irb(main):005:0> api.resources
+=> [<Resource :roles>, <Resource :images>, <Resource :reports>, <Resource :hosts>, .... <Resource :architectures>]
+```
+
+##### Listing actions
+
+```
+irb(main):006:0> api.resource(:architectures).actions
+=> [<Action :index>, <Action :show>, <Action :create>, <Action :update>, <Action :destroy>]
+```
+
+##### Listing routes
+```
+irb(main):008:0> api.resource(:architectures).action(:show).routes
+=> [<Route /api/architectures/:id>]
+```
+
+##### Listing params
+
+```
+irb(main):007:0> api.resource(:architectures).action(:show).params
+=> [<Param *id (String)>]
+
+
+irb(main):009:0> api.resource(:architectures).action(:show).params.first.required?
+=> true
+```
+
+##### Calling methods (all the calls bellow are equivalent)
+
+```
+irb(main):012:0> api.resource(:architectures).call(:show, :id => 1)
+=> {"name"=>"x86_64", "id"=>1, "created_at"=>"2013-12-03T15:00:08Z", "updated_at"=>"2013-12-03T15:00:08Z"}
+
+irb(main):013:0> api.call(:architectures, :show, :id => 1)
+=> {"name"=>"x86_64", "id"=>1, "created_at"=>"2013-12-03T15:00:08Z", "updated_at"=>"2013-12-03T15:00:08Z"}
+
+irb(main):014:0> api.resource(:architectures).action(:show).call(:id => 1)
+=> {"name"=>"x86_64", "id"=>1, "created_at"=>"2013-12-03T15:00:08Z", "updated_at"=>"2013-12-03T15:00:08Z"}
+
+```
+
+TODO
+----
+* parameter validation
+* better configurability
+* error handling
+* logging
+* lots of other things
+
+
+License
+-------
+
+This project is licensed under the GPLv3+.

data/lib/apipie-bindings.rb

@@ -0,0 +1 @@
+require 'apipie_bindings'

data/lib/apipie_bindings.rb

@@ -0,0 +1,15 @@
+module ApipieBindings
+
+  def self.log
+    Logging.logger['API']
+  end
+
+end
+
+require 'apipie_bindings/version'
+require 'apipie_bindings/api'
+require 'apipie_bindings/resource'
+require 'apipie_bindings/action'
+require 'apipie_bindings/route'
+require 'apipie_bindings/param'
+require 'apipie_bindings/example'

data/lib/apipie_bindings/action.rb

@@ -0,0 +1,76 @@
+module ApipieBindings
+
+  class Action
+
+    attr_reader :name
+
+    def initialize(resource, name, api)
+      @resource = resource
+      @name = name.to_sym
+      @api = api
+    end
+
+    def call(params={}, headers={}, options={})
+      @api.call(@resource, @name, params, headers, options)
+    end
+
+    def apidoc
+      methods = @api.apidoc[:docs][:resources][@resource][:methods].select do |action|
+        action[:name].to_sym == @name
+      end
+      methods.first
+    end
+
+    def routes
+      apidoc[:apis].map do |api|
+        ApipieBindings::Route.new(
+          api[:api_url], api[:http_method], api[:short_description])
+      end
+    end
+
+    def params
+      apidoc[:params].map do |param|
+        ApipieBindings::Param.new(param)
+      end
+    end
+
+    def examples
+      apidoc[:examples].map do |example|
+        ApipieBindings::Example.parse(example)
+      end
+    end
+
+    def find_route(params={})
+      sorted_routes = routes.sort_by { |r| [-1 * r.params_in_path.count, r.path] }
+
+      suitable_route = sorted_routes.find do |route|
+        route.params_in_path.all? { |path_param| params.keys.map(&:to_s).include?(path_param) }
+      end
+
+      suitable_route ||= sorted_routes.last
+      return suitable_route
+    end
+
+    def validate!(params)
+      # return unless params.is_a?(Hash)
+
+      # invalid_keys = params.keys.map(&:to_s) - (rules.is_a?(Hash) ? rules.keys : rules)
+      # raise ArgumentError, "Invalid keys: #{invalid_keys.join(", ")}" unless invalid_keys.empty?
+
+      # if rules.is_a? Hash
+      #   rules.each do |key, sub_keys|
+      #     validate_params!(params[key], sub_keys) if params[key]
+      #   end
+      # end
+    end
+
+    def to_s
+      "<Action :#{@name}>"
+    end
+
+    def inspect
+      to_s
+    end
+
+  end
+end

data/lib/apipie_bindings/api.rb

@@ -0,0 +1,178 @@
+require 'json'
+require 'rest_client'
+require 'oauth'
+require 'logging'
+require 'awesome_print'
+module ApipieBindings
+
+  class API
+
+    attr_reader :apidoc_cache_name, :fake_responses
+    attr_writer :dry_run
+
+    def initialize(config, options={})
+      @uri = config[:uri]
+      @api_version = config[:api_version] || 2
+      @apidoc_cache_dir = config[:apidoc_cache_dir] || File.join('/tmp/apipie_bindings', @uri.tr(':/', '_'))
+      @apidoc_cache_name = config[:apidoc_cache_name] || set_default_name
+      @dry_run = config[:dry_run] || false
+      @fake_responses = {}
+
+      config = config.dup
+
+      headers = {
+        :content_type => 'application/json',
+        :accept       => "application/json;version=#{@api_version}"
+      }
+      headers.merge!(config[:headers]) unless config[:headers].nil?
+      headers.merge!(options.delete(:headers)) unless options[:headers].nil?
+
+      resource_config = {
+        :user     => config[:username],
+        :password => config[:password],
+        :oauth    => config[:oauth],
+        :headers  => headers
+      }.merge(options)
+
+      @client = RestClient::Resource.new(config[:uri], resource_config)
+      @config = config
+    end
+
+    def set_default_name(default='default')
+      cache_file = Dir["#{@apidoc_cache_dir}/*.json"].first
+      if cache_file
+        File.basename(cache_file, ".json")
+      else
+        default
+      end
+    end
+
+    def apidoc_cache_file
+       File.join(@apidoc_cache_dir, "#{@apidoc_cache_name}.json")
+    end
+
+    def load_apidoc
+      if File.exist?(apidoc_cache_file)
+        JSON.parse(File.read(apidoc_cache_file), :symbolize_names => true)
+      end
+    end
+
+    def retrieve_apidoc
+      FileUtils.mkdir_p(@apidoc_cache_dir) unless File.exists?(@apidoc_cache_dir)
+      path = "/apidoc/v#{@api_version}.json"
+      begin
+        response = http_call('get', path, {},
+          {:accept => "application/json;version=1"}, {:response => :raw})
+      rescue
+        raise "Could not load data from #{@uri}#{path}"
+      end
+      File.open(apidoc_cache_file, "w") { |f| f.write(response.body) }
+      ApipieBindings.log.debug "New apidoc loaded from the server"
+      load_apidoc
+    end
+
+    def apidoc
+      @apidoc = @apidoc || load_apidoc || retrieve_apidoc
+      @apidoc
+    end
+
+    def dry_run?
+      @dry_run ? true : false
+    end
+
+    def has_resource?(name)
+      apidoc[:docs][:resources].has_key? name
+    end
+
+    def resource(name)
+      ApipieBindings::Resource.new(name, self)
+    end
+
+    def resources
+      apidoc[:docs][:resources].keys.map { |res| resource(res) }
+    end
+
+    def call(resource_name, action_name, params={}, headers={}, options={})
+      resource = resource(resource_name)
+      action = resource.action(action_name)
+      route = action.find_route(params)
+      #action.validate(params)
+      options[:fake_response] = find_match(fake_responses, resource_name, action_name, params) || action.examples.first if dry_run?
+      return http_call(
+        route.method,
+        route.path(params),
+        params.reject { |par, _| route.params_in_path.include? par.to_s },
+        headers, options)
+    end
+
+
+    def http_call(http_method, path, params={}, headers={}, options={})
+      headers ||= { }
+
+      args = [http_method]
+      if %w[post put].include?(http_method.to_s)
+        args << params.to_json
+      else
+        headers[:params] = params if params
+      end
+
+      ApipieBindings.log.info "#{http_method.to_s.upcase} #{path}"
+      ApipieBindings.log.debug "Params: #{params.ai}"
+      # logger.debug "Headers: #{headers.inspect}"
+
+      args << headers if headers
+
+      if dry_run?
+        empty_response = ApipieBindings::Example.new('', '', '', 200, '')
+        ex = options[:fake_response ] || empty_response
+        response = RestClient::Response.create(ex.response, ex.status, ex.args)
+      else
+        response = @client[path].send(*args)
+        update_cache(response.headers[:apipie_apidoc_hash])
+      end
+
+      result = options[:response] == :raw ? response : process_data(response)
+      ApipieBindings.log.debug "Response #{result.ai}"
+      result
+    end
+
+    def process_data(response)
+      data = begin
+               JSON.parse(response.body)
+             rescue JSON::ParserError
+               response.body
+             end
+      # logger.debug "Returned data: #{data.inspect}"
+      return data
+    end
+
+    def update_cache(cache_name)
+      if !cache_name.nil? && (cache_name != @apidoc_cache_name)
+        clean_cache
+        ApipieBindings.log.debug "Cache expired. (#{@apidoc_cache_name} -> #{cache_name})"
+        @apidoc_cache_name = cache_name
+      end
+    end
+
+    def clean_cache
+      @apidoc = nil
+      Dir["#{@apidoc_cache_dir}/*.json"].each { |f| File.delete(f) }
+    end
+
+    private
+
+    def find_match(fakes, resource, action, params)
+      resource = fakes[[resource, action]]
+      if resource
+        if resource.has_key?(params)
+          return resource[params]
+        elsif resource.has_key?(:default)
+          return resource[:default]
+        end
+      end
+      return nil
+    end
+
+  end
+
+end

data/lib/apipie_bindings/example.rb

@@ -0,0 +1,21 @@
+module ApipieBindings
+
+  class Example
+
+    attr_reader :http_method, :path, :args, :status, :response
+
+    def initialize(http_method, path, args, status, response)
+      @http_method = http_method
+      @path = path
+      @args = args
+      @status = status.to_i
+      @response = response
+    end
+
+    def self.parse(example)
+      prep = /(\w+)\ ([^\n]*)\n?(.*)?\n(\d+)\n(.*)/m.match(example)
+      new(*prep[1..5])
+    end
+  end
+
+end

data/lib/apipie_bindings/param.rb

@@ -0,0 +1,34 @@
+require 'active_support/core_ext/hash/indifferent_access'
+
+module ApipieBindings
+
+  class Param
+
+    attr_reader :name, :params, :expected_type, :description, :validator
+
+    def initialize(param)
+      param = param.with_indifferent_access
+      @name = param[:name]
+      params = param[:params] || []
+      @params = params.map { |p| ApipieBindings::Param.new(p) }
+      @expected_type = param[:expected_type].to_sym
+      @description = param[:description].gsub(/<\/?[^>]+?>/, "")
+      @required = param[:required]
+      @validator = param[:validator]
+    end
+
+    def required?
+      @required
+    end
+
+    def to_s
+      "<Param #{ required? ? '*' : '' }#{@name} (#{@expected_type.capitalize})>"
+    end
+
+    def inspect
+      to_s
+    end
+
+  end
+
+end

data/lib/apipie_bindings/resource.rb

@@ -0,0 +1,49 @@
+require 'active_support/core_ext/string'
+
+module ApipieBindings
+
+  class Resource
+
+    attr_reader :name
+
+    def initialize(name, api)
+      raise NameError.new("Resource '#{name}' does not exist in the API") unless api.apidoc[:docs][:resources].key?(name)
+      @name = name
+      @api = api
+    end
+
+    def call(action, params={}, headers={}, options={})
+      @api.call(@name, action, params, headers, options)
+    end
+
+    def apidoc
+      @api.apidoc[:docs][:resources][@name]
+    end
+
+    def actions
+      apidoc[:methods].map { |a| action(a[:name].to_sym) }
+    end
+
+    def has_action?(name)
+      apidoc[:methods].any? { |action| action[:name].to_sym == name }
+    end
+
+    def action(name)
+      ApipieBindings::Action.new(@name, name, @api)
+    end
+
+    def singular_name
+      @name.to_s.singularize
+    end
+
+    def to_s
+      "<Resource :#{@name}>"
+    end
+
+    def inspect
+      to_s
+    end
+
+  end
+
+end

data/lib/apipie_bindings/route.rb

@@ -0,0 +1,37 @@
+module ApipieBindings
+
+  class Route
+
+    attr_reader :method, :description
+
+    def initialize(path, method, description="")
+      @path = path
+      @method = method.downcase
+      @description = description
+    end
+
+    def params_in_path
+      @path.scan(/:([^\/]*)/).map { |m| m.first }
+    end
+
+    def path(params=nil)
+      return @path if params.nil?
+
+      path = params_in_path.inject(@path) do |p, param_name|
+        param_value = (params[param_name.to_sym] or params[param_name.to_s]) or
+          raise ArgumentError, "missing param '#{param_name}' in parameters"
+        p.sub(":#{param_name}", URI.escape(param_value.to_s))
+      end
+    end
+
+    def to_s
+      "<Route #{@path}>"
+    end
+
+    def inspect
+      to_s
+    end
+
+  end
+
+end

data/lib/apipie_bindings/version.rb

@@ -0,0 +1,5 @@
+module ApipieBindings
+  def self.version
+    @version ||= Gem::Version.new '0.0.1'
+  end
+end

data/test/unit/action_test.rb

@@ -0,0 +1,61 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe ApipieBindings::Action do
+
+  let(:resource) { ApipieBindings::API.new({:apidoc_cache_dir => 'test/unit/data',
+    :apidoc_cache_name => 'architecture'}).resource(:architectures) }
+
+  it "should allow user to call the action" do
+    params = { :a => 1 }
+    headers = { :content_type => 'application/json' }
+    ApipieBindings::API.any_instance.expects(:call).with(:architectures, :index, params, headers, {})
+    resource.action(:index).call(params, headers)
+  end
+
+  it "should return routes" do
+    resource.action(:index).routes.first.must_be_kind_of ApipieBindings::Route
+  end
+
+  it "should find suitable route" do
+    resource.action(:index).find_route.path.must_equal "/api/architectures"
+  end
+
+  it "should return params" do
+    resource.action(:create).params.map(&:name).must_equal ['architecture']
+  end
+
+  # TODO add tests for more find_route cases
+    # @param possible_apis [Array] Array of hasahs in form of
+    #   [{:api_url => '/path1', :http_method => 'GET'}, {...}]
+    # @param params [Hash] enterred params
+    # @return api that suits the enterred params mosts
+    #
+    # Given this paths:
+    #   1. +/comments+
+    #   2. +/users/:user_id/comments+
+    #   3. +/users/:user_id/posts/:post_id/comments+
+    #
+    # If +:user_id+ and +:post_id+ is pecified, the third path is
+    # used. If only +:user_id+ is specified, the second one is used.
+    # The selection defaults to the path with the least number of
+    # incuded params in alphanumeric order.
+
+
+  it "should validate the params" do
+    resource.action(:create).validate!({ :architecture => { :name => 'i386' } })
+  end
+
+  it "should have name visible in puts" do
+    out, err = capture_io { puts resource.action(:index) }
+    out.must_equal "<Action :index>\n"
+  end
+
+  it "should have name visible in inspect" do
+    resource.action(:index).inspect.must_equal "<Action :index>"
+  end
+
+  it "should have examples" do
+    resource.action(:index).examples.length.must_equal 1
+  end
+
+end

data/test/unit/api_test.rb

@@ -0,0 +1,109 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe ApipieBindings::API do
+
+  let(:api) { ApipieBindings::API.new({:apidoc_cache_dir => 'test/unit/data', :apidoc_cache_name => 'architecture'}) }
+
+  it "should provide resource" do
+    result = api.resource(:architectures)
+    result.must_be_kind_of ApipieBindings::Resource
+  end
+
+  it "should test if resource is available" do
+    api.has_resource?(:architectures).must_equal true
+  end
+
+  it "should list resources" do
+    api.resources.map(&:name).must_equal [:architectures]
+  end
+
+  # it "should have apidoc_cache_file available" do
+  # end
+
+  it "should call the method" do
+    params = { :a => 1 }
+    headers = { :content_type => 'application/json' }
+    ApipieBindings::API.any_instance.expects(:http_call).with('get', '/api/architectures', params, headers, {})
+    api.call(:architectures, :index, params, headers)
+  end
+
+  it "should call the method and fill in the params" do
+    params = { :id => 1 }
+    headers = { :content_type => 'application/json' }
+    ApipieBindings::API.any_instance.expects(:http_call).with('get', '/api/architectures/1', {}, headers, {})
+    api.call(:architectures, :show, params, headers)
+  end
+
+  it "should return values from examples in dry_run mode" do
+    api.dry_run = true
+    result = api.call(:architectures, :index)
+    result.must_be_kind_of Array
+  end
+
+  it "should allow to set dry_run mode in config params" do
+    api = ApipieBindings::API.new({
+      :apidoc_cache_dir => 'test/unit/data',
+      :apidoc_cache_name => 'architecture',
+      :dry_run => true })
+    result = api.call(:architectures, :index)
+    result.must_be_kind_of Array
+  end
+
+  it "should allow to set fake response in config params" do
+    api = ApipieBindings::API.new({
+      :apidoc_cache_dir => 'test/unit/data',
+      :apidoc_cache_name => 'architecture',
+      :dry_run => true,
+      :fake_params => { [:architectures, :index] => {:default => [] } }} )
+    result = api.call(:architectures, :index)
+    result.must_be_kind_of Array
+  end
+
+  context "update_cache" do
+
+    before :each do
+      @dir = Dir.mktmpdir
+      @api = ApipieBindings::API.new({:apidoc_cache_dir => @dir, :apidoc_cache_name => 'cache'})
+      @api.stubs(:retrieve_apidoc).returns(nil)
+      File.open(@api.apidoc_cache_file, "w") { |f| f.write(['test'].to_json) }
+    end
+
+    after :each do
+      Dir["#{@dir}/*"].each { |f| File.delete(f) }
+      Dir.delete(@dir)
+    end
+
+    it "should clean the internal cache when the name has changed" do
+      @api.update_cache('new_name')
+      @api.apidoc.must_equal nil
+    end
+
+    it "should clean the cache dir when the name has changed" do
+      @api.update_cache('new_name')
+      Dir["#{@dir}/*"].must_be_empty
+    end
+
+    it "should set the new cache name when the name has changed" do
+      @api.update_cache('new_name')
+      @api.apidoc_cache_file.must_equal File.join(@dir, 'new_name.json')
+    end
+
+    it "should not touch enything if the name is same" do
+      @api.update_cache('cache')
+      @api.apidoc.must_equal ['test']
+    end
+
+    # caching is turned off on server
+    it "should not touch enything if the name is nil" do
+      @api.update_cache(nil)
+      @api.apidoc.must_equal ['test']
+    end
+
+    it "should load cache and its name from cache dir" do
+      FileUtils.cp('test/unit/data/architecture.json', File.join(@dir, 'api_cache.json'))
+      @api = ApipieBindings::API.new({:apidoc_cache_dir => @dir})
+      @api.apidoc_cache_name.must_equal 'api_cache'
+    end
+  end
+
+end

data/test/unit/data/architecture.json

@@ -0,0 +1,153 @@
+{
+    "docs": {
+        "api_url": "/api",
+        "copyright": "",
+        "doc_url": "/apidoc/v2",
+        "info": "Another API description",
+        "name": "Foreman",
+        "resources": {
+            "architectures": {
+                "api_url": "/api",
+                "doc_url": "/apidoc/v2/architectures",
+                "formats": null,
+                "full_description": null,
+                "methods": [
+                    {
+                        "apis": [
+                            {
+                                "api_url": "/api/architectures",
+                                "http_method": "GET",
+                                "short_description": "List all architectures."
+                            }
+                        ],
+                        "doc_url": "/apidoc/v2/architectures/index",
+                        "errors": [],
+                        "examples": [
+                            "GET /api/architectures\n200\n[\n  {\n    \"architecture\": {\n      \"name\": \"s390\",\n      \"id\": 381564594,\n      \"updated_at\": \"2012-12-18T15:24:42Z\",\n      \"operatingsystem_ids\": [],\n      \"created_at\": \"2012-12-18T15:24:42Z\"\n    }\n  },\n  {\n    \"architecture\": {\n      \"name\": \"sparc\",\n      \"id\": 331892513,\n      \"updated_at\": \"2012-12-18T15:24:42Z\",\n      \"operatingsystem_ids\": [\n        442321401\n      ],\n      \"created_at\": \"2012-12-18T15:24:42Z\"\n    }\n  },\n  {\n    \"architecture\": {\n      \"name\": \"x86_64\",\n      \"id\": 501905019,\n      \"updated_at\": \"2012-12-18T15:24:42Z\",\n      \"operatingsystem_ids\": [\n        331303656,\n        309172073,\n        1073012828\n      ],\n      \"created_at\": \"2012-12-18T15:24:42Z\"\n    }\n  }\n]"
+                        ],
+                        "formats": null,
+                        "full_description": "",
+                        "name": "index",
+                        "params": [
+                            {
+                                "allow_nil": false,
+                                "description": "\n<p>filter results</p>\n",
+                                "expected_type": "string",
+                                "full_name": "search",
+                                "name": "search",
+                                "required": false,
+                                "validator": "Must be String"
+                            },
+                            {
+                                "allow_nil": false,
+                                "description": "\n<p>sort results</p>\n",
+                                "expected_type": "string",
+                                "full_name": "order",
+                                "name": "order",
+                                "required": false,
+                                "validator": "Must be String"
+                            },
+                            {
+                                "allow_nil": false,
+                                "description": "\n<p>paginate results</p>\n",
+                                "expected_type": "string",
+                                "full_name": "page",
+                                "name": "page",
+                                "required": false,
+                                "validator": "Must be String"
+                            },
+                            {
+                                "allow_nil": false,
+                                "description": "\n<p>number of entries per request</p>\n",
+                                "expected_type": "string",
+                                "full_name": "per_page",
+                                "name": "per_page",
+                                "required": false,
+                                "validator": "Must be String"
+                            }
+                        ],
+                        "see": []
+                    },
+                    {
+                        "apis": [
+                            {
+                                "api_url": "/api/architectures/:id",
+                                "http_method": "GET",
+                                "short_description": "Show an architecture."
+                            }
+                        ],
+                        "doc_url": "/apidoc/v2/architectures/show",
+                        "errors": [],
+                        "examples": [
+                            "GET /api/architectures/x86_64\n200\n{\n  \"architecture\": {\n    \"name\": \"x86_64\",\n    \"id\": 501905019,\n    \"updated_at\": \"2012-12-18T15:24:42Z\",\n    \"operatingsystem_ids\": [\n      309172073,\n      1073012828,\n      331303656\n    ],\n    \"created_at\": \"2012-12-18T15:24:42Z\"\n  }\n}"
+                        ],
+                        "formats": null,
+                        "full_description": "",
+                        "name": "show",
+                        "params": [
+                            {
+                                "allow_nil": false,
+                                "description": "",
+                                "expected_type": "string",
+                                "full_name": "id",
+                                "name": "id",
+                                "required": true,
+                                "validator": "Must be an identifier, string from 1 to 128 characters containing only alphanumeric characters, space, underscore(_), hypen(-) with no leading or trailing space."
+                            }
+                        ],
+                        "see": []
+                    },
+                    {
+                        "apis": [
+                            {
+                                "api_url": "/api/architectures",
+                                "http_method": "POST",
+                                "short_description": "Create an architecture."
+                            }
+                        ],
+                        "doc_url": "/apidoc/v2/architectures/create",
+                        "errors": [],
+                        "examples": [
+                            "POST /api/architectures\n{\n  \"architecture\": {\n    \"name\": \"i386\"\n  }\n}\n200\n{\n  \"architecture\": {\n    \"name\": \"i386\",\n    \"id\": 501905020,\n    \"updated_at\": \"2012-12-18T15:24:43Z\",\n    \"operatingsystem_ids\": [],\n    \"created_at\": \"2012-12-18T15:24:43Z\"\n  }\n}"
+                        ],
+                        "formats": null,
+                        "full_description": "",
+                        "name": "create",
+                        "params": [
+                            {
+                                "allow_nil": false,
+                                "description": "",
+                                "expected_type": "hash",
+                                "full_name": "architecture",
+                                "name": "architecture",
+                                "params": [
+                                    {
+                                        "allow_nil": false,
+                                        "description": "",
+                                        "expected_type": "string",
+                                        "full_name": "architecture[name]",
+                                        "name": "name",
+                                        "required": true,
+                                        "validator": "Must be String"
+                                    },
+                                    {
+                                        "allow_nil": false,
+                                        "description": "\n<p>Operatingsystem ID\u2019s</p>\n",
+                                        "expected_type": "array",
+                                        "full_name": "architecture[operatingsystem_ids]",
+                                        "name": "operatingsystem_ids",
+                                        "required": false,
+                                        "validator": "Must be Array"
+                                    }
+                                ],
+                                "required": true,
+                                "validator": "Must be a Hash"
+                            }
+                        ],
+                        "see": []
+                    }
+                ]
+            }
+        }
+    }
+}

data/test/unit/example_test.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe ApipieBindings::Example do
+
+  it "should parse the example format from apidoc POST" do
+    example_string = "POST /api/architectures\n{\n  \"architecture\": {\n    \"name\": \"i386\"\n  }\n}\n200\n{\n  \"architecture\": {\n    \"name\": \"i386\",\n    \"id\": 501905020,\n    \"updated_at\": \"2012-12-18T15:24:43Z\",\n    \"operatingsystem_ids\": [],\n    \"created_at\": \"2012-12-18T15:24:43Z\"\n  }\n}"
+    ex = ApipieBindings::Example.parse(example_string)
+    ex.http_method.must_equal 'POST'
+    ex.path.must_equal '/api/architectures'
+    ex.args.must_equal "{\n  \"architecture\": {\n    \"name\": \"i386\"\n  }\n}"
+    ex.status.must_equal 200
+    ex.response.must_include "{\n  \"architecture\": "
+  end
+
+  it "should parse the example format from apidoc GET" do
+    example_string = "GET /api/architectures/x86_64\n200\n{\n  \"architecture\": {\n    \"name\": \"x86_64\",\n    \"id\": 501905019,\n    \"updated_at\": \"2012-12-18T15:24:42Z\",\n    \"operatingsystem_ids\": [\n      309172073,\n      1073012828,\n      331303656\n    ],\n    \"created_at\": \"2012-12-18T15:24:42Z\"\n  }\n}"
+    ex = ApipieBindings::Example.parse(example_string)
+    ex.http_method.must_equal 'GET'
+    ex.path.must_equal '/api/architectures/x86_64'
+    ex.args.must_equal ""
+    ex.status.must_equal 200
+    ex.response.must_include "{\n  \"architecture\": "
+  end
+
+end

data/test/unit/main_test.rb

@@ -0,0 +1,5 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe ApipieBindings do
+
+end

data/test/unit/param_test.rb

@@ -0,0 +1,57 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe ApipieBindings::Param do
+
+  let(:param) {ApipieBindings::Param.new({
+          "allow_nil" => false,
+          "description" => "<p>Architecture</p>",
+          "expected_type" => "hash",
+          "full_name" => "architecture",
+          "name" => "architecture",
+          "params" => [
+              {
+                  "allow_nil" => false,
+                  "description" => "",
+                  "expected_type" => "string",
+                  "full_name" => "architecture[name]",
+                  "name" => "name",
+                  "required" => false,
+                  "validator" => "Must be String"
+              }
+
+          ],
+          "required" => true,
+          "validator" => "Must be a Hash"
+      }
+    )}
+  it "should create nested params" do
+    param.params.first.name.must_equal 'name'
+  end
+
+  it "should have expected_type" do
+    param.expected_type.must_equal :hash
+  end
+
+  it "should have description taht strip html tags" do
+    param.description.must_equal "Architecture"
+  end
+
+  it "should have required?" do
+    param.required?.must_equal true
+    param.params.first.required?.must_equal false
+  end
+
+  it "should have validator" do
+    param.validator.must_equal "Must be a Hash"
+  end
+
+  it "should have full name, type and required visible in puts" do
+    out, err = capture_io { puts param }
+    out.must_equal "<Param *architecture (Hash)>\n"
+  end
+
+  it "should have full name, type and required visible in inspect" do
+    param.inspect.must_equal "<Param *architecture (Hash)>"
+  end
+
+end

data/test/unit/resource_test.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe ApipieBindings::Resource do
+
+  let(:resource) { ApipieBindings::API.new({:apidoc_cache_dir => 'test/unit/data',
+    :apidoc_cache_name => 'architecture'}).resource(:architectures) }
+
+  it "should list actions" do
+    resource.actions.map(&:name).must_equal [:index, :show, :create]
+  end
+
+  it "should test action existence" do
+    resource.has_action?(:index).must_equal true
+  end
+
+  it "should return action" do
+    resource.action(:index).must_be_kind_of ApipieBindings::Action
+  end
+
+  it "should allow user to call the action" do
+    params = { :a => 1 }
+    headers = { :content_type => 'application/json' }
+    ApipieBindings::API.any_instance.expects(:call).with(:architectures, :index, params, headers, {})
+    resource.call(:index, params, headers)
+  end
+
+  it "should allow user to call the action with minimal params" do
+    ApipieBindings::API.any_instance.expects(:call).with(:architectures, :index, {}, {}, {})
+    resource.call(:index)
+  end
+
+  it "should print name in singular on demand" do
+    resource.singular_name.must_equal 'architecture'
+  end
+
+  it "should have name visible in puts" do
+    out, err = capture_io { puts resource }
+    out.must_equal "<Resource :architectures>\n"
+  end
+
+  it "should have name visible in inspect" do
+    resource.inspect.must_equal "<Resource :architectures>"
+  end
+
+  it "should rise error when the resource does no exist" do
+    assert_raises( NameError ){ ApipieBindings::API.new({:apidoc_cache_dir => 'test/unit/data',
+      :apidoc_cache_name => 'architecture'}).resource(:none) }
+  end
+end

data/test/unit/route_test.rb

@@ -0,0 +1,36 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe ApipieBindings::Route do
+
+  let(:route) { ApipieBindings::Route.new("/api/architectures/:id", "GET") }
+  it "should list params in path" do
+    route.params_in_path.must_equal ['id']
+  end
+
+  it "should downcase the method" do
+    route.method.must_equal 'get'
+  end
+
+  it "should fill in the params" do
+    route.path({ "id" => 1 }).must_equal "/api/architectures/1"
+  end
+
+  it "should fill in the params as symbols" do
+    route.path({ :id => 1 }).must_equal "/api/architectures/1"
+  end
+
+  it "should return the path as is without the params" do
+    route.path.must_equal "/api/architectures/:id"
+  end
+
+  it "should have path visible in puts" do
+    out, err = capture_io { puts route }
+    out.must_equal "<Route /api/architectures/:id>\n"
+  end
+
+  it "should have path visible in inspect" do
+    route.inspect.must_equal "<Route /api/architectures/:id>"
+  end
+
+
+end

data/test/unit/test_helper.rb

@@ -0,0 +1,19 @@
+require 'simplecov'
+require 'pathname'
+
+SimpleCov.use_merging true
+SimpleCov.start do
+  command_name 'MiniTest'
+  add_filter 'test'
+end
+SimpleCov.root Pathname.new(File.dirname(__FILE__) + "../../../")
+
+
+require 'minitest/autorun'
+require 'minitest/spec'
+require "minitest-spec-context"
+require "mocha/setup"
+
+require 'apipie_bindings'
+
+Logging.logger.root.appenders = Logging::Appenders['__test__'] || Logging::Appenders::StringIo.new('__test__')

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: apipie-bindings
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Martin Bačovský
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+- !ruby/object:Gem::Dependency
+  name: oauth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  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: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Bindings for API calls that are documented with Apipie. Bindings are generated on the fly.
+email: mbacovsk@redhat.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- LICENSE
+- README.md
+- lib/apipie-bindings.rb
+- lib/apipie_bindings.rb
+- lib/apipie_bindings/action.rb
+- lib/apipie_bindings/api.rb
+- lib/apipie_bindings/example.rb
+- lib/apipie_bindings/param.rb
+- lib/apipie_bindings/resource.rb
+- lib/apipie_bindings/route.rb
+- lib/apipie_bindings/version.rb
+- test/unit/action_test.rb
+- test/unit/api_test.rb
+- test/unit/data/architecture.json
+- test/unit/example_test.rb
+- test/unit/main_test.rb
+- test/unit/param_test.rb
+- test/unit/resource_test.rb
+- test/unit/route_test.rb
+- test/unit/test_helper.rb
+homepage: http://github.com/Apipie/apipie-bindings
+licenses:
+- GPL-3
+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.0.14
+signing_key: 
+specification_version: 4
+summary: The Ruby bindings for Apipie documented APIs
+test_files:
+- test/unit/action_test.rb
+- test/unit/api_test.rb
+- test/unit/data/architecture.json
+- test/unit/example_test.rb
+- test/unit/main_test.rb
+- test/unit/param_test.rb
+- test/unit/resource_test.rb
+- test/unit/route_test.rb
+- test/unit/test_helper.rb
+has_rdoc: