chamber 1.0.3 → 2.0.0

data/bin/chamber

@@ -1,291 +1,5 @@
 #!/usr/bin/env ruby
 
-require 'pp'
-require 'thor'
-require 'bundler'
-require 'chamber'
-require 'yaml'
-require 'tempfile'
+require 'chamber/binary/runner'
 
-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
-      else
-        puts current_heroku_config
-      end
-    end
-
-    desc 'diff', 'Displays the difference between what is currently stored in the Heroku application\'s config and what Chamber knows about locally'
-    method_option :only_ignored,
-                  type:     :boolean,
-                  aliases:  '-o',
-                  default:  true,
-                  desc:     'When enabled, the diff will only consider settings contained in files which have been gitignored, the rest will be accessed directly'
-    def diff
-      ::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
-
-      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/application')
-
-          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
+Chamber::Binary::Runner.start

data/lib/chamber.rb

@@ -1,88 +1,40 @@
-require 'singleton'
-require 'forwardable'
-require 'chamber/file_set'
+require 'chamber/instance'
 require 'chamber/rails'
 
-class  Chamber
-  include Singleton
+module  Chamber
+  extend self
 
-  class << self
-    extend Forwardable
-
-    def_delegators  :instance,  :[],
-                                :basepath,
-                                :load,
-                                :filenames,
-                                :namespaces,
-                                :settings,
-                                :to_environment,
-                                :to_hash,
-                                :to_s
-
-    alias_method    :env,       :instance
-  end
-
-  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, {})
+  def load(options = {})
+    self.instance = Instance.new(options)
   end
 
-  def filenames
-    self.files.filenames
+  def to_s(options = {})
+    instance.to_s(options)
   end
 
-  def namespaces
-    settings.namespaces
+  def env
+    instance.settings
   end
 
-  def settings
-    @settings ||= -> do
-      @settings = Settings.new
+  protected
 
-      files.to_settings do |parsed_settings|
-        @settings.merge! parsed_settings
-      end
+  def instance
+    @@instance ||= Instance.new({})
+  end
 
-      @settings
-    end.call
+  def instance=(new_instance)
+    @@instance = new_instance
   end
 
+  public
+
   def method_missing(name, *args)
-    if settings.respond_to?(name)
-      return settings.public_send(name, *args)
-    end
+    return instance.public_send(name, *args) if instance.respond_to?(name)
 
     super
   end
 
   def respond_to_missing?(name, include_private = false)
-    settings.respond_to?(name, include_private)
-  end
-
-  def to_s(*args)
-    settings.to_s(*args)
-  end
-
-  protected
-
-  attr_writer :settings
-
-  def files
-    @files ||= FileSet.new files: []
-  end
-
-  private
-
-  def basepath=(pathlike)
-    @basepath = pathlike == '' ? '' : Pathname.new(::File.expand_path(pathlike))
+    instance.respond_to?(name, include_private)
   end
 end

data/lib/chamber/binary/heroku.rb

@@ -0,0 +1,59 @@
+require 'thor'
+require 'chamber/commands/heroku/clear'
+require 'chamber/commands/heroku/push'
+require 'chamber/commands/heroku/pull'
+require 'chamber/commands/heroku/compare'
+
+module  Chamber
+module  Binary
+class   Heroku < Thor
+
+  class_option :app,
+                type:     :string,
+                aliases:  '-a',
+                required: true,
+                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
+    Commands::Heroku::Clear.call(options)
+  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_sensitive,
+                type:     :boolean,
+                aliases:  '-o',
+                default:  true,
+                desc:     'When enabled, only settings contained in files which have been gitignored or settings which are marked as "_secure" will be pushed'
+  def push
+    Commands::Heroku::Push.call(options)
+  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
+    puts Commands::Heroku::Pull.call(options)
+  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 :only_sensitive,
+                type:     :boolean,
+                aliases:  '-o',
+                default:  true,
+                desc:     'When enabled, the diff will only consider settings contained in files which have been gitignored or settings which are marked as "_secure"'
+  def compare
+    Commands::Heroku::Compare.call(options)
+  end
+end
+end
+end