whoisxmlapi 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee3ef0dacc5ba9fc76df7676ead15f629cb34785ca90db96f8ca89f7ff15c6f9
-  data.tar.gz: 7f7b7e5c16db21d3c0c27b09fa0d14a2cdc21d5de5eb564a790948e36c3b5be9
+  metadata.gz: fe3b9a00715ebd01c80e1378d9f64c57051f4af98848fe8fba3b548dac9716c4
+  data.tar.gz: 4cbb2e345411dd433820b4ec4c465635e4cbb6c13ac4ae687175ada3d776c64d
 SHA512:
-  metadata.gz: 00656d04d2cdd7fd68a8076e10671e176d4ba2f76f557cce1db16c9227073c335a452c649939fae5131c5e711dec59895c64f7867292f9009d10b28acd0d2e72
-  data.tar.gz: 0c64f4c1c9b9d9a3dbdf4a3f2e3e540f91d2a75e87e6d64d8682b6238cc39452610f26a01dbc3119e964ebfa8018f2c078f20ef8d561471d699d7ef04f9fa91a
+  metadata.gz: c6be612f3c774ad9d4a0511c49bc3a78cf53b3cc592fcd47c02a7c94423be084d3ce54728f5b96b9a568194c76a4ed6d912a6ab101b9576cdef937cc45c73f22
+  data.tar.gz: ebe16297aa08021577cecca96c15be662cb0da4995940ccf9bcb7041ca2047854d720281434bdfd88b0c02af496e61c22ff7527d891419d02b6ea333e20c1d92

data/lib/whoisxmlapi/client.rb

@@ -7,74 +7,126 @@ module WhoisXMLAPI
 
   class Client
 
+    ####################################################################################################
+    # Whois
+    ####################################################################################################
+
     # https://whoisapi.whoisxmlapi.com/docs
     # GET https://www.whoisxmlapi.com/whoisserver/WhoisService?apiKey=YOUR_API_KEY&domainName=google.com
-    def whois(domain)
+    def whois_cacheless(domain, owner=nil)
       unless PublicSuffix.valid?(domain)
-        res = WhoisXMLAPI::BadDomain.new
+        res = WhoisXMLAPI::BadDomain.new(:whoisable => owner)
         res.parse(domain)
         return res
       end
 
-      query = WhoisXMLAPI::Result.where(:domain => domain)
-      query = query.where(:created_at.gte => (Time.now - WhoisXMLAPI.cache_length)) if WhoisXMLAPI.cache
-      res = query.first
-
-      if res.nil? || res._type == "WhoisXMLAPI::Unavailable"
-        params = {
-          :apiKey => WhoisXMLAPI.api_key,
-          :domainName => domain,
-          :outputFormat => 'JSON'
-        }
-
-        begin
-          r = HTTParty.get(WhoisXMLAPI.whois_path, :query => params, :timeout => 120)
-        rescue StandardError => e
-          WhoisXMLAPI.logger.info "WhoisXMLAPI#whois - Error getting Whois info for #{domain}: #{e}"
-          res = WhoisXMLAPI::Unavailable.new
-          res.parse(domain)
-          return res
-        end
+      params = {
+        :apiKey => WhoisXMLAPI.api_key,
+        :domainName => domain,
+        :outputFormat => 'JSON'
+      }
 
+      begin
+        r = HTTParty.get(WhoisXMLAPI.whois_path, :query => params, :timeout => 120)
+      rescue StandardError => e
+        WhoisXMLAPI.logger.info "WhoisXMLAPI#whois - Error getting Whois info for \'#{domain}\': #{e}"
+        res = WhoisXMLAPI::Unavailable.new(:whoisable => owner)
+        res.parse(domain)     # parse will save document for Unavailable
+      else
         if WhoisXMLAPI.callbacks[:whois]
-          WhoisXMLAPI.callbacks[:whois].each do |cb|
-            cb.call
-          end
+          WhoisXMLAPI.callbacks[:whois].each{ |cb| cb.call }
         end
-
         # WhoisXML and HTTParty are sometimes returning a Hash and not a JSON string as requested,
         # which is causing an error of "no implicit conversion of Hash into String" when we call JSON.parse.
         # Logger message is to monitor whether WhoisXML and/or HTTParty will still return a string on occasion.
         if r
           if r.parsed_response.is_a?(String)
