const_conf 0.0.0

data/spec/const_conf/tree_spec.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+
+describe ConstConf::Tree do
+  module ModuleWithSettings
+    include ConstConf
+    description 'Test Configuration'
+    prefix 'TEST'
+
+    TEST_VAR = set do
+      description 'A test variable'
+      prefix '' # Remove the superflous TEST prefix for env var TEST_VAR
+      default 'default_value'
+      required true
+    end
+
+    NESTED_CONFIG = set do
+      # prefix is inherited from ModuleWithSettings's 'TEST', make this env var
+      # TEST_NESTED_CONFIG
+      description 'Nested configuration'
+      default 'nested_default'
+    end
+  end
+
+  describe '.from_const_conf' do
+    context 'with a ConstConf module' do
+      it 'converts module to tree structure' do
+        tree = ConstConf::Tree.from_const_conf(ModuleWithSettings)
+
+        expect(tree).to be_a(ConstConf::Tree)
+        expect(tree.to_s).to include('Test Configuration')
+        expect(tree.to_s).to include('::TEST_VAR')
+        expect(tree.to_s).to include('TEST_NESTED_CONFIG')
+        expect(tree.to_s).to include('::NESTED_CONFIG')
+      end
+    end
+
+    context 'with a Setting object' do
+      let(:setting) do
+        ModuleWithSettings::TEST_VAR!
+      end
+
+      it 'converts setting to tree structure' do
+        tree = ConstConf::Tree.from_const_conf(setting)
+
+        expect(tree).to be_a(ConstConf::Tree)
+        expect(tree.to_s).to include('TEST_VAR')
+        expect(tree.to_s).to include('A test variable')
+      end
+    end
+
+    context 'with invalid argument' do
+      it 'raises ArgumentError' do
+        expect {
+          ConstConf::Tree.from_const_conf(Object.new)
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe 'Tree instance methods' do
+    let(:tree) do
+      ConstConf::Tree.new('Test Node')
+    end
+
+    describe '#initialize' do
+      it 'creates tree with name and value' do
+        tree = ConstConf::Tree.new('Test')
+        expect(tree.instance_variable_get(:@name)).to eq 'Test'
+      end
+    end
+
+    describe '#<<' do
+      it 'adds child nodes' do
+        child = ConstConf::Tree.new('Child')
+        tree << child
+
+        expect(tree.instance_variable_get(:@children)).to include(child)
+      end
+    end
+
+    describe '#to_enum' do
+      it 'yields tree structure with proper indentation' do
+        child1 = ConstConf::Tree.new('Child 1')
+        child2 = ConstConf::Tree.new('Child 2')
+
+        tree << child1
+        tree << child2
+
+        enum = tree.to_enum
+        result = enum.to_a
+
+        expect(result).to be_an(Array)
+        expect(result.size).to be >= 3 # root + children
+      end
+    end
+
+    describe '#to_s' do
+      it 'returns formatted string representation' do
+        tree << ConstConf::Tree.new('Child Node')
+
+        result = tree.to_s
+        expect(result).to be_a(String)
+        expect(result).not_to be_empty
+      end
+    end
+
+    describe '#default_utf8', protect_env: true do
+      context 'when LANG contains utf-8' do
+        before do
+          ENV['LANG'] = 'en_US.UTF-8'
+        end
+
+        it 'returns true' do
+          expect(tree.default_utf8).to be true
+        end
+      end
+
+      context 'when LANG does not contain utf-8' do
+        before do
+          ENV['LANG'] = 'en_US.ISO8859-1'
+        end
+
+        it 'returns false' do
+          expect(tree.default_utf8).to be false
+        end
+      end
+    end
+  end
+
+  module ParentModule
+    include ConstConf
+    description 'Parent Configuration'
+    prefix 'PARENT'
+
+    module NestedModule
+      include ConstConf
+      description 'Nested Config'
+      prefix 'NESTED'
+
+      NESTED_VAR = set do
+        description 'Nested variable'
+        default 'nested_value'
+      end
+    end
+
+    PARENT_VAR = set do
+      description 'Parent variable'
+      default 'parent_value'
+    end
+  end
+
+  describe 'tree rendering with nested modules' do
+    it 'handles nested module structures' do
+      tree = ConstConf::Tree.from_const_conf(ParentModule)
+
+      # Should contain parent and nested module information
+      expect(tree.to_s).to include('Parent Configuration')
+      expect(tree.to_s).to include('Nested Config')
+      expect(tree.to_s).to include('::PARENT_VAR')
+      expect(tree.to_s).to include('PARENT_PARENT_VAR')
+      expect(tree.to_s).to include('::NESTED_VAR')
+      expect(tree.to_s).to include('NESTED_NESTED_VAR')
+    end
+  end
+
+  describe 'setting details rendering' do
+    let(:setting) do
+      ModuleWithSettings::TEST_VAR!
+    end
+
+    it 'renders detailed setting information' do
+      tree = ConstConf::Tree.from_const_conf(setting)
+
+      # Should include various setting metadata
+      result = tree.to_s
+
+      expect(result).to include('TEST_VAR')
+      expect(result).to include('A test variable')
+      expect(result).to include('prefix')
+      expect(result).to include('env var name')
+      expect(result).to include('default')
+      expect(result).to include('value')
+    end
+  end
+end

data/spec/const_conf/yaml_plugin_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe ConstConf::YAMLPlugin do
+  let(:yaml_file) { asset('config.yml') }
+  let(:env_yaml_file) { asset('config_env.yml') }
+
+  describe '#yaml' do
+    context 'when file exists' do
+      it 'reads and parses YAML content as a hash' do
+        instance = double('Config').extend(described_class)
+        result = instance.yaml(yaml_file)
+        expect(result.hello).to eq 'world'
+      end
+
+      it 'handles environment-specific loading when env: true' do
+        instance = double('Config').extend(described_class)
+        ENV['RAILS_ENV'] = 'development'
+
+        # This will actually call complex_config_with_env with the real ENV value
+        result = instance.yaml(env_yaml_file, env: true)
+        expect(result.hello).to eq 'world'
+      end
+
+      it 'handles environment-specific loading with explicit env' do
+        instance = double('Config').extend(described_class)
+        result = instance.yaml(env_yaml_file, env: 'production')
+        expect(result.hello).to eq 'outer world'
+      end
+    end
+
+    context 'when file does not exist' do
+      let(:nonexistent_file) { asset('nonexistent.yml') }
+
+      it 'returns nil when file does not exist and required is false' do
+        instance = double('Config').extend(described_class)
+        result = instance.yaml(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.yaml(nonexistent_file, required: true)
+        }.to raise_error(ConstConf::RequiredValueNotConfigured)
+      end
+    end
+
+    context 'when env is specified but no RAILS_ENV is set' do
+      it 'raises RequiredValueNotConfigured when env is true and RAILS_ENV is not set' do
+        instance = double('Config').extend(described_class)
+        ENV['RAILS_ENV'] = nil
+
+        expect {
+          instance.yaml(env_yaml_file, env: true)
+        }.to raise_error(ConstConf::RequiredValueNotConfigured)
+      end
+    end
+
+    context 'with custom configuration module' do
+      before do
+        eval %{
+          if Object.const_defined?(:ConstConfTestModuleWithYAML)
+            Object.send(:remove_const, :ConstConfTestModuleWithYAML)
+          end
+          module ::ConstConfTestModuleWithYAML
+            include ConstConf
+            plugin ConstConf::YAMLPlugin
+
+            description 'Module with YAMLPlugin'
+
+            CONFIG_VALUE = set do
+              description 'Configuration from YAML file'
+              default yaml("#{yaml_file}")
+            end
+          end
+        }
+      end
+
+      it 'can be used in a ConstConf module' do
+        expect(ConstConfTestModuleWithYAML::CONFIG_VALUE.hello).to eq 'world'
+      end
+    end
+  end
+end

data/spec/const_conf_spec.rb

@@ -0,0 +1,216 @@
+require 'spec_helper'
+
+describe ConstConf do
+  before do
+    if Object.const_defined?(:TestConstConf)
+      Object.send(:remove_const, :TestConstConf)
+    end
+  end
+
+  describe 'in ConstConf module' do
+    context 'reloading' do
+      before do
+        module TestConstConf
+          include ConstConf
+
+          description 'foo'
+
+          TEST = set do
+            description 'bar'
+          end
+        end
+      end
+
+      describe '.register' do
+        it 'registers configurations' do
+          expect(ConstConf.module_files).to include(TestConstConf => __FILE__)
+        end
+      end
+
+      describe '.destroy' do
+        it 'can be destroyed' do
+          expect(ConstConf.destroy).to include(__FILE__)
+        end
+      end
+
+      describe '.reload' do
+        it 'first destroys and then reloads' do
+          files = %w[ /path/to/foo.rb ]
+          expect(ConstConf).to receive(:destroy).and_return(files)
+          expect(ConstConf).to receive(:load).with(files.first)
+          ConstConf.reload
+        end
+      end
+    end
+
+    describe 'in including modules' do
+      describe '.plugin' do
+        before do
+          module TestConstConf
+            include ConstConf
+
+            plugin ConstConf::FilePlugin
+
+            description 'foo'
+
+            TEST = set do
+              description 'test'
+              default 'bar'
+            end
+          end
+        end
+
+        it 'can include FilePlugin' do
+          expect(ConstConf::Setting).to receive(:include).
+            with(ConstConf::FilePlugin).
+            and_call_original
+          TestConstConf.plugin(ConstConf::FilePlugin)
+        end
+      end
+
+      describe '.description' do
+        before do
+          module TestConstConf
+            include ConstConf
+          end
+        end
+
+        it 'sets and retrieves module description' do
+          expect { TestConstConf.description "Test Configuration" }
+            .to change { TestConstConf.description }
+            .from(nil)
+            .to("Test Configuration")
+        end
+      end
+
+      context 'nested configurations' do
+        before do
+          module TestNestedConstConf
+            include ConstConf
+
+            description 'TestConstConf'
+
+            module InnerConstConf
+              description 'InnerConstConf'
+            end
+          end
+        end
+
+        describe '.outer_configuration' do
+          it 'knows about outer_configuration' do
+            expect(TestNestedConstConf::InnerConstConf.outer_configuration).
+              to eq TestNestedConstConf
+          end
+        end
+
+        describe '.all_configurations' do
+          it 'can return all configurations' do
+            expect(TestNestedConstConf.all_configurations).to eq(
+              [ TestNestedConstConf, TestNestedConstConf::InnerConstConf ]
+            )
+          end
+        end
+
+        describe '.nested_configurations' do
+          it 'can return nested configurations' do
+            expect(TestNestedConstConf.nested_configurations).to eq(
+              [ TestNestedConstConf::InnerConstConf ]
+            )
+          end
+
+          describe '.each_nested_configuration' do
+            it 'can iterate over nested configurations' do
+              expect(TestNestedConstConf.each_nested_configuration).
+                to be_a Enumerator
+              expect(TestNestedConstConf.each_nested_configuration.to_a).
+                to eq([ TestNestedConstConf, TestNestedConstConf::InnerConstConf ])
+            end
+          end
+        end
+
+        describe '.env_var_names' do
+          it 'returns the names environment variables' do
+            ENV['FOO'] = 'test_value'
+            module TestConstConf
+              include ConstConf
+              description 'foo foo'
+              FOO = set do
+                prefix ''
+                description 'foo'
+              end
+            end
+            expect(TestConstConf.env_var_names).to eq %w[ FOO ]
+          end
+        end
+      end
+
+      describe '.env_vars' do
+        it 'returns a hash of environment variable values' do
+          ENV['FOO'] = 'test_value'
+          module TestConstConf
+            include ConstConf
+
+            description 'foo foo'
+            FOO = set do
+              prefix ''
+              description 'foo'
+            end
+          end
+          expect(TestConstConf.env_vars).to eq(
+            'FOO' => 'test_value'
+          )
+        end
+      end
+
+      context 'with a setting' do
+        before do
+          module TestConstConf
+            include ConstConf
+
+            description 'foo'
+
+            TEST = set do
+              description 'test'
+              default 'bar'
+            end
+          end
+        end
+
+        describe '.prefix' do
+          it 'sets and retrieves prefix properly' do
+            expect { TestConstConf.prefix "FOO" }.to change { TestConstConf.prefix }.
+              from("TEST_CONST_CONF").to("FOO")
+          end
+        end
+
+        it 'modifies settings after set' do
+          expect(TestConstConf.settings['TEST_CONST_CONF_TEST']).
+            to be_a(ConstConf::Setting)
+        end
+
+        describe '.setting_for' do
+          it 'can be returned' do
+            expect(TestConstConf.setting_for('TEST_CONST_CONF_TEST')).
+              to be_a ConstConf::Setting
+          end
+        end
+
+        describe '.setting_value_for' do
+          it 'has a value that be returned' do
+            expect(TestConstConf.setting_for('TEST_CONST_CONF_TEST').value).
+              to eq 'bar'
+          end
+
+          describe '.view' do
+            it 'renders tree view' do
+              expect(ConstConf::Tree).to receive(:from_const_conf).with(
+                TestConstConf
+              )
+              TestConstConf.view
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,140 @@
+require 'gem_hadar/simplecov'
+GemHadar::SimpleCov.start
+require 'rspec'
+begin
+  require 'debug'
+rescue LoadError
+end
+require 'const_conf'
+
+# A module that provides helper methods for asset management within the
+# application.
+#
+# The AssetHelpers module encapsulates functionality related to handling and
+# processing application assets, such as CSS, JavaScript, and image files. It
+# offers utilities for managing asset paths, generating URLs, and performing
+# operations on assets during the application's runtime.
+module AssetHelpers
+  # The asset method constructs and returns the full path to an asset file.
+  #
+  # This method takes a filename argument and combines it with the assets directory
+  # located within the same directory as the calling file, returning the
+  # complete path to that asset.
+  #
+  # @param name [String] the name of the asset file
+  #
+  # @return [String] the full path to the asset file
+  def asset(name)
+    File.join(__dir__, 'assets', name)
+  end
+
+  # Reads and returns the content of an asset file from the assets directory.
+  #
+  # @param name [String] the name of the asset file to read
+  #
+  # @return [String] the content of the asset file as a string
+  def asset_content(name)
+    File.read(File.join(__dir__, 'assets', name))
+  end
+
+  # The asset_io method retrieves an IO object for a specified asset file.
+  #
+  # This method constructs the path to an asset file within the assets directory
+  # and returns an IO object representing that file. If a block is provided, it
+  # yields the IO object to the block and ensures the file is properly closed
+  # after the block executes.
+  #
+  # @param name [ String ] the name of the asset file to retrieve
+  #
+  # @yield [ io ] yields the IO object for the asset file to the provided block
+  #
+  # @return [ File, nil ] returns the IO object for the asset file, or nil if a
+  # block is provided and the block does not return a value
+  def asset_io(name, &block)
+    io = File.new(File.join(__dir__, 'assets', name))
+    if block
+      begin
+        block.call(io)
+      ensure
+        io.close
+      end
+    else
+      io
+    end
+  end
+
+  # The asset_json method reads and parses a JSON asset file.
+  #
+  # This method retrieves an asset by name, reads its contents from the
+  # filesystem, and then parses the resulting string as JSON, returning the
+  # parsed data structure.
+  #
+  # @param name [String] the name of the asset to retrieve and parse
+  #
+  # @return [Object] the parsed JSON data structure, typically a Hash or Array
+  def asset_json(name)
+    JSON(JSON(File.read(asset(name))))
+  end
+end
+
+# A module that provides functionality for stubbing Ollama server responses.
+#
+# The StubOllamaServer module enables developers to simulate Ollama API
+# interactions in test environments by intercepting requests and returning
+# predefined responses. This allows for faster, more reliable testing without
+# requiring external service calls.
+module StubOllamaServer
+  # The connect_to_ollama_server method establishes a connection to an Ollama
+  # server.
+  #
+  # This method sets up stubbed HTTP requests to simulate responses from an
+  # Ollama server, including API tags, show, and version endpoints. It can
+  # optionally instantiate a chat session after setting up the stubs.
+  #
+  # @param instantiate [Boolean] whether to instantiate a chat session after setting up stubs
+  def connect_to_ollama_server(instantiate: true)
+    before do
+      stub_request(:get, %r(/api/tags\z)).
+        to_return(status: 200, body: asset_json('api_tags.json'))
+      stub_request(:post, %r(/api/show\z)).
+        to_return(status: 200, body: asset_json('api_show.json'))
+      stub_request(:get, %r(/api/version\z)).
+        to_return(status: 200, body: asset_json('api_version.json'))
+      instantiate and chat
+    end
+  end
+end
+
+# A module that provides functionality for protecting environment variables during tests.
+#
+# This module ensures that environment variable changes made during test execution
+# are automatically restored to their original values after the test completes.
+# It is designed to prevent side effects between tests that modify environment
+# variables, maintaining a clean testing environment.
+module ProtectEnvVars
+  # The apply method creates a lambda that protects environment variables
+  # during test execution.
+  #
+  # @return [Proc] a lambda that wraps test execution with environment variable
+  # preservation
+  def self.apply
+    -> example do
+      if example.metadata[:protect_env]
+        begin
+          stored_env = ENV.to_h
+          example.run
+        ensure
+          ENV.replace(stored_env)
+        end
+      else
+        example.run
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include AssetHelpers
+
+  config.around(&ProtectEnvVars.apply)
+end