namecheap 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 02175aa0d1001ac1e0499395be9dee997c0a74f1
-  data.tar.gz: 95188f2d6d9d7d39e67325db8ed8d1b9b85165c5
+SHA256:
+  metadata.gz: ac9a157ca91cc9a4089e1e2bd74c2f83fd58b9d5b5e07d8eeccc3ac3ccc9d0e5
+  data.tar.gz: 164c6465fe12394adb24b8a7217b114bb35549af30c154016d8b26e44ac9e8ca
 SHA512:
-  metadata.gz: ab1a114c6c2e9d703542f29532a04a7505cbeb31fabba049f51e17c233619c24b33d5ef2637a80bcbaa862031a11877ec495b7794b8286c527f7432a1b7b36f9
-  data.tar.gz: f02b397a82767d88993cb6d87aed36793c047d27bbc86ad0e60ad069394cc8bc857351d2fd7d25f6e72a4d082a365cb23325602a5e78ceaabbb13735b05bcfb4
+  metadata.gz: 0e24890a03f3420defe8dda7102ba59b59d8f4171ddff4eb01fe15c06d3485c53b69293ecceecfa2911e1909e0cfaa206ee23656312452e9cad9e2698fb3b0bb
+  data.tar.gz: 1daca40cfe219520446afaa5c5518bafc64d3b44ef22a554afb20aea0a2f99a963da215132b3f96d28be82584faaec1c1608ab2c4ff7e9b0f4342cdc8abef61d

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+## 0.3.1 (2026-07-25)
+
+- Require Ruby 3.3 or newer and add CI coverage for supported Ruby versions.
+- Fix required configuration validation for username and client IP.
+- Fix PUT and DELETE request dispatch.
+- Fix YAML configuration loading on modern Ruby.
+- Replace accidental live-network specs with deterministic request tests.
+- Modernize gem metadata, development tooling, and documentation.
+- Allow sandbox or production selection independently of the Rails/Rack environment.
+
+## 0.3.0 (2014-08-18)
+
+- Refactor the API wrappers and add Rails 3 compatibility.

data/README.md

@@ -1,94 +1,137 @@
-Overview
-========
+# Namecheap
 