-            WhoisXMLAPI.logger.debug "WhoisXMLAPI#whois - WARNING: passed back parsed_response as a String instead of a Hash for #{domain}."
+            WhoisXMLAPI.logger.debug "WhoisXMLAPI#whois - WARNING: passed back parsed_response as a String instead of a Hash for \'#{domain}\'."
             presponse = JSON.parse(r.parsed_response)
           else
             presponse = r.parsed_response
           end
           if presponse.key? 'ErrorMessage'
             WhoisXMLAPI.logger.info "WhoisXMLAPI#whois - Error getting Whois info: #{presponse['ErrorMessage']['msg']}"
-            res = WhoisXMLAPI::Unavailable.new
-            res.parse(domain)
+            res = WhoisXMLAPI::Unavailable.new(:whoisable => owner)
+            res.parse(domain)                     # parse will save document for Unavailable
           elsif (200..299).include? r.code.to_i
-            res = WhoisXMLAPI::Good.new
-            res.parse(presponse['WhoisRecord'])
+            res = WhoisXMLAPI::Good.new(:whoisable => owner)
+            res.parse(presponse['WhoisRecord'])   # parse will NOT save document for Good or UnParsable
             res.save
           end
         end
+      end
 
-        unless res
-          WhoisXMLAPI.logger.info "WhoisXMLAPI#whois - Unable to get Whois info for : #{domain}"
-          res = WhoisXMLAPI::Unavailable.new
-          res.parse(domain)
-        end
-
+      unless res
+        WhoisXMLAPI.logger.info "WhoisXMLAPI#whois - Unable to get Whois info for domain: \'#{domain}\'"
+        res = WhoisXMLAPI::Unavailable.new(:whoisable => owner)
+        res.parse(domain)   # parse will save document for Unavailable
       end
+
       return res
     end
 
 
-    def self.send_rwhois_request(entity_name)
+    # https://whoisapi.whoisxmlapi.com/docs
+    # GET https://www.whoisxmlapi.com/whoisserver/WhoisService?apiKey=YOUR_API_KEY&domainName=google.com
+    def whois(domain, owner=nil)
+      unless PublicSuffix.valid?(domain)
+        res = WhoisXMLAPI::BadDomain.new
+        res.parse(domain)
+        return res
+      end
+
+      query = WhoisXMLAPI::Result.where(:domain => domain)
+      query = query.where(:created_at.gte => (Time.now - WhoisXMLAPI.cache_length)) if WhoisXMLAPI.cache
+      res = query.first
+
+      if res.nil? || res._type == "WhoisXMLAPI::Unavailable"
+        WhoisXMLAPI.logger.debug "WhoisXMLAPI#whois - no cached Whois data for \'#{domain}\': initiating API access."
+        res = whois_cacheless(domain, owner)
+      else
+        WhoisXMLAPI.logger.debug "WhoisXMLAPI#whois - using cached Whois data for \'#{domain}\'"
+      end
+      res
+    end
+
+
+    def exists?(domain)
+      params = {
+        :cmd => 'GET_DN_AVAILABILITY',
+        :domainName => domain,
+        :outputFormat => 'JSON',
+        :apiKey => WhoisXMLAPI.api_key
+      }
+      begin
+        r = HTTParty.get(WhoisXMLAPI.whois_path, :query => params, :timeout => 120)
+      rescue StandardError => e
+        WhoisXMLAPI.logger.info "WhoisXMLAPI#whois - Error getting Whois info for \'#{domain}\': #{e}"
+        res = WhoisXMLAPI::Unavailable.new
+        res.parse(domain)
+        return res
+      end
+
+      # WhoisXML and HTTParty are sometimes returning a Hash and not a JSON string as requested,
+      # which is causing an error of "no implicit conversion of Hash into String" when we call JSON.parse.
+      # Logger message is to monitor whether WhoisXML and/or HTTParty will still return a string on occasion.
+      if r.parsed_response.is_a?(String)
+        WhoisXMLAPI.logger.debug "WhoisXMLAPI#exists? - passed back parsed_response as a String instead of a Hash for \'#{domain}\'."
+        resp = JSON.parse(r.parsed_response)
+      else
+        resp = r.parsed_response
+      end
+
+      resp["DomainInfo"]["domainAvailability"] == "UNAVAILABLE"
+    end
+
+
+    ####################################################################################################
+    # Reverse Whois
+    ####################################################################################################
+
+
+    def self.send_rwhois_request(entity_name, since_dt=nil)
       params = {
         :apiKey           => WhoisXMLAPI.api_key,
         :searchType       => "current",
@@ -82,13 +134,15 @@ module WhoisXMLAPI
         :responseFormat   => 'json',
         :basicSearchTerms => {
           :include => [entity_name]  # must be an array of strings!
-        },
+        }
       }
