configatron 2.13.0 → 3.0.0.rc1

data/lib/configatron/store.rb

@@ -1,373 +1,100 @@
-class Configatron
-  class Store
-    if RUBY_VERSION.match(/^1\.9\.[^1]/)
-      require 'syck'
-      ::YAML::ENGINE.yamler = 'syck' unless RUBY_PLATFORM == 'java'
-    end
-
-    alias_method :send!, :send
-
-    # Takes an optional Hash of parameters
-    def initialize(options = {}, name = nil, parent = nil)
-      @_name = name
-      @_parent = parent
-      @_store = {}
-      configure_from_hash(options)
-      @_protected = []
-      @_locked = false
-    end
-
-    def [](key)
-      method_missing(key.to_sym)
-    end
-
-    def []=(key, value)
-      method_missing(:"#{key}=", value)
-    end
-
-    # Returns a Hash representing the configurations
-    def to_hash
-      h = Hash.new
-      @_store.each { |k,v|
-        # Descend the tree and hashify each node
-        h[k] = v.is_a?(Store) ? v.to_hash : v
-      }
-      h
-    end
+require 'forwardable'
 
-    def heirarchy
-      path = [@_name]
-      parent = @_parent
-      until parent.nil?
-        path << parent.instance_variable_get('@_name')
-        parent = parent.instance_variable_get('@_parent')
-      end
-      path.compact!
-      path.reverse!
-      path.join('.')
-    end
-
-    def configatron_keys
-      return @_store.keys.collect{|k| k.to_s}.sort
-    end
+class Configatron
+  class Store# < BasicObject
+    extend ::Forwardable
 
-    # Checks whether or not a parameter exists
-    #
-    # Examples:
-    #   configatron.i.am.alive = 'alive!'
-    #   configatron.i.am.exists?(:alive) # => true
-    #   configatron.i.am.exists?(:dead) # => false
-    def exists?(name)
-      @_store.has_key?(name.to_sym) || @_store.has_key?(name.to_s)
+    def initialize(attributes = {})
+      @__locked = false
+      @attributes = attributes || {}
+      @attributes.send(:extend, DeepClone)
     end
 
-    # respond_to to respond_to
-    def respond_to?(name)
-      exists?(name) || super
+    def lock!
+      @__locked = true
     end
 
-    def inspect
-      name = _store_name
-      f_out = []
-      @_store.each do |k, v|
-        if v.is_a?(Configatron::Store)
-          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}"
+    def [](key)
+      fetch(key.to_sym) do
+        if @__locked
+          raise Configatron::UndefinedKeyError.new("Key Not Found: #{key}")
         end
+        ::Configatron::Store.new
       end
-      f_out.compact.sort.join("\n")
     end
 
-    # Allows for the configuration of the system via a Hash
-    def configure_from_hash(options)
-      parse_options(options)
-    end
-
-    # Allows for the configuration of the system from a YAML file.
-    # Takes the path to the YAML file.  Also takes an optional parameter,
-    # <tt>:hash</tt>, that indicates a specific hash that should be
-    # loaded from the file.
-    def configure_from_yaml(path, opts = {})
-      Configatron.log.warn "DEPRECATED! (configure_from_yaml) Please stop using YAML and use Ruby instead. This method will be removed in 3.1."
-      begin
-        yml = ::Yamler.load(path)
-        yml = yml[opts[:hash]] unless opts[:hash].nil?
-        configure_from_hash(yml)
-      rescue Errno::ENOENT => e
-        puts e.message
+    def store(key, value)
+      if @__locked
+        raise Configatron::LockedError.new("Locked! Can not set key #{key}!")
       end
+      @attributes[key.to_sym] = value
     end
 
