builderator 1.0.0.pre.rc.9 → 1.0.0.pre.rc.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ff5accfec82561d29eafb07b3477a9f739684fd2
-  data.tar.gz: ac6c8c3d414ddff108046a84fc5c32e0ac4a10a3
+  metadata.gz: c7e1986d4b7bb1afd09020158460d0ab35220850
+  data.tar.gz: 1545ff99c44cbb336fd0315d6f43d3121568a720
 SHA512:
-  metadata.gz: 8e50ade752fcfa4ae0d80bbb90eb614d9cb52301f614d76efe02239ce3cece1e1413724039e4bdb4c0d11fdef7aec1bdddc8898fb7232c8f88d6a5ca63ec4153
-  data.tar.gz: 161932a36e9ac67e57fcfc7ccb682bb44cbebd279be4c467ed5002e7f09ab20f7f706a69ed3c25eb80f342e3b8b5623f48bf6675270cb9e7c7d77cf0c3df5ae1
+  metadata.gz: 419b869cec9a0f1eca44d02e4aa125a7bb4a5e959f5caea5c093ef7477066d64f6a62c9aa1bc7423636d962920a5c9496a520260ce55fe575eb53762d37a6b5d
+  data.tar.gz: 2639dbc8a87bbd6a788a8960fbdda57a64a15dc6c498f6ccdc8a06789bad1b569c8966887f6f4b8c496e7213d26c2cfc963fed1e7bf4b650797e9e01e5f78e2f

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    builderator (1.0.0.pre.rc.8)
+    builderator (1.0.0.pre.rc.9)
       aws-sdk (~> 2.0)
       berkshelf (~> 3.2)
       chef (~> 12.0)

data/VERSION

@@ -1 +1 @@
-1.0.0-rc.9
+1.0.0-rc.10

data/docs/configuration.md

@@ -1,9 +1,9 @@
 Configuration DSL
 =================
 
-The configuration DSL is made up of key-value pairs, called `attributes`, which are grouped into `namespaces` and `collections`.
+Builderator's configuration language is a Ruby DSL, composed of `attributes`,  which are grouped into `namespaces`. A `namespace` may be singular, or it may be part of a `collection`, in which case more than one named entry may be defined with the same `namespace`.
 
-Namespaces can accessed with blocks, or with a fluent interface:
+Namespaces and collections can accessed with blocks, or with a fluent interface:
 
 ```ruby
 aws do |a|
@@ -14,26 +14,119 @@ end
 aws.region = 'us-west-1'
 ```
 
-Collections are named sets. Like namespaces, they can be accessed with blocks, or a fluent interface:
+Collections are sets of named items. Like namespaces, they can be accessed with blocks, or a fluent interface:
 
 ```ruby
 profile :default do |default_profile|
-  default_profile.chef.run_list 'apt:default', 'redis:server'
+  default_profile.chef.run_list 'apt:default', 'redis:server', 'app::server'
 end
 
 profile(:default).chef.environment 'development'
+profile(:prod).chef.environment 'production'
 ```
 
