blueprint_config 1.0.0

data/lib/blueprint_config/configuration.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'blueprint_config/options_hash'
+require 'blueprint_config/options_array'
+
+module BlueprintConfig
+  class Configuration
+    include Singleton
+
+    attr_accessor :config, :backends
+
+    %i[dig dig! fetch \[\] method_missing].each do |method|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(...)
+          reload! unless backends&.fresh?
+          config.#{method}(...)
+        rescue KeyError => e
+          raise KeyError, e.message, caller[1..], cause: nil    
+        end
+      RUBY
+    end
+
+    def init(&block)
+      backends = BackendCollection.new
+      block.call(backends)
+      @backends = backends
+      reload!
+    end
+
+    def refine(&block)
+      backends = @backends
+      block.call(backends)
+      @backends = backends
+      reload!
+    end
+
+    def reload!
+      new_config = @backends.each_with_object(OptionsHash.new) do |backend, config|
+        config.deep_merge! OptionsHash.new(backend.load_keys, source: backend.source)
+      end
+
+      @config = new_config
+      @config = process_erb(new_config)
+    end
+
+    def process_erb(object)
+      case object
+      when String
+        if object.start_with?('<%=') && object.end_with?('%>')
+          ERB.new(object).result(binding)
+        else
+          object
+        end
+      when OptionsArray
+        object.each_with_index { |o, index| object[index] = process_erb(o) }
+      when OptionsHash
+        object.each { |k, v| object[k] = process_erb(v) }
+      else
+        object
+      end
+    end
+  end
+end

data/lib/blueprint_config/options_array.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module BlueprintConfig
+  class OptionsArray < Array
+    attr_accessor :__sources, :__indeces, :__path
+
+    def initialize(options = [], path: nil, source: nil)
+      super() # important - brackets needed to create an empty array
+      @__path = path
+      @__sources = []
+      @__indeces = []
+      options.each do |elem|
+        __push(elem, source:)
+      end
+    end
+
+    def __assign(other)
+      if other.first.to_s == '__append'
+        concat other[1..]
+        @__sources.concat other.__sources[1..]
+        @__indeces.concat other.__indeces[1..]
+      else
+        clear
+        concat(other)
+        __sources.clear
+        __sources.concat(other.__sources)
+        __indeces.clear
+        __indeces.concat(other.__indeces)
+      end
+      self
+    end
+
+    def dig(key, *identifiers)
+      super(key, *identifiers)
+    end
+
+    def merge!(other, &block)
+      @__sources.reverse_merge!(other.__sources) if other.is_a?(OptionsHash)
+      super
+    end
+
+    def __push(elem, source: nil)
+      elem = OptionsHash.new(elem, path: [@__path, size].compact.join('.'), source:) if elem.is_a?(Hash)
+      elem = self.class.new(elem, path: [@__path, size].compact.join('.'), source:) if elem.is_a?(Array)
+      @__sources.push source
+      @__indeces.push size
+      push elem
+    end
+
+    def source(*args)
+      index = args.shift
+      if index >= size
+        raise IndexError, "Configuration key '#{[@__path, index].compact.join('.')}' is not set", caller[1..],
+              cause: nil
+      end
+
+      if args.empty?
+        "#{@__sources[index]} #{[@__path, @__indeces[index]].compact.join('.')}"
+      else
+        self[index].source(*args)
+      end
+    end
+
+    def dig!(*args, &block)
+      leading = args.shift
+      if args.empty?
+        fetch(leading, &block)
+      else
+        fetch(leading, &block).dig!(*args, &block)
+      end
+    rescue IndexError => e
+      raise e, e.message, caller[1..], cause: nil
+    end
+
+    def fetch(index, *args, &block)
+      super(index, *args, &block)
+    rescue IndexError
+      raise IndexError, "Configuration key '#{[@__path, index].compact.join('.')}' is not set", caller[1..], cause: nil
+    end
+  end
+end

