const_conf 0.0.0

data/spec/assets/.env/API_KEY

@@ -0,0 +1 @@
+sk-1234567890abcdef1234567890abcdef

data/spec/assets/config.json

@@ -0,0 +1,3 @@
+{
+  "hello": "world"
+}

data/spec/assets/config.yml

@@ -0,0 +1 @@
+hello: world

data/spec/assets/config_env.yml

@@ -0,0 +1,7 @@
+development: &development
+  hello: world
+
+test: *development
+
+production:
+  hello: outer world

data/spec/const_conf/dir_plugin_spec.rb

@@ -0,0 +1,249 @@
+require 'spec_helper'
+
+describe ConstConf::DirPlugin, protect_env: true do
+  let(:temp_dir) { Dir.mktmpdir }
+  let(:config_dir) { File.join(temp_dir, 'myapp') }
+  let(:file_in_dir) { File.join(config_dir, 'config.yaml') }
+  let(:nonexistent_file) { File.join(config_dir, 'nonexistent.txt') }
+
+  before do
+    # Create a test config directory and file
+    FileUtils.mkdir_p(config_dir)
+    File.write(file_in_dir, "key: value\nother_key: other_value\n")
+  end
+
+  after do
+    FileUtils.rm_rf(temp_dir)
+  end
+
+  describe ConstConf::DirPlugin::ConfigDir do
+    let(:config_dir_instance) do
+      described_class.new('myapp', root_path: temp_dir, env_var: nil, env_var_name: nil)
+    end
+
+    describe '#initialize' do
+      it 'initializes with name and root path' do
+        expect(config_dir_instance).to be_a(described_class)
+      end
+
+      it 'raises ArgumentError when both env_var and env_var_name are provided' do
+        expect {
+          described_class.new('myapp', root_path: temp_dir, env_var: 'value', env_var_name: 'VAR_NAME')
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'uses env_var_name to lookup environment variable value' do
+        ENV['CUSTOM_HOME'] = temp_dir
+        config_dir_with_env = described_class.new('myapp', env_var: nil, env_var_name: 'CUSTOM_HOME')
+        expect(config_dir_with_env.to_s).to include(temp_dir)
+      end
+    end
+
+    describe '#to_s' do
+      it 'returns the directory path as string' do
+        result = config_dir_instance.to_s
+        expect(result).to include('myapp')
+      end
+    end
+
+    describe '#join' do
+      it 'joins path with directory path' do
+        joined_path = config_dir_instance.join('config.yaml')
+        expect(joined_path.to_s).to eq file_in_dir
+      end
+    end
+
+    describe '#read' do
+      context 'when file exists' do
+        it 'reads file content as string' do
+          result = config_dir_instance.read('config.yaml')
+          expect(result).to eq "key: value\nother_key: other_value\n"
+        end
+
+        it 'handles file with block' do
+          result = config_dir_instance.read('config.yaml') do |file|
+            file.read
+          end
+          expect(result).to eq "key: value\nother_key: other_value\n"
+        end
+      end
+
+      context 'when file does not exist' do
+        it 'returns nil when file does not exist and no default or required' do
+          result = config_dir_instance.read('nonexistent.txt')
+          expect(result).to be_nil
+        end
+
+        it 'returns default value when file does not exist but default is provided' do
+          result = config_dir_instance.read('nonexistent.txt', default: 'default_content')
+          expect(result).to eq 'default_content'
+        end
+
+        it 'raises RequiredValueNotConfigured when file required and does not exist' do
+          expect {
+            config_dir_instance.read('nonexistent.txt', required: true)
+          }.to raise_error(ConstConf::RequiredValueNotConfigured)
+        end
+
+        it 'yields StringIO with default when block given and file does not exist' do
+          result = config_dir_instance.read('nonexistent.txt', default: 'default_content') do |io|
+            io.read
+          end
+          expect(result).to eq 'default_content'
+        end
+      end
+    end
+
+    describe '#derive_directory_path' do
+      it 'combines root path and name' do
+        path = config_dir_instance.send(:derive_directory_path, 'myapp', temp_dir)
+        expect(path.to_s).to include('myapp')
+      end
+    end
+
+    describe '#default_root_path' do
+      it 'returns default XDG config path from HOME' do
+        ENV['HOME'] = temp_dir
+        path = config_dir_instance.send(:default_root_path)
+        expect(path.to_s).to include('.config')
+      end
+    end
+  end
+
+  describe '#dir' do
+    let(:instance) { double('Config').extend(described_class) }
+
+    context 'with existing file in directory' do
+      it 'reads file content from directory' do
+        result = instance.dir('myapp', 'config.yaml', env_var: temp_dir)
+        expect(result).to eq "key: value\nother_key: other_value\n"
+      end
+    end
+
+    context 'with non-existent file' do
+      it 'returns default when provided' do
+        result = instance.dir('myapp', 'nonexistent.txt', env_var: temp_dir, default: 'default_value')
+        expect(result).to eq 'default_value'
+      end
+
+      it 'returns nil when no default and file does not exist' do
+        result = instance.dir('myapp', 'nonexistent.txt', env_var: temp_dir)
+        expect(result).to be_nil
+      end
+
+      it 'raises error when required is true and file does not exist' do
+        expect {
+          instance.dir('myapp', 'nonexistent.txt', env_var: temp_dir, required: true)
+        }.to raise_error(ConstConf::RequiredValueNotConfigured)
+      end
+    end
+  end
+
+  describe 'integration with ConstConf settings' do
+    let(:module_with_dir_plugin) do
+      Module.new do
+        include ConstConf
+        plugin ConstConf::DirPlugin
+
+        description 'Module with DirPlugin'
+
+        # Test basic dir usage
+        CONFIG_FILE = set do
+          description 'Configuration from directory file'
+          default dir('myapp', 'config.yaml', env_var: temp_dir)
+          decode { |s| YAML.load(s) }
+        end
+
+        # Test required directory file
+        REQUIRED_DIR_FILE = set do
+          description 'Required file in directory'
+          default dir('myapp', 'nonexistent.txt', env_var: temp_dir, required: false)
+        end
+      end
+    end
+
+    before do
+      # Create the module with dynamic eval to simulate real usage
+      eval <<~RUBY
+        if Object.const_defined?(:ConstConfTestModuleWithDir)
+          Object.send(:remove_const, :ConstConfTestModuleWithDir)
+        end
+        module ConstConfTestModuleWithDir
+          include ConstConf
+          plugin ConstConf::DirPlugin
+
+          description 'Module with DirPlugin'
+
+          CONFIG_FILE = set do
+            description 'Configuration from directory file'
+            default dir('myapp', 'config.yaml', env_var: '#{temp_dir}')
+            decode { |s| YAML.load(s) }
+          end
+        end
+      RUBY
+    end
+
+    it 'can read files from directories' do
+      # This will test the actual integration
+      expect(ConstConfTestModuleWithDir::CONFIG_FILE).to be_a(Hash)
+    end
+
+    context 'XDG-compliant directory structure' do
+      before do
+        eval <<~RUBY
+          if Object.const_defined?(:ConstConfXDGModule)
+            Object.send(:remove_const, :ConstConfXDGModule)
+          end
+          module ConstConfXDGModule
+            include ConstConf
+            plugin ConstConf::DirPlugin
+
+            description 'XDG Compliant Module'
+
+            XDG_CONFIG_HOME = set do
+              description 'XDG Config HOME'
+              prefix ''
+            end
+
+            API_KEY = set do
+              description 'API Key from XDG config'
+              default dir('myapp', 'api_key.txt', env_var: ConstConfXDGModule::XDG_CONFIG_HOME)
+            end
+          end
+        RUBY
+      end
+
+      it 'handles XDG-compliant directory structure' do
+        # This tests the XDG pattern from the example
+        expect { ConstConfXDGModule::API_KEY }.not_to raise_error
+      end
+    end
+  end
+
+  describe 'error handling' do
+    let(:instance) { double('Config').extend(described_class) }
+
+    it 'handles directory operations gracefully' do
+      # Test that we can handle edge cases in directory operations
+      expect {
+        instance.dir('nonexistent', 'file.txt', env_var: '/nonexistent/path')
+      }.not_to raise_error
+    end
+  end
+
+  describe 'complex scenarios' do
+    let(:nested_config_dir) { File.join(temp_dir, 'app', 'config') }
+    let(:nested_file) { File.join(nested_config_dir, 'settings.yml') }
+
+    before do
+      FileUtils.mkdir_p(nested_config_dir)
+      File.write(nested_file, "nested: true\n")
+    end
+
+    it 'works with nested directory structures' do
+      instance = described_class::ConfigDir.new('app/config', root_path: temp_dir, env_var: nil, env_var_name: nil)
+      result = instance.read('settings.yml')
+      expect(result).to eq "nested: true\n"
+    end
+  end
+end

data/spec/const_conf/env_dir_extension_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe ConstConf::EnvDirExtension do
+  module TestConfig
+    include ConstConf
+
+    description 'Test Configuration'
+
+    module EnvDir
+      extend ConstConf::EnvDirExtension
+      description 'All variables loaded from .env directory'
+
+      load_dotenv_dir('spec/assets/.env/*') {}
+    end
+  end
+
+  describe '#load_dotenv_dir' do
+    it 'creates constants with proper naming and metadata including descriptions' do
+      # Verify the setting exists and has correct properties
+      expect(TestConfig::EnvDir::API_KEY).to eq "sk-1234567890abcdef1234567890abcdef"
+
+      # Test that it's marked as sensitive (since it's a secret)
+      setting = TestConfig::EnvDir.settings['API_KEY']
+      expect(setting.sensitive?).to be true
+
+      # Test that it has proper description from the file
+      expect(setting.description).to include("Value of \"API_KEY\" from")
+      expect(TestConfig.settings.size).to eq 0
+      expect(TestConfig::EnvDir.settings.size).to eq 1
+    end
+
+    it 'handles duplicate definitions gracefully with proper error handling' do
+      module TestConfigWithManualSetting
+        include ConstConf
+
+        description 'Test Configuration'
+
+        # Manually define first (should take precedence)
+        API_KEY = set  do
+          description 'Manually defined API_KEY'
+          prefix ''
+
+          default "manual_value"
+        end
+
+        module EnvDir
+          extend ConstConf::EnvDirExtension
+          description 'All variables loaded from .env directory'
+
+          load_dotenv_dir('spec/assets/.env/*') {}
+        end
+      end
+      # Should use the manual definition, not the file content
+      expect(TestConfigWithManualSetting::API_KEY).to eq "manual_value"
+      expect(TestConfigWithManualSetting.settings.size).to eq 1
+      expect(TestConfigWithManualSetting::EnvDir.settings.size).to eq 0
+    end
+  end
+end

data/spec/const_conf/file_plugin_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+describe ConstConf::FilePlugin do
+  let(:temp_dir) { Dir.mktmpdir }
+  let(:config_file) { File.join(temp_dir, 'config.txt') }
+  let(:nonexistent_file) { File.join(temp_dir, 'nonexistent.txt') }
+
+  before do
+    eval %{
+      if Object.const_defined?(:ConstConfTestModule)
+        Object.send(:remove_const, :ConstConfTestModule)
+      end
+      module ::ConstConfTestModule
+        include ConstConf
+
+        description 'Outer configuration namespace'
+      end
+    }
+  end
+
+
+  let :instance do
+    double('Config').extend(described_class)
+  end
+
+  before do
+    # Create a test config file with content
+    File.write(config_file, "test_content\nwith_newlines")
+  end
+
+  after do
+    FileUtils.rm_rf(temp_dir)
+  end
+
+  describe '#file' do
+    context 'when file exists' do
+      it 'reads the file content as a string' do
+        result = instance.file(config_file)
+        expect(result).to eq "test_content\nwith_newlines"
+      end
+
+      it 'handles files with UTF-8 encoding' do
+        utf8_file = File.join(temp_dir, 'utf8.txt')
+        File.write(utf8_file, "café 🚀\n")
+
+        result = instance.file(utf8_file)
+        expect(result).to eq "café 🚀\n"
+      end
+    end
+
+    context 'when file does not exist' do
+      it 'returns nil when file does not exist and required is false' do
+        result = instance.file(nonexistent_file, required: false)
+        expect(result).to be_nil
+      end
+
+      it 'raises RequiredValueNotConfigured when file is required and does not exist' do
+        expect {
+          instance.file(nonexistent_file, required: true)
+        }.to raise_error(ConstConf::RequiredValueNotConfigured)
+      end
+    end
+
+    context 'with custom configuration module' do
+      before do
+        eval %{
+          module ConstConfTestModule::ModuleWithFilePlugin
+            include ConstConf
+            plugin ConstConf::FilePlugin
+
+            description 'Module with FilePlugin'
+
+            CONFIG_VALUE = set do
+              description 'Configuration from file'
+              default file("#{config_file}")
+            end
+          end
+        }
+      end
+
+      it 'can be used in a ConstConf module' do
+        expect(ConstConfTestModule::ModuleWithFilePlugin::CONFIG_VALUE).to eq "test_content\nwith_newlines"
+      end
+
+      it 'handles required files properly' do
+        expect {
+          eval %{
+            module ConstConfTestModule::ModuleWithRequired
+              include ConstConf
+              plugin ConstConf::FilePlugin
+
+              description 'Module with Required'
+
+              REQUIRED_CONFIG = set do
+                description 'Required config from file'
+                default file("#{nonexistent_file}", required: true)
+              end
+            end
+          }
+        }.to raise_error(ConstConf::RequiredValueNotConfigured)
+      end
+    end
+  end
+
+  describe 'integration with ConstConf settings' do
+    before do
+      eval %{
+        module ConstConfTestModule::ConfigModule
+          include ConstConf
+          plugin ConstConf::FilePlugin
+
+          description 'Some ConfigModule'
+
+          # Test file reading in setting definition
+          API_KEY = set do
+            description 'API key from file'
+            default file("#{config_file}")
+            decode(&:chomp)
+          end
+
+          # Test with required file
+          REQUIRED_CONFIG = set do
+            description 'Required config file'
+            default file("#{nonexistent_file}", required: false)
+          end
+        end
+      }
+    end
+
+    it 'properly reads file content' do
+      expect(ConstConfTestModule::ConfigModule::API_KEY).to eq "test_content\nwith_newlines"
+    end
+
+    it 'handles decoding operations on file content' do
+      # The decode(&:chomp) should strip trailing whitespace/newlines
+      expect(ConstConfTestModule::ConfigModule::API_KEY).to eq "test_content\nwith_newlines"
+    end
+
+    it 'handles missing files gracefully when not required' do
+      expect(ConstConfTestModule::ConfigModule::REQUIRED_CONFIG).to be_nil
+    end
+  end
+
+  describe 'error handling' do
+    it 'properly raises exceptions for invalid file paths' do
+      # This would test edge cases in the underlying File.read behavior
+      expect {
+        instance.file('/nonexistent/directory/file.txt')
+      }.not_to raise_error
+    end
+  end
+
+  context 'with directory-based setup' do
+    let(:config_dir) { Dir.mktmpdir }
+
+    after do
+      FileUtils.rm_rf(config_dir)
+    end
+
+    it 'works correctly with different file operations' do
+      # Create a nested structure for testing
+      subdir = File.join(config_dir, 'subdir')
+      FileUtils.mkdir_p(subdir)
+
+      test_file = File.join(subdir, 'test.txt')
+      File.write(test_file, 'nested_content')
+
+      # This tests that the plugin can be used in different contexts
+      result = instance.file(test_file)
+      expect(result).to eq 'nested_content'
+    end
+  end
+end

data/spec/const_conf/json_plugin_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe ConstConf::JSONPlugin do
+  let(:json_file) { asset('config.json') }
+
+  describe '#json' do
+    context 'when file exists' do
+      it 'reads and parses JSON content as a hash' do
+        instance = double('Config').extend(described_class)
+        result = instance.json(json_file)
+        expect(result.hello).to eq 'world'
+      end
+
+      it 'handles JSON with custom object_class' do
+        instance = double('Config').extend(described_class)
+        foobar_class = Class.new(JSON::GenericObject)
+        result = instance.json(json_file, object_class: foobar_class)
+        expect(result).to be_a(foobar_class)
+      end
+    end
+
+    context 'when file does not exist' do
+      let(:nonexistent_file) { asset('nonexistent.json') }
+
+      it 'returns nil when file does not exist and required is false' do
+        instance = double('Config').extend(described_class)
+        result = instance.json(nonexistent_file, required: false)
+        expect(result).to be_nil
+      end
+
+      it 'raises RequiredValueNotConfigured when file is required and does not exist' do
+        instance = double('Config').extend(described_class)
+        expect {
+          instance.json(nonexistent_file, required: true)
+        }.to raise_error(ConstConf::RequiredValueNotConfigured)
+      end
+    end
+
+    context 'with custom configuration module' do
+      before do
+        eval %{
+          if Object.const_defined?(:ConstConfTestModuleWithJSON)
+            Object.send(:remove_const, :ConstConfTestModuleWithJSON)
+          end
+          module ::ConstConfTestModuleWithJSON
+            include ConstConf
+            plugin ConstConf::JSONPlugin
+
+            description 'Module with JSONPlugin'
+
+            CONFIG_VALUE = set do
+              description 'Configuration from JSON file'
+              default json("#{json_file}")
+            end
+          end
+        }
+      end
+
+      it 'can be used in a ConstConf module' do
+        expect(ConstConfTestModuleWithJSON::CONFIG_VALUE.hello).to eq 'world'
+      end
+    end
+  end
+end

data/spec/const_conf/setting_accessor_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe ConstConf::SettingAccessor do
+  let(:klass) do
+    Class.new do
+      extend ConstConf::SettingAccessor
+    end
+  end
+
+  describe '.setting_accessor' do
+    context 'with default value' do
+      before do
+        klass.setting_accessor :foobar, 'default_value'
+      end
+
+      it 'returns default value when not set' do
+        instance = klass.new
+        expect(instance.foobar).to eq 'default_value'
+      end
+
+      it 'returns set value when explicitly set' do
+        instance = klass.new
+        instance.foobar 'explicit_value'
+        expect(instance.foobar).to eq 'explicit_value'
+      end
+    end
+
+    context 'with block default' do
+      before do
+        klass.setting_accessor :foobar do
+          'block_default'
+        end
+      end
+
+      it 'evaluates block for default value' do
+        instance = klass.new
+        expect(instance.foobar).to eq 'block_default'
+      end
+
+      it 'returns set value when explicitly set' do
+        instance = klass.new
+        instance.foobar 'explicit_value'
+        expect(instance.foobar).to eq 'explicit_value'
+      end
+    end
+
+    context 'with arg_block' do
+      before do
+        klass.setting_accessor :foobar
+      end
+
+      it 'foo' do
+        instance = klass.new
+        expect(instance.foobar).to be nil
+        instance.foobar do
+          :bar
+        end
+        expect(instance.foobar).to be_a Proc
+        expect(instance.foobar.()).to be :bar
+      end
+    end
+
+    context 'setter mode behavior' do
+      before do
+        klass.setting_accessor :required_setting, nil
+      end
+
+      it 'raises ArgumentError when in setter_mode and value is nil' do
+        # This requires setting up thread-local setter_mode
+        expect do
+          instance = klass.new
+          # Simulate setter mode behavior
+          allow(klass).to receive(:setter_mode).and_return(true)
+          instance.required_setting
+        end.to raise_error(ArgumentError, /need an argument/)
+      end
+    end
+
+    context 'with positional argument' do
+      before do
+        klass.setting_accessor :foobar, 'default'
+      end
+
+      it 'accepts positional argument for setting value' do
+        instance = klass.new
+        # This is a bit tricky to test since the method signature is complex
+        expect(instance.foobar('explicit')).to eq 'explicit'
+      end
+    end
+
+    context 'with block argument' do
+      before do
+        klass.setting_accessor :foobar, 'default'
+      end
+
+      it 'accepts block argument for setting value' do
+        instance = klass.new
+        result = instance.foobar { 'block_value' }
+        expect(result).to be_a Proc
+        expect(instance.foobar.()).to eq 'block_value'
+      end
+    end
+  end
+
+  describe 'thread_local behavior' do
+    it 'manages thread-local setter_mode state' do
+      expect(klass.setter_mode).to be_falsey
+      klass.enable_setter_mode do
+        expect(klass.setter_mode).to be_truthy
+      end
+      expect(klass.setter_mode).to be_falsey
+    end
+  end
+end