configatron 3.2.0 → 4.5.0

data/lib/configatron/store.rb

@@ -1,68 +1,94 @@
 require 'forwardable'
 
 class Configatron
-  class Store# < BasicObject
+  class Store < BasicObject
     extend ::Forwardable
 
-    def initialize(attributes = {})
-      @__locked = false
-      @attributes = attributes || {}
-      @attributes.send(:extend, DeepClone)
+    def initialize(root_store, name='configatron', attributes={}, path=[])
+      @root_store = root_store
+      @name = name
+      @attributes = attributes
+
+      # We could derive @name from @path, though this would break
+      # backwards-compatibility.
+      @path = path
+
+      @cow = root_store.__cow
+    end
+
+    def clone
+      Store.new(
+        @root_store,
+        @name,
+        @attributes.clone,
+        @path
+        )
     end
 
-    def lock!(value=true)
-      @__locked = value
+    def __cow
+      @cow
     end
 
-    def reset!
-      @attributes.clear
+    def __cow_clone
+      # A temp has started since the last time this was written
+      if @root_store.__cow != @cow
+        self.clone
+      else
+        self
+      end
     end
 
     def [](key)
       val = fetch(key.to_sym) do
-        if @__locked
-          raise Configatron::UndefinedKeyError.new("Key Not Found: #{key}")
+        if @root_store.locked?
+          ::Kernel.raise ::Configatron::UndefinedKeyError.new("Key not found: #{key} (for locked #{self})")
         end
-        ::Configatron::Store.new
+        ::Configatron::Store.new(@root_store, "#{@name}.#{key}", {}, @path + [key])
       end
       return val
     end
 
     def store(key, value)
-      if @__locked
-        raise Configatron::LockedError.new("Locked! Can not set key #{key}!")
+      if @root_store.locked?
+        ::Kernel.raise ::Configatron::LockedError.new("Cannot set key #{key} for locked #{self}")
+      end
+
+      key = key.to_sym
+      if @root_store.__cow != @cow
+        copy = @root_store.__cow_path(@path)
+        # Cow should now match, so this won't recurse. (Note this is
+        # not particularly thread-safe.)
+        copy.store(key, value)
+      else
+        @attributes[key] = value
       end
-      @attributes[key.to_sym] = value
     end
 
     def fetch(key, default_value = nil, &block)
-      val = @attributes[key.to_sym]
-      if val.nil?
-        if block_given?
+      key = key.to_sym
+      if key?(key)
+        val = @attributes[key]
+      else
+        if block
           val = block.call
         elsif default_value
           val = default_value
         end
         store(key, val)
       end
-      if val.is_a?(Configatron::Proc)
+      if ::Configatron::Proc === val
         val = val.call
       end
       return val
     end
 
-    def nil?
-      @attributes.empty?
-    end
-
     def key?(key)
-      val = self[key.to_sym]
-      !val.is_a?(Configatron::Store)
+      @attributes.key?(key.to_sym)
     end
 
     def configure_from_hash(hash)
       hash.each do |key, value|
-        if value.is_a?(Hash)
+        if ::Hash === value
           self[key].configure_from_hash(value)
         else
           store(key, value)
@@ -70,22 +96,58 @@ class Configatron
       end
     end
 
-    def temp(&block)
-      temp_start
-      yield
-      temp_end
+    def to_s
+      @name
+    end
+
+    def inspect
+      f_out = []
+      @attributes.each do |k, v|
+        if ::Configatron::Store === v
+          v.inspect.each_line do |line|
+            if line.match(/\n/)
+              line.each_line do |l|
+                l.strip!
+                f_out << l
+              end
+            else
+              line.strip!
+              f_out << line
+            end
+          end
+        else
+          f_out << "#{@name}.#{k} = #{v.inspect}"
+        end
+      end
+      f_out.compact.sort.join("\n")
+    end
+
+    def method_missing(name, *args, &block)
+      do_lookup(name, *args, &block)
     end
 
-    def temp_start
-      @__temp = @attributes.deep_clone
+    def to_h
+      @attributes.each_with_object({}) do |(k, v), h|
+        v = v.call if ::Configatron::Proc === v
+        h[k] = Store === v ? v.to_h : v
+      end
     end
 
-    def temp_end
-      @attributes = @__temp
+    # So that puts works (it expects the object to respond to to_ary)
+    def to_ary
+      nil
     end
 
