polisher 0.10.2 → 0.11.1

data/lib/polisher/{gem_state.rb → gem/state.rb}

@@ -1,12 +1,12 @@
-# Polisher Gem State Represenation
+# Polisher Gem State Mixin
 #
 # Licensed under the MIT license
 # Copyright (C) 2014 Red Hat, Inc.
 
-require 'polisher/tag_mapper'
+require 'polisher/util/tag_mapper'
 
 module Polisher
-  module HasState
+  module GemState
     def koji_tags
       Koji.tagged_version_for(name)
     end
@@ -17,7 +17,7 @@ module Polisher
       return :missing   if koji_tags.empty?
       return :available unless check_dep
 
-      koji_tags.each do |tag, version|
+      koji_tags.each do |_tag, version|
         return :available if !version.nil? && args[:check].match?(name, version)
       end
 
@@ -31,7 +31,7 @@ module Polisher
     def distgit_branches
       tags = []
 
-      koji_tags.each do |tag, version|
+      koji_tags.each do |tag, _version|
         tag = TagMapper.map(tag)
         tags << tag unless tag.nil?
       end
@@ -77,7 +77,7 @@ module Polisher
 
       state = distgit_state(args)
       return :needs_repo   if state == :missing_repo
-      return :needs_branch if state == :missing_branch 
+      return :needs_branch if state == :missing_branch
       return :needs_spec   if state == :missing_spec
       return :needs_build  if state == :available
       return :needs_update

data/lib/polisher/gem/versions.rb

@@ -0,0 +1,131 @@
+# Polisher Gem Versions Mixin
+#
+# Licensed under the MIT license
+# Copyright (C) 2014 Red Hat, Inc.
+
+require 'polisher/adaptors/version_checker'
+
+module Polisher
+  module GemVersions
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # 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 local_versions_for(name, &bl)
+        silence_warnings do
+          @local_db ||= ::Gem::Specification.all
+        end
+        versions = @local_db.select { |s| s.name == name }.collect { |s| s.version }
+        bl.call(:local_gem, name, versions) unless bl.nil?
+        versions
+      end
+
+      # Retrieve all versions of gem available on rubygems
+      def remote_versions_for(name)
+        require 'json'
+
+        client.url = "https://rubygems.org/api/v1/versions/#{name}.json"
+        client.follow_location = true
+        client.http_get
+        json = JSON.parse(client.body_str)
+        json.collect { |version| version['number'] }
+      end
+
+      # Retieve latest version of gem available on rubygems
+      def latest_version_of(name)
+        remote_versions_for(name).collect { |v| ::Gem::Version.new v }.max.to_s
+      end
+
+      # Retrieve versions matching dependency
+      def versions_matching(dep)
+        remote_versions_for(dep.name).select { |v|
+          dep.match? dep.name, v
+        }
+      end
+
+      # Retrieve latest version matching dep
+      def latest_version_matching(dep)
+        version = versions_matching(dep).collect { |v| ::Gem::Version.new v }.max
+        version.nil? ? nil : version.to_s
+      end
+
+      # Retrieve earliest version matching dep
+      def earliest_version_matching(dep)
+        version = versions_matching(dep).collect { |v| ::Gem::Version.new v }.min
+        version.nil? ? nil : version.to_s
+      end
+
+      # Retrieve version of gem matching target
+      def version_matching_target(dep, target)
+        version = versions_in_target(dep.name, target).select  { |v| dep.match? dep.name, v }
+                                                      .collect { |v|   ::Gem::Version.new v }.max
+        version.nil? ? nil : version.to_s
+      end
+
+      # Return versions of gem in target
+      def versions_in_target(name, target)
+        require 'polisher/targets'
+        Polisher.target(target).versions_for(name)
+      end
+
+      # Return latest version of gem in target
+      def latest_version_in_target(name, target)
+        versions_in_target(name, target).collect { |v| ::Gem::Version.new v }.max
+      end
+    end # module ClassMethods
+
+    # Retreive versions of gem available in all configured targets (optionally recursively)
+    #
+    # @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
+    # @retrieve versions of all gem dependencies available in configured targets
+    def dependency_versions(args = {}, &bl)
+      versions   = args[:versions] || {}
+      check_deps = args[:dev] ? dev_deps : deps
+
+      check_deps.each do |dep|
+        unless versions.key?(dep.name)
+          begin
+            gem = Polisher::Gem.retrieve(dep.name)
+            versions.merge! gem.versions(args, &bl)
+          rescue
+            unknown = Polisher::VersionChecker.unknown_version(:all, dep.name, &bl)
+            versions.merge! dep.name => unknown
+          end
+        end
+
+        args[:versions] = versions
+      end
+
+      versions
+    end
+
+    # (and dependencies if specified)
+    def versions(args = {}, &bl)
+      local_args = Hash[args]
+      recursive  = local_args[:recursive]
+      dev_deps   = local_args[:dev_deps]
+      versions   = local_args[:versions] || {}
+
+      gem_versions = Polisher::VersionChecker.versions_for(name, &bl)
+      versions.merge! name => gem_versions
+      local_args[:versions] = versions
+
+      if recursive
+        versions.merge! dependency_versions local_args, &bl
+        versions.merge! dependency_versions local_args.merge(:dev => true), &bl if dev_deps
+      end
+
+      versions
+    end # module ClassMethods
+  end # module GemVersions
+end # module Polisher

