ky 0.2.0 → 0.3.0beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 88f4ea27998f9a2958de3c9e2bdf989de7d99110
-  data.tar.gz: 2fd156270734c5064cd94d47e4f79d8a734e8658
+  metadata.gz: eff2da2223846540c4f8bb47a3bb59684215b698
+  data.tar.gz: 793e1b97792108e5feada8ec4969cec526a73875
 SHA512:
-  metadata.gz: fb7b698da20ddb79a6aba30ee1e4fdba2983cd319bd08dae0325cbacabf4c60c50cfed7aafe5f074a80f3bd1af3d880755d6851eb30821c89adaa6bbaf9abf0e
-  data.tar.gz: 5da3f95409421d0f5b3974283a8cb6187b9174cf043e35268ce979878b942dd2565218fea461d8f43855c982fae8af7bd3f4a3316c69515f644b2a4932588c21
+  metadata.gz: 1e02009691a0503ff6d92af8799577792fd9fac9205cfb3c2f7fd9ca88b58c0d2ca38547c95689ee1c646f900488008e534181b1ddf176368fcc337c8a2fe460
+  data.tar.gz: 21727d8f5bbec27b5278b7db6837c508517784c37d33d5300956d85912a53b5318656c150060a122fd2529621f5c8234afae791860139da494a54e81e8283924

data/README.md

@@ -4,8 +4,26 @@
 
 The primary purpose is to automate/DRY up duplication and agreement between multiple deployment YAML files and config/secret yaml files that we saw emerging as we built our kubernetes configuration.
 
