polisher 0.10.2 → 0.11.1

data/lib/polisher/bodhi.rb

@@ -1,23 +0,0 @@
-# Polisher Bodhi Operations
-#
-# Licensed under the MIT license
-# Copyright (C) 2013-2014 Red Hat, Inc.
-
-# XXX issue w/ retreiving packages from pkgwat causing sporadic issues:
-# https://github.com/fedora-infra/fedora-packages/issues/55
-require 'polisher/component'
-
-module Polisher
-  # fedora pkgwat provides a frontend to bodhi
-  Component.verify("Bodhi", "pkgwat") do
-    class Bodhi
-      def self.versions_for(name, &bl)
-        versions = Pkgwat.get_updates("rubygem-#{name}", 'all', 'all').
-                     select  { |update| update['stable_version']  != 'None' }.
-                     collect { |update| update['stable_version'] }
-        bl.call(:bodhi, name, versions) unless(bl.nil?)
-        versions
-      end
-    end
-  end
-end

data/lib/polisher/config.rb

@@ -1,32 +0,0 @@
-# Polisher Config Operations
-#
-# Licensed under the MIT license
-# Copyright (C) 2013-2014 Red Hat, Inc.
-
-require 'yaml'
-require 'active_support'
-require 'active_support/core_ext'
-
-module Polisher
-  class Config
-    CONF    = "#{ENV['HOME']}/.polisher/config"
-    TARGETS = [['koji',    'polisher/koji',    'Koji'],
-               ['distgit', 'polisher/git/pkg', 'Git::Pkg'],
-               ['rpm',     'polisher/rpm/spec', 'RPM::Requirement'],
-               ['tags',    'polisher/tag_mapper', 'TagMapper']]
-
-    def self.opts
-      @opts ||=  File.exist?(CONF) ? YAML.load_file(CONF) : {}
-    end
-
-    def self.set
-      TARGETS.each do |target, req, polisher_class|
-        if opts[target]
-          require req
-          target_class = "Polisher::#{polisher_class}".constantize
-          opts[target].each { |k, v| target_class.send(k.intern, v) }
-        end
-      end
-    end
-  end # class Config
-end # module Polisher

data/lib/polisher/core.rb

