yacht 0.1.2 → 0.2.0

data/.gitignore

@@ -1,4 +1,7 @@
 coverage
+tmp
+doc
+.yardoc
 *.gem
 .DS_Store
 Gemfile.lock

data/.yardopts

@@ -0,0 +1,6 @@
+--title "Yacht: Yet Another Configuration Helper Tool"
+--no-private
+lib/**/*.rb
+Gemfile
+features//*.feature
+features//*.rb

data/Gemfile

@@ -2,4 +2,6 @@ source :rubygems
 
 gemspec
 
-gem 'rake'
+gem 'rake'
+gem 'ruby-debug19', :platform => :ruby_19
+gem 'ruby-debug', :platform => :ruby_18

data/README.rdoc

@@ -4,6 +4,7 @@ Yacht is an application configuration gem that lets you define settings for mult
 * use of ClassyStruct for improved performance over OpenStruct
 * protection of sensitive settings by specifying a whitelist in a YAML file
 * easy override of nested keys (not pretty with YAML references)
+* no need for an initializer or constant to store loaded values (just use Yacht.my_key)
 
 == Installation
 
@@ -39,8 +40,13 @@ First create two (or more) YAML files in the same directory to define your setti
 
     # config/yacht/whitelist.yml (required)
     # any keys specified here can be used as a whitelist filter:
-    #   YachtLoader.to_hash(:apply_whitelist? => true)
+    #   Yacht::Loader.to_hash(:apply_whitelist? => true)
+    #   or
+    #   Yacht::Loader.to_classy_struct(:apply_whitelist? => true)
     #   (by default the whitelist is ignored)
+    # NOTE: the whitelist is ignored when using Yacht.my_key or Yacht['my_key']
+    #       you have to use Yacht::Loader#to_hash or
+    #       Yacht::Loader#to_classy_struct to use the whitelist
     - super_secret_info
 
     # config/yacht/local.yml (optional)
@@ -49,28 +55,16 @@ First create two (or more) YAML files in the same directory to define your setti
     production:
       cdn_host: localhost
 
-=== Step 2: Define a constant
+=== Step 2: Use Yacht.my_key or Yacht['my_key']
 
 * <b>Rails</b>:
-    # config/initializers/01_yacht.rb
-    # Define a constant that will store all settings
-    # looks for the following YAML files:
-    #   * config/yacht/base.yml
-    #   * config/yacht/local.yml
-    #   * config/yacht/whitelist.yml
-    Yacht = YachtLoader.to_classy_struct
     # now you can access any key set in your YAML files with:
     #   Yacht.my_key
 
-* Outside of rails, you need to tell +YachtLoader+ where your YAML files are stored, and what environment you want to use.
-    YachtLoader.dir          = '/path/to/YAML/dir'
-    YachtLoader.environment  = 'my_environment'
-    Yacht                    = YachtLoader.to_classy_struct
-
-
-== How it works
-
-Currently, the +Yacht+ gem defines a class called +YachtLoader+ that will read your YAML files and output them as a regular +Hash+ or a +ClassyStruct+ . Then you use <tt>YachtLoader#to_classy_struct</tt> (or <tt>YachtLoader#to_hash</tt>) to define a constant. You can name the constant whatever you like, but you should use +Yacht+. This is because a planned feature is to have +Yacht+ defined when the gem is required and have everything namespaced under a single +Yacht+ class.
+* Outside of rails, you need to tell +Yacht+ where your YAML files are stored, and what environment you want to use.
+    Yacht::Loader.dir          = '/path/to/YAML/dir'
+    Yacht::Loader.environment  = 'my_environment'
+    Yacht.my_key
 
 == License
 

data/Rakefile

@@ -6,4 +6,4 @@ Bundler::GemHelper.install_tasks
 
 Dir['gem_tasks/**/*.rake'].each { |rake| load rake }
 
-task :default => [:spec]
+task :default => [:spec, :features]

data/features/load.feature