-    # Returns true if there are no configuration parameters
-    def nil?
-      return @_store.empty?
-    end
-
-    def blank?
-      value = retrieve(@_name)
-      value.respond_to?(:empty?) ? value.empty? : !value
-    end
-
-    # Retrieves a certain parameter and if that parameter
-    # doesn't exist it will return the default_value specified.
-    def retrieve(name, default_value = nil)
-      val = method_missing(name.to_sym)
-      return val.is_a?(Configatron::Store) ? default_value : val
-    end
-
-    # Removes a parameter. In the case of a nested parameter
-    # it will remove all below it.
-    def remove(name)
-      @_store.delete(name.to_sym)
-    end
-
-    # Sets a 'default' value. If there is already a value specified
-    # it won't set the value.
-    def set_default(name, default_value)
-      unless @_store[name.to_sym]
-        # @_store[name.to_sym] = parse_options(default_value)
-        self.send("#{name}=", default_value)
-      end
-    end
-
-    def method_missing(sym, *args) # :nodoc:
-      if sym.to_s.match(/(.+)=$/)
-        name = sym.to_s.gsub("=", '').to_sym
-        raise Configatron::ProtectedParameter.new(name) if @_protected.include?(name) || methods_include?(name)
-        raise Configatron::LockedNamespace.new(@_name) if @_locked && !@_store.has_key?(name)
-        @_store[name] = parse_options(*args)
-      elsif sym.to_s.match(/(.+)\?/)
-        object = _store_lookup($1.to_sym)
-        return !_object_blank?(object)
-      elsif block_given?
-        yield self.send(sym)
-      elsif @_store.has_key?(sym)
-        val = _store_lookup(sym)
-        if val.is_a?(Configatron::Proc)
-          res = val.execute
-          if val.finalize?
-            @_store[sym] = res
-          end
-          return res
+    def fetch(key, default_value = nil, &block)
+      val = @attributes[key.to_sym]
+      if val.nil?
+        if block_given?
+          val = block.call
+        elsif default_value
+          val = default_value
         end
-        return val
-      else
-        # This will error out if strict is enabled, and be a no-op
-        # otherwise. The nice thing is the error message will be the
-        # same as in the .method? case.
-        _store_lookup(sym)
-        store = Configatron::Store.new({}, sym, self)
-        @_store[sym] = store
-        return store
+        store(key, val)
       end
+      return val
     end
 
-    def ==(other) # :nodoc:
-      self.to_hash == other
-    end
-
-    # Prevents a parameter from being reassigned. If called on a 'namespace' then
-    # all parameters below it will be protected as well.
-    def protect(name)
-      @_protected << name.to_sym
-    end
-
-    # Prevents all parameters from being reassigned.
-    def protect_all!
-      @_protected.clear
-      @_store.keys.each do |k|
-        val = self.send(k)
-        val.protect_all! if val.class == Configatron::Store
-        @_protected << k
-      end
-    end
-
-    # Removes the protection of a parameter.
-    def unprotect(name)
-      @_protected.reject! { |e| e == name.to_sym }
-    end
-
-    def unprotect_all!
-      @_protected.clear
-      @_store.keys.each do |k|
-        val = self.send(k)
-        val.unprotect_all! if val.class == Configatron::Store
-      end
-    end
-
-    # Prevents a namespace from having new parameters set. The lock is applied
-    # recursively to any namespaces below it.
-    def lock(name)
-      namespace = @_store[name.to_sym]
-      raise ArgumentError, "Namespace #{name.inspect} does not exist" if namespace.nil?
-      namespace.lock!
+    def nil?
+      @attributes.empty?
     end
 
-    def unlock(name)
-      namespace = @_store[name.to_sym]
-      raise ArgumentError, "Namespace #{name.inspect} does not exist" if namespace.nil?
-      namespace.unlock!
+    def has_key?(key)
+      val = self[key]
+      !val.is_a?(Configatron::Store)
     end
 
