blueprint_config 1.3.1 → 1.5.0

data/lib/blueprint_config/options_hash.rb

@@ -108,5 +108,25 @@ module BlueprintConfig
     def deep_merge?(other)
       other.is_a?(self.class)
     end
+
+    def with_sources
+      result = {}
+      each do |key, value|
+        if value.is_a?(BlueprintConfig::OptionsHash)
+          result[key] = value.with_sources
+        elsif value.is_a?(BlueprintConfig::OptionsArray)
+          result[key] = {
+            value: value.to_a,
+            source: @__sources[key]
+          }
+        else
+          result[key] = {
+            value: value,
+            source: @__sources[key]
+          }
+        end
+      end
+      result
+    end
   end
 end

data/lib/blueprint_config/setting.rb

@@ -6,7 +6,7 @@ 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 }
+    enum :type, { section: 0, string: 1, integer: 2, boolean: 3, json: 4, selection: 5, set: 6 }
 
     def parsed_json_value
       parsed = begin

data/lib/blueprint_config/version.rb

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

data/lib/blueprint_config.rb

@@ -3,6 +3,7 @@
 require 'blueprint_config/version'
 require 'blueprint_config/backend/env'
 require 'blueprint_config/backend/yaml'
+require 'blueprint_config/backend/memory'
 require 'blueprint_config/configuration'
 require 'blueprint_config/backend_collection'
 
@@ -59,6 +60,11 @@ BlueprintConfig.before_initialize ||= proc do
     backends.use :credentials, BlueprintConfig::Backend::Credentials.new
     backends.use :env,         BlueprintConfig::Backend::ENV.new(BlueprintConfig.env_backend_options)
     backends.use :app_local,   BlueprintConfig::Backend::YAML.new('config/app.local.yml')
+    
+    # Memory backend with highest priority for test environment (added last)
+    if defined?(Rails) && Rails.env.test?
+      backends.use :memory, BlueprintConfig::Backend::Memory.new
+    end
   end
 end
 
@@ -71,5 +77,12 @@ BlueprintConfig.after_initialize ||= proc do
     else
       backends.push :db, ar_backend
     end
+
+    # Ensure memory backend is always last (highest priority) in test environment
+    if defined?(Rails) && Rails.env.test? && backends[:memory]
+      memory_backend = backends[:memory]
+      backends.delete(:memory)
+      backends.push :memory, memory_backend
+    end
   end
 end