-Documentation
------
+`namecheap` is a Ruby wrapper for the [Namecheap XML API](https://www.namecheap.com/support/api/intro/). It supports the existing domains, DNS, nameserver, transfer, SSL, user, and domain privacy commands exposed by the gem.
 
-[http://rubygems.org/gems/namecheap](http://rubygems.org/gems/namecheap)
+Version 0.3.1 requires Ruby 3.3 or newer.
 
-Usage
------
+## Installation
 
-In your initializers, configure Namecheap like so:
+Add the gem to your bundle:
+
+```ruby
+gem "namecheap"
+```
+
+Then run `bundle install`.
+
+## API setup
+
+Enable API access in your Namecheap account and whitelist the public IPv4 address that will make requests. Sandbox and production use separate accounts and credentials.
+
+The gem uses the sandbox endpoint unless `RACK_ENV` (or `Rails.env`) is `production`. Test requests against the sandbox before enabling production:
 
 ```ruby
 Namecheap.configure do |config|
-  config.key = 'apikey'
-  config.username = 'apiuser'
-  config.client_ip = '127.0.0.1'
+  config.key = ENV.fetch("NAMECHEAP_API_KEY")
+  config.username = ENV.fetch("NAMECHEAP_USERNAME")
+  config.client_ip = ENV.fetch("NAMECHEAP_CLIENT_IP")
 end
 ```
 
-Then you can do something like:
+Applications can select the Namecheap environment independently of `RACK_ENV`
+or `Rails.env`. This is useful when a staging application runs in production
+mode but must continue using Namecheap's sandbox:
+
+```ruby
+Namecheap.configure do |config|
+  config.environment = "sandbox"
+end
+```
+
+Set `environment` to either `"sandbox"` or `"production"`. Leave it unset, or
+set it to `nil`, to retain automatic Rails/Rack environment selection.
+
+Avoid committing API keys or account configuration to source control.
+
+## Usage
+
+The resource methods mirror Namecheap command names:
 
 ```ruby
 Namecheap.domains.get_list
+Namecheap.domains.check(["example.com", "example.net"])
+Namecheap.dns.get_hosts("example", "com")
 ```
 
-Please see the Namecheap API documentation for more information
+Additional command parameters can be passed as a final hash:
 
-About this project
--------------
+```ruby
+Namecheap.domains.get_list(page: 2, page_size: 50)
+```
 
-Namecheap is a ruby wrapper for the [Namecheap API](http://developer.namecheap.com/docs/doku.php?id=api-reference:index)
+Namecheap returns XML responses. This version returns the `HTTParty::Response` directly so existing applications can inspect the parsed response, status, and headers.
 
-The code was originally forked from https://github.com/hashrocket/namecheap
+Configuration can also be loaded from an ERB-enabled YAML file. The selected top-level key must match `RACK_ENV`, or `development` when it is unset:
 
-At [Mindvalley](http://www.mindvalley.com) (the company I work for) we have something
-called 'HackdayFridays' where we spend the whole day hacking on an interesting
-project that may or may not be directly related to the business. It was enacted
-so that the tech and production team can unwind from what can be a monotonous
-work week, and hack on something more interesting.
+```yaml
+development:
+  username: sandbox_user
+  key: <%= ENV.fetch("NAMECHEAP_API_KEY") %>
+  client_ip: 192.0.2.1
+  environment: sandbox
+```
 
-One of the proposed projects was a 'big red button' where someone can just type
-in the domain name, push a big red button, and magically:
+```ruby
+Namecheap::Config.load!("config/namecheap.yml")
+```
 
-* the domain name is purchased
-* the DNS is pointed to our load balancer
-* a subversion repository is created (with users)
-* a template is committed to the repository with default pages
-* a project is created in webistrano
-* the initial setup and deployment is done
+## Development
 
-Mostly everything is already automated except the domain name purchase and dns.
-We purchase most of our domains from Namecheap (and some from GoDaddy) and it was
-fortunate that Namecheap has an API. Unfortunately there didn't seem to be a gem
-that already existed.
+Install dependencies and run the test and style checks:
 
-A search brought me to HashRocket's namecheap API wrapper. It didn't have any of
-the purchase API wrappers, but it was a good starting point (and allowed me to
-study how seasoned pros would approach API wrappers). So I forked, published a
-gem based on the fork, and hacked on it. And that's how it all began :)
+```shell
+mise exec -- bundle install
+mise exec -- bundle exec rake
+```
 
-Credits
--------
+Build a local gem without publishing it:
 
-Tristan V. Gomez: tristan dot gomez at gmail dot com
+```shell
+mise exec -- bundle exec gem build namecheap.gemspec
+```
 
-[Hashrocket](http://www.hashrocket.com/) from where the original code was forked from
+### Manual release
 
-[Mongoid](http://www.mongoid.org) from where the configuration code was modified from
+Releases from this legacy branch are intentionally manual. Start from a clean
+`legacy/0.3` checkout and confirm that `lib/namecheap/version.rb` and the dated
+changelog heading contain the same version. Then run:
 
+```shell
+mise exec -- bundle install
+mise exec -- bundle exec rake
+mise exec -- bundle exec gem build namecheap.gemspec
+mise exec -- ruby -rrubygems/package -e \
+  'spec = Gem::Package.new(ARGV.fetch(0)).spec; puts "#{spec.name} #{spec.version} (Ruby #{spec.required_ruby_version})"' \
+  namecheap-0.3.1.gem
+```
+
+Commit and push the finalized release changes before creating a signed,
+annotated tag for the exact release commit:
 
-Plug!!
-------
+```shell
+git tag -s v0.3.1 -m "Release 0.3.1"
+git push origin legacy/0.3
+git push origin v0.3.1
+```
 
-Mindvalley is [hiring](http://www.mindvalley.com/careers) :)
+Publish the artifact to RubyGems manually. RubyGems may prompt for MFA:
 
-License
--------
+```shell
+mise exec -- gem push namecheap-0.3.1.gem
+```
+
+After RubyGems reports version 0.3.1 as published, create the corresponding
+GitHub Release:
+
+```shell
+gh release create v0.3.1 --verify-tag --generate-notes --title v0.3.1
+```
 
-Copyright (c) 2011 Tristan V. Gomez
+Changing the version, building the gem, or pushing the branch does not publish
+a release.
 
-This program 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
-(at your option) any later version.
+## License
 
-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.
+Copyright 2011 Tristan V. Gomez. This project is available under the GNU Lesser General Public License, version 3 or any later version. See [COPYING](COPYING).
 
-You should have received a copy of the GNU General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.
+The original API wrapper was forked from Hashrocket's `namecheap` project.

data/lib/namecheap/api.rb

@@ -1,62 +1,75 @@
-require 'active_support/core_ext/string/inflections'
+require "active_support/core_ext/string/inflections"
 
 module Namecheap
   class Api
-    SANDBOX = 'https://api.sandbox.namecheap.com/xml.response'
-    PRODUCTION = 'https://api.namecheap.com/xml.response'
-    ENVIRONMENT = defined?(Rails) && Rails.respond_to?(:env) ? Rails.env : (ENV["RACK_ENV"] || 'development')
-    ENDPOINT = (ENVIRONMENT == 'production' ? PRODUCTION : SANDBOX)
+    SANDBOX = "https://api.sandbox.namecheap.com/xml.response"
+    PRODUCTION = "https://api.namecheap.com/xml.response"
+    ENVIRONMENT = (defined?(Rails) && Rails.respond_to?(:env)) ? Rails.env.to_s : (ENV["RACK_ENV"] || "development")
+    ENDPOINT = (ENVIRONMENT == "production") ? PRODUCTION : SANDBOX
 
     def get(command, options = {})
-      request 'get', command, options
+      request "get", command, options
     end
 
     def post(command, options = {})
-      request 'post', command, options
+      request "post", command, options
     end
 
     def put(command, options = {})
-      request 'post', command, options
+      request "put", command, options
     end
 
     def delete(command, options = {})
-      request 'post', command, options
+      request "delete", command, options
     end
 
     def request(method, command, options = {})
-      command = 'namecheap.' + command
-      options = init_args.merge(options).merge({:command => command})
+      command = "namecheap.#{command}"
+      options = init_args.merge(options).merge(command: command)
       options.keys.each do |key|
         options[key.to_s.camelize] = options.delete(key)
       end
 
       case method
-      when 'get'
-        #raise options.inspect
-        HTTParty.get(ENDPOINT, { :query => options})
-      when 'post'
-        HTTParty.post(ENDPOINT, { :query => options})
-      when 'put'
-        HTTParty.put(ENDPOINT, { :query => options})
-      when 'delete'
-        HTTParty.delete(ENDPOINT, { :query => options})
+      when "get"
+        HTTParty.get(endpoint, query: options)
+      when "post"
+        HTTParty.post(endpoint, query: options)
+      when "put"
+        HTTParty.put(endpoint, query: options)
+      when "delete"
+        HTTParty.delete(endpoint, query: options)
       end
     end
 
     def init_args
-      %w(username key client_ip).each do |key|
-        if Namecheap.config.key.nil?
+      %w[username key client_ip].each do |key|
+        if Namecheap.config.public_send(key).nil?
           raise Namecheap::Config::RequiredOptionMissing,
-            "Configuration parameter missing: #{key}, " +
+            "Configuration parameter missing: #{key}, " \
             "please add it to the Namecheap.configure block"
         end
       end
-      options = {
-        api_user:  Namecheap.config.username,
+
+      {
+        api_user: Namecheap.config.username,
         user_name: Namecheap.config.username,
-        api_key:   Namecheap.config.key,
+        api_key: Namecheap.config.key,
         client_ip: Namecheap.config.client_ip
       }
     end
+
+    private
+
+    def endpoint
+      case Namecheap.config.environment
+      when "sandbox"
+        SANDBOX
+      when "production"
+        PRODUCTION
+      else
+        ENDPOINT
+      end
+    end
   end
 end

data/lib/namecheap/config.rb

@@ -1,9 +1,25 @@
+require "erb"
+require "yaml"
+
 module Namecheap
   module Config
-    class RequiredOptionMissing < RuntimeError ; end
+    class RequiredOptionMissing < RuntimeError; end
     extend self
 
+    ENVIRONMENTS = %w[sandbox production].freeze
+
     attr_accessor :key, :username, :client_ip
+    attr_reader :environment
+
+    def environment=(environment)
+      if environment.nil?
+        @environment = nil
+      elsif ENVIRONMENTS.include?(environment)
+        @environment = environment
+      else
+        raise ArgumentError, "environment must be sandbox or production"
+      end
+    end
 
     # Configure namecheap from a hash. This is usually called after parsing a
     # yaml config file such as mongoid.yml.
@@ -26,10 +42,9 @@ module Namecheap
     #
     # @param [ String ] path The path to the file.
     def load!(path)
-      settings = YAML.load(ERB.new(File.new(path).read).result)[ENVIRONMENT]
-      if settings.present?
-        from_hash(settings)
-      end
+      contents = ERB.new(File.read(path)).result
+      settings = YAML.safe_load(contents, aliases: true)&.fetch(Namecheap::Api::ENVIRONMENT, nil)
+      from_hash(settings) if settings && !settings.empty?
     end
   end
 end

data/lib/namecheap/dns.rb

@@ -3,54 +3,54 @@ module Namecheap
     # Sets domain to use Namecheap's default DNS servers.
     # @see http://developer.namecheap.com/docs/doku.php?id=api-reference:domains.dns:setdefault
     def set_default(sld, tld, options = {})
-      options = {:SLD => sld, :TLD => tld}.merge(options)
-      get 'domains.dns.setDefault', options
+      options = {SLD: sld, TLD: tld}.merge(options)
+      get "domains.dns.setDefault", options
     end
 
     # Sets domain to use custom DNS servers.
     # @see http://developer.namecheap.com/docs/doku.php?id=api-reference:domains.dns:setcustom
     def set_custom(sld, tld, nameservers = [], options = {})
       if nameservers.respond_to?(:join)
-        nameservers = nameservers.join(',')
+        nameservers = nameservers.join(",")
       end
-      
-      options = {:SLD => sld, :TLD => tld, :Nameservers => nameservers}.merge(options)
-      get 'domains.dns.setCustom', options
+
+      options = {SLD: sld, TLD: tld, Nameservers: nameservers}.merge(options)
+      get "domains.dns.setCustom", options
     end
 
     # Gets a list of DNS servers associated with the requested domain.
     # @see http://developer.namecheap.com/docs/doku.php?id=api-reference:domains.dns:getlist
     def get_list(sld, tld, options = {})
-      options = {:SLD => sld, :TLD => tld}.merge(options)
-      get 'domains.dns.getList', options
+      options = {SLD: sld, TLD: tld}.merge(options)
+      get "domains.dns.getList", options
     end
 
     # Retrieves DNS host record settings for the requested domain.
     # @see http://developer.namecheap.com/docs/doku.php?id=api-reference:domains.dns:gethosts
     def get_hosts(sld, tld, options = {})
-      options = {:SLD => sld, :TLD => tld}.merge(options)
-      get 'domains.dns.getHosts', options
+      options = {SLD: sld, TLD: tld}.merge(options)
+      get "domains.dns.getHosts", options
     end
 
     # Gets email forwarding settings for the requested domain.
     # @see http://developer.namecheap.com/docs/doku.php?id=api-reference:domains.dns:getemailforwarding
     def get_email_forwarding(domain, options = {})
-      options = {:DomainName => domain}.merge(options)
-      get 'domains.dns.getEmailForwarding', options
+      options = {DomainName: domain}.merge(options)
+      get "domains.dns.getEmailForwarding", options
     end
 
     # Sets email forwarding for a domain name.
     # @see http://developer.namecheap.com/docs/doku.php?id=api-reference:domains.dns:setemailforwarding
     def set_email_forwarding(domain, options = {})
-      options = {:DomainName => domain}.merge(options)
-      get 'domains.dns.setEmailForwarding', options
+      options = {DomainName: domain}.merge(options)
+      get "domains.dns.setEmailForwarding", options
     end
 
     # Sets DNS host records settings for the requested domain.
     # @see http://developer.namecheap.com/docs/doku.php?id=api-reference:domains.dns:sethosts
     def set_hosts(sld, tld, options = {})
-      options = {:SLD => sld, :TLD => tld}.merge(options)
-      get 'domains.dns.setHosts', options
+      options = {SLD: sld, TLD: tld}.merge(options)
+      get "domains.dns.setHosts", options
     end
   end
 end

data/lib/namecheap/domains.rb

@@ -3,80 +3,80 @@ module Namecheap
     # Returns a list of domains for the particular user.
     # @see http://developer.namecheap.com/docs/doku.php?id=api-reference:domains:getlist
     def get_list(options = {})
-      get 'domains.getList', options
+      get "domains.getList", options
     end
 
     # Gets contact information for the requested domain.
     # @see http://developer.namecheap.com/docs/doku.php?id=api-reference:domains:getcontacts
     def get_contacts(domain, options = {})
-      options = {:DomainName => domain}.merge(options)
-      get 'domains.getContacts', options
+      options = {DomainName: domain}.merge(options)
+      get "domains.getContacts", options
     end
 
     # Registers a domain.
     # @see http://developer.namecheap.com/docs/doku.php?id=api-reference:domains:create
     def create(domain, options = {})
-      options = {:DomainName => domain}.merge(options)
-      get 'domains.create', options
+      options = {DomainName: domain}.merge(options)
+      get "domains.create", options
     end
 
     # Returns a list of tlds.
     # @see http://developer.namecheap.com/docs/doku.php?id=api-reference:domains:gettldlist
     def get_tld_list(options = {})
-      get 'domains.getTldList', options
+      get "domains.getTldList", options
     end
 
     # Sets contact information for the requested domain.
     # @see http://developer.namecheap.com/docs/doku.php?id=api-reference:domains:setcontacts
     def set_contacts(domain, options = {})
-      options = {:DomainName => domain}.merge(options)
-      get 'domains.setContacts', options
+      options = {DomainName: domain}.merge(options)
+      get "domains.setContacts", options
     end
 
     # Checks the availability of domains.
     # @see http://developer.namecheap.com/docs/doku.php?id=api-reference:domains:check
     def check(domains = [], options = {})
       if domains.respond_to?(:join)
-        domains = domains.join(',')
+        domains = domains.join(",")
       end
-      
-      options = {:DomainList => domains}.merge(options)
-      get 'domains.check', options
+
+      options = {DomainList: domains}.merge(options)
+      get "domains.check", options
     end
 
     # Reactivates an expired domain.
     # @see http://developer.namecheap.com/docs/doku.php?id=api-reference:domains:reactivate
     def reactivate(domain, options = {})
-      options = {:DomainName => domain}.merge(options)
-      get 'domains.reactivate', options
+      options = {DomainName: domain}.merge(options)
+      get "domains.reactivate", options
     end
 
     # Renews an expiring domain.
     # http://developer.namecheap.com/docs/doku.php?id=api-reference:domains:renew
     def renew(domain, options = {})
-      options = {:DomainName => domain}.merge(options)
-      get 'domains.renew', options
+      options = {DomainName: domain}.merge(options)
+      get "domains.renew", options
     end
 
     # Gets the status of RegistrarLock for the requested domain.
     # @see http://developer.namecheap.com/docs/doku.php?id=api-reference:domains:getregistrarlock
     def get_registrar_lock(domain, options = {})
-      options = {:DomainName => domain}.merge(options)
-      get 'domains.getRegistrarLock', options
+      options = {DomainName: domain}.merge(options)
+      get "domains.getRegistrarLock", options
     end
 
     # Sets the RegistrarLock status for a domain.
     # @see http://developer.namecheap.com/docs/doku.php?id=api-reference:domains:setregistrarlock
     def set_registrar_lock(domain, options = {})
-      options = {:DomainName => domain}.merge(options)
-      get 'domains.setRegistrarLock', options
+      options = {DomainName: domain}.merge(options)
+      get "domains.setRegistrarLock", options
     end
 
     # Returns information about the requested domain.
     # @see http://developer.namecheap.com/docs/doku.php?id=api-reference:domains:getinfo
     def get_info(domain, options = {})
-      options = {:DomainName => domain}.merge(options)
-      get 'domains.getInfo', options
+      options = {DomainName: domain}.merge(options)
+      get "domains.getInfo", options
     end
   end
 end

data/lib/namecheap/ns.rb

@@ -3,29 +3,29 @@ module Namecheap
     # Creates a new nameserver.
     # @see http://developer.namecheap.com/docs/doku.php?id=api-reference:domains.ns:create
     def create(sld, tld, options = {})
-      options = {:SLD => sld, :TLD => tld}.merge(options)
-      get 'domains.ns.create', options
+      options = {SLD: sld, TLD: tld}.merge(options)
+      get "domains.ns.create", options
     end
 
     # Deletes a nameserver associated with the requested domain.
     # @see http://developer.namecheap.com/docs/doku.php?id=api-reference:domains.ns:delete
     def delete(sld, tld, options = {})
-      options = {:SLD => sld, :TLD => tld}.merge(options)
-      get 'domains.ns.delete', options
+      options = {SLD: sld, TLD: tld}.merge(options)
+      get "domains.ns.delete", options
     end
 
     # Retrieves information about a registered nameserver.
     # @see http://developer.namecheap.com/docs/doku.php?id=api-reference:domains.ns:getinfo
     def get_info(sld, tld, options = {})
-      options = {:SLD => sld, :TLD => tld}.merge(options)
-      get 'domains.ns.getInfo', options
+      options = {SLD: sld, TLD: tld}.merge(options)
+      get "domains.ns.getInfo", options
     end
 
     # Updates the IP address of a registered nameserver.
     # @see http://developer.namecheap.com/docs/doku.php?id=api-reference:domains.ns:update
     def update(sld, tld, options = {})
-      options = {:SLD => sld, :TLD => tld}.merge(options)
-      get 'domains.ns.update', options
+      options = {SLD: sld, TLD: tld}.merge(options)
+      get "domains.ns.update", options
     end
   end
 end