-In the example above, the same collection is accessed twice. The final result looks like:
+In the example above, the same collection item is accessed twice. A second item is also defined in the same collection. The final result looks like:
 
 ```json
 {
   "profile": {
     "default": {
       "chef": {
-        "run_list": ["apt:default", "redis:server"],
+        "run_list": ["apt:default", "redis:server", "app::server"],
         "environment": "development"
       }
+    },
+    "prod": {
+      "chef": {
+        "environment": "production"
+      }
+    }
+  }
+}
+```
+
+Collections and namespaces may be nested indefinitely.
+
+## Extending Collection Items
+
+A collection item can extend another item using a hash-notation:
+
+```ruby
+profile :prod => Config.profile(:default) do |prod|
+  prod.chef.environment = 'production'
+end
+```
+
+Following the example, above, the `prod` profile will now be pre-populated with all of the values in the `default` profile, which can be overridden:
+
+```json
+{
+  "profile": {
+    "default": {
+      "chef": {
+        "run_list": ["apt:default", "redis:server", "app::server"],
+        "environment": "development"
+      }
+    },
+    "prod": {
+      "chef": {
+        "run_list": ["apt:default", "redis:server", "app::server"],
+        "environment": "production"
+      }
+    }
+  }
+}
+```
+
+## List-type Attributes
+
+Some configuration attributes are actually ordered sets of values. These are referred to as `list-type` attributes, and have some additional options:
+
+```ruby
+chef.run_list 'apt:default', :mode => :override
+```
+
+The `:mode` parameter tells the configuration manager how how to compile a list-type attribute that is defined in two or more layers, or is modified in an extended collection item. Currently, two modes are implemented:
+
+* `:override` - Instructs the compiler to discard any elements that have been loaded from lower layers. This does not have any effect upon the behavior of the same attribute in higher layers, meaning that the current layer's override may be appended to or overridden by future layers, according to their `mode` parameter.
+* `:union` - Default behavior. Instructs the compiler to perform a set-union between the current layer's elements and the current set of elements compiled from lower layers.
+
+List-type attributes may also have an `appender method`, which allows elements to be appended to the current set _in that layer_. **List-type attributes do not have an `=` setter.**
+
+Because `chef.run_list` is a list-type attribute, we can tell Builderator to override the `default` profile's `run_list`:
+
+```ruby
+profile :prod => Config.profile(:default) do |prod|
+  prod.chef.environment = 'production'
+  prod.chef.run_list 'apt:default', 'redis:server', 'app::server', 'app::tls', :mode => :override
+end
+```
+
+We could also append to `default`'s `run_list` without modifying `default`:
+
+```ruby
+profile :prod => Config.profile(:default) do |prod|
+  prod.chef.environment = 'production'
+  prod.chef.run_list_item 'app::tls'
+end
+```
+
+Both of the above will result in the same compiled configuration:
+
+```json
+{
+  "profile": {
+    "default": {
+      "chef": {
+        "run_list": ["apt:default", "redis:server", "app::server"],
+        "environment": "development"
+      }
+    },
+    "prod": {
+      "chef": {
+        "run_list": ["apt:default", "redis:server", "app::server", "app::tls"],
+        "environment": "production"
+      }
     }
   }
 }
@@ -46,9 +139,9 @@ In the example above, the same collection is accessed twice. The final result lo
 
 * `vendored(name, path)` - Return the absolute path to `path` in the named vendor resource. _ Hint: Use this helper to reference Builderator policy files and Chef data_bag and environment sources in an external repository._
 
-## Configuration File DSL
+* `relative(path)` - Return the absolute path to `path` relative to the calling Buildfile _Hint: Use this helper to reference templates included with a vendored policy._
 
-Collections and namespaces may be nested indefinitely.
+## Configuration Parameters
 
 * [Namespace `cookbook`](configuration/cookbook.md)
 * [Collection `profile`](configuration/profile.md)
@@ -60,14 +153,12 @@ Collections and namespaces may be nested indefinitely.
 * `version` The version of this release of the build. Auto-populated by `autoversion` by default
 * `cleanup` Enable post-build cleanup tasks. Default `true`
 
-* `relative(path)` - Return the absolute path to `path` relative to the calling Buildfile _Hint: Use this helper to reference templates included with a vendored policy._
-
-## Namespace `autoversion`
+### Namespace `autoversion`
 
 * `create_tags` During a release, automatically create and push new SCM tags
 * `search_tags` Use SCM tags to determine the current version of the build
 
-## Namespace `chef`
+### Namespace `chef`
 
 Global configurations for chef provisioners in Vagrant and Packer
 
@@ -75,28 +166,28 @@ Global configurations for chef provisioners in Vagrant and Packer
 * `staging_directory` the path in VMs and images that Chef artifacts should be mounted/copied to. Defaults to `/var/chef`
 * `version` The version of chef to install with Omnibus
 
-## Namespace `local`
+### Namespace `local`
 
 Local paths used for build tasks
 
 * `cookbook_path` Path at which to vendor cookbooks. Default `.builderator/cookbooks`
 * `data_bag_path` and `environment_path` Paths that Chef providers should load data-bag and environment documents from.
 
-## Collection `policy`
+### Collection `policy`
 
 Load additional attributes into the parent file from a relative path
 
 * `path` Load a DSL file, relative => true
 * `json` Load a JSON file relative => true
 
-## Namespace `aws`
+### Namespace `aws`
 
 AWS API configurations. _Hint: Configure these in `$HOME/.builderator/Buildfile`, or use a built-in credential source, e.g. ~/.aws/config!_
 
 * `region` The default AWS region to use
 * `access_key` and `secret_key` A valid IAM key-pair
 
-## Collection `vendor`
+### Collection `vendor`
 
 Fetch remote artifacts for builds
 
@@ -105,16 +196,16 @@ Fetch remote artifacts for builds
   * `git` Fetch a git repository
   * `github` Fetch a git repository from a GitHub URI (e.g. `OWNER/REPO`) using the SSH protocol. You must have a valid SSH key configuration for public GitHub.
 * Git-specific parameters:
-  * `branch`
-  * `tag`
-  * `ref`
+  * `remote` - The name of the remote repository at `git` or `github`. Defaults to `origin`
+  * `branch` - The SCM branch to check out. Defaults to `master`
+  * `tag` or `ref` - A SHA-ish or SCM tag to check out. Overrides `branch`.
   * `rel` Checkout a sub-directory of a git repository
 
-## Namespace `cleaner`
+### Namespace `cleaner`
 
 Configuration parameters for `build-clean` tasks
 
-### Namespace `limits`
+#### Namespace `limits`
 
 Maximum number of resources to remove without manual override
 
@@ -123,25 +214,25 @@ Maximum number of resources to remove without manual override
 * `snapshots`
 * `volumes`
 
-## Namespace `generator`
+### Namespace `generator`
 
 Configurations for the `generator` task
 
-### Collection `project`
+#### Collection `project`
 
 * `builderator.version` The version of Builderator to install with Bundler
 * `ruby.version` The version of ruby to require for Bundler and `rbenv`/`rvm`
 
-#### Namespace `vagrant`
+##### Namespace `vagrant`
 
 * `install` Boolean, include the vagrant gem from GitHub `mitchellh/vagrant`
 * `version` The version of Vagrant to use from GitHub, if `install` is true
 
-##### Collection `plugin`
+###### Collection `plugin`
 
 Vagrant plugins to install, either with the `build vagrant plugin` command, for a system-wide installation of Vagrant, or in the generated Gemfile if `install` is true
 
-#### Collection `resource`
+##### Collection `resource`
 
 Add a managed file to the project definition
 

data/lib/builderator/config.rb

@@ -14,7 +14,7 @@ module Builderator
       end
 
       def all_layers
-        ([defaults] + layers + [overrides, argv])
+        ([GLOBAL_DEFAULTS, defaults] + layers + [overrides, argv])
       end
 
       def defaults
@@ -51,22 +51,23 @@ module Builderator
         compiled.unseal
         compile_iterations = 0
 
-        ## Initialize with global defaults
+        ## Inject GLOBAL_DEFAULTS before starting compile
         compiled.merge(GLOBAL_DEFAULTS.compile)
 
         ## Automatically recompile while layers are dirty
         loop do
           fail "Re-compile iteration limit of #{max_iterations} has been exceeded" if compile_iterations >= max_iterations
 
-          ## Reset flags before next iteration
-          compiled.clean
-
           ## Merge layers from lowest to highest. Compile, then merge.
-          all_layers.each(&:compile)
           all_layers.each do |layer|
-            compiled.merge(layer)
+            layer.compile
+          end
 
+          all_layers.each do |layer|
             layer.policies.each { |_, policy| compiled.merge(policy) }
+
+            ## Merge layer after its policy documents to allow overides
+            compiled.merge(layer)
           end
 
           break unless dirty?
@@ -79,7 +80,7 @@ module Builderator
       alias_method :recompile, :compile
 
       def dirty?
-        all_layers.any?(&:dirty) || compiled.dirty
+        all_layers.any?(&:dirty)
       end
 
       def compiled

data/lib/builderator/config/attributes.rb

@@ -2,6 +2,7 @@ require 'forwardable'
 require 'json'
 
 require_relative './rash'
+require_relative './list'
 
 module Builderator
   module Config
@@ -18,31 +19,30 @@ module Builderator
           # Helpers for Array-type attributes
           ##
           if options[:type] == :list
-            default = Array
+            define_method(attribute_name) do |*arg, **run_options|
+              ## Instantiate List if it doesn't exist yet. `||=` will always return a new Rash.
+              @attributes[attribute_name] = Config::List.new(run_options) unless @attributes.has?(attribute_name, Config::List)
 
-            ## Add an appender DSL method
-            define_method(options[:singular]) do |*args|
-              append_if_valid(attribute_name, args.flatten, default, options)
+              @attributes[attribute_name].set(*arg.flatten) unless arg.empty?
+              @attributes[attribute_name]
+            end
+
+            define_method(options[:singular]) do |*arg, **run_options|
+              send(attribute_name, run_options).push(*arg.flatten)
             end if options.include?(:singular)
+
+            return
           end
 
           ## Getter/Setter
           define_method(attribute_name) do |*arg|
-            arg.flatten!
-            arg = arg.first unless options[:type] == :list
-
-            set_or_return(attribute_name, arg, default, options)
+            set_or_return(attribute_name, arg.first, default, options)
           end
 
           ## Setter
           define_method("#{attribute_name}=") do |arg|
             set_if_valid(attribute_name, arg, options)
-          end unless options[:type] == :list
-        end
-
-        ## Add a method the DSL
-        def define(method_name, &block)
-          define_method(method_name, &block)
+          end
         end
 
         ##
@@ -58,7 +58,7 @@ module Builderator
         # end
         # ```
         #
