chamber 0.0.4 → 1.0.0

data/bin/chamber

@@ -0,0 +1,277 @@
+#!/usr/bin/env ruby
+
+require 'pp'
+require 'thor'
+require 'bundler'
+require 'chamber'
+require 'yaml'
+require 'tempfile'
+
+class   Chamber
+module  Commands
+  class Heroku < Thor
+    class_option :app,
+                 type:    :string,
+                 aliases: '-a',
+                 desc:    'The name of the Heroku application whose config values will be affected'
+
+    desc 'clear', 'Removes all Heroku environment variables which match settings that Chamber knows about'
+    method_option :dry_run,
+                  type:     :boolean,
+                  aliases:  '-d',
+                  desc:     'Does not actually remove anything, but instead displays what would change if cleared'
+    def clear
+      ::Chamber::Commands::Chamber.init(options)
+
+      keys = ::Chamber.to_environment.keys
+
+      if options[:dry_run]
+        puts "Running without --dry-run will remove the following Heroku environment variables"
+
+        keys_regex            = keys.join('|')
+        current_heroku_config = heroku("config --shell")
+
+        current_heroku_config.each_line do |line|
+          puts line if line.match(keys_regex)
+        end
+      else
+        puts heroku("config:unset #{keys.join(' ')}")
+      end
+    end
+
+    desc 'push', 'Sends settings to Heroku so that they may be used in the application once it is deployed'
+    method_option :dry_run,
+                  type:     :boolean,
+                  aliases:  '-d',
+                  desc:     'Does not actually push anything to Heroku, but instead displays what would change if pushed'
+    method_option :only_ignored,
+                  type:     :boolean,
+                  aliases:  '-o',
+                  default:  true,
+                  desc:     'Does not push settings up to Heroku unless the file that the setting is contained in has been gitignored'
+    def push
+      ::Chamber::Commands::Chamber.init(options)
+
+      if options[:only_ignored]
+        ignored_settings_files = `git ls-files --other --ignored --exclude-from=.gitignore | sed -e "s|^|${PWD}/|" | grep --colour=never -E '#{::Chamber.filenames.join('|')}'`
+
+        ::Chamber.load  files:       ignored_settings_files.split("\n"),
+                        namespaces:  options[:namespaces]
+      end
+
+      if options[:dry_run]
+        puts "Running without --dry-run will set the following Heroku environment variables"
+
+        puts ::Chamber.to_s(pair_separator: "\n")
+      else
+        heroku("config:set #{::Chamber.to_s}")
+      end
+    end
+
+    desc 'pull', 'Retrieves the environment variables for the application and stores them in a temporary file'
+    method_option :into,
+                  type:     :string,
+                  desc:     'The file into which the Heroku config information should be stored. This file WILL BE OVERRIDDEN.'
+    def pull
+      current_heroku_config = heroku("config --shell")
+
+      if options[:into]
+        ::File.open(options[:into], 'w+') do |file|
+          file.write current_heroku_config
+        end
+      end
+    end
+
+    desc 'diff', 'Displays the difference between what is currently stored in the Heroku application\'s config and what Chamber knows about locally'
+    def diff
+      ::Chamber::Commands::Chamber.init(options)
+
+      current_heroku_config = heroku("config --shell")
+      current_local_config  = ::Chamber.to_s(pair_separator:    "\n",
+                                             value_surrounder:  '')
+
+      heroku_config_file =  Tempfile.open('heroku') do |file|
+                              file.write  current_heroku_config.chomp
+                              file.to_path
+                            end
+      local_config_file  =  Tempfile.open('local') do |file|
+                              file.write  current_local_config
+                              file.to_path
+                            end
+
+      system("git diff --no-index #{local_config_file} #{heroku_config_file}")
+    end
+
+    no_commands do
+      def app
+        options[:app] ? " --app #{options[:app]}" : ""
+      end
+
+      def heroku(command)
+        Bundler.with_clean_env { `heroku #{command}#{app}` }
+      end
+    end
+  end
+
+  class Travis < Thor
+    desc 'secure', 'Uses your Travis CI public key to encrypt the settings you have chosen not to commit to the repo'
+    method_option :dry_run,
+                  type:     :boolean,
+                  aliases:  '-d',
+                  desc:     'Does not actually encrypt anything to .travis.yml, but instead displays what values would be encrypted'
+    method_option :only_ignored,
+                  type:     :boolean,
+                  aliases:  '-o',
+                  default:  true,
+                  desc:     'Does not encrpyt settings into .travis.yml unless the file that the setting is contained in has been gitignored'
+    def secure
+      ::Chamber::Commands::Chamber.init(options)
+
+      if options[:only_ignored]
+        ignored_settings_files = `git ls-files --other --ignored --exclude-from=.gitignore | sed -e "s|^|${PWD}/|" | grep --colour=never -E '#{::Chamber.filenames.join('|')}'`
+
+        ::Chamber.load  files:       ignored_settings_files.split("\n"),
+                        namespaces:  options[:namespaces]
+      end
+
+      setting_values = ::Chamber.to_s(pair_separator: "\n")
+
+      if options[:dry_run]
+        puts "Running without --dry-run will encrypt the following Travis CI environment variables"
+
+        puts setting_values
+      else
+        travis_encrypt('--override ryterutoiuewrtoiuweorit="invalid"')
+
+        setting_values.each_line do |line|
+          puts "Encrypting: #{line}"
+          travis_encrypt("--append #{line}")
+        end
+      end
+    end
+
+    no_commands do
+      def travis_encrypt(command)
+        Bundler.with_clean_env { `travis encrypt --add 'env.global' #{command}` }
+      end
+    end
+  end
+
+  class Settings < Thor
+    desc 'show', 'Displays the list of settings and their values'
+    method_option :as_env,
+                  type:     :boolean,
+                  aliases:  '-e',
+                  desc:     'Whether the displayed settings should be environment variable compatible'
+    def show
+      ::Chamber::Commands::Chamber.init(options)
+
+      if options[:as_env]
+        puts ::Chamber.to_s(pair_separator: "\n")
+      else
+        pp ::Chamber.to_hash
+      end
+    end
+
+    desc 'files', 'Lists the settings files which are parsed with the given options'
+    def files
+      ::Chamber::Commands::Chamber.init(options)
+
+      pp ::Chamber.filenames
+    end
+
+    desc 'compare', 'Displays the difference between what is currently stored in the Heroku application\'s config and what Chamber knows about locally'
+    method_option :keys_only,
+                  type:     :boolean,
+                  default:  true,
+                  desc:     'Whether or not to only compare the keys but not the values of the two sets of settings'
+    method_option :first,
+                  type:     :array,
+                  desc:     'The list of namespaces which will be used as the source of the comparison'
+    method_option :second,
+                  type:     :array,
+                  desc:     'The list of namespaces which will be used as the destination of the comparison'
+    def compare
+      ::Chamber::Commands::Chamber.init(options)
+
+      ::Chamber.load  basepath:   options[:basepath],
+                      files:      options[:files],
+                      namespaces: options[:first]
+
+      first_config  = if options[:keys_only]
+                        ::Chamber.to_environment.keys.join("\n")
+                      else
+                        ::Chamber.to_s(pair_separator: "\n")
+                      end
+
+      ::Chamber.load  basepath:   options[:basepath],
+                      files:      options[:files],
+                      namespaces: options[:second]
+
+      second_config = if options[:keys_only]
+                        ::Chamber.to_environment.keys.join("\n")
+                      else
+                        ::Chamber.to_s(pair_separator: "\n")
+                      end
+
+      first_config_file   = Tempfile.open('first') do |file|
+                              file.write  first_config
+                              file.to_path
+                            end
+      second_config_file  = Tempfile.open('second') do |file|
+                              file.write  second_config
+                              file.to_path
+                            end
+
+      system("git diff --no-index #{first_config_file} #{second_config_file}")
+    end
+  end
+
+  class Chamber < Thor
+    class_option  :basepath,
+                  type:     :string,
+                  aliases:  '-b',
+                  desc:     'The base filepath where Chamber will look for the conventional settings files'
+    class_option  :files,
+                  type:     :array,
+                  aliases:  '-f',
+                  desc:     'The set of file globs that Chamber will use for processing'
+    class_option  :namespaces,
+                  type:     :array,
+                  aliases:  '-n',
+                  default:  [],
+                  desc:     'The set of namespaces that Chamber will use for processing'
+    class_option  :preset,
+                  type:     :string,
+                  aliases:  '-p',
+                  enum:     ['rails'],
+                  desc:     'Used to quickly assign a given scenario to the chamber command (eg Rails apps)'
+
+    desc 'settings SUBCOMMAND ...ARGS', 'For working with Chamber settings'
+    subcommand 'settings',  ::Chamber::Commands::Settings
+
+    desc 'travis SUBCOMMAND ...ARGS',   'For manipulating Travis CI environment variables'
+    subcommand 'travis',    ::Chamber::Commands::Travis
+
+    desc 'heroku SUBCOMMAND ...ARGS',   'For manipulating Heroku environment variables'
+    subcommand 'heroku',    ::Chamber::Commands::Heroku
+
+    no_commands do
+      def self.init(options)
+        if options[:preset] == 'rails'
+          require ::File.expand_path('./config/environment')
+
+          options[:basepath]   = Rails.root.join('config')
+          options[:namespaces] = options[:namespaces].empty? ? [Rails.env] : options[:namespaces]
+        end
+
+        ::Chamber.load  basepath:   options[:basepath],
+                        files:      options[:files],
+                        namespaces: options[:namespaces]
+      end
+    end
+  end
+end
+end
+
+Chamber::Commands::Chamber.start

