unified_settings 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cc523c80caf34cfc9c862df454f01a434518c149e94ef342d354c7f5af4e40fe
+  data.tar.gz: 42e5d82f9d6b6cb4ee87b49c0ef97c987176bbb688a4f8b2492f6f4f353ff509
+SHA512:
+  metadata.gz: d7ead0fae11ea90725007c1b0c8d80c309ad12fe2e25b86181355502efca95631992ffbbee21c8416228b65937238bae242c76ddb170771f5169ca229d3567ec
+  data.tar.gz: 96a5d214ba297bee6f0cbc0e8309a34ab30a85ad4d87c91d8941ab06b17954341d6b4bbb0416850f327f642922b32bc3b352908520d778fc9296a571dc78a7d7

data/.rubocop.yml

@@ -0,0 +1,53 @@
+require:
+  - 'rubocop-performance'
+  - 'rubocop-rails'
+  - 'rubocop-minitest'
+  - 'rubocop-rake'
+
+AllCops:
+  NewCops: enable
+  # Don't run rubocop on these files/directories
+  Exclude:
+    - '**/templates/**/*'
+    - '**/vendor/**/*'
+    - 'lib/templates/**/*'
+    - 'db/**/*'
+    - 'config/**/*'
+    - 'vendor/**/*'
+    - 'bin/**/*'
+
+Layout/LineLength:
+  Max: 80
+  Exclude:
+    - 'unified_settings.gemspec'
+
+Metrics/AbcSize:
+  Max: 30
+  Exclude:
+    - 'test/**/*'
+
+Metrics/BlockLength:
+  Max: 40
+  Exclude:
+    - 'unified_settings.gemspec'
+    - 'test/**/*'
+
+Metrics/ClassLength:
+  Max: 150
+  Exclude:
+    - 'test/**/*'
+
+Metrics/MethodLength:
+  Max: 35
+  Exclude:
+    - 'test/**/*'
+
+Metrics/ModuleLength:
+  Max: 100
+
+Minitest/MultipleAssertions:
+  Max: 10
+
+Rails/RefuteMethods:
+  Exclude:
+    - 'test/**/*'

data/.ruby-gemset

@@ -0,0 +1 @@
+unified_settings

data/.ruby-version

@@ -0,0 +1 @@
+ruby-3.2.2

data/Gemfile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in unified_settings.gemspec
+gemspec
+
+gem 'bundler', '~> 2.3'
+gem 'bundler-audit', '>= 0'
+gem 'config', '>= 3.0'
+gem 'minitest', '~> 5.0'
+gem 'rake', '~> 13.0'
+gem 'rubocop', '~> 1.21'
+gem 'rubocop-minitest', '>= 0'
+gem 'rubocop-performance', '>= 0'
+gem 'rubocop-rails', '>= 0'
+gem 'rubocop-rake', '>= 0'
+gem 'ruby_audit', '>= 0'

data/Gemfile.lock