-    # = DeepClone
-    #
-    # == Version
-    #  1.2006.05.23 (change of the first number means Big Change)
-    #
-    # == Description
-    #  Adds deep_clone method to an object which produces deep copy of it. It means
-    #  if you clone a Hash, every nested items and their nested items will be cloned.
-    #  Moreover deep_clone checks if the object is already cloned to prevent endless recursion.
-    #
-    # == Usage
-    #
-    #  (see examples directory under the ruby gems root directory)
-    #
-    #   require 'rubygems'
-    #   require 'deep_clone'
-    #
-    #   include DeepClone
-    #
-    #   obj = []
-    #   a = [ true, false, obj ]
-    #   b = a.deep_clone
-    #   obj.push( 'foo' )
-    #   p obj   # >> [ 'foo' ]
-    #   p b[2]  # >> []
-    #
-    # == Source
-    # http://simplypowerful.1984.cz/goodlibs/1.2006.05.23
-    #
-    # == Author
-    #  jan molic (/mig/at_sign/1984/dot/cz/)
-    #
-    # == Licence
-    #  You can redistribute it and/or modify it under the same terms of Ruby's license;
-    #  either the dual license version in 2003, or any later version.
-    #
-    def deep_clone( obj=self, cloned={} )
-      if cloned.has_key?( obj.object_id )
-        return cloned[obj.object_id]
-      else
-        begin
-          cl = obj.clone
-        rescue Exception
-          # unclonnable (TrueClass, Fixnum, ...)
-          cloned[obj.object_id] = obj
-          return obj
+    def configure_from_hash(hash)
+      hash.each do |key, value|
+        if value.is_a?(Hash)
+          self[key].configure_from_hash(value)
         else
-          cloned[obj.object_id] = cl
-          cloned[cl.object_id] = cl
-          if cl.is_a?( Hash )
-            cl.clone.each { |k,v|
-              cl[k] = deep_clone( v, cloned )
-            }
-          elsif cl.is_a?( Array )
-            cl.collect! { |v|
-              deep_clone( v, cloned )
-            }
-          end
-          cl.instance_variables.each do |var|
-            v = cl.instance_eval( var.to_s )
-            v_cl = deep_clone( v, cloned )
-            cl.instance_eval( "#{var} = v_cl" )
-          end
-          return cl
+          store(key, value)
         end
       end
     end
 
-    protected
-    def lock!
-      @_locked = true
-      @_store.values.each { |store| store.lock! if store.is_a?(Configatron::Store) }
-    end
-
-    def unlock!
-      @_locked = false
-      @_store.values.each { |store| store.unlock! if store.is_a?(Configatron::Store) }
+    def temp(&block)
+      @__temp = @attributes.deep_clone
+      yield
+      @attributes = @__temp
     end
 
-    private
-    def methods_include?(name)
-      self.methods.include?(RUBY_VERSION > '1.9.0' ? name.to_sym : name.to_s)
-    end
-
-    def is_syck?(obj)
-      if defined?(SYCK_CONSTANT)
-        Configatron.log.warn "DEPRECATED! (SYCK) Syck support has been removed from Configatron in Ruby 2.x. This feature will be removed entirely in Configatron 3.0. Please be advised."
-        return obj.is_a?(SYCK_CONSTANT)
-      end
-      return false
-    end
-
-    def parse_options(options)
-      if options.is_a?(Hash)
-        options.each do |k,v|
-          if v.is_a?(Hash)
-            if v.keys.length == 1 && is_syck?(v.keys.first)
-              self.method_missing("#{k}=", v.values.first.flatten)
-            else
-              self.method_missing(k.to_sym).configure_from_hash(v)
-            end
-          else
-            self.method_missing("#{k}=", v)
-          end
-        end
+    def method_missing(name, *args, &block)
+      if block_given?
+        yield self[name]
       else
-        return options
-      end
-    end
-
-    def _store_name
-      path = [@_name]
-      parent = @_parent
-      until parent.nil?
-        path << parent.instance_variable_get('@_name')
-        parent = parent.instance_variable_get('@_parent')
-      end
-      path << 'configatron'
-      path.compact!
-      path.reverse!
-      path.join('.')
-    end
-
-    # Give it this awkward name to hopefully avoid config keys people
-    # are using.
-    def _store_lookup(sym)
-      begin
-        @_store.fetch(sym)
-      rescue IndexError => e
-        raise e.class.new("#{e.message} (for #{_store_name})") if Configatron.strict
-        nil
+        name = name.to_s
+        if /(.+)=$/.match(name)
+          return store($1, args[0])
+        else
+          return self[name]
+        end
       end
     end
 