data/lib/chamber.rb

@@ -1,90 +1,88 @@
-require 'erb'
-require 'hashie'
-require 'yaml'
-
-require 'chamber/version'
-
-module Chamber
-  class ChamberInvalidOptionError < ArgumentError; end
-
-  def source(filename, options={})
-    assert_valid_keys(options)
-
-    add_source(filename, options)
+require 'singleton'
+require 'forwardable'
+require 'chamber/file_set'
+require 'chamber/rails'
+
+class  Chamber
+  include Singleton
+
+  class << self
+    extend Forwardable
+
+    def_delegators  :instance,  :[],
+                                :basepath,
+                                :load,
+                                :filenames,
+                                :namespaces,
+                                :settings,
+                                :to_environment,
+                                :to_hash,
+                                :to_s
+
+    alias_method    :env,       :instance
   end
 
-  def load!
-    sources.each do |source|
-      filename, options = source
-
-      load_source!(filename, options)
-    end
-  end
-
-  def clear!
-    @chamber_instance = nil
-    @chamber_sources = nil
+  attr_accessor :basepath,
+                :files
+
+  def load(options)
+    self.settings = nil
+    self.basepath = options[:basepath] || ''
+    file_patterns = options[:files] || [
+                      self.basepath + 'credentials*.yml',
+                      self.basepath + 'settings*.yml',
+                      self.basepath + 'settings' ]
+    self.files    = FileSet.new files:      file_patterns,
+                                namespaces: options.fetch(:namespaces, {})
   end
 
