polisher 0.4 → 0.5.1

data/lib/polisher/gemspec.rb

@@ -0,0 +1,32 @@
+# Polisher Gemspec Represenation
+#
+# Licensed under the MIT license
+# Copyright (C) 2013 Red Hat, Inc.
+
+require 'polisher/version_checker'
+
+module Polisher
+  class Gemspec
+    include VersionedDependencies
+
+    attr_accessor :deps
+
+    def initialize(args={})
+      @deps     = args[:deps]
+    end
+
+    # Parse the specified gemspec & return new Gemspec instance from metadata
+    #
+    # @param [String] path to gemspec to parse
+    # @return [Polisher::Gemspec] gemspec instantiated from parsed metadata
+    def self.parse(path)
+      parser = Gemnasium::Parser.gemspec(File.read(path))
+      metadata = {:deps => [], :dev_deps => []}
+      parser.dependencies.each { |dep|
+        metadata[:deps] << dep.name
+      }
+
+      self.new metadata
+    end
+  end
+end

data/lib/polisher/git.rb

@@ -0,0 +1,135 @@
+# Polisher DistGit Package Representation
+#
+# Licensed under the MIT license
+# Copyright (C) 2013 Red Hat, Inc.
+
+# TODO use ruby git api and others
+
+require 'polisher/rpmspec'
+
+module Polisher
+  class GitPackage
+    attr_accessor :name
+    attr_accessor :version
+
+    # TODO these should be to be configurable
+    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]
+    end
+
+    # Return full rpm name of package containing optional prefix
+    def rpm_name
+      "#{RPM_PREFIX}#{self.name}"
+    end
+
+    # Return full srpm file name of package
+    def srpm
+      "#{rpm_name}-#{self.version}-1.*.src.rpm"
+    end
+
+    # Return full spec file name
+    def spec
+      "#{rpm_name}.spec"
+    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}"
+
+      unless File.directory? rpm_name
+        `#{PKG_CMD} clone #{rpm_name}`
+      end
+      
+      # cd into working directory
+      Dir.chdir rpm_name
+
+      if File.exists? 'dead.package'
+        raise Exception, "Dead package detected"
+      end
+      
+      # checkout the latest rawhide
+      # TODO allow other branches to be specified
+      `#{GIT_CMD} checkout master`
+      `#{GIT_CMD} reset HEAD~ --hard`
+      `#{GIT_CMD} pull`
+
+      self.new :name => name
+    end
+
+    # Update the locally cloned package to the specified gem version
+    #
+    # @param [Polisher::Gem] gem instance of gem containing metadata to update to
+    def update_to(gem)
+      # TODO use Polisher::RPMSpec to update spec
+      `#{SED_CMD} -i "s/Version.*/Version: #{gem.version}/" #{spec}`
+      `#{SED_CMD} -i "s/Release:.*/Release: 1%{?dist}/" #{spec}`
+      `#{MD5SUM_CMD} #{gem.name}-#{gem.version}.gem > sources`
+      File.open(".gitignore", "w") { |f| f.write "#{gem.name}-#{gem.version}.gem" }
+    end
+
+    # Build the locally cloned package using the configured build command
+    def build
+      # build srpm
+      `#{PKG_CMD} srpm`
+      
+      # attempt to build packages
+      `#{BUILD_CMD} build --scratch #{BUILD_TGT} #{srpm}`
+      # TODO if build fails, spit out error, exit
+    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?
+      open(spec, "r") do |spec|
+        spec.lines.any? { |line| line.include?("%check") }
+      end 
+    end
+
+    # Command the local package to the local git repo
+    def commit
+      # git add spec, git commit w/ message
+      `#{GIT_CMD} add #{spec} sources .gitignore`
+      #`git add #{gem_name}-#{version}.gem`
+      `#{GIT_CMD} commit -m 'updated to #{self.version}'`
+    end
+
+    # Retrieve list of the version of the specified package in git
+    #
+    # @param [String] name name of package to lookup
+    # @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
+          `#{GIT_CMD} clone #{DIST_GIT_URL}#{rpm_name}.git . >& /dev/null`
+          begin
+            spec = Polisher::RPMSpec.parse(File.read("#{rpm_name}.spec"))
+            version = spec.version
+          rescue => e
+          end
+        end
+      end
+
+      bl.call(:git, name, [version]) unless(bl.nil?) 
+      version
+    end
+  end # class GitPackage
+end # module Polisher

data/lib/polisher/koji.rb