data/lib/blueprint_config/options_hash.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module BlueprintConfig
+  class OptionsHash < Hash
+    # include ActiveSupport::DeepMergeable
+
+    attr_accessor :__sources, :__path
+
+    def initialize(options = {}, path: nil, source: nil)
+      super() # important - brackets needed to create an empty hash
+      @__path = path
+      @__sources = {}
+      options.each do |key, value|
+        __set(key, value, source:)
+      end
+    end
+
+    def [](key)
+      super(key.to_sym)
+    end
+
+    def dig(key, *identifiers)
+      super(key.to_sym, *identifiers)
+    end
+
+    def merge!(other, &block)
+      @__sources.reverse_merge!(other.__sources) if other.is_a?(OptionsHash)
+      super
+    end
+
+    def __set(key, value, source: nil)
+      value = self.class.new(value, path: [@__path, key].compact.join('.'), source:) if value.is_a?(Hash)
+      value = OptionsArray.new(value, path: [@__path, key].compact.join('.'), source:) if value.is_a?(Array)
+      @__sources[key] = source
+      self[key.to_sym] = value
+    end
+
+    def source(*args)
+      key = args.shift
+      if args.empty?
+        "#{@__sources[key]} #{[@__path, key].compact.join('.')}"
+      else
+        unless key?(key)
+          raise KeyError, "Configuration key '#{[@__path, key].compact.join('.')}' is not set", caller[1..], cause: nil
+        end
+
+        self[key].source(*args)
+      end
+    end
+
+    def dig!(*args, &block)
+      leading = args.shift
+      if args.empty?
+        fetch(leading, &block)
+      else
+        fetch(leading, &block).dig!(*args, &block)
+      end
+    rescue KeyError => e
+      raise e, e.message, caller[1..], cause: nil
+    end
+
+    def method_missing(name, *args)
+      name_string = +name.to_s
+      if name_string.chomp!('=')
+        self[name_string] = args.first
+      else
+        questions = name_string.chomp!('?')
+        if questions
+          self[name_string].present?
+        else
+          bangs = name_string.chomp!('!')
+
+          if bangs
+            self[name_string].presence ||
+              raise(KeyError, "Configuration key '#{[@__path, name_string].compact.join('.')}' is not set", caller[1..])
+          else
+            self[name_string]
+          end
+        end
+      end
+    end
+
+    def fetch(key, *args, &block)
+      super(key.to_sym, *args, &block)
+    rescue KeyError
+      raise KeyError, "Configuration key '#{[@__path, key].compact.join('.')}' is not set", caller[1..], cause: nil
+    end
+
+    # deep_merge methods copied from ActiveSupport to avoid extra dependency
+    def deep_merge(other, &block)
+      dup.deep_merge!(other, &block)
+    end
+
+    def deep_merge!(other, &block)
+      merge!(other) do |key, this_val, other_val|
+        if this_val.is_a?(BlueprintConfig::OptionsHash) && this_val.deep_merge?(other_val)
+          this_val.deep_merge(other_val, &block)
+        elsif this_val.is_a?(BlueprintConfig::OptionsArray) && other_val.is_a?(BlueprintConfig::OptionsArray)
+          this_val.__assign(other_val, &block)
+        elsif block_given?
+          block.call(key, this_val, other_val)
+        else
+          other_val
+        end
+      end
+    end
+
+    def deep_merge?(other)
+      other.is_a?(self.class)
+    end
+  end
+end

data/lib/blueprint_config/setting.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'active_record'
+
+module BlueprintConfig
+  class Setting < ::ActiveRecord::Base
+    self.inheritance_column = nil
+
+    enum type: { section: 0, string: 1, integer: 2, boolean: 3, json: 4, selection: 5, set: 6 }
+
+    def parsed_json_value
+      parsed = begin
+        JSON.parse(value)
+      rescue StandardError
+        nil
+      end
+      parsed.is_a?(Hash) ? parsed.with_indifferent_access : parsed
+    end
+
+    def parsed_value
+      return value.to_i if integer?
+      return value.to_b if boolean?
+      return parsed_json_value if json? || set?
+
+      value
+    end
+  end
+end

data/lib/blueprint_config/version.rb

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

