polisher 0.9.1 → 0.10.1

data/lib/polisher/errata.rb

@@ -3,73 +3,73 @@
 # Licensed under the MIT license
 # Copyright (C) 2013-2014 Red Hat, Inc.
 
-require 'json'
-require 'curb'
-
 require 'polisher/core'
+require 'polisher/component'
 
 module Polisher
-  class Errata
-    extend ConfHelpers
+  Component.verify("Errata", 'json', 'curb') do
+    class Errata
+      include ConfHelpers
+
+      conf_attr :advisory_url, ''
+      conf_attr :package_prefix, 'rubygem-'
 
-    conf_attr :advisory_url, ''
-    conf_attr :package_prefix, 'rubygem-'
+      # Initialize/return singleton curl handle to query errata
+      def self.client
+        @curl ||= begin
+          curl = Curl::Easy.new
+          curl.ssl_verify_peer = false
+          curl.ssl_verify_host = false
+          curl.http_auth_types = :negotiate
+          curl.userpwd = ':'
+          curl
+        end
+      end
 
-    # Initialize/return singleton curl handle to query errata
-    def self.client
-      @curl ||= begin
-        curl = Curl::Easy.new
-        curl.ssl_verify_peer = false
-        curl.ssl_verify_host = false
-        curl.http_auth_types = :negotiate
-        curl.userpwd = ':'
-        curl
+      def self.clear!
+        @cached_url = nil
+        @cached_builds = nil
+        self
       end
-    end
 
-    def self.clear!
-      @cached_url = nil
-      @cached_builds = nil
-      self
-    end
+      def self.builds
+        @cached_url    ||= advisory_url
+        @cached_builds ||= nil
 
-    def self.builds
-      @cached_url    ||= advisory_url
-      @cached_builds ||= nil
+        if @cached_url != advisory_url || @cached_builds.nil?
+          client.url     = "#{advisory_url}/builds"
+          @cached_builds = client.get
+          @cached_builds = JSON.parse(client.body_str)
+        end
 
-      if @cached_url != advisory_url || @cached_builds.nil?
-        client.url     = "#{advisory_url}/builds"
-        @cached_builds = client.get
-        @cached_builds = JSON.parse(client.body_str)
+        @cached_builds
       end
 
-      @cached_builds
-    end
-
-    def self.versions_for(name, &bl)
-      versions = builds.collect do |tag, builds|
-        ErrataBuild.builds_matching(builds, name)
-      end.flatten
-      bl.call(:errata, name, versions) unless(bl.nil?) 
-      versions
-    end
-  end
+      def self.versions_for(name, &bl)
+        versions = builds.collect do |tag, builds|
+          ErrataBuild.builds_matching(builds, name)
+        end.flatten
+        bl.call(:errata, name, versions) unless(bl.nil?)
+        versions
+      end
+    end # class Errata
 
-  class ErrataBuild
-    def self.builds_matching(builds, name)
-      builds.collect { |build|
-        self.build_matches?(build, name) ? self.build_version(build, name) : nil
-      }.compact
-    end
+    class ErrataBuild
+      def self.builds_matching(builds, name)
+        builds.collect { |build|
+          self.build_matches?(build, name) ? self.build_version(build, name) : nil
+        }.compact
+      end
 
-    def self.build_matches?(build, name)
-      pkg,meta = *build.flatten
-      pkg =~ /^#{Errata.package_prefix}#{name}-([^-]*)-.*$/
-    end
+      def self.build_matches?(build, name)
+        pkg,meta = *build.flatten
+        pkg =~ /^#{Errata.package_prefix}#{name}-([^-]*)-.*$/
+      end
 
-    def self.build_version(build, name)
-      pkg,meta = *build.flatten
-      pkg.gsub(Errata.package_prefix, '').split('-')[1]
-    end
-  end
-end
+      def self.build_version(build, name)
+        pkg,meta = *build.flatten
+        pkg.gsub(Errata.package_prefix, '').split('-')[1]
+      end
+    end # class ErrataBuild
+  end # Component.verify(Errata)
+end # module Polisher

