ky 0.4.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b1de2efb87f781886061141962646b113a33da52
-  data.tar.gz: c51ee92b728200441a515f09953a2a25ac71d494
+  metadata.gz: a3e2cbbf671a3e7fd09fb7eac2e4b209cc2eccc5
+  data.tar.gz: aea2bbb6db0bde006fea255fdbbcc53bb502b79f
 SHA512:
-  metadata.gz: 435791205d319456386a1b81774768ef80618225a15a55edca06839cdd1905bf4ad91cc0ee8e654ef5ed6d8a4bd032d95b4c878b103e4213aa96280325479064
-  data.tar.gz: 5b41cec9ba39bbf3b67cc5e7bfd102d5dfebc45992550031032500d164270fd8bf8053dbf7ee18576e1affab37c07c590f55dd4748a1bb4069714ed6f708af7b
+  metadata.gz: a486fa1c392976cd44a83a5498728fb60f6ebd222432725537bc2b82609a6f035956a6a24fd1feaa583ed715168fa9af38a3b7e10787019eb409c22afb93f5dc
+  data.tar.gz: 0def538f73dcbbe5a574363911feff3b94e58f92646b8370074b375bdcfb3288b66424ca67f64eb87279934e7c7bd0356e121d927dce37db3d5cf77d236357ff

data/ky.gemspec

@@ -17,6 +17,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rspec', '~> 3.5'
   s.add_development_dependency 'pry', '~> 0.10'
   s.add_runtime_dependency 'thor', '~> 0.19'
+  s.add_runtime_dependency 'activesupport', '>= 3.0'
   s.add_runtime_dependency 'deep_merge', '~> 1.1'
 
   s.description = <<-DESC

data/lib/ky/cli.rb

@@ -1,40 +1,40 @@
 require_relative '../ky'
 require 'thor'
-class KY
+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|
-        KY.new.encode(output_object, input_object)
+        Manipulation.encode(output_object, input_object)
       end
     end
 
     desc "decode secrets.yml", "decoded yaml version of secrets.yml with base64 encoded data attributes"
     def decode(input_source=$stdin, output_source=$stdout)
       input_output(input_source, output_source) do |input_object, output_object|
-        KY.new.decode(output_object, input_object)
+        Manipulation.decode(output_object, input_object)
       end
     end
 
     desc "merge base.yml env.yml", "deep merged/combined yaml of two seperate files"
     def merge(input_source1, input_source2=$stdin, output_source=$stdout)
       input_output(input_source1, output_source) do |input_object1, output_object|
-        with(input_source2, 'r') {|input_object2| KY.new.merge(output_object, input_object1, input_object2) }
+        with(input_source2, 'r') {|input_object2| Manipulation.merge(output_object, input_object1, input_object2) }
       end
     end
 
     desc "env config.yml secrets.yml", "generate env variables section of a deployment from a config and a secrets file"
     def env(input_source1, input_source2=$stdin, output_source=$stdout)
       input_output(input_source1, output_source) do |input_object1, output_object|
-        with(input_source2, 'r') {|input_object2| KY.new.env(output_object, input_object1, input_object2) }
+        with(input_source2, 'r') {|input_object2| EnvGeneration.env(output_object, input_object1, input_object2) }
       end
     end
 
-    desc "compile Procfile config.yml secrets.yml output", <<-DOC.strip_heredoc
-    Generate kubernetes deployment.yml from Procfile;
+    desc "compile (config.yml secrets.yml output)", <<-DOC.strip_heredoc
+    Generate kubernetes deployment.yml from Procfile and env files;
     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
+    Procfile path may be specified in configuration as procfile_path or via flag.
     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
@@ -42,15 +42,15 @@ class KY
     method_option :namespace, type: :string, aliases: "-n"
     method_option :environment, type: :string, aliases: "-e"
     method_option :image_tag, type: :string, aliases: "-t"