+      params[:createdDateFrom] = since_dt.strftime("%F") if since_dt
+
       begin
         # To DEBUG add ":debug_output => $stdout"
         r = HTTParty.post(WhoisXMLAPI.rwhois_path, :body => params.to_json, :timeout => 120, :headers => {'Content-Type' => 'application/json'})
       rescue StandardError => e
-        WhoisXMLAPI.logger.info "WhoisXMLAPI#rwhois - Error getting RWhois info for #{entity_name}: #{e}"
+        WhoisXMLAPI.logger.info "WhoisXMLAPI#rwhois - Error getting RWhois info for \'#{entity_name}\': #{e}"
         r = nil
       end
 
@@ -104,81 +158,76 @@ module WhoisXMLAPI
 
     # https://reverse-whois-api.whoisxmlapi.com/docs
     # POST https://reverse-whois-api.whoisxmlapi.com/api/v2
-    def rwhois(entity_name)
+    def rwhois_cacheless(entity_name, since_dt=nil, owner=nil)
       # entity_name is really the domain being passed in for Rwhois not the actual entity name
-      return nil if entity_name.nil?
-      query = WhoisXMLAPI::RWhoisResult.where(:entity_name => entity_name)
-      query = query.where(:created_at.gte => (Time.now - WhoisXMLAPI.cache_length)) if WhoisXMLAPI.cache
-      res = query.first
-
-      if res
-        WhoisXMLAPI.logger.debug "WhoisXMLAPI#rwhois - using cached rwhois data for #{entity_name}"
-      else
-        WhoisXMLAPI.logger.debug "WhoisXMLAPI#rwhois - no cached rwhois data for #{entity_name}"
-        res = WhoisXMLAPI::RWhoisResult.create(:entity_name => entity_name)
-
-        r = WhoisXMLAPI::Client.send_rwhois_request(entity_name)
+      return nil unless entity_name.present?
+      res = WhoisXMLAPI::RWhoisResult.new(:entity_name => entity_name, :rwhoisable => owner, :domains => [])
+      r = WhoisXMLAPI::Client.send_rwhois_request(entity_name, since_dt)
+      if r && r.parsed_response && r.parsed_response['domainsList']
+        res.domains = r.parsed_response['domainsList']
+      elsif PublicSuffix.valid?(entity_name)
+        # if no luck with what was passed in and we have a valid domain with TLD, try just the second-level domain.
+        domain_sld = PublicSuffix.parse(entity_name).sld
+        WhoisXMLAPI.logger.debug "WhoisXMLAPI#rwhois_cacheless - no domains found for domain \'#{entity_name}\', trying #{domain_sld}"
+        res.entity_name = domain_sld
+        r = WhoisXMLAPI::Client.send_rwhois_request(domain_sld)
         if r && r.parsed_response && r.parsed_response['domainsList']
           res.domains = r.parsed_response['domainsList']
-          res.save
-        elsif PublicSuffix.valid?(entity_name)
-          # if no luck with what was passed in and we have a valid domain with TLD, try just the second-level domain.
-          domain = PublicSuffix.parse(entity_name)
-          domain_sld = domain.sld
-          WhoisXMLAPI.logger.debug "WhoisXMLAPI#rwhois - no domains found for domain #{entity_name}, trying #{domain_sld}"
-          res = WhoisXMLAPI::RWhoisResult.create(:entity_name => domain_sld)
-
-          r = WhoisXMLAPI::Client.send_rwhois_request(domain_sld)
-          if r && r.parsed_response && r.parsed_response['domainsList']
-            res.domains = r.parsed_response['domainsList']
-            res.save
-          else
-            res.domains = []
-            res.save
-          end
-        else
-          WhoisXMLAPI.logger.debug "WhoisXMLAPI#rwhois - no domains found for #{entity_name}!"
-          res.domains = []
-          res.save
         end
