vanagon 0.15.17 → 0.15.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 164f0e66bb5d957115ab0f12d7f684cb69ea1018
-  data.tar.gz: f6929e9ae26855623b23a55c5c55fc49162ab5f2
+SHA256:
+  metadata.gz: 98826d92d0eb55918c4a5db6ef30e6216785cb567560ecf34e0254e72ae45336
+  data.tar.gz: aec8e9bd65afafc3dd1b83bb5045e9159357d0d5c7c18037217bb61ac71730af
 SHA512:
-  metadata.gz: 3e5c38c5e6a26ba56ac6daad39cff1b5f6ff0e86f13e60c9e6f6e7fe756435299ff1bf34dc4a02cc64adfba4d7e5e7839edf124e9c335ae6b80f1d107d623aec
-  data.tar.gz: 4c2992d5672d7f12bd0b588ad6027e4f826827f8061701ece80e6b9fe24b31d878390b67aac9328695fe4bc33a38ccf9eb5a25b15619548d80a35f1a2eb8f7cb
+  metadata.gz: 8b52b708b61e3361fb37e085f11e5dcb4ce2426fac0ce1435b21a8872fba3772df72c1146c74cafe6f1bbb89bf92f6aafd1d3f71c2a4926e7d77a8762dc4a5e1
+  data.tar.gz: 318ec2188ac994dd0c1086fd736d25a6d3dc3474111d7b33127e8fba43bb87e5f0bc6e88cec6cd1d63f6179dd9a8197a87e7362e9d27961d396fcb076ae70cd9

data/lib/vanagon/component.rb

@@ -350,17 +350,17 @@ class Vanagon
 
     # Fetches patches if any are provided for the project.
     #
-    # @param workdir [String] working directory to put the patches into
-    def get_patches(workdir)
-      unless @patches.empty?
-        patchdir = File.join(workdir, "patches")
-        FileUtils.mkdir_p(patchdir)
-        @patches.each do |p|
-          target = File.join(patchdir, File.basename(p.path))
-          raise Vanagon::Error, "Duplicate patch files detected, '#{p.path}' would have overwritten '#{target}'! Please ensure patch file names are unique across all components." if File.exist?(target)
-
-          FileUtils.cp(p.path, patchdir)
+    # @param patch_root [String] working directory to put the patches into
+    def get_patches(patch_root)
+      return if @patches.empty?
+      @patches.each do |patch|
+        patch_assembly_path = File.join(patch_root, patch.assembly_path)
+        if File.exist?(patch_assembly_path)
+          raise Vanagon::Error, "Duplicate patch files detected, '#{patch.origin_path}' would have overwritten '#{patch.assembly_path}'. Ensure all patch file names within a component are unique."
         end
+        patch_target_directory = File.dirname(patch_assembly_path)
+        FileUtils.mkdir_p(patch_target_directory)
+        FileUtils.cp(patch.origin_path, patch_assembly_path)
       end
     end
 

data/lib/vanagon/component/dsl.rb

@@ -85,19 +85,22 @@ class Vanagon
       # Add a patch to the list of patches to apply to the component's source after unpacking
       #
       # @param patch [String] Path to the patch that should be applied
-      # @param destination [String] Path to the location where the patch should be applied
-      # @param strip [String, Integer] directory levels to skip in applying patch
-      # @param fuzz [String, Integer] levels of context miss to ignore in applying patch
-      # @param after [String] the location in the makefile where the patch command should be run
-      def apply_patch(patch, destination: @component.dirname, strip: 1, fuzz: 0, after: 'unpack')
-        @component.patches << Vanagon::Patch.new(patch, strip, fuzz, after, destination)
+      # @param options [Hash] options controlling the patch
+      # @option namespace [String] Namespace for package patches
+      # @option destination [String] Path to the location where the patch should be applied
+      # @option strip [String, Integer] directory levels to skip in applying patch
+      # @option fuzz [String, Integer] levels of context miss to ignore in applying patch
+      # @option after [String] the location in the makefile where the patch command should be run
+      def apply_patch(patch, options = {})
+        @component.patches << Vanagon::Patch.new(patch, @component, options)
       end
 
       # Loads and parses json from a file. Will treat the keys in the
       # json as methods to invoke on the component in question
       #
       # @param file [String] Path to the json file
-      # @raise [RuntimeError] exceptions are raised if there is no file, if it refers to methods that don't exist, or if it does not contain a Hash
+      # @raise [RuntimeError] exceptions are raised if there is no file,
+      #   if it refers to methods that don't exist, or if it does not contain a Hash
       def load_from_json(file)
         if File.exists?(file)
           data = JSON.parse(File.read(file))