@@ -0,0 +1,80 @@
+Feature: Load configuration settings
+  In order to organize my configuration settings
+  As a developer using Yacht
+  I want to load configuration settings from an external source like a YAML file
+
+  Background:
+    Given a file named "base.yml" with:
+    """
+    default:
+      :api_key: some_fake_key
+      :partner_sites:
+        - twitter
+        - github
+      :mail:
+        :host: localhost
+        :from: Our great company
+    development:
+      :api_key: some_development_key
+    production:
+      :api_key: the_real_mccoy
+      :partner_sites:
+        - facebook
+      :mail:
+        host: example.com
+        reply-to: info@example.com
+    """
+
+  Scenario: Load from YAML
+    When I load Yacht with environment: "development"
+    Then Yacht should contain the following hash:
+      """
+        {
+          :api_key       =>  'some_development_key',
+          :partner_sites =>  [
+                                'twitter',
+                                'github'
+                              ],
+          :mail          =>  {
+                                :host => 'localhost',
+                                :from => 'Our great company'
+                              }
+        }
+      """
+
+  Scenario: Local overrides with local.yml
+    Given a file named "local.yml" with:
+      """
+      :api_key: some_crazy_local_key
+      """
+      When I load Yacht with environment: "development"
+      Then Yacht should contain the following hash:
+        """
+          {
+            :api_key       =>  'some_crazy_local_key',
+            :partner_sites =>  [
+                                  'twitter',
+                                  'github'
+                                ],
+            :mail          =>  {
+                                  :host => 'localhost',
+                                  :from => 'Our great company'
+                                }
+          }
+        """
+
+  Scenario: Whitelisting with whitelist.yml
+  Given a file named "whitelist.yml" with:
+    """
+    - :partner_sites
+    """
+    When I define the constant "MyYacht" with environment: "development" using a whitelist
+    Then the constant "MyYacht" should contain the following hash:
+      """
+        {
+          :partner_sites =>  [
+                                'twitter',
+                                'github'
+                              ]
+        }
+      """

data/features/missing_yaml_files.feature

@@ -0,0 +1,30 @@
+Feature: Handle missing YAML files reasonably
+  In order to ensure robustness and correctness of data
+  Missing YAML files should cause an error to be raised when reasonable
+
+  Background:
+    Given a file named "base.yml" with:
+    """
+    development:
+      api_key: some_fake_key
+    """
+
+  Scenario: No base.yml
+    Given a file named "base.yml" does not exist
+    When I try to use Yacht
+    Then Yacht should raise an error with message: "Couldn't load base config"
+
+  Scenario: No local.yml
+    Given a file named "local.yml" does not exist
+    When I try to use Yacht
+    Then Yacht should not raise an error
+
+  Scenario: No whitelist.yml but whitelist not used
+    Given a file named "whitelist.yml" does not exist
+    When I try to use Yacht
+    Then Yacht should not raise an error
+
+  Scenario: No whitelist.yml and whitelist used
+    Given a file named "whitelist.yml" does not exist
+    When I try to use Yacht with a whitelist
+    Then Yacht should raise an error with message: "Couldn't load whitelist"

data/features/step_definitions/aruba_extension_steps.rb

@@ -0,0 +1,5 @@
+Given /^a file named "([^"]*)" does not exist$/ do |file_name|
+  in_current_dir do
+    FileUtils.rm(file_name) if File.file?(file_name)
+  end
+end

data/features/step_definitions/error_handling_steps.rb

@@ -0,0 +1,27 @@
+Then /^Yacht should raise an error with message: "([^"]*)"$/ do |message|
+  @last_yacht.class.should be(Yacht::LoadError)
+  @last_yacht.message.should == message
+end
+
+When /^I try to use Yacht( with a whitelist)?$/ do |whitelist|
+  @last_yacht = use_yacht(!!whitelist)
+end
+
+Then /^Yacht should not raise an error$/ do
+  @last_yacht.class.should_not <= Exception
+end
+
+module ErrorHandlingHelpers
+  # Try to use Yacht and return output of Yacht#to_classy_struct if no error raised
+  # If an error is raised, return it instead
+  def use_yacht(whitelist=false)
+    in_current_dir do
+      Yacht::Loader.dir = '.'
+      Yacht::Loader.environment = 'development'
+      Yacht::Loader.to_classy_struct(:apply_whitelist? => whitelist)
+    end
+  rescue Exception => e
+    e
+  end
+end
+World(ErrorHandlingHelpers)

