polisher 0.4 → 0.5.1

data/bin/ruby_rpm_spec_updater.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/ruby
+# Ruby RPM Spec Updater
+#
+# Simple tool to update the rpm spec of a packaged gem
+# or ruby app.
+#
+# User should specify the location of the rpm spec to
+# manipulate. Script takes an additional option to specify
+# the version of the gem to update to or the location of
+# the gem/gemspec/gemfile source which parse and use.
+#
+# Usage: 
+#   ruby_rpm_spec_updater.rb <path-to-spec> <optional-source-or-version>
+#
+# Licensed under the MIT License
+# Copyright (C) 2013 Red Hat, Inc.
+
+require 'colored'
+require 'polisher'
+
+spec_file = ARGV.shift
+source    = ARGV.shift
+rpmspec   = Polisher::RPMSpec.parse File.read(spec_file)
+source    = source.nil? ?
+  Polisher::Gem.retrieve(rpmspec.gem_name) :
+  Polisher::Upstream.parse(source)
+
+rpmspec.update_to(source)
+puts rpmspec.to_string.yellow.bold

data/lib/polisher.rb

@@ -0,0 +1,19 @@
+# Ruby Polisher
+#
+# Licensed under the MIT license
+# Copyright (C) 2013 Red Hat, Inc.
+
+require 'polisher/core'
+require 'polisher/rpmspec'
+require 'polisher/gem'
+require 'polisher/upstream'
+require 'polisher/gemfile'
+require 'polisher/git'
+require 'polisher/apt'
+require 'polisher/yum'
+require 'polisher/bodhi'
+require 'polisher/rhn'
+require 'polisher/bugzilla'
+require 'polisher/koji'
+require 'polisher/fedora'
+require 'polisher/version_checker'

data/lib/polisher/apt.rb

@@ -0,0 +1,12 @@
+# Polisher APT Operations
+#
+# Licensed under the MIT license
+# Copyright (C) 2013 Red Hat, Inc.
+
+module Polisher
+  class Apt
+    def self.version_for(name)
+      # TODO
+    end
+  end
+end

data/lib/polisher/bodhi.rb

@@ -0,0 +1,21 @@
+# Polisher Bodhi Operations
+#
+# Licensed under the MIT license
+# Copyright (C) 2013 Red Hat, Inc.
+
+require 'pkgwat'
+
+module Polisher
+  class Bodhi
+    def self.versions_for(name, &bl)
+      # fedora pkgwat provides a frontend to bodhi
+      updates = Pkgwat.get_updates("rubygem-#{name}", 'all', 'all') # TODO set timeout
+      updates.reject! { |u|
+        u['stable_version'] == 'None' && u['testing_version'] == "None"
+      }
+      versions = updates.collect { |u| u['stable_version'] }
+      bl.call(:bodhi, name, versions) unless(bl.nil?) 
+      versions
+    end
+  end
+end

data/lib/polisher/bugzilla.rb

@@ -0,0 +1,9 @@
+# Polisher Bugzilla Operations
+#
+# Licensed under the MIT license
+# Copyright (C) 2013 Red Hat, Inc.
+
+module Polisher
+  class Bugzilla
+  end
+end

data/lib/polisher/core.rb

@@ -0,0 +1,33 @@
+# Polisher Core Ruby Extensions
+#
+# Licensed under the MIT license
+# Copyright (C) 2013 Red Hat, Inc.
+
+require 'polisher/rpmspec'
+
+class String
+  def gem?
+    File.extname(self) == ".gem"
+  end
+
+  def gemspec?
+    File.extname(self) == ".gemspec"
+  end
+
+  def gemfile?
+    File.basename(self) == "Gemfile"
+  end
+
+  def unrpmize
+    fmm = Polisher::RPMSpec::FILE_MACRO_MATCHERS
+    fmr = Polisher::RPMSpec::FILE_MACRO_REPLACEMENTS
+    f = fmm.inject(self) { |file, matcher| file.gsub(matcher, '') }
+    f = fmr.keys.inject(f) { |file, r| file.gsub(Regexp.new(r), fmr[r]) }
+    f
+  end
+
+  def rpmize
+    fmr = Polisher::RPMSpec::FILE_MACRO_REPLACEMENTS.invert
+    fmr.keys.inject(self) { |file, r| file.gsub(r, fmr[r]) }
+  end
+end

data/lib/polisher/errata.rb

@@ -0,0 +1,43 @@
+# Polisher Errata Operations
+#
+# Licensed under the MIT license
+# Copyright (C) 2013 Red Hat, Inc.
+
+require 'curb'
+
+module Polisher
+  class Errata
+    def self.client(url)
+      @curl ||= begin
+        c = Curl::Easy.new
+        c.ssl_verify_peer = false
+        c.ssl_verify_host = false
+        c.http_auth_types = :negotiate
+        c.userpwd = ':'
+        c.get
+      end
+
+      @curl.url = url
+      @curl
+    end
+
+    def self.versions_for(advisory_url, name, &bl)
+      url    = "#{advisory_url}/builds"
+      result = self.client(url).get
+      json   = JSON.parse result.body_str
+      versions =
+        json.collect { |tag, builds|
+          builds.collect { |build|
+            pkg,meta = *build.flatten
+            if pkg =~ /^rubygem-#{name}-([^-]*)-.*$/
+              $1
+            else
+              nil
+            end
+          }
+        }.flatten.compact
+      bl.call(:errata, name, versions) unless(bl.nil?) 
+      versions
+    end
+  end
+end

data/lib/polisher/fedora.rb

@@ -0,0 +1,43 @@
+# Polisher Fedora Operations
+#
+# Licensed under the MIT license
+# Copyright (C) 2013 Red Hat, Inc.
+
+require 'curb'
+require 'pkgwat'
+
+module Polisher
+  class Fedora
+    PACKAGE_LIST = 'https://admin.fedoraproject.org/pkgdb/users/packages/'
+
+    # 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)
+      curl = Curl::Easy.new("#{PACKAGE_LIST}}#{user}")
+      curl.http_get
+      packages = curl.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)
+      # XXX bug w/ python-pkgwat, some html content
+      # is being returned w/ versions, need to look into
+      versions = Pkgwat.get_versions(name)
+      versions.reject! { |pkg| pkg['stable_version'] == "None" }
+      versions = versions.collect { |pkg| pkg['stable_version'] }
+      bl.call(:fedora, name, versions) unless(bl.nil?) 
+      versions
+    end
+  end # class Fedora
+end # module Polisher

data/lib/polisher/gem.rb