+      else
+        WhoisXMLAPI.logger.debug "WhoisXMLAPI#rwhois_cacheless - no domains found for \'#{entity_name}\'!"
+      end
+      unless res.save
+        WhoisXMLAPI.logger.debug "WhoisXMLAPI#rwhois_cacheless - ERROR saving RWhoisResult: #{res.errors.full_messages.join('; ')} - #{res}!"
       end
       res
     end
 
 
-    def exists?(domain)
-      params = {
-        :cmd => 'GET_DN_AVAILABILITY',
-        :domainName => domain,
-        :outputFormat => 'JSON',
-        :apiKey => WhoisXMLAPI.api_key
-      }
-      begin
-        r = HTTParty.get(WhoisXMLAPI.whois_path, :query => params, :timeout => 120)
-      rescue StandardError => e
-        WhoisXMLAPI.logger.info "WhoisXMLAPI#whois - Error getting Whois info for #{domain}: #{e}"
-        res = WhoisXMLAPI::Unavailable.new
-        res.parse(domain)
-        return res
-      end
+    # https://reverse-whois-api.whoisxmlapi.com/docs
+    # POST https://reverse-whois-api.whoisxmlapi.com/api/v2
+    def rwhois(entity_name, since_dt=nil, owner=nil)
+      # entity_name is really the domain being passed in for Rwhois not the actual entity name
+      return nil if entity_name.nil?
+      query = WhoisXMLAPI::RWhoisResult.where(:entity_name => entity_name, :rwhoisable => owner)
+      query = query.where(:created_at.gte => (Time.now - WhoisXMLAPI.cache_length)) if WhoisXMLAPI.cache
+      res   = query.first
 
-      # WhoisXML and HTTParty are sometimes returning a Hash and not a JSON string as requested,
-      # which is causing an error of "no implicit conversion of Hash into String" when we call JSON.parse.
-      # Logger message is to monitor whether WhoisXML and/or HTTParty will still return a string on occasion.
-      if r.parsed_response.is_a?(String)
-        WhoisXMLAPI.logger.debug "WhoisXMLAPI#exists? - passed back parsed_response as a String instead of a Hash for #{domain}."
-        resp = JSON.parse(r.parsed_response)
+      if res.nil?
+        WhoisXMLAPI.logger.debug "WhoisXMLAPI#rwhois - no cached RWhois data for \'#{entity_name}\': initiating API access."
+        res = rwhois_cacheless(entity_name, since_dt, owner)
       else
-        resp = r.parsed_response
+        WhoisXMLAPI.logger.debug "WhoisXMLAPI#rwhois - using cached RWhois data for \'#{entity_name}\'"
       end
-
-      resp["DomainInfo"]["domainAvailability"] == "UNAVAILABLE"
+      res
     end
 
 
+    ####################################################################################################
+    # Account Balance
+    ####################################################################################################
+
+
     #
     # GET https://user.whoisxmlapi.com/service/account-balance?apiKey=YOUR_API_KEY
+    # wc.account_balance
+    # =>
+    # {
+    #   "Email Verification API"     => {:product_id => 7,  :credits => 1000},
+    #   "IP Geolocation API"         => {:product_id => 8,  :credits => 1000},
+    #   "Domain Research Suite"      => {:product_id => 14, :credits => 100},
+    #   "WHOIS API"                  => {:product_id => 1,  :credits => 1000},
+    #   "Domain Reputation API"      => {:product_id => 20, :credits => 100},
+    #   "IP Netblocks API"           => {:product_id => 23, :credits => 1000},
+    #   "Domain Availability API"    => {:product_id => 25, :credits => 100},
+    #   "Screenshot API"             => {:product_id => 27, :credits => 500},
+    #   "Website Categorization API" => {:product_id => 21, :credits => 100},
+    #   "Website Contacts API"       => {:product_id => 29, :credits => 100},
+    #   "DNS Lookup API"             => {:product_id => 26, :credits => 500}
+    # }
+
     def account_balance
+      result = nil
       params = {
         :apiKey => WhoisXMLAPI.api_key
       }
@@ -190,15 +239,30 @@ module WhoisXMLAPI
         r = nil
       end
 