data/lib/polisher/gemfile.rb

@@ -1,96 +1,27 @@
-# Polisher Gemfile Represenation
+# Polisher Gemfile
 #
 # Licensed under the MIT license
 # Copyright (C) 2013-2014 Red Hat, Inc.
 
-require 'polisher/git'
-require 'polisher/gem'
-require 'polisher/component'
-require 'polisher/version_checker'
+require 'polisher/mixins/versioned_dependencies'
+require 'polisher/gemfile/attributes'
+require 'polisher/gemfile/parser'
+require 'polisher/gemfile/deps'
 
 module Polisher
-  Component.verify("Gemfile", 'bundler') do
-    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 :file_paths
-
-      attr_accessor :definition
-
-      def initialize(args = {})
-        @version  = nil
-        @deps     = args[:deps]
-        @dev_deps = args[:dev_deps]
-        @definition = args[:definition]
-        @file_paths = []
-      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, args = {})
-        groups = args[:groups]
-
-        definition = nil
-        path, gemfile = File.split(path)
-        Dir.chdir(path){
-          begin
-            definition = Bundler::Definition.build(gemfile, nil, false)
-          rescue Bundler::GemfileNotFound
-            raise ArgumentError, "invalid gemfile: #{path}"
-          end
-        }
-
-        metadata = {}
-        metadata[:deps] =
-          definition.dependencies.select { |d|
-            groups.nil? || groups.empty? ||                  # groups not specified
-            groups.any? { |g| d.groups.include?(g.intern) }  # dep in any group
-          }
-
-        metadata[:dev_deps] = [] # TODO
-        metadata[:definition] = definition
-
-        new metadata
-      end
-
-      # Simply alias for all dependencies in Gemfile
-      def vendored
-        deps + dev_deps
-      end
-
-      # Retrieve gems which differ from
-      # rubygems.org/other upstream sources
-      def patched
-        vendored.collect do |dep|
-          # TODO: right now just handling git based alternate sources,
-          # should be able to handle other types bundler supports
-          # (path and alternate rubygems src)
-          next unless dep.source.is_a?(Bundler::Source::Git)
-          src = dep.source
-
-          # retrieve gem
-          gem = src.version ?
-                Polisher::Gem.new(:name => dep.name, :version => src.version) :
-                Polisher::Gem.retrieve(dep.name)
-
-          # retrieve dep
-          git = Polisher::Git::Repo.new :url => src.uri
-          git.clone unless git.cloned?
-          git.checkout src.ref if src.ref
-
-          # diff gem against git
-          gem.diff(git.path)
-        end.compact!
-      end
-    end # class Gemfile
-  end # Component.verify("Gemfile")
+  class Gemfile
+    include VersionedDependencies
+
+    include GemfileAttributes
+    include GemfileDeps
+    include GemfileParser
+
+    def initialize(args = {})
+      @version    = nil
+      @deps       = args[:deps]
+      @dev_deps   = args[:dev_deps]
+      @definition = args[:definition]
+      @file_paths = []
+    end
+  end # class Gemfile
 end # module Polisher

data/lib/polisher/gemfile/attributes.rb

@@ -0,0 +1,19 @@
+# Polisher Gemfile Attributes Mixin
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+module Polisher
+  module GemfileAttributes
+    # always nil, for interface compatability
+    attr_accessor :version
+
+    attr_accessor :deps
+    attr_accessor :dev_deps
+
+    # always empty array, for interface compatability
+    attr_accessor :file_paths
+
+    attr_accessor :definition
+  end # module GemfileAttributes
+end # module Polisher

data/lib/polisher/gemfile/deps.rb

