packager-dsl 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 83e945fadcebe543ffcc791eca75b25c006d98e2
-  data.tar.gz: de066bb4cc80308d485bc1e9762ee0d4a3327a77
+  metadata.gz: 42215c276926e0d4783fa92a7a27c10210f856cf
+  data.tar.gz: b808a1736416be2e501bc6c9d27037a2624ff3d7
 SHA512:
-  metadata.gz: 117fb6a9bca9d53f124f9e2f7d0140423fa9eea4fa330980a4213989bfba31689cb9bbf9752f22ece959bfc44178132809e01fb5609a14a54d9aafcdccac58ee
-  data.tar.gz: 7dd09bd6951ca17bcd53c77e66868c4a1196c469f406b94eb0d2279e213f39e74ca34bb8686b54485e0732704f746795db1a6f199b76b1c27b43b274e4d0a9cd
+  metadata.gz: 01474c3afa86dff4563647d07e21b0a21755a0a3f34075c7a02bfb082365b78a97d4976b2942c37455f7904faea633e6b288748806437db8f47770163f841fbc
+  data.tar.gz: 64d0a769989d2828567f8469abc2898fda61843d55a4daa2ce4995d002effcbef8da353d8d174b688f2a7d5aded2f87af95438ac9d562ccdb399b0e210b22df7

data/Changes

@@ -1,5 +1,14 @@
 Revision history for Packager (ordered by revision number).
 
+0.1.2 Nov 30 2018
+   - [FEATURE] Add support for the following flags:
+       * --before-install (aliased as --pre-install)
+       * --after-install (aliased as --post-install)
+       * --before-remove (aliased as --pre-uninstall)
+       * --after-remove (aliased as --post-uninstall)
+       * --before-upgrade
+       * --after-upgrade
+
 0.1.1 Nov 10 2018
    - [FEATURE] Add the ability to provide variables
    - [FEATURE] Add the ability to specify `--dryrun`

data/README.md

@@ -63,11 +63,12 @@ Consider providing helpers for the following:
 ## DSL
 
 * package <name>
-   * name    String
-   * type    String
-   * version VersionString
-   * file / files
-      * source String
-      * dest   String
-   * requires Array[String]
-   * provides Array[String]
+   * `name`    String
+   * `type`    String
+   * `version` VersionString
+   * `file` / `files`
+      * `source` String
+      * `dest`   String
+   * `requires` Array[String]
+   * `provides` Array[String]
+   * `before_install` Array[String]

data/lib/packager/dsl.rb

@@ -46,12 +46,21 @@ class Packager::DSL < DSL::Maker
     :file => AliasOf(:files),
     :requires => ArrayOf[String],
     :provides => ArrayOf[String],
+    :before_install => ArrayOf[String],
+    :after_install  => ArrayOf[String],
+    :before_remove  => ArrayOf[String],
+    :after_remove   => ArrayOf[String],
+    :before_upgrade => ArrayOf[String],
+    :after_upgrade  => ArrayOf[String],
   }) do |*args|
     type(Packager::DSL.default_type) unless type
     default(:name, args, 0)
 
     Packager::Struct::Package.new(
       name, version, type, files, requires, provides,
+      before_install, after_install,
+      before_remove, after_remove,
+      before_upgrade, after_upgrade,
     )
   end
   add_verification(:package) do |item|

data/lib/packager/executor.rb

@@ -38,6 +38,12 @@ class Packager
         :target   => item.type,
         :requires => item.requires,
         :provides => item.provides,
+        :before_install => item.before_install,
+        :after_install  => item.after_install,
+        :before_remove  => item.before_remove,
+        :after_remove   => item.after_remove,
+        :before_upgrade => item.before_upgrade,
+        :after_upgrade  => item.after_upgrade,
       )
 
       Dir.glob('*') do |entry|

data/lib/packager/struct.rb

@@ -17,12 +17,21 @@ class Packager::Struct < Struct
 
   class Package < Packager::Struct.new(
     :name, :version, :type, :files, :requires, :provides,
+    :before_install, :after_install,
+    :before_remove, :after_remove,
+    :before_upgrade, :after_upgrade,
   )
     def initialize(*args)
       super(*args)
       self.files ||= []
       self.requires ||= []
       self.provides ||= []
+      self.before_install ||= []
+      self.after_install  ||= []
+      self.before_remove  ||= []
+      self.after_remove   ||= []
+      self.before_upgrade ||= []
+      self.after_upgrade  ||= []
     end
   end
 