data/lib/polisher/fedora.rb

@@ -3,44 +3,44 @@
 # Licensed under the MIT license
 # Copyright (C) 2013-2014 Red Hat, Inc.
 
-require 'curb'
-require 'pkgwat'
-
 require 'polisher/bodhi'
+require 'polisher/component'
 
 module Polisher
-  class Fedora
-    PACKAGE_LIST = 'https://admin.fedoraproject.org/pkgdb/users/packages/'
+  Component.verify("Fedora", "curb", "pkgwat", "nokogiri") do
+    class Fedora
+      PACKAGE_LIST = 'https://admin.fedoraproject.org/pkgdb/users/packages/'
 
-    def self.client
-      @client ||= Curl::Easy.new
-    end
+      def self.client
+        @client ||= Curl::Easy.new
+      end
 
-    # Retrieve list of gems owned by the specified user
-    #
-    # @param [String] user Fedora username to lookup
-    # @return [Array<String>] list of gems which the user owns/has access to
-    def self.gems_owned_by(user)
-      client.url = "#{PACKAGE_LIST}#{user}"
-      client.http_get
-      packages = client.body_str
-      # TODO instantiate Polisher::Gem instances & return
-      Nokogiri::HTML(packages).xpath("//a[@class='PackageName']").
-                               select { |i| i.text =~ /rubygem-.*/ }.
-                               collect { |i| i.text.gsub(/rubygem-/, '') }
-    end
+      # Retrieve list of gems owned by the specified user
+      #
+      # @param [String] user Fedora username to lookup
+      # @return [Array<String>] list of gems which the user owns/has access to
+      def self.gems_owned_by(user)
+        client.url = "#{PACKAGE_LIST}#{user}"
+        client.http_get
+        packages = client.body_str
+        # TODO: instantiate Polisher::Gem instances & return
+        Nokogiri::HTML(packages).xpath("//a[@class='PackageName']")
+                                .select { |i| i.text =~ /rubygem-.*/ }
+                                .collect { |i| i.text.gsub(/rubygem-/, '') }
+      end
 
-    # Retrieve list of the versions of the specified package in the various
-    # Fedora releases.
-    #
-    # @param [String] name name of the package to lookup
-    # @param [Callable] bl optional callback to invoke with versions retrieved
-    # @return [Array<String>] list of versions in Fedora
-    def self.versions_for(name, &bl)
-      # simply dispatch to bodhi to get latest updates
-      Polisher::Bodhi.versions_for name do |target,name,versions|
-        bl.call(:fedora, name, versions) unless(bl.nil?) 
+      # Retrieve list of the versions of the specified package in the various
+      # Fedora releases.
+      #
+      # @param [String] name name of the package to lookup
+      # @param [Callable] bl optional callback to invoke with versions retrieved
+      # @return [Array<String>] list of versions in Fedora
+      def self.versions_for(name, &bl)
+        # simply dispatch to bodhi to get latest updates
+        Polisher::Bodhi.versions_for name do |_target, pkg_name, versions|
+          bl.call(:fedora, pkg_name, versions) unless bl.nil?
+        end
       end
-    end
-  end # class Fedora
+    end # class Fedora
+  end # Component.verify("Fedora")
 end # module Polisher

data/lib/polisher/gem.rb

@@ -3,310 +3,345 @@
 # Licensed under the MIT license
 # Copyright (C) 2013-2014 Red Hat, Inc.
 
-require 'curb'
-require 'json'
-require 'yaml'
-require 'tempfile'
-require 'pathname'
-require 'fileutils'
-require 'awesome_spawn'
-require 'rubygems/installer'
-require 'active_support/core_ext'
-
-require 'polisher/version_checker'
-require 'polisher/gem_cache'
+require 'polisher/core'
 require 'polisher/vendor'
