configatronn 4.5.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 33f037ad90a09009fff36e0668cc8f2232a08a577098a930656da08bab11d653
+  data.tar.gz: d08458dfa3ad8abba43bea11c603a1a01cc5bf70c2e9e96bb9079be355de14b4
+SHA512:
+  metadata.gz: 667a6bbc0bf2a2957770d7508e9a349440c20d8f1c5957598c9b0ccc9b9b404b509254b79682d23627692dfc7efac180708aa0747883546f1543308c5777c737
+  data.tar.gz: c625e5f08734f6e7ed45f15b1483f4dc0bc07e110742cbaa5aca4673e45367ddbb1c8bc3dade7962bf7b1a9f413f4b534d9be79bf49fcc9e5ec2cf5083fd0eaa

data/.github/workflows/test.yml

@@ -0,0 +1,27 @@
+name: test
+
+on:
+  push:
+    paths-ignore:
+      - '**.md'
+  pull_request:
+    paths-ignore:
+      - '**.md'
+  schedule:
+    - cron: "0 15 * * 0"
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby: ['3.0', '3.1', '3.2', '3.3', '3.4']
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - name: Run tests
+        run: bundle update && bundle exec rake test

data/.gitignore

@@ -0,0 +1,22 @@
+doc
+*.gem
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.ruby-version
+
+.DS_Store
+*.rbc
+*.log

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in bar.gemspec
+gemspec

data/History.txt

@@ -0,0 +1,82 @@
+=== 4.5.2
+
+* Fix bug: Configatron::Integrations::Rails.init raise without Rails gem.
+* Add Ruby 3.2 support, as File.exists? alias was removed.
+* Remove deprecation warning: use assert_nil if expecting nil by Minitest.
+
+=== 4.5.1
+
+* Replace regex with end_with? in lookup
+
+=== 4.5.0
+
+* [backwards-incompatible] Switch from DeepClone to copy-on-write for temp. As part of the implementation, *values* are no longer cloned.
+
+=== 4.4.1
+
+* Make lock!/unlock! support blocks
+
+=== 4.4.0
+
+* [backwards-incompatible] Make temp preserve locking state across invocations
+
+=== 4.3.0
+
+* [backwards-incompatible] Make nil into a valid config value
+* [backwards-incompatible] Make temp clean up after itself when an exception is thrown
+
+=== 4.2.1
+
+* Fix a bug with deep cloning which caused temping to break for nested settings
+
+=== 4.2.0
+
+* [backwards-incompatible] Make to_h/to_hash recursively hashify Configatron::Stores, and resolve Configatron::Procs.
+
+=== 4.1.1
+
+* Fix delayed attributes
+
+=== 4.1.0
+
+* Fix bugs from BasicObject fallout
+* Have KernelStore proxy calls using `public_send` for consistent shadowing
+
+=== 4.0.3
+
+* Switch Store and RootStore to descend from BasicObject
+
+=== 4.0.2
+
+* Add missing require of Rails integration
+
+=== 4.0.1
+
+* Fix #inspect and #to_s methods on KernelStore to pass through to Store
+
+=== 4.0.0
+
+This is largely a restructuring of existing functionality, making it
+simpler and more consistent. The tests have also been fully
+refactored.
+
+Added the following:
+
+* A Minitest integration at Configatron::Integrations::Minitest
+* Key errors while locked return the name of the relevant configatron
+* Configatron::RootStore is now the intended way to start a new configatron hiearchy. (You should likely not initialize a Configatron::Store yourself.)
+
+Deprecated the following:
+
+* Initializing a Configatron::Store with a custom hash
+* Calling .nil?/.empty? on a Configatron::Store
+* Calling locking, temp, or reset methods directly on a Configatron::Store (moved instead to Configatron::RootStore)
+* A DeepClone module is no longer defined at the top-level
+* Removed Configatron::KernelStore
+
+Other backwards-incompatible changes:
+
+* Renamespaced Configatron::Rails under Configatron::Integrations::Rails.
+* Moved locking and temp methods to exist just on Configatron::RootStore.
+* Configatron::Store.inspect no longer takes a name
+* key? will now return true for sub-Configatron::Stores

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2013 Mark Bates
+Copyright (c) 2025 Taku Shimizu
+
+MIT License
+
+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.md