@@ -34,6 +43,9 @@ class Packager::Struct < Struct
   class Command < Packager::Struct.new(
     :executable, :name, :version,
     :source, :target, :directories, :requires, :provides,
+    :before_install, :after_install,
+    :before_remove, :after_remove,
+    :before_upgrade, :after_upgrade,
   )
     class << self
       attr_accessor :default_executable
@@ -44,8 +56,19 @@ class Packager::Struct < Struct
       self.source ||= 'empty'
       self.executable ||= self.class.default_executable || 'fpm'
       self.directories ||= {}
-      self.requires ||= []
-      self.provides ||= []
+
+      @unique_mappers = {
+        :requires => '--depends',
+        :provides => '--provides',
+        :before_install => '--before-install',
+        :after_install  => '--after-install',
+        :before_remove  => '--before-remove',
+        :after_remove   => '--after-remove',
+        :before_upgrade => '--before-upgrade',
+        :after_upgrade  => '--after-upgrade',
+      }
+
+      @unique_mappers.keys.each {|i| self[i] ||= [] }
     end
 
     def add_directory(*items)
@@ -62,12 +85,10 @@ class Packager::Struct < Struct
         '--version', version,
       ]
 
-      self.requires.uniq.each do |req|
-        cmd.concat(['--depends', req])
-      end
-
-      self.provides.uniq.each do |req|
-        cmd.concat(['--provides', req])
+      @unique_mappers.each do |element, flag|
+        self[element].uniq.each do |item|
+          cmd.concat([flag, item])
+        end
       end
 
       cmd.concat(['-s', source, '-t', target])

data/lib/packager/version.rb

@@ -1,3 +1,3 @@
 class Packager
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

data/spec/dsl/dependency_spec.rb

@@ -2,6 +2,9 @@ require './spec/dsl/context.rb'
 describe Packager::DSL do
   include_context :dsl
 