+require 'polisher/component'
+require 'polisher/gem_cache'
+require 'polisher/version_checker'
+require 'polisher/gem_state'
 
 module Polisher
-  class Gem
-    include HasVendoredDeps
-
-    GEM_CMD      = '/usr/bin/gem'
-    DIFF_CMD     = '/usr/bin/diff'
-
-    # Common files shipped in gems that we should ignore
-    IGNORE_FILES = ['.gemtest', '.gitignore', '.travis.yml',
-                    /.*.gemspec/, /Gemfile.*/, 'Rakefile',
-                    /rspec.*/, '.yardopts', '.rvmrc']
-
-    # TODO also mark certain files to be tagged as %{doc}
-
-    attr_accessor :spec
-    attr_accessor :name
-    attr_accessor :version
-    attr_accessor :deps
-    attr_accessor :dev_deps
-
-    attr_accessor :path
-
-    def initialize(args={})
-      @spec     = args[:spec]
-      @name     = args[:name]
-      @version  = args[:version]
-      @path     = args[:path]
-      @deps     = args[:deps]     || []
-      @dev_deps = args[:dev_deps] || []
-    end
-
-    # Return bool indiicating if the specified file is on the IGNORE_FILES list
-    def self.ignorable_file?(file)
-      IGNORE_FILES.any? do |ignore|
-        ignore.is_a?(Regexp) ? ignore.match(file) : ignore == file
+  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 ConfHelpers
+      include HasState
+      include HasVendoredDeps
+
+      conf_attr :diff_cmd, '/usr/bin/diff'
+
+      # Common files shipped in gems that we should ignore
+      IGNORE_FILES = ['.gemtest', '.gitignore', '.travis.yml',
+                      /.*.gemspec/, /Gemfile.*/, 'Rakefile',
+                      /rspec.*/, '.yardopts', '.rvmrc']
+
+      # Common files shipped in gems that we should mark as doc
+      DOC_FILES = [/\/?CHANGELOG.*/, /\/?CONTRIBUTING.*/, /\/?README.*/, /\/?.*LICENSE/]
+
+      attr_accessor :spec
+      attr_accessor :name
+      attr_accessor :version
+      attr_accessor :deps
+      attr_accessor :dev_deps
+
+      attr_accessor :path
+
+      def file_name
+        "#{name}-#{version}.gem"
       end
-    end
-
-    # Retrieve list of the versions of the specified gem installed locally
-    #
-    # @param [String] name name of the gem to lookup
-    # @param [Callable] bl optional block to invoke with versions retrieved
-    # @return [Array<String>] list of versions of gem installed locally
-    def self.local_versions_for(name, &bl)
-      silence_warnings do
-        @local_db ||= ::Gem::Specification.all
+
+      def initialize(args = {})
+        @spec     = args[:spec]
+        @name     = args[:name]
+        @version  = args[:version]
+        @path     = args[:path]
+        @deps     = args[:deps]     || []
+        @dev_deps = args[:dev_deps] || []
       end
