polisher 0.9.1 → 0.10.1

data/lib/polisher/gem_state.rb

@@ -0,0 +1,86 @@
+# Polisher Gem State Represenation
+#
+# Licensed under the MIT license
+# Copyright (C) 2014 Red Hat, Inc.
+
+require 'polisher/tag_mapper'
+
+module Polisher
+  module HasState
+    def koji_tags
+      Koji.tagged_version_for(name)
+    end
+
+    def koji_state(args = {})
+      check_dep = args.key?(:check)
+
+      return :missing   if koji_tags.empty?
+      return :available unless check_dep
+
+      koji_tags.each do |tag, version|
+        return :available if !version.nil? && args[:check].match?(name, version)
+      end
+
+      return :missing
+    end
+
+    def distgit
+      @distgit ||= Git::Pkg.new :name => name
+    end
+
+    def distgit_branches
+      tags = []
+
+      koji_tags.each do |tag, version|
+        tag = TagMapper.map(tag)
+        tags << tag unless tag.nil?
+      end
+
+      tags.empty? ? distgit.valid_branches : tags
+    end
+
+    def distgit_versions
+      distgit_branches.collect do |branch|
+        distgit.fetch branch
+        distgit.spec.version if distgit.spec?
+      end.compact
+    end
+
+    def distgit_state(args = {})
+      check_dep = args.key?(:check)
+
+      begin
+        distgit.clone
+      rescue
+        return :missing_repo
+      end
+
+      return :missing_branch if distgit.valid_branches.empty?
+      return :missing_spec   if distgit_versions.empty?
+      return :available      unless check_dep
+
+      distgit_versions.each do |version|
+        return :available if args[:check].match?(name, version)
+      end
+
+      return :missing
+    end
+
+    # Return the 'state' of the gem as inferred by
+    # the targets which there are versions for.
+    #
+    # If optional :check argument is specified, version
+    # analysis will be restricted to targets satisfying
+    # the specified gem dependency requirements
+    def state(args = {})
+      return :available if koji_state(args) == :available
+
+      state = distgit_state(args)
+      return :needs_repo   if state == :missing_repo
+      return :needs_branch if state == :missing_branch 
+      return :needs_spec   if state == :missing_spec
+      return :needs_build  if state == :available
+      return :needs_update
+    end
+  end
+end

data/lib/polisher/gemfile.rb

@@ -3,96 +3,94 @@
 # Licensed under the MIT license
 # Copyright (C) 2013-2014 Red Hat, Inc.
 
-require 'bundler'
-
 require 'polisher/git'
 require 'polisher/gem'
+require 'polisher/component'
 require 'polisher/version_checker'
 
 module Polisher