+  # It's unclear how to replicate what was done in spec/executor/dependency_spec
+  # here. The parse_dsl{} needs to have the name of the parameter. Use eval?
+
   context "requires" do
     it "handles a dependency" do
       items = parse_dsl {
@@ -59,4 +62,178 @@ describe Packager::DSL do
       expect(items[0].provides).to eq([ 'foo', 'bar', 'baz' ])
     end
   end
+
+  context "before_install" do
+    it "handles a before_install" do
+      items = parse_dsl {
+        package {
+          name 'foo'
+          version '0.0.1'
+          type 'test'
+          before_install 'foo'
+        }
+      }
+      expect(items[0].before_install).to be_instance_of(Array)
+      expect(items[0].before_install[0]).to eq('foo')
+    end
+
+    it "handles multiple before_installs" do
+      items = parse_dsl {
+        package {
+          name 'foo'
+          version '0.0.1'
+          type 'test'
+          before_install 'foo', 'bar'
+          before_install 'baz'
+        }
+      }
+      expect(items[0].before_install).to be_instance_of(Array)
+      expect(items[0].before_install).to eq([ 'foo', 'bar', 'baz' ])
+    end
+  end
+
+  context "after_install" do
+    it "handles a after_install" do
+      items = parse_dsl {
+        package {
+          name 'foo'
+          version '0.0.1'
+          type 'test'
+          after_install 'foo'
+        }
+      }
+      expect(items[0].after_install).to be_instance_of(Array)
+      expect(items[0].after_install[0]).to eq('foo')
+    end
+
+    it "handles multiple after_installs" do
+      items = parse_dsl {
+        package {
+          name 'foo'
+          version '0.0.1'
+          type 'test'
+          after_install 'foo', 'bar'
+          after_install 'baz'
+        }
+      }
+      expect(items[0].after_install).to be_instance_of(Array)
+      expect(items[0].after_install).to eq([ 'foo', 'bar', 'baz' ])
+    end
+  end
+
+  context "before_remove" do
+    it "handles a before_remove" do
+      items = parse_dsl {
+        package {
+          name 'foo'
+          version '0.0.1'
+          type 'test'
+          before_remove 'foo'
+        }
+      }
+      expect(items[0].before_remove).to be_instance_of(Array)
+      expect(items[0].before_remove[0]).to eq('foo')
+    end
+
+    it "handles multiple before_removes" do
+      items = parse_dsl {
+        package {
+          name 'foo'
+          version '0.0.1'
+          type 'test'
+          before_remove 'foo', 'bar'
+          before_remove 'baz'
+        }
+      }
+      expect(items[0].before_remove).to be_instance_of(Array)
+      expect(items[0].before_remove).to eq([ 'foo', 'bar', 'baz' ])
+    end
+  end
+
+  context "after_remove" do
+    it "handles a after_remove" do
+      items = parse_dsl {
+        package {
+          name 'foo'
+          version '0.0.1'
+          type 'test'
+          after_remove 'foo'
+        }
+      }
+      expect(items[0].after_remove).to be_instance_of(Array)
+      expect(items[0].after_remove[0]).to eq('foo')
+    end
+
+    it "handles multiple after_removes" do
+      items = parse_dsl {
+        package {
+          name 'foo'
+          version '0.0.1'
+          type 'test'
+          after_remove 'foo', 'bar'
+          after_remove 'baz'
+        }
+      }
+      expect(items[0].after_remove).to be_instance_of(Array)
+      expect(items[0].after_remove).to eq([ 'foo', 'bar', 'baz' ])
+    end
+  end
+
+  context "before_upgrade" do
+    it "handles a before_upgrade" do
+      items = parse_dsl {
+        package {
+          name 'foo'
+          version '0.0.1'
+          type 'test'
+          before_upgrade 'foo'
+        }
+      }
+      expect(items[0].before_upgrade).to be_instance_of(Array)
+      expect(items[0].before_upgrade[0]).to eq('foo')
+    end
+
+    it "handles multiple before_upgrades" do
+      items = parse_dsl {
+        package {
+          name 'foo'
+          version '0.0.1'
+          type 'test'
+          before_upgrade 'foo', 'bar'
+          before_upgrade 'baz'
+        }
+      }
+      expect(items[0].before_upgrade).to be_instance_of(Array)
+      expect(items[0].before_upgrade).to eq([ 'foo', 'bar', 'baz' ])
+    end
+  end
+
+  context "after_upgrade" do
+    it "handles a after_upgrade" do
+      items = parse_dsl {
+        package {
+          name 'foo'
+          version '0.0.1'
+          type 'test'
+          after_upgrade 'foo'
+        }
+      }
+      expect(items[0].after_upgrade).to be_instance_of(Array)
+      expect(items[0].after_upgrade[0]).to eq('foo')
+    end
+
+    it "handles multiple after_upgrades" do
+      items = parse_dsl {
+        package {
+          name 'foo'
+          version '0.0.1'
+          type 'test'
+          after_upgrade 'foo', 'bar'
+          after_upgrade 'baz'
+        }
+      }
+      expect(items[0].after_upgrade).to be_instance_of(Array)
+      expect(items[0].after_upgrade).to eq([ 'foo', 'bar', 'baz' ])
+    end
+  end
 end

data/spec/executor/context.rb

@@ -1,4 +1,3 @@
 RSpec.shared_context :executor do
   subject(:executor) { Packager::Executor.new(:dryrun => true) }
-
 end

data/spec/executor/dependency_spec.rb

@@ -2,14 +2,13 @@ require './spec/executor/context.rb'
 describe Packager::Executor do
   include_context :executor
 
-  context "dependencies" do
-    it "handles a dependency" do
-      item = Packager::Struct::Package.new(
+  def self.testit(name, addl_input, addl_output)
+    it "handles a #{name}" do
+      item = Packager::Struct::Package.new({
         :name => 'foo',
         :version => '0.0.1',
         :type => 'test',
-        :requires => [ 'foo' ],
-      )
+      }.merge(addl_input))
       executor.execute_on([item])
       expect(executor.commands[0]).to eq(
         Packager::Struct::Command.new({
@@ -17,30 +16,56 @@ describe Packager::Executor do
           :version => '0.0.1',
           :source => 'empty',
           :target => 'test',
-          :requires => [ 'foo' ],
-        })
+        }.merge(addl_output))
       )
     end
   end
 
