stackup 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6ba465cd7978cabe9b222a5053e0dcafbf8334e3
-  data.tar.gz: 731b59587827b376025ad29b769f3495aec6361c
+  metadata.gz: a2f56d7cc442a15b14e0df0bd2ed9b9c39b34197
+  data.tar.gz: 187f7372696c5f6ae84530e218bb9c0c0bf691bd
 SHA512:
-  metadata.gz: 32fe3ab0b69a2c80a00ef6d41baea6a75732ed0e46ed8fef37c14ac14248d2aa15203309010eb3e262f42ad018aec828ba77abf78ff47a6ae1a662931382ee56
-  data.tar.gz: 5455f7e5e49d56e892fdc3a4964d29b7e0f9715837097a2d7afef165395897532fda6cacbadfe737cc8982eb85a818e3c44661fd619f9a599ed0f550838b748d
+  metadata.gz: f33df243de76851d2f63c8776b8ee44eb2634219fb838adee0d096ecca2fffc19feeb2effcc50aadded2d0f4e04dec2fd7a5640045fe4362782b19874ae81bc1
+  data.tar.gz: b72c70703f52d5be553ffff3a2c98e360b7cf008aa8f03c993d3920888c84d897a55d38ab8705655d567b6bec52c1b31fa7e377ee3ecb86650e7188cb28e7ae9

data/README.md

@@ -37,6 +37,8 @@ Called with `--list`, it will list stacks:
     foo-bar-test
     zzz-production
 
+The command-line support inputs (template and parameters) in either JSON or YAML format.
+
 ### Stack create/update
 
 Use sub-command "up" to create or update a stack, as appropriate:
@@ -79,7 +81,7 @@ Stackup integrates with Rake to generate handy tasks for managing a stack, e.g.
 
     require "stackup/rake_tasks"
 
-    Stackup::RakeTasks("app") do |t|
+    Stackup::RakeTasks.new("app") do |t|
       t.stack = "my-app"
       t.template = "app-template.json"
     end
@@ -90,3 +92,12 @@ providing tasks:
     rake app:down       # Delete my-app stack
     rake app:inspect    # Show my-app stack outputs and resources
     rake app:up         # Update my-app stack
+
+Parameters and tags may be specified via files, or as a Hash, e.g.
+
+    Stackup::RakeTasks.new("app") do |t|
+      t.stack = "my-app"
+      t.template = "app-template.json"
+      t.parameters = "production-params.json"
+      t.tags = { "environment" => "production" }
+    end

data/bin/stackup

@@ -4,9 +4,9 @@ $LOAD_PATH << File.expand_path("../../lib", __FILE__)
 
 require "clamp"
 require "console_logger"
-require "diffy"
 require "multi_json"
 require "stackup"
+require "stackup/differ"
 require "stackup/version"
 require "yaml"
 
@@ -22,6 +22,14 @@ Clamp do
 
   option ["-Y", "--yaml"], :flag, "output data in YAML format"
 
+  option ["--region"], "REGION", "set region" do |arg|
+    unless arg =~ /^[a-z]{2}-[a-z]+-\d$/
+      fail ArgumentError, "#{arg.inspect} doesn't look like a region"
+    end
+    Aws.config.update(:region => arg)
+    arg
+  end
+
   option "--debug", :flag, "enable debugging"
 
   option ["--version"], :flag, "display version" do
@@ -103,6 +111,13 @@ Clamp do
     option ["-p", "--parameters"], "FILE", "parameters file",
            :attribute_name => :parameters_file
 
+    option ["-o", "--override"], "PARAM=VALUE", "parameters overrides",
+           :multivalued => true,
+           :attribute_name => :override_list
+
+    option "--tags", "FILE", "stack tags file",
+           :attribute_name => :tags_file
+
     option "--policy", "FILE", "stack policy file",
            :attribute_name => :policy_file
 
@@ -117,7 +132,8 @@ Clamp do
       options = {}
       options[:template] = load_data(template_file) if template_file
       options[:on_failure] = on_failure
-      options[:parameters] = load_data(parameters_file) if parameters_file
+      options[:parameters] = parameters
+      options[:tags] = load_data(tags_file) if tags_file
       options[:stack_policy] = load_data(policy_file) if policy_file
       options[:use_previous_template] = use_previous_template?
       report_change do
