confset 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 78d6fd35c87f305efd074652b7382687bee16e33a696e1ae63ec605cc31d2ff6
+  data.tar.gz: c823bdae1fc505a4683a1a5ff2a798d1af65d4abd1f13f40d33594209df99434
+SHA512:
+  metadata.gz: c0aff665228c8381d782965c7342b843a3bdf0936917b26085258c1fa86ae8d8069b367fefea9237b1e73c950bb64ba89ff5bcb73d0b7f2fdb3719c749148d9c
+  data.tar.gz: 7a8e6957095c1f3dc0f21488c8df1e2a1109db6041579def3ed335584a34a0a3da731baa4eba634fb37d41619fca4046ce429fb3b0e866678ae13589aff4df4c

data/Rakefile

@@ -0,0 +1,44 @@
+#!/usr/bin/env rake
+# frozen_string_literal: true
+
+begin
+  require "bundler/setup"
+rescue LoadError
+  puts "You must `gem install bundler` and `bundle install` to run rake tasks"
+end
+
+Bundler::GemHelper.install_tasks
+
+begin
+  require "rake/testtask"
+  require "rubocop/rake_task"
+
+  RuboCop::RakeTask.new(:rubocop) do |t|
+    t.options = ["--display-cop-names"]
+  end
+rescue LoadError
+  # no rspec available
+end
+
+begin
+  require "rspec/core/rake_task"
+
+  RSpec::Core::RakeTask.new(:spec)
+rescue LoadError
+  # no rspec available
+end
+
+# Documentation
+require "rdoc/task"
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title    = "Confset #{Confset::VERSION}"
+  rdoc.options << "--line-numbers"
+  rdoc.rdoc_files.include("README.*")
+  rdoc.rdoc_files.include("CHANGELOG.*")
+  rdoc.rdoc_files.include("LICENSE.*")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+task default: %i[rubocop spec]

data/docs/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+## v1.0.0-20220527 - [Danilo Carolino](@danilogco)
+
+Initial release
+
+Build
+
+Refac the project focusing on the newer versions of the Ruby
+language and Ruby on Rails.
+
+---------------------
+
+You can find the full changelog of the original "config" gem at the link
+<https://github.com/rubyconfig/config/blob/master/CHANGELOG.md>.

data/docs/LICENSE.md

