inkdit 0.0.1

data/.gitignore

@@ -0,0 +1,7 @@
+*.swp
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.yardoc
+doc

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in inkdit.gemspec
+gemspec

data/README.md

@@ -0,0 +1,79 @@
+# Inkdit API Client Library #
+
+## Obtaining an API Key ##
+
+To use the Inkdit API you need to [register your application](https://developer.inkdit.com/apps/register).
+Once your application is registered, you'll be given an API key and a shared secret.
+
+    Inkdit::Config['api_key'] = '...'
+    Inkdit::Config['secret']  = '...'
+
+## Obtaining an Access Token ##
+
+Accessing the API requires an [OAuth 2](http://tools.ietf.org/html/draft-ietf-oauth-v2-22#section-4.1) access token.
+This means the user needs to give your application authorization to access their account.
+
+First, you redirect the user to the authorization code URL:
+
+    redirect_to Inkdit.authorization_code_url(scopes, redirect_uri)
+
+`scopes` is the list of permissions that your application needs (see https://developer.inkdit.com/docs/read/Home).
+When the user authorizes your application (or denies authorization), their browser will be redirected to `redirect_uri`.
+
+If the authorization is successfully, a `code` parameter will be included when the user is redirected.
+
+    access_token = Inkdit.get_token(params[:code], redirect_uri)
+
+You should store this token somewhere.
+
+    some_storage_function(current_user, access_token.token, access_token.refresh_token, access_token.expires_at)
+
+For the full details (including what a client needs to do for security and error
+handling), read the [OAuth 2 spec](htjp://tools.ietf.org/html/draft-ietf-oauth-v2-22).
+
+## Using the API ##
+
+At last, we're ready to go! Once everything is set up, you can create an `Inkdit::Client` using the access token you stored:
+
+    client = Inkdit::Client.new(:access_token => ..., :expires_at => ..., :refresh_token => ...)
+
+The first thing to do is find out who this access token belongs to:
+
+    entity = client.get_entity
+
+Then you might want to take a look at that entity's contracts:
+
+    entity.get_contracts
+
+or create a new contract:
+
+    params = { :name => '...', :content => '...' }
+    contract = Inkdit::Contract.create(client, entity, params)
+
+Given an `Inkdit::Contract`, you can list the signature fields:
+
+    contract.fetch!
+    contract.signatures
+
+and sign an unsigned field:
+
+    signature_field.sign!
+
+If you know the URL of a form contract, you can sign it:
+
+    form_contract = Inkdit::FormContract.new client, form_contract_url
+    form_contract.fetch!
+    form_contract.sign!
+
+## Running the Specs ##
+
+To run the specs you need a config.yml file containing your API key, shared secret, and access token.
+Once you've obtained an API key, there's a demo application that can be used to obtain an access token:
+
+    ./script/get_access_token.rb
+
+Then visit http://localhost:4567/ in your browser.
+
+Once you've entered your API key and shared scret, you will be prompted to log
+into Inkdit and authorize the application. When the application is authorized, it will produce a file that you can copy and paste into config.yml.
+

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+require 'yard'
+require 'yard/rake/yardoc_task'
+
+RSpec::Core::RakeTask.new('spec')
+YARD::Rake::YardocTask.new

data/inkdit.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "inkdit/version"
+
+Gem::Specification.new do |s|
+  s.name        = "inkdit"
+  s.version     = Inkdit::VERSION
+  s.authors     = ["Brendan Taylor"]
+  s.email       = ["brendan@inkdit.com"]
+  s.homepage    = "https://developer.inkdit.com/"
+  s.summary     = %q{A library for using the Inkdit API to sign, share and store contracts}
+  s.description = %q{This is both a working Ruby gem and a code sample that other client implementations can work from.}
+
+  s.rubyforge_project = "inkdit"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "oauth2"
+
+  # documentation
+  s.add_development_dependency "yard"
+
+  # test dependencies
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "vcr"
+
+  # dependencies for our access token getter
+  s.add_development_dependency "sinatra"
+  s.add_development_dependency "haml"
+end

data/lib/inkdit.rb

@@ -0,0 +1,64 @@
+require "inkdit/version"
+
+require "inkdit/client"
+require "inkdit/resource"
+
+require "inkdit/entity"
+
+require "inkdit/contract"
+require "inkdit/form_contract"
+
+require "inkdit/signature"
+require "inkdit/signature_field"
+
+require "oauth2"
+
+module Inkdit
+  # global configuration for the client.
+  # this has to be set up for anything to work. It must have the keys:
+  #
+  # +api_key+:: your application's API key, obtained from https://developer.inkdit.com/
+  # +secret+::  your application's shared secret, obtained from https://developer.inkdit.com/
+  #
+  # It can optionally have the key:
+  #
+  # +debug+::   +true+ if you want HTTP requests and responses printed to stdout.
+  Config = {}
+
+  # @param [Array<String,Symbol>] scopes an Array of the permissions that your application needs (see https://developer.inkdit.com/docs/read/Home)
+  # @param [String] redirect_uri the URL that the user should be redirected to after the authorization code is obtained (OAuth 2 section 4.1.2)
+  #
+  # @return [String] the URL that the user should be sent to to obtain an authorization code. (OAuth 2 section 4.1.1)
+  def self.authorization_code_url(scopes, redirect_uri)
+    scopes = scopes.join('%20')
+    "https://inkdit.com/oauth?response_type=code&client_id=#{Config['api_key']}&scope=#{scopes}&redirect_uri=#{redirect_uri}"
+  end
+
+  # you probably don't want to call this.
+  #
+  # @return [OAuth2::Client]
+  def self.oauth_client # :nodoc:
+    api_key = Inkdit::Config['api_key']
+    secret  = Inkdit::Config['secret']
+
+    opts = { :site => 'https://api.inkdit.com/',
+             :token_url => '/token',
+             :raise_errors => false
+           }
+
+    OAuth2::Client.new(api_key, secret, opts)
+  end
+
+  # requests an access token using an authorization code (OAuth 2 section 4.1.3/4.1.4)
+  #
+  # @param [String] authorization_code the authorization code Inkdit passed to your application
+  # @param [String] redirect_uri       the redirect URI you used when requesting the authorization code
+  #
+  # @return [OAuth2::AccessToken]
+  def self.get_token(authorization_code, redirect_uri)
+	  self.oauth_client.auth_code.get_token(authorization_code, :redirect_uri => redirect_uri)
+  end
+
+  # an exception that's raised when a request fails due to an invalid access token
+  class Unauthorized < Exception; end
+end

data/lib/inkdit/client.rb

@@ -0,0 +1,87 @@
+module Inkdit
+  # a client that can issue authenticated HTTP requests to Inkdit's API.
+  class Client
+    # +token+ is a Hash containing the details of the access token returned by {Inkdit.get_token}.
+    # The keys +access_token+, +refresh_token+, and +expires_at+ are required.
+    def initialize(token)
+      # AccessToken#from_hash modifies the hash it's passed.
+      @access_token = OAuth2::AccessToken.from_hash(oauth_client, token.clone)
+    end
+
+    # @return [Entity] the entity that this access token belongs to
+    def get_entity
+      response = get '/v1/'
+
+      entity = response.parsed["entities"].first
+      Entity.new(self, entity)
+    end
+
+    # issue an HTTP +GET+.
+    # @return [OAuth2::Response]
+    def get(path)
+      request(:get, path, {})
+    end
+
+    # issue an HTTP +POST+.
+    # @return [OAuth2::Response]
+    def post(path, params)
+      request(:post, path, params)
+    end
+
+    # issue an HTTP +PUT+.
+    # @return [OAuth2::Response]
+    def put(path, params)
+      request(:put, path, params)
+    end
+
+    # issue an HTTP +DELETE+.
+    # @return [OAuth2::Response]
+    def delete(path, params)
+      request(:delete, path, {})
+    end
+
+  private
+
+    def oauth_client
+      @_oauth_client ||= Inkdit.oauth_client
+    end
+
+    def when_debugging
+      yield if Inkdit::Config['debug']
+    end
+
+    # issue an HTTP request.
+    # @return [OAuth2::Response]
+    def request(method, path, params)
+      when_debugging do
+        puts '---'
+        puts "#{method.to_s.upcase} #{path}"
+        puts params.inspect
+        puts
+      end
+
+      response = @access_token.send(method, path, params)
+
+      when_debugging do
+        puts response.status
+        puts response.body
+        puts
+      end
+
+      checked_response(response)
+    end
+
+    # raises {Inkdit::Unauthorized} if the response indicates an invalid access token.
+    # @return [OAuth2::Response]
+    def checked_response(response)
+      if response.status == 401 and response.headers['www-authenticate'].match /invalid_token/
+        # wrong access token or the user rescinded the app's access.
+        # TODO: properly parse the header
+        # Bearer realm="api.inkdit.com", error="invalid_token"
+        raise Inkdit::Unauthorized
+      end
+
+      response
+    end
+  end
+end

data/lib/inkdit/contract.rb

@@ -0,0 +1,72 @@
+module Inkdit
+  # Represents an {https://developer.inkdit.com/docs/read/Contract_Description Inkdit Contract}.
+  class Contract < Resource
+    # create a new contract.
+    #
+    # @param [Client] client the client to create this contract with
+    # @param [Entity] owner  the entity that will own this contract
+    # @param [Hash]   params the details of the new contract.
+    #                        this should include the basic details required in a
+    #                        {https://developer.inkdit.com/docs/read/Contract_Description Contract Description}.
+    #
+    # @return [Contract] contract the newly created contract
+    def self.create(client, owner, params)
+      response = client.post owner.contracts_link, { :body => params.to_json, :headers => { 'Content-Type' => 'application/json' } }
+      self.new(client, response.parsed)
+    end
+
+    # @return [String] a human-readable name for the contract
+    def name
+      @params['name']
+    end
+
+    # @return [String] the contract's content
+    def content
+      @params['content']
+    end
+
+    # whether the cantract is a test contract or not
+    def test?
+      @params['test']
+    end
+
+    # the URL of this contract's HTML representation.
+    def html_link
+      @params['links']['html']
+    end
+
+    def sharing_link
+      @params['links']['shared-with']
+    end
+
+    # an opaque string indicating the version of the contract's content
+    def content_updated_at
+      @params['content_updated_at']
+    end
+
+    # @return [Array<Signature,SignatureField>] this contract's signatures and unsigned signature fields
+    def signatures
+      @params['signatures'].map do |s|
+        if s['signed_by']
+          Inkdit::Signature.new(@client, s)
+        else
+          Inkdit::SignatureField.new(@client, self, s)
+        end
+      end
+    end
+
+    # @param [Entity] individual the individual who should be connected to the contract
+    # @param [Entity] entity     the entity that the individual should be connected to the contract through
+    def share_with(individual, entity)
+      params = {
+        :individual => {
+          :url => individual
+        },
+        :entity => {
+          :url => entity
+        }
+      }
+      @client.post self.sharing_link, { :body => params.to_json, :headers => { 'Content-Type' => 'application/json' } }
+    end
+  end
+end

data/lib/inkdit/entity.rb

@@ -0,0 +1,37 @@
+module Inkdit
+  # Represents an {https://developer.inkdit.com/docs/read/Entity_Description Inkdit Entity}.
+  class Entity < Resource
+    # this entity's type. +'individual'+ or +'organization'+.
+    def type
+      @params['type']
+    end
+
+    # this entity's human-readable name.
+    def label
+      @params['label']
+    end
+
+    # the URL of this entity's HTML representation.
+    def html_link
+      @params['links']['html']
+    end
+
+    # the URL of this entity's Contract Collection
+    def contracts_link
+      @params['links']['contracts']
+    end
+
+    # retrieves this entity's Contract Collection
+    # @return [Array<Contract>] the contracts in this entity's Contract Collection
+    def get_contracts
+      response = @client.get(contracts_link)
+      response.parsed['resources'].map do |contract_params|
+        Contract.new @client, contract_params
+      end
+    end
+
+    def inspect
+      "#<Inkdit::Entity type=#{type} label=#{label}>"
+    end
+  end
+end

data/lib/inkdit/form_contract.rb

@@ -0,0 +1,32 @@
+module Inkdit
+  # represents a form contract on Inkdit
+  class FormContract < Resource
+    # @return [String] a human-readable name for the contract
+    def name
+      @params['name']
+    end
+
+    # @return [String] the contract's content
+    def content
+      @params['content']
+    end
+
+    def signatures_link
+      @params['links']['signatures']
+    end
+
+    # an opaque string indicating the version of the form contract's content
+    def content_updated_at
+      @params['content_updated_at']
+    end
+
+    # sign this field as the user and entity associated with the current access token.
+    # @return [Signature] the newly-created signature
+    def sign!
+      params = { :if_updated_at => self.content_updated_at }
+      response = @client.post self.signatures_link, { :body => params.to_json, :headers => { 'Content-Type' => 'application/json' } }
+
+      Inkdit::Signature.new(@client, response.parsed)
+    end
+  end
+end

data/lib/inkdit/resource.rb

@@ -0,0 +1,41 @@
+module Inkdit
+  # some resource (in the REST sense) in the system
+  class Resource
+    # the URL of this resource
+    attr_reader :url
+
+    # @param [Client]      client the client to use this resource with
+    # @param [String,Hash] opts   either the resource's URL, or a hash describing the resource
+    def initialize(client, opts)
+      @client = client
+
+      if opts.is_a? String
+        @url    = opts
+        @params = []
+      else
+        self.params = opts
+      end
+    end
+
+    # retrieve this resource using its URL.
+    def fetch!
+      response = @client.get(self.url)
+      @params  = response.parsed
+    end
+
+    def ==(other_resource)
+      self.url == other_resource.url
+    end
+
+    def inspect
+      "#<#{self.class.inspect} params=#{@params}>"
+    end
+
+  private
+
+    def params=(params)
+      @params = params
+      @url    = params['url']
+    end
+  end
+end

data/lib/inkdit/signature.rb

@@ -0,0 +1,34 @@
+module Inkdit
+  # Represents a signed {https://developer.inkdit.com/docs/read/Signature_Description signature placeholder}.
+  class Signature
+    def initialize(client, params)
+      @client = client
+      @params = params
+    end
+
+    # @return [Entity] the individual who signed this field
+    def signed_by
+      Inkdit::Entity.new(@client, @params['signed_by'])
+    end
+
+    # @return [Entity] the entity this field was signed on behalf of
+    def on_behalf_of
+      Inkdit::Entity.new(@client, @params['on_behalf_of'])
+    end
+
+    # @return [Time] when this field was signed
+    def signed_at
+      Time.parse(params['signed_at'])
+    end
+
+    # @return [Contract] the contract this field is part of
+    def contract
+      return unless @params['contract']
+      Inkdit::Contract.new @client, @params['contract']
+    end
+
+    def inspect
+      "#<#{self.class.inspect} params=#{@params}>"
+    end
+  end
+end

data/lib/inkdit/signature_field.rb

@@ -0,0 +1,31 @@
+module Inkdit
+  # Represents an unsigned {https://developer.inkdit.com/docs/read/Signature_Description signature placeholder}.
+  class SignatureField
+    def initialize(client, contract, params)
+      @client   = client
+      @contract = contract
+      @params   = params
+    end
+
+    # @return [String] the URL of this signature field
+    def url
+      @params['url']
+    end
+
+    # sign this field as the user and entity associated with the current access token.
+    # @return [Signature] the newly-created signature
+    def sign!
+      params = {
+        :if_updated_at => @contract.content_updated_at
+      }
+
+      response = @client.put self.url, { :body => params.to_json, :headers => { 'Content-Type' => 'application/json' } }
+
+      Inkdit::Signature.new(@client, response.parsed)
+    end
+
+    def inspect
+      "#<#{self.class.inspect} params=#{@params}>"
+    end
+  end
+end

data/lib/inkdit/version.rb

@@ -0,0 +1,3 @@
+module Inkdit
+  VERSION = "0.0.1"
+end

data/script/get_access_token.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+
+require 'inkdit'
+
+require 'sinatra'
+require 'haml'
+
+get '/' do
+  haml <<END
+%div
+  %form{:action => '/get-auth-code'}
+    %p First, I need your details for accessing the Inkdit API:
+    %label
+      API Key:
+      %input{:name => 'api_key'}
+    %br
+    %label
+      Secret:
+      %input{:name => 'secret'}
+    %br
+    %input{:type => 'submit'}
+END
+end
+
+get '/get-auth-code' do
+  Inkdit::Config['api_key'] = params[:api_key]
+  Inkdit::Config['secret']  = params[:secret]
+
+  redirect_url = url('/got-auth-code')
+  auth_code_url = Inkdit.authorization_code_url([:read, :write, :sign], redirect_url)
+
+  redirect auth_code_url
+end
+
+get '/got-auth-code' do
+  auth_code = params[:code]
+
+  @access_token = Inkdit.get_token(params[:code], url('/got-auth-code'))
+
+  config = {
+    'api_key' => Inkdit::Config['api_key'],
+    'secret'  => Inkdit::Config['secret'],
+    'access_token' => {
+      'access_token'  => @access_token.token,
+      'refresh_token' => @access_token.refresh_token,
+      'expires_at'    => @access_token.expires_at
+    }
+  }
+
+  <<END
+<p>
+  Ok, we've got a thing for you! Save the below as config.yml.
+</p>
+
+<pre>
+#{config.to_yaml}
+</pre>
+END
+end

data/spec/client_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Inkdit::Client do
+  before do
+    @client = Inkdit::Client.new(Inkdit::Config['access_token'])
+  end
+
+  it 'gives you information about the entity the client is authorized to access' do
+    entity = @client.get_entity
+
+    entity.type.should  == 'individual'
+    entity.label.should == 'API Test'
+
+    entity.html_link.should_not      be_nil
+    entity.contracts_link.should_not be_nil
+  end
+end

data/spec/contract_spec.rb

@@ -0,0 +1,50 @@
+require 'time'
+
+require 'spec_helper'
+
+describe Inkdit::Contract do
+  before do
+    @client = Inkdit::Client.new(Inkdit::Config['access_token'])
+  end
+
+  it 'allows you to manipulate a contract' do
+    entity = @client.get_entity
+
+    contract_name = "API Test #{Time.now.iso8601}"
+
+    params = {
+      :name    => contract_name,
+      :content => "<contract> <signature id='1' /></contract>",
+      :test    => true
+    }
+
+    contract = Inkdit::Contract.create @client, entity, params
+
+    # the new contract should have the attributes we asked for
+    contract.name.should == contract_name
+    contract.should be_test
+
+    contract.html_link.should_not    be_nil
+    contract.sharing_link.should_not be_nil
+
+    # the new contract should appear in the list of contracts
+    contracts = entity.get_contracts
+    contracts.find { |c| c.name == contract_name }.should_not be_nil
+
+    # the new contract can be signed
+    #
+    # first we need to fetch the full representation of the contract
+    # (since the other representation doesn't include signatures)
+    contract.fetch!
+
+    contract.signatures.length.should == 1
+    signature_field = contract.signatures.first
+
+    signature = signature_field.sign!
+
+    signature.signed_by.should    == entity
+    signature.on_behalf_of.should == entity
+  end
+
+  pending 'sharing a contract (this is tough to do because it requires an entity URL)'
+end

data/spec/form_contract_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Inkdit::FormContract do
+  before do
+    @client = Inkdit::Client.new(Inkdit::Config['access_token'])
+  end
+
+  it 'allows you to sign a form contract' do
+    # this is the path of the Web 2.0 Information Superhighway API Demo
+    form_contract_path = '/v1/offers/x53c396c3de147b54'
+
+    form_contract = Inkdit::FormContract.new @client, form_contract_path
+    form_contract.fetch!
+
+    form_contract.name.should == 'Web 2.0 Information Superhighway API Demo'
+    form_contract.signatures_link.should_not be_nil
+
+    signature = form_contract.sign!
+
+    signature.signed_by.should_not    be_nil
+    signature.on_behalf_of.should_not be_nil
+
+    signature.contract.name.should == 'Web 2.0 Information Superhighway API Demo'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'inkdit'
+
+Inkdit::Config.merge! YAML.load_file('config.yml')
+
+RSpec.configure do |config|
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: inkdit
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Brendan Taylor
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: oauth2
+  requirement: &9892260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *9892260
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &9891720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *9891720
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &9888300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *9888300
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: &9887800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *9887800
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: &9887080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *9887080
+- !ruby/object:Gem::Dependency
+  name: haml
+  requirement: &9886460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *9886460
+description: This is both a working Ruby gem and a code sample that other client implementations
+  can work from.
+email:
+- brendan@inkdit.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- inkdit.gemspec
+- lib/inkdit.rb
+- lib/inkdit/client.rb
+- lib/inkdit/contract.rb
+- lib/inkdit/entity.rb
+- lib/inkdit/form_contract.rb
+- lib/inkdit/resource.rb
+- lib/inkdit/signature.rb
+- lib/inkdit/signature_field.rb
+- lib/inkdit/version.rb
+- script/get_access_token.rb
+- spec/client_spec.rb
+- spec/contract_spec.rb
+- spec/form_contract_spec.rb
+- spec/spec_helper.rb
+homepage: https://developer.inkdit.com/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: inkdit
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A library for using the Inkdit API to sign, share and store contracts
+test_files: []