Implement Gem#state and Gemfile#dependency_states (rev 2)

Infers state of gem and gems in gemfile from various targets
in distgit/koji build process.

Revised to incorporate alternate workflow. A little less efficient
(for example distgit repo/branch will always be checked even
 if build exists but doesn't match) but code is alot cleaner

Manually verified, specs still TBD

lib/polisher/gem.rb

@@ -7,12 +7,14 @@
 require 'polisher/component'
 require 'polisher/gem_cache'
 require 'polisher/version_checker'
+require 'polisher/gem_state'
 
 module Polisher
   deps = ['curb', 'json', 'yaml', 'tempfile', 'pathname', 'fileutils',
           'awesome_spawn', 'rubygems/installer', 'active_support', 'active_support/core_ext']
   Component.verify("Gem", *deps) do
     class Gem
+      include HasState
       include HasVendoredDeps
 
       GEM_CMD      = '/usr/bin/gem'

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

lib/polisher/koji.rb

@@ -76,19 +76,38 @@ def self.tagged_in(name)
       # @return [Array<String>] versions retrieved, empty array if none found
       def self.versions_for(name, &bl)
         # koji xmlrpc call
-        builds =
-          koji_tags.collect do |tag|
-            package_prefixes.collect do |prefix|
-              #                         tag  event inherit prefix latest
-              client.call('listTagged', tag, nil,  true,   nil,   false,
-                          "#{prefix}#{name}")
-            end
-          end.flatten
-        versions = builds.collect { |b| b['version'] }.uniq
+        versions = tagged_versions_for(name).values.flatten.uniq
         bl.call(:koji, name, versions) unless bl.nil?
         versions
       end
 
+      def self.tagged_versions_for(name)
+        versions = {}
+        koji_tags.each do |tag|
+          versions[tag] = versions_for_tag(name, tag).flatten.uniq
+        end
+        versions
+      end
+
+      def self.tagged_version_for(name)
+        versions = {}
+        tagged_versions_for(name).each do |tag, tagged_versions|
+          versions[tag] = tagged_versions.first
+        end
+        versions
+      end
+
+      def self.versions_for_tag(name, tag)
+        metadata =
+          package_prefixes.collect do |prefix|
+            #                         tag  event inherit prefix latest
+            client.call('listTagged', tag, nil,  true,   nil,   false,
+                        "#{prefix}#{name}")
+          end
+
+        metadata.flatten.collect { |b| b['version'] }.uniq
+      end
+
       # Run a build against the specified target using the specified rpm
       def self.build(args = {})
         target  = args[:target] || build_tgt

lib/polisher/tag_mapper.rb

@@ -10,7 +10,7 @@ module Polisher
   class TagMapper
     extend ConfHelpers
 
-    def self.method_missing(id, *args, &bl)
+    def self.method_missing(id, *args)
       set(id.to_s, args.first)
     end
 
@@ -20,6 +20,7 @@ def self.set(tag, value)
     end
 
     def self.map(tag)
+      @tags ||= {}
       @tags[tag]
     end
   end # class TagMapper

lib/polisher/version_checker.rb

@@ -163,5 +163,15 @@ def dependency_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