Merge 8ac2af4 into 284aa6a

bin/README

@@ -23,6 +23,8 @@ Conversion
 
 - ruby_rpm_spec_updater - update the rpm spec of a gem to the specified or latest version upstream
 
+- update_gems - analyze gem upstream dependency tree similar to gems2update and updates downstream
+                equivalents in same manner as git_gem_updater
 
 Misc
 ---

bin/git_gem_updater.rb

@@ -20,9 +20,9 @@
     conf = git_gem_updater_conf
 optparse = git_gem_updater_option_parser
 optparse.parse!
-validate_args!
+validate_gems!
 
 Polisher::Config.set
 
 chdir
-process_gems
+update_gems

bin/update_gems.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/ruby
+# Enhanced gem updater that navigates the gem dependency tree
+# and updates gems to their latest target versions
+#
+# Licensed under the MIT license
+# Copyright (C) 2016 Red Hat, Inc.
+
+require 'polisher/util/logger'
+require 'polisher/util/config'
+
+require 'polisher/cli/all'
+require 'polisher/cli/bin/update_gems'
+
+include Polisher::CLI
+
+    conf = update_gems_conf
+optparse = update_gems_parser
+optparse.parse!
+
+Polisher::Logging.level = conf[:log_level]
+Polisher::Config.set
+set_profiles conf
+
+#begin
+run_gems_update conf
+#rescue Exception => e
+#end

lib/polisher/adaptors/version_checker.rb

@@ -32,6 +32,17 @@ def self.versions_for(name, &bl)
       versions
     end
 
+    def self.known_versions_for(name, &bl)
+      versions = {}
+      versions_for(name) do |tgt, _name, target_versions|
+        unless target_versions.include?(:unknown)
+          bl.call tgt, name, versions unless bl.nil?
+          versions.merge! tgt => target_versions
+        end
+      end
+      versions
+    end
+
     # Return version of package most frequent references in each
     # configured target.
     def self.version_for(name)
@@ -55,7 +66,7 @@ def self.unknown_version(tgt, name)
 
     # Return versions matching dependency
     def self.matching_versions(dep)
-      versions = versions_for(dep.name).values.flatten.uniq.compact
+      versions = known_versions_for(dep.name).values.flatten.uniq.compact
       versions.select { |v| dep.match? dep.name, v }
     end
   end

lib/polisher/cli/all.rb

@@ -10,10 +10,14 @@
 require 'polisher/cli/targets'
 require 'polisher/cli/specifier'
 require 'polisher/cli/format'
+require 'polisher/cli/fedora'
 require 'polisher/cli/conf'
+require 'polisher/cli/paths'
 require 'polisher/cli/status'
 require 'polisher/cli/deps'
 require 'polisher/cli/profiles'
+require 'polisher/cli/cross_ref'
+require 'polisher/cli/updater'
 
 module Polisher
   module CLI

lib/polisher/cli/bin/gem_dependency_checker.rb

@@ -59,14 +59,14 @@ def print_dep(dep, tgt, versions)
 
     def print_gem_deps(gem)
       gem.versions(:recursive => true,
-                   :dev_deps  => conf[:devel_deps]) do |tgt, dep, versions|
+                   :dev_deps  => dev_deps?) do |tgt, dep, versions|
         print_dep(dep, tgt, versions)
       end
     end
 
     def print_gemfile_deps(gemfile)
       gemfile.dependency_versions :recursive => true,
-                                  :dev_deps  => conf[:devel_deps] do |tgt, dep, versions|
+                                  :dev_deps  => dev_deps? do |tgt, dep, versions|
         print_dep(dep, tgt, versions)
       end
     end

lib/polisher/cli/bin/gem_mapper.rb

@@ -26,7 +26,7 @@ def print_dep(gem, dep, resolved_dep)
 
 def print_deps(source)
   source.dependency_tree(:recursive => true,
-                         :dev_deps  => conf[:devel_deps],
+                         :dev_deps  => dev_deps?,
                          :matching  => conf[:matching]) do |gem, dep, resolved_dep|
     print_dep(gem, dep, resolved_dep)
   end

lib/polisher/cli/bin/gems2update.rb

@@ -22,19 +22,16 @@ def gems2update_parser
   end
 end
 
