yaml2env 0.1.2 → 0.2.0

data/.gitignore

@@ -1,4 +1,9 @@
-*.gem
+.DS_Store
 .bundle
+.rbx
+.*~
 Gemfile.lock
 pkg/*
+*.gem
+*.rbc
+*~

data/.travis.yml

@@ -4,7 +4,6 @@ rvm:
   - ree
   - ruby-head
   - rbx
-  - rbx-2.0
   - jruby
 notifications:
   disabled: true

data/Gemfile

@@ -1,11 +1,13 @@
 source "http://rubygems.org"
 
-# Specify your gem's dependencies in yaml2env.gemspec
 gemspec
 
 group :test do
   group :darwin do
     gem 'rb-fsevent'
   end
+
+  # Solving runner bug: https://github.com/guard/guard-minitest/pull/25
+  gem 'guard-minitest', :git => 'https://github.com/grimen/guard-minitest'
 end
 

data/README.textile

@@ -22,13 +22,13 @@ Add to your @Gemfile@:
 
 h2. Usage
 
-To give this some context; this is how we use @Yaml2Env@ to initialize "Hoptoad":http://hoptoadapp.com:
+To give this some context; this is how we use @Yaml2env@ to initialize "Hoptoad":http://hoptoadapp.com:
 
 <pre>
-  Yaml2Env.load! 'config/hoptoad.yml', {'HOPTOAD_API_KEY' => 'api_key'}
+  Yaml2env.require! 'config/hoptoad.yml', {'HOPTOAD_API_KEY' => 'api_key'}
 
   # ...or if a warning note in the logs is enough:
-  #   Yaml2Env.load 'config/hoptoad.yml', {'HOPTOAD_API_KEY' => 'api_key'}
+  #   Yaml2env.require 'config/hoptoad.yml', {'HOPTOAD_API_KEY' => 'api_key'}
 
   if defined?(HoptoadNotifier)
     HoptoadNotifier.configure do |config|
@@ -56,37 +56,160 @@ To give this some context; this is how we use @Yaml2Env@ to initialize "Hoptoad"
 ...which will yield:
 
 <pre>
-  # Rails.env => 'development'
-  ENV['HOPTOAD_API_KEY'] => 'NONE'
+  # For: Rails.env => 'development'
+  ENV['HOPTOAD_API_KEY']
+    => 'NONE'
 
-  # Rails.env => 'staging'
-  ENV['HOPTOAD_API_KEY'] => '123abc'
+  # For: Rails.env => 'staging'
+  ENV['HOPTOAD_API_KEY']
+    => '123abc'
 
-  # Rails.env => 'production'
-  ENV['HOPTOAD_API_KEY'] => 'abc123'
+  # For: Rails.env => 'production'
+  ENV['HOPTOAD_API_KEY']
+    => 'abc123'
 
-  # Rails.env => 'test'
-  ENV['HOPTOAD_API_KEY'] => 'NONE'
+  # For: Rails.env => 'test'
+  ENV['HOPTOAD_API_KEY']
+    => 'NONE'
 
-  # Rails.env => 'other'
-  => "Failed to load required config for environment 'other': /Users/grimen/development/example.com/config/hoptoad.yml"
+  # For: Rails.env => 'other'
+    => STDOUT: "Failed to load required config for environment 'other': /Users/grimen/development/example.com/config/hoptoad.yml"
 </pre>
 
-h2. Helpers
+h2. API
 
-A few convenient helpers:
+Being lazy and just dropping a lot of examples here.
+
+*@Yaml2env.require@*
+
+<pre>
+  # Case: If config file exists with proper keys
+  Yaml2env.require 'config/hoptoad.yml', {'HOPTOAD_API_KEY' => 'api_key'}
+    => true
+  Yaml2env.require 'config/hoptoad.yml', {'HOPTOAD_API_KEY' => 'api_key'}
+    => false + STDOUT: (already loaded warning)
+
+  # Case: If config file don't exists, or it don't contain expected setting-key(s)
+  Yaml2env.require 'config/hoptoad2.yml', {'HOPTOAD_API_KEY' => 'api_key'}
+    => false + STDOUT: (invalid file or missing key warning)
+</pre>
+
+*@Yaml2env.require!@*
+
+See above: Same as @Yaml2env.require@ but raises error instead of log warning.
+
+*@Yaml2env.load@*
+
+<pre>
+  # Case: If config file exists with proper keys
+  Yaml2env.load 'config/hoptoad.yml', {'HOPTOAD_API_KEY' => 'api_key'}
+    => true
+
+  # Case: If config file don't exists, or it don't contain expected setting-key(s)
+  Yaml2env.load 'config/hoptoad.yml', {'HOPTOAD_API_KEY' => 'api_key'}
+    => STDOUT: (warning)
+</pre>
+
+*@Yaml2env.load!@*
+
+See above: Same as @Yaml2env.require@ but raises error instead of log warning.
+
+*@Yaml2env.assert_keys@*
 
 <pre>
-  Yaml2Env.loaded? 'HOPTOAD_API_KEY'
-  => true
+  Yaml2env.assert_keys 'HOPTOAD_API_KEY'
+    => true
+
+  Yaml2env.assert_keys 'BAZOOKA'
+    => false + STDOUT: (warning)
+</pre>
+
+*@Yaml2env.assert_keys!@*
 
-  Yaml2Env.loaded? 'BAZOOKA'
-  => false
+See above: Same as @Yaml2env.assert_keys@ but raises error instead of log warning.
+
+*@Yaml2env.assert_values@*
+
+<pre>
+  Yaml2env.assert_values 'HOPTOAD_API_KEY' => /[a-z0-9]+/
+    => true
 
-  Yaml2Env.loaded? 'HOPTOAD_API_KEY', 'BAZOOKA'
-  => false
+  Yaml2env.assert_values 'HOPTOAD_API_KEY' => /[0-9]+/
+    => false + STDOUT: (warning)
+</pre>
+
+*@Yaml2env.assert_values!@*
+
+See above: Same as @Yaml2env.assert_values@ but raises error instead of log warning.
+
+*@Yaml2env.log_root@*
+
+<pre>
+  Yaml2env.log_root
+    => STDOUT: :: Yaml2env.root = '/path/to/project/root'
 </pre>
 
+*@Yaml2env.log_env@*
+
+<pre>
+  Yaml2env.log_env
+    => STDOUT: :: Yaml2env.env = 'development' (default)
+</pre>
+
+*@Yaml2env.log_values@*
+
+<pre>
+  Yaml2env.log_values
+    => STDOUT: :: ENV = {'HOPTOAD_API_KEY' => 'api_key', 'RUBY_VERSION' => 'ruby-1.9.3-p0', ...}
+
+  Yaml2env.log_values 'HOPTOAD_API_KEY'
+    => STDOUT: :: ENV = {'HOPTOAD_API_KEY' => 'api_key'}
+
+  Yaml2env.log_values 'BAZOOKA'
+    => STDOUT: :: ENV = {}
+
+  Yaml2env.log_values /RACK|MERCHII/
+    => STDOUT: :: ENV = {'RACK_ENV' => 'api_key', 'MERCHII_ASSETS_DOMAIN' => 'assets.merchii.com'}
+</pre>
+
+*@Yaml2env.detect_root!@*
+
+<pre>
+  # For: Rack, Sinatra, Rails, or Yaml2env.default_env is set
+  Yaml2env.detect_root!
+    => Yaml2env.root = '/path/to/project/root'
+
+  # For: Failed detection
+  Yaml2env.detect_root!
+    => DetectionFailedError
+</pre>
+
+*@Yaml2env.detect_env!@*
+
+<pre>
+  # For: Rack, Sinatra, Rails, or Yaml2env.default_env is set
+  Yaml2env.detect_env!
+    => Yaml2env.env = ENV['RACK_ENV']  # ...example for Rack
+
+  # For: Failed detection
+  Yaml2env.detect_env!
+    => DetectionFailedError
+
+  # For: Default environment set
+  Yaml2env.default_env = 'development'
+  Yaml2env.detect_env!
+    => Yaml2env.env = 'development'
+</pre>
+
+*@Yaml2env.loaded@*
+
+<pre>
+  Yaml2env.loaded
+    => STDOUT: '/path/to/project/root/config/hoptoad.yml' => {'HOPTOAD_API_KEY' => 'abc123'}
+</pre>
+
+There are a few more, but these are the most useful ones.
+
 h2. Notes
 
 This gem was developed for our own requirements at *"Merchii":http://github.com/merchii*, so feel free to send pull-requests with enhancements of any kind (features, bug-fixes, documentation, tests, etc.) to make it better or useful for you as well.

data/Rakefile

@@ -1,5 +1,4 @@
-require 'bundler'
-Bundler::GemHelper.install_tasks
+require 'bundler/gem_tasks'
 require 'rake/testtask'
 
 task :default => :test

data/TODO

@@ -0,0 +1,13 @@
+
+== NEXT
+
+- [feature]: Yaml2env.log_files => Array
+
+- [enhancement]: Make use of 'awesome_print' - with fallback on 'pretty_print' - without breaking Ruby specs; "ordered hash keys" issue causes pain here so disabled it temporarily to get a green build.
+
+
+== WOULD-BE-NICE
+
+- [review]: Find out best practice for testing Pathname vs. String like this: Pathname.new("/tmp") == "/tmp"
+
+- [spec]: Find out why many specs fail when Yaml2env.env is a ActiveSupport::StringInquirer - works in Rails.

data/lib/yaml2env/version.rb

@@ -1,3 +1,3 @@
 module Yaml2env
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/lib/yaml2env.rb

@@ -1,5 +1,15 @@
 require 'yaml'
 require 'logger'
+require 'active_support/string_inquirer'
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/ordered_hash'
+require 'active_support/core_ext/object/blank'
+require 'pp'
+begin
+  require 'awesome_print'
+rescue LoadError
+  # optional
+end
 
 module Yaml2env
 
@@ -8,6 +18,9 @@ module Yaml2env
   class Error < ::StandardError
   end
 
+  class ArgumentError < ::ArgumentError
+  end
+
   class DetectionFailedError < Error
   end
 
@@ -17,6 +30,18 @@ module Yaml2env
   class MissingConfigKeyError < Error
   end
 
+  class InvalidConfigValueError < Error
+  end
+
+  class InvalidRootError < ArgumentError
+  end
+
+  class AlreadyLoadedError < Error
+  end
+
+  class HumanError < Error
+  end
+
   # Hash tracking all of the loaded ENV-values via Yaml2env.load.
   LOADED_ENV = {}
 
@@ -32,15 +57,51 @@ module Yaml2env
   # Default: +::Logger.new(::STDOUT)+
   @@logger = ::Logger.new(::STDOUT)
 
+  # Loaded files and their values.
+  @@loaded = {}
+
+  # Default env.
+  @@default_env = nil
+
   class << self
 
-    [:root, :env, :logger].each do |name|
+    [:default_env, :logger].each do |name|
       define_method name do
-        class_variable_get "@@#{name}"
+        class_variable_get :"@@#{name}"
+      end
+      define_method :"#{name}=" do |value|
+        class_variable_set :"@@#{name}", value
       end
-      define_method "#{name}=" do |value|
-        class_variable_set "@@#{name}", value
+    end
+
+    define_method :'root' do
+      class_variable_get :'@@root'
+    end
+    define_method :'root=' do |value|
+      if value.present?
+        value = File.expand_path(value) rescue value
+        value = Pathname.new(value) rescue value
+        # FIXME: Makes sense, but need to rewrite specs somewhat - later.
+        # if Dir.exists?(value)
+        #   value = Pathname.new(value).expand_path
+        # else
+        #   raise InvalidRootError, "Trying to set Yaml2env.root to a path that don't exists: #{value.inspect}. Yaml2env.root must point to existing path."
+        # end
       end
+      class_variable_set :'@@root', value
+    end
+
+    define_method :'env' do
+      class_variable_get :'@@env'
+    end
+    define_method :'env=' do |value|
+      # FIXME: Specs "Yaml2env.env.must_equal" fails in really weird way with this line enabled.
+      # value = ActiveSupport::StringInquirer.new(value.to_s) unless value.is_a?(ActiveSupport::StringInquirer)
+      class_variable_set :'@@env', value
+    end
+
+    define_method :'loaded' do
+      class_variable_get :'@@loaded'
     end
 
     alias :environment :env
@@ -49,6 +110,8 @@ module Yaml2env
       @@root ||= nil
       @@env ||= nil
       @@logger ||= ::Logger.new(::STDOUT)
+      @@loaded ||= {}
+      @@default_env ||= nil
     end
 
     def configure
@@ -62,7 +125,9 @@ module Yaml2env
       config ||= {}
 
       begin
-        config_path = File.expand_path(File.join(self.root, config_path)).to_s
+        unless File.exists?(config_path)
+          config_path = File.expand_path(File.join(self.root, config_path)).to_s
+        end
         config = self.load_config_for_env(config_path, self.env)
       rescue
         raise ConfigLoadingError, "Failed to load required config for environment '#{self.env}': #{config_path}"
@@ -70,31 +135,62 @@ module Yaml2env
 
       # Merge required + optional keys.
       keys_values = optional_keys.merge(required_keys)
+      loaded_key_values = ActiveSupport::OrderedHash.new
 
       # Stash found keys from the config into ENV.
       keys_values.each do |extected_env_key, extected_yaml_key|
-        ::Yaml2env::LOADED_ENV[extected_env_key.to_s] = ::ENV[extected_env_key.to_s] = config[extected_yaml_key.to_s]
-        self.logger.info ":: ENV[#{extected_env_key.inspect}] = #{::ENV[extected_env_key.to_s].inspect}" if self.logger?
+        config_value = config[extected_yaml_key.to_s]
+        ::Yaml2env::LOADED_ENV[extected_env_key.to_s] = ::ENV[extected_env_key.to_s] = config_value
+        info ":: ENV[#{extected_env_key.inspect}] = #{::ENV[extected_env_key.to_s].inspect}"
       end
 
+      self.loaded[config_path] = config
+
       # Raise error if any credentials are missing.
       required_keys.keys.each do |env_key|
         ::Yaml2env::LOADED_ENV[env_key.to_s] ||
           raise(MissingConfigKeyError, "ENV variable '#{env_key}' needs to be set. Query: #{keys_values.inspect}. Found: #{config.inspect}")
       end
+
+      true
     end
 
     def load(config_path, required_keys = {}, optional_keys = {})
+      args = [config_path, required_keys, optional_keys]
+
       begin
         self.load!(config_path, required_keys, optional_keys)
       rescue Error => e
-        if self.logger?
-          ::Yaml2env.logger.warn("[Yaml2env]: #{e} -- called from: #{__FILE__})")
-        end
+        warn "[Yaml2env]: #{e} -- arguments: #{args.inspect})"
       end
       true
     end
 
+    public # force public - we are overriding private Ruby method here, but should be all good in the hood. >:)
+
+    def require!(config_path, required_keys = {}, optional_keys = {})
+      self.detect_root!
+      config_path = File.expand_path(File.join(self.root, config_path)).to_s
+      raise AlreadyLoadedError, "Already loaded:" if self.loaded_files.include?(config_path)
+      self.load!(config_path, required_keys, optional_keys)
+    end
+
+    def require(*args)
+      begin
+        self.require!(*args)
+        true
+      rescue AlreadyLoadedError => e
+        false
+      rescue Error => e
+        warn "[Yaml2env]: #{e} -- arguments: #{args.inspect})"
+        false
+      end
+    end
+
+    def loaded_files
+      self.loaded.keys
+    end
+
     def loaded?(*constant_names)
       constant_names.all? { |cn| ::Yaml2env::LOADED_ENV.key?(cn.to_s) }
     end
@@ -112,14 +208,16 @@ module Yaml2env
     end
 
     def detect_env!
-      self.env ||= if ::ENV.key?('RACK_ENV')
+      self.env ||= if ::ENV['RACK_ENV'].present?
         ::ENV['RACK_ENV']
       elsif defined?(::Rails)
         ::Rails.env
       elsif defined?(::Sinatra::Application)
         ::Sinatra::Application.environment
+      elsif self.default_env.present?
+        self.default_env
       else
-        raise DetectionFailedError, "Failed to auto-detect Yaml2env.root (config root). Specify environment before loading any configs/initializers using Yaml2env, e.g. Yaml2env.env = 'development'."
+        raise DetectionFailedError, "Failed to auto-detect Yaml2env.env (config environment). Specify environment before loading any configs/initializers using Yaml2env, e.g. Yaml2env.env = 'development'."
       end
     end
 
@@ -127,7 +225,142 @@ module Yaml2env
       self.logger.respond_to?(:info)
     end
 
+    def root?
+      self.root.present?
+    end
+
+    def env?(*args)
+      if args.size > 0
+        raise HumanError, "Seriously, what are you trying to do? *<:)" if args.size > 1 && args.count { |a| a.blank? } > 1
+        args.any? do |arg|
+          arg.is_a?(Regexp) ? self.env.to_s =~ arg : self.env.to_s == arg.to_s
+        end
+      else
+        self.env.present?
+      end
+    end
+
+    def default_env?
+      self.env == self.default_env
+    end
+
+    def log_env
+      value = self.env.inspect
+      output = ":: Yaml2env.env = #{value}"
+      output << " (default)" if self.default_env? && self.default_env.present?
+      puts output
+    end
+
+    def log_root
+      value = self.root.present? ? self.root.to_s.inspect : self.root.inspect
+      output = ":: Yaml2env.root = #{value}"
+      puts output
+    end
+
+    def log_values(*args)
+      if args.blank?
+        should_include = proc { true }
+      elsif args.first.is_a?(Regexp)
+        key_pattern = args.shift
+        should_include = proc { |key| key =~ key_pattern }
+      else
+        should_include = proc { |key| args.any? { |key_string| key == key_string; }  }
+      end
+      key_values = {}
+      ::ENV.keys.sort.each do |k,v|
+        key_values[k] = ENV[k] if should_include.call(k)
+      end
+      print ":: ENV = "
+      puts format_output key_values
+    end
+
+    def assert_keys!(*required_keys)
+      raise ArgumentError, "Expected ENV-keys, but got: #{required_keys.inspect}" if required_keys.blank?
+      raise ArgumentError, "Expected ENV-keys, but got: #{required_keys.inspect}" unless required_keys.first.is_a?(String) || required_keys.first.is_a?(Symbol)
+
+      required_keys = required_keys.collect { |k| k.to_s }
+      missing_keys = required_keys - ::ENV.keys
+
+      if missing_keys.size == 0
+        true
+      else
+        raise MissingConfigKeyError, "Assertion failed, no such ENV-keys loaded: #{missing_keys}"
+      end
+    end
+
+    def assert_keys(*required_keys)
+      begin
+        self.assert_keys!(*required_keys)
+        true
+      rescue Error => e
+        print "[Yaml2env] WARN: Assertion failed, no such ENV-keys loaded: "
+        puts format_output required_keys
+        false
+      end
+    end
+
+    def assert_values!(key_values)
+      raise ArgumentError, "Expected hash, but got: #{key_values.inspect}" unless key_values.is_a?(Hash) && key_values.present?
+      raise ArgumentError, "Expected hash with string-regexp values, but got: #{key_values.inspect}" unless key_values.all? { |k, v| v.is_a?(Regexp) }
+
+      self.assert_keys! *key_values.keys
+
+      failed_assertions = {}
+
+      key_values.each do |k, v|
+        k = k.to_s
+        failed_assertions[k] = ::ENV[k] unless ::ENV[k] =~ v
+      end
+
+      if failed_assertions.keys.size == 0
+        true
+      else
+        raise InvalidConfigValueError, "Assertion failed, invalid values: #{failed_assertions}"
+      end
+    end
+
+    def assert_values(key_values)
+      begin
+        self.assert_values!(key_values)
+        true
+      rescue Error => e
+        print "[Yaml2env] WARN: Assertion failed, invalid values: "
+        puts format_output key_values
+        false
+      end
+    end
+
     protected
+
+      # Work around helpers to make output specs pass on different Ruby version (ordered hash problem). Grrr...
+      def format_output(array_or_hash)
+        if array_or_hash.is_a?(Array)
+          array_or_hash.collect(&:to_s).sort.collect { |k| "#{k.inspect}" }.join(", ")
+        elsif array_or_hash.is_a?(Hash)
+          array_or_hash = ActiveSupport::HashWithIndifferentAccess.new(array_or_hash)
+          array_or_hash.keys.collect(&:to_s).sort.collect { |k| "#{k.inspect} => #{array_or_hash[k].inspect}" }.join(", ")
+        end
+      end
+
+      def pretty(*args)
+        begin
+          ap *args
+        rescue
+          pp *args
+        end
+      end
+
+      def info(message)
+        self.logger.info message if self.logger?
+        # puts message
+      end
+
+      # FIXME: Should show filepath for calle.
+      def warn(message)
+        self.logger.warn(message) if self.logger?
+        # puts message
+      end
+
       def load_config(config_file)
         YAML.load(File.open(config_file))
       end
@@ -136,6 +369,7 @@ module Yaml2env
         config = self.load_config(config_file)
         config[env]
       end
+
   end
 
 end

data/spec/fixtures/example2.yml

@@ -0,0 +1,19 @@
+development:
+  api_key: DEVELOPMENT_KEY_2
+  api_secret: DEVELOPMENT_SECRET_2
+
+staging:
+  api_key: STAGING_KEY_2
+  api_secret: STAGING_SECRET_2
+
+production:
+  api_key: PRODUCTION_KEY_2
+  api_secret: PRODUCTION_SECRET_2
+
+test:
+  api_key: TEST_KEY_2
+  api_secret: TEST_SECRET_2
+
+nyan_cat_mode:
+  api_key: NYAN_CAT_MODE_KEY_2
+  api_secret: NYAN_CAT_MODE_SECRET_2

data/spec/spec_helper.rb

@@ -1,16 +1,61 @@
 # -*- encoding: utf-8 -*-
-require 'rubygems'
-require 'bundler'
-Bundler.require
-
 require 'minitest/autorun'
 require 'minitest/unit'
 require 'minitest/spec'
 require 'minitest/pride'
 require 'minitest/mock'
+require 'mocha'
 
 require 'yaml2env'
 
+def rack!(loaded)
+  if loaded
+    ::ENV['RACK_ROOT'] = '/home/grimen/development/rack_app'
+    ::ENV['RACK_ENV'] = 'rack_env'
+  else
+    ::ENV['RACK_ROOT'] = nil
+    ::ENV['RACK_ENV'] = nil
+  end
+end
+
+def rails!(loaded)
+  if loaded
+    eval <<-EVAL
+      unless defined?(::Rails)
+        module ::Rails
+          class << self
+            attr_accessor :root, :env
+          end
+        end
+      end
+    EVAL
+    Rails.root = '/home/grimen/development/rails_app'
+    Rails.env = 'rails_env'
+  else
+    Object.send(:remove_const, :Rails) if defined?(::Rails)
+  end
+end
+
+def sinatra!(loaded)
+  if loaded
+    eval <<-EVAL
+    unless defined?(::Sinatra::Application)
+      module ::Sinatra
+        class Application
+          class << self
+            attr_accessor :root, :environment
+          end
+        end
+      end
+    end
+    EVAL
+    Sinatra::Application.root = '/home/grimen/development/sinatra_app'
+    Sinatra::Application.environment = 'sinatra_env'
+  else
+    Object.send(:remove_const, :Sinatra) if defined?(::Sinatra::Application)
+  end
+end
+
 def silence_all_warnings
   # Ruby 1.8: Kernel.silence_warnings { yield }
   old_verbose = $VERBOSE