data/spec/backend_source_tracking_spec.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'blueprint_config'
+require 'blueprint_config/backend/yaml'
+require 'blueprint_config/backend/credentials'
+require 'blueprint_config/backend/env'
+require 'blueprint_config/backend/active_record'
+require 'blueprint_config/backend/memory'
+
+describe 'Backend source tracking' do
+  describe BlueprintConfig::Backend::YAML do
+    let(:yaml_backend) { described_class.new('config/test.yml') }
+    
+    describe '#source' do
+      it 'includes the file path' do
+        expect(yaml_backend.source).to eq('BlueprintConfig::Backend::YAML(config/test.yml)')
+      end
+    end
+  end
+
+  describe BlueprintConfig::Backend::Credentials do
+    let(:credentials_backend) { described_class.new }
+    
+    describe '#source' do
+      context 'without Rails' do
+        before do
+          hide_const('Rails')
+        end
+        
+        it 'returns just the class name' do
+          expect(credentials_backend.source).to eq('BlueprintConfig::Backend::Credentials')
+        end
+      end
+      
+      context 'with Rails in development' do
+        before do
+          unless defined?(Rails)
+            module Rails
+              def self.env
+                ActiveSupport::StringInquirer.new('development')
+              end
+              def self.root
+                Pathname.new('/app')
+              end
+            end
+          end
+        end
+        
+        after do
+          Object.send(:remove_const, :Rails) if defined?(Rails)
+        end
+        
+        it 'shows environment info when no env-specific file exists' do
+          allow(File).to receive(:exist?).with('config/credentials/development.yml.enc').and_return(false)
+          expect(credentials_backend.source).to eq('BlueprintConfig::Backend::Credentials(global)')
+        end
+        
+        it 'shows merged info when env-specific file exists' do
+          allow(File).to receive(:exist?).with('config/credentials/development.yml.enc').and_return(true)
+          expect(credentials_backend.source).to eq('BlueprintConfig::Backend::Credentials(global + development)')
+        end
+      end
+    end
+  end
+
+  describe BlueprintConfig::Backend::ENV do
+    describe '#source' do
+      it 'returns class name when no options' do
+        env_backend = described_class.new
+        expect(env_backend.source).to eq('BlueprintConfig::Backend::ENV')
+      end
+      
+      it 'includes whitelist_keys when configured' do
+        env_backend = described_class.new(whitelist_keys: ['API_KEY', 'SECRET'])
+        expect(env_backend.source).to eq('BlueprintConfig::Backend::ENV(whitelist_keys: API_KEY, SECRET)')
+      end
+      
+      it 'includes whitelist_prefixes when configured' do
+        env_backend = described_class.new(whitelist_prefixes: ['APP_', 'MYAPP_'])
+        expect(env_backend.source).to eq('BlueprintConfig::Backend::ENV(whitelist_prefixes: APP_, MYAPP_)')
+      end
+      
+      it 'includes both options when configured' do
+        env_backend = described_class.new(
+          whitelist_keys: ['API_KEY'],
+          whitelist_prefixes: ['APP_']
+        )
+        expect(env_backend.source).to eq('BlueprintConfig::Backend::ENV(whitelist_keys: API_KEY, whitelist_prefixes: APP_)')
+      end
+    end
+  end
+
+  describe BlueprintConfig::Backend::ActiveRecord do
+    let(:ar_backend) { described_class.new }
+    
+    describe '#source' do
+      context 'when table exists' do
+        before do
+          allow(ar_backend).to receive(:table_exist?).and_return(true)
+          ar_backend.instance_variable_set(:@configured, true)
+        end
+        
+        it 'shows settings table' do
+          expect(ar_backend.source).to eq('BlueprintConfig::Backend::ActiveRecord(settings table)')
+        end
+      end
+      
+      context 'when not configured' do
+        before do
+          ar_backend.instance_variable_set(:@configured, false)
+        end
+        
+        it 'shows not available' do
+          expect(ar_backend.source).to eq('BlueprintConfig::Backend::ActiveRecord(not available)')
+        end
+      end
+    end
+  end
+
+  describe BlueprintConfig::Backend::Memory do
+    let(:memory_backend) { described_class.new }
+    
+    describe '#source' do
+      it 'returns the class name' do
+        expect(memory_backend.source).to eq('BlueprintConfig::Backend::Memory')
+      end
+    end
+  end
+end

