Add preliminary logger support

Log Polisher::VersionChecker targets as they are queried and
their results come in

Implements a simple shared wrapper around the ruby logger
class w/ mechanism to set log level from symbol/string

bin/gem_dependency_checker.rb

@@ -23,6 +23,7 @@
 ##########################################################
 
 conf = {:format         => nil,
+        :log_level      => :info,
         :gemfile        => './Gemfile',
         :gemspec        => nil,
         :gemname        => nil,
@@ -48,6 +49,10 @@
     conf[:format] = f
   end
 
+  opts.on("--log-level level", "Log verbosity") do |l|
+    conf[:log_level] = l.intern
+  end
+
   opts.on('--gemfile file', 'Location of the gemfile to parse') do |g|
     conf[:gemfile] = g
   end
@@ -123,6 +128,7 @@
    end
 end
 
+Polisher::Logging.level = conf[:log_level]
 Polisher::Config.set
 
 targets = []

lib/polisher/logger.rb

@@ -0,0 +1,23 @@
+# Polisher Logging Module
+#
+# Licensed under the MIT license
+# Copyright (C) 2014 Red Hat, Inc.
+
+module Polisher
+  module Logging
+    # This is the magical bit that gets mixed into your classes
+    def logger
+      Logging.logger
+    end
+
+    # Set the log level
+    def self.level=(level)
+      logger.level = Logger.const_get(level.to_s.upcase)
+    end
+
+    # Global, memoized, lazy initialized instance of a logger
+    def self.logger
+      @logger ||= Logger.new(STDOUT)
+    end
+  end # module Logging
+end # module Polisher

lib/polisher/version_checker.rb

@@ -4,9 +4,12 @@
 # Copyright (C) 2013-2014 Red Hat, Inc.
 
 require 'polisher/gem'
+require 'polisher/logger'
 
 module Polisher
   class VersionChecker
+    extend Logging
+
     GEM_TARGET    = :gem
     KOJI_TARGET   = :koji
     FEDORA_TARGET = :fedora
@@ -40,59 +43,86 @@ def self.versions_for(name, &bl)
       versions = {}
 
       if should_check?(GEM_TARGET)
-        versions.merge! :gem => Gem.local_versions_for(name, &bl)
+        logger.debug "versions_for<gem>(#{name})..."
+        gem_versions = Gem.local_versions_for(name, &bl)
+        logger.debug gem_versions
+        versions.merge! :gem => gem_versions
       end
 
       if should_check?(FEDORA_TARGET)
         begin
           require 'polisher/fedora'
-          versions.merge! :fedora => Fedora.versions_for(name, &bl)
+          logger.debug "versions_for<fedora>(#{name})..."
+          fedora_versions = Fedora.versions_for(name, &bl)
+          logger.debug fedora_versions
+          versions.merge! :fedora => fedora_versions
         rescue
+          logger.debug 'unknown'
           versions.merge! :fedora => unknown_version(:fedora, name, &bl)
         end
       end
 
       if should_check?(KOJI_TARGET)
         begin
           require 'polisher/koji'
-          versions.merge! :koji => Koji.versions_for(name, &bl)
+          logger.debug "versions_for<koji>(#{name})..."
+          koji_versions = Koji.versions_for(name, &bl)
+          logger.debug koji_versions
+          versions.merge! :koji => koji_versions
         rescue
+          logger.debug 'unknown'
           versions.merge! :koji => unknown_version(:koji, name, &bl)
         end
       end
 
       if should_check?(GIT_TARGET)
         begin
           require 'polisher/git/pkg'
-          versions.merge! :git => Git::Pkg.versions_for(name, &bl)
+          logger.debug "versions_for<git>(#{name})..."
+          git_versions = Git::Pkg.versions_for(name, &bl)
+          logger.debug git_versions
+          versions.merge! :git => git_versions
         rescue
+          logger.debug 'unknown'
           versions.merge! :git => unknown_version(:git, name, &bl)
         end
       end
 
       if should_check?(YUM_TARGET)
         begin
           require 'polisher/yum'
-          versions.merge! :yum => [Yum.version_for(name, &bl)]
+          logger.debug "versions_for<yum>(#{name})..."
+          yum_versions = [Yum.version_for(name, &bl)]
+          versions.merge! :yum => yum_versions
+          logger.debug yum_versions
         rescue
+          logger.debug 'unknown'
           versions.merge! :yum => unknown_version(:yum, name, &bl)
         end
       end
 
       if should_check?(BODHI_TARGET)
         begin
           require 'polisher/bodhi'
-          versions.merge! :bodhi => Bodhi.versions_for(name, &bl)
+          logger.debug "versions_for<bodhi>(#{name})..."
+          bodhi_versions = Bodhi.versions_for(name, &bl)
+          versions.merge! :bodhi => bodhi_versions
+          logger.debug bodhi_versions
         rescue
+          logger.debug 'unknown'
           versions.merge! :bodhi => unknown_version(:bodhi, name, &bl)
         end
       end
 
       if should_check?(ERRATA_TARGET)
         begin
           require 'polisher/errata'
-          versions.merge! :errata => Errata.versions_for(name, &bl)
+          logger.debug "versions_for<errata>(#{name})..."
+          errata_versions = Errata.versions_for(name, &bl)
+          versions.merge! :errata => errata_versions
+          logger.debug errata_versions
         rescue
+          logger.debug 'unknown'
           versions.merge! :errata => unknown_version(:errata, name, &bl)
         end
       end