polisher 0.9.1 → 0.10.1

data/lib/polisher/tag_mapper.rb

@@ -0,0 +1,27 @@
+# Polisher Tag Mapper, simple mechanism to associate
+# tags with each other
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+require 'polisher/core'
+
+module Polisher
+  class TagMapper
+    extend ConfHelpers
+
+    def self.method_missing(id, *args)
+      set(id.to_s, args.first)
+    end
+
+    def self.set(tag, value)
+      @tags ||= {}
+      @tags[tag] = value
+    end
+
+    def self.map(tag)
+      @tags ||= {}
+      @tags[tag]
+    end
+  end # class TagMapper
+end # module Polisher

data/lib/polisher/version.rb

@@ -1,3 +1,3 @@
 module Polisher
-  VERSION = "0.9.1"
+  VERSION = "0.10.1"
 end

data/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
@@ -20,7 +23,7 @@ module Polisher
     # Enable the specified target(s) in the list of target to check
     def self.check(*target)
       @check_list ||= []
-      target.each { |t| @check_list << t }
+      target.flatten.each { |t| @check_list << t }
     end
 
     def self.should_check?(target)
@@ -40,37 +43,88 @@ module Polisher
       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)
-        require 'polisher/fedora'
-        versions.merge! :fedora => Fedora.versions_for(name, &bl)
+        begin
+          require 'polisher/fedora'
+          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)
-        require 'polisher/koji'
-        versions.merge! :koji => Koji.versions_for(name, &bl)
+        begin
+          require 'polisher/koji'
+          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)
-        require 'polisher/git/pkg'
-        versions.merge! :git => [Git::Pkg.version_for(name, &bl)]
+        begin
+          require 'polisher/git/pkg'
+          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)
-        require 'polisher/yum'
-        versions.merge! :yum => [Yum.version_for(name, &bl)]
+        begin
+          require 'polisher/yum'
+          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)
-        require 'polisher/bodhi'
-        versions.merge! :bodhi => Bodhi.versions_for(name, &bl)
+        begin
+          require 'polisher/bodhi'
+          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)
-        require 'polisher/errata'
-        versions.merge! :errata => Errata.versions_for(name, &bl)
+        begin
+          require 'polisher/errata'
+          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
 
       versions
@@ -81,7 +135,12 @@ module Polisher
     # returns the max.
     def self.version_for(name)
       versions = self.versions_for(name).values
-      versions.inject(Hasn.new(0)) { |total, i| total[i] += 1; total }.first
+      versions.inject(Hash.new(0)) { |total, i| total[i] += 1; total }.first
+    end
+
+    # Invoke block for specified target w/ an 'unknown' version
+    def self.unknown_version(tgt, name)
+      yield tgt, name, [:unknown]
     end
   end
 
@@ -98,11 +157,21 @@ module Polisher
     def dependency_versions(args = {}, &bl)
       args = {:recursive => true, :dev_deps  => true}.merge(args)
       versions = {}
-      self.deps.each do |dep|
-        gem = Polisher::Gem.retrieve(dep)
+      deps.each do |dep|
+        gem = Polisher::Gem.retrieve(dep.name)
         versions.merge!(gem.versions(args, &bl))
       end
       versions
     end
+
+    # Return list of states which gem dependencies are in
+    def dependency_states
+      states = {}
+      deps.each do |dep|
+        gem = Polisher::Gem.new :name => dep.name
+        states.merge dep.name => gem.state(:check => dep)
+      end
+      states
+    end
   end
 end

data/lib/polisher/yum.rb

@@ -3,28 +3,35 @@
 # Licensed under the MIT license
 # Copyright (C) 2013-2014 Red Hat, Inc.
 
-require 'awesome_spawn'
+require 'polisher/core'
+require 'polisher/component'
 
 module Polisher
-  class Yum
-    YUM_CMD = '/usr/bin/yum'
+  Component.verify("Yum", 'awesome_spawn') do
+    class Yum
+      include ConfHelpers
 
-    # Retrieve version of gem available in yum
-    #
-    # @param [String] name name of gem to loopup
-    # @param [Callable] bl optional callback to invoke with version retrieved
-    # @returns [String] version of gem in yum or nil if not found
-    def self.version_for(name, &bl)
-      version = nil
-      result  = AwesomeSpawn.run "#{YUM_CMD} info rubygem-#{name}"
-      out = result.output
+      conf_attr :yum_cmd, '/usr/bin/yum'
 