-    def compile(procfile_path=nil, config_or_secrets_path=nil, secrets_or_config_path=nil, output_dir=nil)
-      instance = KY.new(options.with_indifferent_access)
-      procfile_path ||= instance.configuration['procfile_path']
+    method_option :procfile_path, type: :string, aliases: "-p"
+    def compile(config_or_secrets_path=nil, secrets_or_config_path=nil, output_dir=nil)
+      instance = Compilation.new(options.with_indifferent_access)
       config_or_secrets_path  ||= instance.configuration['config_path'] || instance.configuration['secret_path']
       secrets_or_config_path  ||= instance.configuration['secret_path'] || instance.configuration['config_path']
       output_dir ||= instance.configuration['output_dir']
-      raise MissingParametersError unless procfile_path && config_or_secrets_path && secrets_or_config_path && output_dir
+      raise MissingParametersError unless config_or_secrets_path && secrets_or_config_path && output_dir && instance.configuration['procfile_path']
       input_input(config_or_secrets_path, secrets_or_config_path) do |input1, input2|
-        instance.compile(procfile_path, input1, input2, output_dir)
+        instance.compile(input1, input2, output_dir)
       end
     end
 

data/lib/ky/compilation.rb

@@ -0,0 +1,20 @@
+module KY
+  class Compilation
+    attr_reader :configuration
+
+    def initialize(opts={})
+      @configuration = Configuration.new(opts)
+    end
+
+    def compile(env1path, env2path, base_output_dir)
+      full_output_dir = Pathname.new(base_output_dir).join(configuration[:environment].to_s).to_s
+      FileUtils.mkdir_p(full_output_dir)
+      env_obj = EnvGeneration.new(env1path, env2path, configuration)
+      deploys_hash = DeployGeneration.new(full_output_dir, env_obj.project, configuration).to_h
+      deploys_hash.each do |file_path, deploy_hash|
+        File.write(file_path, Manipulation.merge_hash(deploy_hash, env_obj.to_h).to_plain_yaml)
+      end
+      Manipulation.write_configs_encode_if_needed(env_obj.config_hsh, env_obj.secret_hsh, full_output_dir, configuration[:project_name])
+    end
+  end
+end

data/lib/ky/configuration.rb

@@ -0,0 +1,51 @@
+module KY
+  class Configuration
+    AmbiguousEnvironmentFile = Class.new(StandardError)
+    attr_reader :configuration, :opts
+
+    def initialize(opts={})
+      @opts = opts
+      @configuration = build_configuration
+    end
+
+    def [](key)
+      configuration[key]
+    end
+
+    def keys
+      configuration.keys
+    end
+
+    def build_configuration
+      config = if config_file_location
+        YAML.load(File.read(config_file_location)).with_indifferent_access
+      else
+        DEFAULT_CONFIG
+      end
+      config.merge(current_environment_hash(config))
+    end
+
+    def current_environment_hash(partial_config)
+      current_config = partial_config || configuration
+      current_environment = opts[:environment] || current_config[:environment]
+      env_file_paths = environment_files(current_config).select {|file| file.match(current_environment) if current_environment }
+      if env_file_paths.count <= 1 # workaround for current possible env/path ambiguity
+        env_file_path = env_file_paths.first
+      else
+        raise AmbiguousEnvironmentFile.new("More than one file path matched the environment")
+      end
+      hsh = env_file_path ?  YAML.load(File.read(env_file_path)).with_indifferent_access : {}
+      (hsh[:configuration] ? hsh[:configuration].merge(opts) : hsh.merge(opts)).with_indifferent_access
+    end
+
+    def environment_files(partial_config)
+      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
+
+  end
+end

data/lib/ky/deploy_generation.rb

@@ -1,14 +1,13 @@
-class KY
+module KY
   class DeployGeneration
-    def initialize(instance, proc_path, full_output_dir, project_name=nil, current_namespace=nil)
-      @instance = instance
-      @proc_commands = File.read(proc_path).split("\n")
+    def initialize(full_output_dir, project_name, configuration=Configuration.new)
+      @configuration = configuration
+      @proc_commands = File.read(configuration[:procfile_path]).split("\n")
                             .map {|line| line.split(':', 2) }
                             .map {|k, v| [k, ["/bin/bash","-c", v]] }
                             .to_h
       @full_output_dir = full_output_dir
-      @project_name = project_name || instance.configuration[:project_name]
-      @current_namespace = current_namespace || instance.configuration[:namespace]
+      @project_name = project_name || configuration[:project_name]
       @deployment_yaml = read_deployment_yaml
     end
 