data/lib/blueprint_config/yaml.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'erb'
+
+module Econfig
+  class YAML
+    def initialize(path)
+      @path = path
+      @mutex = Mutex.new
+      @options = nil
+    end
+
+    def keys
+      Set.new(options.keys)
+    end
+
+    def get(key)
+      options[key]
+    end
+
+    def has_key?(key)
+      options.key?(key)
+    end
+
+    private
+
+    def path
+      raise Econfig::UninitializedError, 'Econfig.root is not set' unless Econfig.root
+
+      File.expand_path(@path, Econfig.root)
+    end
+
+    def options
+      return @options if @options
+
+      @mutex.synchronize do
+        @options ||= if File.exist?(path)
+                       ::YAML.load(::ERB.new(File.read(path)).result)[Econfig.env] || {}
+                     else
+                       {}
+                     end
+      end
+    end
+  end
+end

data/lib/blueprint_config.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'blueprint_config/version'
+require 'blueprint_config/backend/env'
+require 'blueprint_config/backend/yaml'
+require 'blueprint_config/configuration'
+require 'blueprint_config/backend_collection'
+
+module BlueprintConfig
+  class << self
+    attr_accessor :root, :env, :before_initialize, :after_initialize
+    attr_writer :shortcut_name, :env_options
+
+    def shortcut_name
+      @shortcut_name || 'AppConfig'
+    end
+
+    def env_options
+      @env_options || {}
+    end
+
+    def define_shortcut
+      Object.const_set shortcut_name, instance
+    end
+
+    def instance
+      BlueprintConfig::Configuration.instance
+    end
+
+    def init
+      before_initialize&.call
+    end
+
+    def configure_rails(config)
+      config.before_configuration do |_app|
+        BlueprintConfig.root ||= Rails.root
+        BlueprintConfig.env ||= Rails.env
+        BlueprintConfig.define_shortcut
+        BlueprintConfig.before_initialize.call
+      end
+
+      config.after_initialize do |_app|
+        BlueprintConfig.after_initialize.call
+      end
+    end
+  end
+end
+
+BlueprintConfig.env_options ||= {}
+
+BlueprintConfig.before_initialize ||= proc do
+  require 'blueprint_config/backend/credentials'
+  require 'blueprint_config/backend/active_record'
+
+  BlueprintConfig.instance.init do |backends|
+    backends.use :app,         BlueprintConfig::Backend::YAML.new('config/app.yml')
+    backends.use :credentials, BlueprintConfig::Backend::Credentials.new
+    backends.use :env,         BlueprintConfig::Backend::ENV.new(BlueprintConfig.env_options)
+    backends.use :app_local,   BlueprintConfig::Backend::YAML.new('config/app.local.yml')
+  end
+end
+
+BlueprintConfig.after_initialize ||= proc do
+  BlueprintConfig.instance.refine do |backends|
+    if backends[:env]
+      backends.insert_after :env, :db, BlueprintConfig::Backend::ActiveRecord.new
+    else
+      backends.push :db, BlueprintConfig::Backend::ActiveRecord.new
+    end
+  end
+end

data/lib/generators/blueprint_config/install/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Generate a migration for config settings in ActiveRecord
+
+Example:
+    rails generate blueprint:install
+
+    This will create:
+      db/migrate/20240107123730_create_blueprint_settings.rb

data/lib/generators/blueprint_config/install/install_generator.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module BlueprintConfig
+  class InstallGenerator < Rails::Generators::Base
+    include ActiveRecord::Generators::Migration
+
+    TEMPLATES = File.join(File.dirname(__FILE__), 'templates')
+    source_paths << TEMPLATES
+
+    def create_migration_file
+      migration_template 'migration.rb.erb', 'db/migrate/create_blueprint_settings.rb'
+    end
+
+    private
+
+    def migration_version
+      "[#{ActiveRecord::VERSION::STRING.to_f}]"
+    end
+  end
+end

data/lib/generators/blueprint_config/install/templates/migration.rb.erb