-      if out.include?("Version")
-        version = out.lines.to_a.find { |l| l =~ /^Version.*/ }
-        version = version.split(':').last.strip
+      # Retrieve version of gem available in yum
+      #
+      # @param [String] name name of gem to loopup
+      # @param [Callable] bl optional callback to invoke with version retrieved
+      # @returns [String] version of gem in yum or nil if not found
+      def self.version_for(name, &bl)
+        require_cmd! yum_cmd
+
+        version = nil
+        result  = AwesomeSpawn.run "#{yum_cmd} info rubygem-#{name}"
+        out = result.output
+
+        if out.include?("Version")
+          version = out.lines.to_a.detect { |l| l =~ /^Version.*/ }
+          version = version.split(':').last.strip
+        end
+        bl.call(:yum, name, [version]) unless bl.nil?
+        version
       end
-      bl.call(:yum, name, [version]) unless(bl.nil?) 
-      version
     end
-  end
-end
+  end # Component.verify("Yum")
+end # module Polisher

data/spec/component_spec.rb

@@ -0,0 +1,53 @@
+require 'polisher/component'
+
+module Polisher
+  describe Component do
+    describe ".verify" do
+      it "executes block for no missing gems" do
+        silence_stream(STDERR) do
+          described_class.verify("Z", "rubygems", "rspec") do
+            module ::Polisher
+              class Z
+                def self.yielded_block_executed
+                  true
+                end
+              end
+            end
+          end
+        end
+
+        expect(Polisher::Z.yielded_block_executed).to be_true
+      end
+
+      describe "missing" do
+        subject do
+          silence_stream(STDERR) do
+            described_class.verify(@test_class, "missing_gem") {}
+          end
+        end
+
+        it "A" do
+          @test_class = "A"
+          subject
+          expect(Polisher::A).to eql Polisher::Component::Missing
+          expect { Polisher::A.new }.to raise_error
+        end
+
+        it "A::B" do
+          @test_class = "A::B"
+          subject
+          expect(Polisher::A).to eql Polisher::Component::Missing
+          expect(Polisher::A::B).to eql Polisher::Component::Missing
+        end
+
+        it "A::B::C" do
+          @test_class = "A::B::C"
+          subject
+          expect(Polisher::A).to eql Polisher::Component::Missing
+          expect(Polisher::A::B).to eql Polisher::Component::Missing
+          expect(Polisher::A::B::C).to eql Polisher::Component::Missing
+        end
+      end
+    end
+  end
+end

data/spec/core_spec.rb

@@ -60,5 +60,11 @@ describe String do
     it "returns string with rpm macros swapped in" do
       "bin".rpmize.should == "%{_bindir}"
     end
+
+    it "prefixes %{gem_instdir} to non-special files" do
+      "spec".rpmize.should == "%{gem_instdir}/spec"
+      "lib".rpmize.should == "%{gem_libdir}"
+      "%{gem_instdir}/foo".rpmize.should == "%{gem_instdir}/foo"
+    end
   end
 end # describe String

data/spec/gem_spec.rb

@@ -9,12 +9,20 @@ require 'polisher/gem'
 
 module Polisher
   describe Gem do
+    describe "#file_name" do
+      it "returns name-version.gem" do
+        expected = 'rails-4.0.0.gem'
+        Polisher::Gem.new(:name => 'rails', :version => '4.0.0')
+                     .file_name.should == expected
+      end
+    end
+
     describe "#initialize" do
       it "sets gem attributes" do
-        gem = Polisher::Gem.new :name => 'rails',
-                                :version => '4.0.0',
-                                :deps => ['activesupport', 'activerecord'],
-                                :dev_deps => ['rake']
+        gem = described_class.new :name     => 'rails',
+                                  :version  => '4.0.0',
+                                  :deps     => %w(activesupport activerecord),
+                                  :dev_deps => ['rake']
         gem.name.should == 'rails'
         gem.version.should == '4.0.0'
         gem.deps.should == ['activesupport', 'activerecord']
@@ -25,33 +33,67 @@ module Polisher
     describe "#ignorable_file?" do
       context "args matches an ignorable file" do
         it "returns true" do
-          Polisher::Gem.ignorable_file?('foo.gemspec').should be_true
-          Polisher::Gem.ignorable_file?('Gemfile').should be_true
+          described_class.ignorable_file?('foo.gemspec').should be_true
+          described_class.ignorable_file?('Gemfile').should be_true
         end
       end
 
       context "args does not match an ignorable file" do
         it "returns false" do
