namecheap 0.0.1 → 0.0.2

data/.gitignore

@@ -2,3 +2,7 @@
 .bundle
 Gemfile.lock
 pkg/*
+/nbproject
+/bak
+config/namecheap.yml
+

data/Rakefile

@@ -1 +1,6 @@
 require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/config/namecheap.yml.orig

@@ -0,0 +1,14 @@
+development:
+  key: 4fad5a63f8bd4e03a8bbc8131a2fb331
+  username: parasquid
+  client_ip: 175.136.192.89
+
+test:
+  key: apikey
+  username: apiuser
+  client_ip: 127.0.0.1
+
+production:
+  key: apikey
+  username: apiuser
+  client_ip: 127.0.0.1

data/lib/monkey_patch.rb

@@ -0,0 +1,21 @@
+class Hash
+  def symbolize_keys!
+    keys.each do |key|
+      self[(key.to_sym rescue key) || key] = delete(key)
+    end
+    self
+  end
+
+  def to_param(namespace = nil)
+    collect do |key, value|
+      value.to_query(namespace ? "#{namespace}[#{key}]" : key)
+    end.sort * '&'
+  end
+
+  protected
+
+  def to_query(key)
+    require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
+    "#{CGI.escape(key.to_param)}=#{CGI.escape(to_param.to_s)}"
+  end
+end

data/lib/namecheap.rb

@@ -1,77 +1,33 @@
-require "namecheap/version"
 require 'httparty'
 
 module Namecheap
-end
-
-class NilNamecheapResponse < Exception
-end
-
-class NamecheapResponse
-  def initialize(response)
-    @response = response
-  end
-
-  def status
-    @response["ApiResponse"]["Status"] 
-  end
-
-  def message
-    if @response["ApiResponse"]["Errors"].any?
-      @response["ApiResponse"]["Errors"]["Error"]
+  SANDBOX = 'https://api.sandbox.namecheap.com/xml.response'
+  PRODUCTION = 'https://api.namecheap.com/xml.response'
+  class Api
+    attr_reader :username, :key, :client_ip
+    def initialize(options = {})
+      config_file = options[:config_file] || "#{File.dirname(__FILE__)}/../config/namecheap.yml"
+      environment = options[:environment] || ENV['RACK_ENV'] || 'development'
+      config = options[:config_file] || YAML.load_file(config_file)[environment].symbolize_keys!
+      @key = options[:key] || config[:key]
+      @username = options[:username] || config[:username]
+      @client_ip = options[:client_ip] || config[:client_ip]
+      @endpoint = (environment == 'production' ? PRODUCTION : SANDBOX)
     end
-  end
-
-  def items
-    response = @response["ApiResponse"]["CommandResponse"]
-    raise NilNamecheapResponse if response.nil?
-    response.delete_if { |key, value| key == "Type" }
-  end
-
-end
 
-class DomainCheck
-  attr_accessor :domain, :available, :error, :description
+    protected
 
-  def initialize(item)
-    @domain = item["Domain"]
-    @available = (item["Available"] == "true" ? true : false)
-    @error = item["ErrorNo"]
-    @description = item["Description"]
-  end
-end
-
-class NamecheapDomainCheckResponse < NamecheapResponse
-  def items
-    super.collect {|item| DomainCheck.new(item[1])} 
+    def api_call(command, command_args)
+      args = {}
+      args['ApiUser'] = args['UserName'] = @username
+      args['ApiKey'] = @key
+      args['ClientIp'] = @client_ip
+      args['Command'] = command
+      query = @endpoint + '?' + args.to_param
+      HTTParty.get(query)
+    end
   end
 end
 
-class Namecheap
-  attr_reader :username, :key, :client_ip
-  def initialize(options = {})
-    config = YAML.load_file("#{File.dirname(__FILE__)}/namecheap.yml").symbolize_keys!
-    @key = options[:key] || config[:key]
-    @username = options[:username] || config[:username]
-    @client_ip = options[:client_ip] || config[:client_ip]
-  end
-
-  def is_domain_available?(domain)
-    results = domain_check(domain).items
-    results.nil? ? false : results.first.available?
-  end
-
-  def domain_check(domain)
-    domain = domain.join(",") if domain.is_a? Array
-    NamecheapDomainCheckResponse.new(do_query("namecheap.domains.check", "&DomainList=#{domain}"))
-  end
-
-  protected
-  
-  def do_query(api_method, options)
-    query = "https://api.sandbox.namecheap.com/xml.response?ApiUser=#{@username}&ApiKey=#{@key}&UserName=#{@username}&ClientIp=#{@client_ip}&Command=#{api_method}"
-    query += options
-    HTTParty.get(query)
-  end
-
-end
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/namecheap")
+Dir.glob("#{File.dirname(__FILE__)}/namecheap/*.rb") { |lib| require File.basename(lib, '.*') }

data/lib/namecheap/domains.rb

@@ -0,0 +1,8 @@
+module Namecheap
+  class Domains < Namecheap::Api
+    def get_list(options = {})
+      args = options.clone
+      api_call('namecheap.domains.getList', args)
+    end
+  end
+end

data/lib/namecheap/version.rb

@@ -1,3 +1,3 @@
 module Namecheap
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/namecheap.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |s|
   s.name        = "namecheap"
   s.version     = Namecheap::VERSION
   s.authors     = ["parasquid"]
-  s.email       = ["tristan.gomezd@gmail.com"]
+  s.email       = ["tristan.gomez@gmail.com"]
   s.homepage    = "https://github.com/parasquid/namecheap"
   s.summary     = %q{Ruby wrapper for the Namecheap API}
   s.description = %q{Ruby wrapper for the Namecheap API}

data/spec/domains_spec.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Domains"  do
+  it "should instantiate"  do
+    Namecheap::Domains.new(:environment => 'test')
+  end
+end

data/spec/namecheap_spec.rb

@@ -1,85 +1,36 @@
 require File.dirname(__FILE__) + '/spec_helper'
-require File.dirname(__FILE__) + '/../lib/namecheap'
-require 'mocha'
 
 describe "NamecheapAPI Wrapper"  do
   describe "initializating settings" do
-    describe "with defaults" do 
+    describe "with defaults" do
       it "should contain a username" do
-	namecheap = Namecheap.new
-	namecheap.send(:username).should == 'apiuser'
-      end	  
+        namecheap = Namecheap::Api.new(:environment => 'test')
+        namecheap.send(:username).should == 'apiuser'
+      end
       it "should contain a key" do
-	namecheap = Namecheap.new
-	namecheap.send(:key).should == 'apikey'
+        namecheap = Namecheap::Api.new(:environment => 'test')
+        namecheap.send(:key).should == 'apikey'
       end
       it "should contain a client_ip" do
-	namecheap = Namecheap.new
-	namecheap.send(:client_ip).should == '127.0.0.1'
+        namecheap = Namecheap::Api.new(:environment => 'test')
+        namecheap.send(:client_ip).should == '127.0.0.1'
       end
     end
 
-    describe "with defaults overidden" do 
+    describe "with defaults overidden" do
       it "shoud contain a overidden username" do
-	namecheap = Namecheap.new(:username => 'testuser')
-	namecheap.send(:username).should == 'testuser'
-      end	  
+        namecheap = Namecheap::Api.new(:environment => 'test', :username => 'testuser')
+        namecheap.send(:username).should == 'testuser'
+      end
 
       it "shoud contain a key" do
-	namecheap = Namecheap.new(:key => 'testkey')
-	namecheap.send(:key).should == 'testkey'
+        namecheap = Namecheap::Api.new(:environment => 'test', :key => 'testkey')
+        namecheap.send(:key).should == 'testkey'
       end
       it "shoud contain a client_ip" do
-	namecheap = Namecheap.new(:client_ip => '66.11.22.44')
-	namecheap.send(:client_ip).should == '66.11.22.44'
-      end
-    end
-  end
-
-  describe "Attempt to connect with bad credentials" do
-    it "should report an error on erroneous account information" do
-      namecheap = Namecheap.new
-      namecheap.domain_check("fakedomain").status.should == "ERROR"
+        namecheap = Namecheap::Api.new(:environmeny => 'test', :client_ip => '66.11.22.44')
+        namecheap.send(:client_ip).should == '66.11.22.44'
       end
-
-    it "should give error message for invalid api key when using an invalid key" do
-      namecheap = Namecheap.new
-      namecheap.domain_check("fakedomain").message.should include("API Key is invalid")
-    end
-  end
-
-  describe "Attempt to connect with valid credentials" do
-     
-  end
-
-  describe "#domain_check" do
-    it "should build query with multiple domains" do
-      namecheap = Namecheap.new()
-      namecheap.expects(:do_query).with("namecheap.domains.check", "&DomainList=domain1.com,domain2.com")
-      namecheap.domain_check(['domain1.com','domain2.com'])
-    end
-  end
-
-  describe "#is_domain_available?" do
-    it "should return false if connection fails" do
-      namecheap = Namecheap.new(:apikey => 'BADKEY')
-      lambda {
-	namecheap.is_domain_available?('fakedomain.tld').should be_false
-      }.should raise_error(NilNamecheapResponse)
-    end
-
-    it "should return true if connections succeeds and domain is available" do
-      pending "Need API Access To Namecheap.com"
-      namecheap = Namecheap.new
-      namecheap.is_domain_available?('saucytuborswithashoefetish.com').should be_true
-    end
-
-    it "should return false if connections succeeds and domain is not available" do
-      namecheap = Namecheap.new
-      lambda {
-	namecheap.is_domain_available?('hashrocket.com').should be_false
-      }.should raise_error(NilNamecheapResponse)
     end
   end
-end
-
+end

data/spec/spec_helper.rb

@@ -1,12 +1,11 @@
 begin
-  require 'spec'
+  require 'rspec'
 rescue LoadError
   require 'rubygems'
   gem 'rspec'
   require 'spec'
 end
 
-require 'activesupport'
-require 'activerecord'
-
-$:.unshift(File.dirname(__FILE__) + '/../lib')
+require File.dirname(__FILE__) + '/../lib/namecheap'
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib/namecheap")
+require 'namecheap/domains'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: namecheap
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: 
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - parasquid
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-07 00:00:00 Z
+date: 2011-10-14 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -47,7 +47,7 @@ dependencies:
   version_requirements: *id002
 description: Ruby wrapper for the Namecheap API
 email: 
-- tristan.gomezd@gmail.com
+- tristan.gomez@gmail.com
 executables: []
 
 extensions: []
@@ -60,12 +60,13 @@ files:
 - Gemfile
 - README.textile
 - Rakefile
+- config/namecheap.yml.orig
+- lib/monkey_patch.rb
 - lib/namecheap.rb
-- lib/namecheap.yml
+- lib/namecheap/domains.rb
 - lib/namecheap/version.rb
 - namecheap.gemspec
-- spec/namecheap_domain_check_response_spec.rb
-- spec/namecheap_response_spec.rb
+- spec/domains_spec.rb
 - spec/namecheap_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/parasquid/namecheap
@@ -102,7 +103,6 @@ signing_key:
 specification_version: 3
 summary: Ruby wrapper for the Namecheap API
 test_files: 
-- spec/namecheap_domain_check_response_spec.rb
-- spec/namecheap_response_spec.rb
+- spec/domains_spec.rb
 - spec/namecheap_spec.rb
 - spec/spec_helper.rb

data/lib/namecheap.yml

@@ -1,4 +0,0 @@
----
-key: apikey
-username: apiuser
-client_ip: 127.0.0.1

data/spec/namecheap_domain_check_response_spec.rb

@@ -1,78 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-require File.dirname(__FILE__) + '/../lib/namecheap'
-
-describe NamecheapDomainCheckResponse  do
-  
-  describe "successful response from namecheap" do
-    before(:each) do
-	@domain_check_response_hash = {"ApiResponse"=>{"Status"=>"OK", 
-			      "Errors"=>{},  
-			    "CommandResponse" => {"Type" => "namecheap.domains.check", 
-			      "DomainCheckResult1" => {"Domain" => "domain1.com", "Available" => "true"},
-			      "DomainCheckResult2" => {"Domain" => "domain2.com", "Available" => "false"},
-			      "DomainCheckResult3" => {"Domain" => "domain.wtf", "Available" => "error", 
-			      "ErrorNo" => "750", "Description" => "No response from the registry"}},
-			    "GMTTimeDifference"=>"--6:00", 
-			    "RequestedCommand"=>"namecheap.domains.check", 
-			    "Server"=>"SERVER159", 
-			    "ExecutionTime"=>"0.01", 
-			    "xmlns"=>"http://api.namecheap.com/xml.response"}} 
-
-      @response = NamecheapDomainCheckResponse.new(@domain_check_response_hash)
-
-    end
-
-    it "should have a domain check result" do
-      @response.items.length.should == 3
-    end
-
-    it "should report that domain1.com is available" do
-      @response.items[1].available.should be_true
-    end
-
-    it "should report that domain2.com is not available" do
-      @response.items[2].available.should be_false
-    end
-
-    it "should report errors if there are any" do
-      @response.items[0].error.should == "750"
-    end
-
-    it "should include a description if there are errors" do
-      @response.items[0].description == "No response from the registry"
-    end
-  end
-
-  describe "failure response from namecheap" do 
-    before(:each) do
-      @bad_response_hash = {"ApiResponse"=>{"Status"=>"ERROR", 
-	      "Errors"=>{"Error"=>"API Key is invalid or API access has not been enabled"}, 
-	      "GMTTimeDifference"=>"--6:00", 
-	      "RequestedCommand"=>"namecheap.domains.check", 
-	      "Server"=>"SERVER159", 
-	      "ExecutionTime"=>"0.01", 
-	      "xmlns"=>"http://api.namecheap.com/xml.response"}}
-       
-
-      it "should return false if bad hash is returned" do
-        
-      end
-    end
-  end
-end
-
-  #<?xml version="1.0" encoding="utf-8"?>
-  # <ApiResponse Status="OK" xmlns="http://api.namecheap.com/xml.response">
-  #  <Errors />
-  #  <RequestedCommand>namecheap.domains.check</RequestedCommand>
-  #  <CommandResponse Type="namecheap.domains.check">
-  #    <DomainCheckResult Domain="domain1.com" Available="true" />
-  #    <DomainCheckResult Domain="availabledomain.com" Available="false" />
-  #    <DomainCheckResult Domain="err.tld" Available="error" ErrorNo="750" Description="No response from the registry" />
-  #  </CommandResponse>
-  #  <Server>SERVER-NAME</Server>
-  #  <GMTTimeDifference>+5</GMTTimeDifference>
-  #  <ExecutionTime>32.76</ExecutionTime>
-  #</ApiResponse>
-
-

data/spec/namecheap_response_spec.rb

@@ -1,25 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-require File.dirname(__FILE__) + '/../lib/namecheap'
-
-describe NamecheapResponse  do
-  before(:each) do
-    @bad_response_hash = {"ApiResponse"=>{"Status"=>"ERROR", 
-            "Errors"=>{"Error"=>"API Key is invalid or API access has not been enabled"}, 
-            "GMTTimeDifference"=>"--6:00", 
-            "RequestedCommand"=>"namecheap.domains.check", 
-            "Server"=>"SERVER159", 
-            "ExecutionTime"=>"0.01", 
-            "xmlns"=>"http://api.namecheap.com/xml.response"}} 
-  end
-
-  it "should return a status" do
-    response = NamecheapResponse.new(@bad_response_hash)
-    response.status.should == "ERROR"
-  end
-
-  it "should give error message for invalid api key when using an invalid key" do
-    response = NamecheapResponse.new(@bad_response_hash)
-    response.message.should include("API Key is invalid")
-  end
-end
-