polisher 0.6.1 → 0.7.1

data/lib/polisher/gem_cache.rb

@@ -0,0 +1,34 @@
+# Mechanism to cache gems
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+require 'fileutils'
+
+module Polisher
+  class GemCache
+    DIR = "#{ENV['HOME']}/.polisher/gems"
+
+    def self.create!
+      FileUtils.mkdir_p(DIR) unless File.directory?(DIR)
+    end
+
+    def self.clear!
+      FileUtils.rm_rf(DIR)
+    end
+
+    def self.path_for(name, version)
+      "#{DIR}/#{name}-#{version}.gem"
+    end
+
+    def self.get(name, version)
+      path = path_for(name, version)
+      File.exists?(path) ? File.read(path) : nil
+    end
+
+    def self.set(name, version, gem)
+      self.create!
+      File.write(path_for(name, version), gem)
+    end
+  end # class GemCache
+end # module Polisher

data/lib/polisher/gemfile.rb

@@ -1,7 +1,7 @@
 # Polisher Gemfile Represenation
 #
 # Licensed under the MIT license
-# Copyright (C) 2013 Red Hat, Inc.
+# Copyright (C) 2013-2014 Red Hat, Inc.
 
 require 'bundler'
 
@@ -39,13 +39,13 @@ module Polisher
     attr_accessor :dev_deps
 
     # always empty array, for interface compatability
-    attr_accessor :files
+    attr_accessor :file_paths
 
     def initialize(args={})
       @version  = nil
       @deps     = args[:deps]
       @dev_deps = args[:dev_deps]
-      @files    = []
+      @file_paths = []
     end
 
     # Parse the specified gemfile & return new Gemfile instance from metadata
@@ -68,5 +68,14 @@ module Polisher
 
       self.new metadata
     end
+
+    # TODO simply alias for gems in gemfile?
+    def vendored
+    end
+
+    # TODO retrieve gems which differ from
+    # rubygems.org/other upstream sources
+    def patched
+    end
   end # class Gemfile
 end # module Polisher

data/lib/polisher/gemspec.rb

@@ -1,7 +1,7 @@
 # Polisher Gemspec Represenation
 #
 # Licensed under the MIT license
-# Copyright (C) 2013 Red Hat, Inc.
+# Copyright (C) 2013-2014 Red Hat, Inc.
 
 require 'polisher/version_checker'
 

data/lib/polisher/git.rb

@@ -1,112 +1,209 @@
-# Polisher DistGit Package Representation
+# Polisher Git Entity Representations
 #
 # Licensed under the MIT license
-# Copyright (C) 2013 Red Hat, Inc.
-
-# TODO use ruby git api and others
+# Copyright (C) 2013-2014 Red Hat, Inc.
 
 require 'tmpdir'
 require 'awesome_spawn'
 require 'polisher/rpmspec'
+require 'polisher/git_cache'
 
 module Polisher
-  class GitPackage
+  # Git Repository
+  class GitRepo
+    # TODO use ruby git api
+    GIT_CMD      = '/usr/bin/git'
+
+    attr_accessor :url
+
+    def initialize(args={})
+      @url  = args[:url]
+    end
+
+    def path
+      GitCache.path_for(@url)
+    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
+
+    # 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
+
+  # DistGit Package Representation
+  class GitPackage < GitRepo
     attr_accessor :name
     attr_accessor :version
 
     # TODO these should be to be configurable
+    RPM_PREFIX   = 'rubygem-'
     PKG_CMD      = '/usr/bin/fedpkg'
-    GIT_CMD      = '/usr/bin/git'
     BUILD_CMD    = '/usr/bin/koji'
     BUILD_TGT    = 'rawhide'
+
     MD5SUM_CMD   = '/usr/bin/md5sum'
     SED_CMD      = '/usr/bin/sed'
-    RPM_PREFIX   = 'rubygem-'
     DIST_GIT_URL = 'git://pkgs.fedoraproject.org/'
 
     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_PREFIX}#{self.name}"
+      @rpm_name ||= "#{RPM_PREFIX}#{self.name}"
     end
 
     # Return full srpm file name of package
     def srpm
-      "#{rpm_name}-#{self.version}-1.*.src.rpm"
+      @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::RPMSpec corresponding to spec
     def spec
-      "#{rpm_name}.spec"
+      @spec ||= in_repo { Polisher::RPMSpec.parse spec_file }
     end
 
