polisher 0.10.2 → 0.11.1

data/lib/polisher/rhn.rb

@@ -1,15 +0,0 @@
-# Polisher RHN Operations
-#
-# Licensed under the MIT license
-# Copyright (C) 2013-2014 Red Hat, Inc.
-require 'polisher/component'
-
-module Polisher
-  Component.verify("RHN", "pkgwat") do
-    class RHN
-      def self.version_for(name)
-        # TODO
-      end
-    end
-  end
-end

data/lib/polisher/version_checker.rb

@@ -1,177 +0,0 @@
-# Helpers to check versions
-#
-# Licensed under the MIT license
-# 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
-    GIT_TARGET    = :git
-    YUM_TARGET    = :yum
-    BODHI_TARGET  = :bodhi  # fedora dispatches to bodhi so not enabled by default
-    ERRATA_TARGET = :errata # not enabled by default
-    ALL_TARGETS   = [GEM_TARGET, KOJI_TARGET, FEDORA_TARGET,
-                     GIT_TARGET, YUM_TARGET]
-
-    # Enable the specified target(s) in the list of target to check
-    def self.check(*target)
-      @check_list ||= []
-      target.flatten.each { |t| @check_list << t }
-    end
-
-    def self.should_check?(target)
-      @check_list ||= ALL_TARGETS
-      @check_list.include?(target)
-    end
-
-    # Retrieve all the versions of the specified package using
-    # the configured targets.
-    #
-    # If not specified, all targets are checked
-    # @param [String] name name of package to query
-    # @param [Callable] bl optional block to invoke with versions retrieved
-    # @returns [Hash<target,Array<String>>] returns a hash of target to versions
-    # available for specified package
-    def self.versions_for(name, &bl)
-      versions = {}
-
-      if should_check?(GEM_TARGET)
-        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'
-          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'
-          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'
-          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'
-          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'
-          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'
-          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
-    end
-
-    # Return version of package most frequent in all configured targets.
-    # Invokes query as normal then counts versions over all targets and
-    # returns the max.
-    def self.version_for(name)
-      versions = self.versions_for(name).values
-      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
-
-  # Helper module to be included in components
-  # that contain lists of dependencies which include version information
-  module VersionedDependencies
-
-    # Return list of versions of dependencies of component.
-    #
-    # Requires module define 'deps' method which returns list
-    # of gem names representing component dependencies. List
-    # will be iterated over, versions will be looked up
-    # recursively and returned
-    def dependency_versions(args = {}, &bl)
-      args = {:recursive => true, :dev_deps  => true}.merge(args)
-      versions = {}
-      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

@@ -1,37 +0,0 @@
-# Polisher Yum Operations
-#
-# Licensed under the MIT license
-# Copyright (C) 2013-2014 Red Hat, Inc.
-
-require 'polisher/core'
-require 'polisher/component'
-
-module Polisher
-  Component.verify("Yum", 'awesome_spawn') do
-    class Yum
-      include ConfHelpers
-
-      conf_attr :yum_cmd, '/usr/bin/yum'
-
-      # 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
-    end
-  end # Component.verify("Yum")
-end # module Polisher

data/spec/git_spec.rb