-        # Multiple calls to the DSL method will are safe and will
+        # Multiple calls to the DSL method are safe and will
         # update the same sub-node.
         ##
         def namespace(namespace_name, &definition)
@@ -68,7 +68,7 @@ module Builderator
             nodes[namespace_name] ||= namespace_class.new(
               @attributes[namespace_name],
               :name => namespace_name,
-              :parent => self, &block).compile
+              :parent => self, &block)
           end
         end
 
@@ -85,16 +85,29 @@ module Builderator
         # Multiple entities can be added to the collection by calling the DSL method
         # with unique `name` arguments. Multiple calls to the DSL method with the
         # same name argument will update the existing entity in place
+        #
+        # An entry can be defined as an extension of another node by passing a hash
+        # as the instance name: `name => Config.node(:name)`. This will use the values
+        # defined in `Config.node(:name)` as defaults for the new entry
         ##
         def collection(collection_name, &definition)
           collection_class = Collection.create(collection_name, &definition)
 
           define_method(collection_name) do |instance_name = nil, &block|
+            extension_base = nil
+
+            ## Allow extension to be defined as a key-value
+            if instance_name.is_a?(Hash)
+              extension_base = instance_name.first.last
+              instance_name = instance_name.first.first
+            end
+
             nodes[collection_name] ||= collection_class.new(
-              @attributes[collection_name])
+              @attributes[collection_name],
+              :parent => self)
 
             return nodes[collection_name] if instance_name.nil?
