pwhois 1.0.1 → 1.1.0

data/bin/pwhois

@@ -1,196 +1,8 @@
 #!/usr/bin/env ruby
 
-require 'optparse'
-require 'whois'
+require 'pwhois'
 
-class Symbol
-    def titleize()
-        to_s.split('_').map { |words| words.capitalize }.join(' ')
-    end
-end
-
-class WhoisParser
-    # Constants
-    UNKNOWN = "UNKNOWN"
-
-    # Class variables
-    @@OUTPUT_STYLES = [ :csv, :tsv, :table, :list ]
-
-    # Instance variables
-    attr_accessor :verbose, :output_style, :attributes
-
-    def self.output_styles
-        @@OUTPUT_STYLES
-    end # output_styles
-
-
-    def initialize()
-        @whois_client = Whois::Client.new
-        @verbose = false
-        @output_style = :list
-        @attributes = [:domain, :created_on, :updated_on, :registrar_name]
-    end # initialize()
-
-
-    def get_attr(record, attr)
-        if record == nil
-            raise(ArgumentError, ":record must not be nil")
-        end
-
-        obj,a = nil
-
-        if "#{attr}".start_with?("registrar")
-            a = "#{attr}".split('_')[1]
-            get_attr(record.registrar, a)
-        else
-            if record.respond_to?(attr)
-                record.send(attr)
-            else
-                raise(ArgumentError, "Warning:  attribute \"#{ attr }\" does not exist for this domain")
-            end
-        end
-    end # get_attr()
-
-
-    def query(q)
-        query_list([ q ])
-    end # query()
-
-
-    def query_list(querys)
-        print_header()
-
-        # only required for table listings.
-        results = []
-
-        querys.each do |q|
-            result = Hash.new
-            begin
-                print_verbose("Querying whois for #{q}...")
-                record = @whois_client.lookup(q)
-                if !record
-                    $stderr.puts "wtf just happened"
-                end
-
-                attributes.each do |a|
-                    begin
-                        result[a] = get_attr(record, a)
-                    rescue ArgumentError => e
-                        $stderr.puts e.message
-                    end
-                end
-
-                if output_style == :table
-                    results.push(result)
-                else
-                    print_item(result)
-                end
-            rescue Whois::ConnectionError => e
-                $stderr.puts e.message
-            rescue NoMethodError => e
-                $stderr.puts e.message
-                $stderr.puts e.backtrace
-            rescue SystemExit,Interrupt
-                print_verbose("Ctrl-C pressed, exiting")
-                exit
-            rescue StandardError => e
-                $stderr.puts e.message
-                $stderr.puts e.backtrace
-                exit
-            end
-        end # querys.each
-
-        if output_style == :table
-            print_table(results)
-        end
-    end # query_list()
-
-    
-    private
-    def print_verbose(msg)
-        if verbose
-            $stderr.puts("[ #{msg} ]")
-        end
-    end # verbose()
-
-
-    private
-    def quote_if_include(str, char)
-        if "#{str}".include?(char)
-            "\"#{str}\""
-        else
-            "#{str}"
-        end
-    end
-
-
-    private
-    def print_header()
-        case output_style
-        when :csv
-            puts attributes.map{ |a| quote_if_include(a.titleize, ',') }.join(',')
-        when :tsv
-            puts attributes.map{ |a| quote_if_include(a.titleize, "\t") }.join("\t")
-        when :table
-            print_verbose("collating data, please wait...")
-        end
-    end # print_header()
-
-    
-    private
-    def print_item(result)
-        case output_style
-        when :csv
-            puts attributes.map{ |a| quote_if_include(result[a], ',') }.join(',')
-        when :tsv
-            puts attributes.map{ |a| result[a] }.join("\t")
-        when :list
-            print_list_item(result)
-        end
-    end # print_item()
-
-
-    private
-    def print_list_item(result)
-        l = attributes.map{ |a| a.length }.sort.last
-        attributes.each do |a|
-            printf("%-#{l}s:\t%s\n", a.titleize, result[a])
-        end
-        puts
-    end # print_list_item()
-
-
-    private
-    def print_table(records)
-        attr_lengths = Hash.new
-        attributes.each do |a|
-            l = records.map{ |r| r[a].to_s.length }.sort.last
-            attr_lengths[a] = (a.length > l) ? a.length : l
-        end
-
-        # print the header row
-        attributes.each do |a|
-            printf("%-#{attr_lengths[a]}s  ", a.titleize)
-        end
-        printf("\n")
-        attributes.each do |a|
-            print '-' * attr_lengths[a]
-            print '  '
-        end
-        printf("\n")
-
-        records.each do |r|
-            attributes.each do |a|
-                printf("%-#{attr_lengths[a]}s  ", r[a])
-            end
-            printf("\n")
-        end
-    end # print_table()
-
-end # class WhoisParser
-
-
-w = WhoisParser.new
+w = Pwhois::WhoisParser.new
 
 OptionParser.new do |opts|
     opts.banner = "Usage: #{opts.program_name} [options]"
