nexoform 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: be5988ba5a83aaf424f2d9f8b0164f738d87daca
+  data.tar.gz: ea0eb52b1ee24f85b886f66dd5d9c2fe073ee7e8
+SHA512:
+  metadata.gz: f51b9ec53e05106619663d190710fd741ee43f6fabf8daa45d45ab5c294c88b71231ce3d89bb00d3e8787c9e58b501520c83461e93098bf75b1bbca5fbbfdb7b
+  data.tar.gz: b4b7623970dd7dfc6db14e3f3dc2bad2b5808fbaba6bfc65f00a9dfb1a65eb996a1797b5ff3b9a81697181b9d285d746ddee876a9d05add42eb3019a1a4f07ed

data/bin/nexoform

@@ -0,0 +1,473 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'rainbow/refinement'
+using Rainbow
+
+require 'thor'
+require 'yaml'
+require 'json'
+require 'shellwords'
+
+require 'nexoform'
+
+# For some reason this method definition can't be inside the NexoformBin class
+# because Thor won't find it when generating description documention
+def default_plan_filename
+  'nexoform.tfplan'
+end
+
+class NexoformBin < Thor
+  class_option :environment, type: :string, aliases: 'e', required: false
+  class_option :assume_yes, type: :boolean, aliases: 'y', default: false
+
+  desc 'apply', 'Apply changes (Runs a terraform apply)'
+  long_desc <<-LONGDESC
+    Applies any applicable changes.  Under the hood, this
+    command runs a terraform apply.
+
+    If you pass --plan, the specified file will be used for the plan
+    If you pass --noplan, no plan file will be used
+    If you don't pass either, no plan file will be used unless the default
+    is present.  If it is, you'll be prompted about using it
+
+    > $ nexoform apply --environment 'dev' [--plan=#{default_plan_filename}]
+  LONGDESC
+  option :plan, type: :string, aliases: 'p', required: false
+  option :noplan, type: :boolean, aliases: 'n', default: false
+  option :overwrite, type: :boolean, required: false
+  def apply
+    exec_apply(options)
+  end
+
+  desc 'plan', 'Print out changes that will be made on next apply (runs a terraform plan)'
+  long_desc <<-LONGDESC
+    Prints out any changes that will be made the next time
+    a nexoform apply is run.  Under the hood, this command
+    runs a terraform plan.
+
+    If you pass an arg to 'out' the plan will be saved to that filename.
+    If you pass '--save' or '-s' the plan will be saved to '#{default_plan_filename}'
+    If you pass '--nosave' or '-n' the plan will not be saved
+    If you pass none of those, you'll be prompted about saving the plan
+
+    > $ nexoform plan --environment 'dev' [--save] [--out='#{default_plan_filename}']
+  LONGDESC
+  option :out, type: :string, aliases: 'o', required: false
+  option :save, type: :boolean, aliases: 's', required: false
+  option :nosave, type: :boolean, aliases: 'n', required: false
+  option :overwrite, type: :boolean, required: false
+  def plan
+    exec_plan(options)
+  end
+
+  desc 'destroy', 'Destroy all provisioned resources (runs a terraform destroy)'
+  long_desc <<-LONGDESC
+    Destroys any resources that have been provisioned
+
+    > $ nexoform destroy --environment 'dev'
+  LONGDESC
+  def destroy
+    exec_destroy(options)
+  end
+
+  desc 'output', 'Print any output from terraform'
+  long_desc <<-LONGDESC
+    Prints any output from last terraform state.  Runs a 'terraform output'
+
+    > $ nexoform output
+  LONGDESC
+  def output
+    execute('terraform output')
+  end
+
+  desc 'version', 'Check current installed version of nexoform'
+  def version
+    puts "Nexoform - Version: #{Nexoform.version}"
+  end
+
+  desc 'config-file', 'Write a default config file'
+  long_desc <<-LONGDESC
+    Writes a nexoform config file to #{Nexoform::Config.filename}
+    containing the default settings.  This can then be configured
+    as preferred.
+
+    > $ nexoform config-file [--upgrade] [--force] [--project-name 'simplenexus']
+  LONGDESC
+  option :force, type: :boolean, aliases: 'f', default: false
+  option :upgrade, type: :boolean, aliases: 'u', default: false
+  option :'project-name', type: :string, aliases: 'c', required: false
+  def config_file
+    exec_config_file(options)
+  end
+
+  desc 'list-envs', 'List the environments'
+  long_desc <<-LONGDESC
+    Lists the available environments and the current default (if applicable).
+    These are defined in the config file at #{Nexoform::Config.filename}
+
+    > $ nexoform list-envs
+  LONGDESC
+  def list_envs
+    exec_list_envs(options)
+  end
+
+  private
+
+  def print_next_color(str)
+    print Rainbow(str).color(next_color)
+  end
+
+  def puts_next_color(str)
+    puts Rainbow(str).color(next_color)
+  end
+
+  def config_file_present?
+    unless File.exist?(Nexoform::Config.filename)
+      print 'Could not find nexoform config file. Please create one at '.red
+      puts Nexoform::Config.filename.yellow
+      print_next_color 'You can generate a starter config file with: '
+      puts_next_color '`nexoform config-file`'
+      exit 2
+    end
+  end
+
+  def terraform_installed?
+    unless Nexoform::Bash.run_command('which terraform').success?
+      puts 'Terraform does not look to be installed, or is not in PATH.'.red
+      print 'To get started, check out: '.yellow
+      puts_next_color 'https://www.terraform.io/intro/getting-started/install.html'
+      exit 3
+    end
+  end
+
+  def terraform_files_present?
+    if Dir.glob('*.tf').empty?
+      puts "There aren't any terraform files here!".red
+      print 'To get started, check out: '.yellow
+      puts_next_color 'https://www.terraform.io/intro/getting-started/build.html'
+      exit 4
+    end
+  end
+
+  def plan_file_recent?(options)
+    # TODO: - check to see that the plan file, if it exists, was modified within the last 12 hours
+    # if it was not, warn/exit or something else more appropriate
+  end
+
+  def sanity_check(options)
+    config_file_present?
+    terraform_installed?
+    terraform_files_present?
+    plan_file_recent?(options)
+  end
+
+  def escape(str)
+    Shellwords.escape(str)
+  end
+
+  def env(options)
+    if options['environment']
+      options['environment']
+    elsif Nexoform::Config.default_env
+      Nexoform::Config.default_env
+    else
+      puts 'No environment was specified, and there is no default set.'.red
+      puts 'Please try again with a --environment specified'.yellow
+      exit 1
+    end
+  end
+
+  def execute(command)
+    puts
+    puts '-----------------------------------------------'.green
+    puts '| Executing command: '.green
+    puts '|'.green
+    puts '| '.green + command.blue
+    puts '-----------------------------------------------'.green
+    puts
+    retval = Nexoform::Bash.run_command_loud(command)
+    unless retval.success?
+      puts '* The previous command exited with failure.  Please check the output and try again:'.red
+      print '    Command:  '.red
+      puts command.yellow
+      exit retval.exitstatus.to_i
+    end
+  end
+
+  def terraform_init(options)
+    args = %W[
+      -backend=true
+      -force-copy
+      -get=true
+      -get-plugins=true
+      -reconfigure
+      -upgrade=true
+      -backend-config="bucket=#{escape(Nexoform::Config.bucket(env(options)))}"
+      -backend-config="key=#{escape(Nexoform::Config.key(env(options)))}"
+      -backend-config="region=#{escape(Nexoform::Config.region(env(options)))}"
+    ]
+    "terraform init #{args.join(' ')}"
+  end
+
+  def run_init(options)
+    print_next_color '* Initializing terraform for environment: '
+    execute(terraform_init(options))
+  end
+
+  def var_file_arg(options)
+    "-var-file #{escape(Nexoform::Config.var_file(env(options)))}"
+  end
+
+  def terraform_refresh(options)
+    "terraform refresh #{var_file_arg(options)}"
+  end
+
+  def run_refresh(options)
+    print_next_color 'Refreshing terraform state against actual state of ' \
+                     'resources for environment: '
+    print_next_color env(options)
+    execute(terraform_refresh(options))
+  end
+
+  def needs_prompt_for_plan_file?(options)
+    (options[:plan].nil? || options[:plan].empty?) && !options[:noplan]
+  end
+
+  def plan_file_in_dir?
+    !Dir.glob('*.tfplan').empty?
+  end
+
+  def prompt_for_plan_file(options)
+    return options if options[:noplan]
+
+    if Nexoform::Config.plan_disabled?(env(options))
+      puts_next_color '* Plan file is disabled in config file. Not using a plan file'
+      return options.merge(noplan: true)
+    end
+
+    if needs_prompt_for_plan_file?(options) && plan_file_in_dir?
+      # use config file if it has the info
+      if Nexoform::Config.has_plan_file?(env(options))
+        plan_file = Nexoform::Config.plan_file(env(options))
+        puts_next_color "* Using #{plan_file} for plan file as specified in " \
+          "config file #{Nexoform::Config.filename} for env #{env(options)}."
+        return options.merge(plan: plan_file)
+      else
+        plan_name = Dir.glob('*.tfplan').first
+        print "You didn't specify a --plan <filename>, but there is a plan " \
+          "file present.  Would you like to use the plan '#{plan_name}'? " \
+          "(pass --plan or --noplan if you don't want to see this prompt) (Y/N)?: ".yellow
+        resp = STDIN.gets.chomp
+        if resp =~ /y/i
+          puts_next_color "* Using plan file: #{plan_name}"
+          return options.merge(plan: plan_name)
+        else
+          puts '* Not using a plan file'.yellow
+        end
+      end
+    end
+    options
+  end
+
+  def exit_if_plan_file_should_but_does_not_exist(options)
+    if options[:plan] && !File.exist?(options[:plan])
+      puts "* Was told to use plan file '#{options[:plan]}' but it does not exist!".red
+      puts '* Please run `nexoform plan` and try again, or Re-run with --noplan'.red
+      exit 6
+    end
+  end
+
+  def apply_with_plan_file?(options)
+    return false if options[:noplan]
+
+    options[:plan]
+  end
+
+  def terraform_apply(options)
+    varfile = apply_with_plan_file?(options) ? '' : var_file_arg(options)
+    planfile = apply_with_plan_file?(options) ? options[:plan] : ''
+    "terraform apply #{varfile} #{planfile}"
+  end
+
+  def exec_apply(options)
+    sanity_check(options)
+    options = prompt_for_plan_file(options)
+    exit_if_plan_file_should_but_does_not_exist(options)
+    unless options[:plan]
+      run_init(options)
+      run_refresh(options)
+    end
+    print_next_color 'Applying any infrastructure changes ' \
+                     'for environment: '
+    puts_next_color env(options)
+    execute(terraform_apply(options))
+  end
+
+  def prompt_for_save_file(options)
+    return options if options[:nosave]
+
+    if Nexoform::Config.has_plan_file?(env(options))
+      plan_file = Nexoform::Config.plan_file(env(options))
+      puts_next_color "* Found plan file in #{Nexoform::Config.filename} for env #{env(options)}.  Using #{plan_file} for plan file"
+      opts = options.merge(out: plan_file)
+
+      if Nexoform::Config.has_plan_file_overwrite?(env(options))
+        pf_overwrite = Nexoform::Config.plan_file_overwrite(env(options))
+        puts_next_color "* Found overwrite setting for plan file '#{plan_file}' in config file '#{Nexoform::Config.filename}'. Setting to '#{pf_overwrite}'"
+        opts = opts.merge(overwrite: pf_overwrite)
+      else
+        puts "* Didn't see an overwrite setting for plan file '#{plan_file}' in the config file '#{Nexoform::Config.filename}' for env '#{env(options)}'. Skipping".yellow
+      end
+
+      return opts
+    elsif Nexoform::Config.plan_disabled?(env(options))
+      puts_next_color '* Plan file is disabled in config file. Not using a plan file'
+      return options.merge(nosave: true)
+    else
+      if !options[:out] && options[:save]
+        return options.merge(out: default_plan_filename)
+      elsif !options[:out]
+        puts "You didn't specify a --out <filename>.  Would you like to save the plan? (pass --nosave if you don't want to see this prompt)\n".yellow
+        puts "1.  'Y' for default filename (#{default_plan_filename}), ".cyan
+        puts "2.  'N' for no saving, ".red
+        puts '3.  Type in a filename'.blue
+        print "\nYour choice: ".yellow
+        resp = STDIN.gets.chomp
+        if resp =~ /^y$/ || resp =~ /^1$/
+          puts_next_color "* Using default filename: #{default_plan_filename}"
+          return options.merge(out: default_plan_filename)
+        elsif resp =~ /^n$/i || resp =~ /^2$/i || resp.empty?
+          puts '* Not saving plan'.yellow
+          return options
+        else
+          puts_next_color "* Using filename: #{resp}"
+          return options.merge(out: resp)
+        end
+      end
+    end
+
+    options
+  end
+
+  def prompt_if_plan_file_exists(options)
+    if options[:out] && File.exist?(options[:out])
+      if options[:overwrite].nil? || options[:overwrite] == 'ask'
+        print "The specified plan file '#{options[:out]}' already exists.  Over write? (Y/N): ".yellow
+        resp = STDIN.gets.chomp
+        if resp =~ /n/i
+          puts '* User declined writing over plan file.  Exiting.'.red
+          exit 5
+        end
+      elsif options[:overwrite] == false
+        puts "* Overwrite is set to false but the plan file '#{options[:out]}' exists.  " \
+             'Exitting.  Please change the setting or delete/move the plan file before ' \
+             'trying again.'.red
+        exit 5
+      elsif options[:overwrite].is_a?(String) && options[:overwrite] != 'ask'
+        puts "* Plan File Overwrite for env '#{env(options)}' is set to '#{options[:overwrite]}' which is not a valid value.  Must be either 'yes', 'no', or 'ask'".red
+        exit 5
+      end
+    end
+  end
+
+  def plan_with_plan_file?(options)
+    return false if options[:noplan]
+
+    options[:plan]
+  end
+
+  def terraform_plan(options)
+    out = options[:out] ? "-out=#{options[:out]}" : ''
+    "terraform plan #{var_file_arg(options)} #{out}"
+  end
+
+  def exec_plan(options)
+    sanity_check(options)
+    options = prompt_for_save_file(options)
+    prompt_if_plan_file_exists(options)
+    run_init(options)
+    run_refresh(options)
+    print_next_color '* Running terraform plan for environment: '
+    puts_next_color env(options)
+    execute(terraform_plan(options))
+  end
+
+  def terraform_destroy(options)
+    "terraform destroy #{var_file_arg(options)}"
+  end
+
+  def exec_destroy(options)
+    sanity_check(options)
+    run_init(options)
+    run_refresh(options)
+    print_next_color '* Destroying any infrastructure resources ' \
+                     'for environment: '
+    puts_next_color env(options)
+    execute(terraform_destroy(options))
+  end
+
+  def config_file_action(options)
+    if options[:upgrade]
+      'u'
+    elsif options[:force]
+      'o'
+    else
+      # Upgrade isn't implemented yet.  Uncomment when it is
+      # print "A config file already exists at #{Nexoform::Config.filename}.  [U]pgrade, [O]verwrite with default settings, or do [N]othing? (U/O/N): ".yellow
+      print "A config file already exists at #{Nexoform::Config.filename}.  [O]verwrite with default settings, or do [N]othing? (O/N): ".yellow
+      STDIN.gets.chomp
+    end
+  end
+
+  def take_action(action, project_name)
+    if action =~ /u/i
+      puts "* Upgrading config file at #{Nexoform::Config.filename}".green
+      Nexoform::Config.upgrade_settings_file
+    elsif action =~ /o/i
+      puts "* Overwriting config file with new version at #{Nexoform::Config.filename}".yellow
+      Nexoform::Config.write_default_settings_file(project_name)
+    else
+      puts '* User declined.  Not writing config file'.red
+      nil
+    end
+  end
+
+  def exec_config_file(options)
+    sanity_check(options)
+    if File.exist?(Nexoform::Config.filename)
+      take_action(config_file_action(options), options[:'project-name'])
+    else
+      puts "* Writing new config file to #{Nexoform::Config.filename}".green
+      Nexoform::Config.write_default_settings_file(options[:'project-name'])
+    end
+  end
+
+  def next_color
+    # colors = %i[cyan indianred magenta aqua]
+    colors = %i[cyan indianred magenta]
+    @last_num ||= -1
+    @last_num = (@last_num + 1) % colors.length
+    colors[@last_num]
+  end
+
+  def exec_list_envs(options)
+    sanity_check(options)
+    puts_next_color "\nValid environments (defined in your config file): \n"
+    Nexoform::Config.envs.each do |env|
+      puts Rainbow("  - #{env}").color(next_color)
+    end
+    puts
+  end
+end
+
+if !ARGV.empty? && %w[-v --version].include?(ARGV.first)
+  puts "Nexoform - Version: #{Nexoform.version}"
+else
+  begin
+    NexoformBin.start(ARGV)
+  rescue StandardError => e
+    puts "* Encountered an error.  Make sure your config-file isn't messed up".red
+    puts "\n* Exception message: #{e.message}".yellow
+  end
+end

data/lib/nexoform/config.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'active_support/core_ext/hash/indifferent_access'
+
+module Nexoform
+  class Config
+    def self.has_config_file?(dir)
+      File.exist?("#{dir}/nexoform.yml")
+    end
+
+    def self.find_config_file(starting_dir)
+      if has_config_file?(starting_dir)
+        "#{starting_dir}/nexoform.yml"
+      elsif starting_dir == '/'
+        default_filename
+      else
+        find_config_file(File.dirname(starting_dir)) # recurse up to /
+      end
+    end
+
+    def self.default_filename
+      './nexoform.yml'
+    end
+
+    def self.filename
+      find_config_file(Dir.pwd)
+    end
+
+    def self.proj_name(project_name)
+      project_name && !project_name.empty? ? project_name : '<companyname>'
+    end
+
+    def self.default_yaml(project_name)
+      %(---
+        nexoform:
+          environments:
+            default: dev          # optional default env so you don't have to specify
+            dev:                  # name of environment
+              varFile: dev.tfvars # terraform var-file to use
+              plan:               # optional block. Avoids getting prompted
+                enabled: yes      # yes | no.  If no, a plan file is not used
+                file: dev.tfplan  # file the plan is saved to automatically
+                overwrite: yes    # overwrite existing file. could be: yes | no | ask
+              state:              # configuration for state management s3 backend
+                bucket: #{project_name}-terraform-state
+                key: dev.tfstate
+                region: us-east-1
+            staging:                  # name of environment
+              varFile: staging.tfvars # terraform var-file to use
+              plan:                   # optional block. Avoids getting prompted
+                enabled: yes          # yes | no.  If no, a plan file is not used
+                file: staging.tfplan  # file the plan is saved to automatically
+                overwrite: yes        # overwrite existing file. could be: yes | no | ask
+              state:                  # configuration for state management s3 backend
+                bucket: #{project_name}-terraform-state
+                key: staging.tfstate
+                region: us-east-1
+            prod:                  # name of environment
+              varFile: prod.tfvars # terraform var-file to use
+              plan:                # optional block. Avoids getting prompted
+                enabled: yes       # yes | no.  If no, a plan file is not used
+                file: prod.tfplan  # file the plan is saved to automatically
+                overwrite: yes     # overwrite existing file. could be: yes | no | ask
+              state:               # configuration for state management s3 backend
+                bucket: #{project_name}-terraform-state
+                key: prod.tfstate
+                region: us-east-1
+      ).split("\n").map { |s| s.sub(' ' * 8, '') }.join("\n")
+    end
+
+    def self.default_settings(project_name = nil)
+      YAML.safe_load(default_yaml(proj_name(project_name))).with_indifferent_access
+    end
+
+    def self.settings(filename = self.filename)
+      YAML.load_file(filename).with_indifferent_access if File.exist?(filename)
+    end
+
+    def self.write_settings(settings, filename = self.filename, is_yaml: false)
+      settings = settings.to_yaml unless is_yaml
+      settings.gsub!(/\s*!ruby\/hash:ActiveSupport::HashWithIndifferentAccess/, '')
+      File.write(filename, settings)
+    end
+
+    def self.write_default_settings_file(project_name = nil)
+      write_settings(default_yaml(proj_name(project_name)), filename, is_yaml: true)
+    end
+
+    def self.debug?
+      settings[:nexoform][:debug]
+    end
+
+    def self.envs
+      settings[:nexoform][:environments].keys.reject { |k| k == 'default' }
+    end
+
+    def self.var_file(environment)
+      find_value(%I[nexoform environments #{environment} varFile])
+    end
+
+    def self.default_env
+      settings[:nexoform][:environments][:default]
+    end
+
+    def self.bucket(environment)
+      find_value(%I[nexoform environments #{environment} state bucket])
+    end
+
+    def self.key(environment)
+      find_value(%I[nexoform environments #{environment} state key])
+    end
+
+    def self.region(environment)
+      find_value(%I[nexoform environments #{environment} state region])
+    end
+
+    def self.plan_enabled(environment)
+      find_value(%I[nexoform environments #{environment} plan enabled])
+    end
+
+    def self.plan_disabled?(environment)
+      !plan_enabled(environment)
+    rescue ConfigError => e
+      false
+    end
+
+    def self.plan_file(environment)
+      find_value(%I[nexoform environments #{environment} plan file])
+    end
+
+    def self.has_plan_file?(environment)
+      return false if plan_disabled?(environment)
+
+      plan_file(environment)
+    rescue ConfigError => e
+      false
+    end
+
+    def self.plan_file_overwrite(environment)
+      find_value(%I[nexoform environments #{environment} plan overwrite])
+    end
+
+    def self.has_plan_file_overwrite?(environment)
+      plan_file_overwrite(environment)
+      true
+    rescue ConfigError => e
+      false
+    end
+
+    private
+
+    class ConfigError < StandardError
+    end
+
+    def self.find_value(keys)
+      keys.reduce(settings) do |last_val, key|
+        if last_val[key].nil?
+          raise ConfigError, "Key '#{key}' in chain '#{keys.join(' -> ')}' produced a " \
+            'nil value.  The expected key is missing in your config file.'
+        end
+        last_val[key]
+      end
+    end
+  end
+end

data/lib/nexoform/shell.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+
+module Nexoform
+  module Sh
+    def self.run_command(command, print_stdout = false)
+      stdout = `#{command}`
+      puts stdout if print_stdout
+      OpenStruct.new(
+        success?: $?.exitstatus.zero?,
+        exitstatus: $?.exitstatus,
+        stdout: stdout
+      )
+    end
+  end
+
+  module Bash
+    def self.escape_double_quotes(str)
+      str.gsub('"', '\\"')
+    end
+
+    def self.run_command(command, print_stdout = false)
+      stdout = `bash -c "#{escape_double_quotes(command)}"`
+      puts stdout if print_stdout
+      OpenStruct.new(
+        success?: $?.exitstatus.zero?,
+        exitstatus: $?.exitstatus,
+        stdout: stdout
+      )
+    end
+
+    def self.run_command_loud(command)
+      exitstatus = system("bash -c \"#{escape_double_quotes(command)}\"")
+      OpenStruct.new(
+        success?: exitstatus,
+        exitstatus: exitstatus ? '0' : '1', # we lose the true exit code
+        stdout: '' # we lose stdout too
+      )
+    end
+  end
+end

data/lib/nexoform/version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Nexoform
+  def self.version
+    '0.0.1'
+  end
+
+  def self.date
+    '2018-11-09'
+  end
+end

data/lib/nexoform.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Gem.find_files('nexoform/**/*.rb').each do |path|
+  require path.gsub(/\.rb$/, '') unless path =~ /bot.*cli/
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: nexoform
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ben Porter
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-11-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  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: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.20'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.20'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.59'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.59'
+description: Nexoform wraps Terraform to provide awareness for multiple environments.
+  Nexoform also provides a more guided experience for using remote backends to track
+  your state.  Without nexoform, there are several ways to accidentally lose or corrupt
+  your current state.  Nexoform puts up guard rails to prevent accidents, and puts
+  you on firm ground with terraform.
+email: bporter@simplenexus.com
+executables:
+- nexoform
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/nexoform
+- lib/nexoform.rb
+- lib/nexoform/config.rb
+- lib/nexoform/shell.rb
+- lib/nexoform/version.rb
+homepage: https://github.com/SimpleNexus/nexoform
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.3
+signing_key: 
+specification_version: 4
+summary: Environment aware wrapping for Terraform
+test_files: []