-The full/hopeful use of the tool may be enabled with the new `compile` command which is very much a rough draft at present, but which takes a crack at generating a complete deployment yaml file for every line of a Procfile such as used for Heroku, and a pair of config and secrets files.  The secret file can be non-base64 encoded, and compile will generate deployments and a base64 encoded secrets file to a target directory specified.  This command uses all the below commands in combination, plus the undocumented `from_proc` command.  The command is invoked as:
-`ky compile Procfile.file config.yml secrets.yml output_dir` and the output directory will be created if necessary.  You may pass a namespace to compile which will be reflected in the deployments (and should agree with the config and secrets, though it's not checking they agree at present).
+The full/hopeful use of the tool may be enabled with the new `compile` command which is very much a rough draft at present, but which takes a crack at generating a complete deployment yaml file for every line of a Procfile such as used for Heroku, and a pair of config and secrets files.  The secret file can be non-base64 encoded, and compile will generate deployments and a base64 encoded secrets file to a target directory specified.  This command uses all the below commands in combination, one other command not exposed via CLI independently.
+
+The command is invoked as:
+`ky compile Procfile.file config.yml secrets.yml output_dir` and the output directory will be created if necessary.  You may pass a namespace to compile which will be reflected in the deployments (and should agree with the config and secrets, though it's not checking they agree at present).  The arguments are all configurable via the configuration file as well, so it can in practice be invoked as `ky compile` or `kky compile --envioronment stg` if you have a configuration file correctly present as described below.
+
+Configuration begins with a config file in the project working directory, or in your home directory if you wish to share across several projects.  Unfortunately there are several competing conventions for configuration files, the traditional dot-file configuration convention and newer, more visible Capitalfile configuration.  KY is a lubricant, and has no opinion, and therefore currently supports naming your configuration file `.ky.yml`, `.ky.yaml`, or `Lubefile` or `Kyfile`.  The default configuration, if this file is not found, is as follows:
+```
+  environments: []
+  replica_count: 1
+  image_pull_policy: "Always"
+  namespace: "default"
+  image: "<YOUR_DOCKER_IMAGE>"
+  image_tag: latest
+  api_version: "extensions/v1beta1"
+  inline_config: true
+  inline_secret: false
+  project_name: "global"
+```
+
+Override any or all of these in your file, and the environments files will also prompt KY to look for files named `development.yml` or `development.yaml` in the same directory as the config file itself, if you override environments as `[development]`, or whatever/however many environments as you name. When running a specific environment, configuration from the specific environment will override your global defaults.
 
 The less automated workflow for the tool might start with generating a yaml file of env mappings from a secrets.yml file and a config.yml file, like so:
 ###Example usage
@@ -90,7 +108,7 @@ spec:
     spec:
       containers:
         - name: web
-          image: docker/image
+          image: docker_image
           imagePullPolicy: Always
           ports:
             - containerPort: 3000
@@ -118,7 +136,7 @@ spec:
     spec:
       containers:
       - name: web
-        image: docker/image
+        image: docker_image
         imagePullPolicy: Always
         ports:
         - containerPort: 3000
@@ -185,4 +203,4 @@ $ cat file.yml | obscure decode # reads non-base64 input yaml from stdin, writes
 $ cat file.yml | obscure encode # reads base64 encoded input yaml from stdin, write encoded to stdout
 ```
 
-A valid url may also be used in place of a file path for input.
+A valid url may also be used in place of a file path for input.

data/examples/.ky.yml

@@ -0,0 +1,15 @@
+environments: [dev, stg, prd]
+deployment: examples/deployment_base.yml
+replica_count: 2
+image_pull_policy: "IfNotPresent"
+namespace: "default"
+image: "organization/project"
+image_tag: "latest"
+api_version: "extensions/v1beta1"
+inline_config: true
+inline_secret: false
+project_name: "connect"
+config_path: "spec/support/config.yml"
+secret_path: "spec/support/decoded.yml"
+output_dir: "namespaces"
+procfile_path: "spec/support/Procfile"

data/examples/deployment_base.yml

@@ -0,0 +1,17 @@
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: <%= id %>
+spec:
+  replicas: <%= replica_count %>
+  template:
+    metadata:
+      labels:
+        app: example-<%= id %>
+    spec:
+      containers:
+        - name: <%= id %>
+          image: organization/project:<%= image_tag %>
+          imagePullPolicy: Always
+          command: <%= command_array.to_s %>
+

data/examples/dev.deployment.yml

@@ -0,0 +1,23 @@
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: <%= id %>
+spec:
+  replicas: <%= replica_count %>
+  template:
+    metadata:
+      labels:
+        app: example-<%= id %>
+    spec:
+      volumes:
+        - name: code
+          persistentVolumeClaim:
+            claimName: code-claim
+      containers:
+        - name: web
+          image: project_dev:latest
+          imagePullPolicy: Always
+          command: <%= command_array.to_s %>
+          volumeMounts:
+            - mountPath: /code
+              name: code

data/examples/dev.yml

@@ -0,0 +1,4 @@
+configuration:
+  replica_count: 1
+  inline_secret: true
+  deployment: dev.deployment.yml

data/ky.gemspec

@@ -16,12 +16,11 @@ Gem::Specification.new do |s|
   s.require_paths = ['lib']
   s.add_development_dependency 'rspec', '~> 3.5'
   s.add_development_dependency 'pry', '~> 0.10'
-  s.add_runtime_dependency 'deep_merge', '~> 1.1'
   s.add_runtime_dependency 'thor', '~> 0.19'
-  s.add_runtime_dependency 'activesupport', ">= 3.0", "< 6"
+  s.add_runtime_dependency 'deep_merge', '~> 1.1'
 
   s.description = <<-DESC
-    Utility belt for managing, manipulating and lubricating kubernetes deployment, config and secrets yml files
+    Utility belt for generating kubernetes deployment, config and secrets yml files
   DESC
 
   s.files         = `git ls-files`.split("\n")

data/lib/ky.rb

@@ -2,13 +2,31 @@ require 'yaml'
 require 'base64'
 require 'open-uri'
 require 'fileutils'
+require 'pathname'
 require_relative 'ky/manipulation'
 require_relative 'ky/env_generation'
+require_relative 'ky/template'
 require_relative 'ky/deploy_generation'
 
 
 module KY
+  CONFIG_FILE_NAMES = [".ky.yml", ".ky.yaml", "Lubefile", "Kyfile"]
+  CONFIG_LOCATIONS = ["#{Dir.pwd}/", "#{Dir.home}/"]
+  DEFAULT_CONFIG = {
+    environments: [],
+    replica_count: 1,
+    image_pull_policy: "Always",
+    namespace: "default",
+    image: "<YOUR_DOCKER_IMAGE>",
+    image_tag: "latest",
+    api_version: "extensions/v1beta1",
+    inline_config: true,
+    inline_secret: false,
+    project_name: "global"
+  }
+
   module_function
+  cattr_accessor :environment
 
   def decode(output, input)
     output << Manipulation.code_yaml(input, :decode)
@@ -29,20 +47,47 @@ module KY
     exit(1)
   end
 
-  def from_proc(proc_path, output_dir)
-    FileUtils.mkdir_p(output_dir)
-    DeployGeneration.new(proc_path, output_dir).call
-  end
-
-  def compile(proc_path, env1path, env2path, output_dir, namespace=DeployGeneration::DEFAULT_NAMESPACE)
-    FileUtils.mkdir_p(output_dir)
+  def compile(proc_path, env1path, env2path, base_output_dir, namespace=DeployGeneration::DEFAULT_NAMESPACE)
+    full_output_dir = Pathname.new(base_output_dir).join(environment.to_s).to_s
+    FileUtils.mkdir_p(full_output_dir)
     env_obj = EnvGeneration.new(env1path, env2path)
-    deploys_hash = DeployGeneration.new(proc_path, output_dir, env_obj.project, namespace).to_h
+    deploys_hash = DeployGeneration.new(proc_path, full_output_dir, env_obj.project, namespace).to_h
     deploys_hash.each do |file_path, deploy_hash|
-      File.write(file_path, deploy_hash.merge(env_obj.to_h).to_yaml)
+      File.write(file_path, Manipulation.merge_hash(deploy_hash, env_obj.to_h).to_yaml)
+    end
+    Manipulation.write_configs_encode_if_needed(env_obj.config_hsh, env_obj.secret_hsh, full_output_dir)
+  end
+
+  def configuration
+    @config ||= begin
+      config = DEFAULT_CONFIG.merge(config_file_location ? YAML.load(File.read(config_file_location)) : {})
+      config = config.merge(current_environment_hash(config)["configuration"] || {})
+      define_methods_from_config(config)
+      config
     end
-    Manipulation.write_configs_encode_if_needed(env_obj.config_hsh, env_obj.secret_hsh, output_dir)
   end
 
+  def current_deployment
+    current_environment_hash["deployment"]
+  end
+
+  def current_environment_hash(partial_config=nil)
+    YAML.load(File.read(KY.environment_files(partial_config).find {|file| file.match(KY.environment) })) rescue {}
+  end
+
+  def environment_files(partial_config=nil)
+    environments = (partial_config || configuration)['environments'].flat_map {|env| ["#{env}.yml", "#{env}.yaml"]}
+    (CONFIG_LOCATIONS * environments.count).zip(environments).map(&:join).select {|path| File.exist?(path) && !File.directory?(path) }
+  end
+
+  def config_file_location
+    (CONFIG_LOCATIONS * CONFIG_FILE_NAMES.count).zip(CONFIG_FILE_NAMES).map(&:join).find {|path| File.exist?(path) && !File.directory?(path) }
+  end
+
+  def define_methods_from_config(config)
+    config.keys.each do |key|
+      Template.send(:define_method, key) { config[key] }
+    end
+  end
 
 end

data/lib/ky/cli.rb

@@ -2,6 +2,7 @@ require_relative '../ky'
 require 'thor'
 module KY
   class Cli < Thor
+    MissingParametersError = Class.new(StandardError)
     desc "encode secrets.yml", "base64 encoded yaml version of data attributes in secrets.yml"
     def encode(input_source=$stdin, output_source=$stdout)
       input_output(input_source, output_source) do |input_object, output_object|
@@ -30,19 +31,40 @@ module KY
       end
     end
 
-    desc "from_proc Procfile.file output_dir", "generate kubernetes deployment base configs from Procfile to output_dir"
-    def from_proc(procfile_path, output_dir)
-      KY.from_proc(procfile_path, output_dir)
-    end
-
-    desc "compile Procfile.file config.yml secrets.yml output_dir", "generate kubernetes deployment configs from Procfile and env files to output_dir, encode secrets if unencoded"
+    desc "compile Procfile config.yml secrets.yml output", <<-DOC.strip_heredoc
+    Generate kubernetes deployment.yml from Procfile;
+    also generate/copy config/secrets files to output_dir, base64 encode secrets if unencoded.
+    Procfile path may also be specified in configuration as procfile_path
+    ConfigMap.yml file path may also be specified in configuration as config_path
+    secrets.yml file path may also be specified in configuration as secret_path
+    Output directory may also be specified in configuration as output_dir
+    DOC
     method_option :namespace, type: :string, aliases: "-n"
-    def compile(procfile_path, config_or_secrets_path, secrets_or_config_path, output_dir)
+    method_option :environment, type: :string, aliases: "-e"
+    def compile(procfile_path=nil, config_or_secrets_path=nil, secrets_or_config_path=nil, output_dir=nil)
+      KY.environment = options[:environment]
+      procfile_path ||= KY.configuration['procfile_path']
+      config_or_secrets_path  ||= KY.configuration['config_path'] || KY.configuration['secret_path']
+      secrets_or_config_path  ||= KY.configuration['secret_path'] || KY.configuration['config_path']
+      output_dir ||= KY.configuration['output_dir']
+      raise MissingParametersError unless procfile_path && config_or_secrets_path && secrets_or_config_path && output_dir
       input_input(config_or_secrets_path, secrets_or_config_path) do |input1, input2|
         KY.compile(procfile_path, input1, input2, output_dir, options[:namespace])
       end
     end
 
+    desc "example", "copy example configuration and environment override file to current directory"
+    def example
+      puts "Writing dev.yml environment example"
+      `cp #{__dir__}/../../examples/dev.yml .`
+      puts "Writing .ky.yml configuration example"
+      `cp #{__dir__}/../../examples/.ky.yml .`
+      puts "Writing deployment_base.yml template example"
+      `cp #{__dir__}/../../examples/deployment_base.yml .`
+      puts "Writing dev.deployment.yml template-override example"
+      `cp #{__dir__}/../../examples/dev.deployment.yml .`
+    end
+
     private
 
     def input_output(input1, output1)

data/lib/ky/deploy_generation.rb

@@ -1,27 +1,14 @@
 module KY
   class DeployGeneration
-    API_VERSION = "extensions/v1beta1"
-    IMAGE_TYPE  = "docker/image"
-    DEFAULT_PULL_POLICY = "Always"
-    DEFAULT_PROJECT_NAME = "global"
-    DEFAULT_NAMESPACE = "default"
-    DEFAULT_REPLICA_COUNT = 1
-
-    #string array meta-trick to avoid naked strings everywhere below, yaml doesn't to_s symbols as desired
-    %w(apiVersion Deployment imagePullPolicy namespace command
-       replicas template labels app kind containers image
-       data metadata name key valueFrom spec template containers env).each do |raw_string|
-      define_method(raw_string.underscore) { raw_string }
-    end
-
-    def initialize(proc_path, output_dir, project_name=DEFAULT_PROJECT_NAME, current_namespace=DEFAULT_NAMESPACE)
+    def initialize(proc_path, full_output_dir, project_name=nil, current_namespace=nil)
       @proc_commands = File.read(proc_path).split("\n")
                             .map {|line| line.split(':', 2) }
                             .map {|k, v| [k, ["/bin/bash","-c", v]] }
                             .to_h
-      @output_dir = output_dir
-      @project = project_name
-      @current_namespace = current_namespace
+      @full_output_dir = full_output_dir
+      @project_name = project_name || KY.configuration[:project_name]
+      @current_namespace = current_namespace || KY.configuration[:namespace]
+      @deployment_yaml = read_deployment_yaml
     end
 
     def call
@@ -32,47 +19,29 @@ module KY
 
     def to_h
       proc_commands.map do |id, command_array|
-        ["#{output_dir}/#{id}.yml", template_hash(id, command_array)]
+        ["#{full_output_dir}/#{id}.yml", template_hash(id, command_array)]
       end.to_h
     end
 
     private
-    attr_reader :proc_commands, :output_dir, :project, :current_namespace
+    attr_reader :proc_commands, :full_output_dir, :project_name, :current_namespace, :deployment_yaml
 
-    def template_hash(id, command_array)
-      {api_version => API_VERSION,
-       kind => deployment,
-       metadata =>{ name => id, namespace => current_namespace},
-       spec =>
-        {replicas => replica_count,
-         template =>
-          {
-            metadata => {
-              labels =>{ app =>"#{project}-#{id}"}
-             },
-           spec => {
-            containers =>
-              [
-                {
-                 name => id,
-                 image => IMAGE_TYPE,
-                 image_pull_policy => pull_policy,
-                 command => command_array
-                }
-              ]
-            }
-          }
-        }
-      }
+    def read_deployment_yaml
+      if KY.configuration['deployment']
+        File.read(KY.configuration['deployment'])
+      else
+        File.read(default_deployment_template)
+      end
     end
 
-    def replica_count
-      ENV['REPLICA_COUNT'] || DEFAULT_REPLICA_COUNT
+    def default_deployment_template
+      "#{__dir__}/../../templates/deployment.yml"
     end
 
-    def pull_policy
-      ENV['PULL_POLICY'] || DEFAULT_PULL_POLICY
+    def template_hash(id, command_array)
+      app_name =  KY.configuration['app_name'] || "#{project_name}-#{id}"
+      template_context = Template.context(app_name: app_name, id: id, command_array: command_array)
+      YAML.load(ERB.new(deployment_yaml).result(template_context))
     end
-
   end
 end

data/lib/ky/env_generation.rb

@@ -5,7 +5,7 @@ module KY
     ConflictingProjectError = Class.new(StandardError)
 
     #string array meta-trick to avoid naked strings everywhere below, yaml doesn't to_s symbols as desired
-    %w(ConfigMap configMapKeyRef Secret secretKeyRef kind data metadata name key valueFrom spec template containers env).each do |raw_string|
+    %w(ConfigMap configMapKeyRef Secret secretKeyRef kind data metadata name key valueFrom value spec template containers env).each do |raw_string|
       define_method(raw_string.underscore) { raw_string }
     end
 
@@ -22,7 +22,7 @@ module KY
     end
 
     def to_h
-      output_hash(config_hsh[data].map {|key, _| config_env(project, key) } + secret_hsh[data].map {|key, _| secret_env(project, key) })
+      output_hash(config_hsh[data].map {|key, value| config_env(key, value) } + secret_hsh[data].map {|key, value| secret_env(key, value) })
     end
 
     def project
@@ -32,15 +32,29 @@ module KY
     private
 
 
-    def config_env(project, kebab_version)
-      env_map(config_map_key_ref, project, kebab_version)
+    def config_env(kebab_version, value)
+      inline_config? ? inline_env_map(config_map_key_ref, kebab_version, value) : env_map(config_map_key_ref, kebab_version)
     end
 
-    def secret_env(project, kebab_version)
-      env_map(secret_key_ref, project, kebab_version)
+    def secret_env(kebab_version, value)
+      inline_secret? ? inline_env_map(secret_key_ref, kebab_version, value) : env_map(secret_key_ref, kebab_version)
     end
 
-    def env_map(type, project, kebab_version)
+    def inline_config?
+      KY.configuration[:inline_config]
+    end
+
+
+    def inline_secret?
+      KY.configuration[:inline_secret]
+    end
+
+    def inline_env_map(type, kebab_version, env_value)
+      puts "WARNING: #{kebab_version} format appears incorrect, format as #{kebab_version.dasherize.downcase}" unless kebab_version == kebab_version.dasherize.downcase
+      {name => kebab_version.underscore.upcase, value => env_value }
+    end
+
+    def env_map(type, kebab_version)
       puts "WARNING: #{kebab_version} format appears incorrect, format as #{kebab_version.dasherize.downcase}" unless kebab_version == kebab_version.dasherize.downcase
       {name => kebab_version.underscore.upcase, value_from => { type => {name => project, key => kebab_version }}}
     end

data/lib/ky/manipulation.rb

@@ -8,10 +8,14 @@ module KY
       def merge_yaml(input1, input2)
         combined = {}
         YAML.load(input1.read).tap { |hsh|
-          hsh.deeper_merge!(YAML.load(input2.read), merge_hash_arrays: true, extend_existing_arrays: true)
+          merge_hash(hsh, YAML.load(input2.read))
         }.to_yaml
       end
 
+      def merge_hash(hsh1, hsh2)
+        hsh1.deeper_merge!(hsh2, merge_hash_arrays: true, extend_existing_arrays: true)
+      end
+
       def code_yaml(yaml_source, direction)
         YAML.load(yaml_source.read).tap { |hsh|
           data = hsh[obscured_data_key]

data/lib/ky/template.rb

@@ -0,0 +1,22 @@
+class Template
+  def self.context(hsh)
+    new(hsh).context
+  end
+
+  attr_reader :context_hash
+  def initialize(hsh)
+    @context_hash = hsh
+  end
+
+  def environment
+    KY.environment
+  end
+
+  def context
+    template_context = binding
+    context_hash.each do |var, value|
+      template_context.local_variable_set(var, value)
+    end
+    template_context
+  end
+end

data/lib/ky/version.rb

@@ -1,3 +1,3 @@
 module KY
-  VERSION = "0.2.0"
+  VERSION = "0.3.0beta1"
 end

data/spec/ky_bin_spec.rb

@@ -1,6 +1,12 @@
 require 'ky/cli'
 describe "cli commands" do
   let(:tmpfile_path) { "spec/support/tmpfile.yml" }
+  before do # for backwards compatible with old non-inlining test/support behavior
+    normal_config = KY::DEFAULT_CONFIG
+    KY.define_methods_from_config(normal_config)
+    allow(KY).to receive(:configuration).and_return(normal_config.merge(inline_config: false))
+  end
+
   after { `rm #{tmpfile_path}` if File.exists?(tmpfile_path) }
   describe "works with stdout" do
     it "decodes" do
@@ -58,17 +64,6 @@ describe "cli commands" do
     end
   end
 
-  describe "parses Procfile into multiple deployment files" do
-    let(:tmpdir) { 'spec/support/tmpdir' }
-    it "to directory" do
-      KY::Cli.new.from_proc('spec/support/Procfile', tmpdir)
-      expect(File.exists?("#{tmpdir}/web.yml")).to be true
-      expect(File.exists?("#{tmpdir}/worker.yml")).to be true
-      expect(File.exists?("#{tmpdir}/jobs.yml")).to be true
-      `rm -r #{tmpdir}`
-    end
-  end
-
   describe "compiles Procfile and env secrets/configs into entire deployments" do
     let(:tmpdir) { 'spec/support/tmpdir' }
     it "to directory" do

data/spec/support/web-base.yml

@@ -12,7 +12,7 @@ spec:
     spec:
       containers:
         - name: web
-          image: docker/image
+          image: docker_image
           imagePullPolicy: Always
           ports:
             - containerPort: 3000

data/spec/support/web-merged.yml

@@ -13,7 +13,7 @@ spec:
     spec:
       containers:
       - name: web
-        image: docker/image
+        image: docker_image
         imagePullPolicy: Always
         ports:
         - containerPort: 3000

data/templates/deployment.yml

@@ -0,0 +1,17 @@
+apiVersion: <%= api_version %>
+kind: Deployment
+metadata:
+  name: <%= project_name %>
+  namespace: <%= namespace %>
+spec:
+  replicas: <%= replica_count %>
+  template:
+    metadata:
+      labels:
+        app: <%= app_name %>
+    spec:
+      containers:
+        - name: web
+          image: <%= image %>:<%= image_tag %>
+          imagePullPolicy: <%= image_pull_policy %>
+          command: <%= command_array.to_s %>

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ky
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0beta1
 platform: ruby
 authors:
 - Brian Glusman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-13 00:00:00.000000000 Z
+date: 2016-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -38,20 +38,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.10'
-- !ruby/object:Gem::Dependency
-  name: deep_merge
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -67,27 +53,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.19'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: deep_merge
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.0'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.0'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '6'
-description: "    Utility belt for managing, manipulating and lubricating kubernetes
-  deployment, config and secrets yml files\n"
+        version: '1.1'
+description: "    Utility belt for generating kubernetes deployment, config and secrets
+  yml files\n"
 email:
 - brian@stellaservice.com
 executables:
@@ -101,12 +81,17 @@ files:
 - LICENSE.txt
 - README.md
 - bin/ky
+- examples/.ky.yml
+- examples/deployment_base.yml
+- examples/dev.deployment.yml
+- examples/dev.yml
 - ky.gemspec
 - lib/ky.rb
 - lib/ky/cli.rb
 - lib/ky/deploy_generation.rb
 - lib/ky/env_generation.rb
 - lib/ky/manipulation.rb
+- lib/ky/template.rb
 - lib/ky/version.rb
 - spec/ky_bin_spec.rb
 - spec/spec_helper.rb
@@ -118,6 +103,7 @@ files:
 - spec/support/web-env.yml
 - spec/support/web-merged-original.yml
 - spec/support/web-merged.yml
+- templates/deployment.yml
 homepage: https://github.com/stellaservice/ky
 licenses:
 - MIT
@@ -133,9 +119,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: ky
 rubygems_version: 2.5.1