@@ -125,6 +141,26 @@ Clamp do
       end
     end
 
+    private
+
+    def parameters
+      parameters_from_file.merge(parameter_overrides)
+    end
+
+    def parameters_from_file
+      return {} unless parameters_file
+      Stackup::Parameters.new(load_data(parameters_file)).to_hash
+    end
+
+    def parameter_overrides
+      {}.tap do |result|
+        override_list.each do |override|
+          key, value = override.split("=", 2)
+          result[key] = value
+        end
+      end
+    end
+
   end
 
   subcommand "diff", "Compare template/params to current stack." do
@@ -135,41 +171,45 @@ Clamp do
     option ["-p", "--parameters"], "FILE", "parameters file",
            :attribute_name => :parameters_file
 
+    option "--tags", "FILE", "stack tags file",
+           :attribute_name => :tags_file
+
     option "--diff-format", "FORMAT", "'text', 'color', or 'html'", :default => "color"
 
     def execute
-      # rubocop:disable Style/GuardClause
+      current = {}
+      planned = {}
       if template_file
-        template = load_data(template_file)
-        diff_data(stack.template, template)
+        current["Template"] = stack.template
+        planned["Template"] = load_data(template_file)
       end
       if parameters_file
-        new_parameters = hashify_parameters(load_data(parameters_file))
-        existing_parameters = stack.parameters
-        new_parameters = existing_parameters.merge(new_parameters)
-        diff_data(existing_parameters.sort.to_h, new_parameters.sort.to_h)
+        current["Parameters"] = existing_parameters.sort.to_h
+        planned["Parameters"] = new_parameters.sort.to_h
+      end
+      if tags_file
+        current["Tags"] = stack.tags.sort.to_h
+        planned["Tags"] = load_data(tags_file).sort.to_h
       end
+      signal_usage_error "specify '--template' or '--parameters'" if planned.empty?
+      puts differ.diff(current, planned)
     end
 
     private
 
-    def diff_data(existing_data, pending_data)
-      existing = format_data(existing_data) + "\n"
-      pending = format_data(pending_data) + "\n"
-      diff = Diffy::Diff.new(existing, pending).to_s(diff_format.to_sym)
-      return if diff =~ /\A\s*\Z/
-      puts diff
+    def differ
+      Stackup::Differ.new(diff_format, &method(:format_data))
     end
 
-    def hashify_parameters(parameters)
-      return parameters unless parameters.is_a?(Array)
-      {}.tap do |result|
-        parameters.each do |p|
-          key = p.fetch("ParameterKey") { p.fetch("parameter_key") }
-          value = p.fetch("ParameterValue") { p.fetch("parameter_value") }
-          result[key] = value
-        end
-      end
+    def existing_parameters
+      @existing_parameters ||= stack.parameters
+    end
+
+    def new_parameters
+      result = load_data(parameters_file)
+      result = Stackup::Parameters.new(result).to_hash
+      result = existing_parameters.merge(result)
+      result.sort
     end
 
   end
@@ -284,12 +324,13 @@ Clamp do
 
   end
 
-  subcommand "inspect", "status + parameters + resources + outputs" do
+  subcommand "inspect", "Display stack particulars" do
 
     def execute
       data = {
         "Status" => stack.status,
         "Parameters" => stack.parameters,
+        "Tags" => stack.tags,
         "Resources" => stack.resources,
         "Outputs" => stack.outputs
       }

data/examples/Rakefile

@@ -0,0 +1,11 @@
+require "stackup/rake_tasks"
+
+Stackup::RakeTasks.new("demo") do |t|
+  t.stack = ENV.fetch("STACKUP_DEMO_STACK", "stackup-demo")
+  t.template = "template.json"
+  t.parameters = "parameters-verbose.json"
+  t.tags = {
+    "environment" => "dev",
+    "team" => "rea-oss"
+  }
+end

data/lib/stackup/differ.rb

@@ -0,0 +1,32 @@
+require "diffy"
+require "yaml"
+
+module Stackup
+
+  # Generates diffs of data.
+  #
+  class Differ
+
+    def initialize(diff_style = :color, &data_formatter)
+      @diff_style = diff_style.to_sym
+      @data_formatter = data_formatter || YAML.method(:dump)
+    end
+
+    attr_reader :diff_style
+
+    def diff(existing_data, pending_data)
+      existing = format(existing_data) + "\n"
+      pending = format(pending_data) + "\n"
+      diff = Diffy::Diff.new(existing, pending).to_s(diff_style)
+      diff unless diff =~ /\A\s*\Z/
+    end
+
+    private
+
+    def format(data)
+      @data_formatter.call(data)
+    end
+
+  end
+
+end

