dotlocal 0.0.2

data/.gitignore

@@ -0,0 +1,5 @@
+.rspec
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in ..gemspec
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/dotlocal.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dot_local/version"
+
+Gem::Specification.new do |s|
+  s.name        = "dotlocal"
+  s.version     = DotLocal::VERSION
+  s.authors     = ["Fabrizio Regini"]
+  s.email       = ["freegenie@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{DotLocal, for versionable config files}
+  s.description = %q{DotLocal helps in managing config files providing ability to define a local version to override settings}
+
+  s.rubyforge_project = "."
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/lib/dot_local.rb

@@ -0,0 +1,28 @@
+require 'yaml'
+require 'dot_local/configuration'
+require 'dot_local/mapper' 
+require 'dot_local/version'
+
+module DotLocal
+  class ParsingError < Exception ; end
+  class MissingFile < Exception ; end
+  class KeyNotFound < Exception ; end
+  class DoubleLoad < Exception ; end
+  class ReservedKey < Exception ; end
+  class BlankValue < Exception ; end
+
+  class << self
+    def deep_merge!(winner, looser)
+      merger = proc do |key,winner,looser|
+        if Hash === winner && Hash === looser
+          winner.merge(looser, &merger)
+        else
+          winner.to_s == '' ? looser : winner
+        end
+      end
+
+      winner.merge!(looser, &merger)
+      winner
+    end
+  end
+end

data/lib/dot_local/configuration.rb

@@ -0,0 +1,112 @@
+module DotLocal
+  class Configuration
+
+    SettingsFileName = 'settings.yml'
+    LocalSuffix = 'local'
+    
+    ReservedKeys = %w(env path file_name local_file_name raw)
+
+    attr_accessor :env, :path, :file_name, :local_file_name, :raw
+
+    def initialize(options={}) 
+      @path = options.delete :path
+      @file_name = options.delete :file_name
+      @local_file_name = options.delete :local_file_name
+      @env = options.delete :env
+
+      @path = File.expand_path('..', __FILE__) if @path.nil?
+      @file_name ||= SettingsFileName
+      @local_file_name ||= interpolate_local_filename
+    end
+    
+    def method_missing(*args)
+      super unless args.size == 1
+      key = args.first.to_s 
+      if Mapper.key_is_hash?(@raw, key) 
+        Mapper.new(self, key)
+      else 
+        Mapper.fetch(@raw, key)
+      end
+    end
+
+    def reload!
+      @loaded = false
+      self.load!
+    end
+
+    def load!
+      raise DotLocal::DoubleLoad if @loaded 
+      @loaded = true
+      @raw = parse(file_name)
+      @parsed = @raw
+      @raw = @raw.fetch(@env.to_s) unless @env.nil?
+
+      merge_with_local! if local_exists?
+      
+      validate_blank_values! 
+      validate_reserved_keys! 
+      
+      @raw.freeze
+    end
+
+    private
+
+    def merge(first, second)
+
+    end
+
+    def local_exists?
+      File.exists?(File.join(path, local_file_name))
+    end
+
+    def recursive_find_blank_values(key,value)
+      if value.is_a?(Hash)
+        value.each do |key,value| 
+          recursive_find_blank_values(key,value)
+        end
+      else
+        if value.to_s == ''
+          raise BlankValue.new("Blank value found for key #{key}")
+        end
+      end
+    end
+
+    def validate_blank_values!
+      @raw.each do |key,value|
+        recursive_find_blank_values(key,value)
+      end
+    end
+
+    def validate_reserved_keys!
+      ReservedKeys.each do |key| 
+        if @raw.keys.map(&:to_s).include? key
+          raise DotLocal::ReservedKey.new("Reserved #{key} found")
+        end
+      end
+    end
+
+    def parse(file_name)
+      file = File.read(File.join(path, file_name).to_s)
+      yaml = YAML.load(file)
+      raise unless yaml.is_a? Hash
+      yaml
+
+    rescue Errno::ENOENT
+      raise DotLocal::MissingFile.new("File #{file} not found")
+    rescue => e 
+      raise ParsingError.new(e.message)
+    end
+
+    def interpolate_local_filename
+      ext = File.extname(@file_name)
+      "#{@file_name.gsub(ext, '')}.#{LocalSuffix}#{ext}"
+    end
+
+    def merge_with_local!
+      local_hash = parse(local_file_name)
+      local_hash = local_hash.fetch(@env.to_s) unless @env.nil?
+      @raw = DotLocal.deep_merge!(local_hash, @raw)
+    end
+
+  end
+end

data/lib/dot_local/mapper.rb

@@ -0,0 +1,57 @@
+module DotLocal
+  class Mapper
+
+    def initialize(config, *args)
+      @parents = args.map!(&:to_s) 
+      @config  = config
+      @raw     = config.raw
+      parents  = @parents.dup 
+
+      # Iterate the three and stop at the last 
+      # key. @raw is now the last member of
+      # the chain. 
+      # This means that @raw can be either a Hash or 
+      # a value
+      while parent = parents.shift
+        @raw = Mapper.fetch(@raw, parent)
+      end
+    end
+
+    def method_missing(*args)
+      super if args.count > 1
+      return_value_or_mapper(args.first.to_s)
+    end
+
+    def self.fetch(hash, key)
+      hash.fetch(key) 
+    rescue KeyError
+      raise KeyNotFound.new("You were looking for #{key} but no luck")
+    end
+
+    def to_hash
+      @raw if @raw.is_a?(Hash)
+    end
+
+    private
+    
+    def return_value_or_mapper(key)
+      if return_mapper?(@raw, key)
+        @parents << key
+        self.class.new(@config, *@parents)
+      else
+        self.class.fetch(@raw, key)
+      end
+    end
+
+    def return_mapper?(value, key)
+      value.is_a?(Hash) && self.class.key_is_hash?(value, key) 
+    end
+
+    def self.key_is_hash?(value, key)
+      value.fetch(key).is_a?(Hash)
+    rescue KeyError
+      false
+    end
+
+  end
+end

data/lib/dot_local/version.rb

@@ -0,0 +1,3 @@
+module DotLocal
+  VERSION = "0.0.2"
+end

data/lib/dotlocal.rb

@@ -0,0 +1 @@
+require 'dot_local'

data/spec/dot_local_spec.rb

@@ -0,0 +1,191 @@
+require 'spec_helper'
+require './lib/dot_local'
+
+describe DotLocal do
+  describe 'deep_merge!' do
+    let(:winner) { {:a => {:b => 'y'}, :c => nil }}
+    let(:looser) { {:a => {:b => 'x', :d => 'x'}, :c => 'x'} }
+    before do
+      DotLocal.deep_merge!(winner,looser)
+    end
+
+    it 'should give priority if key exists' do
+      winner[:a][:b].should == 'y'
+    end
+
+    it 'should keep key in nested hash' do
+      winner[:a][:d].should == 'x'
+    end
+
+    it 'should keep exceeding key' do
+      winner[:c].should == 'x'
+    end
+  end
+end
+
+describe DotLocal::Mapper do
+  let(:config_hash) do
+    {'foo' => {'bar' => {'baz' => 10 } } }
+  end
+
+  let(:config) do
+    config = DotLocal::Configuration.new
+    config.stub(:raw => config_hash)
+    config
+  end
+
+  it 'should return config value' do
+    mapper = DotLocal::Mapper.new(config, :foo, :bar)
+    mapper.baz.should == 10
+  end
+
+  it 'should return a mapper' do
+    mapper = DotLocal::Mapper.new(config, :foo)
+    mapper.bar.should be_a(DotLocal::Mapper)
+  end
+  
+  it 'should have a to_hash method' do 
+    mapper = DotLocal::Mapper.new(config, :foo)
+    mapper.bar.to_hash.should == {'baz' => 10}
+  end
+
+end
+
+describe DotLocal::Configuration do
+  it 'should set path by options' do
+    config = DotLocal::Configuration.new(:path => '/path/to/me')
+    config.path.to_s.should == '/path/to/me'
+  end
+
+  it 'should set env by options' do
+    config = DotLocal::Configuration.new(:env => 'production')
+    config.env.should == 'production'
+  end
+
+  it 'should look for a file named settings.yml' do
+    path =  File.join(File.dirname(__FILE__), 'support', 'fixtures')
+    config = DotLocal::Configuration.new(:path => path)
+    config.load!
+  end
+
+  it 'should raise an exception if settings file is not found' do
+    config = DotLocal::Configuration.new(:path => '/path/to/nowhere')
+    expect {
+      config.load!
+    }.to raise_error(DotLocal::MissingFile)
+  end
+
+  it 'should preserve extension for local file name' do
+    config = DotLocal::Configuration.new(:file_name => 'foo.yml')
+    config.local_file_name.should == 'foo.local.yml'
+  end
+
+  context 'on fixtures path' do
+    let(:path) { File.join(File.dirname(__FILE__), 'support', 'fixtures') }
+
+    context 'with a settings file' do
+      let(:config) do
+        DotLocal::Configuration.new(:path => path).tap do |config|
+          config.load!
+        end
+      end
+
+      it 'should get a value without env' do
+        config.env = nil
+        config.reload!
+        config.production.key_one.should == 1
+      end
+
+      it 'should return the raw settings hash' do
+        config.raw.should be_a(Hash)
+      end
+
+      it 'should raise for double load call' do
+        expect {
+          config.load!
+        }.to raise_error(DotLocal::DoubleLoad)
+      end
+
+      it 'should allow for reload' do
+        expect {
+          config.reload!
+        }.to_not raise_error
+      end
+
+      it 'should raise if settings has reserved keys' do
+        config.file_name = 'reserved_keys.yml'
+        config.env = nil
+        expect {
+          config.reload!
+        }.to raise_error(DotLocal::ReservedKey)
+      end
+
+      it 'should create methods for top level keys' do
+        config.env = nil
+        config.reload!
+        config.development.should be_a(DotLocal::Mapper)
+      end
+
+      it 'should set env' do
+        config.env = 'development'
+        config.reload!
+        expect {
+          config.development
+        }.to raise_error(DotLocal::KeyNotFound)
+      end
+
+      it 'should get a value when env is set' do
+        config.env = 'development'
+        config.file_name = 'settings.yml'
+        config.reload!
+        config.key_one.should == 11
+      end
+
+      it 'should raise when calling a missing config key' do
+        expect {
+          config.non_existing
+        }.to raise_error(DotLocal::KeyNotFound)
+      end
+    end
+
+    context 'with a settings file with errors' do
+      let(:config) do
+        DotLocal::Configuration.new(:path => path,
+                                    :file_name => 'error_settings.yml')
+      end
+
+      it 'should raise ParsingError' do
+        expect {
+          config.load!
+        }.to raise_error(DotLocal::ParsingError)
+      end
+    end
+
+    context 'on a settings file with nil keys' do
+      let(:config) do
+        DotLocal::Configuration.new(:path => path,
+                                    :file_name => 'blank_values.yml')
+      end
+
+      it 'should raise an exception' do
+        expect {
+          config.load!
+        }.to raise_error(DotLocal::BlankValue)
+      end
+    end
+
+    context 'a settings file with local' do
+      let(:config) do
+        DotLocal::Configuration.new(:path => path,
+                                    :file_name => 'with_local.yml')
+      end
+
+      it 'should have settings overridden by local' do
+        config.load!
+        config.food.cheese.parmesan.should == 2
+      end
+
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper.rb"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require 'ruby-debug'
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end

data/spec/support/fixtures/blank_values.yml

@@ -0,0 +1,4 @@
+value: 
+  blank: 
+
+

data/spec/support/fixtures/error_settings.yml

@@ -0,0 +1,10 @@
+:this
+  :is 
+    ------- a line 
+    { something wrong }
+    :not
+            :a 
+       :good
+                    :yaml
+                                :file
+       

data/spec/support/fixtures/reserved_keys.yml

@@ -0,0 +1,2 @@
+path: 1 
+file_name: 2 

data/spec/support/fixtures/settings.yml

@@ -0,0 +1,14 @@
+:defaults: &defaults
+  key_one: 1 
+  key_two: 2 
+
+production:
+  <<: *defaults
+
+development: 
+  key_one: 11 
+  key_two: 22 
+
+test: 
+  key_one: 111 
+  key_two: 222

data/spec/support/fixtures/with_local.local.yml

@@ -0,0 +1,10 @@
+food:
+  cheese:
+    cheddar: 1
+    parmesan: 2
+
+sport:
+  racing: 
+    bikers: 1
+    cars: 2 
+

data/spec/support/fixtures/with_local.yml

@@ -0,0 +1,10 @@
+food:
+  cheese:
+    cheddar: 1
+    parmesan: 
+
+sport:
+  racing: 
+    bikers: 1
+    cars: 
+

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: dotlocal
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Fabrizio Regini
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-26 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2157950820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2157950820
+description: DotLocal helps in managing config files providing ability to define a
+  local version to override settings
+email:
+- freegenie@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- dotlocal.gemspec
+- lib/dot_local.rb
+- lib/dot_local/configuration.rb
+- lib/dot_local/mapper.rb
+- lib/dot_local/version.rb
+- lib/dotlocal.rb
+- spec/dot_local_spec.rb
+- spec/spec_helper.rb
+- spec/support/fixtures/blank_values.yml
+- spec/support/fixtures/error_settings.yml
+- spec/support/fixtures/reserved_keys.yml
+- spec/support/fixtures/settings.yml
+- spec/support/fixtures/with_local.local.yml
+- spec/support/fixtures/with_local.yml
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: .
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: DotLocal, for versionable config files
+test_files:
+- spec/dot_local_spec.rb
+- spec/spec_helper.rb
+- spec/support/fixtures/blank_values.yml
+- spec/support/fixtures/error_settings.yml
+- spec/support/fixtures/reserved_keys.yml
+- spec/support/fixtures/settings.yml
+- spec/support/fixtures/with_local.local.yml
+- spec/support/fixtures/with_local.yml