@@ -0,0 +1,155 @@
+# Polisher Gem Represenation
+#
+# Licensed under the MIT license
+# Copyright (C) 2013 Red Hat, Inc.
+
+require 'curb'
+require 'json'
+require 'tempfile'
+require 'pathname'
+require 'rubygems/installer'
+require 'active_support/core_ext'
+
+require 'polisher/version_checker'
+
+module Polisher
+  class Gem
+    attr_accessor :name
+    attr_accessor :version
+    attr_accessor :deps
+    attr_accessor :dev_deps
+    attr_accessor :files
+
+    def initialize(args={})
+      @name     = args[:name]
+      @version  = args[:version]
+      @deps     = args[:deps]     || []
+      @dev_deps = args[:dev_deps] || []
+      @files    = args[:files]    || []
+    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)
+      @local_db ||= ::Gem::Specification.all
+      versions = @local_db.select { |s| s.name == name }.collect { |s| s.version }
+      bl.call(:local_gem, name, versions) unless(bl.nil?) 
+      versions
+    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={})
+      metadata = {}
+
+      if args.is_a?(String)
+        specj     = JSON.parse(args)
+        metadata[:name]     = specj['name']
+        metadata[:version]  = specj['version']
+        metadata[:deps]     = specj['dependencies']['runtime'].collect { |d| d['name'] }
+        metadata[:dev_deps] = specj['dependencies']['development'].collect { |d| d['name'] }
+
+      elsif args.has_key?(:gemspec)
+        gemspec  = ::Gem::Specification.load(args[:gemspec])
+        metadata[:name]     = gemspec.name
+        metadata[:version]  = gemspec.version.to_s
+        metadata[:deps]     =
+          gemspec.dependencies.select { |dep| dep.type == :runtime }.collect { |dep| dep.name }
+        metadata[:dev_deps] =
+          gemspec.dependencies.select { |dep| dep.type == :development }.collect { |dep| dep.name }
+
+      elsif args.has_key?(:gem)
+        # TODO
+      end
+
+      self.new metadata
+    end
+
+    # Download the gem and return the binary file contents as a string
+    # @return [String] binary gem contents
+    def download_gem
+      gem_path = "https://rubygems.org/gems/#{@name}-#{@version}.gem"
+      curl = Curl::Easy.new(gem_path)
+      curl.follow_location = true
+      curl.http_get
+      gemf = curl.body_str
+    end
+
+    # Retrieve the list of files in the gem
+    #
+    # @return [Array<String>] list of files in the gem
+    def refresh_files
+      gemf = download_gem
+      tgem = Tempfile.new(@name)
+      tgem.write gemf
+      tgem.close
+
+      @files = []
+      pkg = ::Gem::Installer.new tgem.path, :unpack => true
+      Dir.mktmpdir { |dir|
+        pkg.unpack dir
+        Pathname(dir).find do |path|
+          pathstr = path.to_s.gsub(dir, '')
+          @files << pathstr unless pathstr.blank?
+        end
+      }
+      @files
+    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.refresh_files
+      gem
+    end
+
+    # Retreive versions of gem available on rubygems.org
+    #
+    # @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] || {}
+      versions.merge!({ self.name => Polisher::VersionChecker.versions_for(self.name, &bl) })
+      args[:versions] = versions
+
+      if recursive
+        self.deps.each { |dep|
+          unless versions.has_key?(dep)
+            gem = Polisher::Gem.retrieve(dep)
+            versions.merge! gem.versions(args, &bl)
+          end
+        }
+
+        if dev_deps
+          self.dev_deps.each { |dep|
+            unless versions.has_key?(dep)
+              gem = Polisher::Gem.retrieve(dep)
+              versions.merge! gem.versions(args, &bl)
+            end
+          }
+        end
+      end
+      versions
+    end
+  end # class Gem
+end # module Polisher

data/lib/polisher/gemfile.rb

@@ -0,0 +1,72 @@
+# Polisher Gemfile Represenation
+#
+# Licensed under the MIT license
+# Copyright (C) 2013 Red Hat, Inc.
+
+require 'bundler'
+
+require 'polisher/version_checker'
+
+# Override bundler's gem registration
+module Bundler
+  class << self
+    attr_accessor :bundler_gems
+
+    def init_gems
+      Bundler.bundler_gems = []
+    end
+  end
+
+  class Dsl
+    alias :old_gem :gem
+    def gem(name, *args)
+      Bundler.bundler_gems ||= []
+      version = args.first.is_a?(Hash) ? nil : args.first
+      Bundler.bundler_gems << [name, version]
+      old_gem(name, *args)
+    end
+  end
+end
+
+module Polisher
+  class Gemfile
+    include VersionedDependencies
+
+    # always nil, for interface compatability
+    attr_accessor :version
+
+    attr_accessor :deps
+    attr_accessor :dev_deps
+
+    # always empty array, for interface compatability
+    attr_accessor :files
+
+    def initialize(args={})
+      @version  = nil
+      @deps     = args[:deps]
+      @dev_deps = args[:dev_deps]
+      @files    = []
+    end
+
+    # Parse the specified gemfile & return new Gemfile instance from metadata
+    # 
+    # @param [String] path to gemfile to parse
+    # @return [Polisher::Gemfile] gemfile instantiated from parsed metadata
+    def self.parse(path)
+      path,g = File.split(path)
+      Dir.chdir(path){
+        Bundler.init_gems
+        begin
+          Bundler::Definition.build(g, nil, false)
+        rescue Bundler::GemfileNotFound
+          raise ArgumentError, "invalid gemfile: #{path}"
+        end
+      }
+      metadata = {}
+      metadata[:deps]     = Bundler.bundler_gems.collect { |n,v| n }
+      metadata[:dev_deps] = [] # TODO
+
+      self.new metadata
+    end
+  end # class Gemfile
+end # module Polisher