data/lib/stackup/parameters.rb

@@ -0,0 +1,76 @@
+module Stackup
+
+  # Parameters to a CloudFormation template.
+  #
+  class Parameters
+
+    class << self
+
+      def new(arg)
+        arg = hashify(arg) unless arg.is_a?(Hash)
+        super(arg)
+      end
+
+      private
+
+      def hashify(parameters)
+        {}.tap do |result|
+          parameters.each do |p|
+            p_struct = ParameterStruct.new(p)
+            result[p_struct.key] = p_struct.value
+          end
+        end
+      end
+
+    end
+
+    def initialize(parameter_hash)
+      @parameter_hash = parameter_hash
+    end
+
+    def to_hash
+      @parameter_hash.dup
+    end
+
+    def to_a
+      @parameter_hash.map do |key, value|
+        { :parameter_key => key }.tap do |record|
+          if value == :use_previous_value
+            record[:use_previous_value] = true
+          else
+            record[:parameter_value] = value
+          end
+        end
+      end
+    end
+
+  end
+
+  class ParameterStruct
+
+    def initialize(attributes)
+      attributes.each do |name, value|
+        if name.respond_to?(:gsub)
+          name = name.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+        end
+        public_send("#{name}=", value)
+      end
+    end
+
+    attr_accessor :parameter_key
+    attr_accessor :parameter_value
+    attr_accessor :use_previous_value
+
+    alias_method :key, :parameter_key
+
+    def value
+      if use_previous_value
+        :use_previous_value
+      else
+        parameter_value
+      end
+    end
+
+  end
+
+end

data/lib/stackup/rake_tasks.rb

@@ -1,4 +1,6 @@
 require "rake/tasklib"
+require "tempfile"
+require "yaml"
 
 module Stackup
 
@@ -10,6 +12,7 @@ module Stackup
     attr_accessor :stack
     attr_accessor :template
     attr_accessor :parameters
+    attr_accessor :tags
 
     alias_method :namespace=, :name=
 
@@ -23,24 +26,24 @@ module Stackup
       define
     end
 
+    # path to the "stackup" executable
+    STACKUP_CLI = File.expand_path("../../../bin/stackup", __FILE__)
+
     def stackup(*rest)
-      sh "stackup", stack, *rest
+      sh STACKUP_CLI, "-Y", stack, *rest
     end
 
     def define
       namespace(name) do
 
-        up_args = ["-t", template]
-        up_deps = [template]
-
-        if parameters
-          up_args += ["-p", parameters]
-          up_deps += [parameters]
-        end
+        data_options = DataOptions.new
+        data_options["--template"] = template
+        data_options["--parameters"] = parameters if parameters
+        data_options["--tags"] = tags if tags
 
         desc "Update #{stack} stack"
-        task "up" => up_deps do
-          stackup "up", *up_args
+        task "up" => data_options.files do
+          stackup "up", *data_options.to_a
         end
 
         desc "Cancel update of #{stack} stack"
@@ -49,8 +52,8 @@ module Stackup
         end
 
         desc "Show pending changes to #{stack} stack"
-        task "diff" => up_deps do
-          stackup "diff", *up_args
+        task "diff" => data_options.files do
+          stackup "diff", *data_options.to_a
         end
 
         desc "Show #{stack} stack outputs and resources"
@@ -66,6 +69,41 @@ module Stackup
       end
     end
 
+    # Options to "stackup up".
+    #
+    class DataOptions
+
+      def initialize
+        @options = {}
+      end
+
+      def []=(option, file_or_value)
+        @options[option] = file_or_value
+      end
+
+      def files
+        @options.values.grep(String)
+      end
+
+      def to_a
+        [].tap do |result|
+          @options.each do |option, file_or_data|
+            result << option
+            result << maybe_tempfile(file_or_data, option[2..-1])
+          end
+        end
+      end
+
+      def maybe_tempfile(file_or_data, type)
+        return file_or_data if file_or_data.is_a?(String)
+        tempfile = Tempfile.new([type, ".yml"])
+        tempfile.write(YAML.dump(file_or_data))
+        tempfile.close
+        tempfile.path.to_s
+      end
+
+    end
+
   end
 
 end

