config_files 0.1.6 → 0.2.1

data/lib/config_files/loaders/base_parser.rb

@@ -0,0 +1,133 @@
+module ConfigFiles
+  module Loaders
+    # Base class providing common parsing functionality for configuration file loaders
+    class BaseParser
+      class << self
+        def call(file_name)
+          content = File.read(file_name)
+          parse(content)
+        end
+
+        private
+
+        # Template method to be implemented by subclasses
+        def parse(content)
+          raise NotImplementedError, "Subclasses must implement #parse"
+        end
+
+        # Common value parsing logic shared across parsers
+        def parse_value(value)
+          return nil if value.nil?
+          return value if value.empty?
+
+          # Try to parse as boolean
+          boolean_result = boolean_value?(value)
+          return boolean_result unless boolean_result.nil?
+
+          # Try to parse as number
+          number_value = parse_number(value)
+          return number_value unless number_value.nil?
+
+          # Return as string
+          value
+        end
+
+        # Parse boolean values with common representations
+        def boolean_value?(value)
+          case value.downcase
+          when 'true', 'yes', 'on', '1'
+            true
+          when 'false', 'no', 'off', '0'
+            false
+          end
+        end
+
+        # Parse numeric values (integers and floats)
+        def parse_number(value)
+          return value.to_i if integer?(value)
+          return value.to_f if float?(value)
+
+          nil
+        end
+
+        # Check if string represents an integer
+        def integer?(value)
+          value.match?(/^\d+$/)
+        end
+
+        # Check if string represents a float
+        def float?(value)
+          value.match?(/^\d+\.\d+$/)
+        end
+
+        # Remove surrounding quotes from a value
+        def unquote(value)
+          value.gsub(/^["']|["']$/, '')
+        end
+
+        # Check if line is a comment based on comment prefixes
+        def comment?(line, prefixes = ['#'])
+          prefixes.any? { |prefix| line.start_with?(prefix) }
+        end
+
+        # Check if line is empty or whitespace only
+        def empty_line?(line)
+          line.strip.empty?
+        end
+
+        # Skip processing for comments and empty lines
+        def skip_line?(line, comment_prefixes = ['#'])
+          empty_line?(line) || comment?(line, comment_prefixes)
+        end
+
+        # Parse section header like [section_name]
+        def parse_section_header(line)
+          match = line.match(/^\[(.+)\]$/)
+          match ? match[1].strip : nil
+        end
+
+        # Check if line is a section header
+        def section_header?(line)
+          line.match?(/^\[.+\]$/)
+        end
+
+        # Set nested value using dot notation (e.g., "server.host" -> {"server" => {"host" => value}})
+        def set_nested_value(hash, key_path, value, section = nil)
+          keys = key_path.split('.')
+          target = section ? (hash[section] ||= {}) : hash
+
+          # Navigate to the nested location
+          keys[0..-2].each do |key|
+            target = (target[key] ||= {})
+          end
+
+          # Set the final value
+          target[keys.last] = value
+        end
+
+        # Check if key contains dot notation for nesting
+        def nested_key?(key)
+          key.include?('.')
+        end
+
+        # Set value in hash, handling sections and nesting
+        def set_value(hash, key, value, current_section = nil)
+          parsed_value = parse_value(value)
+
+          if nested_key?(key)
+            set_nested_value(hash, key, parsed_value, current_section)
+          elsif current_section
+            hash[current_section][key] = parsed_value
+          else
+            hash[key] = parsed_value
+          end
+        end
+
+        # Initialize section in hash if it doesn't exist
+        def ensure_section(hash, section_name)
+          hash[section_name] ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/config_files/loaders/conf.rb

@@ -0,0 +1,61 @@
+require_relative 'base_parser'
+
+module ConfigFiles
+  module Loaders
+    class Conf < BaseParser
+      # Supported key-value separators in order of preference
+      SEPARATORS = ['=', ':', ' '].freeze
+
+      class << self
+        private
+
+        def parse(content)
+          result = {}
+          current_section = nil
+
+          content.each_line do |line|
+            line = line.strip
+            next if skip_line?(line)
+
+            if section_header?(line)
+              current_section = parse_section_header(line)
+              ensure_section(result, current_section)
+              next
+            end
+
+            key, value = parse_conf_line(line)
+            next unless key && value
+
+            set_value(result, key, value, current_section)
+          end
+
+          result
+        end
+
+        # Parse CONF format line supporting multiple syntaxes:
+        # key=value, key: value, key value (space-separated)
+        def parse_conf_line(line)
+          key, value = extract_key_value_pair(line)
+          return [nil, nil] unless key && value
+
+          key = key.strip
+          value = unquote(value.strip)
+
+          [key, value]
+        end
+
+        # Extract key-value pair from line using different separators
+        def extract_key_value_pair(line)
+          SEPARATORS.each do |separator|
+            if line.include?(separator)
+              parts = line.split(separator, 2)
+              return parts if parts.length == 2
+            end
+          end
+
+          [nil, nil]
+        end
+      end
+    end
+  end
+end

data/lib/config_files/loaders/default.rb

@@ -1 +1,3 @@
-ConfigFiles::Loaders::Default=ConfigFiles::Loaders::Yaml
+# frozen_string_literal: true
+
+ConfigFiles::Loaders::Default = ConfigFiles::Loaders::Yaml

data/lib/config_files/loaders/ini.rb

@@ -0,0 +1,48 @@
+require_relative 'base_parser'
+
+module ConfigFiles
+  module Loaders
+    class Ini < BaseParser
+      # INI files support both # and ; for comments
+      COMMENT_PREFIXES = ['#', ';'].freeze
+
+      class << self
+        private
+
+        def parse(content)
+          result = {}
+          current_section = nil
+
+          content.each_line do |line|
+            line = line.strip
+            next if skip_line?(line, COMMENT_PREFIXES)
+
+            if section_header?(line)
+              current_section = parse_section_header(line)
+              ensure_section(result, current_section)
+              next
+            end
+
+            key, value = parse_ini_line(line)
+            next unless key && value
+
+            set_value(result, key, value, current_section)
+          end
+
+          result
+        end
+
+        # Parse INI format line (key=value only)
+        def parse_ini_line(line)
+          return [nil, nil] unless line.include?('=')
+
+          key, value = line.split('=', 2)
+          key = key.strip
+          value = unquote(value.strip)
+
+          [key, value]
+        end
+      end
+    end
+  end
+end

data/lib/config_files/loaders/json.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 
 module ConfigFiles
@@ -5,7 +7,7 @@ module ConfigFiles
     class Json
       class << self
         def call(file_name, object_class: ::Hash)
-          ::JSON.load(::File.open(file_name), nil, {object_class: object_class, quirks_mode: true})
+          ::JSON.parse(::File.read(file_name), { object_class: object_class, quirks_mode: true })
         end
       end
     end

data/lib/config_files/loaders/xml.rb

@@ -0,0 +1,67 @@
+require 'rexml/document'
+require_relative 'base_parser'
+
+module ConfigFiles
+  module Loaders
+    class Xml < BaseParser
+      class << self
+        private
+
+        def parse(content)
+          doc = REXML::Document.new(content)
+          doc.root ? parse_element(doc.root) : {}
+        end
+
+        def parse_element(element)
+          result = parse_attributes(element)
+          parse_child_elements(element, result)
+
+          # Return text content if element has no children or attributes
+          return parse_text_content(element) if result.empty? && element.has_text?
+
+          result
+        end
+
+        # Parse element attributes, prefixing with @
+        def parse_attributes(element)
+          result = {}
+          element.attributes.each do |name, value|
+            result["@#{name}"] = parse_value(value)
+          end
+          result
+        end
+
+        # Parse child elements, handling duplicates and nesting
+        def parse_child_elements(element, result)
+          element.elements.each do |child|
+            key = child.name
+            child_value = child.has_elements? ? parse_element(child) : parse_leaf_element(child)
+
+            if result.key?(key)
+              result[key] = convert_to_array(result[key])
+              result[key] << child_value
+            else
+              result[key] = child_value
+            end
+          end
+        end
+
+        # Parse leaf element (no child elements)
+        def parse_leaf_element(element)
+          text = element.text
+          text ? parse_value(text.strip) : nil
+        end
+
+        # Parse text content of element
+        def parse_text_content(element)
+          parse_value(element.text.strip)
+        end
+
+        # Convert single value to array for handling multiple elements with same name
+        def convert_to_array(value)
+          value.is_a?(Array) ? value : [value]
+        end
+      end
+    end
+  end
+end

data/lib/config_files/loaders/yaml.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ConfigFiles
   module Loaders
     class Yaml

data/lib/config_files/loaders.rb

@@ -1,3 +1,8 @@
+# frozen_string_literal: true
+
 require_relative 'loaders/json'
 require_relative 'loaders/yaml'
-require_relative 'loaders/default'
+require_relative 'loaders/conf'
+require_relative 'loaders/ini'
+require_relative 'loaders/xml'
+require_relative 'loaders/default'

data/lib/config_files/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ConfigFiles
-  VERSION='0.1.6'
+  VERSION = '0.2.1'
 end

data/lib/config_files.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require 'config_files/file_factory'
 require 'config_files/loader_factory'
 require 'config_files/loaders'
 require 'config_files/version'
+require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/hash/deep_merge'
 require 'active_support/core_ext/object/blank'
 
@@ -9,8 +12,8 @@ require 'meta'
 require 'yaml'
 
 class NoDirectoryEntry < NoMethodError; end
-module ConfigFiles
 
+module ConfigFiles
   class << self
     def included(base)
       base.class_eval do
@@ -25,7 +28,7 @@ module ConfigFiles
 
     def self.extended(base)
       base.instance_eval do
-        self.directories=default_directories
+        self.directories = default_directories
       end
     end
 
@@ -38,21 +41,23 @@ module ConfigFiles
     end
 
     def default_directories
-      { :etc => ['config', 'etc', '/etc'] }
+      { etc: ['config', 'etc', '/etc'] }
     end
 
     def config_directories(*arr)
-      self.directories||=default_directories
+      self.directories ||= default_directories
       arr.each do |directory_list|
         directory_list.each do |key, value|
-          self.directories[key]=value.map { |dir| ::File.expand_path(dir) }
+          self.directories[key] = value.map { |dir| ::File.expand_path(dir) }
           meta_def("#{key}_dir") { @directories[key] }
         end
       end
     end
 
     def merged_hash(file)
-      config_files(file).inject({}) { |master, file|  master.deep_merge(FileFactory.(file)) }
+      all_config_files(file).inject(::HashWithIndifferentAccess.new) do |master, file|
+        master.deep_merge(FileFactory.call(file))
+      end
     end
 
     def build_combined(file)
@@ -61,7 +66,7 @@ module ConfigFiles
 
     def static_config_files(*arr)
       arr.each do |file|
-        content=build_combined(file)
+        content = build_combined(file)
         meta_def(file) { content }
       end
     end
@@ -72,27 +77,38 @@ module ConfigFiles
       end
     end
 
-    alias_method :config_files, :dynamic_config_files
+    alias config_files dynamic_config_files
 
     private
+
     def directory_listing(directory, file)
-      ::Dir.glob(::File.join(directory, "#{file}.*"))
+      ::Dir.glob(::File.join(directory, "#{file}.*")).sort
     end
 
-    def first_directory(file, key=config_key)
-      begin
-        self.directories[key]&.detect { |directory| directory_listing(directory, file).presence } || ''
-      rescue NoMethodError=>e
-        raise NoDirectoryEntry, "Unable to find #{key} in #{self.directories}"
-      end
+    def first_directory(file, key = config_key)
+      self.directories[key]&.detect { |directory| directory_listing(directory, file).presence } || ''
+    rescue NoMethodError
+      raise NoDirectoryEntry, "Unable to find #{key} in #{self.directories}"
     end
 
-    def files(file, key=config_key)
+    def files(file, key = config_key)
       directory_listing(first_directory(file, key), file)
     end
 
-    def config_files(file, key=config_key)
-      files(file, key)
+    def all_config_files(file, key = config_key)
+      return [] unless self.directories && self.directories[key]
+
+      # Collect files by directory, maintaining alphabetical order within each directory
+      files_by_directory = []
+      self.directories[key].each do |directory|
+        if ::File.directory?(directory)
+          directory_files = directory_listing(directory, file)
+          files_by_directory << directory_files if directory_files.any?
+        end
+      end
+
+      # Reverse directory order but keep file order within each directory
+      files_by_directory.reverse.flatten
     end
   end
 end

data/lib/meta.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # @author Paul McKibbin based on meta definitions by _why_the_lucky_stiff_
 module Meta
   def meta_self
@@ -6,7 +8,7 @@ module Meta
     end
   end
 
-  def meta_def name, &blk
+  def meta_def(name, &blk)
     meta_self.instance_eval { define_method name, &blk }
   end
 end

data/scripts/install_rubies_asdf.sh

@@ -0,0 +1,187 @@
+#!/bin/bash
+
+# Script to install all Ruby versions needed for testing using asdf
+# This is a specialized script for asdf users
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Ruby versions to install
+RUBY_VERSIONS=("2.7.8" "3.0.6" "3.1.4" "3.2.2" "3.3.0" "3.4.1")
+
+echo -e "${BLUE}ConfigFiles Ruby Installation Script (asdf)${NC}"
+echo -e "${BLUE}===========================================${NC}"
+
+# Function to check if asdf is installed and configured
+check_asdf() {
+    if ! command -v asdf >/dev/null 2>&1; then
+        echo -e "${RED}asdf not found. Please install asdf first.${NC}"
+        echo -e "${BLUE}Installation instructions:${NC}"
+        echo -e "  macOS: brew install asdf"
+        echo -e "  Linux: git clone https://github.com/asdf-vm/asdf.git ~/.asdf --branch v0.14.0"
+        echo -e "  More info: https://asdf-vm.com/guide/getting-started.html"
+        exit 1
+    fi
+    
+    echo -e "${GREEN}✓ asdf found${NC}"
+    
+    # Check if ruby plugin is installed
+    if ! asdf plugin list | grep -q "^ruby$"; then
+        echo -e "${YELLOW}Installing Ruby plugin...${NC}"
+        if asdf plugin add ruby https://github.com/asdf-vm/asdf-ruby.git; then
+            echo -e "${GREEN}✓ Ruby plugin installed${NC}"
+        else
+            echo -e "${RED}✗ Failed to install Ruby plugin${NC}"
+            exit 1
+        fi
+    else
+        echo -e "${GREEN}✓ Ruby plugin already installed${NC}"
+    fi
+}
+
+# Function to check if Ruby version is installed
+check_ruby_version() {
+    local version=$1
+    asdf list ruby 2>/dev/null | grep -q "^\s*${version}$"
+}
+
+# Function to install Ruby version
+install_ruby_version() {
+    local version=$1
+    echo -e "${YELLOW}Installing Ruby ${version}...${NC}"
+    
+    # Show progress
+    if asdf install ruby "$version"; then
+        echo -e "${GREEN}✓ Ruby ${version} installed successfully${NC}"
+        return 0
+    else
+        echo -e "${RED}✗ Failed to install Ruby ${version}${NC}"
+        return 1
+    fi
+}
+
+# Function to show system requirements
+show_requirements() {
+    echo -e "\n${BLUE}System Requirements:${NC}"
+    echo -e "Before installing Ruby versions, make sure you have the required dependencies:"
+    echo
+    
+    if [[ "$OSTYPE" == "darwin"* ]]; then
+        echo -e "${YELLOW}macOS:${NC}"
+        echo -e "  brew install openssl readline sqlite3 xz zlib"
+        echo -e "  xcode-select --install"
+    elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
+        echo -e "${YELLOW}Ubuntu/Debian:${NC}"
+        echo -e "  sudo apt-get install -y build-essential libssl-dev libreadline-dev zlib1g-dev"
+        echo -e "  sudo apt-get install -y libsqlite3-dev libxml2-dev libxslt1-dev libcurl4-openssl-dev"
+        echo -e "  sudo apt-get install -y libffi-dev libyaml-dev"
+        echo
+        echo -e "${YELLOW}CentOS/RHEL/Fedora:${NC}"
+        echo -e "  sudo yum groupinstall -y 'Development Tools'"
+        echo -e "  sudo yum install -y openssl-devel readline-devel zlib-devel sqlite-devel"
+    fi
+    
+    echo
+    read -p "Have you installed the required dependencies? (y/N): " -n 1 -r
+    echo
+    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+        echo -e "${YELLOW}Please install the dependencies first, then run this script again.${NC}"
+        exit 1
+    fi
+}
+
+# Main execution
+echo -e "\n${YELLOW}This script will install the following Ruby versions using asdf:${NC}"
+for version in "${RUBY_VERSIONS[@]}"; do
+    echo -e "  - Ruby ${version}"
+done
+
+echo
+read -p "Continue? (y/N): " -n 1 -r
+echo
+if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+    echo -e "${YELLOW}Installation cancelled.${NC}"
+    exit 0
+fi
+
+# Check asdf installation
+check_asdf
+
+# Show system requirements
+show_requirements
+
+# Check current installations
+echo -e "\n${BLUE}Checking current Ruby installations...${NC}"
+already_installed=()
+to_install=()
+
+for ruby_version in "${RUBY_VERSIONS[@]}"; do
+    if check_ruby_version "$ruby_version"; then
+        echo -e "${GREEN}✓ Ruby ${ruby_version} is already installed${NC}"
+        already_installed+=("$ruby_version")
+    else
+        echo -e "${YELLOW}○ Ruby ${ruby_version} needs to be installed${NC}"
+        to_install+=("$ruby_version")
+    fi
+done
+
+if [ ${#to_install[@]} -eq 0 ]; then
+    echo -e "\n${GREEN}All Ruby versions are already installed! 🎉${NC}"
+    exit 0
+fi
+
+# Install missing versions
+echo -e "\n${BLUE}Installing ${#to_install[@]} Ruby versions...${NC}"
+failed_installations=()
+successful_installations=()
+
+for ruby_version in "${to_install[@]}"; do
+    echo -e "\n${YELLOW}[$(date '+%H:%M:%S')] Installing Ruby ${ruby_version}...${NC}"
+    
+    if install_ruby_version "$ruby_version"; then
+        successful_installations+=("$ruby_version")
+    else
+        failed_installations+=("$ruby_version")
+        echo -e "${RED}Installation of Ruby ${ruby_version} failed. Continuing with others...${NC}"
+    fi
+done
+
+# Summary
+echo -e "\n${BLUE}=== Installation Summary ===${NC}"
+echo -e "Already installed: ${#already_installed[@]}"
+echo -e "${GREEN}Successfully installed: ${#successful_installations[@]}${NC}"
+echo -e "${RED}Failed installations: ${#failed_installations[@]}${NC}"
+
+if [ ${#successful_installations[@]} -gt 0 ]; then
+    echo -e "\n${GREEN}Successfully installed:${NC}"
+    for version in "${successful_installations[@]}"; do
+        echo -e "${GREEN}  ✓ Ruby ${version}${NC}"
+    done
+fi
+
+if [ ${#failed_installations[@]} -gt 0 ]; then
+    echo -e "\n${RED}Failed installations:${NC}"
+    for version in "${failed_installations[@]}"; do
+        echo -e "${RED}  ✗ Ruby ${version}${NC}"
+    done
+    echo -e "\n${YELLOW}Troubleshooting tips:${NC}"
+    echo -e "  1. Make sure you have all system dependencies installed"
+    echo -e "  2. Check asdf ruby plugin: asdf plugin update ruby"
+    echo -e "  3. Try installing manually: asdf install ruby <version>"
+    echo -e "  4. Check logs in ~/.asdf/installs/ruby/<version>/install.log"
+fi
+
+# Show next steps
+echo -e "\n${BLUE}Next Steps:${NC}"
+echo -e "  1. Run the test suite: ./scripts/test_multiple_rubies.sh"
+echo -e "  2. Set a global Ruby version: asdf global ruby <version>"
+echo -e "  3. Set a local Ruby version: asdf local ruby <version>"
+
+total_available=$((${#already_installed[@]} + ${#successful_installations[@]}))
+echo -e "\n${GREEN}You now have ${total_available} Ruby versions available for testing! 🚀${NC}"