-      # WhoisXML and HTTParty are sometimes returning a Hash and not a JSON string as requested,
-      # which is causing an error of "no implicit conversion of Hash into String" when we call JSON.parse.
-      # Logger message is to monitor whether WhoisXML and/or HTTParty will still return a string on occasion.
-      if r.parsed_response.is_a?(String)
-        WhoisXMLAPI.logger.debug "WhoisXMLAPI#account_balance - passed back parsed_response as a String instead of a Hash."
-        JSON.parse(r.parsed_response)
-      end
+      if r.response.is_a? Net::HTTPOK
+        if r && r.parsed_response
+          # WhoisXML and HTTParty are sometimes returning a Hash and not a JSON string as requested,
+          # which is causing an error of "no implicit conversion of Hash into String" when we call JSON.parse.
+          # Logger message is to monitor whether WhoisXML and/or HTTParty will still return a string on occasion.
+          if r.parsed_response.is_a?(String)
+            WhoisXMLAPI.logger.debug "WhoisXMLAPI#account_balance - passed back parsed_response as a String instead of a Hash."
+            JSON.parse(r.parsed_response)
+          end
 
-      r ? r.parsed_response : nil
+          if r.parsed_response["error"]
+            result = {:error => {message: r.parsed_response["error"]}}
+          elsif r.parsed_response["data"]
+            result = {}
+            r.parsed_response["data"].each do |datum|
+              key = datum["product"]["name"]
+              result[key] = {product_id: datum["product_id"], credits: datum["credits"]}
+            end
+          end
+        end
+      else
+        result = {:error =>{code: r.response.code, message: r.response.message}}
+      end
+      result
     end
 
 

data/lib/whoisxmlapi/contact.rb

@@ -19,8 +19,28 @@ module WhoisXMLAPI
     field :state
     field :postalCode
     field :country
+    field :countryCode
     field :email
     field :telephone
     field :fax
+
+    def self.selectively_create_from_hash(h)
+      attr = {
+        :name         => h['name'],
+        :organization => h['organization'],
+        :street1      => h['street1'],
+        :street2      => h['street2'],
+        :city         => h['city'],
+        :state        => h['state'],
+        :postalCode   => h['postalCode'],
+        :country      => h['country'],
+        :countryCode  => h['countryCode'],
+        :email        => h['email'],
+        :telephone    => h['telephone'],
+        :fax          => h['fax'],
+      }
+      Contact.create(attr)
+    end
+
   end
 end

data/lib/whoisxmlapi/result.rb

@@ -5,6 +5,9 @@ module WhoisXMLAPI
     include Mongoid::Document
     include Mongoid::Timestamps
 
+    # https://blog.bigbinary.com/2016/02/15/rails-5-makes-belong-to-association-required-by-default.html
+    belongs_to :whoisable, :polymorphic => true, optional: true
+
     field :domain
     field :record_created
     field :record_updated
@@ -15,11 +18,10 @@ module WhoisXMLAPI
     field :status
 
     has_one :registrant, :as => :contactable, :class_name => "WhoisXMLAPI::Contact", :autosave => true
-    has_one :admin, :as => :contactable, :class_name => "WhoisXMLAPI::Contact", :autosave => true
-    has_one :tech, :as => :contactable, :class_name => "WhoisXMLAPI::Contact", :autosave => true
-    has_one :billing, :as => :contactable, :class_name => "WhoisXMLAPI::Contact", :autosave => true
+    has_one :admin,      :as => :contactable, :class_name => "WhoisXMLAPI::Contact", :autosave => true
+    has_one :tech,       :as => :contactable, :class_name => "WhoisXMLAPI::Contact", :autosave => true
+    has_one :billing,    :as => :contactable, :class_name => "WhoisXMLAPI::Contact", :autosave => true
 
-    belongs_to :whoisable, :polymorphic => true
     # Actual indexing is performed in db_mongoid_extend.rake
     # index([
     #   [ :whoisable_id, Mongo::ASCENDING ],
@@ -27,6 +29,7 @@ module WhoisXMLAPI
     # ])
     index({whoisable_id: 1, whoisable_type: 1})
 
+
     def parse(record)
       self.domain = record['domainName']
       self.data_error = record['dataError'] ? record['dataError'] : nil
@@ -57,21 +60,47 @@ module WhoisXMLAPI
       technical_data      = record['technicalContact'] || (record['registryData'] ? record['registryData']['technicalContact'] : nil)
       billing_data        = record['billingContact'] || (record['registryData'] ? record['registryData']['billingContact'] : nil)
 
