viaduct-gandi 1.0.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 Viaduct Hosting Limited.
+
+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,229 @@
+# Gandi API Library
+
+This is a short library to facilitate working with the Gandi API for
+domain registrations. While there are other libraries for this purpose
+this offers a more satisfying syntax.
+
+## Installation
+
+As usual, just pop a reference to the gem into your `Gemfile` and run
+`bundle`. Alternatively, just install the gem and require it manually.
+
+```ruby
+gem 'viaduct-gandi', :require => 'gandi'
+```
+
+## Configuration
+
+Before you can run commands, you'll need to configure the library.
+
+```ruby
+Gandi.apikey = 'abc123abc123abc123abc'
+Gandi.mode   = 'test' # or 'live' 
+```
+
+## Pricing
+
+You can obtain pricing for registrations very easily. This example is the 
+most basic form of obtaining a price. In this instance, it returns the price
+for registering a .com domain.
+
+```ruby
+price = Gandi::Price.find('example.com')
+price.action          #=> 'create'
+price.description     #=> '.com'
+price.price           #=> 5.5
+price.min_duration    #=> 1
+price.max_duration    #=> 10
+price.currency        #=> 'GBP'
+price.grid            #=> 'E'
+price.duration_unit   #=> 'y'
+```
+
+There are a number of options which can be passed to method.
+
+* `:action` - which service you will be using (create, renew, restore, transfer, plus others - create is default)
+* `:currency` - which currency to return a price in (GBP, EUR or USD - GBP is default)
+* `:grid` - your pricing grid (A,B,C,D,E - E is default)
+* `:duration` - the duration of the registration (a positive interger - 1 is default)
+
+## Contacts
+
+At the root of all domain registrations is a contact. Each contact has a unique `handle`
+which identifies the contact and is needed for all registrations.
+
+### Creating a new contact
+
+```ruby
+contact = Gandi::Contact.new
+contact.type            = 0
+contact.first_name      = 'Adam'
+contact.last_name       = 'Cooke'
+contact.address         = 'Unit 9 Winchester Place'
+contact.city            = 'Poole'
+contact.country         = 'GB'
+contact.email_address   = 'adam@example.com'
+contact.phone           = '+44.1202901101'
+contact.password        = 'randompasswordhere'
+contact.save            #=> true
+contact.handle          #=> 'AC1234-GANDI'
+```
+
+If an error occurs here there are two possible exceptions which may be raised (as the
+same applies to updates). If a validation error is caught locally you will find a 
+`Gandi::ValidationError` is raised otherwise you'll receive `Gandi::DataError` with some
+mostly uninteligiable garbage from the Gandi API.
+
+### Finding a contact
+
+```ruby
+contact = Gandi::Contact.find('AC1234')
+contact.first_name      #=> 'Adam'
+```
+
+### Updating a contact
+
+To update a contact you need to find it and then make changes to its attributes followed
+by a save operation.
+
+```ruby
+contact = Gandi::Contact.find('AC1234')
+contact.phone = '+44.123451234'
+contact.save
+```
+
+### Determine if a contact can be associated with a domain
+
+If you wish to see whether a contact is suitable for registration with a given domain,
+you can call this method on any contact.
+
+```ruby
+contact.can_associate?('yourdomain.com')
+```
+
+This will return true or an error string straight from the Gandi API.
+
+### Return associated domains
+
+If you wish to return all domains associated with a contact, you can call the `domains`
+method.
+
+```ruby
+contact.domains     #=> [Gandi::Domain, Gandi::Domains, ...]
+```
+
+## Domains
+
+Once you have some contacts, you can easily manage domains through through the library.
+
+### TLDs
+
+You can get a full list of TLDs which can be registered using the Gandi API using the method
+shown below. This will return an array of hashes with TLD information.
+
+```ruby
+Gandi::Domains.tlds
+```
+
+### Checking domain availability
+
+Gandi provides a asyncronous method for checking domain availability. This library provides
+methods for determining availability both asyncronously and syncronously.
+
+The asyncronous method accepts a number of domains to check and will return a hash
+of domains with their availability status. Any status which is 'pending' has not been determined
+yet and another call should be made in the near future to check again.
+
+```ruby
+Gandi::Domain.check_availability('domain1.com', 'domain2.io')   #=> {'domain1.com' => 'pending', 'domain2.io' => 'pending'}
+```
+
+The syncronous method will keep calling the API until it gets a non-pending status for all
+requested domains. Pending will only be returned if the status cannot be determined within
+20 requests to the Gandi API.
+
+```ruby
+Gandi::Domain.check_availability!('domain1.com', 'domain2.io')   #=> {'domain1.com' => 'unavailable', 'domain2.io' => 'available'}
+```
+
+In addition to these methods, there is also a shorthand syncronous method for checking a
+single domain's status.
+
+```ruby
+Gandi::Domain.available?('blahblahblah.com')    #=> true or false
+```
+
+### Create/register a new domain
+
+In order to register a domain you need to create a new domain registration object. Once
+created the domain will be set up automatically. You should monitor the operation's 'step'
+attribute to see how things are progressing. When this is 'DONE', the domain has been
+registered.
+
+```ruby
+if Gandi::Domain.available?('somedomain.com')
+  # Create a domain registration request
+  operation = Gandi::Domain.create('blahblahblah.com', :owner => 'ABC123')
+  # Monitor the operation status
+  operation.step          #=> 'BILL'
+  operation.reload
+  operation.step          #=> 'RUN'
+  operation.reload
+  operation.step          #=> 'DONE' or 'ERROR'
+  operation.last_error    #=> 'An error message here if failed'
+else
+  # Domain is not available for registration
+end
+```
+
+### Looking up domain information
+
+Once a domain has been registered, you can look it up using the following method.
+
+```ruby
+domain = Gandi::Domain.find('blahblahblah.com')
+domain.name       #=> "blahblahblah.com"
+domain.owner      #=> A Gandi::Contact instance for the owner\
+domain.partial?   #=> false
+```
+
+In addition to these methods, there are a number of other attributes which are available.
+Consult with the [Gandi docs](http://doc.rpc.gandi.net/domain/reference.html#DomainReturn) 
+for full details.
+
+### Changing contacts
+
+To change the contact associated with a domain you can use the method below. You must
+pass the Gandi handle for the new contact. 
+
+```ruby
+domain = Gandi::Domain.find('blahblahblah.com')
+operation = domain.change_contacts('admin' => 'DEF123', 'bill' => 'DEF123', 'tech' => 'DEF123')
+```
+
+Note: you cannot change the owner with this method and you don't need to change all
+the contact types. You should monitor the operation object to determine the status.
+
+### Renewing a domain
+
+If you wish to renew a domain, you can use the method below.
+
+```ruby
+domain = Gandi::Domain.find('blahblahblah.com')
+operation = domain.renew(2015, 2)
+```
+
+The first argument here is the current expiry year and the second argument is the duration
+for the renewal. You should monitor the operation object to determine the status.
+
+### Restoring a domain
+
+If you wish to restore a domain, you can use the method below.
+
+```ruby
+domain = Gandi::Domain.find('blahblahblah.com')
+operation = domain.restore(2)
+```
+
+The first argument here is the duration you wish to renew the domain for.
+You should monitor the operation object to determine the status.

data/lib/gandi.rb

@@ -0,0 +1,44 @@
+require 'xmlrpc/client'
+require 'gandi/zlib_parser_decorator'
+require 'gandi/version'
+require 'gandi/price'
+require 'gandi/contact'
+require 'gandi/domain'
+require 'gandi/operation'
+
+module Gandi
+    
+    class Error < StandardError; end
+    class DataError < Error; end
+    class ServerError < Error; end
+    class ValidationError < Error; end
+  
+  
+  class << self
+    attr_accessor :apikey
+    attr_accessor :mode
+    
+    def endpoint
+      mode == 'live' ? 'https://rpc.gandi.net/xmlrpc/' : 'https://rpc.ote.gandi.net/xmlrpc/'
+    end
+    
+    def client
+      @client ||= begin
+        XMLRPC::Config.module_eval do
+          remove_const(:ENABLE_NIL_PARSER)
+          const_set(:ENABLE_NIL_PARSER, true)
+        end
+        client = XMLRPC::Client.new2(self.endpoint)
+        client.http_header_extra = {"Accept-Encoding" => "gzip"}
+        client.set_parser ZlibParserDecorator.new(client.send(:parser))
+        client
+      end
+    end
+    
+    def call(name, *args)
+      client.call(name, apikey, *args)
+    rescue XMLRPC::FaultException => e
+      raise(e.faultCode < 500000 ? ServerError : DataError, e.faultString)
+    end
+  end
+end

data/lib/gandi/contact.rb

@@ -0,0 +1,200 @@
+module Gandi
+  class Contact
+    
+    COUNTRIES = ['AF','ZA','AL','DZ','DE','AD','AO','AI','AG','AN','SA','AR','AM','AW','AC','AU','AT','AZ','BS','BH','BD','BB','BY','BE','BZ','BJ','BM','BT','BO','BA','BW','BR','BN','BG','BF','BI','KH','CM','CA','CV','KY','CF','CL','CN','CY','CO','KM','CG','CD','CK','KR','KP','CR','CI','HR','CU','DK','DJ','DO','DM','EG','SV','AE','EC','ER','ES','EE','US','ET','FK','FO','FJ','FI','FR','GA','GM','GE','GH','GI','GR','GD','GL','GU','GT','GN','GQ','GW','GY','HT','HI','HN','HK','HU','IN','ID','IR','IQ','IE','IS','IL','IT','JM','JP','JE','JO','KZ','KE','KG','KI','KW','LA','LS','LV','LB','LR','LY','LI','LT','LU','MO','MK','MG','MY','MW','MV','ML','MT','MP','MA','MH','MU','MR','MX','FM','MD','MC','MN','MS','MZ','MM','NA','NR','NP','NI','NE','NG','NU','NF','NO','NZ','OM','UG','UZ','PK','PW','PS','PA','PG','PY','NL','PE','PH','PL','PT','PR','QA','RO','GB','RU','RW','SH','LC','KN','SM','VC','SB','AS','WS','ST','SN','SC','SL','SG','SK','SI','SO','SD','LK','SE','CH','SR','SZ','SY','TJ','TW','TZ','TD','CZ','TH','TP','TG','TK','TO','TT','TN','TM','TC','TR','TV','UA','UY','VU','VE','VI','VG','VN','YE','ZM','ZW','RE','PF','AQ','GF','NC','MQ','GP','PM','TF','YT','RS','TL','CC','CX','HM','AX','BV','GS','GG','IM','ME','IO','PN','EH','BL','MF','VA','SJ','WF','EP']
+    TYPES = {0 => 'person', 1 => 'company', 2 => 'association', 3 => 'public_body'}
+    ATTRIBUTE_MAP = {
+      'type'              => 'type',
+      'given'             => 'first_name',
+      'family'            => 'last_name',
+      'orgname'           => 'organization',
+      'password'          => 'password',
+      'streetaddr'        => 'address',
+      'city'              => 'city',
+      'zip'               => 'post_code',
+      'country'           => 'country',
+      'email'             => 'email_address',
+      'phone'             => 'phone',
+      'extra_parameters'  => 'extra_parameters'
+    }
+    
+    # Type of object
+    attr_reader :handle
+    attr_reader :attributes
+    attr_accessor :type
+    
+    # Name
+    attr_accessor :first_name
+    attr_accessor :last_name
+    attr_accessor :organization
+    
+    # Credentials
+    attr_accessor :password
+    
+    # Address Fields
+    attr_accessor :address
+    attr_accessor :city
+    attr_accessor :post_code
+    attr_accessor :country
+    
+    # Contact details
+    attr_accessor :email_address
+    attr_accessor :phone
+    attr_accessor :extra_parameters
+    
+    def initialize
+      @attributes = {}
+    end
+    
+    #
+    # Find a contact based on it's handle
+    #
+    def self.find(handle)
+      info = Gandi.call("contact.info", handle)
+      contact = self.new
+      contact.set_attributes(info)
+      contact
+    rescue Gandi::DataError => e
+      e.message =~ /CAUSE_NOTFOUND/ ? nil : raise
+    end
+    
+    #
+    # Return extra parameters for this contact
+    #
+    def extra_parameters
+      @extra_parameters ||= {}
+    end
+    
+    #
+    # Save the contact's information
+    #
+    def save
+      new_record? ? create : update
+    end
+     
+    #
+    # Is this a new record?
+    #   
+    def new_record?
+      self.handle.nil?
+    end
+
+    # 
+    # Create a contact
+    #
+    def create
+      return false unless new_record?
+      raise Gandi::ValidationError, self.errors unless self.errors.empty?
+      result = Gandi.call('contact.create', dirty_attributes_with_remote_keys)
+      set_attributes(result)
+      true
+    end
+    
+    #
+    # Update a contact
+    #
+    def update
+      return false if new_record?
+      raise Gandi::ValidationError, self.errors unless self.errors.empty?
+      result = Gandi.call('contact.update', self.handle, dirty_attributes_with_remote_keys)
+      set_attributes(result)
+      true
+    end
+    
+    #
+    # Is the current instance dirty? (I.e. need updating remotely)
+    #
+    def dirty?
+      dirty_attributes.empty?
+    end
+    
+    #
+    # Returns a hash of all dirty attributes (with local keys)
+    #
+    def dirty_attributes
+      ATTRIBUTE_MAP.values.inject(Hash.new) do |hash, local|
+        if @attributes.keys.include?(local) && @attributes[local] == self.send(local)
+          next hash
+        else
+          hash[local] = self.send(local)
+        end
+        hash
+      end
+    end
+    
+    #
+    # Returns a hash of all dirty_attributes (with remote keys)
+    #
+    def dirty_attributes_with_remote_keys
+      dirty_attributes.inject(Hash.new) do |hash, (local, value)|
+        remote = ATTRIBUTE_MAP.select { |k,v| v == local }.first[0]
+        hash[remote] = value || ''
+        hash
+      end
+    end
+    
+    #
+    # Set the attributes from a remote hash
+    #
+    def set_attributes(hash)
+      @handle = hash['handle']
+      @attributes = {}
+      ATTRIBUTE_MAP.each do |remote, local|
+        self.send(local + '=', hash[remote])
+        remote_value = hash[remote]
+        remote_value = remote_value.dup if remote_value && !remote_value.is_a?(Fixnum)
+        @attributes[local] = remote_value
+      end
+    end
+    
+    #
+    # Validate the contact looks OK to avoid getting ugly-ass and unhelpful messages
+    # from the Gandi endpoint.
+    # 
+    # Returns an array of problems or empty if no issues.
+    #
+    def errors
+      Hash.new.tap do |a|
+        a[:type] = "must be one of #{TYPES.keys.join(',')}" unless TYPES.keys.include?(self.type)
+        a[:city]          = 'is required'   if is_blank?(self.city)
+        a[:first_name]    = 'is required'   if is_blank?(self.first_name)
+        a[:last_name]     = 'is required'   if is_blank?(self.last_name)
+        a[:organization]  = 'is required'   if is_blank?(self.organization) && [1,2,3].include?(self.type)
+        a[:country]       = 'is invalid'    unless COUNTRIES.include?(self.country)
+        a[:address]       = 'is required'   if is_blank?(self.address)
+        a[:phone]         = 'is invalid'    unless self.phone =~ /^\+\d{1,3}\.\d+$/
+        a[:password]      = 'is required'   if is_blank?(self.password) && new_record?
+        a[:email_address] = 'is invalid'    unless self.email_address =~ /^(([a-z0-9_\.\+\-\=\?\^\#]){1,64}\@(([a-z0-9\-]){1,251}\.){1,252}[-a-z0-9]{2,63})$/
+      end
+    end
+    
+    #
+    # Is the given variable blank?
+    #
+    def is_blank?(variable)
+      variable.nil? || variable.length == 0
+    end
+    
+    #
+    # Return whether this contact is suitable for use with a certain domain
+    #
+    def can_associate?(domain)
+      spec = {'domain' => domain, 'owner' => true, 'admin' => true}
+      res = Gandi.call('contact.can_associate_domain', self.handle, spec)
+      if res == true
+        true
+      else
+        res
+      end
+    end
+    
+    #
+    # Return an array of domains associated with this contact
+    #
+    def domains
+      return [] if new_record?
+      Gandi.call('domain.list', {'handle' => self.handle}).map { |d| Domain.new(d, true)}
+    end
+    
+  end
+end

data/lib/gandi/domain.rb

@@ -0,0 +1,157 @@
+module Gandi
+  class Domain
+    
+    class << self
+      
+      #
+      # Return all available TLDs
+      #
+      def tlds
+        Gandi.call('domain.tld.list')
+      end
+      
+      #
+      # Check the availability of a set of domains
+      #
+      def check_availability(*domains)
+        Gandi.call('domain.available', domains)
+      end
+      
+      #
+      # Check the availability of a set of domains syncronously
+      #
+      def check_availability!(*domains)
+        max_checks = 10
+        loop do
+          result = check_availability(*domains)
+          return result if result.all? { |k,v| v != 'pending' }
+          max_checks -= 1
+          return result if max_checks <= 0
+          sleep 0.7
+        end
+      end
+      
+      #
+      # Check the availability of a given domain
+      #
+      def available?(domain, max_checks = 10)
+        loop do
+          result = check_availability(domain)
+          return result[domain] == 'available' unless result[domain] == 'pending'
+          max_checks -= 1
+          return false if max_checks <= 0
+          sleep 0.7
+        end
+      end
+      
+      #
+      # Return the total number of domains on the account
+      #
+      def count
+        Gandi.call('domain.count')
+      end
+      
+      #
+      # Register a domain for the given contact. This is a billable action
+      # so be cautious. This method will return an operation object as this
+      # is not run straight away.
+      #
+      def create(domain, options = {})
+        raise ValidationError, "You must specify 'owner' as an option" unless options[:owner]
+        spec = {}
+        spec['duration']      = options[:duration] || 1
+        spec['owner']         = options[:owner]
+        spec['admin']         = options[:admin] || options[:owner]
+        spec['bill']          = options[:bill]  || options[:owner]
+        spec['tech']          = options[:tech]  || options[:owner]
+        spec['nameservers']   = options[:nameservers] if options[:nameservers]
+        spec['zone_id']       = options[:zone_id] if options[:zone_id]
+        result = Gandi.call('domain.create', domain, spec)
+        Operation.new(result)
+      end
+      
+      #
+      # Return information about a doman
+      #
+      def find(name)
+        self.new(Gandi.call('domain.info', name))
+      end
+      
+      #
+      # Return an array of all domains
+      #
+      def list
+        Gandi.call('domain.list').map { |d| self.new(d, true) }
+      end
+      
+    end
+    
+    def initialize(attributes, partial = false)
+      @attributes = attributes
+      @partial = partial
+    end
+    
+    def partial?
+      @partial
+    end
+    
+    def to_s
+      "#<Gandi::Domain #{name}>"
+    end
+    
+    #
+    # Return the domain name
+    #
+    def name
+      @attributes['fqdn']
+    end
+    
+    #
+    # Return attributes
+    #
+    def method_missing(name, value = nil)
+      if @attributes.keys.include?(name.to_s)
+        @attributes[name.to_s]
+      else
+        super
+      end
+    end
+    
+    #
+    # Get all the latest information about the domain
+    #
+    def reload
+      @attributes = Gandi.call('domain.info', name)
+      self
+    end
+    
+    #
+    # Return the domain's owner object
+    #
+    def owner
+      @owner ||= Gandi::Contact.find(contacts['owner']['handle'])
+    end
+    
+    #
+    # Change the domains. Accepts a hash
+    #
+    def change_contacts(hash)
+      Operation.new(Gandi.call('domain.contacts.set', name, hash))
+    end
+    
+    #
+    # Renew the domain
+    #
+    def renew(current_year, duration = 1)
+      Operation.new(Gandi.call('domain.renew', name, 'current_year' => current_year, 'duration' => duration))
+    end
+    
+    #
+    # Restore the domain
+    #
+    def restore(duration = 1)
+      Operation.new(Gandi.call('domain.restore', name, 'duration' => duration))
+    end
+    
+  end
+end

data/lib/gandi/operation.rb

@@ -0,0 +1,27 @@
+module Gandi
+  class Operation
+    
+    def self.find(id)
+      self.new(Gandi.call('operation.info', id))
+    end
+    
+    def initialize(attributes)
+      @attributes = attributes
+    end
+        
+    
+    def method_missing(name, value = nil)
+      if @attributes.keys.include?(name.to_s)
+        @attributes[name.to_s]
+      else
+        super
+      end
+    end
+    
+    def reload
+      @attributes = Gandi.call('operation.info', @attributes['id'])
+      self
+    end
+    
+  end
+end

data/lib/gandi/price.rb

@@ -0,0 +1,48 @@
+module Gandi
+  class Price
+    
+    attr_accessor :action
+    attr_accessor :description
+    attr_accessor :price
+    attr_accessor :min_duration
+    attr_accessor :max_duration
+    attr_accessor :currency
+    attr_accessor :grid
+    attr_accessor :duration_unit
+
+    def self.find(domain, options = {})
+      options[:action]    ||= 'create'
+      options[:duration]  ||= 1
+      options[:currency]  ||= 'GBP'
+      options[:grid]      ||= 'E'
+      product_spec = {
+        'product' => {
+          'description' => domain,
+          'type' => 'domain'
+        },
+        'action' => {
+          'name' => options[:action],
+          :duration => options[:duration],
+          'param' => {'tld_phase' => 'golive'}
+        }
+      }
+      list = Gandi.client.call("catalog.list", Gandi.apikey, product_spec, options[:currency], options[:grid])
+      if list.size == 1
+        price = self.new
+        price.action          = list.first['action']['name']
+        price.description     = list.first['product']['description']
+        return nil unless list.first['unit_price'].first
+        price.price           = list.first['unit_price'].first['price']
+        price.min_duration    = list.first['unit_price'].first['min_duration']
+        price.max_duration    = list.first['unit_price'].first['max_duration']
+        price.currency        = list.first['unit_price'].first['currency']
+        price.grid            = list.first['unit_price'].first['grid']
+        price.duration_unit   = list.first['unit_price'].first['duration_unit']
+        price
+      else
+        nil
+      end
+    end
+      
+  end
+end

data/lib/gandi/version.rb

@@ -0,0 +1,3 @@
+module Gandi
+  VERSION = '1.0.0'
+end

data/lib/gandi/zlib_parser_decorator.rb

@@ -0,0 +1,15 @@
+module Gandi
+  class ZlibParserDecorator
+    def initialize(parser)
+      @parser = parser
+    end
+
+    def parseMethodResponse(responseText)
+      @parser.parseMethodResponse(Zlib::GzipReader.new(StringIO.new(responseText)).read)
+    end
+
+    def parseMethodCall(*args)
+      @parser.parseMethodCall(*args)
+    end
+  end
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: viaduct-gandi
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Adam Cooke
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-05 00:00:00.000000000 Z
+dependencies: []
+description: A Gandi module for working with domain registrations.
+email:
+- adam@viaduct.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/gandi/contact.rb
+- lib/gandi/domain.rb
+- lib/gandi/operation.rb
+- lib/gandi/price.rb
+- lib/gandi/version.rb
+- lib/gandi/zlib_parser_decorator.rb
+- lib/gandi.rb
+- MIT-LICENSE
+- README.md
+homepage: http://viaduct.io
+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: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A Gandi module.
+test_files: []
+has_rdoc: