polisher 0.10.2 → 0.11.1

data/lib/polisher/gem/attributes.rb

@@ -0,0 +1,20 @@
+# Polisher Gem Attributes Mixin
+#
+# Licensed under the MIT license
+# Copyright (C) 2014 Red Hat, Inc.
+
+module Polisher
+  module GemAttributes
+    attr_accessor :spec
+    attr_accessor :name
+    attr_accessor :version
+    attr_accessor :deps
+    attr_accessor :dev_deps
+
+    attr_accessor :path
+
+    def file_name
+      "#{name}-#{version}.gem"
+    end
+  end # module GemAttributes
+end # module Polisher

data/lib/polisher/gem/dependencies.rb

@@ -0,0 +1,63 @@
+# Polisher Gem Dependencies Mixin
+#
+# Licensed under the MIT license
+# Copyright (C) 2014 Red Hat, Inc.
+
+require 'polisher/adaptors/version_checker'
+
+module Polisher
+  module GemDependencies
+    # Retrieve map of gems to dependencies (optionally recursively)
+    def dependency_tree(args = {}, &bl)
+      local_args        = Hash[args]
+      recursive         = local_args[:recursive]
+      retrieve_dev_deps = local_args[:dev_deps]
+      matching          = local_args[:matching]
+      dependencies      = local_args[:dependencies] || {}
+      return dependencies if dependencies.key?(name) && dependencies[name].key?(version)
+
+      dependencies[name]          ||= {}
+      dependencies[name][version]   = deps + dev_deps
+      args[:dependencies]           = dependencies
+
+      resolved_deps = resolve_tree_deps(args.merge({:deps => deps}),     &bl)
+      resolved_dev  = retrieve_dev_deps ? resolve_tree_deps(args.merge({:deps => dev_deps}), &bl) : []
+
+      (resolved_deps + resolved_dev).each { |dep|
+        dependencies.merge! dep.dependency_tree(args, &bl)
+        args[:dependencies] = dependencies
+      } if recursive
+
+      return dependencies
+    end
+
+    private
+
+    def resolve_tree_deps(args = {}, &bl)
+      deps = args[:deps]
+      deps.collect { |dep|
+        resolve_tree_dep args.merge({:dep => dep}), &bl
+      }
+    end
+
+    def resolve_tree_dep(args = {}, &bl)
+      dep          = args[:dep]
+      matching     = args[:matching]
+
+      resolved = nil
+      begin
+        resolved = Polisher::Gem.matching(dep, matching)
+      rescue
+      end
+      bl.call self, dep, resolved
+
+      return resolved unless resolved.nil?
+
+      begin
+        Polisher::Gem.latest_matching(dep)
+      rescue
+        Polisher::Gem.retrieve_latest(dep.name)
+      end
+    end
+  end # module GemVersions
+end # module Polisher

data/lib/polisher/gem/diff.rb

@@ -0,0 +1,39 @@
+# Polisher Gem Diff Mixin
+#
+# Licensed under the MIT license
+# Copyright (C) 2014 Red Hat, Inc.
+
+require 'fileutils'
+require 'polisher/git/repo'
+
+module Polisher
+  module GemDiff
+    # Return diff of content in this gem against other
+    def diff(other)
+      require_dep! 'awesome_spawn'
+      require_cmd! diff_cmd
+      out = nil
+
+      begin
+        this_dir  = unpack
+        other_dir = if other.is_a?(Polisher::Gem)
+                      other.unpack
+                    elsif other.is_a?(Polisher::Git::Repo) 
+                      other.path   
+                    else
+                      other
+                    end
+
+        result = AwesomeSpawn.run("#{diff_cmd} -r #{this_dir} #{other_dir}")
+        out = result.output.gsub("#{this_dir}", 'a').gsub("#{other_dir}", 'b')
+      rescue
+      ensure
+        FileUtils.rm_rf this_dir  unless this_dir.nil?
+        FileUtils.rm_rf other_dir unless  other_dir.nil? ||
+                                         !other.is_a?(Polisher::Gem)
+      end
+
+      out
+    end
+  end # module GemDiff
+end # module Polisher

data/lib/polisher/gem/files.rb