-def check_missing(deps, alts)
-  deps.each { |name, gdeps|
-    versions = Polisher::Gem.remote_versions_for(name)
-    matching = versions.select { |v| gdeps.all? { |dep| dep.match?(name, v)} }
-    latest    = alts[name].max
+def check_missing
+  missing_deps.each { |name, deps|
+    latest   = latest_alt(name)
+    print "#{name}(#{latest}) #{deps.collect { |dep| dep.requirement.to_s }}: ".blue.bold
 
-    print "#{name}(#{latest}) #{gdeps.collect { |dep| dep.requirement.to_s }}: ".blue.bold
-
-    if matching.empty?
+    if !upstream_version?(name)
       puts "No matching upstream versions".red.bold
 
     else
-      updatable = latest.nil? ? matching : matching.select { |m| m > latest }
+      updatable = updatable_versions(name)
 
       if updatable.empty?
         puts "No matching upstream version > #{latest} (downstream)".red.bold
@@ -48,39 +45,17 @@ def check_missing(deps, alts)
 end
 
 def check_gems2update(source)
-  deps = {}
-  alts = {}
-
   msg = 'processing dependencies'
-  waiting :msg => msg,
-          :color => :red
+  waiting :msg => msg, :color => :red
 
   source.dependency_tree(:recursive => true,
-                         :dev_deps  => conf[:devel_deps]) do |source, dep, resolved_dep|
-    waiting_msg "#{msg} #{source.name}(#{dep.name})"
-
-    # XXX : need to nullify dep.type for this lookup
-    dep.instance_variable_set(:@type, :runtime)
-    name = dep.name
-    other_version_missing = deps.key?(name)
-    has_dep = other_version_missing && deps[name].any? { |gdep| gdep == dep }
-
-    unless has_dep
-      versions = Polisher::VersionChecker.matching_versions(dep)
-      missing_downstream = versions.empty?
-    end
-
-    if missing_downstream || other_version_missing
-      deps[name] ||= []
-      deps[name] << dep unless has_dep
-
-      alts[name] = Polisher::VersionChecker.versions_for(name).values.flatten unless alts.key?(name)
-    end
-
+                         :dev_deps  => dev_deps?) do |src, dep, resolved_dep|
+    waiting_msg "#{msg} #{src.is_a?(Polisher::Gemfile) ? "Gemfile" : src.name}(#{dep.name})"
+    check_missing_dep dep
   end
 
   end_waiting
-  check_missing(deps, alts)
+  check_missing
 end
 
 def check_gems(conf)

lib/polisher/cli/bin/git_gem_updater.rb

@@ -11,177 +11,30 @@
 
 module Polisher
   module CLI
-    def orig_dir
-      @orig_dir ||= Dir.pwd
-    end
-
     def git_gem_updater_conf
-      conf.merge!({ :dir      => orig_dir,
-                    :user     =>      nil,
-                    :gems     =>       [],
-                    :versions =>       [],
-                    :deps     =>       []}).merge!(default_conf)
-    end
-
-    def git_gem_updater_options(option_parser)
-      option_parser.on('-n', '--name GEM', 'gem name(s)' ) do |n|
-        queue_gem n
-      end
-
-      option_parser.on('-v', '--version version', 'version of last gem specified') do |v|
-        conf[:versions][-1] = v
-      end
-
-      option_parser.on('-u', '--user USER', 'fedora user name' ) do |u|
-        conf[:user] = u
-      end
-
-      option_parser.on('-d', '--dir path', 'Directory to cd to before checking out / manipulating packages' ) do |p|
-        conf[:dir] = p
-      end
+      conf.merge!(update_conf)
+          .merge!(fedora_conf)
+          .merge!(path_conf)
+          .merge!(default_conf)
     end
 
     def git_gem_updater_option_parser
       OptionParser.new do |opts|
         default_options         opts
         gem_deps_options        opts
-        git_gem_updater_options opts
-      end
-    end
-
-    def validate_user!
-      unless conf[:user].nil?
-        begin
-          conf[:gems] += Polisher::Fedora.gems_owned_by(conf[:user])
-        rescue
-          puts "Could not retrieve gems owned by #{conf[:user]}".red
-          exit 1
-        end
+        path_options            opts
+        fedora_options          opts
+        update_options          opts
       end
     end
 
     def validate_gems!
+      conf[:gems] += user_gems
+
       if conf[:gems].empty?
-        puts "must specify a gem name or user name!".red
+        puts "must specify a gem or user name!".red
         exit 1
       end
     end
-
-    def validate_args!
-      validate_user!
-      validate_gems!
-    end
-
-    def queue_gem(name)
-      conf[:gems]     << name
-      conf[:versions] << nil
-      conf[:deps]     << nil
-    end
-
-    def chdir
-      Dir.mkdir conf[:dir] unless File.directory?(conf[:dir])
-      Dir.chdir conf[:dir]
-    end
-
-     def current_gem(args={})
-      @distgit_pkg  = nil
-      @upstream_gem = nil
-      @gem_name     = args[:name]
-      @gem_version  = args[:version]
-      @gem_dep      = args[:dep]
-    end
-
-    def distgit_pkg
-      @distgit_pkg ||= begin
-        Polisher::Git::Pkg.new(:name => @gem_name).fetch
-      rescue => e
-        puts "Problem Cloning Package, Skipping: #{e}"
-        nil
-      end
-    end
-
-    def upstream_gem
-      @upstream_gem ||=
-        if @gem_dep
-          Polisher::Gem.latest_matching(@gem_dep)
-        else
-          Polisher::Gem.retrieve(@gem_name, @gem_version)
-        end
-    end
-
-    def process_gems
-      # TODO - Process deps & order gem list so dependencies are built before dependents.
-      #      - Use chained scratch builds to make them available.
-      #      - Add cli opt to exit entire sequence / executable if one in queue fails
-      #      - Process gems & run builds in parallel
-      conf[:gems].each_index do |g|
-        name    = conf[:gems][g]
-        version = conf[:versions][g]
-        dep     = conf[:deps][g]
-        current_gem :name    =>    name,
-                    :version => version,
-                    :dep     =>     dep
-
-        process_gem
-        process_gem_deps if specified_gem_deps? && !skip_gem_deps?
-      end
-    end
-
-    def update_args
-      skip_gem_deps_args
-    end
-
-    def update_git
-      distgit_pkg.update_to(upstream_gem, update_args)
-      # TODO append gem dependencies to conf[:gems] list
-    end
-
-    # TODO print koji url (both on success & failure)
-    def scratch_build
-      begin
-        distgit_pkg.build
-      rescue => e
-        puts "Warning: scratch build failed: #{e}".bold.red
-      end
-    end
-
-    def verify_check_section
-      unless distgit_pkg.spec.has_check?
-        puts "Warning: no %check section in spec, "\
-             "manually verify functionality!".bold.red
-      end
-    end
-
-    def git_commit
-      distgit_pkg.commit
-    end
-
-    def print_results
-      puts "#{@gem_name} commit complete".green
-      puts "Package located in #{distgit_pkg.path.bold}"
-      puts "Push commit with: git push".blue
-      puts "Build and tag official rpms with: #{Polisher::Git::Pkg.pkg_cmd} build".blue
-    end
-
-    def process_gem
-      return if distgit_pkg.nil?
-
-      update_git
-      scratch_build
-      verify_check_section
-      git_commit
-
-      print_results
-    end
-
-    def process_gem_deps
-      (upstream_gem.deps + upstream_gem.dev_deps).each do |dep|
-        # XXX ignoring duplicate gems here, even if they specify alt deps
-        unless conf[:gems].include?(dep.name)
-          queue_gem dep.name
-          conf[:deps][-1] = dep
-        end
-      end
-    end
   end # module CLI
 end # module Polisher

lib/polisher/cli/bin/missing_deps.rb

@@ -22,7 +22,7 @@ def missing_deps_parser
 
 def check_missing_deps(source)
   source.dependency_tree(:recursive => true,
-                         :dev_deps  => conf[:devel_deps]) do |source, dep, resolved_dep|
+                         :dev_deps  => dev_deps?) do |source, dep, resolved_dep|
     versions   = Polisher::VersionChecker.matching_versions(dep)
     alt        = Polisher::VersionChecker.versions_for(dep.name)
     source_str = source.is_a?(Polisher::Gemfile) ? "Gemfile" : "#{source.name} #{source.version}"