-      self.registrant = WhoisXMLAPI::Contact.create(registrant_data.merge({'email' => record['contactEmail']})) if registrant_data
-      self.admin      = WhoisXMLAPI::Contact.create(administrative_data) if administrative_data
-      self.tech       = WhoisXMLAPI::Contact.create(technical_data) if technical_data
-      self.billing    = WhoisXMLAPI::Contact.create(billing_data) if billing_data
+      self.registrant = WhoisXMLAPI::Contact.selectively_create_from_hash(registrant_data.merge({'email' => record['contactEmail']})) if registrant_data
+      self.admin      = WhoisXMLAPI::Contact.selectively_create_from_hash(administrative_data) if administrative_data
+      self.tech       = WhoisXMLAPI::Contact.selectively_create_from_hash(technical_data) if technical_data
+      self.billing    = WhoisXMLAPI::Contact.selectively_create_from_hash(billing_data) if billing_data
     end
 
+
     def complete?
       ( self.domain and self.registrar and ( self.registrant or self.admin or self.tech) )
     end
 
+
     def private?
       %w/networksolutionsprivateregistration.com domainprivacygroup.com/.each do |priv|
         return true if self.registrant.email =~ /#{priv}/
       end
       false
     end
+
+
+    def contact_email(contact)
+      case contact
+      when :registrant
+        registrant ? registrant.email : nil
+      when :admin
+        admin ? admin.email : nil
+      when :tech
+        tech ? tech.email : nil
+      when :billing
+        billing ? billing.email : nil
+      else
+        nil
+      end
+    end
+
+
+    def contact_email_host(contact)
+      email = contact_email(contact)
+      host = email.squish.split("@").last.downcase if email.present? && email.include?("@")
+      PublicSuffix.valid?(host) ? host : nil
+    end
+
   end
 end

data/lib/whoisxmlapi/rwhois_result.rb

@@ -3,16 +3,12 @@ module WhoisXMLAPI
     include Mongoid::Document
     include Mongoid::Timestamps
 
-    belongs_to :rwhoisable, :polymorphic => true
+    # https://blog.bigbinary.com/2016/02/15/rails-5-makes-belong-to-association-required-by-default.html
+    belongs_to :rwhoisable, :polymorphic => true, optional: true
+
     # Actual indexing is performed in db_mongoid_extend.rake
-    # index([
-    #   [ :rwhoisable_id, Mongo::ASCENDING ],
-    #   [ :rwhoisable_type, Mongo::ASCENDING ]
-    # ])
-    index({rwhoisable_id: 1, rwhoisable_type: 1})
-    
-    field :entity_name, :type => String
-    field :domains, :type => Array
 
+    field :entity_name, :type => String   # , index: true
+    field :domains,     :type => Array
   end
 end

data/lib/whoisxmlapi/version.rb

@@ -1,3 +1,3 @@
 module WhoisXMLAPI
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

data/whoisxmlapi.gemspec

@@ -6,8 +6,8 @@ require 'whoisxmlapi/version'
 Gem::Specification.new do |spec|
   spec.name          = "whoisxmlapi"
   spec.version       = WhoisXMLAPI::VERSION
-  spec.authors       = ["Christopher Maujean", "David Hillard", "Matt Appel", "Chip Roberson", "Edgar Abadines"]
-  spec.email         = ["cmaujean@brandle.net", "dhillard@brandle.net", "mappel@brandle.net", "chip@brandle.net", "ed@brandle.net"]
+  spec.authors       = ["David Hillard", "Matt Appel", "Chip Roberson", "Edgar Abadines"]
+  spec.email         = ["dhillard@brandle.net", "mappel@brandle.net", "chip@brandle.net", "ed@brandle.net"]
   spec.description   = %q{Gem for accessing the Whois XML API via JSON, with caching}
   spec.summary       = %q{whoisxmlapi.com access}
   spec.homepage      = "http://brandle.net/"

metadata

@@ -1,10 +1,9 @@
 --- !ruby/object:Gem::Specification
 name: whoisxmlapi
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
-- Christopher Maujean
 - David Hillard
 - Matt Appel
 - Chip Roberson
@@ -12,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-03 00:00:00.000000000 Z
+date: 2020-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -100,7 +99,6 @@ dependencies:
         version: '0'
 description: Gem for accessing the Whois XML API via JSON, with caching
 email:
-- cmaujean@brandle.net
 - dhillard@brandle.net
 - mappel@brandle.net
 - chip@brandle.net
@@ -145,7 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: whoisxmlapi.com access