-          Polisher::Gem.ignorable_file?('.rvmra').should be_false
-          Polisher::Gem.ignorable_file?('foo.gemspoc').should be_false
+          described_class.ignorable_file?('.rvmra').should be_false
+          described_class.ignorable_file?('foo.gemspoc').should be_false
+        end
+      end
+    end
+
+    describe "#doc_file?" do
+      context "file is on doc file list" do
+        it "returns true" do
+          described_class.doc_file?('CHANGELOG').should be_true
+        end
+      end
+
+      context "file is not on doc file list" do
+        it "returns false" do
+          described_class.doc_file?('foobar.rb').should be_false
         end
       end
     end
 
     describe "#local_versions_for" do
-      it "returns versions of specified gem in local db"
-      it "invokes cb with versions retrieved"
+      before(:each) do
+        # XXX clear the cached version of the gem specification db
+        described_class.instance_variable_set(:@local_db, nil)
+
+        gem1 = ::Gem::Specification.new 'rake', '1.0'
+        gem2 = ::Gem::Specification.new 'rake', '2.0'
+        gem3 = ::Gem::Specification.new 'rails', '3.0'
+        ::Gem::Specification.should_receive(:all).and_return([gem1, gem2, gem3])
+
+        @version1 = ::Gem::Version.new '1.0'
+        @version2 = ::Gem::Version.new '2.0'
+      end
+
+      it "returns versions of specified gem in local db" do
+        described_class.local_versions_for('rake').should == [@version1, @version2]
+      end
+
+      it "invokes cb with versions retrieved" do
+        cb = proc {}
+        cb.should_receive(:call).with(:local_gem, 'rake', [@version1, @version2])
+        described_class.local_versions_for('rake', &cb)
+      end
     end
 
     describe "#parse" do
       it "returns new gem" do
-        gem = Polisher::Gem.parse
-        gem.should be_an_instance_of(Polisher::Gem)
+        gem = described_class.parse
+        gem.should be_an_instance_of(described_class)
       end
 
       it "parses gem from gem spec" do
         spec = Polisher::Test::GEM_SPEC
-        gem  = Polisher::Gem.parse(:gemspec => spec[:path])
+        gem  = described_class.parse(:gemspec => spec[:path])
         gem.name.should     == spec[:name]
         gem.version.should  == spec[:version]
         gem.deps.should     == spec[:deps]
@@ -62,7 +104,7 @@ module Polisher
 
       it "parses gem from metadata hash" do
         gemj = Polisher::Test::GEM_JSON
-        gem = Polisher::Gem.parse gemj[:json]
+        gem = described_class.parse gemj[:json]
         gem.name.should     == gemj[:name]
         gem.version.should  == gemj[:version]
         gem.deps.should     == gemj[:deps]
@@ -70,45 +112,103 @@ module Polisher
       end
     end
 
+    describe "#remote_versions_for" do
+      it "retrieves versions from rubygems.org" do
+        curl = Curl::Easy.new
+        described_class.should_receive(:client)
+                       .at_least(:once).and_return(curl)
+        curl.should_receive(:http_get)
+
+        # actual output too verbose, just including bits we need
+        curl.should_receive(:body_str)
+            .and_return([{'number' => 1.1}, {'number' => 2.2}].to_json)
+        described_class.remote_versions_for('polisher').should == [1.1, 2.2]
+        curl.url.should == "https://rubygems.org/api/v1/versions/polisher.json"
+      end
+    end
+
+    describe "#lastest_version_of" do
+      it "retrieves latests version of gem available on rubygems.org" do
+        described_class.should_receive(:remote_versions_for)
+                       .with('polisher')
+                       .and_return([2.2, 1.1])
+        described_class.latest_version_of('polisher').should == 2.2
+      end
+    end
 
     describe "#download_gem" do
       context "gem in GemCache" do
