ultra_settings 0.0.1.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a4bf1774f001f4b527b419e5c1f19ed05556a86ecf8f88b0b07df9f828ca3c7b
+  data.tar.gz: a204f002cc7a2a5d0747cd00abd6d64f9b7facb899475a4f9d96c15eeaa8814e
+SHA512:
+  metadata.gz: 1a9a7d61e85e0c0a3cd406535f33e978b1455cfcecb66cf8376ec3d76255540b35e950e39566c86b758004e3d80491d9267c4cccb6b5a889cd964d3b3119afe9
+  data.tar.gz: e6f32cbc8d56496a7486ed05bd388e8ab93229b1df2ac016e56c9fac610dbc39ddd29c89967ae5f2ca1029f8d34919b1bbde451b31c4262adde44adde68dfa8f

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## 1.0.0
+
+### Added
+- Initial release.

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2023 Brian Durand
+
+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,42 @@
+# Unified Rails Configuration :construction:
+
+[![Continuous Integration](https://github.com/bdurand/ultra_settings/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/bdurand/ultra_settings/actions/workflows/continuous_integration.yml)
+[![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
+
+TODO
+
+## Usage
+
+```ruby
+UltraSettings.my_service.host
+
+Rails.application.settings.my_service.host
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "ultra_settings"
+```
+
+Then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install ultra_settings
+```
+
+## Contributing
+
+Open a pull request on [GitHub](https://github.com/bdurand/ultra_settings).
+
+Please use the [standardrb](https://github.com/testdouble/standard) syntax and lint your code with `standardrb --fix` before submitting.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/VERSION

@@ -0,0 +1 @@
+0.0.1.rc1

data/lib/ultra_settings/configuration.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module UltraSettings
+  class Configuration
+    include Singleton
+
+    ALLOWED_NAME_PATTERN = /\A[a-z_][a-zA-Z0-9_]*\z/
+    ALLOWED_TYPES = [:string, :symbol, :integer, :float, :boolean, :datetime, :array].freeze
+
+    class_attribute :environment_variables_disabled, instance_accessor: false, default: false
+
+    class_attribute :runtime_settings_disabled, instance_accessor: false, default: false
+
+    class_attribute :yaml_config_disabled, instance_accessor: false, default: false
+
+    class_attribute :env_var_delimiter, instance_accessor: false, default: "_"
+
+    class_attribute :setting_delimiter, instance_accessor: false, default: "."
+
+    class_attribute :env_var_upcase, instance_accessor: false, default: true
+
+    class_attribute :setting_upcase, instance_accessor: false, default: false
+
+    class_attribute :yaml_config_directory, instance_accessor: false, default: "config"
+
+    class << self
+      def define(name, type: :string, default: nil, default_if: nil, static: false, setting: nil, env_var: nil, yaml_key: nil)
+        name = name.to_s
+        type = type.to_sym
+        static = !!static
+
+        unless name.match?(ALLOWED_NAME_PATTERN)
+          raise ArgumentError.new("Invalid name: #{name.inspect}")
+        end
+
+        unless ALLOWED_TYPES.include?(type)
+          raise ArgumentError.new("Invalid type: #{type.inspect}")
+        end
+
+        unless default_if.nil? || default_if.is_a?(Proc)
+          raise ArgumentError.new("default_if must be a Proc")
+        end
+
+        defined_fields[name] = Field.new(
+          name: name,
+          type: type,
+          default: default,
+          default_if: default_if,
+          env_var: env_var,
+          setting_name: setting,
+          yaml_key: yaml_key,
+          env_var_prefix: env_var_prefix,
+          env_var_upcase: env_var_upcase,
+          setting_prefix: setting_prefix,
+          setting_upcase: setting_upcase
+        )
+
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1 # rubocop:disable Security/Eval
+          def #{name}
+            __get_value__(#{name.inspect}, #{static.inspect})
+          end
+        RUBY
+
+        if type == :boolean
+          alias_method "#{name}?", name
+        end
+      end
+
+      def env_var_prefix=(value)
+        @env_var_prefix = value&.to_s
+      end
+
+      def env_var_prefix
+        unless defined?(@env_var_prefix)
+          @env_var_prefix = default_env_var_prefix
+        end
+        @env_var_prefix
+      end
+
+      def setting_prefix=(value)
+        @setting_prefix = value&.to_s
+      end
+
+      def setting_prefix
+        unless defined?(@setting_prefix)
+          @setting_prefix = default_setting_prefix
+        end
+        @setting_prefix
+      end
+
+      def configuration_file=(value)
+        value = Pathname.new(value) if value.is_a?(String)
+        value = Rails.root + value if value && !value.absolute?
+        @configuration_file = value
+      end
+
+      def configuration_file
+        unless defined?(@configuration_file)
+          @configuration_file = default_configuration_file
+        end
+        @configuration_file
+      end
+
+      def load_yaml_config
+        return nil unless configuration_file
+        return nil unless configuration_file.exist?
+
+        Rails.application.config_for(configuration_file)
+      end
+
+      private
+
+      def defined_fields
+        unless defined?(@defined_fields)
+          @defined_fields = {}
+          if superclass < Configuration
+            superclass.send(:defined_fields).each do |name, field|
+              @defined_fields[name] = Field.new(
+                name: field.name,
+                type: field.type,
+                default: field.default,
+                default_if: field.default_if,
+                env_var: field.env_var,
+                setting_name: field.setting_name,
+                yaml_key: field.yaml_key,
+                env_var_prefix: env_var_prefix,
+                env_var_upcase: env_var_upcase,
+                setting_prefix: setting_prefix,
+                setting_upcase: setting_upcase
+              )
+            end
+          end
+        end
+        @defined_fields
+      end
+
+      def root_name
+        name.sub(/Configuration\z/, "")
+      end
+
+      def default_configuration_file
+        path = Pathname.new(yaml_config_directory)
+        path = Rails.root + path if defined?(Rails) && !path.absolute?
+        path.join(*"#{root_name.underscore}.yml".split("/"))
+      end
+
+      def default_env_var_prefix
+        prefix = root_name.underscore.gsub("/", env_var_delimiter) + env_var_delimiter
+        prefix = prefix.upcase if env_var_upcase
+        prefix
+      end
+
+      def default_setting_prefix
+        prefix = root_name.underscore.gsub("/", setting_delimiter) + setting_delimiter
+        prefix = prefix.upcase if setting_upcase
+        prefix
+      end
+    end
+
+    def initialize
+      @mutex = Mutex.new
+      @memoized_values = {}
+    end
+
+    def [](name)
+      send(name.to_s) if include?(name)
+    end
+
+    def include?(name)
+      self.class.send(:defined_fields).include?(name.to_s)
+    end
+
+    private
+
+    def __get_value__(name, static)
+      if static && @memoized_values.include?(name)
+        return @memoized_values[name]
+      end
+
+      field = self.class.send(:defined_fields)[name]
+      return nil unless field
+
+      if !Rails.application.initialized? && !static
+        raise UltraSettings::NonStaticValueError.new("Cannot access non-static field #{name} during initialization")
+      end
+
+      env = ENV unless self.class.environment_variables_disabled?
+      settings = __runtime_settings__ unless static || self.class.runtime_settings_disabled?
+      yaml_config = __yaml_config__ unless self.class.yaml_config_disabled?
+
+      value = field.value(yaml_config: yaml_config, env: env, settings: settings)
+
+      if static
+        @mutex.synchronize do
+          if @memoized_values.include?(name)
+            value = @memoized_values[name]
+          else
+            @memoized_values[name] = value
+          end
+        end
+      end
+
+      value
+    end
+
+    def __runtime_settings__
+      SuperSettings
+    end
+
+    def __yaml_config__
+      @yaml_config ||= (self.class.load_yaml_config || {})
+    end
+  end
+end

data/lib/ultra_settings/field.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module UltraSettings
+  # Definition for a field on a configuration.
+  class Field
+    attr_reader :name
+    attr_reader :type
+    attr_reader :default
+    attr_reader :default_if
+    attr_reader :env_var
+    attr_reader :setting_name
+    attr_reader :yaml_key
+    attr_reader :env_var_prefix
+    attr_reader :env_var_upcase
+    attr_reader :setting_prefix
+    attr_reader :setting_upcase
+
+    # @param name [String, Symbol] The name of the field.
+    # @param type [Symbol] The type of the field.
+    # @param default [Object] The default value of the field.
+    # @param default_if [Proc] A proc that returns true if the default value should be used.
+    # @param env_var [String, Symbol] The name of the environment variable to use for the field.
+    # @param setting_name [String, Symbol] The name of the setting to use for the field.
+    # @param yaml_key [String, Symbol] The name of the YAML key to use for the field.
+    # @param env_var_prefix [String, Symbol] The prefix to use for the environment variable name.
+    # @param env_var_upcase [Boolean] Whether or not to upcase the environment variable name.
+    # @param setting_prefix [String, Symbol] The prefix to use for the setting name.
+    # @param setting_upcase [Boolean] Whether or not to upcase the setting name.
+    def initialize(
+      name:,
+      type: :string,
+      default: nil,
+      default_if: nil,
+      env_var: nil,
+      setting_name: nil,
+      yaml_key: nil,
+      env_var_prefix: nil,
+      env_var_upcase: true,
+      setting_prefix: nil,
+      setting_upcase: false
+    )
+      @name = frozen_string(name)
+      @type = type.to_sym
+      @default = coerce_value(default).freeze
+      @default_if = default_if
+      @env_var = frozen_string(env_var)
+      @setting_name = frozen_string(setting_name)
+      @yaml_key = frozen_string(yaml_key)
+      @env_var_prefix = frozen_string(env_var_prefix)
+      @env_var_upcase = !!env_var_upcase
+      @setting_prefix = frozen_string(setting_prefix)
+      @setting_upcase = !!setting_upcase
+    end
+
+    # Get the value for the field from the passed in state.
+    #
+    # @param env [#[]] The environment variables.
+    # @param settings [#[]] The runtime settings.
+    # @param yaml_config [#[]] The YAML configuration.
+    def value(env: nil, settings: nil, yaml_config: nil)
+      val = fetch_value(env: env, settings: settings, yaml_config: yaml_config)
+      val = coerce_value(val).freeze
+      val = @default if use_default?(val)
+      val
+    end
+
+    private
+
+    def fetch_value(env:, settings:, yaml_config:)
+      value = env_value(env) if env
+      value = nil if value == ""
+
+      if value.nil? && settings
+        value = runtime_value(settings)
+        value = nil if value == ""
+      end
+
+      if value.nil? && yaml_config
+        value = yaml_value(yaml_config)
+        value = nil if value == ""
+      end
+
+      value
+    end
+
+    def coerce_value(value)
+      return nil if value.nil?
+
+      case type
+      when :integer
+        value.is_a?(Integer) ? value : value.to_s&.to_i
+      when :float
+        value.is_a?(Float) ? value : value.to_s&.to_f
+      when :boolean
+        SuperSettings::Coerce.boolean(value)
+      when :datetime
+        SuperSettings::Coerce.time(value)
+      when :array
+        Array(value).map(&:to_s)
+      when :symbol
+        value.to_s.to_sym
+      else
+        value.to_s
+      end
+    end
+
+    def env_value(env)
+      var_name = env_var
+      if var_name.nil?
+        var_name = "#{env_var_prefix}#{name}"
+        var_name = var_name.upcase if env_var_upcase
+      end
+      env[var_name.to_s]
+    end
+
+    def runtime_value(settings)
+      var_name = setting_name
+      if var_name.nil?
+        var_name = "#{setting_prefix}#{name}"
+        var_name = var_name.upcase if setting_upcase
+      end
+      settings[var_name.to_s]
+    end
+
+    def yaml_value(yaml_config)
+      key = (yaml_key || name)
+      yaml_config[key.to_s]
+    end
+
+    def use_default?(value)
+      if value && @default_if
+        @default_if.call(value)
+      else
+        value.nil?
+      end
+    end
+
+    def frozen_string(value)
+      value&.to_s&.dup&.freeze
+    end
+  end
+end

data/lib/ultra_settings.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "super_settings"
+
+require_relative "ultra_settings/configuration"
+require_relative "ultra_settings/field"
+
+# This is the root namespace for UltraSettings. You can add configurations to
+# this namespace using the add method.
+#
+# @example
+#   UltraSettings.add(:test)
+#   UltraSettings.test # => TestConfiguration.instance
+module UltraSettings
+  @configurations = {}
+  @mutex = Mutex.new
+
+  class NonStaticValueError < StandardError
+  end
+
+  class << self
+    # Adds a configuration to the root namespace. The configuration will be
+    # available as a method on the UltraSettings module with the provide name.
+    #
+    # @param name [Symbol, String] The name of the configuration.
+    # @param klass [Class, String] The class of the configuration. If this is not
+    #   provided then the class will be inferred from the name by camelizing the
+    #   name and appending "Configuration" to get the class name.
+    # @return [void]
+    def add(name, klass = nil)
+      name = name.to_s
+      unless name.match?(/\A[a-z_][a-zA-Z0-9_]*\z/)
+        raise ArgementError.new("Invalid configuration name: #{name.inspect}")
+      end
+
+      class_name = klass&.to_s
+      class_name ||= "#{name.classify}Configuration"
+
+      @mutex.synchronize do
+        @configurations.delete(name)
+
+        eval <<-RUBY, binding, __FILE__, __LINE__ + 1 # rubocop:disable Security/Eval
+          def #{name}
+            __load_config__(#{name.inspect}, #{class_name.inspect})
+          end
+        RUBY
+      end
+
+      # Control if settings can be loaded from environment variables. By default
+      # environment variables are enabled. This can also be disabled on
+      # individual Configuration classes.
+      #
+      # @param value [Boolean] Whether or not to load settings from environment variables.
+      # @return [void]
+      def environment_variables_disabled=(value)
+        Configuration.environment_variables_disabled = !!value
+      end
+
+      # Control if settings can be loaded from runtime settings. By default
+      # runtime settings are enabled. This can also be disabled on individual
+      # Configuration classes.
+      #
+      # @param value [Boolean] Whether or not to load settings from runtime settings.
+      # @return [void]
+      def runtime_settings_disabled=(value)
+        Configuration.runtime_settings_disabled = !!value
+      end
+
+      # Control if settings can be loaded from YAML configuration files. By
+      # default YAML configuration is enabled. This can also be disabled on
+      # individual Configuration classes.
+      #
+      # @param value [Boolean] Whether or not to load settings from YAML configuration.
+      # @return [void]
+      def yaml_config_disabled=(value)
+        Configuration.yaml_config_disabled = !!value
+      end
+
+      # Set the delimiter to use when determining environment variable names.
+      # By default this is an underscore.
+      #
+      # @param value [String] The delimiter to use.
+      # @return [void]
+      def env_var_delimiter=(value)
+        Configuration.env_var_delimiter = value.to_s
+      end
+
+      # Set the delimiter to use when determining setting names. By default
+      # this is a period.
+      #
+      # @param value [String] The delimiter to use.
+      def setting_delimiter=(value)
+        Configuration.setting_delimiter = value.to_s
+      end
+
+      # Control if environment variable names should be upcased. By default
+      # this is true.
+      #
+      # @param value [Boolean] Whether or not to upcase environment variable names.
+      # @return [void]
+      def env_var_upcase=(value)
+        Configuration.env_var_upcase = !!value
+      end
+
+      # Control if setting names should be upcased. By default this is false.
+      #
+      # @param value [Boolean] Whether or not to upcase setting names.
+      # @return [void]
+      def setting_upcase=(value)
+        Configuration.setting_upcase = !!value
+      end
+
+      # Set the directory to use when loading YAML configuration files. By
+      # default this is the config directory in the Rails root.
+      #
+      # @param value [String, Pathname] The directory to use.
+      # @return [void]
+      def yaml_config_directory=(value)
+        Configuration.yaml_config_directory = value.to_s
+      end
+    end
+
+    private
+
+    # Load a configuration class.
+    def __load_config__(name, class_name)
+      klass = @configurations[name]
+
+      if klass && !Rails.configuration.cache_classes
+        klass = nil if klass != class_name.constantize
+      end
+
+      unless klass
+        klass = class_name.constantize
+        @mutex.synchronize do
+          unless klass < Configuration
+            raise TypeError.new("Configuration class #{class_name} does not inherit from UltraSettings::Configuration")
+          end
+          @configurations[name] = klass
+        end
+      end
+
+      klass.instance
+    end
+  end
+end

data/ultra_settings.gemspec

@@ -0,0 +1,36 @@
+Gem::Specification.new do |spec|
+  spec.name = "ultra_settings"
+  spec.version = File.read(File.expand_path("../VERSION", __FILE__)).strip
+  spec.authors = ["Brian Durand"]
+  spec.email = ["bbdurand@gmail.com"]
+
+  spec.summary = "Unified configuration for Rails applications that allows for configuration via environment variables, YAML files, and dynamic runtime setting."
+
+  spec.homepage = "https://github.com/bdurand/ultra_settings"
+  spec.license = "MIT"
+
+  # 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.
+  ignore_files = %w[
+    .
+    Appraisals
+    Gemfile
+    Gemfile.lock
+    Rakefile
+    bin/
+    gemfiles/
+    spec/
+  ]
+  spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| ignore_files.any? { |path| f.start_with?(path) } }
+  end
+
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 2.5"
+
+  spec.add_dependency "rails", ">= 5"
+  spec.add_dependency "super_settings"
+
+  spec.add_development_dependency "bundler"
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: ultra_settings
+version: !ruby/object:Gem::Version
+  version: 0.0.1.rc1
+platform: ruby
+authors:
+- Brian Durand
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-06-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: super_settings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+- bbdurand@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- MIT-LICENSE
+- README.md
+- VERSION
+- lib/ultra_settings.rb
+- lib/ultra_settings/configuration.rb
+- lib/ultra_settings/field.rb
+- ultra_settings.gemspec
+homepage: https://github.com/bdurand/ultra_settings
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: Unified configuration for Rails applications that allows for configuration
+  via environment variables, YAML files, and dynamic runtime setting.
+test_files: []