data/lib/stackup/stack.rb

@@ -2,6 +2,7 @@ require "aws-sdk-resources"
 require "logger"
 require "multi_json"
 require "stackup/error_handling"
+require "stackup/parameters"
 require "stackup/stack_watcher"
 
 module Stackup
@@ -65,8 +66,11 @@ module Stackup
     # @option options [String] :on_failure (ROLLBACK)
     #   if stack creation fails: DO_NOTHING, ROLLBACK, or DELETE
     # @option options [Hash, Array<Hash>] :parameters
-    #   stack parameters, either as a Hash, or as an Array of
+    #   stack parameters, either as a Hash, or an Array of
     #   +Aws::CloudFormation::Types::Parameter+ structures
+    # @option options [Hash, Array<Hash>] :tags
+    #   stack tags, either as a Hash, or an Array of
+    #   +Aws::CloudFormation::Types::Tag+ structures
     # @option options [Array<String>] :resource_types
     #   resource types that you have permissions to work with
     # @option options [Hash] :stack_policy
@@ -100,7 +104,10 @@ module Stackup
         options[:template_body] = MultiJson.dump(template_data)
       end
       if (parameters = options[:parameters])
-        options[:parameters] = normalise_parameters(parameters)
+        options[:parameters] = Parameters.new(parameters).to_a
+      end
+      if (tags = options[:tags])
+        options[:tags] = normalize_tags(tags)
       end
       if (policy_data = options.delete(:stack_policy))
         options[:stack_policy_body] = MultiJson.dump(policy_data)
@@ -188,13 +195,16 @@ module Stackup
     # @raise [Stackup::NoSuchStack] if the stack doesn't exist
     #
     def parameters
-      handling_validation_error do
-        {}.tap do |h|
-          cf_stack.parameters.each do |p|
-            h[p.parameter_key] = p.parameter_value
-          end
-        end
-      end
+      extract_hash(:parameters, :parameter_key, :parameter_value)
+    end
+
+    # Get the current tags.
+    #
+    # @return [Hash] current stack tags
+    # @raise [Stackup::NoSuchStack] if the stack doesn't exist
+    #
+    def tags
+      extract_hash(:tags, :key, :value)
     end
 
     # Get stack outputs.
@@ -203,13 +213,7 @@ module Stackup
     # @raise [Stackup::NoSuchStack] if the stack doesn't exist
     #
     def outputs
-      handling_validation_error do
-        {}.tap do |h|
-          cf_stack.outputs.each do |o|
-            h[o.output_key] = o.output_value
-          end
-        end
-      end
+      extract_hash(:outputs, :output_key, :output_value)
     end
 
     # Get stack outputs.
@@ -219,13 +223,7 @@ module Stackup
     # @raise [Stackup::NoSuchStack] if the stack doesn't exist
     #
     def resources
-      handling_validation_error do
-        {}.tap do |h|
-          cf_stack.resource_summaries.each do |r|
-            h[r.logical_resource_id] = r.physical_resource_id
-          end
-        end
-      end
+      extract_hash(:resource_summaries, :logical_resource_id, :physical_resource_id)
     end
 
     def watch(zero = true)
@@ -268,6 +266,7 @@ module Stackup
       fail StackUpdateError, "stack update failed" unless status == "UPDATE_COMPLETE"
       status
     rescue NoUpdateRequired
+      logger.info "No update required"
       nil
     end
 
@@ -279,7 +278,8 @@ module Stackup
     def event_handler
       @event_handler ||= lambda do |e|
         fields = [e.logical_resource_id, e.resource_status, e.resource_status_reason]
-        logger.info(fields.compact.join(" - "))
+        time = e.timestamp.localtime.strftime("%H:%M:%S")
+        logger.info("[#{time}] #{fields.compact.join(' - ')}")
       end
     end
 
@@ -302,33 +302,35 @@ module Stackup
       end
     end
 
-    def normalise_parameters(arg)
-      if arg.is_a?(Hash)
-        return arg.map do |key, value|
-          {
-            :parameter_key => key,
-            :parameter_value => value
-          }
+    def normalize_tags(tags)
+      if tags.is_a?(Hash)
+        tags.map do |key, value|
+          { :key => key, :value => value }
         end