-  def reload!
-    @chamber_instance = nil
-    load!
+  def filenames
+    self.files.filenames
   end
 
-  def instance
-    @chamber_instance ||= Hashie::Mash.new
+  def namespaces
+    settings.namespaces
   end
 
-  def method_missing(method_name, *args, &block)
-    instance.public_send(method_name, *args, &block)
-  end
+  def settings
+    @settings ||= -> do
+      @settings = Settings.new
 
-  alias_method :env, :instance
+      files.to_settings do |parsed_settings|
+        @settings.merge! parsed_settings
+      end
 
-private
+      @settings
+    end.call
+  end
 
-  def assert_valid_keys(options)
-    unknown_keys = options.keys - [:namespace, :override_from_environment]
+  def method_missing(name, *args)
+    if settings.respond_to?(name)
+      return settings.public_send(name, *args)
+    end
 
-    raise(ChamberInvalidOptionError, options) unless unknown_keys.empty?
+    super
   end
 
-  def sources
-    @chamber_sources ||= []
+  def respond_to_missing?(name, include_private = false)
+    settings.respond_to?(name, include_private)
   end
 
-  def add_source(filename, options)
-    sources << [filename, options]
+  def to_s(*args)
+    settings.to_s(*args)
   end
 
-  def load_source!(filename, options)
-    return unless File.exists?(filename)
+  protected
 
