polisher 0.10.2 → 0.11.1

data/lib/polisher/rpm/spec/check.rb

@@ -0,0 +1,14 @@
+# RPM Spec Check Module
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+module Polisher
+  module RPM
+    module SpecCheck
+      def has_check?
+        !!has_check
+      end
+    end # module SpecCheck
+  end  # module RPM
+end # module Polisher

data/lib/polisher/rpm/spec/comparison.rb

@@ -0,0 +1,64 @@
+# RPM Spec Comparison Mixin
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+module Polisher
+  module RPM
+    module SpecComparison
+      # Compare this spec to a sepecified upstream gem source
+      # and return result.
+      #
+      # upstream_source should be an instance of Polisher::Gem,
+      # Polisher::Gemfile, or other class defining a 'deps'
+      # accessor that returns an array of Gem::Requirement dependencies
+      #
+      # Result will be a hash containing the shared dependencies as
+      # well as those that differ and their respective differences
+      def compare(upstream_source)
+        same = {}
+        diff = {}
+        upstream_source.deps.each do |d|
+          spec_reqs = requirements_for_gem(d.name)
+          spec_reqs_specifier = spec_reqs.empty? ? nil :
+               spec_reqs.collect { |req| req.specifier }
+
+          if spec_reqs.nil?
+            diff[d.name] = {:spec     => nil,
+                            :upstream => d.requirement.to_s}
+
+          elsif !spec_reqs.any? { |req| req.matches?(d) } ||
+                !self.has_all_requirements_for?(d)
+            diff[d.name] = {:spec     => spec_reqs_specifier,
+                            :upstream => d.requirement.to_s}
+
+          elsif !diff.has_key?(d.name)
+            same[d.name] = {:spec     => spec_reqs_specifier,
+                            :upstream => d.requirement.to_s}
+          end
+        end
+
+        @metadata[:requires].each do |req|
+          next unless req.gem?
+
+          upstream_dep = upstream_source.deps.find { |d| d.name == req.gem_name }
+
+          if upstream_dep.nil?
+            diff[req.gem_name] = {:spec     => req.specifier,
+                                  :upstream => nil}
+
+          elsif !req.matches?(upstream_dep)
+            diff[req.gem_name] = {:spec     => req.specifier,
+                                  :upstream => upstream_dep.requirement.to_s}
+
+          elsif !diff.has_key?(req.gem_name)
+            same[req.gem_name] = {:spec     => req.specifier,
+                                  :upstream => upstream_dep.requirement.to_s}
+          end
+        end unless @metadata[:requires].nil?
+
+        {:same => same, :diff => diff}
+      end
+    end # module SpecComparison
+  end # module RPM
+end # module Polisher

data/lib/polisher/rpm/spec/files.rb

@@ -0,0 +1,15 @@
+# RPM Spec Files Mixin
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+module Polisher
+  module RPM
+    module SpecFiles
+      # Return list of all files in the spec
+      def files
+        pkg_files.values.flatten
+      end
+    end # module SpecFiles
+  end # module RPM
+end # module Polisher

data/lib/polisher/rpm/spec/gem_files.rb