data/features/step_definitions/loader_steps.rb

@@ -0,0 +1,28 @@
+When /^I define the constant "([^"]*)" with environment: "([^"]*)"( using a whitelist)?$/ do |constant_name, env, whitelist|
+  in_current_dir do
+    Yacht::Loader.dir = '.'
+    Yacht::Loader.environment = env
+    Object.const_set( constant_name, Yacht::Loader.to_classy_struct(:apply_whitelist? => whitelist ) )
+  end
+end
+
+
+Then /^the constant "([^"]*)" should contain the following hash:$/ do |constant_name, stringified|
+  hash = eval(stringified)
+  Object.const_get(constant_name).to_hash.should == hash # don't forget to tack on to_hash to avoid weird errors
+                                                         # TODO: make ClassyStruct more Hash-like so
+                                                         # i t can be compared against hashes using `==`
+end
+
+When /^I load Yacht with environment: "([^"]*)"$/ do |env|
+  Yacht::Loader.dir = '.'
+  Yacht::Loader.environment = env
+end
+
+Then /^Yacht should contain the following hash:$/ do |stringified|
+  hash = eval(stringified)
+
+  in_current_dir do
+    Yacht::Loader.to_hash.should == hash
+  end
+end

data/features/support/cleanup.rb

@@ -0,0 +1,9 @@
+After do
+  Yacht::Loader.environment = nil
+  Yacht::Loader.dir         = nil
+
+  Yacht::Loader.instance_variable_set(:@config_file_names, nil)
+  Yacht::Loader.instance_variable_set(:@classy_struct_instance, nil)
+
+  Yacht.instance_variable_set(:@_loader, nil)
+end

data/features/support/env.rb

@@ -0,0 +1,4 @@
+$:.unshift(File.dirname(__FILE__) + '/../../lib')
+
+require 'aruba/cucumber'
+require 'yacht'

data/gem_tasks/cucumber.rake

@@ -0,0 +1,5 @@
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new(:features) do |t|
+  t.fork = false
+end

data/lib/yacht/base.rb

@@ -0,0 +1,14 @@
+class Yacht < BasicObject
+  class LoadError < ::StandardError
+  end
+
+  class << self
+    def [](key)
+      self._hash[key]
+    end
+
+    def _hash
+      @_hash ||= Loader.to_hash
+    end
+  end
+end

data/lib/yacht/classy_struct.rb

@@ -0,0 +1,32 @@
+require 'classy_struct'
+
+class Yacht < BasicObject
+  class Loader
+    class << self
+      def classy_struct_instance
+        @classy_struct_instance ||= ClassyStruct.new
+      end
+
+      def to_classy_struct(opts={})
+        classy_struct_instance.new( self.to_hash(opts) )
+      rescue StandardError => e
+        # don't do anything to our own custom errors
+        if e.is_a? Yacht::LoadError
+          raise e
+        else
+          raise Yacht::LoadError.new("Error creating ClassyStruct: #{e.message}")
+        end
+      end
+    end
+  end
+
+  class << self
+    def method_missing(method, *args, &block)
+      _classy_struct.send(method)
+    end
+
+    def _classy_struct
+      @_classy_struct ||= Loader.to_classy_struct
+    end
+  end
+end

data/lib/{yacht_loader/base.rb → yacht/loader.rb}

@@ -1,9 +1,6 @@
 # TODO: Rename YachtLoader to Yacht and somehow incorporate ClassyStruct
 
-class YachtLoader
-  class LoadError < StandardError
-  end
-
+class Yacht::Loader
   class << self
     def environment
       @environment ||= 'default'
@@ -20,7 +17,7 @@ class YachtLoader
     end
 
     def config_file_for(config_type)
-      raise LoadError.new "#{config_type} is not a valid config type" unless valid_config_types.include?(config_type.to_s)
+      raise Yacht::LoadError.new "#{config_type} is not a valid config type" unless valid_config_types.include?(config_type.to_s)
 
       full_file_path_for_config(config_type)
     end