@@ -1,101 +0,0 @@
-# Polisher Core Ruby Extensions
-#
-# Licensed under the MIT license
-# Copyright (C) 2013-2014 Red Hat, Inc.
-
-require 'polisher/config'
-
-module ConfHelpers
-  module ClassMethods
-    # Defines a 'config attribute' or attribute on the class
-    # which this is defined in. Accessors to the single shared
-    # attribute will be added to the class as well as instances
-    # of the class. Specify the default value with the attr name
-    # or via an env variable
-    #
-    # @example
-    #   class Custom
-    #     extend ConfHelpers
-    #     conf_attr :data_dir, '/etc/'
-    #   end
-    #   Custom.data_dir # => '/etc/'
-    #   ENV['POLISHER_DATA_DIR'] = '/usr/'
-    #   Custom.data_dir # => '/usr/'
-    #   Custom.data_dir == Custom.new.data_dir # => true
-    #
-    def conf_attr(name, default=nil)
-      self.send(:define_singleton_method, name) do |*args|
-        nvar = "@#{name}".intern
-        current = self.instance_variable_get(nvar)
-        envk    = "POLISHER_#{name.to_s.upcase}"
-        instance_variable_set(nvar, default)    unless current
-        instance_variable_set(nvar, ENV[envk])  if ENV.key?(envk)
-        # TODO also allow vars to be able to be set from a conf file
-        self.instance_variable_set(nvar, args.first) unless args.empty?
-        self.instance_variable_get(nvar)
-      end
-
-      self.send(:define_method, name) do
-        self.class.send(name)
-      end
-    end
-
-    def cmd_available?(cmd)
-      File.exist?(cmd) && File.executable?(cmd)
-    end
-
-    def require_cmd!(cmd)
-      raise "command #{cmd} not available" unless cmd_available?(cmd)
-    end # module ClassMethods
-  end
-
-  def self.included(base)
-    base.extend(ClassMethods)
-  end
-
-  def require_cmd!(cmd)
-    self.class.require_cmd!(cmd)
-  end
-end
-
-class String
-  # Return bool indicating if self is a path to a gem
-  def gem?
-    File.extname(self) == ".gem"
-  end
-
-  # Return bool indicating if self is a path to a gemspec
-  def gemspec?
-    File.extname(self) == ".gemspec"
-  end
-
-  # Return bool indicating if self is a path to a Gemfile
-  def gemfile?
-    File.basename(self) == "Gemfile"
-  end
-
-  # Remove and replace all occurances of rpm macros in self with non-rpm
-  # macro correspondents. If no rpm macro is specified macro will
-  # simply be removed
-  def unrpmize
-    require 'polisher/rpm/spec'
-    matchers = Polisher::RPM::Spec::FILE_MACRO_MATCHERS
-    replacements = Polisher::RPM::Spec::FILE_MACRO_REPLACEMENTS
-    f = matchers.inject(self) { |file, matcher| file.gsub(matcher, '') }
-    f = replacements.keys.inject(f) { |file, r| file.gsub(Regexp.new(r), replacements[r]) }
-    f
-  end
-
-  # Replace all occurrances of non-rpm macro strings in self
-  # with their macro correspondences
-  def rpmize
-    require 'polisher/rpm/spec'
-    matchers = Polisher::RPM::Spec::FILE_MACRO_MATCHERS
-    replacements = Polisher::RPM::Spec::FILE_MACRO_REPLACEMENTS.invert
-    f = replacements.keys.inject(self) { |file, r| file.gsub(r, replacements[r]) }
-
-    special = (matchers + replacements.values).any? { |matcher| f =~ /^#{matcher}.*/ }
-    f = special ? f : "%{gem_instdir}/#{f}"
-    f
-  end
-end

data/lib/polisher/errata.rb

@@ -1,75 +0,0 @@
-# Polisher Errata Operations
-#
-# Licensed under the MIT license
-# Copyright (C) 2013-2014 Red Hat, Inc.
-
-require 'polisher/core'
-require 'polisher/component'
-
-module Polisher
-  Component.verify("Errata", 'json', 'curb') do
-    class Errata
-      include ConfHelpers
-
-      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
-
-      def self.clear!
-        @cached_url = nil
-        @cached_builds = nil
-        self
-      end
-
-      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
-
-        @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 # 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
-
-      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 # class ErrataBuild
-  end # Component.verify(Errata)
-end # module Polisher

data/lib/polisher/fedora.rb

@@ -1,46 +0,0 @@
-# Polisher Fedora Operations
-#
-# Licensed under the MIT license
-# Copyright (C) 2013-2014 Red Hat, Inc.
-
-require 'polisher/bodhi'
-require 'polisher/component'
-
-module Polisher
-  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
-
-      # 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, pkg_name, versions|
-          bl.call(:fedora, pkg_name, versions) unless bl.nil?
-        end
-      end
-    end # class Fedora
-  end # Component.verify("Fedora")
-end # module Polisher

data/lib/polisher/git.rb

@@ -1,8 +0,0 @@
-# Polisher Git Entity Representations
-#
-# Licensed under the MIT license
-# Copyright (C) 2013-2014 Red Hat, Inc.
-
-require 'polisher/git/repo'
-require 'polisher/git/pkg'
-require 'polisher/git/project'

data/lib/polisher/koji.rb

@@ -1,159 +0,0 @@
-# Polisher Koji Operations
-#
-# Licensed under the MIT license
-# Copyright (C) 2013-2014 Red Hat, Inc.
-
-require 'polisher/core'
-require 'polisher/component'
-
-module Polisher
-  deps = ['awesome_spawn', 'xmlrpc/client', 'active_support',
-          'active_support/core_ext/kernel/reporting']
-  Component.verify("Koji", *deps) do
-    silence_warnings do
-      XMLRPC::Config::ENABLE_NIL_PARSER = true
-      XMLRPC::Config::ENABLE_NIL_CREATE = true
-    end
-
-    class Koji
-      include ConfHelpers
-
-      conf_attr :koji_url, 'koji.fedoraproject.org/kojihub'
-      conf_attr :koji_tag, 'f21'
-      conf_attr :package_prefix, 'rubygem-'
-
-      # XXX don't like having to shell out to koji but quickest
-      # way to get an authenticated session so as to launch builds
-      conf_attr :build_cmd, '/usr/bin/koji'
-      conf_attr :build_tgt,    'rawhide'
-
-      def self.koji_tags
-        [koji_tag].flatten
-      end
-
-      def self.package_prefixes
-        [package_prefix].flatten
-      end
-
-      # Retrieve shared instance of xmlrpc client to use
-      def self.client
-        @client ||= begin
-          url = koji_url.split('/')
-          XMLRPC::Client.new(url[0..-2].join('/'),
-                             "/#{url.last}")
-        end
-      end
-
-      # Return bool indiciating if koji has a build exactly
-      # matching the specified version
-      def self.has_build?(name, version)
-        versions = versions_for name
-        versions.include?(version)
-      end
-
-      # Return bool indicating if koji has a build which
-      # satisfies the specified ruby dependency
-      def self.has_build_satisfying?(name, version)
-        dep = ::Gem::Dependency.new name, version
-        versions_for(name).any? { |v| dep.match?(name, v) }
-      end
-
-      # Return list of tags for which a package exists
-      #
-      # @param [String] name of package to lookup
-      # @return [Hash<String,String>] hash of tag names to package versions for tags
-      # which package was found in
-      def self.tagged_in(name)
-        #                               tagid  userid         pkgid  prefix inherit with_dups
-        pkgs = client.call('listPackages', nil, nil, "rubygem-#{name}", nil, false, true)
-        pkgs.collect { |pkg| pkg['tag_name'] }
-      end
-
-      # Retrieve list of the versions 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 [Array<String>] versions retrieved, empty array if none found
-      def self.versions_for(name, &bl)
-        # koji xmlrpc call
-        versions = tagged_versions_for(name).values.flatten.uniq
-        bl.call(:koji, name, versions) unless bl.nil?
-        versions
-      end
-
-      def self.tagged_versions_for(name)
-        versions = {}
-        koji_tags.each do |tag|
-          versions[tag] = versions_for_tag(name, tag).flatten.uniq
-        end
-        versions
-      end
-
-      def self.tagged_version_for(name)
-        versions = {}
-        tagged_versions_for(name).each do |tag, tagged_versions|
-          versions[tag] = tagged_versions.first
-        end
-        versions
-      end
-
-      def self.versions_for_tag(name, tag)
-        metadata =
-          package_prefixes.collect do |prefix|
-            #                         tag  event inherit prefix latest
-            client.call('listTagged', tag, nil,  true,   nil,   false,
-                        "#{prefix}#{name}")
-          end
-
-        metadata.flatten.collect { |b| b['version'] }.uniq
-      end
-
-      # Run a build against the specified target using the specified rpm
-      def self.build(args = {})
-        require_cmd! build_cmd
-
-        target  = args[:target] || build_tgt
-        srpm    = args[:srpm]
-        scratch = args[:scratch] ? '--scratch' : ''
-
-        cmd = "#{build_cmd} build #{scratch} #{target} #{srpm}"
-        result = AwesomeSpawn.run(cmd)
-        url = parse_url(result.output)
-        raise url if result.exit_status != 0
-        url
-      end
-
-      # Parse a koji build url from output
-      def self.parse_url(output)
-        task_info = output.lines.detect { |l| l =~ /Task info:.*/ }
-        task_info ? task_info.split.last : ''
-      end
-
-      # def self.build_logs(url) # TODO
-
-      # Return diff between list of packages in two tags in koji
-      def self.diff(tag1, tag2)
-        builds1 = client.call('listTagged', tag1, nil, false, nil, false)
-        builds2 = client.call('listTagged', tag2, nil, false, nil, false)
-        builds  = {}
-        builds1.each do |build|
-          name         = build['package_name']
-          build2       = builds2.detect { |b| b['name'] == name }
-          version1     = build['version']
-          version2     = build2 && build2['version']
-          builds[name] = {tag1 => version1, tag2 => version2}
-        end
-
-        builds2.each do |build|
-          name = build['package_name']
-          next if builds.key?(name)
-
-          version = build['version']
-          builds[name] = {tag1 => nil, tag2 => version}
-        end
-
-        builds
-      end
-    end # class Koji
-  end # Component.verify("Koji")
-end # module Polisher