configatronn 4.5.2

data/lib/configatron/root_store.rb

@@ -0,0 +1,126 @@
+require 'singleton'
+require 'forwardable'
+
+# This is the root configatron object, and contains methods which
+# operate on the entire configatron hierarchy.
+class Configatron::RootStore < BasicObject
+  include ::Singleton
+  extend ::Forwardable
+
+  attr_reader :store
+
+  # Have one global RootStore instance, but allow people to create
+  # their own parallel ones if they desire.
+  class << self
+    public :new
+  end
+
+  @@cow = 0
+
+  def initialize
+    @locked = false
+    @cow = nil
+
+    @temporary_locks = []
+    @temporary_states = []
+
+    reset!
+  end
+
+  def __cow
+    @cow
+  end
+
+  def __cow_path(path)
+    start = @store.__cow_clone
+
+    node = start
+    branch = path.map do |key|
+      node = node[key]
+      node.__cow_clone
+    end
+    nodes = [start] + branch
+
+    # [node1, node2, node3] with
+    # [node2, node3, node4] and
+    # ['key1', 'key2, 'key3']
+    nodes[0...-1].zip(nodes[1..-1], path) do |parent, child, key|
+      # These are all cow_clones, so won't trigger a further cow
+      # modification.
+      parent[key] = child
+    end
+
+    @store = nodes.first
+    nodes.last
+  end
+
+  def method_missing(name, *args, &block)
+    store.__send__(name, *args, &block)
+  end
+
+  def reset!
+    @store = ::Configatron::Store.new(self)
+  end
+
+  def temp(&block)
+    temp_start
+
+    begin
+      yield
+    ensure
+      temp_end
+    end
+  end
+
+  def temp_start
+    @temp_cow = @cow
+
+    # Just need to have a unique Copy-on-Write generation ID
+    @cow = @@cow += 1
+
+    @temporary_locks.push(@locked)
+    @temporary_states.push(@store)
+  end
+
+  def temp_end
+    @cow = @temp_cow
+
+    @locked = @temporary_locks.pop
+    @store = @temporary_states.pop
+  end
+
+  def locked?
+    @locked
+  end
+
+  def lock!(&blk)
+    if blk
+      orig = @locked
+      begin
+        @locked = true
+        blk.call
+      ensure
+        @locked = orig
+      end
+    else
+      @locked = true
+    end
+  end
+
+  def unlock!(&blk)
+    if blk
+      orig = @locked
+      begin
+        @locked = false
+        blk.call
+      ensure
+        @locked = orig
+      end
+    else
+      @locked = false
+    end
+  end
+
+  def_delegator :@store, :to_s
+  def_delegator :@store, :inspect
+end

data/lib/configatron/store.rb

@@ -0,0 +1,182 @@
+require 'forwardable'
+
+class Configatron
+  class Store < BasicObject
+    extend ::Forwardable
+
+    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 __cow
+      @cow
+    end
+
+    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 @root_store.locked?
+          ::Kernel.raise ::Configatron::UndefinedKeyError.new("Key not found: #{key} (for locked #{self})")
+        end
+        ::Configatron::Store.new(@root_store, "#{@name}.#{key}", {}, @path + [key])
+      end
+      return val
+    end
+
+    def store(key, value)
+      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
+    end
+
+    def fetch(key, default_value = nil, &block)
+      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 ::Configatron::Proc === val
+        val = val.call
+      end
+      return val
+    end
+
+    def key?(key)
+      @attributes.key?(key.to_sym)
+    end
+
+    def configure_from_hash(hash)
+      hash.each do |key, value|
+        if ::Hash === value
+          self[key].configure_from_hash(value)
+        else
+          store(key, value)
+        end
+      end
+    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 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
+
+    # So that puts works (it expects the object to respond to to_ary)
+    def to_ary
+      nil
+    end
+
+    # 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
+        if name.end_with?('=')
+          return store(name[0..-2], args[0])
+        elsif name.end_with?('!')
+          key = name[0..-2]
+          if self.has_key?(key)
+            return self[key]
+          else
+            ::Kernel.raise ::Configatron::UndefinedKeyError.new($1)
+          end
+        else
+          return self[name]
+        end
+      end
+    end
+
+    alias :[]= :store
+    alias :has_key? :key?
+    alias :to_hash :to_h
+
+    def_delegator :@attributes, :values
+    def_delegator :@attributes, :keys
+    def_delegator :@attributes, :each
+    def_delegator :@attributes, :delete
+    # def_delegator :@attributes, :fetch
+    # def_delegator :@attributes, :has_key?
+    # def_delegator :$stdout, :puts
+
+  end
+end