-    # Clone git package
-    #
-    # @param [String] name name of package to clone
-    # @return [Polisher::GitPackage] git package instance representing cloned package
-    def self.clone(name)
-      rpm_name = "#{RPM_PREFIX}#{name}"
+    # 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
 
-      unless File.directory? rpm_name
+    # Alias orig clone method to git_clone
+    alias :git_clone :clone
+
+    # Override clone to use PKG_PCMD
+    # @override
+    def clone
+      in_repo do
         AwesomeSpawn.run "#{PKG_CMD} clone #{rpm_name}"
+        Dir.glob(rpm_name, '*').each { |f| File.move f, '.' }
+        FileUtils.rm_rf rpm_name
       end
-      
-      # cd into working directory
-      Dir.chdir rpm_name
 
-      if File.exists? 'dead.package'
-        raise Exception, "Dead package detected"
+      self
+    end
+
+    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 'master'
+      reset!
+      pull
+
+      self
+    end
+
+    # Update the local spec to the specified gem version
+    #
+    # FIXME this should be removed and calls replaced with self.spec.update_to(gem)
+    def update_spec_to(gem)
+      in_repo do
+        replace_version = "s/Version.*/Version: #{gem.version}/"
+        replace_release = "s/Release:.*/Release: 1%{?dist}/"
+        [replace_version, replace_release].each do |replace|
+          AwesomeSpawn.run "#{SED_CMD} -i '#{replace}' #{spec_file}"
+        end
       end
-      
-      # checkout the latest rawhide
-      # TODO allow other branches to be specified
-      AwesomeSpawn.run "#{GIT_CMD} checkout master"
-      AwesomeSpawn.run "#{GIT_CMD} reset HEAD~ --hard"
-      AwesomeSpawn.run "#{GIT_CMD} pull"
+    end
 
-      self.new :name => name
+    # Generate new sources file
+    def gen_sources_for(gem)
+      in_repo do
+        AwesomeSpawn.run "#{MD5SUM_CMD} #{gem.name}-#{gem.version}.gem > sources"
+      end
+    end
+
+    # Update git ignore to ignore gem
+    def ignore(gem)
+      File.open(".gitignore", "w") { |f| f.write "#{gem.name}-#{gem.version}.gem" }
     end
 
-    # Update the locally cloned package to the specified gem version
+    # Update the local pkg to specified gem
     #
     # @param [Polisher::Gem] gem instance of gem containing metadata to update to
     def update_to(gem)
-      # TODO use Polisher::RPMSpec to update spec
-      AwesomeSpawn.run "#{SED_CMD} -i 's/Version.*/Version: #{gem.version}/' #{spec}"
-      AwesomeSpawn.run "#{SED_CMD} -i 's/Release:.*/Release: 1%{?dist}/' #{spec}"
-      AwesomeSpawn.run "#{MD5SUM_CMD} #{gem.name}-#{gem.version}.gem > sources"
-      File.open(".gitignore", "w") { |f| f.write "#{gem.name}-#{gem.version}.gem" }
+      update_spec_to  gem
+      gen_sources_for gem
+      ignore gem
+      self
     end
 
-    # Build the locally cloned package using the configured build command
-    def build
-      # build srpm
-      AwesomeSpawn.run "#{PKG_CMD} srpm"
-      
-      # attempt to build packages
-      AwesomeSpawn.run "#{BUILD_CMD} build --scratch #{BUILD_TGT} #{srpm}"
-      # TODO if build fails, spit out error, exit
+    # 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
 
-    # Return boolean indicating if package spec has a %check section
-    #
-    # @return [Boolean] true/false depending on whether or not spec has %check
-    def has_check?
-      File.open(spec, "r") do |spec|
-        spec.lines.any? { |line| line.include?("%check") }
-      end 
+    # Build the srpm
+    def build_srpm
+      in_repo { AwesomeSpawn.run "#{PKG_CMD} srpm" }
+      self
     end
 
-    # Command the local package to the local git repo
-    def commit
-      # git add spec, git commit w/ message
-      AwesomeSpawn.run "#{GIT_CMD} add #{spec} sources .gitignore"
-      #`git add #{gem_name}-#{version}.gem`
-      AwesomeSpawn.run "#{GIT_CMD} commit -m 'updated to #{self.version}'"
+    # 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
@@ -115,23 +212,24 @@ module Polisher
     # @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)
-      rpm_name = "#{RPM_PREFIX}#{name}"
       version = nil
