polisher 0.7.1 → 0.8.1

data/lib/polisher/git/project.rb

@@ -0,0 +1,23 @@
+# Polisher Git Based Project Representation
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+require 'polisher/vendor'
+require 'polisher/git/repo'
+
+module Polisher
+  module Git
+    # Git based project representation
+    class Project < Repo
+      include HasVendoredDeps
+
+      # Override vendored to ensure repo is
+      # cloned before retrieving modules
+      def vendored
+        clone unless cloned?
+        super
+      end
+    end # class Project
+  end # module Git
+end # module Polisher

data/lib/polisher/git/repo.rb

@@ -0,0 +1,74 @@
+# Polisher Git Repo Representation
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+require 'awesome_spawn'
+require 'polisher/core'
+require 'polisher/git_cache'
+
+module Polisher
+  module Git
+    # Git Repository
+    class Repo
+      extend ConfHelpers
+  
+      # TODO use ruby git api
+      conf_attr :git_cmd, '/usr/bin/git'
+  
+      attr_accessor :url
+  
+      def initialize(args={})
+        @url  = args[:url]
+      end
+  
+      def path
+        GitCache.path_for(@url)
+      end
+  
+      # Clobber the git repo
+      def clobber!
+        FileUtils.rm_rf path
+      end
+  
+      def clone
+        AwesomeSpawn.run "#{git_cmd} clone #{url} #{path}"
+      end
+  
+      def cloned?
+        File.directory?(path)
+      end
+  
+      def in_repo
+        Dir.chdir path do
+          yield
+        end
+      end
+  
+      def file_paths
+        in_repo { Dir['**/*'] }
+      end
+  
+      # Note be careful when invoking:
+      def reset!
+        in_repo { AwesomeSpawn.run "#{git_cmd} reset HEAD~ --hard" }
+        self
+      end
+  
+      def pull
+        in_repo { AwesomeSpawn.run "#{git_cmd} pull" }
+        self
+      end
+  
+      def checkout(tgt)
+        in_repo { AwesomeSpawn.run "#{git_cmd} checkout #{tgt}" }
+        self
+      end
+  
+      def commit(msg)
+        in_repo { AwesomeSpawn.run "#{git_cmd} commit -m '#{msg}'" }
+        self
+      end
+    end # class Repo
+  end # module Git
+end # module Polisher

data/lib/polisher/koji.rb

@@ -7,29 +7,23 @@ require 'xmlrpc/client'
 XMLRPC::Config::ENABLE_NIL_PARSER = true
 XMLRPC::Config::ENABLE_NIL_CREATE = true
 
+require 'polisher/core'
+
 module Polisher
   class Koji
-    KOJI_URL = 'koji.fedoraproject.org/kojihub'
-    KOJI_TAG = 'f21'
+    extend ConfHelpers
 
-    # Get/Set the koji url
-    def self.koji_url(value=nil)
-      @koji_url ||= KOJI_URL
-      @koji_url   = value unless value.nil?
-      @koji_url
-    end
+    # TODO Koji#build (on class or instance?)
 
-    # Get/Set the koji tag to use
-    def self.koji_tag(value=nil)
-      @koji_tag ||= KOJI_TAG
-      @koji_tag   = value unless value.nil?
-      @koji_tag
-    end
+    # TODO Koji#diff(tag1, tag2)
+
+    conf_attr :koji_url, 'koji.fedoraproject.org/kojihub'
+    conf_attr :koji_tag, 'f21'
 
     # Retrieve shared instance of xmlrpc client to use
     def self.client
       @client ||= begin
-        url = self.koji_url.split('/')
+        url = koji_url.split('/')
         XMLRPC::Client.new(url[0..-2].join('/'),
                            "/#{url.last}")
       end
@@ -60,7 +54,7 @@ module Polisher
       # koji xmlrpc call
       builds =
         self.client.call('listTagged',
-          self.koji_tag, nil, false, nil, false,
+          koji_tag, nil, false, nil, false,
           "rubygem-#{name}")
       versions = builds.collect { |b| b['version'] }
       bl.call(:koji, name, versions) unless(bl.nil?) 

data/lib/polisher/rpm/patch.rb