@@ -25,11 +24,11 @@ class KY
     end
 
     private
-    attr_reader :proc_commands, :full_output_dir, :project_name, :current_namespace, :deployment_yaml, :instance
+    attr_reader :proc_commands, :full_output_dir, :project_name, :deployment_yaml, :configuration
 
     def read_deployment_yaml
-      if instance.configuration['deployment']
-        File.read(instance.configuration['deployment'])
+      if configuration['deployment']
+        File.read(configuration['deployment'])
       else
         File.read(default_deployment_template)
       end
@@ -40,14 +39,19 @@ class KY
     end
 
     def template_hash(id, command_array)
-      app_name =  instance.configuration['app_name'] || "#{project_name}-#{id}"
-      template_context = Template.context(app_name: app_name, id: id, command_array: command_array)
+      app_name =  configuration['app_name'] || "#{project_name}-#{id}"
+      template_context = Template.new(configuration).context(app_name: app_name, id: id, command_array: command_array)
       tmp = Manipulation.merge_hash(
         YAML.load(
           ERB.new(deployment_yaml).result(template_context)
         ),
-        instance.deploy_merge(id)
+        deploy_merge(id)
       )
     end
+
+    def deploy_merge(id)
+      return {} unless configuration[:merge]
+      configuration[:merge][id].to_h
+    end
   end
 end

data/lib/ky/env_generation.rb

@@ -1,7 +1,7 @@
 require 'active_support'
 require 'active_support/core_ext'
 require 'securerandom'
-class KY
+module KY
   class EnvGeneration
     ConflictingProjectError = Class.new(StandardError)
 
@@ -10,14 +10,24 @@ class KY
       define_method(raw_string.underscore) { raw_string }
     end
 
-    def self.generate_env(instance, input1, input2)
-      new(instance, input1, input2).to_h
+    def self.env(output, input1, input2)
+      output << generate_env(input1, input2).to_plain_yaml
+    rescue ConflictingProjectError => e
+      $stderr << "Error processing yml files, please provide a config and a secrets file from the same kubernetes project/name"
+      exit(1)
     end
 
-    attr_reader :config_hsh, :secret_hsh, :instance
-    def initialize(instance, input1, input2)
-      input_hashes = YAML.load(input1.read), YAML.load(input2.read)
-      @instance = instance
+    def self.generate_env(input1, input2)
+      new(input1, input2).to_h
+    end
+
+    attr_reader :config_hsh, :secret_hsh, :configuration
+    def initialize(input1, input2, configuration = Configuration.new)
+      input_hashes = YAML.load(input1.read).with_indifferent_access, YAML.load(input2.read).with_indifferent_access
+      @configuration = configuration
+      input_hashes.each do |env_hsh|
+        env_hsh[:metadata][:namespace] = configuration[:namespace]
+      end
       @config_hsh = input_hashes.find {|h| h[kind] == config_map }
       @secret_hsh = input_hashes.find {|h| h[kind] == secret }
       raise ConflictingProjectError.new("Config and Secret metadata names do not agree") unless secret_hsh[metadata][name] == project
@@ -34,7 +44,7 @@ class KY
     private
 
     def force_config
-      return [] unless instance.configuration[:force_configmap_apply]
+      return [] unless configuration[:force_configmap_apply]
       [inline_env_map(config_map_key_ref, "force-configmap-apply", SecureRandom.hex)]
     end
 
@@ -47,12 +57,12 @@ class KY
     end
 
     def inline_config?
-      instance.configuration[:inline_config]
+      configuration[:inline_config]
     end
 
 
     def inline_secret?
-      instance.configuration[:inline_secret]
+      configuration[:inline_secret]
     end
 
     def inline_env_map(type, kebab_version, env_value)

data/lib/ky/manipulation.rb

@@ -1,10 +1,23 @@
 require 'deep_merge/rails_compat'
-class KY
+module KY
   module Manipulation
     DEFAULT_DATA_KEY = 'data'
     MAGIC_DELIMITER = '@'
     BASE_64_DETECTION_REGEX = /^([A-Za-z0-9+]{4})*([A-Za-z0-9+]{4}|[A-Za-z0-9+]{3}=|[A-Za-z0-9+]{2}==)$/
     class << self