-      versions = @local_db.select { |s| s.name == name }.collect { |s| s.version }
-      bl.call(:local_gem, name, versions) unless(bl.nil?) 
-      versions
-    end
-
-    # Return new instance of Gem from JSON Specification
-    def self.from_json(json)
-      specj     = JSON.parse(json)
-      metadata           = {}
-      metadata[:spec]    = specj
-      metadata[:name]    = specj['name']
-      metadata[:version] = specj['version']
-
-      metadata[:deps] =
-        specj['dependencies']['runtime'].collect { |d|
-          ::Gem::Dependency.new d['name'], *d['requirements'].split(',')
-        }
-
-      metadata[:dev_deps] =
-        specj['dependencies']['development'].collect { |d|
-          ::Gem::Dependency.new d['name'], d['requirements'].split(',')
-        }
-
-      self.new metadata
-    end
-
-    # Return new instance of Gem from Gemspec
-    def self.from_gemspec(gemspec)
-      gemspec  =
-        ::Gem::Specification.load(gemspec) if !gemspec.is_a?(::Gem::Specification) &&
-                                               File.exists?(gemspec)
-
-      metadata           = {}
-      metadata[:spec]    = gemspec
-      metadata[:name]    = gemspec.name
-      metadata[:version] = gemspec.version.to_s
-
-      metadata[:deps] =
-        gemspec.dependencies.select { |dep|
-          dep.type == :runtime
-        }.collect { |dep| dep }
-
-      metadata[:dev_deps] =
-        gemspec.dependencies.select { |dep|
-          dep.type == :development
-        }.collect { |dep| dep }
-
-      self.new metadata
-    end
-
-    # Return new instance of Gem from rubygem
-    def self.from_gem(gem_path)
-      gem = self.parse :gemspec => ::Gem::Package.new(gem_path).spec
-      gem.path = gem_path
-      gem
-    end
-
-    # Parse the specified gemspec & return new Gem instance from metadata
-    # 
-    # @param [String,Hash] args contents of actual gemspec of option hash
-    # specifying location of gemspec to parse
-    # @option args [String] :gemspec path to gemspec to load / parse
-    # @return [Polisher::Gem] gem instantiated from gemspec metadata
-    def self.parse(args={})
-      if args.is_a?(String)
-        return self.from_json args
-
-      elsif args.has_key?(:gemspec)
-        return self.from_gemspec args[:gemspec]
-
-      elsif args.has_key?(:gem)
-        return self.from_gem args[:gem]
 
+      # Return bool indicating if the specified file is on the IGNORE_FILES list
+      def self.ignorable_file?(file)
+        IGNORE_FILES.any? do |ignore|
+          ignore.is_a?(Regexp) ? ignore.match(file) : ignore == file
+        end
       end
 
-      self.new
-    end
-
-    # Return handler to internal curl helper
-    def self.client
-      @client ||= Curl::Easy.new
-    end
-
-    # Download the specified gem and return the binary file contents as a string
-    #
-    # @return [String] binary gem contents
-    def self.download_gem(name, version)
-      cached = GemCache.get(name, version)
-      return cached unless cached.nil?
-
-      client.url = "https://rubygems.org/gems/#{name}-#{version}.gem"
-      client.follow_location = true
-      client.http_get
-      gemf = client.body_str
-
-      GemCache.set(name, version, gemf)
-      gemf
-    end
-
-    # Download the local gem and return it as a string
-    def download_gem
-      self.class.download_gem @name, @version
-    end
-
-    # Download the specified gem / version from rubygems and
-    # return instance of Polisher::Gem class corresponding to it
-    def self.from_rubygems(name, version)
-      download_gem name, version
-      self.from_gem downloaded_gem_path(name, version)
-    end
-
-    # Returns path to downloaded gem
-    #
-    # @return [String] path to downloaded gem
-    def self.downloaded_gem_path(name, version)
-      # ensure gem is downloaded
-      self.download_gem(name, version)
-      GemCache.path_for(name, version)
-    end
-
-    # Return path to downloaded gem
-    def downloaded_gem_path
-      self.class.downloaded_gem_path @name, @version
-    end
-
-    # Returns path to gem, either specified one of downloaded one
-    def gem_path
-      @path || downloaded_gem_path
-    end
-
-    # Unpack files & return unpacked directory
-    #
-    # If block is specified, it will be invoked
-    # with directory after which directory will be removed
-    def unpack(&bl)
-      dir = nil
-      pkg = ::Gem::Installer.new gem_path, :unpack => true
-
-      if bl
-        Dir.mktmpdir { |dir|
-          pkg.unpack dir
-          bl.call dir
-        }
-      else
-        dir = Dir.mktmpdir
-        pkg.unpack dir
+      # Return bool indicating if the specified file is on the DOC_FILES list
+      def self.doc_file?(file)
+        DOC_FILES.any? do |doc|
+          doc.is_a?(Regexp) ? doc.match(file) : doc == file
+        end
       end
 