@@ -34,7 +31,7 @@ class YachtLoader
     end
 
     def to_hash(opts={})
-     opts[:apply_whitelist?] = false unless opts.has_key?(:apply_whitelist?)
+     opts[:apply_whitelist?] ||= false unless opts.has_key?(:apply_whitelist?)
      self.environment = opts[:env] if opts.has_key?(:env)
 
      if opts[:apply_whitelist?]
@@ -45,60 +42,47 @@ class YachtLoader
    end
 
     def whitelist
-      load_config_file(:whitelist, :expect_to_load => Array) || begin
-        raise LoadError.new("Couldn't load whitelist")
-      end
+      load_config_file(:whitelist, :expect_to_load => Array) || raise( Yacht::LoadError.new("Couldn't load whitelist") )
     end
 
     def base_config
-      load_config_file(:base) || begin
-        raise LoadError.new("Couldn't load base config")
-      end
+      load_config_file(:base) || raise( Yacht::LoadError.new("Couldn't load base config") )
     end
 
     def local_config
-      load_config_file(:local, :require_presence? => false) || {}
+      load_config_file(:local) || {}
     end
 
   protected
+    # Wrap the YAML.load for easier mocking
+    def _load_config_file(file_name)
+      YAML.load( File.read(file_name) ) if File.exists?(file_name)
+    end
+
+    # Load a config file with plenty of error-checking
     def load_config_file(file_type, opts={})
       # by default, expect a Hash to be loaded
       expected_class    = opts[:expect_to_load] || Hash
 
-      # by default, raise error if file missing or empty
-      presence_required = if opts.has_key?(:require_presence?)
-                            opts[:require_presence?]
-                          else
-                            true
-                          end
-
       file_name = self.config_file_for(file_type)
-
-      loaded =  if File.exists?(file_name)
-                  YAML.load( File.read(file_name) )
-                else
-                  nil
-                end
-
-      # an empty YAML file will be converted to boolean false
-      raise LoadError.new "#{file_name} cannot be empty" if presence_required && loaded === false
+      loaded    = self._load_config_file(file_name)
 
       # YAML contained the wrong type
-      raise LoadError.new "#{file_name} must contain #{expected_class} (got #{loaded.class})" if loaded && !loaded.is_a?(expected_class)
+      raise Yacht::LoadError.new "#{file_name} must contain #{expected_class} (got #{loaded.class})" if loaded && !loaded.is_a?(expected_class)
 
       loaded
     rescue => e
       # don't do anything to our own custom errors
-      if e.is_a? YachtLoader::LoadError
+      if e.is_a? Yacht::LoadError
         raise e
       else
-        # convert other errors to YachtLoader::LoadError
-        raise LoadError.new "ERROR: loading config file: '#{file_type}': #{e}"
+        # convert other errors to YachtLoader::Yacht::LoadError
+        raise Yacht::LoadError.new "ERROR: loading config file: '#{file_type}': #{e}"
       end
     end
 
     def chain_configs(config, env)
-      raise LoadError.new "environment '#{env}' does not exist" unless config.has_key?(env)
+      raise Yacht::LoadError.new "environment '#{env}' does not exist" unless config.has_key?(env)
 
       parent = if config[env]['_parent']
                  chain_configs(config, config[env]['_parent'])
@@ -109,4 +93,8 @@ class YachtLoader
       parent.deep_merge(config[env])
     end
   end
-end
+
+end
+
+# Alias for Yacht::Loader for backwards compatibility
+Object.const_set(:YachtLoader, Yacht::Loader)

data/lib/{yacht_loader → yacht}/rails.rb

@@ -1,4 +1,4 @@
-class YachtLoader
+class Yacht::Loader
   class << self
     # use the current rails environment by default
     def environment

data/lib/yacht/version.rb

@@ -0,0 +1,3 @@
+class Yacht < BasicObject
+  VERSION = "0.2.0"
+end

data/lib/yacht.rb