-        it "returns GemCache gem"
+        it "returns GemCache gem" do
+          gem = described_class.new
+          GemCache.should_receive(:get).with('polisher', '1.1')
+                                       .and_return(gem)
+          described_class.download_gem('polisher', '1.1').should == gem
+        end
+      end
+
+      it "uses curl to download gem" do
+        GemCache.should_receive(:get).and_return(nil)
+        curl = Curl::Easy.new
+        described_class.should_receive(:client)
+                       .at_least(:once).and_return(curl)
+        curl.should_receive(:http_get)
+        curl.should_receive(:body_str).and_return('') # stub out body_str
+
+        described_class.download_gem 'polisher', '2.2'
+        curl.url.should == "https://rubygems.org/gems/polisher-2.2.gem"
+      end
+
+      it "sets gem in gem cache" do
+        GemCache.should_receive(:get).and_return(nil)
+        curl = Curl::Easy.new
+        described_class.should_receive(:client)
+                       .at_least(:once).and_return(curl)
+        curl.stub(:http_get) # stub out http_get
+        curl.should_receive(:body_str).and_return('gem')
+        GemCache.should_receive(:set)
+                .with('polisher', '1.1', 'gem')
+        described_class.download_gem 'polisher', '1.1'
       end
 
-      it "uses curl to download gem"
-      it "sets gem in gem cached"
-      it "returns downloaded gem binary contents"
+      it "returns downloaded gem binary contents" do
+        GemCache.should_receive(:get).and_return(nil)
+        curl = Curl::Easy.new
+        described_class.should_receive(:client)
+                       .at_least(:once).and_return(curl)
+        curl.stub(:http_get) # stub out http_get
+        curl.should_receive(:body_str).and_return('gem')
+        described_class.download_gem('polisher', '1.1').should == 'gem'
+      end
     end
 
     describe "#download_gem_path" do
       it "downloads gem" do
-        gem = Polisher::Gem.new
-        Polisher::Gem.should_receive(:download_gem)
+        gem = described_class.new
+        described_class.should_receive(:download_gem)
         gem.downloaded_gem_path
       end
 
       it "returns gem cache path for gem" do
         # stub out d/l
-        gem = Polisher::Gem.new :name => 'rails', :version => '1.0'
-        Polisher::Gem.should_receive(:download_gem)
-        Polisher::GemCache.should_receive(:path_for).
-                           with('rails', '1.0').
-                           at_least(:once).
-                           and_return('rails_path')
+        gem = described_class.new :name => 'rails', :version => '1.0'
+        described_class.should_receive(:download_gem)
+        Polisher::GemCache.should_receive(:path_for)
+                          .with('rails', '1.0')
+                          .at_least(:once)
+                          .and_return('rails_path')
         gem.downloaded_gem_path.should == 'rails_path'
       end
     end
 
     describe "#gem_path" do
       it "returns specified path" do
-        gem = Polisher::Gem.new :path => 'gem_path'
+        gem = described_class.new :path => 'gem_path'
         gem.gem_path.should == 'gem_path'
       end
 
       context "specified path is null" do
         it "returns downloaded gem path" do
-          gem = Polisher::Gem.new
+          gem = described_class.new
           gem.should_receive(:downloaded_gem_path).and_return('gem_path')
           gem.gem_path.should == 'gem_path'
         end
@@ -126,39 +226,122 @@ module Polisher
     end
 
     describe "#file_paths" do
-      it "returns list of file paths in gem"
+      it "returns list of file paths in gem" do
+        gem = described_class.new
+        gem.should_receive(:each_file).and_yield('file1').and_yield('file2')
+        gem.file_paths.should == %w(file1 file2)
+      end
     end
 
     describe "#retrieve" do
-      before(:each) do
-        @local_gem = Polisher::Test::LOCAL_GEM
-      end
-
       it "returns gem retrieved from rubygems" do
-        gem = Polisher::Gem.retrieve(@local_gem[:name])
-        gem.should be_an_instance_of(Polisher::Gem)
-        gem.name.should     == @local_gem[:name]
-        gem.version.should  == @local_gem[:version]
-        gem.deps.should     == @local_gem[:deps]
-        gem.dev_deps.should == @local_gem[:dev_deps]
+        curl = Curl::Easy.new
+        curl.should_receive(:body_str).and_return('spec')
+
+        url = "https://rubygems.org/api/v1/gems/rails.json"
+        Curl::Easy.should_receive(:http_get).with(url).and_return(curl)
+
+        gem = described_class.new
+        described_class.should_receive(:parse).with('spec').and_return(gem)
+
+        described_class.retrieve('rails').should == gem
       end
     end
 
     describe "#versions" do