data/lib/vanagon/patch.rb

@@ -2,9 +2,22 @@ require 'vanagon/errors'
 
 class Vanagon
   class Patch
-    # @!attribute [r] path
-    #   @return [String] The path to the patch
-    attr_reader :path
+    # @!attribute [r] origin_path
+    #   @return [String] The path to the patch before assembly
+    attr_reader :origin_path
+
+    # @!attribute [r] namespace
+    #   @return [String] The namespace for the patch
+    attr_reader :namespace
+
+    # @!attribute [r] assembly_path
+    #   @return [String] The path to the patch inside the assembly
+    attr_reader :assembly_path
+
+    # @!attribute [r] destination
+    #   @return [String] The working directory where this patch will be applied.
+    #     Only used for post-installation patches.
+    attr_reader :destination
 
     # @!attribute [r] strip
     #   @return [Integer] the number of path components to strip from the patch path
@@ -18,21 +31,28 @@ class Vanagon
     #   @return [String] What step should this patch be applied to, one of ["unpack", "install"]
     attr_reader :after
 
-    # @!attribute [r] destination
-    #   @return [String] The working directory where this patch will be applied. Only used for post-installation patches.
-    attr_reader :destination
+    def initialize(origin_path, component, options) # rubocop:disable Metrics/AbcSize,Metrics/PerceivedComplexity
+      valid_keys = %i[namespace destination strip fuzz after]
+      bad_keys = options.each_key.reject { |k| valid_keys.include? k }
+
+      unless bad_keys.empty?
+        raise Vanagon::Error, "Bad options in patch initialization: #{bad_keys}."
+      end
 
-    def initialize(path, strip, fuzz, after, destination)
-      raise Vanagon::Error, "We can only apply patches after the source is unpacked or after installation" unless ['unpack', 'install'].include?(after)
-      @path = path
-      @strip = strip
-      @fuzz = fuzz
-      @after = after
-      @destination = destination
+      @origin_path = origin_path
+      @namespace = options[:namespace] || component.name
+      @assembly_path = "patches/#{@namespace}/#{File.basename(@origin_path)}"
+      @strip = options[:strip] || 1
+      @fuzz = options[:fuzz] || 0
+      @after = options[:after] || 'unpack'
+      unless ['unpack', 'install'].include?(@after)
+        raise Vanagon::Error, 'Only "unpack" or "install" permitted for "after" option.'
+      end
+      @destination = options[:destination] || component.dirname
     end
 
     def cmd(platform)
-      "#{platform.patch} --strip=#{@strip} --fuzz=#{@fuzz} --ignore-whitespace --no-backup-if-mismatch < $(workdir)/patches/#{File.basename(@path)}"
+      return "#{platform.patch} --strip=#{@strip} --fuzz=#{@fuzz} --ignore-whitespace --no-backup-if-mismatch < $(workdir)/#{@assembly_path}"
     end
   end
 end

data/resources/rpm/project.spec.erb

@@ -68,7 +68,12 @@ Requires:  <%= requires %>
 # did not specify a dependency on these.
 # In the future, we will supress pre/post scripts completely if there's nothing
 # specified by the project or the components.
-<%- unless @platform.is_aix? -%>
+<%- if @platform.is_fedora? && @platform.os_version.to_i >= 29 -%>
+Requires(pre): /usr/bin/mkdir
+Requires(pre): /usr/bin/touch
+Requires(post): /usr/bin/mkdir
+Requires(post): /usr/bin/touch
+<%- elsif !@platform.is_aix? -%>
 Requires(pre): /bin/mkdir
 Requires(pre): /bin/touch
 Requires(post): /bin/mkdir

data/spec/lib/vanagon/component/dsl_spec.rb

@@ -220,80 +220,80 @@ end" }
 
   describe '#apply_patch' do
     it 'adds the patch to the list of patches' do
-      comp = Vanagon::Component::DSL.new('patch-test', {}, {})
-      comp.apply_patch('patch_file1')
-      comp.apply_patch('patch_file2')
-      expect(comp._component.patches.count).to eq 2
-      expect(comp._component.patches.first.path).to eq 'patch_file1'
-      expect(comp._component.patches.last.path).to eq 'patch_file2'
+      dsl = Vanagon::Component::DSL.new('patch-test', {}, {})
+      dsl.apply_patch('patch_file1')
+      dsl.apply_patch('patch_file2')
+      expect(dsl._component.patches.count).to eq 2
+      expect(dsl._component.patches.first.origin_path).to eq 'patch_file1'
+      expect(dsl._component.patches.last.origin_path).to eq 'patch_file2'
     end
 
     it 'can specify strip and fuzz' do