-  class Gemfile
-    include VersionedDependencies
-
-    # always nil, for interface compatability
-    attr_accessor :version
-
-    attr_accessor :deps
-    attr_accessor :dev_deps
-
-    # always empty array, for interface compatability
-    attr_accessor :file_paths
-
-    attr_accessor :definition
-
-    def initialize(args={})
-      @version  = nil
-      @deps     = args[:deps]
-      @dev_deps = args[:dev_deps]
-      @definition = args[:definition]
-      @file_paths = []
-    end
-
-    # Parse the specified gemfile & return new Gemfile instance from metadata
-    # 
-    # @param [String] path to gemfile to parse
-    # @return [Polisher::Gemfile] gemfile instantiated from parsed metadata
-    def self.parse(path, args={})
-      groups = args[:groups]
-
-      definition = nil
-      path,g = File.split(path)
-      Dir.chdir(path){
-        begin
-          definition = Bundler::Definition.build(g, nil, false)
-        rescue Bundler::GemfileNotFound
-          raise ArgumentError, "invalid gemfile: #{path}"
-        end
-      }
-
-      metadata = {}
-      metadata[:deps] =
-        definition.dependencies.select { |d|
-           groups.nil? || groups.empty? ||                  # groups not specified
-           groups.any? { |g| d.groups.include?(g.intern) }  # dep in any group
-        }.collect { |d| d.name }
-
-      metadata[:dev_deps] = [] # TODO
-      metadata[:definition] = definition
-
-      self.new metadata
-    end
-
-    # Simply alias for all dependencies in Gemfile
-    def vendored
-      deps + dev_deps
-    end
-
-    # Retrieve gems which differ from
-    # rubygems.org/other upstream sources
-    def patched
-      vendored.collect do |dep|
-        bundler_dep = @definition ?
-                      @definition.dependencies.find { |d| d.name == dep } : nil
-
-        # TODO right now just handling git based alternate sources,
-        # should be able to handle other types bundler supports
-        # (path and alternate rubygems src)
-        next unless bundler_dep && bundler_dep.source.is_a?(Bundler::Source::Git)
-        src = bundler_dep.source
-
-        # retrieve gem
-        gem = src.version ?
-              Polisher::Gem.new(:name => dep, :version => src.version) :
-              Polisher::Gem.retrieve(dep)
-
-        # retrieve dep
-        git = Polisher::Git::Repo.new :url => src.uri
-        git.clone unless git.cloned?
-        git.checkout src.ref if src.ref
-
-        # diff gem against git
-        gem.diff(git.path)
-      end.compact!
-    end
-  end # class Gemfile
+  Component.verify("Gemfile", 'bundler') do
+    class Gemfile
+      include VersionedDependencies
+
+      # always nil, for interface compatability
+      attr_accessor :version
+
+      attr_accessor :deps
+      attr_accessor :dev_deps
+
+      # always empty array, for interface compatability
+      attr_accessor :file_paths
+
+      attr_accessor :definition
+
+      def initialize(args = {})
+        @version  = nil
+        @deps     = args[:deps]
+        @dev_deps = args[:dev_deps]
+        @definition = args[:definition]
+        @file_paths = []
+      end
+
+      # Parse the specified gemfile & return new Gemfile instance from metadata
+      #
+      # @param [String] path to gemfile to parse
+      # @return [Polisher::Gemfile] gemfile instantiated from parsed metadata
+      def self.parse(path, args = {})
+        groups = args[:groups]
+
+        definition = nil
+        path, gemfile = File.split(path)
+        Dir.chdir(path){
+          begin
+            definition = Bundler::Definition.build(gemfile, nil, false)
+          rescue Bundler::GemfileNotFound
+            raise ArgumentError, "invalid gemfile: #{path}"
+          end
+        }
+
+        metadata = {}
+        metadata[:deps] =
+          definition.dependencies.select { |d|
+            groups.nil? || groups.empty? ||                  # groups not specified
+            groups.any? { |g| d.groups.include?(g.intern) }  # dep in any group
+          }
+
+        metadata[:dev_deps] = [] # TODO
+        metadata[:definition] = definition
+
+        new metadata
+      end
+
+      # Simply alias for all dependencies in Gemfile
+      def vendored
+        deps + dev_deps
+      end
+
+      # Retrieve gems which differ from
+      # rubygems.org/other upstream sources
+      def patched
+        vendored.collect do |dep|
+          # TODO: right now just handling git based alternate sources,
+          # should be able to handle other types bundler supports
+          # (path and alternate rubygems src)
+          next unless dep.source.is_a?(Bundler::Source::Git)
+          src = dep.source
+
+          # retrieve gem
+          gem = src.version ?
+                Polisher::Gem.new(:name => dep.name, :version => src.version) :
+                Polisher::Gem.retrieve(dep.name)
+
+          # retrieve dep
+          git = Polisher::Git::Repo.new :url => src.uri
+          git.clone unless git.cloned?
+          git.checkout src.ref if src.ref
+
+          # diff gem against git
+          gem.diff(git.path)
+        end.compact!
+      end
+    end # class Gemfile
+  end # Component.verify("Gemfile")
 end # module Polisher

data/lib/polisher/git/pkg.rb