@@ -0,0 +1,43 @@
+# Polisher Gemfile Deps Mixin
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+require 'polisher/git/repo'
+require 'polisher/gem'
+
+module Polisher
+  module GemfileDeps
+    # Simply alias for all dependencies in Gemfile
+    def vendored
+      deps + dev_deps
+    end
+
+    # Retrieve gems which differ from
+    # rubygems.org/other upstream sources
+    def patched
+      vendored.collect do |dep|
+        # TODO: right now just handling git based alternate sources,
+        # should be able to handle other types bundler supports
+        # (path and alternate rubygems src)
+        next unless dep.source.is_a?(Bundler::Source::Git)
+        src = dep.source
+
+        # retrieve gem
+        gem = if src.version
+                Polisher::Gem.new(:name => dep.name, :version => src.version)
+              else
+                Polisher::Gem.retrieve(dep.name)
+              end
+
+        # retrieve dep
+        git = Polisher::Git::Repo.new :url => src.uri
+        git.clone unless git.cloned?
+        git.checkout src.ref if src.ref
+
+        # diff gem against git
+        gem.diff(git.path)
+      end.compact!
+    end
+  end # module GemfileDeps
+end # module Polisher

data/lib/polisher/gemfile/parser.rb

@@ -0,0 +1,45 @@
+# Polisher Gemfile Parser Mixin
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+module Polisher
+  module GemfileParser
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # 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 parse(path, args = {})
+        require 'bundler'
+
+        groups = args[:groups]
+
+        definition = nil
+        path, gemfile = File.split(path)
+        Dir.chdir(path) do
+          begin
+            definition = Bundler::Definition.build(gemfile, nil, false)
+          rescue Bundler::GemfileNotFound
+            raise ArgumentError, "invalid gemfile: #{path}"
+          end
+        end
+
+        metadata = {}
+        metadata[:deps] = definition.dependencies.select do |d|
+          groups.nil? || groups.empty? ||                  # groups not specified
+          groups.any? { |g| d.groups.include?(g.intern) }  # dep in any group
+        end
+
+        metadata[:dev_deps] = [] # TODO
+        metadata[:definition] = definition
+
+        new metadata
+      end
+    end # module ClassMethods
+  end # module GemfileParser
+end # module Polisher

data/lib/polisher/git/pkg.rb

@@ -1,248 +1,43 @@
-# Polisher Git Based Package (distgit) Representation
+# Polisher Git Package (distgit)
 #
 # Licensed under the MIT license
 # Copyright (C) 2013-2014 Red Hat, Inc.
 
-require 'fileutils'
-
-require 'polisher/error'
 require 'polisher/git/repo'
-require 'polisher/rpm/spec'
-require 'polisher/component'
-require 'polisher/koji'
-require 'polisher/logger'
+require 'polisher/git/pkg/attributes'
+require 'polisher/git/pkg/repo'
+require 'polisher/git/pkg/versions'
+require 'polisher/git/pkg/builder'
+require 'polisher/git/pkg/updater'
 
 module Polisher
   module Git