-      comp = Vanagon::Component::DSL.new('patch-test', {}, {})
+      dsl = Vanagon::Component::DSL.new('patch-test', {}, {})
       # This patch must be amazing
-      comp.apply_patch('patch_file1', fuzz: 12, strip: 1000000)
-      expect(comp._component.patches.count).to eq 1
-      expect(comp._component.patches.first.path).to eq 'patch_file1'
-      expect(comp._component.patches.first.fuzz).to eq 12
-      expect(comp._component.patches.first.strip).to eq 1000000
+      dsl.apply_patch('patch_file1', fuzz: 12, strip: 1000000)
+      expect(dsl._component.patches.count).to eq 1
+      expect(dsl._component.patches.first.origin_path).to eq 'patch_file1'
+      expect(dsl._component.patches.first.fuzz).to eq 12
+      expect(dsl._component.patches.first.strip).to eq 1000000
     end
 
     it 'can specify a directory where the patch should be applied' do
-      comp = Vanagon::Component::DSL.new('patch-test', {}, {})
-      comp.apply_patch('patch_file1', destination: 'random/install/directory')
-      expect(comp._component.patches.count).to eq 1
-      expect(comp._component.patches.first.path).to eq 'patch_file1'
-      expect(comp._component.patches.first.destination).to eq 'random/install/directory'
+      dsl = Vanagon::Component::DSL.new('patch-test', {}, {})
+      dsl.apply_patch('patch_file1', destination: 'random/install/directory')
+      expect(dsl._component.patches.count).to eq 1
+      expect(dsl._component.patches.first.origin_path).to eq 'patch_file1'
+      expect(dsl._component.patches.first.destination).to eq 'random/install/directory'
     end
 
     it 'can specify when to try to apply the patch' do
-      comp = Vanagon::Component::DSL.new('patch-test', {}, {})
-      comp.apply_patch('patch_file1', after: 'install')
-      expect(comp._component.patches.count).to eq 1
-      expect(comp._component.patches.first.path).to eq 'patch_file1'
-      expect(comp._component.patches.first.after).to eq 'install'
+      dsl = Vanagon::Component::DSL.new('patch-test', {}, {})
+      dsl.apply_patch('patch_file1', after: 'install')
+      expect(dsl._component.patches.count).to eq 1
+      expect(dsl._component.patches.first.origin_path).to eq 'patch_file1'
+      expect(dsl._component.patches.first.after).to eq 'install'
     end
 
     it 'will default the patch timing to after the source is unpacked' do
-      comp = Vanagon::Component::DSL.new('patch-test', {}, {})
-      comp.apply_patch('patch_file1')
-      expect(comp._component.patches.count).to eq 1
-      expect(comp._component.patches.first.path).to eq 'patch_file1'
-      expect(comp._component.patches.first.after).to eq 'unpack'
+      dsl = Vanagon::Component::DSL.new('patch-test', {}, {})
+      dsl.apply_patch('patch_file1')
+      expect(dsl._component.patches.count).to eq 1
+      expect(dsl._component.patches.first.origin_path).to eq 'patch_file1'
+      expect(dsl._component.patches.first.after).to eq 'unpack'
     end
 
     it 'will fail if the user wants to install the patch at an unsupported step' do
-      comp = Vanagon::Component::DSL.new('patch-test', {}, {})
-      expect { comp.apply_patch('patch_file1', after: 'delivery') }.to raise_error(Vanagon::Error)
+      dsl = Vanagon::Component::DSL.new('patch-test', {}, {})
+      expect { dsl.apply_patch('patch_file1', after: 'delivery') }.to raise_error(Vanagon::Error)
     end
 
     it 'can specify a directory where the patch should be applied' do
-      comp = Vanagon::Component::DSL.new('patch-test', {}, {})
-      comp.apply_patch('patch_file1', destination: 'random/install/directory')
-      expect(comp._component.patches.count).to eq 1
-      expect(comp._component.patches.first.path).to eq 'patch_file1'
-      expect(comp._component.patches.first.destination).to eq 'random/install/directory'
+      dsl = Vanagon::Component::DSL.new('patch-test', {}, {})
+      dsl.apply_patch('patch_file1', destination: 'random/install/directory')
+      expect(dsl._component.patches.count).to eq 1
+      expect(dsl._component.patches.first.origin_path).to eq 'patch_file1'
+      expect(dsl._component.patches.first.destination).to eq 'random/install/directory'
     end
 
     it 'can specify when to try to apply the patch' do