data/spec/blueprint_config/backend/memory_spec.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require 'blueprint_config/backend/memory'
+
+describe BlueprintConfig::Backend::Memory do
+  let(:backend) { described_class.new }
+
+  describe '#load_keys' do
+    it 'returns empty hash initially' do
+      expect(backend.load_keys).to eq({})
+    end
+
+    it 'returns stored values as nested structure' do
+      backend.set('foo', 'bar')
+      expect(backend.load_keys).to eq({ foo: 'bar' })
+    end
+
+    it 'returns a copy of the store' do
+      backend.set('foo', 'bar')
+      loaded = backend.load_keys
+      loaded[:baz] = 'qux'
+      expect(backend.load_keys).to eq({ foo: 'bar' })
+    end
+  end
+
+  describe '#set' do
+    context 'with simple key-value' do
+      it 'stores the value' do
+        backend.set('foo', 'bar')
+        expect(backend.load_keys[:foo]).to eq('bar')
+      end
+
+      it 'converts key to string' do
+        backend.set(:foo, 'bar')
+        expect(backend.load_keys[:foo]).to eq('bar')
+      end
+
+      it 'overwrites existing value' do
+        backend.set('foo', 'bar')
+        backend.set('foo', 'baz')
+        expect(backend.load_keys[:foo]).to eq('baz')
+      end
+
+      it 'handles numeric values' do
+        backend.set('port', 3000)
+        expect(backend.load_keys[:port]).to eq(3000)
+      end
+
+      it 'handles boolean values' do
+        backend.set('enabled', true)
+        expect(backend.load_keys[:enabled]).to be true
+      end
+
+      it 'handles nil values' do
+        backend.set('empty', nil)
+        expect(backend.load_keys[:empty]).to be nil
+      end
+    end
+
+    context 'with nested hash value' do
+      it 'creates nested structure from single level hash' do
+        backend.set('smtp', { server: 'localhost', port: 1025 })
+        expect(backend.load_keys).to eq({
+          smtp: {
+            server: 'localhost',
+            port: 1025
+          }
+        })
+      end
+
+      it 'creates nested structure from deeply nested hash' do
+        backend.set('app', {
+          mail: {
+            smtp: {
+              settings: {
+                address: '127.0.0.1',
+                port: 587
+              }
+            }
+          }
+        })
+        expect(backend.load_keys).to eq({
+          app: {
+            mail: {
+              smtp: {
+                settings: {
+                  address: '127.0.0.1',
+                  port: 587
+                }
+              }
+            }
+          }
+        })
+      end
+
+      it 'handles empty parent key' do
+        backend.set('', { foo: 'bar', baz: 'qux' })
+        expect(backend.load_keys).to eq({
+          foo: 'bar',
+          baz: 'qux'
+        })
+      end
+
+      it 'merges with existing values' do
+        backend.set('app.name', 'MyApp')
+        backend.set('app', { version: '1.0' })
+        expect(backend.load_keys).to include(
+          app: {
+            name: 'MyApp',
+            version: '1.0'
+          }
+        )
+      end
+
+      it 'handles mixed types in nested hash' do
+        backend.set('config', {
+          string: 'value',
+          number: 42,
+          boolean: true,
+          null: nil,
+          nested: { key: 'value' }
+        })
+        
+        expect(backend.load_keys).to eq({
+          config: {
+            string: 'value',
+            number: 42,
+            boolean: true,
+            null: nil,
+            nested: {
+              key: 'value'
+            }
+          }
+        })
+      end
+    end
+
+    context 'with dotted keys' do
+      it 'creates nested structure from dotted keys' do
+        backend.set('smtp.server', 'mail.example.com')
+        backend.set('smtp.port', 587)
+        expect(backend.load_keys).to eq({
+          smtp: {
+            server: 'mail.example.com',
+            port: 587
+          }
+        })
+      end
+    end
+  end
+
+  describe '#clear' do
+    it 'removes all stored values' do
+      backend.set('foo', 'bar')
+      backend.set('baz', 'qux')
+      backend.clear
+      expect(backend.load_keys).to eq({})
+    end
+
+    it 'allows setting new values after clear' do
+      backend.set('foo', 'bar')
+      backend.clear
+      backend.set('new', 'value')
+      expect(backend.load_keys).to eq({ new: 'value' })
+    end
+  end
+
+  describe '#fresh?' do
+    it 'always returns true' do
+      expect(backend.fresh?).to be true
+      backend.set('foo', 'bar')
+      expect(backend.fresh?).to be true
+    end
+  end
+
+  describe '#source' do
+    it 'returns the class name' do
+      expect(backend.source).to eq('BlueprintConfig::Backend::Memory')
+    end
+  end
+end

