dc-settingslogic 2.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3b99784f5ea316afb0a97ad07755540a89bf0e55
+  data.tar.gz: ccdfb941953d43fa57d70236807ab6fa5f548f92
+SHA512:
+  metadata.gz: c04822d02195eb8c005167b8a7cb0630060c0413ee6b686ad918da5e5bdcbf099f9b6bbb72ab39057a1966286e175da50df05bf20227dafbc5ce151ca669417f
+  data.tar.gz: 4733c6ddca69d39aa9434e20cdbcd07bfefb94e16efddb07aeb608b484f69eb1584bef0d5a040321be400e42050995ee0d22d2d92668e1ccee3e7c04e5a75867

data/.gitignore

@@ -0,0 +1,12 @@
+.DS_Store
+*.log
+*.sqlite3
+pkg/*
+coverage/*
+doc/*
+benchmarks/*
+.bundle
+vendor/bundle
+.rvmrc
+.ruby-version
+.ruby-gemset

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,30 @@
+PATH
+  remote: .
+  specs:
+    dc-settingslogic (2.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    rake (10.3.2)
+    rspec (3.0.0)
+      rspec-core (~> 3.0.0)
+      rspec-expectations (~> 3.0.0)
+      rspec-mocks (~> 3.0.0)
+    rspec-core (3.0.2)
+      rspec-support (~> 3.0.0)
+    rspec-expectations (3.0.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.0.0)
+    rspec-mocks (3.0.2)
+      rspec-support (~> 3.0.0)
+    rspec-support (3.0.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  dc-settingslogic!
+  rake
+  rspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Ben Johnson of Binary Logic (binarylogic.com)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,157 @@
+= Settingslogic
+
+Settingslogic is a simple configuration / settings solution that uses an ERB enabled YAML file. It has been great for
+our apps, maybe you will enjoy it too.  Settingslogic works with Rails, Sinatra, or any Ruby project.
+
+== Helpful links
+
+*	<b>Documentation:</b> http://rdoc.info/projects/binarylogic/settingslogic
+*	<b>Repository:</b> http://github.com/binarylogic/settingslogic/tree/master
+* <b>Issues:</b> http://github.com/binarylogic/settingslogic/issues
+
+== Installation
+
+  gem install settingslogic
+
+== Usage
+
+=== 1. Define your class
+
+Instead of defining a Settings constant for you, that task is left to you. Simply create a class in your application
+that looks like:
+
+  class Settings < Settingslogic
+    source "#{Rails.root}/config/application.yml"
+    namespace Rails.env
+  end
+
+Name it Settings, name it Config, name it whatever you want. Add as many or as few as you like. A good place to put
+this file in a rails app is app/models/settings.rb
+
+I felt adding a settings file in your app was more straightforward, less tricky, and more flexible.
+
+=== 2. Create your settings
+
+Notice above we specified an absolute path to our settings file called "application.yml". This is just a typical YAML file.
+Also notice above that we specified a namespace for our environment.  A namespace is just an optional string that corresponds
+to a key in the YAML file.
+
+Using a namespace allows us to change our configuration depending on our environment:
+
+  # config/application.yml
+  defaults: &defaults
+    cool:
+      saweet: nested settings
+    neat_setting: 24
+    awesome_setting: <%= "Did you know 5 + 5 = #{5 + 5}?" %>
+
+  development:
+    <<: *defaults
+    neat_setting: 800
+
+  test:
+    <<: *defaults
+
+  production:
+    <<: *defaults
+
+_Note_: Certain Ruby/Bundler versions include a version of the Psych YAML parser which incorrectly handles merges (the `<<` in the example above.)
+If your default settings seem to be overwriting your environment-specific settings, including the following lines in your config/boot.rb file may solve the problem:
+
+  require 'yaml'
+  YAML::ENGINE.yamler= 'syck'
+
+=== 3. Access your settings
+
+  >> Rails.env
+  => "development"
+
+  >> Settings.cool
+  => "#<Settingslogic::Settings ... >"
+
+  >> Settings.cool.saweet
+  => "nested settings"
+
+  >> Settings.neat_setting
+  => 800
+
+  >> Settings.awesome_setting
+  => "Did you know 5 + 5 = 10?"
+
+You can use these settings anywhere, for example in a model:
+
+  class Post < ActiveRecord::Base
+    self.per_page = Settings.pagination.posts_per_page
+  end
+
+=== 4. Optional / dynamic settings
+
+Often, you will want to handle defaults in your application logic itself, to reduce the number of settings
+you need to put in your YAML file.  You can access an optional setting by using Hash notation:
+
+  >> Settings.messaging.queue_name
+  => Exception: Missing setting 'queue_name' in 'message' section in 'application.yml'
+
+  >> Settings.messaging['queue_name']
+  => nil
+
+  >> Settings.messaging['queue_name'] ||= 'user_mail'
+  => "user_mail"
+
+  >> Settings.messaging.queue_name
+  => "user_mail"
+
+Modifying our model example:
+
+  class Post < ActiveRecord::Base
+    self.per_page = Settings.posts['per_page'] || Settings.pagination.per_page
+  end
+
+This would allow you to specify a custom value for per_page just for posts, or
+to fall back to your default value if not specified.
+
+=== 5. Suppressing Exceptions Conditionally
+
+Raising exceptions for missing settings helps highlight configuration problems.  However, in a
+Rails app it may make sense to suppress this in production and return nil for missing settings.
+While it's useful to stop and highlight an error in development or test environments, this is
+often not the right answer for production.
+
+  class Settings < Settingslogic
+    source "#{Rails.root}/config/application.yml"
+    namespace Rails.env
+    suppress_errors Rails.env.production?
+  end
+
+  >> Settings.non_existent_key
+  => nil
+
+== Note on Sinatra / Capistrano / Vlad
+
+Each of these frameworks uses a +set+ convention for settings, which actually defines methods
+in the global Object namespace:
+
+  set :application, "myapp"  # does "def application" globally
+
+This can cause collisions with Settingslogic, since those methods are global. Luckily, the
+solution is to just add a call to load! in your class:
+
+  class Settings < Settingslogic
+    source "#{Rails.root}/config/application.yml"
+    namespace Rails.env
+    load!
+  end
+
+It's probably always safest to add load! to your class, since this guarantees settings will be
+loaded at that time, rather than lazily later via method_missing.
+
+Finally, you can reload all your settings later as well:
+
+  Settings.reload!
+
+This is useful if you want to support changing your settings YAML without restarting your app.
+
+== Author
+
+Copyright (c) 2008-2010 {Ben Johnson}[http://github.com/binarylogic] of {Binary Logic}[http://www.binarylogic.com],
+released under the MIT license.  Support for optional settings and reloading by {Nate Wiger}[http://nate.wiger.org].

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :default => :spec

data/lib/settingslogic.rb

@@ -0,0 +1,196 @@
+require "yaml"
+require "erb"
+require 'open-uri'
+
+# A simple settings solution using a YAML file. See README for more information.
+class Settingslogic < Hash
+  class MissingSetting < StandardError; end
+
+  class << self
+    def name # :nodoc:
+      self.superclass != Hash && instance.key?("name") ? instance.name : super
+    end
+
+    # Enables Settings.get('nested.key.name') for dynamic access
+    def get(key)
+      parts = key.split('.')
+      curs = self
+      while p = parts.shift
+        curs = curs.send(p)
+      end
+      curs
+    end
+
+    def source(value = nil)
+      @source ||= []
+      @source << value
+    end
+
+    def namespace(value = nil)
+      @namespace ||= value
+    end
+
+    def suppress_errors(value = nil)
+      @suppress_errors ||= value
+    end
+
+    def [](key)
+      instance.fetch(key.to_s, nil)
+    end
+
+    def []=(key, val)
+      # Setting[:key][:key2] = 'value' for dynamic settings
+      val = new(val, source) if val.is_a? Hash
+      instance.store(key.to_s, val)
+      instance.create_accessor_for(key, val)
+    end
+
+    def load!
+      instance
+      true
+    end
+
+    def reload!
+      @instance = nil
+      load!
+    end
+
+    private
+      def instance
+        return @instance if @instance
+        @instance = new
+        create_accessors!
+        @instance
+      end
+
+      def method_missing(name, *args, &block)
+        instance.send(name, *args, &block)
+      end
+
+      # It would be great to DRY this up somehow, someday, but it's difficult because
+      # of the singleton pattern.  Basically this proxies Setting.foo to Setting.instance.foo
+      def create_accessors!
+        instance.each do |key,val|
+          create_accessor_for(key)
+        end
+      end
+
+      def create_accessor_for(key)
+        return unless key.to_s =~ /^\w+$/  # could have "some-setting:" which blows up eval
+        instance_eval "def #{key}; instance.send(:#{key}); end"
+      end
+
+  end
+
+  # Initializes a new settings object. You can initialize an object in any of the following ways:
+  #
+  #   Settings.new(:application) # will look for config/application.yml
+  #   Settings.new("application.yaml") # will look for application.yaml
+  #   Settings.new("/var/configs/application.yml") # will look for /var/configs/application.yml
+  #   Settings.new(:config1 => 1, :config2 => 2)
+  #
+  # Basically if you pass a symbol it will look for that file in the configs directory of your rails app,
+  # if you are using this in rails. If you pass a string it should be an absolute path to your settings file.
+  # Then you can pass a hash, and it just allows you to access the hash via methods.
+  def initialize(hash_or_file = self.class.source, section = nil)
+    #puts "new! #{hash_or_file}"
+    case hash_or_file
+    when nil
+      raise Errno::ENOENT, "No file specified as Settingslogic source"
+    when Hash
+      self.replace hash_or_file
+    else
+      hash = {}
+      files = hash_or_file.reject { |file| file.nil? }
+      files.each do |file|
+        next unless File.exist? file
+
+        file_contents = open(file).read
+        single_hash = file_contents.empty? ? {} : YAML.load(ERB.new(file_contents).result).to_hash
+        hash.merge! single_hash
+      end
+      if self.class.namespace
+        hash = hash[self.class.namespace] or return missing_key("Missing setting '#{self.class.namespace}' in #{files.join(', ')}")
+      end
+      self.replace hash
+    end
+    @section = section || self.class.source.reject { |file| file.nil? }.join(', ')  # so end of error says "in application.yml"
+    create_accessors!
+  end
+
+  # Called for dynamically-defined keys, and also the first key deferenced at the top-level, if load! is not used.
+  # Otherwise, create_accessors! (called by new) will have created actual methods for each key.
+  def method_missing(name, *args, &block)
+    key = name.to_s
+    return missing_key("Missing setting '#{key}' in #{@section}") unless has_key? key
+    value = fetch(key)
+    create_accessor_for(key)
+    value.is_a?(Hash) ? self.class.new(value, "'#{key}' section in #{@section}") : value
+  end
+
+  def [](key)
+    fetch(key.to_s, nil)
+  end
+
+  def []=(key,val)
+    # Setting[:key][:key2] = 'value' for dynamic settings
+    val = self.class.new(val, @section) if val.is_a? Hash
+    store(key.to_s, val)
+    create_accessor_for(key, val)
+  end
+
+  # Returns an instance of a Hash object
+  def to_hash
+    Hash[self]
+  end
+
+  # This handles naming collisions with Sinatra/Vlad/Capistrano. Since these use a set()
+  # helper that defines methods in Object, ANY method_missing ANYWHERE picks up the Vlad/Sinatra
+  # settings!  So settings.deploy_to title actually calls Object.deploy_to (from set :deploy_to, "host"),
+  # rather than the app_yml['deploy_to'] hash.  Jeezus.
+  def create_accessors!
+    self.each do |key,val|
+      create_accessor_for(key)
+    end
+  end
+
+  # Use instance_eval/class_eval because they're actually more efficient than define_method{}
+  # http://stackoverflow.com/questions/185947/ruby-definemethod-vs-def
+  # http://bmorearty.wordpress.com/2009/01/09/fun-with-rubys-instance_eval-and-class_eval/
+  def create_accessor_for(key, val=nil)
+    return unless key.to_s =~ /^\w+$/  # could have "some-setting:" which blows up eval
+    instance_variable_set("@#{key}", val)
+    self.class.class_eval <<-EndEval
+      def #{key}
+        return @#{key} if @#{key}
+        return missing_key("Missing setting '#{key}' in #{@section}") unless has_key? '#{key}'
+        value = fetch('#{key}')
+        @#{key} = if value.is_a?(Hash)
+          self.class.new(value, "'#{key}' section in #{@section}")
+        elsif value.is_a?(Array) && value.all?{|v| v.is_a? Hash}
+          value.map{|v| self.class.new(v)}
+        else
+          value
+        end
+      end
+    EndEval
+  end
+
+  def symbolize_keys
+    inject({}) do |memo, tuple|
+      k = (tuple.first.to_sym rescue tuple.first) || tuple.first
+
+      v = k.is_a?(Symbol) ? send(k) : tuple.last # make sure the value is accessed the same way Settings.foo.bar works
+
+      memo[k] = v && v.respond_to?(:symbolize_keys) ? v.symbolize_keys : v #recurse for nested hashes
+
+      memo
+    end
+  end
+
+  def missing_key(msg)
+    return nil if self.class.suppress_errors
+
+    raise MissingSetting, msg
+  end
+end

data/settingslogic.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "dc-settingslogic"
+  s.version     = "2.1.0"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ben Johnson", "Jeong, Jiung"]
+  s.email       = ["bjohnson@binarylogic.com", "ethernuiel@sanultari.com"]
+  s.homepage    = "http://github.com/sanultari/settingslogic"
+  s.summary     = %q{A simple and straightforward settings solution that uses an ERB enabled YAML file and a singleton design pattern.}
+  s.description = %q{A simple and straightforward settings solution that uses an ERB enabled YAML file and a singleton design pattern.}
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+
+  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"]
+end

data/spec/multi_source_config.rb

@@ -0,0 +1,4 @@
+class MultiSourceConfig < Settingslogic
+  source "#{File.dirname(__FILE__)}/settings.yml"
+  source "#{File.dirname(__FILE__)}/override.yml"
+end

data/spec/override.yml

@@ -0,0 +1,3 @@
+setting2: 10
+
+override: true

data/spec/settings.rb

@@ -0,0 +1,6 @@
+class Settings < Settingslogic
+  source "#{File.dirname(__FILE__)}/settings.yml"
+end
+
+class SettingsInst < Settingslogic
+end

data/spec/settings.yml

@@ -0,0 +1,28 @@
+setting1:
+  setting1_child: saweet
+  deep:
+    another: my value
+    child:
+      value: 2
+
+setting2: 5
+setting3: <%= 5 * 5 %>
+name: test
+
+language:
+  haskell:
+    paradigm: functional
+  smalltalk:
+    paradigm: object oriented 
+
+collides:
+  does: not
+nested:
+  collides:
+    does: not either
+
+array:
+  -
+    name: first
+  -
+    name: second

data/spec/settings2.rb

@@ -0,0 +1,4 @@
+class Settings2 < Settingslogic
+  source "#{File.dirname(__FILE__)}/settings.yml"
+  namespace "setting1"
+end

data/spec/settings3.rb

@@ -0,0 +1,4 @@
+class Settings3 < Settingslogic
+  source "#{File.dirname(__FILE__)}/settings.yml"
+  load!  # test of load
+end

data/spec/settings4.rb

@@ -0,0 +1,4 @@
+class Settings4 < Settingslogic
+  source "#{File.dirname(__FILE__)}/settings.yml"
+  suppress_errors true
+end

data/spec/settings_empty.rb

@@ -0,0 +1,3 @@
+class SettingsEmpty < Settingslogic
+  source "#{File.dirname(__FILE__)}/settings_empty.yml"
+end

data/spec/settingslogic_spec.rb

@@ -0,0 +1,184 @@
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+
+describe "Settingslogic" do
+  it "should access settings" do
+    expect(Settings.setting2).to eq(5)
+  end
+
+  it "should access nested settings" do
+    expect(Settings.setting1.setting1_child).to eq("saweet")
+  end
+
+  it "should access settings in nested arrays" do
+    expect(Settings.array.first.name).to eq("first")
+  end
+
+  it "should access deep nested settings" do
+    expect(Settings.setting1.deep.another).to eq("my value")
+  end
+
+  it "should access extra deep nested settings" do
+    expect(Settings.setting1.deep.child.value).to eq(2)
+  end
+
+  it "should enable erb" do
+    expect(Settings.setting3).to eq(25)
+  end
+
+  it "should namespace settings" do
+    expect(Settings2.setting1_child).to eq("saweet")
+    expect(Settings2.deep.another).to eq("my value")
+  end
+
+  it "should return the namespace" do
+    expect(Settings.namespace).to be_nil
+    expect(Settings2.namespace).to eq('setting1')
+  end
+
+  it "should distinguish nested keys" do
+    expect(Settings.language.haskell.paradigm).to eq('functional')
+    expect(Settings.language.smalltalk.paradigm).to eq('object oriented')
+  end
+
+  it "should not collide with global methods" do
+    expect(Settings3.nested.collides.does).to eq('not either')
+    Settings3[:nested] = 'fooey'
+    expect(Settings3[:nested]).to eq('fooey')
+    expect(Settings3.nested).to eq('fooey')
+    expect(Settings3.collides.does).to eq('not')
+  end
+
+  it "should raise a helpful error message" do
+    expect { Settings.missing }.to raise_error(Settingslogic::MissingSetting, /Missing setting 'missing' in/)
+    expect { Settings.language.missing }.to raise_error(Settingslogic::MissingSetting, /Missing setting 'missing' in 'language' section/)
+  end
+
+  it "should handle optional / dynamic settings" do
+    expect { Settings.language.erlang }.to raise_error(Settingslogic::MissingSetting, /Missing setting 'erlang' in 'language' section/)
+
+    expect(Settings.language['erlang']).to be_nil
+    Settings.language['erlang'] = 5
+    expect(Settings.language['erlang']).to eq(5)
+
+    Settings.language['erlang'] = {'paradigm' => 'functional'}
+    expect(Settings.language.erlang.paradigm).to eq('functional')
+    expect(Settings).not_to respond_to :erlang
+
+    Settings.reload!
+    expect(Settings.language['erlang']).to be_nil
+
+    Settings.language[:erlang] ||= 5
+    expect(Settings.language[:erlang]).to eq(5)
+
+    Settings.language[:erlang] = {}
+    Settings.language[:erlang][:paradigm] = 'functional'
+    expect(Settings.language.erlang.paradigm).to eq('functional')
+
+    Settings[:toplevel] = '42'
+    expect(Settings.toplevel).to eq('42')
+  end
+
+  it "should raise an error on a nil source argument" do
+    class NoSource < Settingslogic; end
+
+    expect { NoSource.foo.bar }.to raise_error Settingslogic::MissingSetting
+  end
+
+  it "should allow suppressing errors" do
+    expect(Settings4.non_existent_key).to be_nil
+  end
+
+  # This one edge case currently does not pass, because it requires very
+  # esoteric code in order to make it pass.  It was judged not worth fixing,
+  # as it introduces significant complexity for minor gain.
+  # it "should handle reloading top-level settings"
+  #   Settings[:inspect] = 'yeah baby'
+  #   Settings.inspect.should == 'yeah baby'
+  #   Settings.reload!
+  #   Settings.inspect.should == 'Settings'
+  # end
+
+  it "should handle oddly-named settings" do
+    Settings.language['some-dash-setting#'] = 'dashtastic'
+    expect(Settings.language['some-dash-setting#']).to eq('dashtastic')
+  end
+
+  it "should handle settings with nil value" do
+    Settings["flag"] = true
+    Settings["flag"] = nil
+    expect(Settings.flag).to be_nil
+  end
+
+  it "should handle settings with false value" do
+    Settings["flag"] = true
+    Settings["flag"] = false
+    expect(Settings.flag).to eq(false)
+  end
+
+  it "should support instance usage as well" do
+    settings = SettingsInst.new(Settings.source)
+    expect(settings.setting1.setting1_child).to eq("saweet")
+  end
+
+  it "should be able to get() a key with dot.notation" do
+    expect(Settings.get('setting1.setting1_child')).to eq("saweet")
+    expect(Settings.get('setting1.deep.another')).to eq("my value")
+    expect(Settings.get('setting1.deep.child.value')).to eq(2)
+  end
+
+  # If .name is not a property, delegate to superclass
+  it "should respond with Module.name" do
+    expect(Settings2.name).to eq("Settings2")
+  end
+
+  # If .name is called on Settingslogic itself, handle appropriately
+  # by delegating to Hash
+  it "should have the parent class always respond with Module.name" do
+    expect(Settingslogic.name).to eq('Settingslogic')
+  end
+
+  # If .name is a property, respond with that instead of delegating to superclass
+  it "should allow a name setting to be overriden" do
+    expect(Settings.name).to eq('test')
+  end
+
+  it "should allow symbolize_keys" do
+    Settings.reload!
+    result = Settings.language.haskell.symbolize_keys
+    expect(result).to be_a Hash
+    expect(result).to eq({:paradigm => "functional"})
+  end
+
+  it "should allow symbolize_keys on nested hashes" do
+    Settings.reload!
+    result = Settings.language.symbolize_keys
+    expect(result).to be_a Hash
+    expect(result).to eq({
+      :haskell => {:paradigm => "functional"},
+      :smalltalk => {:paradigm => "object oriented"}
+    })
+  end
+
+  it "should handle empty file" do
+    expect(SettingsEmpty.keys).to be_empty
+  end
+
+  # Put this test last or else call to .instance will load @instance,
+  # masking bugs.
+  it "should be a hash" do
+    expect(Settings.send(:instance)).to be_a Hash
+  end
+
+  it "should override configuration from multiple source" do
+    expect(MultiSourceConfig.setting2).to eq(10)
+    expect(MultiSourceConfig.override).to eq(true)
+    expect(MultiSourceConfig.name).to eq("test")
+  end
+
+  describe "#to_hash" do
+    it "should return a new instance of a Hash object" do
+      expect(Settings.to_hash).to be_a Hash
+      expect(Settings.to_hash.object_id).not_to eq(Settings.object_id)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rspec'
+require 'settingslogic'
+require_relative 'settings'
+require_relative 'settings2'
+require_relative 'settings3'
+require_relative 'settings4'
+require_relative 'multi_source_config'
+require_relative 'settings_empty'
+
+# Needed to test Settings3
+Object.send :define_method, 'collides' do
+  'collision'
+end
+
+RSpec.configure do |config|
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: dc-settingslogic
+version: !ruby/object:Gem::Version
+  version: 2.1.0
+platform: ruby
+authors:
+- Ben Johnson
+- Jeong, Jiung
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simple and straightforward settings solution that uses an ERB enabled
+  YAML file and a singleton design pattern.
+email:
+- bjohnson@binarylogic.com
+- ethernuiel@sanultari.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.rdoc
+- Rakefile
+- lib/settingslogic.rb
+- settingslogic.gemspec
+- spec/multi_source_config.rb
+- spec/override.yml
+- spec/settings.rb
+- spec/settings.yml
+- spec/settings2.rb
+- spec/settings3.rb
+- spec/settings4.rb
+- spec/settings_empty.rb
+- spec/settings_empty.yml
+- spec/settingslogic_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/sanultari/settingslogic
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A simple and straightforward settings solution that uses an ERB enabled YAML
+  file and a singleton design pattern.
+test_files:
+- spec/multi_source_config.rb
+- spec/override.yml
+- spec/settings.rb
+- spec/settings.yml
+- spec/settings2.rb
+- spec/settings3.rb
+- spec/settings4.rb
+- spec/settings_empty.rb
+- spec/settings_empty.yml
+- spec/settingslogic_spec.rb
+- spec/spec_helper.rb