@@ -202,8 +14,8 @@ OptionParser.new do |opts|
         w.verbose = v
     end
 
-    output_list = WhoisParser.output_styles.join(', ')
-    opts.on("-o", "--output TYPE", WhoisParser.output_styles,
+    output_list = Pwhois::OUTPUT_STYLES.join(', ')
+    opts.on("-o", "--output TYPE", Pwhois::OUTPUT_STYLES,
             "Output style.  One of: #{output_list}") do |style|
         w.output_style = style
     end
@@ -222,10 +34,16 @@ OptionParser.new do |opts|
         exit
     end
 
-    #opts.on_tail("--version", "Show version") do
-        #puts ::Version.join('.')
-        #exit
-    #end
+    opts.on_tail("-V", "--version", "Show version") do
+        puts Pwhois::VERSION
+        exit
+    end
+
+    if ARGV.length == 0
+        puts "No domains given."
+        puts opts
+        exit
+    end
 end.parse!
 
 w.query_list(ARGV)

data/lib/pwhois.rb

@@ -0,0 +1,189 @@
+require 'optparse'
+require 'whois'
+require 'pwhois/version'
+
+class Symbol
+    def titleize()
+        to_s.split('_').map { |words| words.capitalize }.join(' ')
+    end
+end
+
+module Pwhois
+    OUTPUT_STYLES = [ :csv, :tsv, :table, :list ]
+
+    class WhoisParser
+        # Constants
+        UNKNOWN = "UNKNOWN"
+
+        # Instance variables
+        attr_accessor :verbose, :output_style, :attributes
+
+        def initialize()
+            @whois_client = Whois::Client.new
+            @verbose = false
+            @output_style = :list
+            @attributes = [:domain, :created_on, :updated_on, :registrar_name]
+        end # initialize()
+
+
+        def get_attr(record, attr)
+            if record == nil
+                raise(ArgumentError, ":record must not be nil")
+            end
+
+            if "#{attr}".start_with?("registrar")
+                if record.registrar != nil
+                    a = "#{attr}".split('_')[1]
+                    get_attr(record.registrar, a)
+                end
+            else
+                if record.respond_to?(attr)
+                    record.send(attr)
+                else
+                    raise(ArgumentError, "Warning:  attribute \"#{ attr }\" does not exist for this domain")
+                end
+            end
+        end # get_attr()
+
+
+        def query(q)
+            query_list([ q ])
+        end # query()
+
+
+        def query_list(querys)
+            print_header()
+
+            # only required for table listings.
+            results = []
+
+            querys.each do |q|
+                result = Hash.new
+                begin
+                    print_verbose("Querying whois for #{q}...")
+                    record = @whois_client.lookup(q)
+                    if !record
+                        $stderr.puts "wtf just happened"
+                    end
+
+                    attributes.each do |a|
+                        begin
+                            result[a] = get_attr(record, a)
+                        rescue ArgumentError => e
+                            $stderr.puts e.message
+                        end
+                    end
+
+                    if output_style == :table
+                        results.push(result)
+                    else
+                        print_item(result)
+                    end
+                rescue Whois::ConnectionError => e
+                    $stderr.puts e.message
+                rescue NoMethodError => e
+                    $stderr.puts e.message
+                    $stderr.puts e.backtrace
+                rescue Timeout::Error => e
+                    $stderr.puts "Timeout encountered retrieving data for #{q}"
+                rescue SystemExit,Interrupt
+                    print_verbose("Ctrl-C pressed, exiting")
+                    exit
+                rescue StandardError => e
+                    $stderr.puts e.message
+                    $stderr.puts e.backtrace
+                    exit
+                end
+            end # querys.each
+
+            if output_style == :table
+                print_table(results)
+            end
+        end # query_list()
+
+
+        private
+        def print_verbose(msg)
+            if verbose
+                $stderr.puts("[ #{msg} ]")
+            end
+        end # verbose()
+
+
+        private
+        def quote_if_include(str, char)
+            if "#{str}".include?(char)
+                "\"#{str}\""
+            else
+                "#{str}"
+            end
+        end
+
+
+        private
+        def print_header()
+            case output_style
+            when :csv
+                puts attributes.map{ |a| quote_if_include(a.titleize, ',') }.join(',')
+            when :tsv
+                puts attributes.map{ |a| quote_if_include(a.titleize, "\t") }.join("\t")
+            when :table
+                print_verbose("collating data, please wait...")
+            end
+        end # print_header()
+
+
+        private
+        def print_item(result)
+            case output_style
+            when :csv
+                puts attributes.map{ |a| quote_if_include(result[a], ',') }.join(',')
+            when :tsv
+                puts attributes.map{ |a| result[a] }.join("\t")
+            when :list
+                print_list_item(result)
+            end
+        end # print_item()
+
+
+        private
+        def print_list_item(result)
+            l = attributes.map{ |a| a.length }.sort.last
+            attributes.each do |a|
+                printf("%-#{l}s:\t%s\n", a.titleize, result[a])
+            end
+            puts
+        end # print_list_item()
+
+
+        private
+        def print_table(records)
+            attr_lengths = Hash.new
+            attributes.each do |a|
+                l = records.map{ |r| r[a].to_s.length }.sort.last
+                attr_lengths[a] = (a.length > l) ? a.length : l
+            end
+
+            # print the header row
+            attributes.each do |a|
+                printf("%-#{attr_lengths[a]}s  ", a.titleize)
+            end
+            printf("\n")
+            attributes.each do |a|
+                print '-' * attr_lengths[a]
+                print '  '
+            end
+            printf("\n")
+
+            records.each do |r|
+                attributes.each do |a|
+                    printf("%-#{attr_lengths[a]}s  ", r[a])
+                end
+                printf("\n")
+            end
+        end # print_table()
+
+    end # class WhoisParser
+
+
+end

data/lib/pwhois/version.rb

@@ -0,0 +1,8 @@
+module Pwhois
+    module Version
+        MAJOR = 1
+        MINOR = 1
+        TINY  = 0
+    end
+    VERSION = [Version::MAJOR, Version::MINOR, Version::TINY].compact * '.'
+end

data/pwhois.gemspec

@@ -1,15 +1,25 @@
 # coding: utf-8
+require File.expand_path('../lib/pwhois/version', __FILE__)
+
 Gem::Specification.new do |spec|
   spec.name          = "pwhois"
-  spec.version       = "1.0.1"
+  spec.version       = Pwhois::VERSION
   spec.authors       = ["Seth Wright"]
   spec.email         = ["seth@crosse.org"]
 
-  spec.summary       = %q{Parse whois results and display them in a coherent style.}
+  spec.summary       = %q{A WHOIS client that provides consistent and coherent results.}
+  spec.description   = <<-EOF
+    pwhois is a small command-line utility that takes advantage of the
+    whois module to parse WHOIS results and display them in a
+    consistent, coherent style.
+  EOF
   spec.homepage      = "https://github.com/Crosse/pwhois"
   spec.license       = "ISC"
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.executables   = ["pwhois"]
-  spec.add_runtime_dependency "whois"
+  spec.files         = `git ls-files`.split($\)
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.executables   = spec.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+
+  spec.require_paths = ["lib"]
+  spec.add_runtime_dependency 'whois', '~>3.6'
 end