-      end
-      arg.map do |parameter|
-        normalise_parameter_keys(parameter)
+      else
+        tags
       end
     end
 
-    def normalise_parameter_keys(input)
-      {}.tap do |output|
-        input.each do |key, value|
-          output[normalise_parameter_key(key)] = value
+    # Extract data from a collection attribute of the stack.
+    #
+    # @param [Symbol] collection_name collection attribute name
+    # @param [Symbol] key_name name of item attribute that provides key
+    # @param [Symbol] value_name name of item attribute that provides value
+    # @return [Hash<String, String>] mapping of collection
+    #
+    def extract_hash(collection_name, key_name, value_name)
+      handling_validation_error do
+        {}.tap do |result|
+          cf_stack.public_send(collection_name).each do |item|
+            key = item.public_send(key_name)
+            value = item.public_send(value_name)
+            result[key] = value
+          end
         end
       end
     end
 
-    def normalise_parameter_key(s)
-      return s if s.is_a?(Symbol)
-      s.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
-    end
-
   end
 
 end

data/lib/stackup/version.rb

@@ -1,5 +1,5 @@
 module Stackup
 
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 
 end

data/spec/spec_helper.rb

@@ -4,6 +4,7 @@ module CfStubbing
 
   def stub_cf_client
     client_options = { :stub_responses => true }
+    client_options[:logger] = Logger.new(nil)
     if ENV.key?("AWS_DEBUG")
       client_options[:logger] = ConsoleLogger.new(STDOUT, true)
       client_options[:log_level] = :debug

data/spec/stackup/parameters_spec.rb

@@ -0,0 +1,149 @@
+require "spec_helper"
+
+require "stackup/parameters"
+
+describe Stackup::Parameters do
+
+  context "constructed with a Hash" do
+
+    let(:input_hash) do
+      {
+        "Ami" => "ami-123",
+        "VpcId" => "vpc-456"
+      }
+    end
+
+    subject(:parameters) { Stackup::Parameters.new(input_hash) }
+
+    describe "#to_hash" do
+
+      it "returns the original Hash" do
+        expect(parameters.to_hash).to eql(input_hash)
+      end
+
+    end
+
+    describe "#to_a" do
+
+      it "returns an array of parameter records" do
+        expected = [
+          { :parameter_key => "Ami", :parameter_value => "ami-123" },
+          { :parameter_key => "VpcId", :parameter_value => "vpc-456" }
+        ]
+        expect(parameters.to_a).to eql(expected)
+      end
+
+    end
+
+    context "with a :use_previous_value" do
+
+      let(:input_hash) do
+        {
+          "Ami" => :use_previous_value
+        }
+      end
+
+      describe "#to_hash" do
+
+        it "returns the original Hash" do
+          expect(parameters.to_hash).to eql(input_hash)
+        end
+
+      end
+
+      describe "#to_a" do
+
+        it "returns a record with :use_previous_value true" do
+          expected = [
+            { :parameter_key => "Ami", :use_previous_value => true }
+          ]
+          expect(parameters.to_a).to eql(expected)
+        end
+
+      end
+
+    end
+
+  end
+
+  context "constructed with an array of parameter records" do
+
+    context "with symbol keys" do
+
+      let(:input_records) do
+        [
+          { :parameter_key => "Ami", :parameter_value => "ami-123" },
+          { :parameter_key => "VpcId", :parameter_value => "vpc-456" }
+        ]
+      end
+
+      subject(:parameters) { Stackup::Parameters.new(input_records) }
+
+      describe "#to_hash" do
+
+        it "returns an equivalent Hash" do
+          expected = {
+            "Ami" => "ami-123",
+            "VpcId" => "vpc-456"
+          }
+          expect(parameters.to_hash).to eql(expected)
+        end
+
+      end
+
+      describe "#to_a" do
+
+        it "returns the array form" do
+          expect(parameters.to_a).to eql(input_records)
+        end
+
+      end
+
+      context "with :use_previous_value" do
+
+        let(:input_records) do
+          [
+            { :parameter_key => "Ami", :use_previous_value => true }
+          ]
+        end
+
+        describe "#to_hash" do
+
+          it "marks the corresponding parameter as :use_previous_value" do
+            expect(parameters.to_hash).to eql("Ami" => :use_previous_value)
+          end
+
+        end
+
+      end
+
+    end
+
+    context "with String keys" do
+
+      let(:input_records) do
+        [
+          { "ParameterKey" => "Ami", "ParameterValue" => "ami-123" },
+          { "ParameterKey" => "VpcId", "ParameterValue" => "vpc-456" }
+        ]
+      end
+
+      subject(:parameters) { Stackup::Parameters.new(input_records) }
+
+      describe "#to_hash" do
+
+        it "returns an equivalent Hash" do
+          expected = {
+            "Ami" => "ami-123",
+            "VpcId" => "vpc-456"
+          }
+          expect(parameters.to_hash).to eql(expected)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/stackup/stack_spec.rb