-
-      Dir.mktmpdir do |dir|
-        Dir.chdir(dir) do |path|
-          version = nil
-          AwesomeSpawn.run "#{GIT_CMD} clone #{DIST_GIT_URL}#{rpm_name}.git ."
-          begin
-            spec = Polisher::RPMSpec.parse(File.read("#{rpm_name}.spec"))
-            version = spec.version
-          rescue => e
-          end
-        end
+      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 # class GitPackage
+
+  # Upstream Git project representation
+  class GitProject < GitRepo
+    # TODO scan project for vendored components
+    def vendored
+    end
+  end
 end # module Polisher

data/lib/polisher/git_cache.rb

@@ -0,0 +1,25 @@
+# Mechanism to cache git repos
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+require 'fileutils'
+
+module Polisher
+  class GitCache
+    DIR = "#{ENV['HOME']}/.polisher/git"
+
+    def self.create!
+      FileUtils.mkdir_p(DIR) unless File.directory?(DIR)
+    end
+
+    def self.clear!
+      FileUtils.rm_rf(DIR)
+    end
+
+    def self.path_for(id)
+      self.create!
+      "#{DIR}/#{id.gsub(/[:\/]/, '')}"
+    end
+  end # class GemCache
+end # module Polisher

data/lib/polisher/koji.rb

@@ -1,7 +1,7 @@
 # Polisher Koji Operations
 #
 # Licensed under the MIT license
-# Copyright (C) 2013 Red Hat, Inc.
+# Copyright (C) 2013-2014 Red Hat, Inc.
 
 require 'xmlrpc/client'
 XMLRPC::Config::ENABLE_NIL_PARSER = true

data/lib/polisher/rhn.rb

@@ -1,7 +1,7 @@
 # Polisher RHN Operations
 #
 # Licensed under the MIT license
-# Copyright (C) 2013 Red Hat, Inc.
+# Copyright (C) 2013-2014 Red Hat, Inc.
 
 require 'pkgwat'
 

data/lib/polisher/rpmspec.rb

@@ -1,15 +1,163 @@
 # Polisher RPM Spec Represenation
 #
 # Licensed under the MIT license
-# Copyright (C) 2013 Red Hat, Inc.
+# Copyright (C) 2013-2014 Red Hat, Inc.
 
 require 'gem2rpm'
+require 'versionomy'
 require 'active_support/core_ext'
 
 require 'polisher/core'
+require 'polisher/gem'
 
 module Polisher
   class RPMSpec
+    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
+
+      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
+
+      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
+
+      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
+
+      def gem?
+        !!(self.str =~ SPEC_GEM_REQ_MATCHER)
+      end
+
+      def gem_name
+        # XXX need to explicitly run regex here to get $1
+        !!(self.str =~ SPEC_GEM_REQ_MATCHER) ? $1 : nil
+      end
+    end
+
     AUTHOR = "#{ENV['USER']} <#{ENV['USER']}@localhost.localdomain>"
 
     COMMENT_MATCHER             = /^\s*#.*/
@@ -24,18 +172,24 @@ module Polisher
     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}/]
+       /^%defattr.*/, /^%exclude\s/, /^%{gem_instdir}\/+/]
     
     FILE_MACRO_REPLACEMENTS =
-      {"%{_bindir}"    => '/bin',
-       "%{gem_libdir}" => '/lib'}
+      {"%{_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
@@ -51,6 +205,32 @@ module Polisher
       end
     end
 
+    def has_check?
+      @metadata.has_key?(:has_check) && @metadata[:has_check]
+    end
+
+    # Return all the requirements for the specified gem
+    def requirements_for_gem(gem_name)
+      @metadata[:requires].nil? ? [] :
+      @metadata[:requires].select { |r| r.gem_name == gem_name }
+    end
+
+    # Return bool indicating if this spec specifies all the
+    # requirements in the specified gem dependency
+    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
+
     # Parse the specified rpm spec and return new RPMSpec instance from metadata
     #
     # @param [String] string contents of spec to parse
@@ -87,12 +267,12 @@ module Polisher
         elsif l =~ SPEC_REQUIRES_MATCHER &&
               !in_subpackage
           meta[:requires] ||= []
-          meta[:requires] << $1.strip
+          meta[:requires] << RPMSpec::Requirement.parse($1.strip)
     
         elsif l =~ SPEC_BUILD_REQUIRES_MATCHER &&
               !in_subpackage
           meta[:build_requires] ||= []
-          meta[:build_requires] << $1.strip
+          meta[:build_requires] << RPMSpec::Requirement.parse($1.strip)
     
         elsif l =~ SPEC_CHANGELOG_MATCHER
           in_changelog = true
@@ -104,6 +284,9 @@ module Polisher
         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] ||= ""