-    hash = hash_from_source(filename, options[:namespace])
-    if options[:override_from_environment]
-      override_from_environment!(hash)
-    end
+  attr_writer :settings
 
-    instance.deep_merge!(hash)
+  def files
+    @files ||= FileSet.new files: []
   end
 
-  def hash_from_source(filename, namespace)
-    contents = open(filename).read
-    hash = YAML.load(ERB.new(contents).result).to_hash || {}
-    hash = Hashie::Mash.new(hash)
+  private
 
-    namespace ? hash.fetch(namespace) : hash
-  end
-
-  def override_from_environment!(hash)
-    hash.each_pair do |key, value|
-      next unless value.is_a?(Hash)
-
-      if value.environment
-        hash[key] = ENV[value.environment]
-      else
-        override_from_environment!(value)
-      end
-    end
+  def basepath=(pathlike)
+    @basepath = pathlike == '' ? '' : Pathname.new(::File.expand_path(pathlike))
   end
 end

data/lib/chamber/file.rb

@@ -0,0 +1,84 @@
+require 'pathname'
+require 'yaml'
+require 'erb'
+
+###
+# Internal: Represents a single file containing settings information in a given
+# file set.
+#
+class   Chamber
+class   File < Pathname
+
+  ###
+  # Internal: Creates a settings file representing a path to a file on the
+  # filesystem.
+  #
+  # Optionally, namespaces may be passed in which will be passed to the Settings
+  # object for consideration of which data will be parsed (see the Settings
+  # object's documentation for details on how this works).
+  #
+  # Examples:
+  #
+  #   ###
+  #   # It can be created by passing namespaces
+  #   #
+  #   settings_file = Chamber::File.new path:       '/tmp/settings.yml',
+  #                                     namespaces: {
+  #                                       environment: ENV['RAILS_ENV'] }
+  #   # => <Chamber::File>
+  #
+  #   settings_file.to_settings
+  #   # => <Chamber::Settings>
+  #
+  #   ###
+  #   # It can also be created without passing any namespaces
+  #   #
+  #   Chamber::File.new path: '/tmp/settings.yml'
+  #   # => <Chamber::File>
+  #
+  def initialize(options = {})
+    self.namespaces = options[:namespaces] || {}
+
+    super options.fetch(:path)
+  end
+
+  ###
+  # Internal: Extracts the data from the file on disk.  First passing it through
+  # ERB to generate any dynamic properties and then passing the resulting data
+  # through YAML.
+  #
+  # Therefore if a settings file contains something like:
+  #
+  # ```erb
+  # test:
+  #   my_dynamic_value: <%= 1 + 1 %>
+  # ```
+  #
+  # then the resulting settings object would have:
+  #
+  # ```ruby
+  # settings[:test][:my_dynamic_value]
+  # # => 2
+  # ```
+  #
+  def to_settings
+    @data ||= Settings.new(settings:    file_contents_hash,
+                           namespaces:  namespaces)
+  end
+
+  protected
+
+  attr_accessor :namespaces
+
+  private
+
+  def file_contents_hash
+    file_contents = self.read
+    erb_result    = ERB.new(file_contents).result
+
+    YAML.load(erb_result) || {}
+  rescue Errno::ENOENT
+    {}
+  end
+end
+end