data/lib/configatron/version.rb

@@ -0,0 +1,3 @@
+class Configatron
+  VERSION = "4.5.2"
+end

data/lib/configatron.rb

@@ -0,0 +1,23 @@
+require 'configatron/version'
+
+require 'configatron/errors'
+require 'configatron/integrations'
+require 'configatron/root_store'
+require 'configatron/store'
+
+# Proc *must* load before dynamic/delayed, or else Configatron::Proc
+# will refer to the global ::Proc
+require 'configatron/proc'
+require 'configatron/delayed'
+require 'configatron/dynamic'
+
+class Configatron
+end
+
+# NO_EXT gets defined when you require "configatron/core", which
+# signals that you don't want any extensions. It'd be nice to have a
+# better internal signaling mechanism (could use environment
+# variables, but then they become part of the public interface).
+unless defined?(Configatron::NO_EXT)
+  require 'configatron/ext/kernel'
+end

data/lib/generators/configatron/install/install_generator.rb

@@ -0,0 +1,24 @@
+require 'rails/generators/base'
+
+class Configatron
+  class InstallGenerator < ::Rails::Generators::Base #:nodoc:
+    
+    desc 'Generates configatron files for the default Rails environments.'
+    
+    def self.source_root
+      @_configatron_source_root ||= File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+    end
+    
+    def self.banner
+      "rails generate configatron:install"
+    end
+
+    def copy_files
+      template 'initializers/configatron.rb', 'config/initializers/configatron.rb'
+      %w{defaults development production test}.each do |env|
+        template "configatron/#{env}.rb", "config/configatron/#{env}.rb"
+      end
+    end
+    
+  end
+end

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

@@ -0,0 +1,7 @@
+# Put all your default configatron settings here.
+
+# Example:
+#   configatron.emails.welcome.subject = 'Welcome!'
+#   configatron.emails.sales_reciept.subject = 'Thanks for your order'
+#
+#   configatron.file.storage = :s3

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

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

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

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

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

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

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

@@ -0,0 +1,2 @@
+require 'configatron'
+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/minitest'
+
+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/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/_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/configatron.rb

@@ -0,0 +1,194 @@
+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 'handles nested temps' do
+      @kernel.temp do
+        @kernel.a = 'Z'
+        @kernel.temp do
+          @kernel.a = 'Y'
+          assert_equal('Y', @kernel.a)
+        end
+        assert_equal('Z', @kernel.a)
+      end
+      assert_equal('A', @kernel.a)
+    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
+
+    it 'restores locking state in nested temps' do
+      @kernel.lock!
+      @kernel.temp do
+        @kernel.unlock!
+        @kernel.temp do
+          @kernel.lock!
+        end
+      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
+      original_stdout = $stdout
+      $stdout = File.open(File::NULL, "w")
+      begin
+        puts @kernel
+        puts @kernel.hi
+      ensure
+        $stdout = original_stdout
+      end
+    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_nil(@kernel.a)
+    end
+  end
+end

data/test/functional/delayed.rb

@@ -0,0 +1,18 @@
+require_relative '_lib'
+
+class Critic::Functional::DelayedTest < Critic::Functional::Test
+  before do
+    @kernel = Configatron::RootStore.new
+  end
+
+  describe 'delayed' do
+    before do
+      @kernel.a = Configatron::Delayed.new { @kernel.b }
+      @kernel.b = "expected"
+    end
+
+    it 'works independent of the order' do
+      assert_equal('expected', @kernel.a)
+    end
+  end
+end

data/test/functional/loading.rb

@@ -0,0 +1,10 @@
+require_relative '_lib'
+require 'subprocess'
+
+class Critic::Functional::ConfigatronTest < Critic::Functional::Test
+  describe 'loading' do
+    it 'does not define top-level configatron method if loading configatron/core' do
+      Subprocess.check_call([File.expand_path('../_lib/scripts/core.rb', __FILE__)])
+    end
+  end
+end

data/test/functional/minitest.rb

@@ -0,0 +1,18 @@
+require_relative '_lib'
+require 'subprocess'
+
+class Critic::Functional::MinitestTest < Critic::Functional::Test
+  include Configatron::Integrations::Minitest
+
+  describe 'multiple runs' do
+    it 'settings get reset: 1' do
+      assert(!configatron.key?(:my_crazy_setting))
+      configatron.my_crazy_setting = true
+    end
+
+    it 'settings get reset: 2' do
+      assert(!configatron.key?(:my_crazy_setting))
+      configatron.my_crazy_setting = true
+    end
+  end
+end