@@ -1,12 +1,7 @@
-# This file is named yacht.rb 
-# so that Bundler will automatically load YachtLoader
-#
-# In the future, once we figure out how to integrate ClassyStruct,
-# YachtLoader will be renamed to Yacht
+require "yacht/base"
+require "yacht/loader"
+require "yacht/classy_struct"
+require "yacht/version"
 
-require "yacht_loader/base"
-require "yacht_loader/classy_struct"
-require "yacht_loader/version"
-
-require "yacht_loader/rails" if Object.const_defined?(:Rails)
-require 'monkeypatches/hash'
+require "yacht/rails" if Object.const_defined?(:Rails)
+require 'monkeypatches/hash'

data/spec/spec_helper.rb

@@ -15,101 +15,8 @@ require 'yacht'
 
 RSpec.configure do |config|
   config.after :each do
-    YachtLoader.environment = nil
-    YachtLoader.dir         = nil
-    YachtLoader.instance_variable_set(:@config_file_names, nil)
-  end
-end
-
-BASE_CONFIG_FILE = <<EOF
-default:
-  name: default
-  defaultkey: defaultvalue
-  dog: schnauzer
-  hashkey:
-    foo: bar
-    baz: wurble
-    xyzzy: thud
-an_environment:
-  name: an_environment
-  hashkey:
-    baz: yay
-  dog: terrier
-a_child_environment:
-  _parent: an_environment
-  name: a_child_environment
-  hashkey:
-    foo: kung
-test:
-  baloney: delicious
-EOF
-
-WHITELIST_CONFIG_FILE = <<EOF
-- defaultkey
-- hashkey
-EOF
-
-EMPTY_WHITELIST_CONFIG_FILE = <<EOF
-EOF
-
-INVALID_WHITELIST_CONFIG_FILE = <<EOF
-somenonsenseorother
-EOF
-
-LOCAL_CONFIG_FILE = <<EOF
-localkey: localvalue
-EOF
-
-EMPTY_LOCAL_CONFIG_FILE = <<EOF
-EOF
-
-INVALID_LOCAL_CONFIG_FILE = <<EOF
-someinvalidstufforother
-EOF
-
-
-# ===================================
-# = Helpers to mock file operations =
-# ===================================
-def banish_config_file_from_prefix(prefix)
-  file_name = YachtLoader.config_file_for(prefix)
-  banish_file(file_name)
-end
-
-# shortcut to mock config file
-def conjure_config_file_from_prefix(prefix, file_contents=nil)
-  file_name     = YachtLoader.config_file_for(prefix)
-  file_contents ||= "#{prefix.upcase}_CONFIG_FILE".constantize
-
-  conjure_file(file_name, file_contents)
-end
-
-def conjure_bad_config_file_from_prefix(prefix)
-  file_name     = "#{prefix}_config_file"
-  file_contents = file_name.upcase.constantize
-
-  conjure_file(file_name, file_contents)
-end
-
-# mock file existence & contents
-def conjure_file(file_name, file_contents)
-  File.stub!(:exists?).with(file_name).and_return true
-  File.stub!(:read).with(file_name).and_return file_contents
-end
-
-# mock file non-existence
-def banish_file(file_name)
-  File.stub!(:exists?).with(file_name).and_return(false)
-  File.stub!(:read).with(file_name).and_raise Errno::ENOENT.new("No such file or directory - #{file_name}")
-end
-
-# ================================================
-# = Railsy helper to turn strings into constants =
-# ================================================
-if !String.instance_methods.include?(:constantize)
-  class String
-    def constantize   # NOT as awesome as ActiveSupport::Inflector#constantize
-      Object.const_get(self)
-    end
+    Yacht::Loader.environment = nil
+    Yacht::Loader.dir         = nil
+    Yacht::Loader.instance_variable_set(:@config_file_names, nil)
   end
 end

data/spec/yacht/base_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Yacht do
+  subject { Yacht }
+
+  describe :[] do
+    it "should retrieve value of key from Yacht::Loader.to_hash" do
+      mock_hash = {}
+
+      Yacht::Loader.should_receive(:to_hash).and_return(mock_hash)
+      mock_hash.should_receive(:[]).with(:foo)
+
+      subject[:foo]
+    end
+  end
+end