config_files 0.1.6 → 0.2.1

data/test/loader_factory_test.rb

@@ -1,40 +1,40 @@
-$:.push(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.push(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'minitest/autorun'
 require 'config_files'
 class LoaderFactoryDummy
   class << self
-    def call(file_name, options={})
+    def call(_file_name, _options = {})
       nil
     end
   end
 end
 
-class LoaderFactoryTest < MiniTest::Test
+class LoaderFactoryTest < Minitest::Test
   def file_locations
     File.join(__dir__, 'etc')
   end
 
   def test_detect_yaml_file_type
-    assert_equal(::ConfigFiles::Loaders::Yaml, ::ConfigFiles::LoaderFactory.(File.join(file_locations,'dummy.yml')))
+    assert_equal(::ConfigFiles::Loaders::Yaml, ::ConfigFiles::LoaderFactory.call(File.join(file_locations, 'dummy.yml')))
   end
 
   def test_detect_json_file_type
-    assert_equal(::ConfigFiles::Loaders::Json, ::ConfigFiles::LoaderFactory.(File.join(file_locations,'dummy.json')))
+    assert_equal(::ConfigFiles::Loaders::Json, ::ConfigFiles::LoaderFactory.call(File.join(file_locations, 'dummy.json')))
   end
 
   def test_detect_unknown_file_type
-    assert_nil(::ConfigFiles::LoaderFactory.(File.join(file_locations,'dummy.wibble'), default_loader: nil))
+    assert_nil(::ConfigFiles::LoaderFactory.call(File.join(file_locations, 'dummy.wibble'), default_loader: nil))
   end
 
   def test_allow_addition_of_file_types_does_not_break_existing
-    assert_equal(::ConfigFiles::Loaders::Yaml, ::ConfigFiles::LoaderFactory.(File.join(file_locations,'dummy.yml'), loaders: {LoaderFactoryDummy=>['wibble']}))
+    assert_equal(::ConfigFiles::Loaders::Yaml, ::ConfigFiles::LoaderFactory.call(File.join(file_locations, 'dummy.yml'), loaders: { LoaderFactoryDummy => ['wibble'] }))
   end
 
   def test_allow_addition_of_file_types_breaks_existing_if_specified
-    assert_nil(::ConfigFiles::LoaderFactory.(File.join(file_locations,'dummy.yml'), loaders: {LoaderFactoryDummy=>['wibble']}, include_default: false, default_loader: nil))
+    assert_nil(::ConfigFiles::LoaderFactory.call(File.join(file_locations, 'dummy.yml'), loaders: { LoaderFactoryDummy => ['wibble'] }, include_default: false, default_loader: nil))
   end
 
   def test_addition_of_new_loaders
-    assert_equal(LoaderFactoryDummy, ::ConfigFiles::LoaderFactory.(File.join(file_locations,'dummy.wibble'), loaders: {LoaderFactoryDummy=>['wibble']}, include_default: false))
+    assert_equal(LoaderFactoryDummy, ::ConfigFiles::LoaderFactory.call(File.join(file_locations, 'dummy.wibble'), loaders: { LoaderFactoryDummy => ['wibble'] }, include_default: false))
   end
-end
+end

data/test/loaders_test.rb

@@ -0,0 +1,362 @@
+require 'test_helper'
+require 'tempfile'
+
+class LoadersTest < Minitest::Test
+  def setup
+    @temp_files = []
+  end
+
+  def teardown
+    @temp_files.each(&:unlink)
+  end
+
+  def create_temp_file(content, extension = '.tmp')
+    file = Tempfile.new(['test', extension])
+    file.write(content)
+    file.close
+    @temp_files << file
+    file.path
+  end
+
+  # CONF Parser Tests
+  def test_conf_parser_basic_key_value_pairs
+    content = <<~CONF
+      key1=value1
+      key2: value2
+      key3 value3
+    CONF
+
+    file_path = create_temp_file(content, '.conf')
+    result = ConfigFiles::Loaders::Conf.call(file_path)
+
+    assert_equal 'value1', result['key1']
+    assert_equal 'value2', result['key2']
+    assert_equal 'value3', result['key3']
+  end
+
+  def test_conf_parser_sections
+    content = <<~CONF
+      global_key=global_value
+
+      [section1]
+      key1=value1
+      key2=value2
+
+      [section2]
+      key3=value3
+    CONF
+
+    file_path = create_temp_file(content, '.conf')
+    result = ConfigFiles::Loaders::Conf.call(file_path)
+
+    assert_equal 'global_value', result['global_key']
+    assert_equal 'value1', result['section1']['key1']
+    assert_equal 'value2', result['section1']['key2']
+    assert_equal 'value3', result['section2']['key3']
+  end
+
+  def test_conf_parser_nested_keys
+    content = <<~CONF
+      server.host=localhost
+      server.port=8080
+      database.connection.host=db.example.com
+
+      [app]
+      cache.redis.host=redis.example.com
+      cache.redis.port=6379
+    CONF
+
+    file_path = create_temp_file(content, '.conf')
+    result = ConfigFiles::Loaders::Conf.call(file_path)
+
+    assert_equal 'localhost', result['server']['host']
+    assert_equal 8080, result['server']['port']
+    assert_equal 'db.example.com', result['database']['connection']['host']
+    assert_equal 'redis.example.com', result['app']['cache']['redis']['host']
+    assert_equal 6379, result['app']['cache']['redis']['port']
+  end
+
+  def test_conf_parser_value_types
+    content = <<~CONF
+      string_value=hello world
+      quoted_string="quoted value"
+      single_quoted='single quoted'
+      integer_value=42
+      float_value=3.14
+      boolean_true=true
+      boolean_false=false
+      boolean_yes=yes
+      boolean_no=no
+      boolean_on=on
+      boolean_off=off
+      boolean_1=1
+      boolean_0=0
+    CONF
+
+    file_path = create_temp_file(content, '.conf')
+    result = ConfigFiles::Loaders::Conf.call(file_path)
+
+    assert_equal 'hello world', result['string_value']
+    assert_equal 'quoted value', result['quoted_string']
+    assert_equal 'single quoted', result['single_quoted']
+    assert_equal 42, result['integer_value']
+    assert_in_delta(3.14, result['float_value'])
+    assert result['boolean_true']
+    refute result['boolean_false']
+    assert result['boolean_yes']
+    refute result['boolean_no']
+    assert result['boolean_on']
+    refute result['boolean_off']
+    assert result['boolean_1']
+    refute result['boolean_0']
+  end
+
+  def test_conf_parser_comments_and_empty_lines
+    content = <<~CONF
+      # This is a comment
+      key1=value1
+
+      # Another comment
+      key2=value2
+
+      [section]
+      # Section comment
+      key3=value3
+    CONF
+
+    file_path = create_temp_file(content, '.conf')
+    result = ConfigFiles::Loaders::Conf.call(file_path)
+
+    assert_equal 'value1', result['key1']
+    assert_equal 'value2', result['key2']
+    assert_equal 'value3', result['section']['key3']
+  end
+
+  # INI Parser Tests
+  def test_ini_parser_basic_key_value_pairs
+    content = <<~INI
+      key1=value1
+      key2=value2
+    INI
+
+    file_path = create_temp_file(content, '.ini')
+    result = ConfigFiles::Loaders::Ini.call(file_path)
+
+    assert_equal 'value1', result['key1']
+    assert_equal 'value2', result['key2']
+  end
+
+  def test_ini_parser_sections
+    content = <<~INI
+      global_key=global_value
+
+      [section1]
+      key1=value1
+      key2=value2
+
+      [section2]
+      key3=value3
+    INI
+
+    file_path = create_temp_file(content, '.ini')
+    result = ConfigFiles::Loaders::Ini.call(file_path)
+
+    assert_equal 'global_value', result['global_key']
+    assert_equal 'value1', result['section1']['key1']
+    assert_equal 'value2', result['section1']['key2']
+    assert_equal 'value3', result['section2']['key3']
+  end
+
+  def test_ini_parser_value_types
+    content = <<~INI
+      string_value=hello world
+      quoted_string="quoted value"
+      single_quoted='single quoted'
+      integer_value=42
+      float_value=3.14
+      boolean_true=true
+      boolean_false=false
+      boolean_yes=yes
+      boolean_no=no
+      boolean_on=on
+      boolean_off=off
+      boolean_1=1
+      boolean_0=0
+    INI
+
+    file_path = create_temp_file(content, '.ini')
+    result = ConfigFiles::Loaders::Ini.call(file_path)
+
+    assert_equal 'hello world', result['string_value']
+    assert_equal 'quoted value', result['quoted_string']
+    assert_equal 'single quoted', result['single_quoted']
+    assert_equal 42, result['integer_value']
+    assert_in_delta(3.14, result['float_value'])
+    assert result['boolean_true']
+    refute result['boolean_false']
+    assert result['boolean_yes']
+    refute result['boolean_no']
+    assert result['boolean_on']
+    refute result['boolean_off']
+    assert result['boolean_1']
+    refute result['boolean_0']
+  end
+
+  def test_ini_parser_comments
+    content = <<~INI
+      # Hash comment
+      ; Semicolon comment
+      key1=value1
+
+      [section]
+      # Section comment
+      ; Another section comment
+      key2=value2
+    INI
+
+    file_path = create_temp_file(content, '.ini')
+    result = ConfigFiles::Loaders::Ini.call(file_path)
+
+    assert_equal 'value1', result['key1']
+    assert_equal 'value2', result['section']['key2']
+  end
+
+  # XML Parser Tests
+  def test_xml_parser_basic_structure
+    content = <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <config>
+        <key1>value1</key1>
+        <key2>value2</key2>
+      </config>
+    XML
+
+    file_path = create_temp_file(content, '.xml')
+    result = ConfigFiles::Loaders::Xml.call(file_path)
+
+    assert_equal 'value1', result['key1']
+    assert_equal 'value2', result['key2']
+  end
+
+  def test_xml_parser_nested_elements
+    content = <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <config>
+        <database>
+          <host>localhost</host>
+          <port>5432</port>
+        </database>
+        <app>
+          <name>Test App</name>
+          <debug>true</debug>
+        </app>
+      </config>
+    XML
+
+    file_path = create_temp_file(content, '.xml')
+    result = ConfigFiles::Loaders::Xml.call(file_path)
+
+    assert_equal 'localhost', result['database']['host']
+    assert_equal 5432, result['database']['port']
+    assert_equal 'Test App', result['app']['name']
+    assert result['app']['debug']
+  end
+
+  def test_xml_parser_attributes
+    content = <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <config>
+        <app name="Test App" version="1.0">
+          <debug>false</debug>
+        </app>
+      </config>
+    XML
+
+    file_path = create_temp_file(content, '.xml')
+    result = ConfigFiles::Loaders::Xml.call(file_path)
+
+    assert_equal 'Test App', result['app']['@name']
+    assert_in_delta(1.0, result['app']['@version'])
+    refute result['app']['debug']
+  end
+
+  def test_xml_parser_multiple_elements_same_name
+    content = <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <config>
+        <item>value1</item>
+        <item>value2</item>
+        <item>value3</item>
+      </config>
+    XML
+
+    file_path = create_temp_file(content, '.xml')
+    result = ConfigFiles::Loaders::Xml.call(file_path)
+
+    assert_kind_of Array, result['item']
+    assert_equal 3, result['item'].length
+    assert_equal 'value1', result['item'][0]
+    assert_equal 'value2', result['item'][1]
+    assert_equal 'value3', result['item'][2]
+  end
+
+  def test_xml_parser_value_types
+    content = <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <config>
+        <string_value>hello world</string_value>
+        <integer_value>42</integer_value>
+        <float_value>3.14</float_value>
+        <boolean_true>true</boolean_true>
+        <boolean_false>false</boolean_false>
+        <empty_value></empty_value>
+      </config>
+    XML
+
+    file_path = create_temp_file(content, '.xml')
+    result = ConfigFiles::Loaders::Xml.call(file_path)
+
+    assert_equal 'hello world', result['string_value']
+    assert_equal 42, result['integer_value']
+    assert_in_delta(3.14, result['float_value'])
+    assert result['boolean_true']
+    refute result['boolean_false']
+    assert_nil result['empty_value']
+  end
+
+  # Test existing dummy files to ensure compatibility
+  def test_existing_dummy_files
+    conf_result = ConfigFiles::Loaders::Conf.call('test/etc/dummy.conf')
+    ini_result = ConfigFiles::Loaders::Ini.call('test/etc/dummy.ini')
+    xml_result = ConfigFiles::Loaders::Xml.call('test/etc/dummy.xml')
+
+    # CONF file assertions
+    assert_equal 'test2', conf_result['config_test']
+    assert_equal 'conf_file', conf_result['only_in_conf']
+    assert_equal 'myserver', conf_result['server']['name']
+    assert_equal 'nested_value', conf_result['nested']['config']['value']
+    assert_equal 'conf-db.example.com', conf_result['database']['host']
+    assert_equal 5433, conf_result['database']['port']
+    assert conf_result['database']['ssl']
+    assert_equal 'CONF App', conf_result['app']['name']
+    refute conf_result['app']['debug']
+
+    # INI file assertions
+    assert_equal 'ini_value', ini_result['global_setting']
+    assert_equal 'ini-db.example.com', ini_result['database']['host']
+    assert_equal 3306, ini_result['database']['port']
+    assert ini_result['database']['ssl']
+    assert_equal 'INI App', ini_result['app']['name']
+    refute ini_result['app']['debug']
+    assert_in_delta(2.0, ini_result['app']['version'])
+
+    # XML file assertions
+    assert_equal 'xml_value', xml_result['global_setting']
+    assert_equal 'xml-db.example.com', xml_result['database']['host']
+    assert_equal 5432, xml_result['database']['port']
+    assert xml_result['database']['ssl']
+    assert_equal 'XML App', xml_result['app']['@name']
+    refute xml_result['app']['debug']
+    assert_in_delta(3.0, xml_result['app']['version'])
+  end
+end

data/test/local/dummy.json

@@ -0,0 +1,10 @@
+{
+  "api": {
+    "endpoint": "https://localhost:3000",
+    "debug": true
+  },
+  "features": {
+    "feature_b": true,
+    "feature_c": true
+  }
+}

data/test/local/dummy.yml

@@ -0,0 +1,6 @@
+config_test: local_override
+database:
+  host: localhost
+  username: local_user
+only_in_local: local_only
+shared_key: from_local

data/test/mixed_format_test.rb

@@ -0,0 +1,152 @@
+$LOAD_PATH.push(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'minitest/autorun'
+require 'config_files'
+require 'fileutils'
+
+class MixedFormatTest < Minitest::Test
+  def setup
+    # Create test directories and files with mixed formats
+    FileUtils.mkdir_p('test/format_test/dir1')
+    FileUtils.mkdir_p('test/format_test/dir2')
+    FileUtils.mkdir_p('test/format_test/dir3')
+
+    # dir1: YAML file
+    File.write('test/format_test/dir1/config.yml', <<~YAML)
+      database:
+        host: yaml-host
+        port: 5432
+      app:
+        name: yaml-app
+        debug: false
+      yaml_only: true
+    YAML
+
+    # dir2: JSON file
+    File.write('test/format_test/dir2/config.json', <<~JSON)
+      {
+        "database": {
+          "host": "json-host",
+          "username": "json-user"
+        },
+        "app": {
+          "name": "json-app",
+          "version": "1.0.0"
+        },
+        "json_only": true
+      }
+    JSON
+
+    # dir3: Both YAML and JSON files
+    File.write('test/format_test/dir3/config.yml', <<~YAML)
+      database:
+        host: final-yaml-host
+        password: secret
+      app:
+        debug: true
+      final_yaml: true
+    YAML
+
+    File.write('test/format_test/dir3/config.json', <<~JSON)
+      {
+        "database": {
+          "host": "final-json-host",
+          "timeout": 30
+        },
+        "app": {
+          "environment": "production"
+        },
+        "final_json": true
+      }
+    JSON
+  end
+
+  def teardown
+    FileUtils.rm_rf('test/format_test')
+  end
+
+  def test_mixed_yaml_and_json_across_directories
+    # Test class that uses mixed format directories
+    mixed_class = Class.new do
+      include ConfigFiles
+      config_directories etc: ['test/format_test/dir1', 'test/format_test/dir2', 'test/format_test/dir3']
+      static_config_files :config
+    end
+
+    config = mixed_class.config
+
+    # Test that values from all formats are present
+    assert config.key?(:yaml_only), "Should have YAML-only value from dir1"
+    assert config.key?(:json_only), "Should have JSON-only value from dir2"
+    assert config.key?(:final_yaml), "Should have YAML value from dir3"
+    assert config.key?(:final_json), "Should have JSON value from dir3"
+
+    # Test deep merging across formats with dir1 taking precedence
+    assert config[:database], "Should have database config"
+    assert_equal 'yaml-host', config[:database][:host], "Host should be from dir1 (highest priority)"
+    assert_equal 5432, config[:database][:port], "Port should come from YAML in dir1"
+    assert_equal 'json-user', config[:database][:username], "Username should come from JSON in dir2"
+    assert_equal 'secret', config[:database][:password], "Password should come from YAML in dir3"
+    assert_equal 30, config[:database][:timeout], "Timeout should come from JSON in dir3"
+
+    # Test app config merging
+    assert config[:app], "Should have app config"
+    assert_equal 'yaml-app', config[:app][:name], "Name should be from dir1 (highest priority)"
+    refute config[:app][:debug], "Debug should be from dir1 (highest priority)"
+    assert_equal '1.0.0', config[:app][:version], "Version should come from JSON in dir2"
+    assert_equal 'production', config[:app][:environment], "Environment should come from JSON in dir3"
+  end
+
+  def test_multiple_files_same_directory_same_format
+    # Test when a directory has multiple files of the same format
+    FileUtils.mkdir_p('test/format_test/multi')
+
+    File.write('test/format_test/multi/config.yml', <<~YAML)
+      from_yml: true
+      shared: yml_value
+    YAML
+
+    File.write('test/format_test/multi/config.json', <<~JSON)
+      {
+        "from_json": true,
+        "shared": "json_value"
+      }
+    JSON
+
+    multi_class = Class.new do
+      include ConfigFiles
+      config_directories etc: ['test/format_test/multi']
+      static_config_files :config
+    end
+
+    config = multi_class.config
+
+    # Both formats should be loaded and merged
+    assert config.key?(:from_yml), "Should have YAML values"
+    assert config.key?(:from_json), "Should have JSON values"
+
+    # YAML should override JSON (alphabetical order: config.yml comes after config.json)
+    assert_equal 'yml_value', config[:shared], "YAML should override JSON for same key"
+  end
+
+  def test_file_processing_order_within_directory
+    # Test that files are processed in a predictable order within each directory
+    FileUtils.mkdir_p('test/format_test/order')
+
+    # Create files that will be processed in alphabetical order
+    File.write('test/format_test/order/config.json', '{"order": "json", "source": "json"}')
+    File.write('test/format_test/order/config.yml', "order: yaml\nsource: yaml")
+    File.write('test/format_test/order/config.conf', ":order: conf\n:source: conf")
+
+    order_class = Class.new do
+      include ConfigFiles
+      config_directories etc: ['test/format_test/order']
+      static_config_files :config
+    end
+
+    config = order_class.config
+
+    # The last file alphabetically should win (yml comes after json and conf)
+    assert_equal 'yaml', config[:order]
+    assert_equal 'yaml', config[:source]
+  end
+end