-            nodes[collection_name].fetch(instance_name, &block).compile
+            nodes[collection_name].fetch(instance_name, :extends => extension_base, &block)
           end
         end
       end
@@ -118,14 +131,10 @@ module Builderator
       end
 
       ## All dirty state should aggregate at the root node
-      def dirty
-        return @dirty if parent == self
-        parent.dirty
-      end
+      def dirty(update = false)
+        return @dirty ||= update if parent == self
 
-      def dirty=(set)
-        return @dirty = set if parent == self
-        parent.dirty = set
+        parent.dirty(update)
       end
 
       def ==(other)
@@ -135,6 +144,7 @@ module Builderator
       attr_reader :attributes
       attr_reader :nodes
       attr_reader :parent
+      attr_reader :extends
 
       def initialize(attributes = {}, options = {}, &block)
         @attributes = Rash.coerce(attributes)
@@ -143,24 +153,35 @@ module Builderator
 
         ## Track change status for consumers
         @parent = options.fetch(:parent, self)
-        self.dirty = false if parent == self
+        @extends = options[:extends]
+        @dirty = false
       end
 
       ## Clear dirty state flag
       def clean
-        self.dirty = false
+        @dirty = false
       end
 
-      def compile
-        instance_eval(&@block) if @block
+      def compile(evaluate = true)
+        ## Compile this node and its children
+        @block.call(self) if @block && evaluate
+        nodes.each { |_, node| node.compile }
+
+        ## Underlay base values if present
+        if extends.is_a?(Attributes)
+          merged_atributes = extends.attributes.clone
+          merged_atributes.merge!(attributes)
+
+          attributes.merge!(merged_atributes)
+        end
+
         self
       end
 
       def merge(other)
