conf_conf 1.0.2 → 2.0.2

data/conf_conf.gemspec

@@ -3,15 +3,23 @@ lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |s|
-  s.name             = "conf_conf"
-  s.version          = "1.0.2"
-  s.licenses         = ["MIT"]
-  s.authors          = ["James Kassemi"] 
-  s.email            = ["jkassemi@gmail.com"]
-  s.homepage         = "https://github.com/jkassemi/conf_conf"
-  s.description      = "Verify correctness of environment variables"
-  s.summary          = "A simple pattern and utility for verifying the correctness of the environment variables at application boot so we can fail fast when there's a configuration problem."
-  s.files            = `git ls-files`.split($/)
+  s.name        = 'conf_conf'
+  s.version     = '2.0.2'
+  s.licenses    = ['MIT']
+  s.authors     = ['James Kassemi']
+  s.email       = ['jkassemi@gmail.com']
+  s.homepage    = 'https://github.com/jkassemi/conf_conf'
+  s.description = 'Verify correctness of environment variables'
+  s.summary     = 'A simple pattern and utility for verifying the correctness of the environment variables at application boot so we can fail fast when there\'s a configuration problem.'
+  s.files       = `git ls-files`.split($/)
+  s.executables = ['conf_conf']
 
-  s.add_development_dependency 'rspec', '~> 3.0'
+  s.add_runtime_dependency 'httpi',             '~> 2.2.4'
+  s.add_runtime_dependency 'thor',              '~> 0.19.1'
+  s.add_runtime_dependency 'colorize',          '~> 0.7.3'
+  s.add_runtime_dependency 'highline',          '~> 1.6.21'
+  s.add_runtime_dependency 'rbnacl-libsodium',  '~> 0.5.0.1'
+  s.add_runtime_dependency 'multi_json',        '~> 1.10.1'
+  s.add_runtime_dependency 'dotenv',            '~> 0.11.1'
+  s.add_development_dependency 'rspec',  '~> 3.0'
 end

data/lib/conf_conf.rb

@@ -1,68 +1,77 @@
+require 'multi_json'
 require 'ostruct'
 
-Dir["tasks/**/*.rake"].each { |ext| load ext } if defined?(Rake)
+require 'conf_conf/project'
+require 'conf_conf/configuration'
+require 'conf_conf/project/developer'
+require 'conf_conf/project/developers'
+require 'conf_conf/project/environment'
+require 'conf_conf/project/environment/storage'
+require 'conf_conf/project/environments'
 
 module ConfConf
+  VERSION = '2.0.2'
+
   class MissingConfigurationValueError < StandardError; end;
+  class InconsistentConfigurationError < StandardError
+    attr_reader :inconsistencies
 
-  class << self
-    def configuration(&block)
-      OpenStruct.new(Configuration.new(&block).parsed_values)
+    def initialize(inconsistencies)
+      @inconsistencies = inconsistencies
     end
+  end
 
-    def rails_configuration(&block)
-      configuration = Configuration.new
-      configuration.run(block)
+  class << self
+    #TODO: This could be cleaned up considerably.
+    def configuration(environment_name=nil, &block)
+      if environment_name
+        # Load ENV
+        project         = ConfConf::Project.new
+        environment     = project.environments[environment_name]
 
-      configuration.parsed_values.each do |key, value|
-        Rails.configuration.send("#{key}=", value)
+        environment.variables.each do |name, value|
+          ENV[name] = value
+        end
       end
-    end
-  end
 
-  class Configuration
-    attr_reader :parsed_values
+      # Run configuration block, if given
+      configuration = ConfConf::Configuration.new
 
-    def initialize(&block)
-      @parsed_values = {}
-      run(block) if block
-    end
+      if block
+        configuration.run(block)
+        references      = configuration.references
+      else
+        references      = {}
+      end
 
-    def run(block)
-      instance_eval(&block)
-    end
+      if environment_name
+        # Find references to variables that aren't defaulted here
+        inconsistencies = project.inconsistencies(environment)
 
-    def config(key, options={})
-      value = Reference.new(key, options).value
+        inconsistencies.each do |inconsistency|
+          if references[inconsistency] && references[inconsistency].default_value?
+            inconsistencies.delete(inconsistency)
+          end
+        end
 
-      if block_given?
-        value = yield(value)
+        if inconsistencies.length > 0
+          raise ConfConf::InconsistentConfigurationError.new(inconsistencies)
+        end
       end
 
-      @parsed_values[key] = value
+      OpenStruct.new(configuration.parsed_values)
     end
-  end
 
-  class Reference < Struct.new(:key, :options)
-    def value
-      environment_value || default_value
-    end 
+    def rails_configuration(environment_name=nil, &block)
+      configuration = configuration(environment_name, block)
 
-    private
-    def default_value
-      if options.has_key? :default
-        options[:default]
-      else
-        raise MissingConfigurationValueError.new("Please set #{environment_key} or supply a default value")
+      configuration.parsed_values.each do |name, value|
+        Rails.configuration.send("#{key}=", value)
       end
     end
 