-      dir
-    end
+      # Retrieve list of the versions of the specified gem installed locally
+      #
+      # @param [String] name name of the gem to lookup
+      # @param [Callable] bl optional block to invoke with versions retrieved
+      # @return [Array<String>] list of versions of gem installed locally
+      def self.local_versions_for(name, &bl)
+        silence_warnings do
+          @local_db ||= ::Gem::Specification.all
+        end
+        versions = @local_db.select { |s| s.name == name }.collect { |s| s.version }
+        bl.call(:local_gem, name, versions) unless(bl.nil?)
+        versions
+      end
+
+      # Return new instance of Gem from JSON Specification
+      def self.from_json(json)
+        specj     = JSON.parse(json)
+        metadata           = {}
+        metadata[:spec]    = specj
+        metadata[:name]    = specj['name']
+        metadata[:version] = specj['version']
+
+        metadata[:deps] =
+          specj['dependencies']['runtime'].collect do |d|
+            ::Gem::Dependency.new d['name'], *d['requirements'].split(',')
+          end
+
+        metadata[:dev_deps] =
+          specj['dependencies']['development'].collect do |d|
+            ::Gem::Dependency.new d['name'], d['requirements'].split(',')
+          end
+
+        new metadata
+      end
+
+      # Retrieve all versions of gem available on rubygems
+      def self.remote_versions_for(name)
+        client.url = "https://rubygems.org/api/v1/versions/#{name}.json"
+        client.follow_location = true
+        client.http_get
+        json = JSON.parse(client.body_str)
+        json.collect { |version| version['number'] }
+      end
+
+      # Retieve latest version of gem available on rubygems
+      def self.latest_version_of(name)
+        remote_versions_for(name).first
+      end
+
+      # Return new instance of Gem from Gemspec
+      def self.from_gemspec(gemspec)
+        gemspec  =
+          ::Gem::Specification.load(gemspec) if !gemspec.is_a?(::Gem::Specification) &&
+                                                 File.exist?(gemspec)
+
+        metadata           = {}
+        metadata[:spec]    = gemspec
+        metadata[:name]    = gemspec.name
+        metadata[:version] = gemspec.version.to_s
+
+        metadata[:deps] =
+          gemspec.dependencies.select { |dep|
+            dep.type == :runtime
+          }.collect { |dep| dep }
+
+        metadata[:dev_deps] =
+          gemspec.dependencies.select { |dep|
+            dep.type == :development
+          }.collect { |dep| dep }
+
+        new metadata
+      end
+
+      # Return new instance of Gem from rubygem
+      def self.from_gem(gem_path)
+        gem = parse :gemspec => ::Gem::Package.new(gem_path).spec
+        gem.path = gem_path
+        gem
+      end
+
+      # Parse the specified gemspec & return new Gem instance from metadata
+      #
+      # @param [String,Hash] args contents of actual gemspec of option hash
+      # specifying location of gemspec to parse
+      # @option args [String] :gemspec path to gemspec to load / parse
+      # @return [Polisher::Gem] gem instantiated from gemspec metadata
+      def self.parse(args={})
+        if args.is_a?(String)
+          return from_json args
+
+        elsif args.key?(:gemspec)
+          return from_gemspec args[:gemspec]
+
+        elsif args.key?(:gem)
+          return from_gem args[:gem]
 
-    # Iterate over each file in gem invoking block with path
-    def each_file(&bl)
-      self.unpack do |dir|
-        Pathname(dir).find do |path|
-          next if path.to_s == dir.to_s
-          pathstr = path.to_s.gsub("#{dir}/", '')
-          bl.call pathstr unless pathstr.blank?
         end
+
+        new
       end