-    def method_missing(name, *args, &block)
-      if block_given?
+    # So that we keep backward-compatibility in case people are using nil? to check
+    # configatron settings:
+    def nil?
+      false
+    end
+
+    private
+
+    def do_lookup(name, *args, &block)
+      if block
         yield self[name]
       else
         name = name.to_s
@@ -96,7 +158,7 @@ class Configatron
           if self.has_key?(key)
             return self[key]
           else
-            raise Configatron::UndefinedKeyError.new($1)
+            ::Kernel.raise ::Configatron::UndefinedKeyError.new($1)
           end
         else
           return self[name]
@@ -104,38 +166,13 @@ class Configatron
       end
     end
 
-    def inspect(name = 'configatron')
-      f_out = []
-      @attributes.each do |k, v|
-        if v.is_a?(Configatron::Store)
-          v.inspect("#{name}.#{k}").each_line do |line|
-            if line.match(/\n/)
-              line.each_line do |l|
-                l.strip!
-                f_out << l
-              end
-            else
-              line.strip!
-              f_out << line
-            end
-          end
-        else
-          f_out << "#{name}.#{k} = #{v.inspect}"
-        end
-      end
-      f_out.compact.sort.join("\n")
-  end
-
     alias :[]= :store
-    alias :blank? :nil?
     alias :has_key? :key?
+    alias :to_hash :to_h
 
     def_delegator :@attributes, :values
     def_delegator :@attributes, :keys
     def_delegator :@attributes, :each
-    def_delegator :@attributes, :empty?
-    def_delegator :@attributes, :to_h
-    def_delegator :@attributes, :to_hash
     def_delegator :@attributes, :delete
     # def_delegator :@attributes, :fetch
     # def_delegator :@attributes, :has_key?

data/lib/configatron/version.rb

@@ -1,3 +1,3 @@
 class Configatron
-  VERSION = "3.2.0"
+  VERSION = "4.5.0"
 end

data/lib/generators/configatron/install/templates/configatron/defaults.rb

@@ -3,5 +3,5 @@
 # Example:
 #   configatron.emails.welcome.subject = 'Welcome!'
 #   configatron.emails.sales_reciept.subject = 'Thanks for your order'
-# 
-#   configatron.file.storage = :s3
+#
+#   configatron.file.storage = :s3

data/lib/generators/configatron/install/templates/configatron/development.rb

@@ -1,4 +1,4 @@
 # Override your default settings for the Development environment here.
-# 
+#
 # Example:
-#   configatron.file.storage = :local
+#   configatron.file.storage = :local

data/lib/generators/configatron/install/templates/configatron/production.rb

@@ -1,4 +1,4 @@
 # Override your default settings for the Production environment here.
-# 
+#
 # Example:
-#   configatron.file.storage = :s3
+#   configatron.file.storage = :s3

data/lib/generators/configatron/install/templates/configatron/test.rb

@@ -1,4 +1,4 @@
 # Override your default settings for the Test environment here.
-# 
+#
 # Example:
-#   configatron.file.storage = :local
+#   configatron.file.storage = :local

data/lib/generators/configatron/install/templates/initializers/configatron.rb

@@ -1,2 +1,2 @@
 require 'configatron'
-Configatron::Rails.init
+Configatron::Integrations::Rails.init

data/test/_lib.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'bundler/setup'
+
+ENV['MT_NO_EXPECTATIONS'] = 'true'
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'mocha/setup'
+
+require 'configatron'
+
+module Critic
+  class Test < ::MiniTest::Spec
+    def setup
+      # Put any stubs here that you want to apply globally
+    end
+  end
+end

data/test/functional/_lib.rb

@@ -0,0 +1,10 @@
+require File.expand_path('../../_lib', __FILE__)
+
+module Critic::Functional
+  module Stubs
+  end
+
+  class Test < Critic::Test
+    include Stubs
+  end
+end

data/test/functional/_lib/scripts/core.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+if defined?(configatron)
+  raise "`configatron` method was defined at load-time!"
+end
+
+require 'configatron/core'
+
+if defined?(configatron)
+  raise "Loaded configatron/core but `configatron` was defined!"
+end

data/test/functional/configatron.rb