-    def environment_value
-      ENV[environment_key]
-    end
-
-    def environment_key
-      options[:from] || key.to_s.upcase
+    def load(environment_name)
+      configuration(environment_name)
     end
   end
 end

data/lib/conf_conf/cli.rb

@@ -0,0 +1,9 @@
+require 'conf_conf'
+
+module ConfConf::CLI
+end
+
+require 'conf_conf/cli/variables'
+require 'conf_conf/cli/developers'
+require 'conf_conf/cli/environments'
+require 'conf_conf/cli/root'

data/lib/conf_conf/cli/developers.rb

@@ -0,0 +1,48 @@
+class ConfConf::CLI::Developers < Thor
+  desc 'key', 'Your developer key'
+  def key
+    developer = ConfConf::Project::Developer.current
+
+    puts MultiJson.dump(developer.pretty_public_key, pretty: true)
+  end
+
+  desc 'permit <key>', 'Give <key> access to environment configurations'
+  def permit(key)
+    project    = ConfConf::Project.new
+    developer  = ConfConf::Project::Developer.new(key)
+    developers = project.developers
+
+    developers.add(developer)
+    developers.save
+
+    project.environments.to_a.each do |environment|
+      environment.save
+    end
+
+    puts MultiJson.dump(developers.keys.to_a, pretty: true)
+  end
+
+  desc 'revoke <key>', 'Deny <key> access to the environment configurations'
+  def revoke(key)
+    project    = ConfConf::Project.new
+    developer  = ConfConf::Project::Developer.new(key)
+    developers = project.developers
+
+    developers.remove(developer)
+    developers.save
+
+    project.environments.to_a.each do |environment|
+      environment.save
+    end
+
+    puts MultiJson.dump(developers.keys.to_a, pretty: true)
+  end
+
+  desc 'list', 'List of keys with access to the environment configurations'
+  def list
+    project    = ConfConf::Project.new
+    developers = project.developers
+
+    puts MultiJson.dump(developers.keys.to_a, pretty: true)
+  end
+end

data/lib/conf_conf/cli/environments.rb

@@ -0,0 +1,61 @@
+module ConfConf::CLI
+  class Environments < Thor
+    desc 'list', 'Show environments'
+    def list
+      project = ConfConf::Project.new
+      puts MultiJson.dump(project.environments.to_a.collect(&:name), pretty: true)
+    end
+
+    desc 'add <environment>', 'Set up new environment'
+    long_desc <<-LONG
+      > $ conf_conf env add staging
+    LONG
+    def add(environment_name)
+      project = ConfConf::Project.new
+      environment = project.environments[environment_name]
+      environment.save
+
+      puts MultiJson.dump(project.environments.to_a.collect(&:name), pretty: true)
+    end
+
+    desc 'remove <environment>', 'Removes an existing environment'
+    def remove(environment_name)
+      project = ConfConf::Project.new
+      project.environments.remove(environment_name)
+
+      puts MultiJson.dump(project.environments.to_a.collect(&:name), pretty: true)
+    end
+
+    desc 'check (<environment>)', 'Check environment consistency'
+    def check(environment_name=nil)
+      project = ConfConf::Project.new
+
+      all_environment_variable_names = Set.new
+
+      project.environments.to_a.each do |environment|
+        all_environment_variable_names += environment.variables.keys
+      end
+
+      if environment_name.nil?
+        environments = project.environments.to_a
+      else
+        environments = [project.environments[environment_name]]
+      end
+
+      environment_warnings = {}
+
+      environments.each do |environment|
+        diff = all_environment_variable_names - environment.variables.keys
+
+        if diff.length > 0
+          diff.each do |key|
+            environment_warnings[environment.name] ||= {:missing => []}
+            environment_warnings[environment.name][:missing] << key
+          end
+        end
+      end
+
+      puts MultiJson.dump(environment_warnings, pretty: true)
+    end
+  end
+end

data/lib/conf_conf/cli/root.rb