-      comp = Vanagon::Component::DSL.new('patch-test', {}, {})
-      comp.apply_patch('patch_file1', after: 'install')
-      expect(comp._component.patches.count).to eq 1
-      expect(comp._component.patches.first.path).to eq 'patch_file1'
-      expect(comp._component.patches.first.after).to eq 'install'
+      dsl = Vanagon::Component::DSL.new('patch-test', {}, {})
+      dsl.apply_patch('patch_file1', after: 'install')
+      expect(dsl._component.patches.count).to eq 1
+      expect(dsl._component.patches.first.origin_path).to eq 'patch_file1'
+      expect(dsl._component.patches.first.after).to eq 'install'
     end
 
     it 'will default the patch timing to after the source is unpacked' do
-      comp = Vanagon::Component::DSL.new('patch-test', {}, {})
-      comp.apply_patch('patch_file1')
-      expect(comp._component.patches.count).to eq 1
-      expect(comp._component.patches.first.path).to eq 'patch_file1'
-      expect(comp._component.patches.first.after).to eq 'unpack'
+      dsl = Vanagon::Component::DSL.new('patch-test', {}, {})
+      dsl.apply_patch('patch_file1')
+      expect(dsl._component.patches.count).to eq 1
+      expect(dsl._component.patches.first.origin_path).to eq 'patch_file1'
+      expect(dsl._component.patches.first.after).to eq 'unpack'
     end
 
     it 'will fail if the user wants to install the patch at an unsupported step' do
-      comp = Vanagon::Component::DSL.new('patch-test', {}, {})
-      expect { comp.apply_patch('patch_file1', after: 'delivery') }.to raise_error(Vanagon::Error)
+      dsl = Vanagon::Component::DSL.new('patch-test', {}, {})
+      expect { dsl.apply_patch('patch_file1', after: 'delivery') }.to raise_error(Vanagon::Error)
     end
   end
 

data/spec/lib/vanagon/component/rules_spec.rb

@@ -66,17 +66,28 @@ describe Vanagon::Component::Rules do
       expect(rule.recipe.size).to eq 1
     end
 
+    it "rejects bad options" do
+      expect { Vanagon::Patch.new('/foo/patch0', component, REALLYBADARGUMENT: 'bad-value') }.to raise_error(Vanagon::Error, /Bad options in patch initialization/i)
+    end
+
     it "applies each listed patch in order when patches are set" do
       component.patches = [
-        Vanagon::Patch.new('/foo/patch0', '1', '0', 'unpack', '/foo/bar'),
-        Vanagon::Patch.new('/foo/patch1', '2', '1', 'unpack', '/foo/bar'),
-        Vanagon::Patch.new('/foo/postinstall/patch1', '2', '1', 'install', '/foo/bar')
+        Vanagon::Patch.new('/foo/patch0', component,
+                           namespace: component.name, strip: '1', fuzz: '0',
+                           after: 'unpack', destination: '/foo/bar'),
+        Vanagon::Patch.new('/foo/patch1', component,
+                           namespace: component.name, strip: '2', fuzz: '1',
+                           after: 'unpack', destination: '/foo/bar'),
+        Vanagon::Patch.new('/foo/postinstall/patch1', component,
+                           namespace: component.name,
+                           strip: '2', fuzz: '1', after: 'install',
+                           destination: '/foo/bar')
       ]
       expect(rule.recipe.first).to eq(
         [
           "cd /foo/bar",
-          "/usr/bin/patch --strip=1 --fuzz=0 --ignore-whitespace --no-backup-if-mismatch < $(workdir)/patches/patch0",
-          "/usr/bin/patch --strip=2 --fuzz=1 --ignore-whitespace --no-backup-if-mismatch < $(workdir)/patches/patch1"
+          "/usr/bin/patch --strip=1 --fuzz=0 --ignore-whitespace --no-backup-if-mismatch < $(workdir)/#{component.patches[0].assembly_path}",
+          "/usr/bin/patch --strip=2 --fuzz=1 --ignore-whitespace --no-backup-if-mismatch < $(workdir)/#{component.patches[1].assembly_path}"
         ].join(" && \\\n")
       )
     end