+
+      def decode(output, input)
+        output << code_yaml(input, :decode)
+      end
+
+      def encode(output, input)
+        output << code_yaml(input, :encode)
+      end
+
+      def merge(output, input1, input2)
+        output << merge_yaml(input1, input2)
+      end
+
       def merge_yaml(input1, input2)
         combined = {}
         YAML.load(input1.read).tap { |hsh|

data/lib/ky/template.rb

@@ -1,19 +1,17 @@
-class KY
+module KY
   class Template
-    def self.context(hsh)
-      new(hsh).context
-    end
 
-    attr_reader :context_hash
-    def initialize(hsh)
-      @context_hash = hsh
+    def initialize(configuration)
+      define_methods_from_config(configuration)
     end
 
-    def environment
-      KY.environment
+    def define_methods_from_config(config)
+      config.keys.each do |key|
+        define_singleton_method(key) { config[key] }
+      end
     end
 
-    def context
+    def context(context_hash)
       template_context = binding
       context_hash.each do |var, value|
         template_context.local_variable_set(var, value)

data/lib/ky/version.rb

@@ -1,3 +1,3 @@
-class KY
-  VERSION = "0.4.0"
+module KY
+  VERSION = "0.4.2"
 end

data/lib/ky.rb

@@ -3,6 +3,8 @@ require 'base64'
 require 'open-uri'
 require 'fileutils'
 require 'pathname'
+require_relative 'ky/configuration'
+require_relative 'ky/compilation'
 require_relative 'ky/manipulation'
 require_relative 'ky/env_generation'
 require_relative 'ky/template'
@@ -10,7 +12,7 @@ require_relative 'ky/deploy_generation'
 require_relative 'ky/hash'
 
 
-class KY
+module KY
   CONFIG_FILE_NAMES = [".ky.yml", ".ky.yaml", "Lubefile"]
   CONFIG_LOCATIONS = ["#{Dir.pwd}/", "#{Dir.home}/"]
   DEFAULT_CONFIG = {
@@ -27,79 +29,4 @@ class KY
     force_configmap_apply: false
   }.with_indifferent_access
 
-  attr_reader :opts, :configuration
-
-  def initialize(opts={})
-    @opts=opts
-    @configuration = build_configuration
-    define_methods_from_config(configuration)
-  end
-
-  def decode(output, input)
-    output << Manipulation.code_yaml(input, :decode)
-  end
-
-  def encode(output, input)
-    output << Manipulation.code_yaml(input, :encode)
-  end
-
-  def merge(output, input1, input2)
-    output << Manipulation.merge_yaml(input1, input2)
-  end
-
-  def env(output, input1, input2)
-    output << EnvGeneration.generate_env(self, input1, input2).to_plain_yaml
-  rescue KY::EnvGeneration::ConflictingProjectError => e
-    $stderr << "Error processing yml files, please provide a config and a secrets file from the same kubernetes project/name"
-    exit(1)
-  end
-
-  def compile(proc_path, env1path, env2path, base_output_dir)
-    full_output_dir = Pathname.new(base_output_dir).join(configuration[:environment].to_s).to_s
-    FileUtils.mkdir_p(full_output_dir)
-    env_obj = EnvGeneration.new(self, env1path, env2path)
-    deploys_hash = DeployGeneration.new(self, proc_path, full_output_dir, env_obj.project, configuration[:namespace]).to_h
-    deploys_hash.each do |file_path, deploy_hash|
-      File.write(file_path, Manipulation.merge_hash(deploy_hash, env_obj.to_h).to_plain_yaml)
-    end
-    Manipulation.write_configs_encode_if_needed(env_obj.config_hsh, env_obj.secret_hsh, full_output_dir, configuration[:project_name])
-  end
-
-  def build_configuration
-    config = if config_file_location
-      YAML.load(File.read(config_file_location))
-    else
-      DEFAULT_CONFIG
-    end.with_indifferent_access
-    config.merge!(current_environment_hash(config))
-    config
-  end
-
-  def deploy_merge(id)
-    return {} unless configuration[:merge]
-    configuration[:merge][id].to_h
-  end
-
-  def current_environment_hash(partial_config)
-    current_config = partial_config || configuration
-    env_file_path = environment_files(current_config).find {|file| file.match(opts[:environment] || current_config[:environment]) } if opts[:environment] || current_config[:environment] # ugh, this find is accident waiting to happen, REFACTOR/RETHINK!
-    hsh = env_file_path ?  YAML.load(File.read(env_file_path)).with_indifferent_access : {}
-    (hsh[:configuration] ? hsh[:configuration].merge(opts) : hsh.merge(opts)).with_indifferent_access
-  end
-
-  def environment_files(partial_config)
-    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/spec/ky_bin_spec.rb

@@ -64,11 +64,14 @@ describe "ky cli" do
   describe "primary cli command generates and" do
     let(:instance) { KY.new }
     let(:fake_tag) { 'fake_tag' }
+    let(:fake_namespace) { 'fake_namespace' }
     let(:tmpdir) { 'spec/support/tmpdir' }
     after { `rm -r #{tmpdir}` }
     describe "compiles Procfile and env secrets/configs into entire deployments" do
       it "to directory" do
-        KY::Cli.new.compile('spec/support/Procfile', 'spec/support/config.yml', 'spec/support/decoded.yml', tmpdir)
+        instance = KY::Cli.new
+        instance.options = {procfile_path: 'spec/support/Procfile'}
+        instance.compile('spec/support/config.yml', 'spec/support/decoded.yml', tmpdir)
         expect(File.exists?("#{tmpdir}/web.deployment.yml")).to be true
         expect(File.exists?("#{tmpdir}/worker.deployment.yml")).to be true
         expect(File.exists?("#{tmpdir}/jobs.deployment.yml")).to be true
@@ -78,7 +81,8 @@ describe "ky cli" do
     describe "encodes secrets.yml when compiling from Procfile without image_tag" do
       it "to directory" do
         instance = KY::Cli.new
-        instance.compile('spec/support/Procfile', 'spec/support/config.yml', 'spec/support/decoded.yml', tmpdir)
+        instance.options = {procfile_path: 'spec/support/Procfile'}
+        instance.compile('spec/support/config.yml', 'spec/support/decoded.yml', tmpdir)
         expect(File.exists?("#{tmpdir}/global.secret.yml")).to be true
         YAML.load(File.read("#{tmpdir}/global.secret.yml"))['data'].each do |_k, v|
           expect(v).to match(KY::Manipulation::BASE_64_DETECTION_REGEX)
@@ -89,8 +93,8 @@ describe "ky cli" do
     describe "encodes secrets.yml when compiling from Procfile with image_tag" do
       it "to directory" do
         instance = KY::Cli.new
-        instance.options = {image_tag: fake_tag}
-        instance.compile('spec/support/Procfile', 'spec/support/config.yml', 'spec/support/decoded.yml', tmpdir)
+        instance.options = {image_tag: fake_tag, procfile_path: 'spec/support/Procfile'}
+        instance.compile('spec/support/config.yml', 'spec/support/decoded.yml', tmpdir)
         expect(File.exists?("#{tmpdir}/global.secret.yml")).to be true
         YAML.load(File.read("#{tmpdir}/global.secret.yml"))['data'].each do |_k, v|
           expect(v).to match(KY::Manipulation::BASE_64_DETECTION_REGEX)
@@ -101,8 +105,8 @@ describe "ky cli" do
     describe "uses image_tag when passed in as option" do
       it "to directory" do
         instance = KY::Cli.new
-        instance.options = {image_tag: fake_tag}
-        instance.compile('spec/support/Procfile', 'spec/support/config.yml', 'spec/support/decoded.yml', tmpdir)
+        instance.options = {image_tag: fake_tag, procfile_path: 'spec/support/Procfile'}
+        instance.compile('spec/support/config.yml', 'spec/support/decoded.yml', tmpdir)
         expect(File.exists?("#{tmpdir}/web.deployment.yml")).to be true
         expect(File.read("#{tmpdir}/web.deployment.yml")).to match(fake_tag)
       end
@@ -111,10 +115,10 @@ describe "ky cli" do
     describe "uses namespace when passed in as option" do
       it "to directory" do
         instance = KY::Cli.new
-        instance.options = {namespace: fake_tag}
-        instance.compile('spec/support/Procfile', 'spec/support/config.yml', 'spec/support/decoded.yml', tmpdir)
+        instance.options = {namespace: fake_namespace, procfile_path: 'spec/support/Procfile'}
+        instance.compile('spec/support/config.yml', 'spec/support/decoded.yml', tmpdir)
         expect(File.exists?("#{tmpdir}/web.deployment.yml")).to be true
-        expect(File.read("#{tmpdir}/web.deployment.yml")).to match(fake_tag)
+        expect(File.read("#{tmpdir}/web.deployment.yml")).to match(fake_namespace)
       end
     end
 
@@ -123,7 +127,8 @@ describe "ky cli" do
       after { `rm Lubefile` }
       it "to directory" do
         instance = KY::Cli.new
-        instance.compile('spec/support/Procfile', 'spec/support/config.yml', 'spec/support/decoded.yml', tmpdir)
+        instance.options = {procfile_path: 'spec/support/Procfile'}
+        instance.compile('spec/support/config.yml', 'spec/support/decoded.yml', tmpdir)
         expect(File.exists?("#{tmpdir}/web.deployment.yml")).to be true
         expect(File.exists?("#{tmpdir}/jobs.deployment.yml")).to be true
         expect(File.read("#{tmpdir}/web.deployment.yml")).to match('port')
@@ -136,7 +141,7 @@ describe "ky cli" do
       after { `rm Lubefile` }
       it "to directory" do
         instance = KY::Cli.new
-        instance.compile('spec/support/Procfile', 'spec/support/config.yml', 'spec/support/decoded.yml', tmpdir)
+        instance.compile('spec/support/config.yml', 'spec/support/decoded.yml', tmpdir)
         expect(File.exists?("#{tmpdir}/web.deployment.yml")).to be true
         expect(File.read("#{tmpdir}/web.deployment.yml")).not_to match('HashWithIndifferentAccess')
       end
@@ -147,13 +152,33 @@ describe "ky cli" do
       after { `rm Lubefile` }
       it "to directory" do
         instance = KY::Cli.new
-        instance.options = {force_configmap_apply: true}
-        instance.compile('spec/support/Procfile', 'spec/support/config.yml', 'spec/support/decoded.yml', tmpdir)
+        instance.options = {procfile_path: 'spec/support/Procfile', force_configmap_apply: true}
+        instance.compile('spec/support/config.yml', 'spec/support/decoded.yml', tmpdir)
         expect(File.exists?("#{tmpdir}/web.deployment.yml")).to be true
         expect(File.read("#{tmpdir}/web.deployment.yml")).to match('FORCE_CONFIGMAP_APPLY')
       end
     end
 
+    describe "applies namespace to generated" do
+
+      before do
+        instance = KY::Cli.new
+        instance.options = {namespace: fake_namespace, procfile_path: 'spec/support/Procfile'}
+        instance.compile('spec/support/config.yml', 'spec/support/decoded.yml', tmpdir)
+      end
+
+      it "configmaps" do
+        expect(File.exists?("#{tmpdir}/global.configmap.yml")).to be true
+        expect(YAML.load(File.read("#{tmpdir}/global.configmap.yml"))['metadata']['namespace']).to match(fake_namespace)
+      end
+
+      it "deployments" do
+        expect(File.exists?("#{tmpdir}/web.deployment.yml")).to be true
+        expect(YAML.load(File.read("#{tmpdir}/web.deployment.yml"))['metadata']['namespace']).to match(fake_namespace)
+      end
+
+    end
+
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ky
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
 platform: ruby
 authors:
 - Brian Glusman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-28 00:00:00.000000000 Z
+date: 2016-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.19'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: deep_merge
   requirement: !ruby/object:Gem::Requirement
@@ -88,6 +102,8 @@ files:
 - ky.gemspec
 - lib/ky.rb
 - lib/ky/cli.rb
+- lib/ky/compilation.rb
+- lib/ky/configuration.rb
 - lib/ky/deploy_generation.rb
 - lib/ky/env_generation.rb
 - lib/ky/hash.rb