-        self.dirty |= attributes.merge!(other.attributes)
+        dirty(attributes.merge!(other.attributes))
         self
       end
-      alias_method :includes, :merge
 
       def to_json(*_)
         JSON.pretty_generate(to_hash)
@@ -182,24 +203,12 @@ module Builderator
         ## Unchanged
         return if @attributes[key] == arg
 
-        self.dirty |= true ## A mutation has occured
+        dirty(true) ## A mutation has occured
         @attributes[key] = arg
       end
 
-      def append_if_valid(key, arg, default = Array, **options)
-        ## TODO: define validation interface
-
-        attribute = set_or_return(key, nil, default, options)
-        arg.reject! { |item| attribute.include?(item) }
-
-        return if arg.empty?
-
-        @dirty |= true ## A mutation has occured
-        attribute.push(*arg)
-      end
-
       def set_or_return(key, arg = nil, default = nil, **options)
-        if arg.nil? || (arg.is_a?(Array) && arg.empty?)
+        if arg.nil?
           return @attributes[key] if @attributes.has?(key)
 
           ## Default
@@ -249,11 +258,6 @@ module Builderator
           @name = options.fetch(:name, self.class.name)
           @collection = options[:collection]
         end
-
-        def compile
-          @block.call(self) if @block
-          self
-        end
       end
 
       ##
@@ -291,12 +295,13 @@ module Builderator
         end
 
         ## Get namespace instances
-        def fetch(instance_name, &block)
-          self.class.namespace_class.new(
+        def fetch(instance_name, **options, &block)
+          nodes[instance_name] ||= self.class.namespace_class.new(
             attributes[instance_name],
             :collection => self,
             :name => instance_name,
-            :parent => self, &block)
+            :parent => self,
+            :extends => options[:extends], &block)
         end
         alias_method :[], :fetch
       end

data/lib/builderator/config/file.rb

@@ -39,7 +39,7 @@ module Builderator
         @type = options.fetch(:type, :code)
         @source = options.fetch(:source, nil)
 
-        super(attributes, &block)
+        super(attributes, options, &block)
       end
 
       def compile
@@ -48,15 +48,19 @@ module Builderator
         case @type
         when :file
           instance_eval(IO.read(source), source, 0)
+          super(false)
+
         when :json
           update = Rash.coerce(JSON.parse(IO.read(source)))
 
           unless @attributes == update
-            @dirty |= true
+            dirty(true)
             @attributes = update
           end
         else
           instance_eval(&@block) if @block
+          super(false)
+
         end
 
         ## Overlay policies
@@ -71,7 +75,7 @@ module Builderator
           end
 
           policies[name].compile
-          self.dirty |= policies[name].dirty
+          dirty(policies[name].dirty)
         end
 
         self
@@ -273,6 +277,7 @@ module Builderator
 
         attribute :git
         attribute :github
+        attribute :remote
         attribute :branch
         attribute :tag
         attribute :ref

data/lib/builderator/config/list.rb

@@ -0,0 +1,63 @@
+module Builderator
+  module Config
+    ##
+    # Extend Array with context about how its values should be merged with other
+    # configuration layers. Possible modes are:
+    #
+    # * 'override' - Do not merge. Replace the other node's elements
+    # * 'union' - Perform a set-union on the elements of this and the other node
+    ##
+    class List < Array
+      class << self
+        def coerce(somehting, options = {})
+          return somehting if somehting.is_a?(self)
+          return new(options).push(*somehting) if somehting.is_a?(Array)
+
+          ## `somehting` is not a valid input. Just give back an instance.
+          new([], options)
+        end
+      end
+
+      attr_reader :mode
+
+      def initialize(from = nil, **options)
+        @mode = options.fetch(:mode, :union)
+
+        merge!(from) unless from.nil?
+      end
+
+      def clone
+        self.class.new(self, :mode => mode)
+      end
+
+      def set(*elements)
+        clear
+        push(*elements)
+      end
+
+      ##
+      # Combine elements with `other` according to `other`'s `mode`
+      ##
+      def merge!(other)
+        other = self.class.coerce(other)
+
+        case other.mode
+        when :override
+          return false if self == other
+          set(*other)
+
+        when :union
+          merged = self | other
+          return false if merged == self
+
+          set(*merged)
+
+        else
+          fail "Invalid List mode #{other.mode}!"
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/builderator/config/rash.rb

