Merge pull request #85 from ManageIQ/logging

Add preliminary logger support

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 = []
@@ -254,7 +260,8 @@ def print_dep(tgt, dep, versions)
     exit 1
   end
 
-  gemfile.dependency_versions do |tgt, dep, versions|
+  gemfile.dependency_versions :recursive => true,
+                              :dev_deps  => conf[:devel_deps] do |tgt, dep, versions|
     print_dep(tgt, dep, versions)
   end
 end

lib/polisher/git/pkg.rb

@@ -23,6 +23,10 @@ class Pkg < Repo
         conf_attr :dist_git_url, 'git://pkgs.fedoraproject.org/'
         conf_attr :fetch_tgt,    'master'
 
+        def self.fetch_tgts
+          [fetch_tgt].flatten
+        end
+
         def initialize(args={})
           @name    = args[:name]
           @version = args[:version]
@@ -93,10 +97,11 @@ def dead?
         end
 
         # Clone / init GitPkg
-        def fetch
+        def fetch(target = nil)
+          target = self.class.fetch_tgts.first if target.nil?
           clone unless cloned?
           raise Exception, "Dead package detected" if dead?
-          checkout fetch_tgt
+          checkout target
           reset!
           pull
 
@@ -168,25 +173,28 @@ def build
           self
         end
 
-        # Retrieve list of the version of the specified package in git
+        # Retrieve list of the versions of the specified package in git
         #
         # @param [String] name name of package to lookup
         # @param [Callable] bl optional block to invoke with version retrieved
-        # @return [String] version retrieved, or nil if none found
-        def self.version_for(name, &bl)
+        # @return [Array<String>] versions retrieved, or empty array if none found
+        def self.versions_for(name, &bl)
           version = nil
           gitpkg = self.new :name => name
           gitpkg.url = "#{dist_git_url}#{gitpkg.rpm_name}.git"
-          gitpkg.git_clone
-          begin
-            version = gitpkg.spec.version
-          rescue => e
+          versions = []
+          fetch_tgts.each do |tgt|
+            begin
+              gitpkg.fetch tgt
+              versions << gitpkg.spec.version
+            rescue
+            end
           end
 
-          bl.call(:git, name, [version]) unless(bl.nil?)
-          version
+          bl.call(:git, name, versions) unless(bl.nil?)
+          versions
         end
       end # module Pkg
-    end # Component.verify("Git::Pkgrrata")
+    end # Component.verify("Git::Pkg")
   end # module Git
 end # module Polisher

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.version_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

spec/git_spec.rb

@@ -358,37 +358,36 @@ module Polisher
       end
     end
 
-    describe "#version_for" do
-      it "uses git to retrieve the package" do
-        pkg = "#{described_class.dist_git_url}rubygem-rails.git"
-        dir = Polisher::GitCache.path_for('rubygem-rails')
-        expected = "/usr/bin/git clone #{pkg} #{dir}"
-        AwesomeSpawn.should_receive(:run!).with(expected)
-        described_class.version_for 'rails'
+    describe "#versions_for" do
+      it "git fetches the package" do
+        pkg = described_class.new
+        described_class.should_receive(:new)
+                       .with(:name => 'rails')
+                       .and_return(pkg)
+        pkg.should_receive(:fetch).with(described_class.fetch_tgt)
+        described_class.versions_for 'rails'
       end
 
       it "returns version of the package" do
-        AwesomeSpawn.should_receive(:run!) # stub out run
-
         spec = Polisher::RPM::Spec.new :version => '1.0.0'
         pkg  = described_class.new
+        pkg.should_receive(:fetch) # stub out fetch
         described_class.should_receive(:new).and_return(pkg)
         pkg.should_receive(:spec).and_return(spec)
 
-        described_class.version_for('rails').should == '1.0.0'
+        described_class.versions_for('rails').should == ['1.0.0']
       end
 
       it "invokes callback with version of package" do
-        AwesomeSpawn.should_receive(:run!) # stub out run
-
         spec = Polisher::RPM::Spec.new :version => '1.0.0'
         pkg  = described_class.new
+        pkg.should_receive(:fetch) # stub out fetch
         described_class.should_receive(:new).and_return(pkg)
         pkg.should_receive(:spec).and_return(spec)
 
         cb = proc {}
         cb.should_receive(:call).with(:git, 'rails', ['1.0.0'])
-        described_class.version_for('rails', &cb)
+        described_class.versions_for('rails', &cb)
       end
     end
   end # describe Git::Pkg