@@ -0,0 +1,44 @@
+# Polisher RPM Patch Representation
+#
+# Licensed under the MIT license
+# Copyright (C) 2014 Red Hat, Inc.
+
+module Polisher
+  module RPM
+    class Patch
+      attr_accessor :title
+      attr_accessor :content
+
+      def initialize(args={})
+        @title   = args[:title]
+        @content = args[:content]
+      end
+
+      def spec_line(n=0)
+        "Patch#{n}: #{title}"
+      end
+
+      def self.from(diff)
+        return diff.collect { |d| self.from(d) } if diff.is_a?(Array)
+
+        result = {}
+
+        in_diff = nil
+        diff.each_line do |line|
+          if line =~ /diff -r ([^\s]+)+ ([^\s]+)+$/
+            result[in_diff] = diff if in_diff
+            in_diff = $1.gsub(/a\//, '')
+            diff    = ''
+          elsif line =~ /Only in.*$/
+            in_diff = nil
+
+          else
+             diff += line
+          end
+        end
+
+        result.collect { |t,c| self.new :title => t, :content => c }
+      end
+    end
+  end
+end

data/lib/polisher/rpm/requirement.rb

@@ -0,0 +1,188 @@
+# Polisher RPM Requirement Represenation
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+require 'gem2rpm'
+require 'versionomy'
+require 'active_support/core_ext'
+
+require 'polisher/core'
+require 'polisher/gem'
+
+module Polisher
+  module RPM
+    class Requirement
+      # Bool indiciating if req is a BR
+      attr_accessor :br
+
+      # Name of requirement
+      attr_accessor :name
+
+      # Condition, eg >=, =, etc
+      attr_accessor :condition
+
+      # Version number
+      attr_accessor :version
+
+      # Requirement string
+      def str
+        sp = self.specifier
+        sp.nil? ? "#{@name}" : "#{@name} #{sp}"
+      end
+
+      # Specified string
+      def specifier
+        @version.nil? ? nil : "#{@condition} #{@version}"
+      end
+
+      # Instantiate / return new rpm spec requirements from string
+      def self.parse(str, opts={})
+        stra   = str.split
+        br = str.include?('BuildRequires')
+        name = condition = version = nil
+
+        if str.include?('Requires')
+          name      = stra[1] 
+          condition = stra[2]
+          version   = stra[3]
+
+        else
+          name      = stra[0]
+          condition = stra[1]
+          version   = stra[2]
+
+        end
+
+        req = self.new({:name      => name,
+                        :condition => condition,
+                        :version   => version,
+                        :br        => br}.merge(opts))
+        req
+      end
+
+      # Instantiate / return new rpm spec requirements from gem dependency.
+      #
+      # Because a gem dependency may result in multiple spec requirements
+      # this will always return an array of Requirement instances
+      def self.from_gem_dep(gem_dep, br=false)
+        gem_dep.requirement.to_s.split(',').collect { |req|
+          expanded = Gem2Rpm::Helpers.expand_requirement [req.split]
+          expanded.collect { |e|
+            self.new :name      => "rubygem(#{gem_dep.name})",
+                     :condition => e.first.to_s,
+                     :version   => e.last.to_s,
+                     :br        => br
+          }
+        }.flatten
+      end
+
+      def initialize(args={})
+        @br        = args[:br] || false
+        @name      = args[:name]
+        @condition = args[:condition]
+        @version   = args[:version]
+
+        @name.strip!      unless @name.nil?
+        @condition.strip! unless @condition.nil?
+        @version.strip!   unless @version.nil?
+      end
+
+      def ==(other)
+        @br        == other.br &&
+        @name      == other.name &&
+        @condition == other.condition &&
+        @version   == other.version
+      end
+
+      # Greatest Common Denominator,
+      # Max version in list that is less than the local version
+      def gcd(versions)
+        lversion = Versionomy.parse(self.version)
+        versions.collect { |v| Versionomy.parse(v) }.
+                 sort { |a,b| a <=> b }.reverse.
+                 find { |v| v < lversion }.to_s
+      end
+
+      # Minimum gem version which satisfies this dependency
+      def min_satisfying_version
+        return "0.0"        if self.version.nil?      ||
+                               self.condition == '<'  ||
+                               self.condition == '<='
+        return self.version if self.condition == '='  ||
+                               self.condition == '>='
+        Versionomy.parse(self.version).bump(:tiny).to_s # self.condition == '>'
+      end
+
+      # Max gem version which satisfies this dependency
+      #
+      # Can't automatically deduce in '<' case, so if that is the conditional
+      # we require a version list, and will return the gcd from it
+      def max_satisfying_version(versions=nil)
+        return Float::INFINITY if self.version.nil?      ||
+                                  self.condition == '>'  ||
+                                  self.condition == '>='
+        return self.version    if self.condition == '='  ||
+                                  self.condition == '<='
+
+        raise ArgumentError    if versions.nil?
+        self.gcd(versions)
+      end
+
+      # Minimum gem version for which this dependency fails
+      def min_failing_version
+        raise ArgumentError if self.version.nil?
+        return "0.0"        if self.condition == '>'  ||
+                               self.condition == '>='
+        return self.version if self.condition == '<'
+        Versionomy.parse(self.version).bump(:tiny).to_s # self.condition == '<=' and '='
+      end
+
+      # Max gem version for which this dependency fails
+      #
+      # Can't automatically deduce in '>=', and '=' cases, so if that is the
+      # conditional we require a version list, and will return the gcd from it
+      def max_failing_version(versions=nil)
+        raise ArgumentError if self.version.nil?      ||
+                               self.condition == '<=' ||
+                               self.condition == '<'
+        return self.version if self.condition == '>'
+
+        raise ArgumentError if versions.nil?
+        self.gcd(versions)
+      end
+
+      # Return bool indicating if requirement matches specified
+      # depedency.
+      #
+      # Comparison mechanism will depend on type of class
+      # passed to this. Valid types include
+      # - Polisher::RPM::Requirements
+      # - ::Gem::Dependency
+      def matches?(dep)
+        return self == dep      if dep.is_a?(self.class)
+        raise ArgumentError unless dep.is_a?(::Gem::Dependency)
+
+        return false if !self.gem? || self.gem_name != dep.name
+        return true  if  self.version.nil?
+
+        Gem2Rpm::Helpers.expand_requirement([dep.requirement.to_s.split]).
+          any?{ |req|
+            req.first == self.condition && req.last.to_s == self.version
+          }
+      end
+
+      # Whether or not this requirement specified a ruby gem dependency
+      def gem?
+        !!(self.str =~ RPM::Spec::SPEC_GEM_REQ_MATCHER)
+      end
+
+      # Return the name of the gem which this requirement is for.
+      # Returns nil if this is not a gem requirement
+      def gem_name
+        # XXX need to explicitly run regex here to get $1
+        !!(self.str =~ RPM::Spec::SPEC_GEM_REQ_MATCHER) ? $1 : nil
+      end
+    end # class Requirement
+  end # module RPM 
+end

data/lib/polisher/rpm/spec.rb

@@ -0,0 +1,381 @@
+# Polisher RPM Spec Represenation
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+require 'gem2rpm'
+require 'versionomy'
+require 'active_support/core_ext'
+
+require 'polisher/core'
+require 'polisher/gem'
+require 'polisher/rpm/requirement'
+
+module Polisher
+  module RPM
+    class Spec
+      AUTHOR = "#{ENV['USER']} <#{ENV['USER']}@localhost.localdomain>"
+  
+      COMMENT_MATCHER             = /^\s*#.*/
+      GEM_NAME_MATCHER            = /^%global\s*gem_name\s(.*)$/
+      SPEC_NAME_MATCHER           = /^Name:\s*rubygem-(.*)$/
+      SPEC_VERSION_MATCHER        = /^Version:\s*(.*)$/
+      SPEC_RELEASE_MATCHER        = /^Release:\s*(.*)$/
+      SPEC_REQUIRES_MATCHER       = /^Requires:\s*(.*)$/
+      SPEC_BUILD_REQUIRES_MATCHER = /^BuildRequires:\s*(.*)$/
+      SPEC_GEM_REQ_MATCHER        = /^.*\s*rubygem\((.*)\)(\s*(.*))?$/
+      SPEC_SUBPACKAGE_MATCHER     = /^%package\s(.*)$/
+      SPEC_CHANGELOG_MATCHER      = /^%changelog$/
+      SPEC_FILES_MATCHER          = /^%files$/
+      SPEC_SUBPKG_FILES_MATCHER   = /^%files\s*(.*)$/
+      SPEC_CHECK_MATCHER          = /^%check$/
+      
+      FILE_MACRO_MATCHERS         =
+        [/^%doc\s/,     /^%config\s/,  /^%attr\s/,
+         /^%verify\s/,  /^%docdir.*/,  /^%dir\s/,
+         /^%defattr.*/, /^%exclude\s/, /^%{gem_instdir}\/+/]
+      
+      FILE_MACRO_REPLACEMENTS =
+        {"%{_bindir}"    => 'bin',
+         "%{gem_libdir}" => 'lib'}
+  
+      attr_accessor :metadata
+  
+      # Return the currently configured author
+      def self.current_author
+        ENV['POLISHER_AUTHOR'] || AUTHOR
+      end
+  
+      def initialize(metadata={})
+        @metadata = metadata
+      end
+  
+      # Dispatch all missing methods to lookup calls in rpm spec metadata
+      def method_missing(method, *args, &block)
+        # proxy to metadata
+        if @metadata.has_key?(method)
+          @metadata[method]
+  
+        else
+          super(method, *args, &block)
+        end
+      end
+  
+      # Return boolean indicating if spec has a %check section
+      def has_check?
+        @metadata.has_key?(:has_check) && @metadata[:has_check]
+      end
+  
+      # Return all the Requires for the specified gem
+      def requirements_for_gem(gem_name)
+        @metadata[:requires].nil? ? [] :
+        @metadata[:requires].select { |r| r.gem_name == gem_name }
+      end
+
+      # Return all the BuildRequires for the specified gem
+      def build_requirements_for_gem(gem_name)
+        @metadata[:build_requires].nil? ? [] :
+        @metadata[:build_requires].select { |r| r.gem_name == gem_name }
+      end
+
+      # Return bool indicating if this spec specifies all the
+      # requirements in the specified gem dependency
+      #
+      # @param [Gem::Dependency] gem_dep dependency which to retreive / compare
+      # requirements
+      def has_all_requirements_for?(gem_dep)
+        reqs = self.requirements_for_gem gem_dep.name
+        # create a spec requirement dependency for each expanded subrequirement,
+        # verify we can find a match for that
+        gem_dep.requirement.to_s.split(',').all? { |greq|
+          Gem2Rpm::Helpers.expand_requirement([greq.split]).all? { |ereq|
+            tereq = Requirement.new :name      => "rubygem(#{gem_dep.name})",
+                                    :condition => ereq.first,
+                                    :version   => ereq.last.to_s
+            reqs.any? { |req| req.matches?(tereq)}
+          }
+        }
+      end
+
+      # Return all gem Requires
+      def gem_requirements
+        @metadata[:requires].nil? ? [] :
+        @metadata[:requires].select { |r| r.gem? }
+      end
+
+      # Return all gem BuildRequires
+      def gem_build_requirements
+        @metadata[:build_requires].nil? ? [] :
+        @metadata[:build_requires].select { |r| r.gem? }
+      end
+
+      # Return all non gem Requires
+      def non_gem_requirements
+        @metadata[:requires].nil? ? [] :
+        @metadata[:requires].select { |r| !r.gem? }
+      end
+
+      # Return all non gem BuildRequires
+      def non_gem_build_requirements
+        @metadata[:build_requires].nil? ? [] :
+        @metadata[:build_requires].select { |r| !r.gem? }
+      end
+
+      # Return all gem requirements _not_ in the specified gem
+      def extra_gem_requirements(gem)
+        gem_reqs = gem.deps.collect { |d| requirements_for_gem(d.name) }.flatten
+        gem_requirements - gem_reqs
+      end
+
+      # Return all gem build requirements _not_ in the specified gem
+      def extra_gem_build_requirements(gem)
+        gem_reqs = gem.deps.collect { |d| requirements_for_gem(d.name) }.flatten
+        gem_build_requirements - gem_reqs
+      end
+  
+      # Parse the specified rpm spec and return new RPM::Spec instance from metadata
+      #
+      # @param [String] string contents of spec to parse
+      # @return [Polisher::RPM::Spec] spec instantiated from rpmspec metadata
+      def self.parse(spec)
+        in_subpackage = false
+        in_changelog  = false
+        in_files      = false
+        subpkg_name   = nil
+        meta = {:contents => spec}
+        spec.each_line { |l|
+          if l =~ COMMENT_MATCHER
+            ;
+      
+          # TODO support optional gem prefix
+          elsif l =~ GEM_NAME_MATCHER
+            meta[:gem_name] = $1.strip
+            meta[:gem_name] = $1.strip
+      
+          elsif l =~ SPEC_NAME_MATCHER &&
+                $1.strip != "%{gem_name}"
+            meta[:gem_name] = $1.strip
+      
+          elsif l =~ SPEC_VERSION_MATCHER
+            meta[:version] = $1.strip
+      
+          elsif l =~ SPEC_RELEASE_MATCHER
+            meta[:release] = $1.strip
+      
+          elsif l =~ SPEC_SUBPACKAGE_MATCHER
+            subpkg_name = $1.strip
+            in_subpackage = true
+      
+          elsif l =~ SPEC_REQUIRES_MATCHER &&
+                !in_subpackage
+            meta[:requires] ||= []
+            meta[:requires] << RPM::Requirement.parse($1.strip)
+      
+          elsif l =~ SPEC_BUILD_REQUIRES_MATCHER &&
+                !in_subpackage
+            meta[:build_requires] ||= []
+            meta[:build_requires] << RPM::Requirement.parse($1.strip)
+      
+          elsif l =~ SPEC_CHANGELOG_MATCHER
+            in_changelog = true
+      
+          elsif l =~ SPEC_FILES_MATCHER
+            subpkg_name = nil
+            in_files = true
+      
+          elsif l =~ SPEC_SUBPKG_FILES_MATCHER
+            subpkg_name = $1.strip
+            in_files = true
+  
+          elsif l =~ SPEC_CHECK_MATCHER
+            meta[:has_check] = true
+      
+          elsif in_changelog
+            meta[:changelog] ||= ""
+            meta[:changelog] << l
+      
+          elsif in_files
+            tgt = subpkg_name.nil? ? meta[:gem_name] : subpkg_name
+            meta[:files] ||= {}
+            meta[:files][tgt] ||= []
+      
+            sl = l.strip.unrpmize
+            meta[:files][tgt] << sl unless sl.blank?
+          end
+        }
+      
+        meta[:changelog_entries] = meta[:changelog] ?
+                                   meta[:changelog].split("\n\n") : []
+        meta[:changelog_entries].collect! { |c| c.strip }.compact!
+  
+        self.new meta
+      end
+  
+      # Update RPM::Spec metadata to new gem
+      #
+      # @param [Polisher::Gem] new_source new gem to update rpmspec to
+      def update_to(new_source)
+        update_deps_from(new_source)
+        update_files_from(new_source)
+        update_metadata_from(new_source)
+      end
+  
+      private
+
+      # Update spec dependencies from new source
+      def update_deps_from(new_source)
+        @metadata[:requires] =
+          non_gem_requirements +
+          extra_gem_requirements(new_source) +
+          new_source.deps.collect { |r|
+            RPM::Requirement.from_gem_dep(r)
+          }.flatten
+  
+        @metadata[:build_requires] =
+          non_gem_build_requirements +
+          extra_gem_build_requirements(new_source) +
+          new_source.dev_deps.collect { |r|
+            RPM::Requirement.from_gem_dep(r, true)
+          }.flatten
+      end
+  
+      # Internal helper to update spec files from new source
+      def update_files_from(new_source)
+        to_add = new_source.file_paths
+        @metadata[:files] ||= {}
+        @metadata[:files].each { |pkg,spec_files|
+          (new_source.file_paths & to_add).each { |gem_file|
+            # skip files already included in spec or in dir in spec
+            has_file = spec_files.any? { |sf|
+                         gem_file.gsub(sf,'') != gem_file
+                       }
+  
+            to_add.delete(gem_file)
+            to_add << gem_file.rpmize if !has_file &&
+                                         !Gem.ignorable_file?(gem_file)
+          }
+        }
+  
+        @metadata[:new_files] = to_add
+      end
+  
+      # Internal helper to update spec metadata from new source
+      def update_metadata_from(new_source)
+        # update to new version
+        @metadata[:version] = new_source.version
+        @metadata[:release] = "1%{?dist}"
+  
+        # add changelog entry
+        changelog_entry = <<EOS
+* #{Time.now.strftime("%a %b %d %Y")} #{RPM::Spec.current_author} - #{@metadata[:version]}-1
+- Update to version #{new_source.version}
+EOS
+        @metadata[:changelog_entries] ||= []
+        @metadata[:changelog_entries].unshift changelog_entry.rstrip
+      end
+  
+      public
+  
+      # Return properly formatted rpmspec as string
+      # 
+      # @return [String] string representation of rpm spec
+      def to_string
+        contents = @metadata[:contents]
+  
+        # replace version / release
+        contents.gsub!(SPEC_VERSION_MATCHER, "Version: #{@metadata[:version]}")
+        contents.gsub!(SPEC_RELEASE_MATCHER, "Release: #{@metadata[:release]}")
+  
+        # add changelog entry
+        cp  = contents.index SPEC_CHANGELOG_MATCHER
+        cpn = contents.index "\n", cp
+        contents = contents[0...cpn+1] +
+                   @metadata[:changelog_entries].join("\n\n")
+  
+        # update requires/build requires
+        rp   = contents.index SPEC_REQUIRES_MATCHER
+        brp  = contents.index SPEC_BUILD_REQUIRES_MATCHER
+        tp   = rp < brp ? rp : brp
+  
+        pp   = contents.index SPEC_SUBPACKAGE_MATCHER
+        pp   = -1 if pp.nil?
+  
+        lrp  = contents.rindex SPEC_REQUIRES_MATCHER, pp
+        lbrp = contents.rindex SPEC_BUILD_REQUIRES_MATCHER, pp
+        ltp  = lrp > lbrp ? lrp : lbrp
+  
+        ltpn = contents.index "\n", ltp
+  
+        contents.slice!(tp...ltpn)
+        contents.insert tp,
+          (@metadata[:requires].collect { |r| "Requires: #{r.str}" } +
+           @metadata[:build_requires].collect { |r| "BuildRequires: #{r.str}" }).join("\n")
+  
+        # add new files
+         fp = contents.index SPEC_FILES_MATCHER
+        lfp = contents.index SPEC_SUBPKG_FILES_MATCHER, fp + 1
+        lfp = contents.index SPEC_CHANGELOG_MATCHER if lfp.nil?
+  
+        contents.insert lfp - 1, @metadata[:new_files].join("\n") + "\n"
+  
+        # return new contents
+        contents
+      end
+  
+      # Compare this spec to a sepecified upstream gem source
+      # and return result.
+      #
+      # upstream_source should be an instance of Polisher::Gem,
+      # Polisher::Gemfile, or other class defining a 'deps'
+      # accessor that returns an array of Gem::Requirement dependencies
+      #
+      # Result will be a hash containing the shared dependencies as
+      # well as those that differ and their respective differences
+      def compare(upstream_source)
+        same = {}
+        diff = {}
+        upstream_source.deps.each do |d|
+          spec_reqs = self.requirements_for_gem(d.name)
+          spec_reqs_specifier = spec_reqs.empty? ? nil :
+               spec_reqs.collect { |req| req.specifier }
+  
+          if spec_reqs.nil?
+            diff[d.name] = {:spec     => nil,
+                            :upstream => d.requirement.to_s}
+  
+          elsif !spec_reqs.any? { |req| req.matches?(d) } ||
+                !self.has_all_requirements_for?(d)
+            diff[d.name] = {:spec     => spec_reqs_specifier,
+                            :upstream => d.requirement.to_s}
+  
+          elsif !diff.has_key?(d.name)
+            same[d.name] = {:spec     => spec_reqs_specifier,
+                            :upstream => d.requirement.to_s }
+          end
+        end
+  
+        @metadata[:requires].each do |req|
+          next unless req.gem?
+  
+          upstream_dep = upstream_source.deps.find { |d| d.name == req.gem_name }
+  
+          if upstream_dep.nil?
+            diff[req.gem_name] = {:spec     => req.specifier,
+                                  :upstream => nil}
+  
+          elsif !req.matches?(upstream_dep)
+            diff[req.gem_name] = {:spec     => req.specifier,
+                                  :upstream => upstream_dep.requirement.to_s }
+  
+          elsif !diff.has_key?(req.gem_name)
+            same[req.gem_name] = {:spec     => req.specifier,
+                                  :upstream => upstream_dep.requirement.to_s }
+          end
+        end unless @metadata[:requires].nil?
+  
+        {:same => same, :diff => diff}
+      end
+  
+    end # class Spec
+  end # module RPM
+end # module Polisher