@@ -0,0 +1,72 @@
+module ConfConf
+  module CLI
+    class Root < Thor
+      desc 'environments', 'Manage available environments'
+      subcommand 'environments', ConfConf::CLI::Environments
+
+      desc 'variables', 'Configure environment variables'
+      subcommand 'variables', ConfConf::CLI::Variables
+
+      desc 'developers', 'Configure access credentials'
+      subcommand 'developers', ConfConf::CLI::Developers
+
+      desc 'init', 'Initialize conf_conf project'
+      long_desc <<-LONG
+        > $ conf_conf init
+
+        Initialize this system user's ~/.conf_conf.json
+      LONG
+      def init
+        account = ConfConf::Project::Developer.current
+        FileUtils.mkdir_p('config/conf_conf')
+        FileUtils.mkdir_p('config/conf_conf/environments')
+        puts MultiJson.dump(account: account, pretty: true)
+      end
+
+      desc 'export <environment>', '.env compatible export for <environment>'
+      def export(environment_name)
+        project     = ConfConf::Project.new
+        environment = project.environments[environment_name]
+
+        environment.variables.each do |variable_name, variable_value|
+          puts "#{variable_name}=#{variable_value}"
+        end
+      end
+
+      desc 'import <environment>', 'Import from .env into <environment>'
+      option :dotenv, default: true
+      def import(environment_name)
+        require 'dotenv'
+
+        project = ConfConf::Project.new
+        environment = project.environments[environment_name]
+        dotenv_environment = Dotenv::Environment.new('.env')
+
+        dotenv_environment.each do |k,v|
+          environment.set(k, v)
+        end
+
+        environment.save
+        puts MultiJson.dump(environment.variables, pretty: true)
+      end
+
+      desc 'info', 'Summary of configurations'
+      def info
+        project = ConfConf::Project.new
+
+        summary = {}
+        summary[:environments] = project.environments.to_a.collect(&:name)
+        summary[:variables] = {}
+
+        project.environments.to_a.each do |environment|
+          environment.variables.each do |variable_name, variable_value|
+            summary[:variables][variable_name] ||= []
+            summary[:variables][variable_name] << environment.name
+          end
+        end
+
+        puts MultiJson.dump(summary, pretty: true)
+      end
+    end
+  end
+end

data/lib/conf_conf/cli/variables.rb

@@ -0,0 +1,85 @@
+class ConfConf::CLI::Variables < Thor
+  desc 'set', 'Set configuration values in the given environment'
+  option :env, default: false, desc: 'environment to set the config var'
+  long_desc <<-LONG
+    Sets Config Values in the given Environment.
+
+    Examples:
+
+    > $ conf_conf set X=1
+
+    Sets the Config Key `X` with Config Value `1` for all Environments.
+
+    > $ conf_conf set --env=production X=1
+
+    Sets the Config Key `X` with Config Value `1` for `production` Environment.
+    Sets the Config Key `X` with the Config Value `1` for the
+    `production` Environment.
+
+    > $ conf_conf set --env=production X=1 Y=2 Z=3
+
+    Sets the Config Keys `X`, `Y`, and `Z` with the Config
+    Values `1`, `2`, and `3`, respectively. Config Values are saved to
+    the `production` Environment.
+  LONG
+  def set(*env_variable_args)
+    project      = ConfConf::Project.new
+    developers   = project.developers
+
+    developer = ConfConf::Project::Developer.current
+    developers.add(developer)
+
+    if options[:env]
+      environments = [project.environments[options[:env]]]
+    else
+      environments = project.environments.to_a
+    end
+
+    return if environments.length == 0
+
+    env_variable_args.each do |env_variable|
+      config_key, config_value = env_variable.split("=").map(&:strip)
+
+      environments.each do |environment|
+        environment.set(config_key, config_value)
+      end
+    end
+
+    environments.map(&:save)
+  end
+
+  desc 'remove', 'Remove a configuration value'
+  option :env, default: 'development', desc: 'environment to remove the config var from'
+  long_desc <<-LONG
+    Examples:
+
+    > $ conf_conf remove X
+
+    Removes the `X` Environment Variable
+
+    > $ conf_conf remove --env=production X
+
+    Removes `X` from production only
+  LONG
+  def remove(*name_args)
+    project      = ConfConf::Project.new
+
+    all_environments = project.environments.to_a
+
+    if options[:env]
+      environments = [project.environments[options[:env]]]
+    else
+      environments = all_environments
+    end
+
+    return if environments.length == 0
+
+    name_args.each do |name|
+      environments.each do |environment|
+        environment.remove(name)
+      end
+    end
+
+    environments.map(&:save)
+  end
+end

data/lib/conf_conf/configuration.rb

@@ -0,0 +1,57 @@
+module ConfConf
+  class Configuration
+    attr_reader :parsed_values
+    attr_reader :references
+
+    def initialize
+      @parsed_values = {}
+      @references = {}
+    end
+
+    def run(block)
+      instance_eval(&block)
+    end
+
+    def config(key, options={})
+      reference = Reference.new(key, options)
+      @references[reference.environment_key] = reference
+
+      value = reference.value
+
+      if block_given?
+        value = yield(value)
+      end
+
+      @parsed_values[key] = value
+    end
+  end
+
+  private
+  class Reference < Struct.new(:key, :options)
+    def value
+      environment_value || default_value
+    end
+
+    def default_value?
+      options[:default]
+    end
+
+    def environment_key
+      options[:from] || key.to_s.upcase
+    end
+
+    private
+    def default_value
+      if options.has_key? :default
+        options[:default]
+      else
+        raise ConfConf::MissingConfigurationValueError.new("Please set #{environment_key} or supply a default value")
+      end
+    end
+
+    def environment_value
+      ENV[environment_key]
+    end
+
+  end
+end