-    end
-
-    # Retrieve the list of paths to files in the gem
-    #
-    # @return [Array<String>] list of files in the gem
-    def file_paths
-      @file_paths ||= begin
-        files = []
-        self.each_file do |path|
-          files << path
+
+      # Return handler to internal curl helper
+      def self.client
+        @client ||= Curl::Easy.new
+      end
+
+      # Download the specified gem and return the binary file contents as a string
+      #
+      # @return [String] binary gem contents
+      def self.download_gem(name, version)
+        cached = GemCache.get(name, version)
+        return cached unless cached.nil?
+
+        client.url = "https://rubygems.org/gems/#{name}-#{version}.gem"
+        client.follow_location = true
+        client.http_get
+        gemf = client.body_str
+
+        GemCache.set(name, version, gemf)
+        gemf
+      end
+
+      # Download the local gem and return it as a string
+      def download_gem
+        self.class.download_gem @name, @version
+      end
+
+      # Download the specified gem / version from rubygems and
+      # return instance of Polisher::Gem class corresponding to it
+      def self.from_rubygems(name, version)
+        download_gem name, version
+        from_gem downloaded_gem_path(name, version)
+      end
+
+      # Returns path to downloaded gem
+      #
+      # @return [String] path to downloaded gem
+      def self.downloaded_gem_path(name, version)
+        # ensure gem is downloaded
+        download_gem name, version
+        GemCache.path_for(name, version)
+      end
+
+      # Return path to downloaded gem
+      def downloaded_gem_path
+        self.class.downloaded_gem_path @name, @version
+      end
+
+      # Returns path to gem, either specified one of downloaded one
+      def gem_path
+        @path || downloaded_gem_path
+      end
+
+      # Unpack files & return unpacked directory
+      #
+      # If block is specified, it will be invoked
+      # with directory after which directory will be removed
+      def unpack(&bl)
+        dir = nil
+        pkg = ::Gem::Installer.new gem_path, :unpack => true
+
+        if bl
+          Dir.mktmpdir do |tmpdir|
+            pkg.unpack tmpdir
+            bl.call tmpdir
+          end
+        else
+          dir = Dir.mktmpdir
+          pkg.unpack dir
+        end
+
+        dir
+      end
+
+      # Iterate over each file in gem invoking block with path
+      def each_file(&bl)
+        unpack do |dir|
+          Pathname(dir).detect do |path|
+            next if path.to_s == dir.to_s
+            pathstr = path.to_s.gsub("#{dir}/", '')
+            bl.call pathstr unless pathstr.blank?
+          end
         end
-        files
       end
-    end
-
-    # Retrieve gem metadata and contents from rubygems.org
-    #
-    # @param [String] name string name of gem to retrieve
-    # @return [Polisher::Gem] representation of gem
-    def self.retrieve(name)
-      gem_json_path = "https://rubygems.org/api/v1/gems/#{name}.json"
-      spec = Curl::Easy.http_get(gem_json_path).body_str
-      gem  = self.parse spec
-      gem
-    end
-
-    # Retreive versions of gem available in all configured targets (optionally recursively)
-    #
-    # @param [Hash] args hash of options to configure retrieval
-    # @option args [Boolean] :recursive indicates if versions of dependencies
-    # should also be retrieved
-    # @option args [Boolean] :dev_deps indicates if versions of development
-    # dependencies should also be retrieved
-    # @return [Hash<name,versions>] hash of name to list of versions for gem
-    # (and dependencies if specified)
-    def versions(args={}, &bl)
-      recursive = args[:recursive]
-      dev_deps  = args[:dev_deps]
-      versions  = args[:versions] || {}
-
-      gem_versions = Polisher::VersionChecker.versions_for(self.name, &bl)
-      versions.merge!({ self.name => gem_versions })
-      args[:versions] = versions
-
-      if recursive
-        self.deps.each { |dep|
-          unless versions.has_key?(dep.name)
-            gem = Polisher::Gem.retrieve(dep.name)
-            versions.merge! gem.versions(args, &bl)
+
+      # Retrieve the list of paths to files in the gem
+      #
+      # @return [Array<String>] list of files in the gem
+      def file_paths
+        @file_paths ||= begin
+          files = []
+          each_file do |path|
+            files << path
           end
-        }
+          files
+        end
+      end
 