@@ -1,3 +1,5 @@
+require_relative './list'
+
 module Builderator
   module Config
     ##
@@ -26,6 +28,10 @@ module Builderator
         merge!(from) ## Clone a Rash or coerce a Hash to a new Rash
       end
 
+      def clone
+        self.class.new(self, sealed)
+      end
+
       def seal(action = true)
         @sealed = action
         each_value { |v| v.seal(action) if v.is_a?(self.class) }
@@ -35,7 +41,9 @@ module Builderator
         seal(false)
       end
 
-      alias_method :has?, :include?
+      def has?(key, klass = BasicObject)
+        include?(key) && fetch(key).is_a?(klass)
+      end
 
       ## Symbolize keys
       [:include?, :[], :fetch, :[]=, :store].each do |m|
@@ -56,24 +64,21 @@ module Builderator
           next if self[k] == v
 
           ## Merge Arrays
-          if fetch(k, nil).is_a?(Array) && v.is_a?(Array)
-            next if (self[k] | v) == self[k]
-
-            dirty |= true
-            next self[k] |= v
+          if v.is_a?(Array)
+            self[k] = has?(k) ? Config::List.coerce(self[k]) : Config::List.new
+            dirty = self[k].merge!(v) || dirty
+            next
           end
 
           ## Overwrite non-Hash values
           unless v.is_a?(Hash)
-            dirty |= true
+            dirty = true
             next self[k] = v
           end
 
-          ## Replace `self[k]` with a new Rash unless it already is one
-          self[k] = self.class.new unless fetch(k, nil).is_a?(self.class)
-
           ## Merge recursivly coerces `v` to a Rash
-          dirty |= self[k].merge!(v)
+          self[k] = self.class.coerce(self[k])
+          dirty = self[k].merge!(v) || dirty
         end
 
         dirty

data/lib/builderator/tasks/vendor.rb

@@ -53,16 +53,20 @@ module Builderator
 
       no_commands do
         def _fetch_git(path, params)
-          empty_directory path
+          ## Ensure that there isn't already something there
+          unless path.join('.git').exist?
+            remove_dir path
+            empty_directory path
+          end
 
           inside path do
             ## Initialize new repository
             unless path.join('.git').exist?
               run 'git init'
-              run "git remote add origin #{ params.git }"
+              run "git remote add #{ params.fetch(:remote, 'origin') } #{ params.git }"
             end
 
-            run 'git fetch origin --tags --prune'
+            run "git fetch #{ params.fetch(:remote, 'origin') } --tags --prune"
 
             ## Checkout reference
             if params.has?(:tag) then run "git checkout #{ params.tag }"
@@ -71,7 +75,7 @@ module Builderator
               run "git checkout #{ params.fetch(:branch, 'master') }"
 
               ## Only pull if a tracking branch is checked out
-              run 'git pull'
+              run "git pull #{ params.fetch(:remote, 'origin') } #{ params.fetch(:branch, 'master') }"
             end
 
             ## Apply relative subdirectory

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: builderator
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.rc.9
+  version: 1.0.0.pre.rc.10
 platform: ruby
 authors:
 - John Manero
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-25 00:00:00.000000000 Z
+date: 2016-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -183,6 +183,7 @@ files:
 - lib/builderator/config/attributes.rb
 - lib/builderator/config/defaults.rb
 - lib/builderator/config/file.rb
+- lib/builderator/config/list.rb
 - lib/builderator/config/rash.rb
 - lib/builderator/control/cleaner.rb
 - lib/builderator/control/cookbook.rb
@@ -256,7 +257,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Tools to make CI Packer builds awesome