@@ -0,0 +1,29 @@
+# The MIT License (MIT)
+
+Copyright (c) 2022 DCO Tecnologia
+
+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.
+
+Third-party materials and licenses:
+
+* Confset contains Config (<https://github.com/rubyconfig/config>) which is governed by the MIT license
+  Copyright (C) 2010-2014 Jacques Crocker, Fred Wu, Piotr Kuczynski
+
+* Confset contains Deep Merge (deep_merge.rb) which is governed by the MIT license
+  Copyright (C) 2008 Steve Midgley

data/lib/confset/configuration.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Confset
+  # The main configuration backbone
+  class Configuration < Module
+    # Accepts configuration options,
+    # initializing a module that can be used to extend
+    # the necessary class with the provided config methods
+    def initialize(**attributes)
+      attributes.each do |name, default|
+        define_reader(name, default)
+        define_writer(name)
+      end
+    end
+
+    private
+      def define_reader(name, default)
+        variable = :"@#{name}"
+
+        define_method(name) do
+          if instance_variable_defined?(variable)
+            instance_variable_get(variable)
+          else
+            default
+          end
+        end
+      end
+
+      def define_writer(name)
+        variable = :"@#{name}"
+
+        define_method("#{name}=") do |value|
+          instance_variable_set(variable, value)
+        end
+      end
+  end
+end

data/lib/confset/integrations/heroku.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "bundler"
+
+module Confset
+  module Integrations
+    class Heroku < Struct.new(:app)
+      def invoke
+        puts "Setting vars..."
+        heroku_command = "config:set #{vars}"
+        heroku(heroku_command)
+        puts "Vars set:"
+        puts heroku_command
+      end
+
+      def vars
+        # Load only local options to Heroku
+        Confset.load_and_set_settings(
+            Rails.root.join("config", "settings.local.yml").to_s,
+            Rails.root.join("config", "settings", "#{environment}.local.yml").to_s,
+            Rails.root.join("config", "environments", "#{environment}.local.yml").to_s
+        )
+
+        out = ""
+        dotted_hash = to_dotted_hash Kernel.const_get(Confset.const_name).to_hash, {}, Confset.const_name
+        dotted_hash.each { |key, value| out += " #{key}=#{value} " }
+        out
+      end
+
+      def environment
+        heroku("run 'echo $RAILS_ENV'").chomp[/(\w+)\z/]
+      end
+
+      def heroku(command)
+        with_app = app ? " --app #{app}" : ""
+        `heroku #{command}#{with_app}`
+      end
+
+      def `(command)
+        Bundler.with_clean_env { super }
+      end
+
+      def to_dotted_hash(source, target = {}, namespace = nil)
+        prefix = "#{namespace}." if namespace
+        case source
+        when Hash
+          source.each do |key, value|
+            to_dotted_hash(value, target, "#{prefix}#{key}")
+          end
+        when Array
+          source.each_with_index do |value, index|
+            to_dotted_hash(value, target, "#{prefix}#{index}")
+          end
+        else
+          target[namespace] = source
+        end
+        target
+      end
+    end
+  end
+end

data/lib/confset/integrations/rails/railtie.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Confset
+  module Integrations
+    module Rails
+      class Railtie < ::Rails::Railtie
+        def preload
+          # Manually load the custom initializer before everything else
+          initializer = ::Rails.root.join("config", "initializers", "confset.rb")
+          require initializer if File.exist?(initializer)
+
+          # Parse the settings before any of the initializers
+          Confset.load_and_set_settings(
+            Confset.setting_files(::Rails.root.join("config"), ::Rails.env)
+          )
+        end
+
+        # Load rake tasks (eg. Heroku)
+        rake_tasks do
+          Dir[File.join(File.dirname(__FILE__), "../tasks/*.rake")].each { |f| load f }
+        end
+
+        config.before_configuration { preload }
+
+        # Development environment should reload settings on every request
+        if ::Rails.env.development?
+          initializer :config_reload_on_development do
+            ActiveSupport.on_load :action_controller_base do
+              if ::Rails::VERSION::MAJOR >= 4
+                prepend_before_action { ::Confset.reload! }
+              else
+                prepend_before_filter { ::Confset.reload! }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/confset/integrations/sinatra.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "confset/rack/reloader"
+
+module Confset
+  # provide helper to register within your Sinatra app
+  #
+  # set :root, File.dirname(__FILE__)
+  # register Confset
+  #
+  def self.registered(app)
+    app.configure do |inner_app|
+      env = inner_app.environment || ENV["RACK_ENV"]
+      root = inner_app.root
+
+      # use Padrino settings if applicable
+      if defined?(Padrino)
+        env = Padrino.env if Padrino.respond_to?(:env)
+        root = Padrino.root if Padrino.respond_to?(:root)
+      end
+
+      Confset.load_and_set_settings(Confset.setting_files(File.join(root, "config"), env))
+
+      inner_app.use(::Confset::Rack::Reloader) if inner_app.development?
+    end
+  end
+end

data/lib/confset/options.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require "ostruct"
+require "pathname"
+require "confset/validation/validate"
+
+module Confset
+  class Options < OpenStruct
+    include Enumerable
+    include Validation::Validate
+
+    def keys
+      marshal_dump.keys
+    end
+
+    def empty?
+      marshal_dump.empty?
+    end
+
+    def add_source!(source)
+      # handle yaml file paths
+      source = (Sources::YAMLSource.new(source)) if source.is_a?(String) || source.is_a?(::Pathname)
+      source = (Sources::HashSource.new(source)) if source.is_a?(Hash)
+
+      @config_sources ||= []
+      @config_sources << source
+    end
+
+    def prepend_source!(source)
+      source = (Sources::YAMLSource.new(source)) if source.is_a?(String) || source.is_a?(::Pathname)
+      source = (Sources::HashSource.new(source)) if source.is_a?(Hash)
+
+      @config_sources ||= []
+      @config_sources.unshift(source)
+    end
+
+    # look through all our sources and rebuild the configuration
+    def reload!
+      conf = {}
+      @config_sources.each do |source|
+        source_conf = source.load
+
+        if conf.empty?
+          conf = source_conf
+        else
+          DeepMerge.deep_merge!(
+                                source_conf,
+                                conf,
+                                preserve_unmergeables: false,
+                                knockout_prefix:       Confset.knockout_prefix,
+                                overwrite_arrays:      Confset.overwrite_arrays,
+                                merge_nil_values:      Confset.merge_nil_values,
+                                merge_hash_arrays:     Confset.merge_hash_arrays
+                               )
+        end
+      end
+
+      # swap out the contents of the OStruct with a hash (need to recursively convert)
+      marshal_load(__convert(conf).marshal_dump)
+
+      validate!
+
+      self
+    end
+
+    alias :load! :reload!
+
+    def reload_from_files(*files)
+      Confset.load_and_set_settings(files)
+      reload!
+    end
+
+    def to_hash
+      result = {}
+      marshal_dump.each do |k, v|
+        if v.instance_of? Confset::Options
+          result[k] = v.to_hash
+        elsif v.instance_of? Array
+          result[k] = descend_array(v)
+        else
+          result[k] = v
+        end
+      end
+      result
+    end
+
+    alias :to_h :to_hash
+
+    def each(*args, &block)
+      marshal_dump.each(*args, &block)
+    end
+
+    def to_json(*args)
+      require "json" unless defined?(JSON)
+      to_hash.to_json(*args)
+    end
+
+    def as_json(options = nil)
+      to_hash.as_json(options)
+    end
+
+    def merge!(hash)
+      current = to_hash
+      DeepMerge.deep_merge!(
+                            hash.dup,
+                            current,
+                            preserve_unmergeables: false,
+                            knockout_prefix:       Confset.knockout_prefix,
+                            overwrite_arrays:      Confset.overwrite_arrays,
+                            merge_nil_values:      Confset.merge_nil_values,
+                            merge_hash_arrays:     Confset.merge_hash_arrays
+                           )
+      marshal_load(__convert(current).marshal_dump)
+      self
+    end
+
+    # Some keywords that don't play nicely with OpenStruct
+    SETTINGS_RESERVED_NAMES = %w[select collect test count zip min max exit!].freeze
+
+    # An alternative mechanism for property access.
+    # This let's you do foo['bar'] along with foo.bar.
+    def [](param)
+      return super if SETTINGS_RESERVED_NAMES.include?(param)
+      send("#{param}")
+    end
+
+    def []=(param, value)
+      send("#{param}=", value)
+    end
+
+    SETTINGS_RESERVED_NAMES.each do |name|
+      define_method name do
+        self[name]
+      end
+    end
+
+    def key?(key)
+      table.key?(key)
+    end
+
+    def has_key?(key)
+      table.has_key?(key)
+    end
+
+    def method_missing(method_name, *args)
+      if Confset.fail_on_missing && method_name !~ /.*(?==\z)/m
+        raise KeyError, "key not found: #{method_name.inspect}" unless key?(method_name)
+      end
+      super
+    end
+
+    def respond_to_missing?(*args)
+      super
+    end
+
+    protected
+      def descend_array(array)
+        array.map do |value|
+          if value.instance_of? Confset::Options
+            value.to_hash
+          elsif value.instance_of? Array
+            descend_array(value)
+          else
+            value
+          end
+        end
+      end
+
+      # Recursively converts Hashes to Options (including Hashes inside Arrays)
+      def __convert(h) # :nodoc:
+        s = self.class.new
+
+        h.each do |k, v|
+          k = k.to_s if !k.respond_to?(:to_sym) && k.respond_to?(:to_s)
+
+          if v.is_a?(Hash)
+            v = v["type"] == "hash" ? v["contents"] : __convert(v)
+          elsif v.is_a?(Array)
+            v = v.collect { |e| e.instance_of?(Hash) ? __convert(e) : e }
+          end
+
+          s[k] = v
+        end
+        s
+      end
+  end
+end

data/lib/confset/rack/reloader.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Confset
+  module Rack
+    # Rack middleware the reloads Confset on every request (only use in dev mode)
+    class Reloader
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        Confset.reload!
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/confset/sources/env_source.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Confset
+  module Sources
+    # Allows settings to be loaded from a "flat" hash with string keys, like ENV.
+    class EnvSource
+      attr_reader :prefix
+      attr_reader :separator
+      attr_reader :converter
+      attr_reader :parse_values
+
+      def initialize(env,
+                     prefix: Confset.env_prefix || Confset.const_name,
+                     separator: Confset.env_separator,
+                     converter: Confset.env_converter,
+                     parse_values: Confset.env_parse_values)
+        @env = env
+        @prefix = prefix.to_s.split(separator)
+        @separator = separator
+        @converter = converter
+        @parse_values = parse_values
+      end
+
+      def load
+        return {} if @env.nil? || @env.empty?
+
+        hash = Hash.new
+
+        @env.each do |variable, value|
+          keys = variable.to_s.split(separator)
+
+          next if keys.shift(prefix.size) != prefix
+
+          keys.map! { |key|
+            case converter
+            when :downcase then
+              key.downcase
+            when nil then
+              key
+            else
+              raise "Invalid ENV variables name converter: #{converter}"
+            end
+          }
+
+          leaf = keys[0...-1].inject(hash) { |h, key|
+            h[key] ||= {}
+          }
+
+          unless leaf.is_a?(Hash)
+            conflicting_key = (prefix + keys[0...-1]).join(separator)
+            raise "Environment variable #{variable} conflicts with variable #{conflicting_key}"
+          end
+
+          leaf[keys.last] = parse_values ? __value(value) : value
+        end
+
+        hash
+      end
+
+      private
+        # Try to convert string to a correct type
+        def __value(v)
+          case v
+          when "false"
+            false
+          when "true"
+            true
+          else
+            Integer(v) rescue Float(v) rescue v
+          end
+        end
+    end
+  end
+end

data/lib/confset/sources/hash_source.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Confset
+  module Sources
+    class HashSource
+      attr_accessor :hash
+
+      def initialize(hash)
+        @hash = hash
+      end
+
+      # returns hash that was passed in to initialize
+      def load
+        hash.is_a?(Hash) ? hash : {}
+      end
+    end
+  end
+end

data/lib/confset/sources/yaml_source.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "erb"
+
+module Confset
+  module Sources
+    class YAMLSource
+      attr_accessor :path
+      attr_reader :evaluate_erb
+
+      def initialize(path, evaluate_erb: Confset.evaluate_erb_in_yaml)
+        @path = path.to_s
+        @evaluate_erb = !!evaluate_erb
+      end
+
+      # returns a config hash from the YML file
+      def load
+        if @path && File.exist?(@path)
+          file_contents = IO.read(@path)
+          file_contents = ERB.new(file_contents).result if evaluate_erb
+          result = YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(file_contents) : YAML.load(file_contents)
+        end
+
+        result || {}
+
+        rescue Psych::SyntaxError => e
+          raise "YAML syntax error occurred while parsing #{@path}. " \
+                "Please note that YAML must be consistently indented using spaces. Tabs are not allowed. " \
+                "Error: #{e.message}"
+      end
+    end
+  end
+end

data/lib/confset/tasks/heroku.rake

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "confset/integrations/heroku"
+
+namespace "confset" do
+  task :heroku, [:app] => :environment do |_, args|
+    Confset::Integrations::Heroku.new(args[:app]).invoke
+  end
+end

data/lib/confset/validation/error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Confset
+  module Validation
+    class Error < StandardError
+      def self.format(v_res)
+        v_res.errors.group_by(&:path).map do |path, messages|
+          "#{' ' * 2}#{path.join('.')}: #{messages.map(&:text).join('; ')}"
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/confset/validation/schema.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Confset
+  module Validation
+    module Schema
+      # Assigns schema configuration option
+      def schema=(value)
+        @schema = value
+      end
+
+      def schema(&block)
+        if block_given?
+          # Delay require until optional schema validation is requested
+          require "dry-validation"
+          @schema = Dry::Schema.define(&block)
+        else
+          @schema
+        end
+      end
+    end
+  end
+end

data/lib/confset/validation/validate.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "confset/validation/error"
+
+module Confset
+  module Validation
+    module Validate
+      def validate!
+        validate_using!(Confset.validation_contract)
+        validate_using!(Confset.schema)
+      end
+
+      private
+        def validate_using!(validator)
+          if validator
+            result = validator.call(to_hash)
+
+            return if result.success?
+
+            error = Confset::Validation::Error.format(result)
+            raise Confset::Validation::Error, "Confset validation failed:\n\n#{error}"
+          end
+        end
+    end
+  end
+end

data/lib/confset/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Confset
+  VERSION = "1.0.0"
+end