@@ -3,189 +3,246 @@
 # Licensed under the MIT license
 # Copyright (C) 2013-2014 Red Hat, Inc.
 
-require 'awesome_spawn'
+require 'fileutils'
 
 require 'polisher/error'
 require 'polisher/git/repo'
 require 'polisher/rpm/spec'
+require 'polisher/component'
+require 'polisher/koji'
+require 'polisher/logger'
 
 module Polisher
   module Git
-    # Git Repository
-    class Pkg < Repo
-      attr_accessor :name
-      attr_accessor :version
-
-      conf_attr :rpm_prefix,   'rubygem-'
-      conf_attr :pkg_cmd,      '/usr/bin/fedpkg'
-      conf_attr :build_cmd,    '/usr/bin/koji'
-      conf_attr :build_tgt,    'rawhide'
-      conf_attr :md5sum_cmd,   '/usr/bin/md5sum'
-      conf_attr :dist_git_url, 'git://pkgs.fedoraproject.org/'
-      conf_attr :fetch_tgt,    'master'
-
-      def initialize(args={})
-        @name    = args[:name]
-        @version = args[:version]
-        super(args)
-      end
-
-      # Return full rpm name of package containing optional prefix
-      def rpm_name
-        @rpm_name ||= "#{rpm_prefix}#{self.name}"
-      end
-
-      # Return full srpm file name of package
-      def srpm
-        @srpm ||= "#{rpm_name}-#{self.version}-1.*.src.rpm"
-      end
-
-      # Return full spec file name
-      def spec_file
-        @spec_path ||= "#{rpm_name}.spec"
-      end
-
-      # Return handle to instance of Polisher::RPM::Spec corresponding to spec
-      def spec
-        @spec ||= in_repo { Polisher::RPM::Spec.parse File.read(spec_file) }
-      end
-
-      # Files representing pkg tracked by git
-      def pkg_files
-        @pkg_files ||= [spec_file, 'sources', '.gitignore']
-      end
-
-      # Override path to reference pkg name
-      # @override
-      def path
-        GitCache.path_for(rpm_name)
-      end
-
-      # Alias orig clone method to git_clone
-      alias :git_clone :clone
-
-      # Override clone to use PKG_PCMD
-      # @override
-      def clone
-        self.clobber!
-        Dir.mkdir path unless File.directory? path
-        in_repo do
-          result = AwesomeSpawn.run "#{pkg_cmd} clone #{rpm_name}"
-          raise PolisherError,
-                "could not clone #{rpm_name}" unless result.exit_status == 0
-
-          # pkg_cmd will clone into the rpm_name subdir,
-          # move everything up a dir
-          Dir.foreach("#{rpm_name}/") do |f|
-            orig = "#{rpm_name}/#{f}"
-            skip = ['.', '..'].include?(f)
-            FileUtils.move orig, '.' unless skip
+    Component.verify("Git::Pkg", 'awesome_spawn') do
+      # Git Based Package
+      class Pkg < Repo
+        extend Logging
+
+        attr_accessor :name
+        attr_accessor :version
+
+        conf_attr :rpm_prefix,   'rubygem-'
+        conf_attr :pkg_cmd,      '/usr/bin/fedpkg'
+        conf_attr :md5sum_cmd,   '/usr/bin/md5sum'
+        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]
+          super(args)
+        end
+
+        # Return full rpm name of package containing optional prefix
+        def rpm_name
+          @rpm_name ||= "#{rpm_prefix}#{name}"
+        end
+
+        # Return full srpm file name of package
+        def srpm
+          @srpm ||= "#{rpm_name}-#{version}-1.*.src.rpm"
+        end
+
+        # Return full spec file name
+        def spec_file
+          @spec_path ||= "#{rpm_name}.spec"
+        end
+
+        # Return boolean indicating if spec file exists
+        def spec?
+          include? spec_file
+        end
+
+        # Return handle to instance of Polisher::RPM::Spec corresponding to spec
+        def spec
+          @spec, @dirty_spec = nil, false if @dirty_spec
+          @spec ||= in_repo { Polisher::RPM::Spec.parse File.read(spec_file) }
+        end
+
+        # Files representing pkg tracked by git
+        def pkg_files
+          @pkg_files ||= [spec_file, 'sources', '.gitignore']
+        end
+
+        # Override path to reference pkg name
+        # @override
+        def path
+          GitCache.path_for(rpm_name)
+        end
+
+        # Alias orig clone method to git_clone
+        alias :git_clone :clone
+
+        # Override clone to use PKG_PCMD
+        # @override
+        def clone
+          require_cmd! pkg_cmd
+          clobber!
+          Dir.mkdir path unless File.directory? path
+          in_repo do
+            result = AwesomeSpawn.run "#{pkg_cmd} clone #{rpm_name}"
+            raise PolisherError,
+                  "could not clone #{rpm_name}" unless result.exit_status == 0
+
+            # pkg_cmd will clone into the rpm_name subdir,
+            # move everything up a dir
+            Dir.foreach("#{rpm_name}/") do |f|
+              orig = "#{rpm_name}/#{f}"
+              skip = ['.', '..'].include?(f)
+              FileUtils.move orig, '.' unless skip
+            end
+
+            FileUtils.rm_rf rpm_name
+          end
+
+          self
+        end
+
+        # Return boolean indicating if package is marked as dead (retired/obsolete/etc)
+        def dead?
+          in_repo { File.exist?('dead.package') }
+        end
+
+        # Fetch specified target or configured fetch_tgt if not specified
+        def fetch(target = nil)
+          target = self.class.fetch_tgts.first if target.nil?
+          clone unless cloned?
+          raise Exception, "Dead package detected" if dead?
+          checkout target
+          reset!
+          pull
+
+          self
+        end
+
+        # Return the valid targets, eg those which we can fetch
+        def valid_targets
+          valid = []
+          self.class.fetch_tgts.collect do |target|
+            begin
+              fetch target
+              valid << target
+            rescue
+              # noop
+            end
           end