@@ -1,445 +0,0 @@
-#
-# Licensed under the MIT license
-# Copyright (C) 2013-2014 Red Hat, Inc.
-
-require 'polisher/git'
-require 'polisher/gem'
-require 'pathname'
-
-module Polisher
-  describe Git::Repo do
-    describe "#initialize" do
-      it "initializes url" do
-        repo = described_class.new :url => 'repo_url'
-        repo.url.should == 'repo_url'
-      end
-    end
-
-    describe "#path" do
-      it "returns git cache path for url" do
-        repo = described_class.new :url => 'repo_url'
-        Polisher::GitCache.should_receive(:path_for).
-                                    with('repo_url').
-                             and_return('repo_path')
-        repo.path.should == 'repo_path'
-      end
-    end
-
-    describe "#clone" do
-      it "runs git clone" do
-        expected = "/usr/bin/git clone repo_url repo_path"
-        AwesomeSpawn.should_receive(:run!).with(expected)
-
-        repo = described_class.new :url => 'repo_url'
-        repo.should_receive(:path).and_return('repo_path')
-        repo.clone
-      end
-    end
-
-    describe "#cloned?" do
-      before(:each) do
-        @repo = described_class.new
-        @repo.should_receive(:path).and_return('repo_path')
-      end
-
-      context "repo path directory exists" do
-        it "returns true" do
-          File.should_receive(:directory?).with('repo_path').and_return(true)
-          @repo.should be_cloned
-        end
-      end
-
-      context "repo path directory does not exist" do
-        it "returns false" do
-          File.should_receive(:directory?).with('repo_path').and_return(false)
-          @repo.should_not be_cloned
-        end
-      end
-    end
-
-    describe "#in_repo" do
-      it "chdir to repo path, invokes block, restores dir" do
-        repo = described_class.new
-        Dir.mktmpdir do |dir|
-          repo.should_receive(:path).and_return(dir)
-
-          expected = Pathname.new(dir).realpath.to_s
-          invoked = false
-          orig = Dir.pwd
-          repo.in_repo do
-            Dir.pwd.should == expected
-            invoked = true
-          end
-          Dir.pwd.should == orig
-          invoked.should be_true
-        end
-      end
-    end
-
-    describe "#file_paths" do
-      it "returns list of all first paths in git repo" do
-        expected = ['file1', 'dir1/file2', 'dir2']
-        repo = described_class.new
-        repo.should_receive(:in_repo).and_yield
-        Dir.should_receive(:[]).with('**/*').and_return(expected)
-        repo.file_paths.should == expected
-      end
-    end
-
-    describe "#reset!" do
-      it "resets git repo to head" do
-        expected = "/usr/bin/git reset HEAD~ --hard"
-        repo = described_class.new
-        repo.should_receive(:in_repo).and_yield
-        AwesomeSpawn.should_receive(:run!).with(expected)
-        repo.reset!
-      end
-    end
-
-    describe "#pull" do
-      it "git pulls" do
-        expected = "/usr/bin/git pull"
-        repo = described_class.new
-        repo.should_receive(:in_repo).and_yield
-        AwesomeSpawn.should_receive(:run!).with(expected)
-        repo.pull
-      end
-    end
-
-    describe "#checkout" do
-      it "git checks out target" do
-        expected = "/usr/bin/git checkout master"
-        repo = described_class.new
-        repo.should_receive(:in_repo).and_yield
-        AwesomeSpawn.should_receive(:run!).with(expected)
-        repo.checkout('master')
-      end
-    end
-
-    describe "#commit" do
-      it "git commits with message" do
-        expected = "/usr/bin/git commit -m 'msg'"
-        repo = described_class.new
-        repo.should_receive(:in_repo).and_yield
-        AwesomeSpawn.should_receive(:run!).with(expected)
-        repo.commit('msg')
-      end
-    end
-  end
-
-  describe Git::Pkg do
-    describe "#initialize" do
-      it "initializes name" do
-        pkg = described_class.new :name => 'pkg_name'
-        pkg.name.should == 'pkg_name'
-      end
-
-      it "initializes version" do
-        pkg = described_class.new :version => 'pkg_version'
-        pkg.version.should == 'pkg_version'
-      end
-    end
-
-    describe "#rpm_name" do
-      it "returns rubygem-gem_name" do
-        pkg = described_class.new :name => 'rails'
-        pkg.rpm_name.should == 'rubygem-rails'
-      end
-    end
-
-    describe "#srpm" do
-      it "returns name of srpm" do
-        pkg = described_class.new :name => 'rails', :version => '1.0.0'
-        pkg.srpm.should == 'rubygem-rails-1.0.0-1.*.src.rpm'
-      end
-    end
-
-    describe "#spec_file" do
-      it "returns name of spec file" do
-        pkg = described_class.new :name => 'rails'
-        pkg.spec_file.should == 'rubygem-rails.spec'
-      end
-    end
-
-    describe "#spec" do
-      it "returns handle to parsed Polisher::RPM::Spec"
-    end
-
-    describe "#pkg_files" do
-      it "returns spec, .gitignore, sources"
-    end
-
-    describe "#path" do
-      it "returns Git Cache path for rpm name"
-    end
-
-    describe "#git_clone" do
-      it "is an alias for superclass#clone"
-    end
-
-    describe "#clone" do
-      it "clones package" do
-        # stub out glob / rm_rf
-        Dir.should_receive(:foreach).and_return([])
-        FileUtils.should_receive(:rm_rf).at_least(:once)
-
-        pkg = described_class.new :name => 'rails'
-        pkg.should_receive(:in_repo).and_yield
-        pkg.should_receive(:require_cmd!).with('/usr/bin/fedpkg').and_return(true)
-
-        expected = '/usr/bin/fedpkg clone rubygem-rails'
-        result   = AwesomeSpawn::CommandResult.new '', '', '', 0
-        AwesomeSpawn.should_receive(:run).with(expected).and_return(result)
-        pkg.clone
-      end
-
-      it "moves files from pkg subdir to current dir"
-      it "rm's pkg subdir"
-    end
-
-    describe "#dead?" do
-      before(:each) do
-        @pkg = described_class.new
-        @pkg.should_receive(:in_repo).and_yield
-      end
-
-      context "dead.package exists" do
-        it "returns true" do
-          File.should_receive(:exist?).with('dead.package').and_return(true)
-          @pkg.should be_dead
-        end
-      end
-
-      context "dead.package does not exist" do
-        it "returns false" do
-          File.should_receive(:exist?).with('dead.package').and_return(false)
-          @pkg.should_not be_dead
-        end
-      end
-    end
-
-    describe "#fetch" do
-      before(:each) do
-        @pkg = described_class.new
-      end
-
-      context "pkg not cloned" do
-        it "clones package" do
-          @pkg.should_receive(:dead?).and_return(false)
-          @pkg.should_receive(:reset!)
-          @pkg.should_receive(:checkout)
-          @pkg.should_receive(:pull)
-
-          @pkg.should_receive(:cloned?).and_return(false)
-          @pkg.should_receive(:clone)
-          @pkg.fetch
-        end
-      end
-
-      context "pkg cloned" do
-        it "does not clone pkg" do
-          @pkg.should_receive(:dead?).and_return(false)
-          @pkg.should_receive(:reset!)
-          @pkg.should_receive(:checkout)
-          @pkg.should_receive(:pull)
-
-          @pkg.should_receive(:cloned?).and_return(true)
-          @pkg.should_not_receive(:clone)
-          @pkg.fetch
-        end
-      end
-
-      context "pkg dead" do
-        it "raises Exception" do
-          @pkg.should_receive(:cloned?).and_return(true)
-          @pkg.should_receive(:dead?).and_return(true)
-          lambda{
-            @pkg.fetch
-          }.should raise_error(Exception)
-        end
-      end
-
-      it "checks out master" do
-        @pkg.should_receive(:cloned?).and_return(true)
-        @pkg.should_receive(:dead?).and_return(false)
-        @pkg.should_receive(:reset!)
-        @pkg.should_receive(:pull)
-
-        @pkg.should_receive(:checkout).with('master')
-        @pkg.fetch
-      end
-
-      it "resets HEAD" do
-        @pkg.should_receive(:cloned?).and_return(true)
-        @pkg.should_receive(:dead?).and_return(false)
-        @pkg.should_receive(:checkout)
-        @pkg.should_receive(:pull)
-
-        @pkg.should_receive(:reset!)
-        @pkg.fetch
-      end
-
-      it "pulls repo" do
-        @pkg.should_receive(:cloned?).and_return(true)
-        @pkg.should_receive(:dead?).and_return(false)
-        @pkg.should_receive(:reset!)
-        @pkg.should_receive(:checkout)
-
-
-        @pkg.should_receive(:pull)
-        @pkg.fetch
-      end
-    end
-
-    describe "#update_metadata" do
-      it "sets pkg version" do
-        pkg = described_class.new
-        pkg.update_metadata(Polisher::Gem.new(:version => '5.0'))
-        pkg.version.should == '5.0'
-      end
-    end
-
-    describe "#update_spec_to" do
-      it "updates spec metadata"
-      it "updates spec version"
-      it "updates spec release"
-    end
-
-    describe "#gen_sources_for" do
-      it "writes gem md5sum to sources file"
-    end
-
-    describe "#ignore" do
-      it "adds gem to .gitignore file"
-    end
-
-    describe "#update_to" do
-      it "updates rpm spec"
-      it "generates new sources file"
-      it "ignores gem"
-    end
-
-    describe "#commit" do
-      it "git adds the pkg_files" do
-        pkg = described_class.new(:name => 'rails')
-        pkg.should_receive(:in_repo).at_least(:once).and_yield
-        pkg.should_receive(:pkg_files).and_return(['pkg_files'])
-        expected = "/usr/bin/git add pkg_files"
-        AwesomeSpawn.should_receive(:run).with(expected)
-        AwesomeSpawn.should_receive(:run).at_least(:once)
-                    .and_return(AwesomeSpawn::CommandResult.new('', '', '', 0))
-        pkg.commit
-      end
-
-      it "commits the package with default msg" do
-        pkg = described_class.new(:name => 'rails', :version => '1.0.0')
-        pkg.should_receive(:in_repo).at_least(:once).and_yield
-        expected = "/usr/bin/git commit -m 'updated to 1.0.0'"
-        AwesomeSpawn.should_receive(:run!).with(expected)
-        AwesomeSpawn.should_receive(:run).at_least(:once)
-                    .and_return(AwesomeSpawn::CommandResult.new('', '', '', 0))
-        pkg.commit
-      end
-    end
-
-    describe "#build_srpm" do
-      it "uses package command to build srpm" do
-        gem  = Polisher::Gem.new
-        spec = RPM::Spec.new
-        pkg  = described_class.new
-        pkg.should_receive(:in_repo).and_yield
-        pkg.should_receive(:require_cmd!).with('/usr/bin/fedpkg').and_return(true)
-        pkg.should_receive(:spec).and_return(spec)
-        spec.should_receive(:upstream_gem).and_return(gem)
-        FileUtils.stub(:ln_s) # stub out ln
-        result = AwesomeSpawn::CommandResult.new "", "", "", 0
-        AwesomeSpawn.should_receive(:run)
-                    .with("/usr/bin/fedpkg srpm")
-                    .and_return(result)
-        pkg.build_srpm
-      end
-
-      context "package command fails" do
-        it "raises RuntimeError with the command stderr" do
-          gem  = Polisher::Gem.new
-          spec = RPM::Spec.new
-          pkg  = described_class.new
-          pkg.should_receive(:in_repo).and_yield
-          pkg.should_receive(:require_cmd!).with('/usr/bin/fedpkg').and_return(true)
-          pkg.should_receive(:spec).and_return(spec)
-          spec.should_receive(:upstream_gem).and_return(gem)
-          FileUtils.stub(:ln_s) # stub out ln
-          result = AwesomeSpawn::CommandResult.new "", "", "cmd_error", 1
-          AwesomeSpawn.should_receive(:run)
-                      .and_return(result)
-          expect { pkg.build_srpm }.to raise_error(RuntimeError, "cmd_error")
-        end
-      end
-    end
-
-    describe "#scratch_build" do
-      it "uses koji to build srpm" do
-        pkg = described_class.new(:name => 'rails', :version => '1.0.0')
-        pkg.should_receive(:in_repo).and_yield
-        Koji.should_receive(:build).with(:srpm => pkg.srpm, :scratch => true)
-        pkg.scratch_build
-      end
-    end
-
-    describe "#build" do
-      it "builds srpm and runs scratch build" do
-        pkg = described_class.new
-        pkg.should_receive(:build_srpm)
-        pkg.should_receive(:scratch_build)
-        pkg.build
-      end
-    end
-
-    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
-        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.versions_for('rails').should == ['1.0.0']
-      end
-
-      it "invokes callback with version of package" do
-        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.versions_for('rails', &cb)
-      end
-    end
-  end # describe Git::Pkg
-
-  describe Git::Project do
-    describe "#vendored" do
-      context "repo not cloned" do
-        it "clones repo" do
-          git = described_class.new
-          git.should_receive(:cloned?).and_return(false)
-          git.should_receive(:clone)
-          git.should_receive(:vendored_file_paths).and_return([]) # stub out
-          git.vendored
-        end
-      end
-    end
-  end
-end # module Polisher