@@ -0,0 +1,129 @@
+PATH
+  remote: .
+  specs:
+    unified_settings (0.1.0)
+      activerecord (> 4.2.0)
+      activesupport (> 4.2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (7.0.6)
+      activesupport (= 7.0.6)
+    activerecord (7.0.6)
+      activemodel (= 7.0.6)
+      activesupport (= 7.0.6)
+    activesupport (7.0.6)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    ast (2.4.2)
+    bundler-audit (0.9.1)
+      bundler (>= 1.2.0, < 3)
+      thor (~> 1.0)
+    concurrent-ruby (1.2.2)
+    config (4.2.1)
+      deep_merge (~> 1.2, >= 1.2.1)
+      dry-validation (~> 1.0, >= 1.0.0)
+    deep_merge (1.2.2)
+    dry-configurable (1.0.1)
+      dry-core (~> 1.0, < 2)
+      zeitwerk (~> 2.6)
+    dry-core (1.0.0)
+      concurrent-ruby (~> 1.0)
+      zeitwerk (~> 2.6)
+    dry-inflector (1.0.0)
+    dry-initializer (3.1.1)
+    dry-logic (1.5.0)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 1.0, < 2)
+      zeitwerk (~> 2.6)
+    dry-schema (1.13.2)
+      concurrent-ruby (~> 1.0)
+      dry-configurable (~> 1.0, >= 1.0.1)
+      dry-core (~> 1.0, < 2)
+      dry-initializer (~> 3.0)
+      dry-logic (>= 1.4, < 2)
+      dry-types (>= 1.7, < 2)
+      zeitwerk (~> 2.6)
+    dry-types (1.7.1)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 1.0)
+      dry-inflector (~> 1.0)
+      dry-logic (~> 1.4)
+      zeitwerk (~> 2.6)
+    dry-validation (1.10.0)
+      concurrent-ruby (~> 1.0)
+      dry-core (~> 1.0, < 2)
+      dry-initializer (~> 3.0)
+      dry-schema (>= 1.12, < 2)
+      zeitwerk (~> 2.6)
+    i18n (1.14.1)
+      concurrent-ruby (~> 1.0)
+    json (2.6.3)
+    language_server-protocol (3.17.0.3)
+    minitest (5.18.1)
+    parallel (1.23.0)
+    parser (3.2.2.3)
+      ast (~> 2.4.1)
+      racc
+    racc (1.7.1)
+    rack (2.2.7)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.8.1)
+    rexml (3.2.5)
+    rubocop (1.54.2)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.2.2.3)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.28.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.29.0)
+      parser (>= 3.2.1.0)
+    rubocop-minitest (0.31.0)
+      rubocop (>= 1.39, < 2.0)
+    rubocop-performance (1.18.0)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    rubocop-rails (2.20.2)
+      activesupport (>= 4.2.0)
+      rack (>= 1.1)
+      rubocop (>= 1.33.0, < 2.0)
+    rubocop-rake (0.6.0)
+      rubocop (~> 1.0)
+    ruby-progressbar (1.13.0)
+    ruby_audit (2.2.0)
+      bundler-audit (~> 0.9.0)
+    thor (1.2.2)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.4.2)
+    zeitwerk (2.6.8)
+
+PLATFORMS
+  x86_64-darwin-22
+  x86_64-linux
+
+DEPENDENCIES
+  bundler (~> 2.3)
+  bundler-audit
+  config (>= 3.0)
+  minitest (~> 5.0)
+  rake (~> 13.0)
+  rubocop (~> 1.21)
+  rubocop-minitest
+  rubocop-performance
+  rubocop-rails
+  rubocop-rake
+  ruby_audit
+  unified_settings!
+
+BUNDLED WITH
+   2.4.10

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 TODO: Write your name
+
+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,249 @@
+# UnifiedSettings
+
+[![CircleCI](https://dl.circleci.com/status-badge/img/gh/prschmid/unified_settings/tree/main.svg?style=shield)](https://dl.circleci.com/status-badge/redirect/gh/prschmid/unified_settings/tree/main)
+[![Gem Version](https://badge.fury.io/rb/unified_settings.svg)](https://badge.fury.io/rb/unified_settings)
+
+A simple and unified way to get any setting in your code regardless of where it is defined.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add unified_settings
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install unified_settings
+
+## Usage
+
+### Basic Usage
+
+To get the value of `some_setting`, simply do:
+
+    UnifiedSettings.get('some_setting')
+
+Or to check if the key has been defined:
+
+    UnifiedSettings.defined?('some_setting')
+
+This will search the following locations in the following order:
+  1. ENV
+  2. Rails Credentials (if using Rails)
+  4. constants
+
+When using `UnifiedSettings.get('some_setting')`, the *first* setting that matches the provided key will be returned. As such, even if the same key is defined in ENV, Credentials and as a constant, it will return the value defined in ENV as that is what will take precedence.
+
+If one wants to change the search order, or limit what is searched, one should provided the handlers to search explicity. For example:
+
+    UnifiedSettings.get(
+        'some_setting',
+        handlers: [
+            UnifiedSettings::Handlers::Credentials,
+            UnifiedSettings::Handlers::Env
+        ]
+    )
+
+This will first search the Credentials, then ENV, and completely ignore any values that might be defined in Settings or as a constant. If there are any other places that need to be searched, a new custom handler can be created and then provided. To do this, just create a class that inherits from `UnifiedSettings::Handlers::Base` and add it to the list of handlers. For details on how to configure `UnifiedSettings` to use differnet handlers by default, see the Configuration section below.
+
+Note, by default the search is also done in a "case insensitive" manner. This means, for each setting source, it will first try to match the key as provied (e.g. `Some_Setting`). If nothing is found it will then attempt an upper case version of the key (`SOME_SETTING`) and a lower case version (`some_setting`). If this is not desired, one can do 
+
+     UnifiedSettings.get('some_setting', case_sensitive: true)
+
+### Predefined Handlers
+
+Build in are 4 pre-defined handlers that look for setting keys in predfined locattions
+
+* `UnifiedSettings::Handlers::ConfigGem`: Look for settings via the interface provied by [Config](https://github.com/rubyconfig/config)
+* `UnifiedSettings::Handlers::Constants`: Look for a setting defined by a constant
+* `UnifiedSettings::Handlers::Credentials`: Look for a setting in a Rails Credentials file
+* `UnifiedSettings::Handlers::Env`: Look for a setting defined in `ENV`
+
+### Coercing strings to objects
+
+In many instances it is only possible to define strings as the value of a setting. For example, when setting an `ENV` var `SUPER_IMPORTANT_IDS` with the value of `1,2,3,4,5`, what the user really wants is a list of numbers, and not a comma separated string. As such, `UnifiedSettings` will automatically try to coerce things that look like arrays into arrays. Furthermore, it will convert things that look like floats to floats, ints to ints, booleans to booleans, etc. This way one does not have to worry about converting the values of settings to be easily used within the application. For example, is `some_setting` had the value of `'  string, tRue,   false,1,      2.2, NiL '`, the following be returned `['string', true, false, 1, 2.2, nil]`.
+
+There are times when coercion is not desired (e.g. for things like long passcodes that may look like arrays since they may contain commas/numbers, etc.). For situations like this, simply disable the coercion.
+
+    UnifiedSettings.get(`some_setting`, coerce: false)
+### Handling Missing Keys
+
+#### Setting a Default Value
+
+In many cases there might be a default value that should be provided if a key is missing. This can be supplied as follows:
+
+    UnifiedSettings.get('some_setting', default: 'some_value')
+
+#### Logging/Raising Error
+
+By default, when there is a missing key, an message will be logged with the severity of `error`. Depending on the situation one may want a different behavior. As such, different error handlers can be passed to meet those needs. The following handlers are predefined: `:log_debug`, `:log_info`, `:log_warn`, `:log_error`, `:log_fatal`, `:raise`. For example:
+
+    UnifiedSettings.get('some_setting', on_missing_key: :raise)
+
+If these do not suffice, one can pass an anonymous function that takes `key` as a parameter. For example:
+    
+    UnifiedSettings.get(
+        'some_setting', 
+        on_missing_key: ->(key) { puts "Something is wrong with #{key}" }
+    ) 
+
+Furthermore, one can pass a list of hanlders, so that multiple things can happen. For example
+
+    UnifiedSettings.get(
+        'some_setting', 
+        on_missing_key: [
+            :log_fatal,
+            ->(key) { puts "Something is wrong with #{key}" },
+            :raise
+        ]
+    )
+
+This will run the handlers in the order that they were defined.
+
+### Nested Settings
+
+In many cases it is advantageous to have settings nested when defining them in, for example, the Rails Credentials file. For example, if we had the following defined in the Credentials file:
+
+    aws:
+        client_id: SOME_ID
+        client_secret: SOME_SECRET
+
+Then the corresponding setting keys would be:
+
+    aws.client_id
+    aws.client_secret
+
+As you can see, for nested settings, the convention to be used is to separate the elements using a '.' 
+
+The separator for ENV variables follow a slightly different as there can be issues when using a `.` in ENV variable names. As such the convention used in `UnifiedSettings` is modeled after the [Config gem](https://github.com/rubyconfig/config). When defining a value via an environment variable, the separator is a double underscore (`__`). Continuing with the above example, the ENV keys would be
+
+    AWS__CLIENT_ID
+    AWS__CLIENT_SECRET
+
+This means, if you do
+
+    UnifiedSettings.get('aws.client_id')
+
+it will look for an ENV var of the form `AWS__CLIENT_ID`.
+
+## Configuration
+
+Most of the settings that can be set at the individual call level can also be globally configured.
+
+IMPORTANT FOR RAILS: If one is planning on using `UnifiedSettings` during the initialization for other Rails gems, then this configuration MUST be done before we run `application.initialize!`.
+
+### Configuring the Handlers
+
+By default, the search order for a settings is:
+  1. ENV
+  2. Rails Credentials (if using Rails)
+  4. constants
+
+For example, if one is also using the [Config gem](https://github.com/rubyconfig/config), and would also like to search for settings there, one can add that handler.
+
+    UnifiedSettings.configure do |config|
+        config.handlers = [
+            UnifiedSettings::Handlers::Env,
+            UnifiedSettings::Handlers::Credentials,
+            UnifiedSettings::Handlers::ConfigGem,
+            UnifiedSettings::Handlers::Constants
+        ]
+    end
+
+If one needs to supply some extra parameters when initializing the handler, for example if a non-default constant is used for the `Config` gem, one needs only to pass a hash as follows:
+
+    UnifiedSettings.configure do |config|
+        config.handlers = [
+            UnifiedSettings::Handlers::Env,
+            UnifiedSettings::Handlers::Credentials,
+            {
+                handler: UnifiedSettings::Handlers::ConfigGem,
+                params: {
+                    const_name: 'ConfigSettings'
+                }
+            },
+            UnifiedSettings::Handlers::Constants
+        ]
+    end
+
+### All Other Options
+
+Instead of going through all the various options, here is a fully worked out example with inline comments.
+
+```
+UnifiedSettings.configure do |config|
+  config.handlers = [
+    UnifiedSettings::Handlers::Env,
+    UnifiedSettings::Handlers::Credentials,
+    {
+      handler: UnifiedSettings::Handlers::ConfigGem,
+      params: {
+        const_name: 'Settings'
+      }
+    },
+    UnifiedSettings::Handlers::Constants
+  ]
+
+  # Whether or not keys should be case sensitive. For example, let's assume the
+  # key foo.bar.baz is defined in one of the locations the handlers are
+  # configured to search. If we use case_sensitive = false then any of the
+  # following examples will match
+  #   UnifiedSettings.get('FOO.BAR.BAZ')
+  #   UnifiedSettings.get('foo.bar.bar')
+  #   UnifiedSettings.get('Foo.BaR.baZ')
+  # If we set set case_sensitive = true, then only if the case exactly matches
+  # the key is a result returned.
+  # Default is: config.case_sensitive = false
+  config.case_sensitive = false
+
+  # This can be any of the following pre-defined handlers:
+  #   :log_debug, :log_info, :log_warn, :log_error, :log_fatal, :raise
+  # or you can pass an anonymous function that takes `key` as a parameter. E.g.
+  #   config.on_missing_key = ->(key) { puts "Something is wrong with #{key}" }
+  # If you need multiple things to happen, simply use an Array here. E.g.
+  #   config.on_missing_key = [
+  #     :log_fatal,
+  #     ->(key) { puts "Something is wrong with #{key}" },
+  #     :raise
+  #   ]
+  # This will run the handlers in the order that they were defined.
+  #
+  # Default is: config.on_missing_key = :log_error
+  config.on_missing_key = :log_error
+
+  # The value that should be returned if no key was found. This can be a set
+  # to a particular value (e.g. `nil`, or `{}`), or can be an anonymous function
+  # that takes `key` as a parameter. E.g.
+  #   config.default_value = ->(key) { key.starts_with?('a') ? 'AA' : 'ZZ'}
+  #
+  # Default is: config.default_value = nil
+  config.default_value = nil
+
+  # The types that should be coerced from strings to their Ruby type.
+  # (e.g. "true" to the boolean true or "1.2" to the float 1.2).
+  # Default is: config.coercions = %i[nil boolean integer float]
+  config.coercions = %i[nil boolean integer float]
+
+  # Whether or not to coerce strings that look like arrays to arrays.
+  # E.g. "a, B, true,1  " would be coerced become to ["a", "B", true, 1]
+  # Defualt is:
+  #   config.coerce_arrays = true
+  #   config.coerce_array_separator = ','
+  config.coerce_arrays = true
+  config.coerce_array_separator = ','
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/prschmid/unified_settings.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/lib/unified_settings/coercer.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module UnifiedSettings
+  #
+  # This will take string values and coerce them to the approrpiate ruby
+  # objects (e.g. "true" to the boolean true or "1.2" to the float 1.2)
+  #
+  class Coercer
+    def initialize(
+      coercions: %i[nil boolean integer float],
+      coerce_arrays: true,
+      array_separator: ','
+    )
+      @coercions = coercions
+      @coerce_arrays = coerce_arrays
+      @array_separator = array_separator
+    end
+
+    def coerce(value)
+      return value unless value
+
+      # If it's already been cast to something other than a string, just
+      # return what it is.
+      return value unless value.is_a?(String)
+
+      stripped_value = value.strip
+
+      coerced_value, is_array = coerce_to_array(stripped_value)
+      if is_array
+        coerced_value.map do |array_value|
+          array_value = array_value.strip
+          coerced_value, did_coerce = coerce_value(array_value)
+          did_coerce ? coerced_value : array_value
+        end
+      else
+        coerced_value, did_coerce = coerce_value(stripped_value)
+        did_coerce ? coerced_value : stripped_value
+      end
+    end
+
+    private
+
+    def coerce_value(value)
+      return [value, false] unless value
+
+      coerced_value, did_coerce = coerce_to_nil(value)
+      return [coerced_value, did_coerce] if did_coerce
+
+      coerced_value, did_coerce = coerce_to_boolean(value)
+      return [coerced_value, did_coerce] if did_coerce
+
+      coerced_value, did_coerce = coerce_to_integer(value)
+      return [coerced_value, did_coerce] if did_coerce
+
+      coerced_value, did_coerce = coerce_to_float(value)
+      return [coerced_value, did_coerce] if did_coerce
+
+      [value, false]
+    end
+
+    def coerce_to_array(value)
+      return [value, false] unless @coerce_arrays
+      return [value, false] unless value.include?(@array_separator)
+
+      [value.split(@array_separator), true]
+    end
+
+    def coerce_to_nil(value)
+      return [value, false] unless @coercions.include?(:nil)
+      return [nil, true] if value.casecmp('nil').zero?
+
+      [value, false]
+    end
+
+    def coerce_to_boolean(value)
+      return [value, false] unless @coercions.include?(:boolean)
+      return [true, true] if value.casecmp('true').zero?
+      return [false, true] if value.casecmp('false').zero?
+
+      [value, false]
+    end
+
+    def coerce_to_integer(value)
+      return [value, false] unless @coercions.include?(:integer)
+
+      begin
+        return [Integer(value), true]
+      rescue ArgumentError # rubocop:disable Lint/SuppressedException
+      end
+
+      [value, false]
+    end
+
+    def coerce_to_float(value)
+      return [value, false] unless @coercions.include?(:float)
+
+      begin
+        return [Float(value), true]
+      rescue ArgumentError # rubocop:disable Lint/SuppressedException
+      end
+
+      [value, false]
+    end
+  end
+end

data/lib/unified_settings/handlers/base.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module UnifiedSettings
+  module Handlers
+    # Base handler for a setting source
+    #
+    # All handers should inherit from this base class and implement the method
+    #   def get(key, case_sensitive: nil)
+    class Base
+      KEY_NESTING_SEPARATOR = '.'
+
+      # rubocop:disable Lint/UnusedMethodArgument
+      def get(key, case_sensitive: nil)
+        raise 'Needs to be implemented by subclasss'
+      end
+      # rubocop:enable Lint/UnusedMethodArgument
+
+      protected
+
+      def split(val, separator)
+        case val
+        when String
+          val.split(separator)
+        when Symbol
+          val.to_s.split(separator)
+        when Array
+          val
+        else
+          raise 'key must either be a string or an array'
+        end
+      end
+
+      def case_sensitive?(case_sensitive)
+        if case_sensitive.nil?
+          UnifiedSettings.config.case_sensitive
+        else
+          case_sensitive
+        end
+      end
+
+      def to_symbol_array(val, separator: KEY_NESTING_SEPARATOR)
+        split(val, separator).map(&:to_sym)
+      end
+
+      def nested_key_exists?(hash, keys)
+        current_level = hash
+        keys.each do |key|
+          return false if current_level.nil?
+          return true if current_level.key?(key)
+
+          current_level = current_level[key]
+        end
+        false
+      end
+    end
+  end
+end

data/lib/unified_settings/handlers/config_gem.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module UnifiedSettings
+  module Handlers
+    # Setting handler for Config gem
+    class ConfigGem < Base
+      # By default the gem makes a `Settings` object available
+      DEFAULT_CONST_NAME = 'Settings'
+
+      def initialize(const_name: nil)
+        super()
+        @const_name = const_name || DEFAULT_CONST_NAME
+      end
+
+      def defined?(key, case_sensitive: nil)
+        key_arr = to_symbol_array(key)
+        case_sensitive = case_sensitive?(case_sensitive)
+
+        return true if nested_key_exists?(setting_obj, key_arr)
+        return false if case_sensitive
+
+        return true if nested_key_exists?(setting_obj, key_arr.map(&:upcase))
+        return true if nested_key_exists?(setting_obj, key_arr.map(&:downcase))
+
+        false
+      end
+
+      def get(key, case_sensitive: nil)
+        key_arr = to_symbol_array(key)
+        case_sensitive = case_sensitive?(case_sensitive)
+
+        val = setting_obj.dig(*key_arr)
+        return val if val
+        return nil if case_sensitive
+
+        val = setting_obj.dig(*key_arr.map(&:downcase))
+        return val if val
+
+        setting_obj.dig(*key_arr.map(&:upcase))
+      end
+
+      private
+
+      def setting_obj
+        Object.const_get("::#{@const_name}")
+      end
+    end
+  end
+end

data/lib/unified_settings/handlers/constants.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module UnifiedSettings
+  module Handlers
+    # Setting handler for Ruby constants
+    class Constants < Base
+      CONSTANT_KEY_NESTING_SEPARATOR = '::'
+
+      def defined?(key, case_sensitive: nil)
+        klass, variable_names = key_to_class_and_variable(
+          key, case_sensitive:
+        )
+
+        variable_names.each do |name|
+          if klass
+            return true if klass.const_get(name)
+          elsif Object.const_get(name)
+            return true
+          end
+        rescue NameError
+          # Ignore if the constant is not defined
+        end
+
+        false
+      end
+
+      def get(key, case_sensitive: nil)
+        klass, variable_names = key_to_class_and_variable(
+          key, case_sensitive:
+        )
+
+        variable_names.each do |name|
+          return klass.const_get(name) if klass
+
+          return Object.const_get(name)
+        rescue NameError
+          # Ignore if the constant is not defined
+        end
+
+        nil
+      end
+
+      private
+
+      def key_to_class_and_variable(key, case_sensitive: nil)
+        key_arr = to_symbol_array(key,
+                                  separator: CONSTANT_KEY_NESTING_SEPARATOR)
+        case_sensitive = case_sensitive?(case_sensitive)
+
+        klass, variable =
+          if key_arr.length > 1
+            [
+              key_arr[0..-2].join(CONSTANT_KEY_NESTING_SEPARATOR)
+                            .safe_constantize,
+              key_arr[-1]
+            ]
+          else
+            [nil, key_arr[0]]
+          end
+
+        variable_names = if case_sensitive
+                           [variable]
+                         else
+                           [variable, variable.upcase, variable.downcase]
+
+                         end
+
+        [klass, variable_names]
+      end
+    end
+  end
+end

data/lib/unified_settings/handlers/credentials.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module UnifiedSettings
+  module Handlers
+    # Setting handler for Rails.application.credentials
+    class Credentials < Base
+      def defined?(key, case_sensitive: nil)
+        key_arr = to_symbol_array(key)
+        case_sensitive = case_sensitive?(case_sensitive)
+
+        return true if nested_key_exists?(Rails.application.credentials,
+                                          key_arr)
+        return false if case_sensitive
+
+        return true if nested_key_exists?(
+          Rails.application.credentials, key_arr.map(&:upcase)
+        )
+        return true if nested_key_exists?(
+          Rails.application.credentials, key_arr.map(&:downcase)
+        )
+
+        false
+      end
+
+      def get(key, case_sensitive: nil)
+        key_arr = to_symbol_array(key)
+        case_sensitive = case_sensitive?(case_sensitive)
+
+        val = Rails.application.credentials.dig(*key_arr)
+        return val if val
+        return nil if case_sensitive
+
+        val = Rails.application.credentials.dig(*key_arr.map(&:downcase))
+        return val if val
+
+        Rails.application.credentials.dig(*key_arr.map(&:upcase))
+      end
+    end
+  end
+end

data/lib/unified_settings/handlers/env.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module UnifiedSettings
+  module Handlers
+    # Settings handler for ENV variables
+    class Env < Base
+      ENV_KEY_NESTING_SEPARATOR = '__'
+
+      def defined?(key, case_sensitive: nil)
+        key_arr = to_symbol_array(key)
+        case_sensitive = case_sensitive?(case_sensitive)
+
+        return true if ENV.key?(key_arr.join(ENV_KEY_NESTING_SEPARATOR))
+        return false if case_sensitive
+
+        return true if ENV.key?(
+          key_arr.map(&:upcase).join(ENV_KEY_NESTING_SEPARATOR)
+        )
+        return true if ENV.key?(
+          key_arr.map(&:downcase).join(ENV_KEY_NESTING_SEPARATOR)
+        )
+
+        false
+      end
+
+      def get(key, case_sensitive: nil)
+        key_arr = to_symbol_array(key)
+        case_sensitive = case_sensitive?(case_sensitive)
+
+        val = ENV.fetch(key_arr.join(ENV_KEY_NESTING_SEPARATOR), nil)
+        return val if val
+        return nil if case_sensitive
+
+        val = ENV.fetch(
+          key_arr.map(&:upcase).join(ENV_KEY_NESTING_SEPARATOR), nil
+        )
+        return val if val
+
+        ENV.fetch(
+          key_arr.map(&:downcase).join(ENV_KEY_NESTING_SEPARATOR), nil
+        )
+      end
+    end
+  end
+end

data/lib/unified_settings/settings.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module UnifiedSettings
+  # Settings
+  #
+  # Main interface for getting any of the settings
+  class Settings
+    attr_accessor :handlers
+
+    def initialize(handlers: nil)
+      handlers_config = handlers || UnifiedSettings.config.handlers
+      @handlers = handlers_config.map { |config| initialize_handler(config) }
+      @coercer = Coercer.new(
+        coercions: UnifiedSettings.config.coercions,
+        coerce_arrays: UnifiedSettings.config.coerce_arrays,
+        array_separator: UnifiedSettings.config.coerce_array_separator
+      )
+    end
+
+    def defined?(key, case_sensitive: nil)
+      return false unless key
+
+      @handlers.each do |handler|
+        return true if handler.defined?(key, case_sensitive:)
+      end
+
+      false
+    end
+
+    def get(
+      key, default: NO_DEFAULT, case_sensitive: nil, coerce: true,
+      on_missing_key: nil
+    )
+      return nil unless key
+
+      @handlers.each do |handler|
+        val = handler.get(key, case_sensitive:)
+        unless val.nil?
+          return coerce ? @coercer.coerce(val) : val
+        end
+      end
+
+      handle_missing_key(key, default:, on_missing_key:)
+    end
+
+    private
+
+    def initialize_handler(config)
+      handler, params = if config.respond_to?(:keys)
+                          [config[:handler], config[:params]]
+                        else
+                          [config, nil]
+                        end
+
+      case handler
+      when String
+        klass = handler.safe_constantize
+        params.blank? ? klass.new : klass.new(**params)
+      when Class
+        params.blank? ? handler.new : handler.new(**params)
+      when SettingHandler
+        handler
+      else
+        raise 'UnifiedSettings: Unsupported handler. Handlers must be an ' \
+              'array of strings, classes, or instances of ' \
+              'UnifiedSettings::SettingHandler'
+      end
+    end
+
+    def handle_missing_key(key, default: NO_DEFAULT, on_missing_key: nil)
+      handle_on_missing_key(key, on_missing_key:)
+
+      val = if default == NO_DEFAULT
+              UnifiedSettings.config.default_value
+            else
+              default
+            end
+      return val.call(key) if val.respond_to?(:call)
+
+      val
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def handle_on_missing_key(key, on_missing_key: nil)
+      actions = on_missing_key || UnifiedSettings.config.on_missing_key
+      actions = [actions] unless actions.is_a?(Array)
+
+      actions.each do |action|
+        if action.respond_to?(:call)
+          action.call(key)
+          next
+        end
+
+        case action
+        when :raise
+          on_missing_key_raise(key)
+        when :log_debug
+          on_missing_key_log(Logger::DEBUG, key)
+        when :log_info
+          on_missing_key_log(Logger::INFO, key)
+        when :log_warn
+          on_missing_key_log(Logger::WARN, key)
+        when :log_error
+          on_missing_key_log(Logger::ERROR, key)
+        when :log_fatal
+          on_missing_key_log(Logger::FATAL, key)
+        else
+          raise "UnifiedSettings: Unknown on_missing_key handler: '#{action}'"
+        end
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+
+    def on_missing_key_raise(key)
+      raise error_message(key)
+    end
+
+    def on_missing_key_log(level, key)
+      ::Rails.logger.add(level) { error_message(key) }
+    rescue NoMethodError
+      logger = Logger.new($stdout, Logger::INFO)
+      logger.add(level) { error_message(key) }
+    end
+
+    def error_message(key)
+      "UnifiedSettings: No matches found for '#{key}'"
+    end
+  end
+end

data/lib/unified_settings/unified_settings.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+# Unified way to get settings
+module UnifiedSettings
+  include ActiveSupport::Configurable
+
+  NO_DEFAULT = :no_default
+
+  def self.configure
+    # Set the defaults
+    config.handlers = [
+      Handlers::Env, Handlers::Credentials, Handlers::Constants
+    ]
+    config.default_value = nil
+    config.case_sensitive = false
+    config.on_missing_key = [:log_error]
+    config.coercions = %i[nil boolean integer float]
+    config.coerce_arrays = true
+    config.coerce_array_separator = ','
+
+    super
+
+    # Create an instance of the settings that can be used
+    @settings = Settings.new
+  end
+
+  def self.defined?(key, case_sensitive: nil, handlers: nil)
+    settings = handlers.nil? ? @settings : Settings.new(handlers:)
+    settings.defined?(key, case_sensitive:)
+  end
+
+  # rubocop:disable Metrics/ParameterLists
+  def self.get(
+    key, default: NO_DEFAULT, case_sensitive: nil, handlers: nil, coerce: true,
+    on_missing_key: nil
+  )
+    settings = handlers.nil? ? @settings : Settings.new(handlers:)
+    settings.get(
+      key,
+      case_sensitive:,
+      coerce:,
+      on_missing_key:,
+      default:
+    )
+  end
+  # rubocop:enable Metrics/ParameterLists
+end

data/lib/unified_settings/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module UnifiedSettings
+  VERSION = '0.1.0'
+end

data/lib/unified_settings.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'unified_settings/version'
+
+directories = [
+  File.join(File.dirname(__FILE__), 'unified_settings'),
+  File.join(File.dirname(__FILE__), 'unified_settings', 'handlers')
+]
+
+directories.each do |directory|
+  Dir[File.join(directory, '*.rb')].each do |file|
+    require file
+  end
+end
+
+ActiveRecord::Base.instance_eval { include UnifiedSettings }
+if defined?(Rails) && Rails.version.to_i < 4
+  raise 'This version of unified_settings requires Rails 4 or higher'
+end

data/unified_settings.gemspec

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'unified_settings/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'unified_settings'
+  spec.version = UnifiedSettings::VERSION
+  spec.authors       = ['Patrick R. Schmid']
+  spec.email         = ['prschmid@gmail.com']
+
+  spec.summary       = 'A unified way to get settings from different sources.'
+  spec.description   = 'A unified way to get settings from different sources.'
+  spec.homepage      = 'https://github.com/prschmid/unified_settings'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the
+  # 'allowed_push_host' to allow pushing to a single host or delete this
+  # section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['homepage_uri'] = spec.homepage
+    spec.metadata['source_code_uri'] = 'https://github.com/prschmid/unified_settings'
+    spec.metadata['changelog_uri'] = 'https://github.com/prschmid/unified_settings'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+          'public gem pushes.'
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 3.2'
+
+  spec.add_runtime_dependency('activerecord', '> 4.2.0')
+  spec.add_runtime_dependency('activesupport', '> 4.2.0')
+  spec.metadata['rubygems_mfa_required'] = 'true'
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: unified_settings
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Patrick R. Schmid
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-07-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+description: A unified way to get settings from different sources.
+email:
+- prschmid@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- ".ruby-gemset"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/unified_settings.rb
+- lib/unified_settings/coercer.rb
+- lib/unified_settings/handlers/base.rb
+- lib/unified_settings/handlers/config_gem.rb
+- lib/unified_settings/handlers/constants.rb
+- lib/unified_settings/handlers/credentials.rb
+- lib/unified_settings/handlers/env.rb
+- lib/unified_settings/settings.rb
+- lib/unified_settings/unified_settings.rb
+- lib/unified_settings/version.rb
+- unified_settings.gemspec
+homepage: https://github.com/prschmid/unified_settings
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/prschmid/unified_settings
+  source_code_uri: https://github.com/prschmid/unified_settings
+  changelog_uri: https://github.com/prschmid/unified_settings
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: A unified way to get settings from different sources.
+test_files: []