-    def _object_blank?(object) # ported ActiveSupport method
-      object.respond_to?(:empty?) ? object.empty? : !object
-    end
-
-    begin
-      undef :test # :nodoc:
-    rescue Exception => e
-    end
+    alias :[]= :store
+    alias :blank? :nil?
 
-    if RUBY_PLATFORM == 'java'
-      SYCK_CONSTANT = YAML::Yecht::MergeKey
-    elsif RUBY_VERSION.match(/^1\.9/)
-      SYCK_CONSTANT = Syck::MergeKey
-    end
+    def_delegator :@attributes, :values
+    def_delegator :@attributes, :keys
+    def_delegator :@attributes, :each
+    def_delegator :@attributes, :empty?
+    def_delegator :@attributes, :inspect
+    def_delegator :@attributes, :to_h
+    def_delegator :@attributes, :to_hash
+    def_delegator :@attributes, :delete
+    # def_delegator :@attributes, :fetch
+    # def_delegator :@attributes, :has_key?
+    # def_delegator :$stdout, :puts
 
-  end # Store
-end # Configatron
+  end
+end

data/lib/configatron/version.rb

@@ -1,3 +1,3 @@
 class Configatron
-  VERSION = "2.13.0"
+  VERSION = "3.0.0.rc1"
 end

data/lib/configatron.rb

@@ -1,17 +1,9 @@
-# You can require 'configure/core' directly to avoid loading
-# configatron's monkey patches (and you can then set
-# `Configatron.disable_monkey_patchs = true` to enforce this). If you
-# do so, no `configatron` top-level method will be defined for
-# you. You can access the configatron object by Configatron.instance.
+require "configatron/version"
+require "configatron/core"
+require "configatron/rails"
 
-base = File.join(File.dirname(__FILE__), 'configatron')
-require File.join(base, 'core')
-
-if Configatron.disable_monkey_patching
-  raise "Cannot require 'configatron' directly, since monkey patching has been disabled. Run `Configatron.disable_monkey_patching = false` to re-enable it, or always require 'configatron/core' to load Configatron."
-end
-
-require File.join(base, 'core_ext', 'kernel')
-require File.join(base, 'core_ext', 'object')
-require File.join(base, 'core_ext', 'string')
-require File.join(base, 'core_ext', 'class')
+module Kernel
+  def configatron
+    @__configatron ||= Configatron::Store.new
+  end
+end

data/test/configatron/store_test.rb