-      it "looks up and returns versions for gemname in polisher version checker"
+      it "looks up and returns versions of gem" do
+        gem = described_class.new :name => 'rails'
+        Polisher::VersionChecker.should_receive(:versions_for)
+                                .with('rails')
+                                .and_return(:koji => ['1.1.1'])
+        gem.versions.should == {'rails' => {:koji => ['1.1.1']}}
+      end
 
       context "recursive is true" do
-        it "appends versions of gem dependencies to versions list"
+        it "retrieves dependency versions" do
+          # stub out version checker
+          retrieved = {:koji => ['1.0']}
+          Polisher::VersionChecker.should_receive(:versions_for)
+                                  .and_return(retrieved)
+
+          versions = {}
+          gem = described_class.new :name => 'rails'
+          gem.should_receive(:dependency_versions)
+             .with(:recursive => true, :versions => {'rails' => retrieved})
+             .and_call_original
+          gem.versions(:recursive => true, :versions => versions)
+             .should == {'rails' => {:koji => ['1.0']}}
+        end
+
         context "dev_deps is true" do
-          it "appends versions of gem dev dependencies to versions list"
+          it "retrieves dev dependency versions" do
+            # stub out version checker
+            retrieved = {:koji => ['1.0']}
+            Polisher::VersionChecker.should_receive(:versions_for)
+                                    .and_return(retrieved)
+
+            versions = {}
+            gem = described_class.new :name => 'rails'
+            gem.should_receive(:dependency_versions)
+               .with(:recursive => true, :dev_deps => true,
+                      :versions => {'rails' => retrieved})
+               .and_call_original
+            gem.should_receive(:dependency_versions)
+               .with(:recursive => true, :dev => true, :dev_deps => true,
+                      :versions => {'rails' => retrieved})
+               .and_call_original
+            gem.versions(:recursive => true, :dev_deps => true,
+                         :versions => versions)
+               .should == {'rails' => {:koji => ['1.0']}}
+          end
+        end
+      end
+    end
+
+    describe "#dependency_versions" do
+      it "retrieves dependency versions" do
+        gem = described_class.new
+        gem.should_receive(:deps).and_return([::Gem::Dependency.new('rake')])
+        described_class.should_receive(:retrieve)
+                       .with('rake').and_return(gem)
+
+        versions = {'rake' => {:koji => ['2.1']}}
+        gem.should_receive(:versions).and_return(versions)
+        gem.dependency_versions.should == versions
+      end
+
+      it "retrieves dev dependency versions" do
+        gem = described_class.new
+        gem.should_receive(:dev_deps).and_return([::Gem::Dependency.new('rake')])
+        described_class.should_receive(:retrieve)
+                       .with('rake').and_return(gem)
+
+        versions = {'rake' => {:koji => ['2.1']}}
+        gem.should_receive(:versions).and_return(versions)
+        gem.dependency_versions(:dev => true).should == versions
+      end
+
+      context "error during gem or version retrieval" do
+        it "sets version to 'unknown'" do
+          gem = described_class.new
+          gem.should_receive(:deps).and_return([::Gem::Dependency.new('rake')])
+          described_class.should_receive(:retrieve)
+                         .with('rake').and_raise(RuntimeError)
+
+          versions = {:all => [:unknown]}
+          gem.should_not_receive(:versions)
+          Polisher::VersionChecker.should_receive(:unknown_version)
+                                  .with(:all, 'rake')
+                                  .and_return(versions)
+          gem.dependency_versions.should == {'rake' => versions}
         end
       end
     end
 
     describe "#diff" do
       before(:each) do
-        @gem1 = Polisher::Gem.new
-        @gem2 = Polisher::Gem.new
+        @gem1 = described_class.new
+        @gem2 = described_class.new
 
         @result = AwesomeSpawn::CommandResult.new '', 'diff_out', '', 0
       end
@@ -166,9 +349,9 @@ module Polisher
       it "runs diff against unpacked local and other gems and returns output" do
         @gem1.should_receive(:unpack).and_return('dir1')
         @gem2.should_receive(:unpack).and_return('dir2')
-        AwesomeSpawn.should_receive(:run).
-          with("#{Polisher::Gem::DIFF_CMD} -r dir1 dir2").
-          and_return(@result)
+        AwesomeSpawn.should_receive(:run)
+          .with("#{Polisher::Gem.diff_cmd} -r dir1 dir2")
+          .and_return(@result)
         @gem1.diff(@gem2).should == @result.output
       end