@@ -0,0 +1,165 @@
+require_relative '_lib'
+
+class Critic::Functional::ConfigatronTest < Critic::Functional::Test
+  before do
+    @kernel = Configatron::RootStore.new
+  end
+
+  describe 'temp' do
+    before do
+      @kernel.a = 'A'
+      @kernel.b = 'B'
+    end
+
+    it 'allows for temporary setting of values' do
+      assert_equal('A', @kernel.a)
+      assert_equal('B', @kernel.b)
+      @kernel.temp do
+        @kernel.a = 'AA'
+        @kernel.c = 'C'
+        assert_equal('AA', @kernel.a)
+        assert_equal('B', @kernel.b)
+        assert_equal('C', @kernel.c)
+      end
+      assert_equal('A', @kernel.a)
+      assert_equal('B', @kernel.b)
+      assert_equal(false, @kernel.key?(:c))
+    end
+
+    it 'nested' do
+      @kernel.foo.bar = 'original'
+      @kernel.temp do
+        @kernel.foo.bar = 'temp'
+        assert_equal('temp', @kernel.foo.bar)
+      end
+      assert_equal('original', @kernel.foo.bar)
+    end
+
+    it 'cleans up after an exception' do
+      @kernel.foo.bar = 'original'
+
+      assert_raises(RuntimeError) do
+        @kernel.temp do
+          @kernel.foo.bar = 'temp'
+          raise RuntimeError.new('error')
+        end
+      end
+
+      assert_equal('original', @kernel.foo.bar)
+    end
+
+    it 'restores locking state' do
+      @kernel.lock!
+      @kernel.temp do
+        @kernel.unlock!
+      end
+      assert(@kernel.locked?)
+    end
+
+    describe 'start/end' do
+      it 'allows for temporary setting of values' do
+        assert_equal('A', @kernel.a)
+        assert_equal('B', @kernel.b)
+        @kernel.temp_start
+        @kernel.a = 'AA'
+        @kernel.c = 'C'
+        assert_equal('AA', @kernel.a)
+        assert_equal('B', @kernel.b)
+        assert_equal('C', @kernel.c)
+        @kernel.temp_end
+        assert_equal('A', @kernel.a)
+        assert_equal('B', @kernel.b)
+        assert_equal(false, @kernel.key?(:c))
+      end
+    end
+  end
+
+  describe 'lock!' do
+    before do
+      @kernel.a.b.c.d = 'DD'
+      @kernel.lock!
+    end
+
+    it 'raises an error when accessing non-existing values' do
+      assert @kernel.a != nil
+      assert @kernel.a.b != nil
+      assert @kernel.a.b.c != nil
+      assert_equal('DD', @kernel.a.b.c.d)
+      assert_raises(Configatron::UndefinedKeyError) do
+        @kernel.unknown
+      end
+    end
+
+    it 'responds to nil? for backward compatibility' do
+      refute_nil @kernel.a
+    end
+
+    it 'raises an error when trying to set a non-existing key' do
+      assert_raises(Configatron::LockedError) do
+        @kernel.unknown = 'known'
+      end
+    end
+
+    it 'locks during the block argument' do
+      @kernel.unlock!
+
+      @kernel.lock! do
+        assert(@kernel.locked?)
+      end
+
+      assert(!@kernel.locked?)
+    end
+
+    it 'executes a block argument' do
+      a = 1
+      @kernel.lock! do
+        a = 2
+      end
+      assert_equal(2, a)
+    end
+  end
+
+  describe 'name' do
+    it 'assigns an appropriate nested name' do
+      name = @kernel.foo.bar.baz.to_s
+      assert_equal(name, 'configatron.foo.bar.baz')
+    end
+  end
+
+  describe 'puts' do
+    it 'does not cause an exception' do
+      puts @kernel
+      puts @kernel.hi
+    end
+  end
+
+  describe 'private methods on kernel' do
+    it 'can be accessed through method accessors' do
+      @kernel.catch = 'hi'
+      @kernel.foo.catch = 'hi'
+
+      assert_equal('hi', @kernel.catch)
+      assert_equal('hi', @kernel.foo.catch)
+    end
+  end
+
+  describe 'to_h and to_hash' do
+    before do
+      @kernel.a = 1
+      @kernel.b.c = Configatron::Delayed.new{ @kernel.a + 3 }
+    end
+
+    it 'returns a hash representation' do
+      expected_hash = { a: 1, b: { c: 4 } }
+      assert_equal(expected_hash, @kernel.to_h)
+      assert_equal(expected_hash, @kernel.to_hash)
+    end
+  end
+
+  describe 'nil value' do
+    it 'remembers a nil value' do
+      @kernel.a = nil
+      assert_equal(nil, @kernel.a)
+    end
+  end
+end