@@ -0,0 +1,111 @@
+# Polisher Gem Files Mixin
+#
+# Licensed under the MIT license
+# Copyright (C) 2014 Red Hat, Inc.
+
+require 'rubygems/installer'
+require 'active_support'
+require 'active_support/core_ext'
+
+module Polisher
+  module GemFiles
+    # Common files shipped in gems that we should ignore
+    IGNORE_FILES = ['.gemtest', '.gitignore', '.travis.yml',
+                    /.*.gemspec/, /Gemfile.*/, 'Rakefile',
+                    /rspec.*/, '.yardopts', '.rvmrc']
+
+    # Critical runtime files that are necessary for the gem to run
+    RUNTIME_FILES = [/\Alib.*/, /\Abin.*/, /\Aapp.*/, /\Avendor.*/]
+
+    # License files
+    LICENSE_FILES = [/\/?MIT/, /\/?GPLv[0-9]+/, /\/?.*LICEN(C|S)E/, /\/?COPYING/]
+
+    # Common files shipped in gems considered doc
+    DOC_FILES = [/\/?CHANGELOG.*/i, /\/?CONTRIBUTING.*/i, /\/?CONTRIBUTORS.*/i,
+                 /\/?README.*/i, /\/?History.*/i, /\/?Release.*/i, /\/?doc(\/.*)?/]
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Return bool indicating if the specified file is on the IGNORE_FILES list
+      def ignorable_file?(file)
+        IGNORE_FILES.any? do |ignore|
+          ignore.is_a?(Regexp) ? ignore.match(file) : ignore == file
+        end
+      end
+
+      # Return bool indicating if the specified file in on the RUNTIME_FILES list
+      def runtime_file?(file)
+        RUNTIME_FILES.any? do |runtime|
+          runtime.is_a?(Regexp) ? runtime.match(file) : runtime == file
+        end
+      end
+
+      # Return bool indicating if the specified file is on the LICENSE_FILES list
+      def license_file?(file)
+        LICENSE_FILES.any? do |license|
+          license.is_a?(Regexp) ? license.match(file) : license == file
+        end
+      end
+
+      # Return bool indicating if the specified file is on the DOC_FILES list
+      def doc_file?(file)
+        DOC_FILES.any? do |doc|
+          doc.is_a?(Regexp) ? doc.match(file) : doc == file
+        end
+      end
+    end # module ClassMethods
+
+    # Return bool indicating if spec file satisfies any file in gem
+    def has_file_satisfied_by?(spec_file)
+      file_paths.any? { |gem_file| RPM::Spec.file_satisfies?(spec_file, gem_file) }
+    end
+
+    # Unpack files & return unpacked directory
+    #
+    # If block is specified, it will be invoked
+    # with directory after which directory will be removed
+    def unpack(&bl)
+      dir = nil
+      pkg = ::Gem::Installer.new gem_path, :unpack => true
+
+      if bl
+        Dir.mktmpdir do |tmpdir|
+          pkg.unpack tmpdir
+          bl.call tmpdir
+        end
+      else
+        dir = Dir.mktmpdir
+        pkg.unpack dir
+      end
+
+      dir
+    end
+
+    # Iterate over each file in gem invoking block with path
+    def each_file(&bl)
+      unpack do |dir|
+        Pathname.new(dir).find do |path|
+          next if path.to_s == dir.to_s
+          pathstr = path.to_s.gsub("#{dir}/", '')
+          bl.call pathstr unless pathstr.blank?
+        end
+      end
+    end
+
+    # Retrieve the list of paths to files in the gem
+    #
+    # @return [Array<String>] list of files in the gem
+    def file_paths
+      @file_paths ||= begin
+        files = []
+        each_file do |path|
+          files << path
+        end
+        files
+      end
+    end
+  end # module GemFiles
+end # module Polisher

data/lib/polisher/gem/parser.rb

@@ -0,0 +1,85 @@
+# Polisher Gem Parser Mixin
+#
+# Licensed under the MIT license
+# Copyright (C) 2014 Red Hat, Inc.
+
+require 'rubygems/installer'
+
+module Polisher
+  module GemParser
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Return new instance of Gem from Gemspec
+      def from_gemspec(gemspec)
+        gemspec  =
+          ::Gem::Specification.load(gemspec) if !gemspec.is_a?(::Gem::Specification) &&
+                                                 File.exist?(gemspec)
+
+        metadata            = {}
+        metadata[:spec]     = gemspec
+        metadata[:name]     = gemspec.name
+        metadata[:version]  = gemspec.version.to_s
+        metadata[:deps]     = gemspec.dependencies
+                                     .select  { |dep| dep.type == :runtime }
+                                     .collect { |dep| dep }
+        metadata[:dev_deps] = gemspec.dependencies
+                                     .select  { |dep| dep.type == :development }
+                                     .collect { |dep| dep }
+
+        new metadata
+      end
+
+      # Return new instance of Gem from JSON Specification
+      def from_json(json)
+        specj     = JSON.parse(json)
+        metadata           = {}
+        metadata[:spec]    = specj
+        metadata[:name]    = specj['name']
+        metadata[:version] = specj['version']
+
+        metadata[:deps] =
+          specj['dependencies']['runtime'].collect do |d|
+            ::Gem::Dependency.new d['name'], *d['requirements'].split(',')
+          end
+
+        metadata[:dev_deps] =
+          specj['dependencies']['development'].collect do |d|
+            ::Gem::Dependency.new d['name'], d['requirements'].split(',')
+          end
+
+        new metadata
+      end
+
+      # Return new instance of Gem from rubygem
+      def from_gem(gem_path)
+        gem = parse :gemspec => ::Gem::Package.new(gem_path).spec
+        gem.path = gem_path
+        gem
+      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 parse(args = {})
+        if args.is_a?(String)
+          return from_json args
+
+        elsif args.key?(:gemspec)
+          return from_gemspec args[:gemspec]
+
+        elsif args.key?(:gem)
+          return from_gem args[:gem]
+
+        end
+
+        new
+      end
+    end # module ClassMethods
+  end # module GemParser
+end # module Polisher