data/spec/configuration_integration_spec.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'blueprint_config'
+require 'tmpdir'
+require 'fileutils'
+
+describe 'Configuration integration with all features' do
+  let(:temp_dir) { Dir.mktmpdir }
+  let(:app_yml_path) { File.join(temp_dir, 'config', 'app.yml') }
+  let(:app_local_yml_path) { File.join(temp_dir, 'config', 'app.local.yml') }
+  
+  before do
+    # Setup directory structure
+    FileUtils.mkdir_p(File.join(temp_dir, 'config'))
+    
+    # Mock BlueprintConfig root
+    allow(BlueprintConfig).to receive(:root).and_return(temp_dir)
+    allow(BlueprintConfig).to receive(:env).and_return('test')
+    
+    # Create YAML files
+    File.write(app_yml_path, <<~YAML)
+      default:
+        app:
+          name: MyApp
+          version: 1.0
+        smtp:
+          server: smtp.example.com
+          port: 587
+      test:
+        app:
+          name: MyApp Test
+        smtp:
+          port: 1025
+    YAML
+    
+    File.write(app_local_yml_path, <<~YAML)
+      default:
+        debug:
+          verbose: true
+        smtp:
+          server: localhost
+    YAML
+    
+    # Mock Rails for credentials
+    unless defined?(Rails)
+      module Rails
+        def self.env
+          ActiveSupport::StringInquirer.new('test')
+        end
+        def self.application
+          Struct.new(:credentials).new(
+            OpenStruct.new(
+              database: { password: 'secret123' },
+              api: { token: 'api_key_123' }
+            )
+          )
+        end
+      end
+    end
+    
+    # Set some ENV variables
+    ENV['APP_HOST'] = 'test.example.com'
+    ENV['APP_FEATURE_NEW_UI'] = 'true'
+    
+    # Initialize configuration
+    BlueprintConfig.instance.instance_variable_set(:@backends, nil)
+    BlueprintConfig.instance.instance_variable_set(:@config, nil)
+    BlueprintConfig.before_initialize.call
+    BlueprintConfig.after_initialize.call
+    BlueprintConfig.define_shortcut
+  end
+  
+  after do
+    FileUtils.rm_rf(temp_dir)
+    ENV.delete('APP_HOST')
+    ENV.delete('APP_FEATURE_NEW_UI')
+    
+    # Clean up memory backend
+    if defined?(AppConfig) && AppConfig.respond_to?(:clear_memory!)
+      AppConfig.clear_memory!
+    end
+    
+    Object.send(:remove_const, :Rails) if defined?(Rails)
+    Object.send(:remove_const, :AppConfig) if defined?(AppConfig)
+  end
+  
+  describe 'configuration loading and precedence' do
+    it 'loads values from all backends' do
+      # From app.yml default section
+      expect(AppConfig.app.version).to eq(1.0)
+      
+      # From app.yml test section (overrides default)
+      expect(AppConfig.app.name).to eq('MyApp Test')
+      
+      # From credentials
+      expect(AppConfig.database.password).to eq('secret123')
+      expect(AppConfig.api.token).to eq('api_key_123')
+      
+      # From app.local.yml (highest file priority)
+      expect(AppConfig.debug.verbose).to be true
+      expect(AppConfig.smtp.server).to eq('localhost')
+    end
+    
+    it 'respects configuration precedence' do
+      # app.yml sets port to 587, test section overrides to 1025
+      expect(AppConfig.smtp.port).to eq(1025)
+      
+      # app.local.yml overrides server from app.yml
+      expect(AppConfig.smtp.server).to eq('localhost')
+    end
+  end
+  
+  describe 'memory backend in test environment' do
+    it 'allows setting values that override all other sources' do
+      # Original value from app.local.yml
+      expect(AppConfig.smtp.server).to eq('localhost')
+      
+      # Override with memory backend
+      AppConfig.set('smtp.server', 'memory.example.com')
+      expect(AppConfig.smtp.server).to eq('memory.example.com')
+      
+      # Clear memory
+      AppConfig.clear_memory!
+      expect(AppConfig.smtp.server).to eq('localhost')
+    end
+    
+    it 'supports setting nested values with hash' do
+      AppConfig.set(
+        features: {
+          new_ui: true,
+          beta: false,
+          limits: {
+            max_users: 100,
+            max_projects: 10
+          }
+        }
+      )
+      
+      expect(AppConfig.features.new_ui).to be true
+      expect(AppConfig.features.beta).to be false
+      expect(AppConfig.features.limits.max_users).to eq(100)
+      expect(AppConfig.features.limits.max_projects).to eq(10)
+    end
+  end
+  
+  describe 'source tracking' do
+    it 'tracks sources for values from different backends' do
+      expect(AppConfig.config.source(:app, :name)).to include('YAML(config/app.yml)')
+      expect(AppConfig.config.source(:database, :password)).to include('Credentials')
+      expect(AppConfig.config.source(:debug, :verbose)).to include('YAML(config/app.local.yml)')
+    end
+    
+    it 'shows memory backend source when value is overridden' do
+      AppConfig.set('test.value', 'from memory')
+      expect(AppConfig.config.source(:test, :value)).to include('Memory')
+    end
+  end
+  
+  describe 'with_sources method' do
+    it 'returns all values with their sources' do
+      result = AppConfig.config.with_sources
+      
+      # Check structure
+      expect(result).to be_a(Hash)
+      expect(result[:app][:name]).to be_a(Hash)
+      expect(result[:app][:name]).to have_key(:value)
+      expect(result[:app][:name]).to have_key(:source)
+      
+      # Check values and sources
+      expect(result[:app][:name][:value]).to eq('MyApp Test')
+      expect(result[:app][:name][:source]).to include('YAML')
+      
+      expect(result[:database][:password][:value]).to eq('secret123')
+      expect(result[:database][:password][:source]).to include('Credentials')
+    end
+    
+    it 'includes memory backend sources' do
+      AppConfig.set('dynamic.setting', 'test value')
+      result = AppConfig.config.with_sources
+      
+      expect(result[:dynamic][:setting][:value]).to eq('test value')
+      expect(result[:dynamic][:setting][:source]).to include('Memory')
+    end
+  end
+  
+  describe 'configuration access methods' do
+    it 'supports member access syntax' do
+      expect(AppConfig.app.name).to eq('MyApp Test')
+    end
+    
+    it 'supports hash access syntax' do
+      expect(AppConfig[:app][:name]).to eq('MyApp Test')
+      expect(AppConfig['app']['name']).to eq('MyApp Test')
+    end
+    
+    it 'supports dig method' do
+      expect(AppConfig.dig(:app, :name)).to eq('MyApp Test')
+      expect(AppConfig.dig(:non, :existent)).to be_nil
+    end
+    
+    it 'supports bang methods for missing keys' do
+      expect { AppConfig.missing! }.to raise_error(KeyError, /missing/)
+    end
+    
+    it 'supports question methods for checking existence' do
+      expect(AppConfig.app?).to be true
+      expect(AppConfig.missing?).to be false
+    end
+  end
+
+  describe 'convenience methods' do
+    it 'supports AppConfig.to_h' do
+      result = AppConfig.to_h
+      expect(result).to be_a(Hash)
+      expect(result[:app][:name]).to eq('MyApp Test')
+      expect(result[:database][:password]).to eq('secret123')
+    end
+
+    it 'supports AppConfig.with_sources' do
+      result = AppConfig.with_sources
+      expect(result).to be_a(Hash)
+      expect(result[:app][:name]).to have_key(:value)
+      expect(result[:app][:name]).to have_key(:source)
+      expect(result[:app][:name][:value]).to eq('MyApp Test')
+      expect(result[:app][:name][:source]).to include('YAML')
+    end
+  end
+  
+  describe 'backend listing' do
+    it 'can list all loaded backends' do
+      backends = []
+      AppConfig.backends.each { |b| backends << b.class.name }
+      
+      expect(backends).to include('BlueprintConfig::Backend::YAML')
+      expect(backends).to include('BlueprintConfig::Backend::Credentials')
+      expect(backends).to include('BlueprintConfig::Backend::Memory')
+    end
+    
+    it 'can access specific backends' do
+      expect(AppConfig.backends[:memory]).to be_a(BlueprintConfig::Backend::Memory)
+      expect(AppConfig.backends[:app]).to be_a(BlueprintConfig::Backend::YAML)
+      expect(AppConfig.backends[:credentials]).to be_a(BlueprintConfig::Backend::Credentials)
+    end
+  end
+end