@@ -0,0 +1,312 @@
+# Configatron
+
+
+Configatron makes configuring your applications and scripts incredibly easy. No longer is a there a need to use constants or global variables. Now you can use a simple and painless system to configure your life. And, because it's all Ruby, you can do any crazy thing you would like to!
+
+One of the more important changes to V3 is that it now resembles more a `Hash` style interface. You can use `[]`, `fetch`, `each`, etc... Actually the hash notation is a bit more robust since the dot notation won't work for a few property names (a few public methods from `Configatron::Store` itself).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'configatronn'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install configatronn --pre
+```
+
+## Usage
+
+Once installed you just need to require it:
+
+```ruby
+require 'configatronn'
+```
+
+### Simple
+
+```ruby
+configatron.email = 'me@example.com'
+configatron.database.url = "postgres://localhost/foo"
+```
+
+Now, anywhere in your code you can do the following:
+
+```ruby
+configatron.email # => "me@example.com"
+configatron.database.url # => "postgres://localhost/foo"
+```
+
+Voila! Simple as can be.
+
+Now you're saying, what if I want to have a 'default' set of options, but then override them later, based on other information? Simple again. Let's use our above example. We've configured our `database.url` option to be `postgres://localhost/foo`. The problem with that is that is our production database url, not our development url. Fair enough, all you have to do is redeclare it:
+
+```ruby
+configatron.database.url = "postgres://localhost/foo_development"
+```
+
+becomes:
+
+```ruby
+configatron.email # => "me@example.com"
+configatron.database.url # => "postgres://localhost/foo_development"
+```
+
+Notice how our other configuration parameters haven't changed? Cool, eh?
+
+### Hash/YAML
+
+You can configure Configatron from a hash as well (this is particularly useful if you'd like to have configuration files):
+
+```ruby
+configatron.configure_from_hash(email: {pop: {address: 'pop.example.com', port: 110}}, smtp: {address: 'smtp.example.com'})
+
+configatron.email.pop.address # => 'pop.example.com'
+configatron.email.pop.port # => 110
+# and so on...
+```
+
+### Method vs hash access
+
+As a note, method (`configatron.foo`) access will be shadowed by public methods defined on the configatron object. (The configatron object descends from [`BasicObject`](http://apidock.com/ruby/BasicObject) and adds a few methods to resemble the `Hash` API and to play nice with `puts`, so it should have a pretty bare set of methods.)
+
+If you need to use keys that are themselves method names, you can just use hash access (`configatron['foo']`).
+
+### Namespaces
+
+The question that should be on your lips is what I need to have namespaced configuration parameters. It's easy! Configatron allows you to create namespaces.
+
+```ruby
+configatron.website_url = "http://www.example.com"
+configatron.email.pop.address = "pop.example.com"
+configatron.email.pop.port = 110
+configatron.email.smtp.address = "smtp.example.com"
+configatron.email.smtp.port = 25
+
+configatron.to_h # => {:website_url=>"http://www.example.com", :email=>{:pop=>{:address=>"pop.example.com", :port=>110}, :smtp=>{:address=>"smtp.example.com", :port=>25}}}
+```
+
+Configatron allows you to nest namespaces to your hearts content! Just keep going, it's that easy.
+
+Of course you can update a single parameter n levels deep as well:
+
+```ruby
+configatron.email.pop.address = "pop2.example.com"
+
+configatron.email.pop.address # => "pop2.example.com"
+configatron.email.smtp.address # => "smtp.example.com"
+```
+
+Configatron will also let you use a block to clean up your configuration. For example the following two ways of setting values are equivalent:
+
+```ruby
+configatron.email.pop.address = "pop.example.com"
+configatron.email.pop.port = 110
+
+configatron.email.pop do |pop|
+  pop.address = "pop.example.com"
+  pop.port = 110
+end
+```
+
+### Temp Configurations
+
+Sometimes in testing, or other situations, you want to temporarily change some settings. You can do this with the `temp` method (only available on the top-level configatron `RootStore`):
+
+```ruby
+configatron.one = 1
+configatron.letters.a = 'A'
+configatron.letters.b = 'B'
+configatron.temp do
+  configatron.letters.b = 'bb'
+  configatron.letters.c = 'c'
+  configatron.one # => 1
+  configatron.letters.a # => 'A'
+  configatron.letters.b # => 'bb'
+  configatron.letters.c # => 'c'
+end
+configatron.one # => 1
+configatron.letters.a # => 'A'
+configatron.letters.b # => 'B'
+configatron.letters.c # => {}
+```
+
+### Delayed and Dynamic Configurations
+
+There are times when you want to refer to one configuration setting in another configuration setting. Let's look at a fairly contrived example:
+
+```ruby
+configatron.memcached.servers = ['127.0.0.1:11211']
+configatron.page_caching.servers = configatron.memcached.servers
+configatron.object_caching.servers = configatron.memcached.servers
+
+if Rails.env == 'production'
+  configatron.memcached.servers = ['192.168.0.1:11211']
+  configatron.page_caching.servers = configatron.memcached.servers
+  configatron.object_caching.servers = configatron.memcached.servers
+elsif Rails.env == 'staging'
+  configatron.memcached.servers = ['192.168.0.2:11211']
+  configatron.page_caching.servers = configatron.memcached.servers
+  configatron.object_caching.servers = configatron.memcached.servers
+end
+```
+
+Now, we could've written that slightly differently, but it helps to illustrate the point. With Configatron you can create `Delayed` and `Dynamic` settings.
+
+#### Delayed
+
+With `Delayed` settings execution of the setting doesn't happen until the first time it is executed.
+
+```ruby
+configatron.memcached.servers = ['127.0.0.1:11211']
+configatron.page_caching.servers = Configatron::Delayed.new {configatron.memcached.servers}
+configatron.object_caching.servers = Configatron::Delayed.new {configatron.memcached.servers}
+
+if Rails.env == 'production'
+  configatron.memcached.servers = ['192.168.0.1:11211']
+elsif Rails.env == 'staging'
+  configatron.memcached.servers = ['192.168.0.2:11211']
+end
+```
+
+Execution occurs once and after that the result of that execution is returned. So in our case the first time someone calls the setting `configatron.page_caching.servers` it will find the `configatron.memcached.servers` setting and return that. After that point if the `configatron.memcached.servers` setting is changed, the original settings are returned by `configatron.page_caching.servers`.
+
+#### Dynamic
+
+`Dynamic` settings are very similar to `Delayed` settings, but with one big difference. Every time you call a `Dynamic` setting is executed. Take this example:
+
+```ruby
+configatron.current.time = Configatron::Dynamic.new {Time.now}
+```
+
+Each time you call `configatron.current.time` it will return a new value to you. While this seems a bit useless, it is pretty useful if you have ever changing configurations.
+
+### Reseting Configurations
+
+In some testing scenarios, it can be helpful to restore Configatron to its default state. This can be done with:
+
+```ruby
+configatron.reset!
+``` 
+
+### Checking keys
+
+Even if parameters haven't been set, you can still call them, but you'll get a `Configatron::Store` object back. You can use `.has_key?` to determine if a key already exists.
+
+```ruby
+configatron.i.dont.has_key?(:exist) # => false
+```
+
+#### (key)!
+
+You can also append a `!` to the end of any key. If the key exists it will return it, otherwise it will raise a `Configatron::UndefinedKeyError`.
+
+``` ruby
+configatron.a.b = 'B'
+configatron.a.b # => 'B'
+configatron.a.b! # => 'B'
+configatron.a.b.c! # => raise Configratron::UndefinedKeyError
+```
+
+### Kernel
+
+The `configatron` "helper" method is stored in the `Kernel` module. You can opt-out of this global monkey-patching by requiring `configatron/core` rather than `configatron`. You'll have to set up your own `Configatron::RootStore` object.
+
+Example:
+
+```ruby
+require 'configatronn/core'
+
+store = Configatron::RootStore.new
+store.foo = 'FOO'
+
+store.to_h #= {foo: 'FOO'}
+```
+
+### Locking
+
+Once you have setup all of your configurations you can call the `lock!` method to lock your settings and raise an error should anyone try to change settings or access an unset setting later.
+
+Example:
+
+```ruby
+configatron.foo = 'FOO'
+configatron.lock!
+
+configatron.foo # => 'FOO'
+
+configatron.bar # => raises Configatron::UndefinedKeyError
+configatron.bar = 'BAR' # => raises Configatron::LockedError
+```
+
+## Rails
+
+Configatron works great with Rails. Use the built-in generate to generate an initializer file and a series of environment files for you to use to configure your applications.
+
+``` bash
+$ rails generate configatron:install
+```
+
+Configatron will read in the `config/configatron/defaults.rb` file first and then the environment specific file, such as `config/configatron/development.rb`. Settings in the environment file will merge into and replace the settings in the `defaults.rb` file.
+
+### Example
+
+```ruby
+# config/configatron/defaults.rb
+configatron.letters.a = 'A'
+configatron.letters.b = 'B'
+```
+
+```ruby
+# config/configatron/development.rb
+configatron.letters.b = 'BB'
+configatron.letters.c = 'C'
+```
+
+```ruby
+configatron.to_h # => {:letters=>{:a=>"A", :b=>"BB", :c=>"C"}}
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Write Tests!
+4. Commit your changes (`git commit -am 'Add some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request
+
+## Contributors (markbates/configatron)
+
+* Mark Bates
+* Greg Brockman
+* Kurtis Rainbolt-Greene
+* Rob Sanheim
+* Jérémy Lecour
+* Cody Maggard
+* Jean-Denis Vauguet
+* chatgris
+* Simon Menke
+* Mat Brown
+* Torsten Schönebaum
+* Gleb Pomykalov
+* Casper Gripenberg
+* Artiom Diomin
+* mattelacchiato
+* Dan Pickett
+* Tim Riley
+* Rick Fletcher
+* Jose Antonio Pio
+* Brandon Dimcheff
+* joe miller
+* Josh Nichols

data/Rakefile

@@ -0,0 +1,15 @@
+require 'bundler'
+require 'rake/testtask'
+
+Bundler::GemHelper.install_tasks
+
+Rake::TestTask.new do |t|
+  t.libs = ["lib"]
+  # t.warning = true
+  t.verbose = true
+  t.test_files = FileList['test/**/*.rb'].reject do |file|
+    file.end_with?('_lib.rb') || file.include?('/_lib/')
+  end
+end
+
+task :default => :test

data/configatronn.gemspec

@@ -0,0 +1,28 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'configatron/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'configatronn'
+  gem.version       = Configatron::VERSION
+  gem.authors       = ['Taku Shimizu']
+  gem.email         = ['t_shimizu@soloshmz.com']
+  gem.description   = 'A powerful Ruby configuration system.'
+  gem.summary       = 'A powerful Ruby configuration system.'
+  gem.homepage      = 'https://github.com/shi-tak/configatronn'
+  gem.license       = 'MIT'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_development_dependency 'minitest', '>=5.2.3'
+  gem.add_development_dependency 'mocha'
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rubocop'
+  gem.add_development_dependency 'rubocop-minitest'
+  gem.add_development_dependency 'rubocop-performance'
+  gem.add_development_dependency 'rubocop-rake'
+  gem.add_development_dependency 'subprocess'
+end

data/lib/configatron/core.rb

@@ -0,0 +1,6 @@
+class Configatron
+  # Signals that we should not load the extensions.
+  NO_EXT = true
+end
+
+require 'configatron'

data/lib/configatron/delayed.rb

@@ -0,0 +1,2 @@
+class Configatron::Delayed < Configatron::Proc
+end

data/lib/configatron/dynamic.rb

@@ -0,0 +1,7 @@
+class Configatron::Dynamic < Configatron::Proc
+
+  def finalize?
+    false
+  end
+
+end

data/lib/configatron/errors.rb

@@ -0,0 +1,9 @@
+class Configatron
+  class UndefinedKeyError < StandardError
+    def initialize(msg)
+      super(msg)
+    end
+  end
+  class LockedError < StandardError
+  end
+end

data/lib/configatron/ext/kernel.rb

@@ -0,0 +1,5 @@
+module Kernel
+  def configatron
+    Configatron::RootStore.instance
+  end
+end

data/lib/configatron/integrations/minitest.rb

@@ -0,0 +1,29 @@
+# Include in a minitest to restore the global configatron object to
+# its global state afterwards. Particularly useful if you'd like to test
+# your application with various config settings.
+#
+# ```ruby
+# class Test::Suite < Minitest::Unit
+#   include Configatron::Integrations::Minitest
+#
+#   it 'works' do
+#     configatron.unlock! do
+#       configatron.some.setting = true
+#     end
+#
+#     [...]
+#   end
+# ```
+module Configatron::Integrations
+  module Minitest
+    def before_setup
+      configatron.temp_start
+      super
+    end
+
+    def before_teardown
+      super
+      configatron.temp_end
+    end
+  end
+end

data/lib/configatron/integrations/rails.rb

@@ -0,0 +1,53 @@
+module Configatron::Integrations
+  # Helpful for making using configatron with Rails even easier!
+  #
+  # To get started you can use the generator to generate
+  # the necessary stub files.
+  #
+  #   $ rails g configatron:install
+  module Rails
+
+    # Loads configatron files in the following order:
+    #
+    # Example:
+    #   <Rails.root>/config/configatron/defaults.rb
+    #   <Rails.root>/config/configatron/<Rails.env>.rb
+    #   # optional:
+    #   <Rails.root>/config/configatron/<Rails.env>/defaults.rb
+    #   <Rails.root>/config/configatron/<Rails.env>/bar.rb
+    #   <Rails.root>/config/configatron/<Rails.env>/foo.rb
+    def self.init(root = nil, env = nil)
+      base_dir = root
+      if root.nil?
+        root = defined?(::Rails) ? ::Rails.root : FileUtils.pwd
+        base_dir = File.expand_path(File.join(root, 'config', 'configatron'))
+      end
+
+      if env.nil?
+        env = defined?(::Rails) ? ::Rails.env : 'development'
+      end
+
+      config_files = []
+
+      config_files << File.join(base_dir, 'defaults.rb')
+      config_files << File.join(base_dir, "#{env}.rb")
+
+      env_dir = File.join(base_dir, env)
+      config_files << File.join(env_dir, 'defaults.rb')
+
+      Dir.glob(File.join(env_dir, '*.rb')).sort.each do |f|
+        config_files << f
+      end
+
+      config_files.collect! {|config| File.expand_path(config)}.uniq!
+
+      config_files.each do |config|
+        if File.exist?(config)
+          # puts "Configuration: #{config}"
+          require config
+        end
+      end
+    end
+
+  end # Rails
+end # Configatron

data/lib/configatron/integrations.rb

@@ -0,0 +1,4 @@
+module Configatron::Integrations; end
+
+require 'configatron/integrations/minitest'
+require 'configatron/integrations/rails'

data/lib/configatron/proc.rb

@@ -0,0 +1,34 @@
+class Configatron
+
+  class Proc
+
+    attr_accessor :execution_count
+    attr_accessor :block
+
+    def initialize(&block)
+      self.execution_count = 0
+      self.block = block
+    end
+
+    def call
+      unless @val
+        val = self.block.call
+        self.execution_count += 1
+        if finalize?
+          @val = val
+        end
+      end
+      return val || @val
+    end
+
+    def finalize?
+      true
+    end
+
+    def inspect
+      call.inspect
+    end
+
+  end
+
+end