@@ -128,6 +311,9 @@ module Polisher
 
     # Update RPMSpec metadata to new gem
     #
+    # TODO add option to enable/disable certain aspects
+    # from being updates
+    #
     # @param [Polisher::Gem] new_source new gem to update rpmspec to
     def update_to(new_source)
       update_deps_from(new_source)
@@ -145,9 +331,9 @@ module Polisher
 
       @metadata[:requires] ||= []
       @metadata[:requires].each { |r|
-        if r !~ SPEC_GEM_REQ_MATCHER
+        if !r.gem?
           non_gem_requires << r
-        elsif !new_source.deps.any? { |d| d.name == $1 }
+        elsif !new_source.deps.any? { |d| d.name == r.gem_name }
           extra_gem_requires << r
         #else
         #  spec_version = $2
@@ -156,9 +342,9 @@ module Polisher
 
       @metadata[:build_requires] ||= []
       @metadata[:build_requires].each { |r|
-        if r !~ SPEC_GEM_REQ_MATCHER
+        if !r.gem?
           non_gem_brequires << r
-        elsif !new_source.deps.any? { |d| d.name == $1 }
+        elsif !new_source.deps.any? { |d| d.name == r.gem_name }
           extra_gem_brequires << r
         #else
         #  spec_version = $2
@@ -171,10 +357,13 @@ module Polisher
         non_gem_requires + extra_gem_requires +
         new_source.deps.collect { |r|
           r.requirement.to_s.split(',').collect { |req|
-           expanded = Gem2Rpm::Helpers.expand_requirement [req.split]
-           expanded.collect { |e|
-             "rubygem(#{r.name}) #{e.first} #{e.last}"
-           }
+            expanded = Gem2Rpm::Helpers.expand_requirement [req.split]
+            expanded.collect { |e|
+              RPMSpec::Requirement.new :name      => "rubygem(#{r.name})",
+                                       :condition => e.first.to_s,
+                                       :version   => e.last.to_s,
+                                       :br        => false
+            }
           }
         }.flatten
 
@@ -182,23 +371,30 @@ module Polisher
         non_gem_brequires + extra_gem_brequires +
         new_source.dev_deps.collect { |r|
           r.requirement.to_s.split(',').collect { |req|
-            "rubygem(#{r.name}) #{req}"
+            expanded = Gem2Rpm::Helpers.expand_requirement [req.split]
+            expanded.collect { |e|
+              RPMSpec::Requirement.new :name      => "rubygem(#{r.name})",
+                                       :condition => e.first.to_s,
+                                       :version   => e.last.to_s,
+                                       :br        => true
+            }
           }
         }.flatten
     end
 
     def update_files_from(new_source)
-      to_add = new_source.files
+      to_add = new_source.file_paths
       @metadata[:files] ||= {}
       @metadata[:files].each { |pkg,spec_files|
-        (new_source.files & to_add).each { |gem_file|
+        (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
+          to_add << gem_file.rpmize if !has_file &&
+                                       !Gem.ignorable_file?(gem_file)
         }
       }
 
@@ -208,14 +404,11 @@ module Polisher
     def update_metadata_from(new_source)
       # update to new version
       @metadata[:version] = new_source.version
-
-      # better release updating ?
-      release = "1%{?dist}"
-      @metadata[:release] = release
+      @metadata[:release] = "1%{?dist}"
 
       # add changelog entry
       changelog_entry = <<EOS
-* #{Time.now.strftime("%a %b %d %Y")} #{AUTHOR} - #{$version}-#{release}
+* #{Time.now.strftime("%a %b %d %Y")} #{RPMSpec.current_author} - #{@metadata[:version]}-1
 - Update to version #{new_source.version}
 EOS
       @metadata[:changelog_entries] ||= []
@@ -256,8 +449,8 @@ EOS
 
       contents.slice!(tp...ltpn)
       contents.insert tp,
-        (@metadata[:requires].collect { |r| "Requires: #{r}" } +
-         @metadata[:build_requires].collect { |r| "BuildRequires: #{r}" }).join("\n")
+        (@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
@@ -270,5 +463,50 @@ EOS
       contents
     end
 
+    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 RPMSpec
 end # module Polisher