@@ -33,7 +33,7 @@ describe Stackup::Stack do
     }
   end
 
-  def stack_description(stack_status)
+  def stack_description(stack_status, details = {})
     {
       :stacks => [
         {
@@ -41,7 +41,7 @@ describe Stackup::Stack do
           :stack_id => unique_stack_id,
           :stack_name => stack_name,
           :stack_status => stack_status
-        }
+        }.merge(details)
       ]
     }
   end
@@ -166,11 +166,11 @@ describe Stackup::Stack do
           }]
         end
 
-        it "converts them to an Array" do
+        it "converts the keys to aws-sdk form" do
           expected_parameters = [
             {
-              "parameter_key" => "foo",
-              "parameter_value" => "bar"
+              :parameter_key => "foo",
+              :parameter_value => "bar"
             }
           ]
           create_or_update
@@ -181,6 +181,44 @@ describe Stackup::Stack do
 
       end
 
+      context "with :tags as Hash" do
+
+        before do
+          options[:tags] = { "foo" => "bar" }
+        end
+
+        it "converts them to an Array" do
+          expected_tags = [
+            { :key => "foo", :value => "bar" }
+          ]
+          create_or_update
+          expect(cf_client).to have_received(:create_stack) do |options|
+            expect(options[:tags]).to eq(expected_tags)
+          end
+        end
+
+      end
+
+      context "with :tags in SDK form" do
+
+        before do
+          options[:tags] = [
+            { :key => "foo", :value => "bar" }
+          ]
+        end
+
+        it "passes them through" do
+          expected_tags = [
+            { :key => "foo", :value => "bar" }
+          ]
+          create_or_update
+          expect(cf_client).to have_received(:create_stack) do |options|
+            expect(options[:tags]).to eq(expected_tags)
+          end
+        end
+
+      end
+
     end
 
   end
@@ -207,6 +245,26 @@ describe Stackup::Stack do
       end
     end
 
+    describe "#tags" do
+
+      let(:tags) do
+        [
+          { :key => "foo", :value => "bar" }
+        ]
+      end
+
+      let(:describe_stacks_responses) do
+        [
+          stack_description(stack_status, :tags => tags)
+        ]
+      end
+
+      it "returns tags as a Hash" do
+        expect(stack.tags).to eq("foo" => "bar")
+      end
+
+    end
+
     describe "#delete" do
 
       context "if successful" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stackup
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Mike Williams
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-19 00:00:00.000000000 Z
+date: 2016-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-resources
@@ -99,18 +99,22 @@ files:
 - README.md
 - Rakefile
 - bin/stackup
-- examples/parameters.json
-- examples/parameters.yml
+- examples/Rakefile
+- examples/parameters-terse.yml
+- examples/parameters-verbose.json
 - examples/template.json
 - lib/stackup.rb
+- lib/stackup/differ.rb
 - lib/stackup/error_handling.rb
 - lib/stackup/errors.rb
+- lib/stackup/parameters.rb
 - lib/stackup/rake_tasks.rb
 - lib/stackup/service.rb
 - lib/stackup/stack.rb
 - lib/stackup/stack_watcher.rb
 - lib/stackup/version.rb
 - spec/spec_helper.rb
+- spec/stackup/parameters_spec.rb
 - spec/stackup/stack_spec.rb
 - spec/stackup/stack_watcher_spec.rb
 - stackup.gemspec
@@ -134,11 +138,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.1
 signing_key: 
 specification_version: 4
 summary: Manage CloudFormation stacks
 test_files:
 - spec/spec_helper.rb
+- spec/stackup/parameters_spec.rb
 - spec/stackup/stack_spec.rb
 - spec/stackup/stack_watcher_spec.rb