+          valid
+        end
 
-          FileUtils.rm_rf rpm_name
-        end
-
-        self
-      end
-
-      # Return boolean indicating if package is marked as dead (retired/obsolete/etc)
-      def dead?
-        in_repo { File.exists?('dead.package') }
-      end
-
-      # Clone / init GitPkg
-      def fetch
-        clone unless cloned?
-        raise Exception, "Dead package detected" if dead?
-        checkout fetch_tgt
-        reset!
-        pull
-
-        self
-      end
-
-      # Update the local spec to the specified gem version
-      def update_spec_to(gem)
-        in_repo do
-          spec.update_to(gem)
-          File.write(spec_file, spec.to_string)
-        end
-      end
-
-      # Generate new sources file
-      def gen_sources_for(gem)
-        in_repo do
-          AwesomeSpawn.run "#{md5sum_cmd} #{gem.gem_path} > sources"
-          File.write('sources', File.read('sources').gsub("#{GemCache::DIR}/", ''))
-        end
-      end
-
-      # Update git ignore to ignore gem
-      def ignore(gem)
-        in_repo do
-          nl = File.exists?('.gitignore') ? "\n" : ''
-          content = "#{nl}#{gem.name}-#{gem.version}.gem"
-          File.open(".gitignore", 'a') { |f| f.write content }
-        end
-      end
-
-      # Update the local pkg to specified gem
-      #
-      # @param [Polisher::Gem] gem instance of gem containing metadata to update to
-      def update_to(gem)
-        update_spec_to  gem
-        gen_sources_for gem
-        ignore gem
-        self
-      end
-
-      # Override commit, generate a default msg, always add pkg files
-      # @override
-      def commit(msg=nil)
-        in_repo { AwesomeSpawn.run "#{git_cmd} add #{pkg_files.join(' ')}" }
-        super(msg.nil? ? "updated to #{version}" : msg)
-        self
-      end
-
-      # Build the srpm
-      def build_srpm
-        in_repo { AwesomeSpawn.run "#{pkg_cmd} srpm" }
-        self
-      end
-
-      # Run a scratch build
-      def scratch_build
-        # TODO if build fails, raise error, else return output
-        cmd = "#{build_cmd} build --scratch #{build_tgt} #{srpm}"
-        in_repo { AwesomeSpawn.run(cmd) }
-        self
-      end
-
-      # Build the pkg
-      def build
-        build_srpm
-        scratch_build
-        self
-      end
-
-      # Retrieve list of the version 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)
-        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
-        end
-
-        bl.call(:git, name, [version]) unless(bl.nil?) 
-        version
-      end
-    end # module Pkg
+        alias :valid_branches :valid_targets
+
+        def update_metadata(gem)
+          @version = gem.version
+        end
+
+        # Update the local spec to the specified gem version
+        def update_spec_to(gem)
+          in_repo do
+            spec.update_to(gem)
+            File.write(spec_file, spec.to_string)
+            @dirty_spec = true
+          end
+        end
+
+        # Generate new sources file
+        def gen_sources_for(gem)
+          require_cmd! md5sum_cmd
+          in_repo do
+            AwesomeSpawn.run "#{md5sum_cmd} #{gem.gem_path} > sources"
+            File.write('sources', File.read('sources').gsub("#{GemCache::DIR}/", ''))
+          end
+        end
+
+        # Update git ignore to ignore gem
+        def ignore(gem)
+          in_repo do
+            nl = File.exist?('.gitignore') ? "\n" : ''
+            content = "#{nl}#{gem.name}-#{gem.version}.gem"
+            File.open(".gitignore", 'a') { |f| f.write content }
+          end
+        end
+
+        # Update the local pkg to specified gem
+        #
+        # @param [Polisher::Gem] gem instance of gem containing metadata to update to
+        def update_to(gem)
+          update_metadata gem
+          update_spec_to gem
+          gen_sources_for gem
+          ignore gem
+          self
+        end
+
+        # Override commit, generate a default msg, always add pkg files
+        # @override
+        def commit(msg = nil)
+          require_cmd! git_cmd
+          in_repo { AwesomeSpawn.run "#{git_cmd} add #{pkg_files.join(' ')}" }
+          super(msg.nil? ? "updated to #{version}" : msg)
+          self
+        end
+
+        # Build the srpm
+        def build_srpm
+          require_cmd! pkg_cmd
+          in_repo do
+            begin
+              gem = spec.upstream_gem
+              FileUtils.rm_f gem.file_name if File.exist?(gem.file_name)
+              FileUtils.ln_s gem.gem_path, gem.file_name
+              result = AwesomeSpawn.run "#{pkg_cmd} srpm"
+              raise result.error unless result.exit_status == 0
+            ensure
+              FileUtils.rm_f gem.file_name if File.exist?(gem.file_name)
+            end
+          end
+          self
+        end
+
+        # Run a scratch build
+        def scratch_build
+          in_repo do
+            Koji.build :srpm    => srpm,
+                       :scratch => true
+          end
+          self
+        end
+
+        # Build the pkg
+        def build
+          build_srpm
+          scratch_build
+          self
+        end
+
+        # 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 [Array<String>] versions retrieved, or empty array if none found
+        def self.versions_for(name, &bl)
+          version = nil
+          gitpkg = new :name => name
+          gitpkg.url = "#{dist_git_url}#{gitpkg.rpm_name}.git"
+          versions = []
+          fetch_tgts.each do |tgt|
+            begin
+              gitpkg.fetch tgt
+              versions << gitpkg.spec.version
+            rescue => e
+              logger.warn "error retrieving #{name} from #{gitpkg.url}/#{tgt}(distgit): #{e}"
+            end
+          end
+
+          bl.call(:git, name, versions) unless bl.nil?
+          versions
+        end
+      end # module Pkg
+    end # Component.verify("Git::Pkg")
   end # module Git
 end # module Polisher