-        if dev_deps
-          self.dev_deps.each { |dep|
-            unless versions.has_key?(dep.name)
+      # Retrieve gem metadata and contents from rubygems.org
+      #
+      # @param [String] name string name of gem to retrieve
+      # @return [Polisher::Gem] representation of gem
+      def self.retrieve(name)
+        gem_json_path = "https://rubygems.org/api/v1/gems/#{name}.json"
+        spec = Curl::Easy.http_get(gem_json_path).body_str
+        gem  = parse spec
+        gem
+      end
+
+      # Retreive versions of gem available in all configured targets (optionally recursively)
+      #
+      # @param [Hash] args hash of options to configure retrieval
+      # @option args [Boolean] :recursive indicates if versions of dependencies
+      # should also be retrieved
+      # @option args [Boolean] :dev_deps indicates if versions of development
+      # dependencies should also be retrieved
+      # @retrieve versions of all gem dependencies available in configured targets
+      def dependency_versions(args = {}, &bl)
+        versions   = args[:versions] || {}
+        check_deps = args[:dev] ? dev_deps : deps
+
+        check_deps.each do |dep|
+          unless versions.key?(dep.name)
+            begin
               gem = Polisher::Gem.retrieve(dep.name)
               versions.merge! gem.versions(args, &bl)
+            rescue
+              unknown = Polisher::VersionChecker.unknown_version(:all, dep.name, &bl)
+              versions.merge! dep.name => unknown
             end
-          }
+          end
+
+          args[:versions] = versions
         end
+
+        versions
       end
-      versions
-    end
-
-    # Return diff of content in this gem against other
-    def diff(other)
-      out = nil
-
-      begin
-        this_dir  = self.unpack
-        other_dir = other.is_a?(Polisher::Gem) ? other.unpack :
-                   (other.is_a?(Polisher::Git::Repo) ? other.path : other)
-        result = AwesomeSpawn.run("#{DIFF_CMD} -r #{this_dir} #{other_dir}")
-        out = result.output.gsub("#{this_dir}", 'a').gsub("#{other_dir}", 'b')
-      rescue
-      ensure
-        FileUtils.rm_rf this_dir  unless this_dir.nil?
-        FileUtils.rm_rf other_dir unless  other_dir.nil? ||
-                                         !other.is_a?(Polisher::Gem)
+
+      # (and dependencies if specified)
+      def versions(args = {}, &bl)
+        local_args = Hash[args]
+        recursive  = local_args[:recursive]
+        dev_deps   = local_args[:dev_deps]
+        versions   = local_args[:versions] || {}
+
+        gem_versions = Polisher::VersionChecker.versions_for(name, &bl)
+        versions.merge! name => gem_versions
+        local_args[:versions] = versions
+
+        if recursive
+          dependency_versions local_args
+          dependency_versions local_args.merge(:dev => true) if dev_deps
+        end
+
+        versions
       end
 
-      out
-    end
 
-  end # class Gem
+      # Return diff of content in this gem against other
+      def diff(other)
+        require_cmd! diff_cmd
+        out = nil
+
+        begin
+          this_dir  = unpack
+          other_dir = other.is_a?(Polisher::Gem) ? other.unpack :
+                     (other.is_a?(Polisher::Git::Repo) ? other.path : other)
+          result = AwesomeSpawn.run("#{diff_cmd} -r #{this_dir} #{other_dir}")
+          out = result.output.gsub("#{this_dir}", 'a').gsub("#{other_dir}", 'b')
+        rescue
+        ensure
+          FileUtils.rm_rf this_dir  unless this_dir.nil?
+          FileUtils.rm_rf other_dir unless  other_dir.nil? ||
+                                           !other.is_a?(Polisher::Gem)
+        end
+
+        out
+      end
+    end # class Gem
+  end # Component.verify("Gem")
 end # module Polisher