@@ -0,0 +1,191 @@
+require 'test_helper'
+
+describe Configatron::Store do
+
+  let(:store) { Configatron::Store.new }
+
+  context "[]" do
+
+    let(:store) { Configatron::Store.new(foo: "bar") }
+
+    it "returns the value if there is one" do
+      store[:foo].must_equal "bar"
+      store["foo"].must_equal "bar"
+    end
+
+    it "returns a new Configatron::Store object if there is no value" do
+      store[:unknown].must_be_kind_of Configatron::Store
+      store["unknown"].must_be_kind_of Configatron::Store
+    end
+
+  end
+
+  context "[]=" do
+
+    it "sets the value" do
+      store[:foo] = "bar"
+      store[:foo].must_equal "bar"
+      store["foo"].must_equal "bar"
+
+      store[:baz] = "bazzy"
+      store[:baz].must_equal "bazzy"
+      store["baz"].must_equal "bazzy"
+    end
+
+  end
+
+  context "fetch" do
+
+    let(:store) { Configatron::Store.new(foo: "bar") }
+
+    it "returns the value" do
+      store.fetch(:foo).must_equal "bar"
+      store.fetch("foo").must_equal "bar"
+    end
+
+    it "sets and returns the value of the default_value if no value is found" do
+      store.fetch(:bar, "bar!!").must_equal "bar!!"
+      store.bar.must_equal "bar!!"
+    end
+
+    it "sets and returns the value of the block if no value is found" do
+      store.fetch(:bar) do
+        "bar!"
+      end.must_equal "bar!"
+      store.bar.must_equal "bar!"
+    end
+
+  end
+
+  context "nil?" do
+
+    it "returns true if there is no value set" do
+      store.foo.must_be_nil
+      store.foo = "bar"
+      store.foo.wont_be_nil
+    end
+
+  end
+
+  context "empty?" do
+
+    it "returns true if there is no value set" do
+      store.foo.must_be_empty
+      store.foo = "bar"
+      store.foo.wont_be_empty
+    end
+
+  end
+
+  context "has_key?" do
+
+    it "returns true if there is a key" do
+      store.has_key?(:foo).must_equal false
+      store.foo = "bar"
+      store.has_key?(:foo).must_equal true
+    end
+
+    it "returns false if the key is a Configatron::Store" do
+      store.has_key?(:foo).must_equal false
+      store.foo = Configatron::Store.new
+      store.has_key?(:foo).must_equal false
+    end
+
+  end
+
+  context "method_missing" do
+
+    let(:store) { Configatron::Store.new(foo: "bar") }
+
+    it "returns the value if there is one" do
+      store.foo.must_equal "bar"
+    end
+
+    it "returns a Configatron::Store if there is no value" do
+      store.bar.must_be_kind_of Configatron::Store
+    end
+
+    it "works with deeply nested values" do
+      store.a.b.c.d = "DD"
+      store.a.b.c.d.must_equal "DD"
+    end
+
+  end
+
+  context "lock!" do
+
+    before do
+      store.a.b.c.d = 'DD'
+      store.lock!
+    end
+
+    it "raises an error when accessing non-existing values" do
+      store.a.wont_be_nil
+      store.a.b.wont_be_nil
+      store.a.b.c.wont_be_nil
+      store.a.b.c.d.must_equal "DD"
+      proc {store.unknown}.must_raise(Configatron::UndefinedKeyError)
+    end
+
+    it "raises an error when trying to set a non-existing key" do
+      proc {store.unknown = "known"}.must_raise(Configatron::LockedError)
+    end
+
+  end
+
+  context "temp" do
+
+    before do
+      store.a = 'A'
+      store.b = 'B'
+    end
+
+
+    it "allows for temporary setting of values" do
+      store.a.must_equal 'A'
+      store.b.must_equal 'B'
+      store.temp do
+        store.a = 'AA'
+        store.c = 'C'
+        store.a.must_equal 'AA'
+        store.b.must_equal 'B'
+        store.c.must_equal 'C'
+      end
+      store.a.must_equal 'A'
+      store.b.must_equal 'B'
+      store.c.must_be_nil
+    end
+
+  end
+
+  context "configuring" do
+
+    context "configure_from_hash" do
+
+      it "allows setup from a hash" do
+        store.configure_from_hash(one: 1, a: {b: {c: {d: "DD"}}})
+        store.one.must_equal 1
+        store.a.b.c.d.must_equal "DD"
+      end
+
+    end
+
+    context "with a block" do
+
+      before do
+        store.a.b = 'B'
+      end
+
+      it "yields up the store to configure with" do
+        store.a do |a|
+          a.c = 'CC'
+        end
+        store.a.b.must_equal 'B'
+        store.a.c.must_equal 'CC'
+      end
+
+    end
+
+  end
+
+end

data/test/configatron_test.rb

@@ -0,0 +1,5 @@
+require 'test_helper'
+
+describe Configatron do
+
+end

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+require 'bundler/setup'
+
+require 'configatron' # and any other gems you need
+
+require 'minitest/autorun'
+require "minitest-colorize"
+
+class MiniTest::Spec
+
+  class << self
+    alias :context :describe
+  end
+
+end