name_checker 0.0.1

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+*.swp
+*.swo
+.DS_Store

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 David Tuite
+
+MIT License
+
+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,66 @@
+# NameChecker
+
+NameChecker makes it easy to check the availability of a word across various
+top-level domains and social networks.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'name_checker'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install name_checker
+
+## Usage
+
+    availability = NameChecker.check("github", "twitter")
+    availability.text
+    #=> "github"
+    availability.available?
+    #=> false
+
+    # NOTE: It is important to include the period at the start 
+    # of the TLD when checking hosts.
+    availability = NameChecker.check("availabledomain", ".net")
+    availability.text
+    #=> "availabledomain.net"
+    availability.available?
+    #=> true
+
+## Checking Hosts
+
+Domain availability checking can occur either with the [Whois Gem](http://bit.ly/KYquaW)
+(default) or via the [RoboWhois API](http://bit.ly/KYqveX).
+
+To use the RoboWhois service, simply configure NameChecker with an API key.
+
+    NameChecker.config do |config|
+      config.robo_whois_api_key = 'jdsfldsjflkj'
+    end
+
+All domain availability requests will then route through RoboWhois.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Running the Specs
+
+You will need to add a RoboWhois Api Key to `spec/spec_helper.rb` to be
+able to run all of the specs. Set it up like this:
+
+    # Add your robo whois api key here:
+    ROBO_WHOIS_API_KEY = 'YOUR_KEY'
+
+You can still run the specs without an API key. However, all specs related
+to the RoboWhoisChecker will fail.

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/name_checker.rb

@@ -0,0 +1,27 @@
+require "name_checker/version"
+
+require "httparty"
+require "whois"
+require "name_checker/logging"
+require "name_checker/configuration"
+require "name_checker/availability"
+require "name_checker/twitter_checker"
+require "name_checker/facebook_checker"
+require "name_checker/robo_whois_checker"
+require "name_checker/whois_checker"
+require "name_checker/net_checker"
+
+module NameChecker
+  def self.check(text, service_name)
+    # NOTE: Symbols are not good for detecting the service name.
+    # Sometimes it might be 'co.uk'.
+    case service_name
+    when 'twitter' then TwitterChecker.check(text)
+    when 'facebook' then FacebookChecker.check(text)
+    # If not Twitter or Facebook then assume that the service
+    # name is that of a TLD (like :com or :co.uk) and pass it to the
+    # default net service checker.
+    else NetChecker.check(text, service_name)
+    end
+  end
+end

data/lib/name_checker/availability.rb

@@ -0,0 +1,39 @@
+module NameChecker
+  class Availability
+    attr_reader :status, :service
+
+    def initialize(service, status_input)
+      @service = service.to_s
+      @status = parse_status(status_input)
+    end
+
+    def to_s
+      "#{service}: #{status}"
+    end
+
+    def available?
+      status == "available"
+    end
+
+    def unavailable?
+      status == "unavailable"
+    end
+    
+    def unknown?
+      status == "unknown"
+    end
+
+    def status=(status_input)
+      @status ||= parse_status(status_input)
+    end
+
+    private 
+      def parse_status(status_input)
+        case status_input
+        when true then "available"
+        when false then "unavailable"
+        else "unknown"
+        end
+      end
+  end
+end

data/lib/name_checker/configuration.rb

@@ -0,0 +1,30 @@
+# Enable setting and getting of configuration options.
+#
+# Example:
+#
+#   This can now be used under config/initializers/name_checker.rb
+#   NameChecker.configure do |config|
+#     config.robo_whois_api_key = 'dfskljkf'
+#   end
+
+module NameChecker
+  class Configuration
+    DEFAULT_LOG_LEVEL = 'info'
+    DEFAULT_ROBO_WHOIS_API_KEY = nil
+
+    attr_accessor :robo_whois_api_key, :log_level
+
+    def initialize
+      self.log_level = DEFAULT_LOG_LEVEL
+      self.robo_whois_api_key = DEFAULT_ROBO_WHOIS_API_KEY
+    end
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield configuration
+  end
+end

data/lib/name_checker/facebook_checker.rb

@@ -0,0 +1,37 @@
+module NameChecker
+  class FacebookChecker
+    include HTTParty
+    include Logging
+    MIN_NAME_LENGTH = 5
+    base_uri "https://graph.facebook.com"
+    @service_name = :facebook
+
+    def self.check(name, options = {})
+      # just return false if the name is too short to be valid.
+      if name.length < MIN_NAME_LENGTH
+        return Availability.new(@service_name, false)
+      end
+
+      res = get("/#{name}")
+      status = handle_response(res, name)
+      Availability.new(@service_name, status)
+    end
+
+  private
+
+    def self.log_warning(name, res)
+      warning = "#{@service_name.upcase}_FAILURE: Handling #{name}. Response: #{res}"
+      Logging.logger.warn(warning)
+      # Nil return must be explicit because the logging will return true.
+      return nil
+    end
+
+    def self.handle_response(res, name)
+      case res.code
+      when 200 then false
+      when 404 then true
+      else log_warning(name, res)
+      end
+    end
+  end
+end

data/lib/name_checker/logging.rb

@@ -0,0 +1,26 @@
+require "logger"
+
+module Logging
+  def logger
+    Logging.logger
+  end
+
+  def self.logger
+    unless @logger
+      @logger = Logger.new(STDOUT)
+      @logger.level = Logging.infer_level
+    end
+    @logger
+  end
+
+  # infer a suitable Log level from the ENVIRONMENT variable
+  # Can pass in an environment value for testing purposes
+  def self.infer_level(level = nil)
+    level = level || NameChecker.configuration.log_level
+    case level
+    when 'debug' then Logger::DEBUG
+    when 'warn' then Logger::WARN
+    else Logger::INFO # default
+    end
+  end
+end

data/lib/name_checker/net_checker.rb

@@ -0,0 +1,15 @@
+module NameChecker
+  class NetChecker
+    def self.check(host_name, tld)
+      host = host_name + tld
+
+      # Use the RoboWhoisChecker if there is an API key set.
+      if NameChecker.configuration.robo_whois_api_key
+        RoboWhoisChecker.check(host)
+      # Or use the WhoisChecker if there isn't (default).
+      else
+        WhoisChecker.check(host)
+      end
+    end
+  end
+end

data/lib/name_checker/railties.rb

@@ -0,0 +1,7 @@
+module NameChecker
+  class Railties < ::Rails::Railtie
+    initializer 'Rails logger' do
+      NameChecker::Logging.logger = Rails.logger
+    end
+  end
+end

data/lib/name_checker/robo_whois_checker.rb

@@ -0,0 +1,61 @@
+module NameChecker
+  class NoAPIKeyError < ArgumentError; end
+
+  class RoboWhoisChecker
+    include HTTParty
+    include Logging
+    base_uri 'http://api.robowhois.com'
+    @service_name = :robo_whois
+
+    def self.check(host, options={})
+      options.merge!(basic_auth: auth_options)
+
+      # NOTE: RoboWhois will return 404 if I append ".json".
+      res = get("/whois/#{host}/availability", options)
+      status = handle_response(res, host)
+      Availability.new(@service_name, status)
+    end
+
+    # NOTE: We can't use the 'basic_auth' method because the
+    # configuration object is not available at the class level.
+    def self.auth_options
+      # raise NoAPIKeyError unless NameChecker.configuration.robo_whois_api_key
+
+      { password: 'X',
+        username: NameChecker.configuration.robo_whois_api_key }
+    end
+
+    def self.warning_limit
+      50
+    end
+
+  private
+    def self.log_warning(name, res)
+      warning = "#{@service_name.upcase}_FAILURE: Handling #{name}. Response: #{res}"
+      Logging.logger.warn(warning)
+      # Nil return must be explicit because the logging will return true.
+      return nil
+    end
+
+    def self.handle_response(res, host)
+      log_remaining_credits(res.headers["X-Creditlimit-Remaining"])
+      case res.code
+      when 200 then res["response"]["available"]
+      else log_warning(host, res)
+      end
+    end
+
+    def self.log_remaining_credits(remaining_count)
+      # INFO: Some responses might not have the header available.
+      unless remaining_count and remaining_count.to_i < warning_limit
+        return nil
+      end
+
+      warning = "RATELIMIT_WARNING: Service #{@service_name}. 
+Remaining credits: #{remaining_count}"
+      Logging.logger.warn(warning)
+      # Nil return must be explicit because the logging will return true.
+      return nil
+    end
+  end
+end

data/lib/name_checker/twitter_checker.rb

@@ -0,0 +1,67 @@
+# NOTE: This is rate limited to 150 requests per hour.
+# TODO: Add OAuth or some other authentication in order
+# to get my request limit rate increased.
+
+module NameChecker
+  class TwitterChecker
+    include HTTParty
+    include Logging
+    MAX_NAME_LENGTH = 16
+    base_uri "http://api.twitter.com"
+    @service_name = :twitter
+
+    def self.check(screen_name, options = {})
+      # Just return false if the suggestion exceeds the max allowed SN length.
+      if screen_name.length > MAX_NAME_LENGTH
+        return Availability.new(@service_name, false)
+      end
+
+      # Carry on with the availability checking.
+      options.merge!( query: { screen_name: screen_name } )
+      res = get("/1/users/show.json", options)
+      status = handle_response(res, screen_name)
+      Availability.new(@service_name, status)
+    end
+
+    def self.warning_limit
+      20
+    end
+
+  private
+    def self.handle_response(res, screen_name)
+      log_rate_limit(res.headers["x-ratelimit-remaining"])
+
+      # Twitter response codes:
+      # INFO: https://dev.twitter.com/docs/error-codes-responses
+      # 403 = Forbidden. Can be for a couple of reasons.
+      case res.code
+      when 200 then false
+      when 403 then parse_403(screen_name, res)
+      # Name is available if the request is not found
+      when 404 then true
+      else log_warning(screen_name, res)
+      end
+    end
+
+    def self.log_warning(name, res)
+      warning = "#{@service_name.upcase}_FAILURE: Handling #{name}. Response: #{res}"
+      Logging.logger.warn(warning)
+      # Nil return must be explicit because the logging will return true.
+      return nil
+    end
+
+    def self.log_rate_limit(remaining)
+      return nil if remaining.to_i > warning_limit
+      warning = "RATELIMIT_WARNING: Service #{@service_name}. Remaining requests: #{remaining}"
+      Logging.logger.warn(warning)
+      # Nil return must be explicit because the logging will return true.
+      return nil
+    end
+
+    def self.parse_403(name, res)
+      return false if res["error"] =~ /suspended/
+      # Something we hadn't intended happened if we reach this point
+      log_warning(name, res)
+    end
+  end
+end