-    Component.verify("Git::Pkg", 'awesome_spawn') do
-      # Git Based Package
-      class Pkg < Repo
-        extend Logging
-
-        attr_accessor :name
-        attr_accessor :version
-
-        conf_attr :rpm_prefix,   'rubygem-'
-        conf_attr :pkg_cmd,      '/usr/bin/fedpkg'
-        conf_attr :md5sum_cmd,   '/usr/bin/md5sum'
-        conf_attr :dist_git_url, 'git://pkgs.fedoraproject.org/'
-        conf_attr :fetch_tgt,    'master'
-
-        def self.fetch_tgts
-          [fetch_tgt].flatten
-        end
-
-        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_name ||= "#{rpm_prefix}#{name}"
-        end
-
-        # Return full srpm file name of package
-        def srpm
-          @srpm ||= "#{rpm_name}-#{version}-1.*.src.rpm"
-        end
-
-        # Return full spec file name
-        def spec_file
-          @spec_path ||= "#{rpm_name}.spec"
-        end
-
-        # Return boolean indicating if spec file exists
-        def spec?
-          include? spec_file
-        end
-
-        # Return handle to instance of Polisher::RPM::Spec corresponding to spec
-        def spec
-          @spec, @dirty_spec = nil, false if @dirty_spec
-          @spec ||= in_repo { Polisher::RPM::Spec.parse File.read(spec_file) }
-        end
-
-        # 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
-
-        # Alias orig clone method to git_clone
-        alias :git_clone :clone
-
-        # Override clone to use PKG_PCMD
-        # @override
-        def clone
-          require_cmd! pkg_cmd
-          clobber!
-          Dir.mkdir path unless File.directory? path
-          in_repo do
-            result = AwesomeSpawn.run "#{pkg_cmd} clone #{rpm_name}"
-            raise PolisherError,
-                  "could not clone #{rpm_name}" unless result.exit_status == 0
-
-            # pkg_cmd will clone into the rpm_name subdir,
-            # move everything up a dir
-            Dir.foreach("#{rpm_name}/") do |f|
-              orig = "#{rpm_name}/#{f}"
-              skip = ['.', '..'].include?(f)
-              FileUtils.move orig, '.' unless skip
-            end
-
-            FileUtils.rm_rf rpm_name
-          end
-
-          self
-        end
-
-        # Return boolean indicating if package is marked as dead (retired/obsolete/etc)
-        def dead?
-          in_repo { File.exist?('dead.package') }
-        end
-
-        # Fetch specified target or configured fetch_tgt if not specified
-        def fetch(target = nil)
-          target = self.class.fetch_tgts.first if target.nil?
-          clone unless cloned?
-          raise Exception, "Dead package detected" if dead?
-          checkout target
-          reset!
-          pull
-
-          self
-        end
-
-        # Return the valid targets, eg those which we can fetch
-        def valid_targets
-          valid = []
-          self.class.fetch_tgts.collect do |target|
-            begin
-              fetch target
-              valid << target
-            rescue
-              # noop
-            end
-          end
-          valid
-        end
-
-        alias :valid_branches :valid_targets
-
-        def update_metadata(gem)
-          @version = gem.version
-        end
-
-        # Update the local spec to the specified gem version
-        def update_spec_to(gem)
-          in_repo do
-            spec.update_to(gem)
-            File.write(spec_file, spec.to_string)
-            @dirty_spec = true
-          end
-        end
-
-        # Generate new sources file
-        def gen_sources_for(gem)
-          require_cmd! md5sum_cmd
-          in_repo do
-            AwesomeSpawn.run "#{md5sum_cmd} #{gem.gem_path} > sources"
-            File.write('sources', File.read('sources').gsub("#{GemCache::DIR}/", ''))
-          end
-        end
-
-        # Update git ignore to ignore gem
-        def ignore(gem)
-          in_repo do
-            nl = File.exist?('.gitignore') ? "\n" : ''
-            content = "#{nl}#{gem.name}-#{gem.version}.gem"
-            File.open(".gitignore", 'a') { |f| f.write content }
-          end
-        end
-
-        # Update the local pkg to specified gem
-        #
-        # @param [Polisher::Gem] gem instance of gem containing metadata to update to
-        def update_to(gem)
-          update_metadata gem
-          update_spec_to gem
-          gen_sources_for gem
-          ignore gem
-          self
-        end
-
-        # Override commit, generate a default msg, always add pkg files
-        # @override
-        def commit(msg = nil)
-          require_cmd! git_cmd
-          in_repo { AwesomeSpawn.run "#{git_cmd} add #{pkg_files.join(' ')}" }
-          super(msg.nil? ? "updated to #{version}" : msg)
-          self
-        end
-
-        # Build the srpm
-        def build_srpm
-          require_cmd! pkg_cmd
-          in_repo do
-            begin
-              gem = spec.upstream_gem
-              FileUtils.rm_f gem.file_name if File.exist?(gem.file_name)
-              FileUtils.ln_s gem.gem_path, gem.file_name
-              result = AwesomeSpawn.run "#{pkg_cmd} srpm"
-              raise result.error unless result.exit_status == 0
-            ensure
-              FileUtils.rm_f gem.file_name if File.exist?(gem.file_name)
-            end
-          end
-          self
-        end
-
-        # Run a scratch build
-        def scratch_build
-          in_repo do
-            Koji.build :srpm    => srpm,
-                       :scratch => true
-          end
-          self
-        end
-
-        # Build the pkg
-        def build
-          build_srpm
-          scratch_build
-          self
-        end
-
-        # Retrieve list of the versions 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 [Array<String>] versions retrieved, or empty array if none found
-        def self.versions_for(name, &bl)
-          version = nil
-          gitpkg = new :name => name
-          gitpkg.url = "#{dist_git_url}#{gitpkg.rpm_name}.git"
-          versions = []
-          fetch_tgts.each do |tgt|
-            begin
-              gitpkg.fetch tgt
-              versions << gitpkg.spec.version
-            rescue => e
-              logger.warn "error retrieving #{name} from #{gitpkg.url}/#{tgt}(distgit): #{e}"
-            end
-          end
-
-          bl.call(:git, name, versions) unless bl.nil?
-          versions
-        end
-      end # module Pkg
-    end # Component.verify("Git::Pkg")
+    # Git Based Package
+    class Pkg < Repo
+      extend Logging
+
+      include PkgAttributes
+      include PkgRepo
+      include PkgVersions
+
+      include PkgBuilder
+      include PkgUpdater
+
+      conf_attr :rpm_prefix,   'rubygem-'
+      conf_attr :pkg_cmd,      '/usr/bin/fedpkg'
+      conf_attr :md5sum_cmd,   '/usr/bin/md5sum'
+      conf_attr :dist_git_url, 'git://pkgs.fedoraproject.org/'
+      conf_attr :fetch_tgt,    'master'
+
+      def self.fetch_tgts
+        [fetch_tgt].flatten
+      end
+
+      def initialize(args = {})
+        @name    = args[:name]
+        @version = args[:version]
+        super(args)
+      end
+    end # module Pkg
   end # module Git
 end # module Polisher