-  context "provides" do
-    it "handles a provides" do
-      item = Packager::Struct::Package.new(
-        :name => 'foo',
-        :version => '0.0.1',
-        :type => 'test',
-        :provides => [ 'foo' ],
-      )
-      executor.execute_on([item])
-      expect(executor.commands[0]).to eq(
-        Packager::Struct::Command.new({
-          :name => 'foo',
-          :version => '0.0.1',
-          :source => 'empty',
-          :target => 'test',
-          :provides => [ 'foo' ],
-        })
-      )
-    end
-  end
+  testit :dependency, {
+    :requires => ['foo'],
+  }, {
+    :requires => ['foo'],
+  }
+
+  testit :provides, {
+    :provides => ['foo'],
+  }, {
+    :provides => ['foo'],
+  }
+
+  testit :before_install, {
+    :before_install => ['foo'],
+  }, {
+    :before_install => ['foo'],
+  }
+
+  testit :after_install, {
+    :after_install => ['foo'],
+  }, {
+    :after_install => ['foo'],
+  }
+
+  testit :before_remove, {
+    :before_remove => ['foo'],
+  }, {
+    :before_remove => ['foo'],
+  }
+
+  testit :after_remove, {
+    :after_remove => ['foo'],
+  }, {
+    :after_remove => ['foo'],
+  }
+
+  testit :before_upgrade, {
+    :before_upgrade => ['foo'],
+  }, {
+    :before_upgrade => ['foo'],
+  }
+
+  testit :after_upgrade, {
+    :after_upgrade => ['foo'],
+  }, {
+    :after_upgrade => ['foo'],
+  }
 end

data/spec/struct/command_spec.rb

@@ -63,5 +63,107 @@ describe Packager::Struct::Command do
         '-s', 'empty', '-t', 'test',
       ])
     end
+
+    it "handles before_install" do
+      cmd = Packager::Struct::Command.new(
+        :name => 'foo',
+        :version => '0.0.1',
+        :target  => 'test',
+        :before_install => ['foo'],
+      )
+
+      expect(cmd.to_system).to eq([
+        'fpm',
+        '--name', 'foo',
+        '--version', '0.0.1',
+        '--before-install', 'foo',
+        '-s', 'empty', '-t', 'test',
+      ])
+    end
+
+    it "handles after_install" do
+      cmd = Packager::Struct::Command.new(
+        :name => 'foo',
+        :version => '0.0.1',
+        :target  => 'test',
+        :after_install => ['foo'],
+      )
+
+      expect(cmd.to_system).to eq([
+        'fpm',
+        '--name', 'foo',
+        '--version', '0.0.1',
+        '--after-install', 'foo',
+        '-s', 'empty', '-t', 'test',
+      ])
+    end
+
+    it "handles before_remove" do
+      cmd = Packager::Struct::Command.new(
+        :name => 'foo',
+        :version => '0.0.1',
+        :target  => 'test',
+        :before_remove => ['foo'],
+      )
+
+      expect(cmd.to_system).to eq([
+        'fpm',
+        '--name', 'foo',
+        '--version', '0.0.1',
+        '--before-remove', 'foo',
+        '-s', 'empty', '-t', 'test',
+      ])
+    end
+
+    it "handles after_remove" do
+      cmd = Packager::Struct::Command.new(
+        :name => 'foo',
+        :version => '0.0.1',
+        :target  => 'test',
+        :after_remove => ['foo'],
+      )
+
+      expect(cmd.to_system).to eq([
+        'fpm',
+        '--name', 'foo',
+        '--version', '0.0.1',
+        '--after-remove', 'foo',
+        '-s', 'empty', '-t', 'test',
+      ])
+    end
+
+    it "handles before_upgrade" do
+      cmd = Packager::Struct::Command.new(
+        :name => 'foo',
+        :version => '0.0.1',
+        :target  => 'test',
+        :before_upgrade => ['foo'],
+      )
+
+      expect(cmd.to_system).to eq([
+        'fpm',
+        '--name', 'foo',
+        '--version', '0.0.1',
+        '--before-upgrade', 'foo',
+        '-s', 'empty', '-t', 'test',
+      ])
+    end
+
+    it "handles after_upgrade" do
+      cmd = Packager::Struct::Command.new(
+        :name => 'foo',
+        :version => '0.0.1',
+        :target  => 'test',
+        :after_upgrade => ['foo'],
+      )
+
+      expect(cmd.to_system).to eq([
+        'fpm',
+        '--name', 'foo',
+        '--version', '0.0.1',
+        '--after-upgrade', 'foo',
+        '-s', 'empty', '-t', 'test',
+      ])
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: packager-dsl
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Rob Kinyon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-11 00:00:00.000000000 Z
+date: 2018-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dsl_maker