@@ -0,0 +1,18 @@
+class CreateBlueConfig < ActiveRecord::Migration<%= migration_version %>
+  def change
+    reversible do |dir|
+      dir.up do
+        # Ensure this incremental update migration is idempotent
+        # with monolithic install migration.
+        return if connection.table_exists?(:settings)
+      end
+    end
+
+    create_table :settings, id: :uuid do |t|
+      t.string :key, null: false, index: { unique: true }
+      t.integer :type, null: false, default: 0
+      t.string :value
+      t.timestamps
+    end
+  end
+end

data/spec/backend_collection_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+describe BlueprintConfig::BackendCollection do
+  let(:collection) { described_class.new }
+  let(:memory) { double('memory') }
+  let(:yaml) { double('yaml') }
+
+  describe '#[]' do
+    it 'retrieves a backend' do
+      collection.push :memory, memory
+      collection[:memory].should equal(memory)
+    end
+  end
+
+  describe '#each' do
+    it 'can be called without a block to receive an enumerator' do
+      collection.push :memory, memory
+      collection.each.take(1).should eq([memory])
+    end
+  end
+
+  describe '#push' do
+    it 'adds a new backend at the bottom' do
+      collection.push :memory, memory
+      collection.push :yaml, yaml
+      collection.to_a.should eq([memory, yaml])
+    end
+
+    it 'is aliased as `use`' do
+      collection.use :memory, memory
+      collection.use :yaml, yaml
+      collection.to_a.should eq([memory, yaml])
+    end
+
+    it 'raises an error if backend already exist' do
+      collection.push :memory, memory
+      expect { collection.push :memory, yaml }.to raise_error(KeyError, 'memory is already set')
+    end
+  end
+
+  describe '#unshift' do
+    it 'adds a new backend at the top' do
+      collection.unshift :memory, memory
+      collection.unshift :yaml, yaml
+      collection.to_a.should eq([yaml, memory])
+    end
+
+    it 'raises an error if backend already exist' do
+      collection.unshift :memory, memory
+      expect { collection.unshift :memory, yaml }.to raise_error(KeyError, 'memory is already set')
+    end
+  end
+
+  describe '#insert_before' do
+    it 'adds a new before the given backend' do
+      collection.push :quox, :quox
+      collection.push :baz, :baz
+      collection.push :foo, :foo
+      collection.insert_before :baz, :memory, memory
+      collection.to_a.should eq([:quox, memory, :baz, :foo])
+    end
+
+    it 'raises an error if the backend does not exist' do
+      expect { collection.insert_before :baz, :memory, memory }.to raise_error(KeyError, /baz is not set/)
+    end
+
+    it 'raises an error if the backend already exists' do
+      collection.push :foo, :foo
+      expect { collection.insert_before :foo, :foo, memory }.to raise_error(KeyError, /foo is already set/)
+    end
+  end
+
+  describe '#insert_after' do
+    it 'adds a new after the given backend' do
+      collection.push :quox, :quox
+      collection.push :baz, :baz
+      collection.push :foo, :foo
+      collection.insert_after :baz, :memory, memory
+      collection.to_a.should eq([:quox, :baz, memory, :foo])
+    end
+
+    it 'raises an error if the backend does not exist' do
+      expect { collection.insert_after :baz, :memory, memory }.to raise_error(KeyError, /baz is not set/)
+    end
+
+    it 'raises an error if the backend already exists' do
+      collection.push :foo, :foo
+      expect { collection.insert_after :foo, :foo, memory }.to raise_error(KeyError, /foo is already set/)
+    end
+  end
+
+  describe '#delete' do
+    it 'removes the given backend' do
+      collection.push :memory, memory
+      collection.delete :memory
+      collection[:memory].should be_nil
+    end
+
+    it 'raises an error if the backend does not exist' do
+      expect { collection.delete :redis }.to raise_error(KeyError, /redis is not set/)
+    end
+  end
+end