data/lib/polisher/gem/retriever.rb

@@ -0,0 +1,137 @@
+# Polisher Gem Retriever Mixin
+#
+# Licensed under the MIT license
+# Copyright (C) 2014 Red Hat, Inc.
+
+require 'polisher/util/gem_cache'
+
+module Polisher
+  module GemRetriever
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Return handler to internal curl helper
+      def client
+        require 'curb'
+
+        @client ||= Curl::Easy.new
+      end
+
+      # Download the specified gem and return the binary file contents as a string
+      #
+      # @return [String] binary gem contents
+      def download_gem(name, version)
+        cached = GemCache.get(name, version)
+        return cached unless cached.nil?
+
+        client.url = "https://rubygems.org/gems/#{name}-#{version}.gem"
+        client.follow_location = true
+        client.http_get
+        gemf = client.body_str
+
+        GemCache.set(name, version, gemf)
+        gemf
+      end
+
+      # Download the specified gem / version from rubygems and
+      # return instance of Polisher::Gem class corresponding to it
+      def from_rubygems(name, version)
+        download_gem name, version
+        from_gem downloaded_gem_path(name, version)
+      end
+
+      # Returns path to downloaded gem
+      #
+      # @return [String] path to downloaded gem
+      def downloaded_gem_path(name, version)
+        # ensure gem is downloaded
+        download_gem name, version
+        GemCache.path_for(name, version)
+      end
+
+      # Retrieve latest gem metadata and contents from rubygems.org
+      #
+      # @param [String] name string name of gem to retrieve
+      # @return [Polisher::Gem] representation of gem
+      def retrieve_latest(name)
+        client.url = "https://rubygems.org/api/v1/gems/#{name}.json"
+        client.http_get
+        spec = client.body_str
+        gem  = parse spec
+        gem
+      end
+
+      # Retrieve specified metadata and contents for gem version from rubygems.org
+      #
+      # @param [String] name string name of gem to retrieve
+      # @param [String] version string version of gem to retrieve
+      # @return [Polisher::Gem] representation of gem
+      def retrieve_version(name, version)
+        path = downloaded_gem_path name, version
+        parse :gem => path
+      end
+
+      # Retrieve gem metadata and contents from rubygems.org
+      #
+      # @param [String] name string name of gem to retrieve
+      # @param [String] version string version of gem to retrieve,
+      #   optional if not specified latest version will be retrieved
+      # @return [Polisher::Gem] representation of gem
+      def retrieve(name, version=nil)
+        version.nil? ? retrieve_latest(name) : retrieve_version(name, version)
+      end
+
+      # Retrieve latest version of gem matching dep
+      def latest_matching(dep)
+        version = latest_version_matching(dep)
+        raise RuntimeError, "no version found" if version.nil?
+        retrieve dep.name, version
+      end
+
+      # Retrieve earliest version of gem matching dep
+      def earliest_matching(dep)
+        version = earliest_version_matching(dep)
+        raise RuntimeError, "no version found" if version.nil?
+        retrieve dep.name, version
+      end
+
+      # Retrieve gem version matching target
+      def matching_target(dep, target)
+        version = version_matching_target(dep, target)
+        raise RuntimeError, "no matching version" if version.nil?
+        retrieve dep.name, version
+      end
+
+      # Retrieve version of gem matching dep and specifier
+      def matching(dep, specifier)
+        case specifier
+        when LATEST_SPECIFIER
+          latest_matching(dep)
+        when EARLIEST_SPECIFIER
+          earliest_matching(dep)
+        else
+          matching_target(dep, specifier)
+        end
+      end
+
+      # Retrieve latest version of gem in target
+      def latest_in_target(name, target)
+        version = latest_version_in_target(name, target)
+        raise RuntimeError, "no matching version" if version.nil?
+        retrieve name, version
+      end
+    end # module ClassMethods
+
+    # Download the local gem and return it as a string
+    def download_gem
+      self.class.download_gem @name, @version
+    end
+
+    # Return path to downloaded gem
+    def downloaded_gem_path
+      self.class.downloaded_gem_path @name, @version
+    end
+  end # module GemRetriever
+end # module Polisher