@@ -0,0 +1,54 @@
+# Polisher Koji Operations
+#
+# Licensed under the MIT license
+# Copyright (C) 2013 Red Hat, Inc.
+
+require 'xmlrpc/client'
+XMLRPC::Config::ENABLE_NIL_PARSER = true
+XMLRPC::Config::ENABLE_NIL_CREATE = true
+
+module Polisher
+  class Koji
+    KOJI_URL = 'koji.fedoraproject.org/kojihub'
+    KOJI_TAG = 'f21'
+
+    # Get/Set the koji url
+    def self.koji_url(value=nil)
+      @koji_url ||= KOJI_URL
+      @koji_url   = value unless value.nil?
+      @koji_url
+    end
+
+    # 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
+
+    # Retrieve shared instance of xmlrpc client to use
+    def self.client
+      @client ||= begin
+        url = self.koji_url.split('/')
+        XMLRPC::Client.new(url[0..-2].join('/'),
+                           "/#{url.last}")
+      end
+    end
+
+    # Retrieve list of the version of the specified package in koji
+    #
+    # @param [String] name name of package to lookup
+    # @param [Callable] bl optional block to invoke with versions retrieved
+    # @return [String] versions retrieved, or nil if none found
+    def self.versions_for(name, &bl)
+      # koji xmlrpc call
+      builds =
+        self.client.call('listTagged',
+          self.koji_tag, nil, false, nil, false,
+          "rubygem-#{name}")
+      versions = builds.collect { |b| b['version'] }
+      bl.call(:koji, name, versions) unless(bl.nil?) 
+      versions
+    end
+  end
+end

data/lib/polisher/rhn.rb

@@ -0,0 +1,14 @@
+# Polisher RHN Operations
+#
+# Licensed under the MIT license
+# Copyright (C) 2013 Red Hat, Inc.
+
+require 'pkgwat'
+
+module Polisher
+  class RHN
+    def self.version_for(name)
+      # TODO
+    end
+  end
+end

data/lib/polisher/rpmspec.rb

@@ -0,0 +1,254 @@
+# Polisher RPM Spec Represenation
+#
+# Licensed under the MIT license
+# Copyright (C) 2013 Red Hat, Inc.
+
+require 'polisher/core'
+
+module Polisher
+  class RPMSpec
+    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\((.*)\)$/
+    SPEC_SUBPACKAGE_MATCHER     = /^%package\s(.*)$/
+    SPEC_CHANGELOG_MATCHER      = /^%changelog$/
+    SPEC_FILES_MATCHER          = /^%files$/
+    SPEC_SUBPKG_FILES_MATCHER   = /^%files\s*(.*)$/
+    
+    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
+
+    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
+
+    # Parse the specified rpm spec and return new RPMSpec instance from metadata
+    #
+    # @param [String] string contents of spec to parse
+    # @return [Polisher::RPMSpec] 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] << $1.strip
+    
+        elsif l =~ SPEC_BUILD_REQUIRES_MATCHER &&
+              !in_subpackage
+          meta[:build_requires] ||= []
+          meta[:build_requires] << $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 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 RPMSpec 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
+
+    def update_deps_from(new_source)
+      non_gem_requires    = []
+      non_gem_brequires   = []
+      extra_gem_requires  = []
+      extra_gem_brequires = []
+
+      @metadata[:requires] ||= []
+      @metadata[:requires].each { |r|
+        if r !~ SPEC_GEM_REQ_MATCHER
+          non_gem_requires << r
+        elsif !new_source.deps.include?($1)
+          extra_gem_requires << r
+        end
+      }
+
+      @metadata[:build_requires] ||= []
+      @metadata[:build_requires].each { |r|
+        if r !~ SPEC_GEM_REQ_MATCHER
+          non_gem_brequires << r
+        elsif !new_source.dev_deps.include?($1)
+          extra_gem_brequires << r
+        end
+      }
+
+      @metadata[:requires] =
+        non_gem_requires + extra_gem_requires +
+        new_source.deps.collect { |r| "rubygem(#{r})" }
+
+      @metadata[:build_requires] =
+        non_gem_brequires + extra_gem_brequires +
+        new_source.dev_deps.collect { |r| "rubygem(#{r})" }
+    end
+
+    def update_files_from(new_source)
+      to_add = new_source.files
+      @metadata[:files] ||= {}
+      @metadata[:files].each { |pkg,spec_files|
+        (new_source.files & 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
+        }
+      }
+
+      @metadata[:new_files] = to_add
+    end
+
+    def update_metadata_from(new_source)
+      # update to new version
+      @metadata[:version] = new_source.version
+
+      # better release updating ?
+      release = "1%{?dist}"
+      @metadata[:release] = release
+
+      # add changelog entry
+      changelog_entry = <<EOS
+* #{Time.now.strftime("%a %b %d %Y")} #{AUTHOR} - #{$version}-#{release}
+- 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}" } +
+         @metadata[:build_requires].collect { |r| "BuildRequires: #{r}" }).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
+
+  end # class RPMSpec
+end # module Polisher