@@ -0,0 +1,65 @@
+# RPM Spec Gem Files Mixin
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+require 'polisher/util/core_ext'
+
+module Polisher
+  module RPM
+    module SpecGemFiles
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # Helper to return bool indicating if specified gem file is satisfied
+        # by specified spec file.
+        #
+        # Spec file satisfies gem file if they are the same or the spec file
+        # corresponds to the the directory in which the gem file resides.
+        def file_satisfies?(spec_file, gem_file)
+          # If spec file for which gemfile.gsub(/^specfile/)
+          # is different than the gemfile the spec contains the gemfile
+          #
+          # TODO: need to incorporate regex matching into this
+          gem_file.gsub(/^#{spec_file.unrpmize}/, '') != gem_file
+        end
+      end # module ClassMethods
+
+      # Return bool indicating if spec is missing specified gemfile.
+      def missing_gem_file?(gem_file)
+        files.none? { |spec_file| self.class.file_satisfies?(spec_file, gem_file) }
+      end
+
+      # Return list of gem files for which we have no corresponding spec files
+      def missing_files_for(gem)
+        # we check for files in the gem for which there are no spec files
+        # corresponding to gem file or directory which it resides in
+        gem.file_paths.select { |gem_file| missing_gem_file?(gem_file) }
+      end
+
+      # Return list of files in upstream gem which have not been included
+      def excluded_files
+        # TODO: also append files marked as %{exclude} (or handle elsewhere?)
+        missing_files_for(upstream_gem)
+      end
+
+      # Return boolean indicating if the specified file is on excluded list
+      def excludes_file?(file)
+        excluded_files.include?(file)
+      end
+
+      # Return extra package file _not_ in the specified gem
+      def extra_gem_files(gem = nil)
+        gem ||= upstream_gem
+        pkg_extra = {}
+        pkg_files.each do |pkg, files|
+          extra = files.select { |spec_file| !gem.has_file_satisfied_by?(spec_file) }
+          pkg_extra[pkg] = extra unless extra.empty?
+        end
+        pkg_extra
+      end
+    end # module SpecGemFiles
+  end # module RPM
+end # module Polisher

data/lib/polisher/rpm/spec/gem_reference.rb

@@ -0,0 +1,59 @@
+# RPM Spec Gem Reference Mixin
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+require 'polisher/gem'
+
+module Polisher
+  module RPM
+    module SpecGemReference
+      # .gem file associated with the RPM specfile
+      attr_accessor :gem
+
+      # Return gem corresponding to spec name/version
+      def upstream_gem
+        @gem, @update_gem = nil, false if @update_gem
+        @gem ||= Polisher::Gem.from_rubygems gem_name, version
+      end
+
+      # Return list of gem dependencies for which we have no
+      # corresponding requirements
+      def missing_deps_for(gem)
+        # Comparison by name here assuming if it is in existing spec,
+        # spec author will have ensured versions are correct for their purposes
+        gem.deps.select { |dep| requirements_for_gem(dep.name).empty? }
+      end
+
+      # Return list of gem dev dependencies for which we have
+      # no corresponding requirements
+      def missing_dev_deps_for(gem)
+        # Same note as in #missing_deps_for above
+        gem.dev_deps.select { |dep| build_requirements_for_gem(dep.name).empty? }
+      end
+
+      # Return list of dependencies of upstream gem which
+      # have not been included
+      def excluded_deps
+        missing_deps_for(upstream_gem)
+      end
+
+      # Return boolean indicating if the specified gem is on excluded list
+      def excludes_dep?(gem_name)
+        excluded_deps.any? { |d| d.name == gem_name }
+      end
+
+      # Return list of dev dependencies of upstream gem which
+      # have not been included
+      def excluded_dev_deps
+        missing_dev_deps_for(upstream_gem)
+      end
+
+      # Return boolean indicating if the specified gem is on
+      # excluded dev dep list
+      def excludes_dev_dep?(gem_name)
+        excluded_dev_deps.any? { |d| d.name == gem_name }
+      end
+    end # module SpecGemReference
+  end # module RPM
+end # module Polisher

data/lib/polisher/rpm/spec/gem_requirements.rb

@@ -0,0 +1,73 @@
+# RPM Spec Gem Requirements Mixin
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+module Polisher
+  module RPM
+    module SpecGemRequirements
+      # Return all the Requires for the specified gem
+      def requirements_for_gem(gem_name)
+        requires.select { |r| r.gem_name == gem_name }
+      end
+
+      # Return all the BuildRequires for the specified gem
+      def build_requirements_for_gem(gem_name)
+        build_requires.select { |r| r.gem_name == gem_name }
+      end
+
+      # Return bool indicating if this spec specifies all the
+      # requirements in the specified gem dependency
+      #
+      # @param [Gem::Dependency] gem_dep dependency which to retreive / compare
+      # requirements
+      def has_all_requirements_for?(gem_dep)
+        require 'gem2rpm'
+
+        reqs = requirements_for_gem gem_dep.name
+        # create a spec requirement dependency for each expanded subrequirement,
+        # verify we can find a match for that
+        gem_dep.requirement.to_s.split(',').all? do |greq|
+          Gem2Rpm::Helpers.expand_requirement([greq.split]).all? do |ereq|
+            tereq = Requirement.new :name      => "#{requirement_prefix}(#{gem_dep.name})",
+                                    :condition => ereq.first,
+                                    :version   => ereq.last.to_s
+            reqs.any? { |req| req.matches?(tereq) }
+          end
+        end
+      end
+
+      # Return all gem Requires
+      def gem_requirements
+        requires.select { |r| r.gem? }
+      end
+
+      # Return all gem BuildRequires
+      def gem_build_requirements
+        build_requires.select { |r| r.gem? }
+      end
+
+      # Return all non gem Requires
+      def non_gem_requirements
+        requires.select { |r| !r.gem? }
+      end
+
+      # Return all non gem BuildRequires
+      def non_gem_build_requirements
+        build_requires.select { |r| !r.gem? }
+      end
+
+      # Return all gem requirements _not_ in the specified gem
+      def extra_gem_requirements(gem)
+        gem_reqs = gem.deps.collect { |d| requirements_for_gem(d.name) }.flatten
+        gem_requirements - gem_reqs
+      end
+
+      # Return all gem build requirements _not_ in the specified gem
+      def extra_gem_build_requirements(gem)
+        gem_reqs = gem.deps.collect { |d| requirements_for_gem(d.name) }.flatten
+        gem_build_requirements - gem_reqs
+      end
+    end # module SpecGemRequirements
+  end  # module RPM
+end # module Polisher

data/lib/polisher/rpm/spec/parser.rb

@@ -0,0 +1,106 @@
+# RPM Spec Parser Mixin
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+module Polisher
+  module RPM
+    module SpecParser
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def default_metadata
+          {:contents          => "",
+           :requires          => [],
+           :build_requires    => [],
+           :pkg_excludes      => {},
+           :pkg_files         => {},
+           :changelog         => "",
+           :changelog_entries => []}
+        end
+
+        # Parse the specified rpm spec and return new RPM::Spec instance from metadata
+        #
+        # @see [Polisher::RPM::SpecConstants::METADATA_IDS]
+        # @param [String] string contents of spec to parse
+        # @return [Polisher::RPM::Spec] spec instantiated from rpmspec metadata
+        def parse(spec)
+          in_subpackage = false
+          in_changelog  = false
+          in_files      = false
+          subpkg_name   = nil
+          meta          = default_metadata.merge(:contents => spec)
+          spec.each_line do |l|
+            if l =~ RPM::Spec::COMMENT_MATCHER
+
+            # TODO: support optional gem prefix
+            elsif l =~ RPM::Spec::GEM_NAME_MATCHER
+              meta[:gem_name] = $1.strip
+              meta[:gem_name] = $1.strip
+
+            elsif l =~ RPM::Spec::SPEC_NAME_MATCHER &&
+                  $1.strip != "%{gem_name}"
+              meta[:gem_name] = $1.strip
+
+            elsif l =~ RPM::Spec::SPEC_VERSION_MATCHER
+              meta[:version] = $1.strip
+
+            elsif l =~ RPM::Spec::SPEC_RELEASE_MATCHER
+              meta[:release] = $1.strip
+
+            elsif l =~ RPM::Spec::SPEC_SUBPACKAGE_MATCHER
+              subpkg_name = $1.strip
+              in_subpackage = true
+
+            elsif l =~ RPM::Spec::SPEC_REQUIRES_MATCHER && !in_subpackage
+              meta[:requires] << RPM::Requirement.parse($1.strip)
+
+            elsif l =~ RPM::Spec::SPEC_BUILD_REQUIRES_MATCHER && !in_subpackage
+              meta[:build_requires] << RPM::Requirement.parse($1.strip)
+
+            elsif l =~ RPM::Spec::SPEC_CHANGELOG_MATCHER
+              in_changelog = true
+
+            elsif l =~ RPM::Spec::SPEC_FILES_MATCHER
+              subpkg_name = nil
+              in_files = true
+
+            elsif l =~ RPM::Spec::SPEC_SUBPKG_FILES_MATCHER
+              subpkg_name = $1.strip
+              in_files = true
+
+            elsif l =~ RPM::Spec::SPEC_CHECK_MATCHER
+              meta[:has_check] = true
+
+            elsif in_changelog
+              meta[:changelog] << l
+
+            elsif in_files
+              tgt = subpkg_name.nil? ? meta[:gem_name] : subpkg_name
+
+              if l =~ RPM::Spec::SPEC_EXCLUDED_FILE_MATCHER
+                sl = Regexp.last_match(1)
+                meta[:pkg_excludes][tgt] ||= []
+                meta[:pkg_excludes][tgt] << sl unless sl.blank?
+
+              else
+                sl = l.strip
+                meta[:pkg_files][tgt] ||= []
+                meta[:pkg_files][tgt] << sl unless sl.blank?
+
+              end
+            end
+          end
+
+          # Ensure pkg_files hash exists
+          meta[:changelog_entries] = meta[:changelog].split("\n\n") if meta[:changelog]
+          meta[:changelog_entries].collect! { |c| c.strip }.compact!
+
+          new meta
+        end
+      end # module ClassMethods
+    end # module SpecParser
+  end # module RPM
+end # module Polisher

data/lib/polisher/rpm/spec/requirements.rb

@@ -0,0 +1,31 @@
+# RPM Has Requirements Mixin
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+require 'polisher/rpm/requirement'
+
+module Polisher
+  module RPM
+    module SpecRequirements
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # RPM Spec Requirement Prefix
+        def requirement_prefix
+          Requirement.prefix
+        end
+
+        def package_prefix
+          requirement_prefix
+        end
+      end # module ClassMethods
+
+      def requirement_prefix
+        self.class.requirement_prefix
+      end
+    end # module SpecRequirements
+  end # module RPM
+end # module Polisher

data/lib/polisher/rpm/spec/subpackages.rb

@@ -0,0 +1,23 @@
+# RPM Spec Subpackages Module
+#
+# Licensed under the MIT license
+# Copyright (C) 2013-2014 Red Hat, Inc.
+
+module Polisher
+  module RPM
+    module SpecSubpackages
+      # Return subpkg containing the specified file
+      def subpkg_containing(file)
+        pkg_files.each do |pkg, spec_files|
+          return pkg if spec_files.include?(file)
+        end
+        nil
+      end
+
+      # Return boolean indicating if spec has a -doc subpkg
+      def has_doc_subpkg?
+        @has_doc_subpkg ||= contents.index Spec::SPEC_DOC_SUBPACKAGE_MATCHER
+      end
+    end # module SpecSubpackages
+  end  # module RPM
+end # module Polisher