@@ -116,7 +127,7 @@ describe Vanagon::Component::Rules do
       component.environment.merge({"PATH" => "/opt/pl-build-tools/bin:$(PATH)"})
       expect(rule.recipe[1]).to eq(
         [
-          'export PATH="/opt/pl-build-tools/bin:$(PATH)"', 
+          'export PATH="/opt/pl-build-tools/bin:$(PATH)"',
           "cd /foo/bar",
           "./configure",
           "cmake .."
@@ -241,13 +252,19 @@ describe Vanagon::Component::Rules do
     it "applies any after-install patches" do
       component.install = ["make install"]
       component.patches = [
-        Vanagon::Patch.new('/foo/patch0', 1, 0, 'unpack', '/foo/bar'),
-        Vanagon::Patch.new('/foo/postinstall/patch0', 3, 9, 'install', '/foo/baz'),
-        Vanagon::Patch.new('/foo/postinstall/patch1', 4, 10, 'install', '/foo/quux'),
+        Vanagon::Patch.new('/foo/patch0', component,
+                           namespace: component.name, strip: 1, fuzz: 0,
+                           after: 'unpack', destination: '/foo/bar'),
+        Vanagon::Patch.new('/foo/postinstall/patch0', component,
+                           namespace: component.name, strip: 3,
+                           fuzz: 9, after: 'install', destination: '/foo/baz'),
+        Vanagon::Patch.new('/foo/postinstall/patch1', component,
+                           namespace: component.name, strip: 4,
+                           fuzz: 10, after: 'install', destination: '/foo/quux'),
       ]
 
-      expect(rule.recipe[1]).to eq("cd /foo/baz && /usr/bin/patch --strip=3 --fuzz=9 --ignore-whitespace --no-backup-if-mismatch < $(workdir)/patches/patch0")
-      expect(rule.recipe[2]).to eq("cd /foo/quux && /usr/bin/patch --strip=4 --fuzz=10 --ignore-whitespace --no-backup-if-mismatch < $(workdir)/patches/patch1")
+      expect(rule.recipe[1]).to eq("cd /foo/baz && /usr/bin/patch --strip=3 --fuzz=9 --ignore-whitespace --no-backup-if-mismatch < $(workdir)/#{component.patches[1].assembly_path}")
+      expect(rule.recipe[2]).to eq("cd /foo/quux && /usr/bin/patch --strip=4 --fuzz=10 --ignore-whitespace --no-backup-if-mismatch < $(workdir)/#{component.patches[2].assembly_path}")
     end
 
     it_behaves_like "a rule that touches the target file"

data/spec/lib/vanagon/component_spec.rb

@@ -217,22 +217,27 @@ describe "Vanagon::Component" do
       plat._platform
     end
 
-    let(:component) { Vanagon::Component::DSL.new('patches-test', {}, platform) }
+    let(:dsl_1) { Vanagon::Component::DSL.new('patches-test-1', {}, platform) }
+    let(:dsl_2) { Vanagon::Component::DSL.new('patches-test-2', {}, platform) }
 
     context("when new patch file would overwrite existing patch file") do
-      let(:patch_file) { 'path/to/test.patch' }
+      let(:patch_file_1) { 'path/to/test.patch_1' }
+      let(:patch_file_2) { 'path/to/test.patch_2' }
 
       before :each do
         allow(FileUtils).to receive(:mkdir_p)
         allow(FileUtils).to receive(:cp)
-
-        expect(File).to receive(:exist?).with(File.join(@workdir, 'patches', File.basename(patch_file))).and_return(true)
-
-        component.apply_patch(patch_file)
       end
 
-      it "fails the build" do
-        expect { component._component.get_patches(@workdir) }.to raise_error(Vanagon::Error, /duplicate patch files/i)
+      it "fails the build with the same namespace" do
+        expect(File).to receive(:exist?).with(/.*\/.*test\.patch_1/).and_return(true)
+        dsl_1.apply_patch(patch_file_1)
+        expect { dsl_1._component.get_patches(@workdir) }.to raise_error(Vanagon::Error, /duplicate patch files/i)
+      end
+      it "works with different namespaces" do
+        expect(File).to receive(:exist?).with(/.*\/.*test\.patch_2/).and_return(false)
+        dsl_2.apply_patch(patch_file_2, namespace: 'foo')
+        expect { dsl_2._component.get_patches(@workdir) }.to_not raise_error
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vanagon
 version: !ruby/object:Gem::Version
-  version: 0.15.17
+  version: 0.15.18
 platform: ruby
 authors:
 - Puppet Labs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-13 00:00:00.000000000 Z
+date: 2018-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: git
@@ -261,7 +261,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 3
 summary: All of your packages will fit into this van with this one simple trick.