data/spec/blueprint_config/backend/active_record_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'active_record'
+require 'blueprint_config/backend/active_record'
+
+ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ':memory:'
+
+ActiveRecord::Base.connection.create_table :settings do |t|
+  t.string :key, null: false, index: { unique: true }
+  t.integer :type, null: false, default: 0
+  t.string :value
+  t.timestamps
+end
+
+describe BlueprintConfig::Backend::ActiveRecord do
+  let(:options) { {} }
+  let(:subject) { described_class.new(options).load_keys }
+  around do |example|
+    ActiveRecord::Base.transaction do
+      BlueprintConfig::Setting.create(key: 'foo', type: :string, value: 'bar')
+      BlueprintConfig::Setting.create(key: 'x', type: :integer, value: '1')
+      BlueprintConfig::Setting.create(key: 'a.b', type: :string, value: '1')
+
+      example.run
+      raise ActiveRecord::Rollback
+    end
+  end
+
+  context 'with default options' do
+    it 'loads all keys' do
+      expect(subject).to eq({ foo: 'bar', "a.b": '1', x: 1 })
+    end
+  end
+
+  context 'when nesting enabled' do
+    let(:options) { { nest: true } }
+    it 'loads all keys' do
+      expect(subject).to eq({ foo: 'bar', a: { b: '1' }, x: 1 })
+    end
+  end
+end

data/spec/blueprint_config/backend/env_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+RSpec.describe BlueprintConfig::Backend::ENV do
+  let(:options) { {} }
+  let(:subject) { BlueprintConfig::Backend::ENV.new(options).load_keys }
+
+  before do
+    ENV['FOO_BAR'] = 'monkey'
+    ENV['TEST'] = 'test'
+  end
+
+  context 'when everything is allowed', :aggregate_failures do
+    let(:options) { { allow_all: true } }
+    it 'copies all env variables' do
+      expect(subject[:foo_bar]).to eq('monkey')
+    end
+  end
+
+  context 'when everything is allowed and keys are nested', :aggregate_failures do
+    let(:options) { { allow_all: true, nest: true } }
+    it 'copies all env variables nesting em' do
+      expect(subject[:foo][:bar]).to eq('monkey')
+    end
+  end
+
+  context 'when keys are whitelisted', :aggregate_failures do
+    let(:options) { { whitelist_keys: [:test] } }
+    it 'copies whitelisted keys' do
+      expect(subject.keys).to eq([:test])
+    end
+  end
+
+  context 'when keys are prefix-whitelisted', :aggregate_failures do
+    let(:options) { { whitelist_prefixes: %i[foo f] } }
+    it 'copies whitelisted keys' do
+      expect(subject.keys).to eq([:foo_bar])
+    end
+  end
+
+  context 'when keys are prefix-whitelisted and', :aggregate_failures do
+    let(:options) { { whitelist_prefixes: %i[foo f], nest: true } }
+    it 'copies whitelisted keys' do
+      expect(subject.keys).to eq([:foo])
+    end
+  end
+
+  context 'when combines prefix-whitelist and whitelist', :aggregate_failures do
+    let(:options) { { whitelist_prefixes: [:foo], whitelist_keys: [:test] } }
+    it 'copies whitelisted keys' do
+      expect(subject.keys).to eq(%i[test foo_bar])
+    end
+  end
+end

data/spec/blueprint_config/backend/yaml_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+describe BlueprintConfig::Backend::YAML do
+  let(:subject) { described_class.new('config/app.yml').load_keys }
+
+  context 'when file exists' do
+    context 'when env is not set' do
+      it 'returns default section' do
+        allow(BlueprintConfig).to receive(:env).and_return(nil)
+        expect(subject).to eq(
+          {
+            array: %w[a b x],
+            array2: [{ a: { d: 1, e: 2 }, b: 2 }, { b: 1, c: 3 }, { x: 4, y: 5 }],
+            nested: { a: 1, b: 2 }
+          }
+        )
+      end
+    end
+
+    context 'when env is set' do
+      it 'returns default section merged with env section' do
+        allow(BlueprintConfig).to receive(:env).and_return('test')
+        expect(subject).to eq(
+          {
+            array: %w[a b x],
+            array2: [{ a: { d: 1, e: 2 }, b: 2 }, { b: 1, c: 3 }, { x: 4, y: 5 }],
+            nested: { a: 3, b: 2, c: 4 },
+            quox: 'baz',
+            envir: "<%= ENV['APP_EXAMPLE'] %>"
+          }
+        )
+      end
+    end
+  end
+end