Safe Navigation Operator

Performance Considerations and Alternatives

class PerformanceAndAlternatives
  def self.performance_comparison
    puts "=== Performance Comparison ==="

    require 'benchmark'

    # Test data
    valid_object = { user: { profile: { name: "Alice" } } }
    nil_object = nil
    n = 100_000

    puts "Comparing performance for #{n} iterations:"

    Benchmark.bm(25) do |x|
      x.report("Traditional nil check") do
        n.times do
          if valid_object && valid_object[:user] && valid_object[:user][:profile]
            valid_object[:user][:profile][:name]
          end
        end
      end

      x.report("Safe navigation") do
        n.times do
          valid_object&.dig(:user, :profile, :name)
        end
      end

      x.report("Rescue approach") do
        n.times do
          begin
            valid_object[:user][:profile][:name]
          rescue
            nil
          end
        end
      end

      x.report("Try-like method") do
        def try_method(obj, *methods)
          methods.reduce(obj) { |o, m| o.respond_to?(m) ? o.send(m) : nil }
        end

        n.times do
          try_method(valid_object, :[], :user, :[], :profile, :[], :name)
        end
      end
    end
  end

  def self.demonstrate_alternatives
    puts "\n=== Alternative Approaches ==="

    test_data = [
      { user: { name: "Alice", email: "alice@example.com" } },
      { user: { name: "Bob" } },  # Missing email
      {},  # Missing user
      nil  # Nil object
    ]

    test_data.each_with_index do |data, i|
      puts "\nData #{i + 1}: #{data.inspect}"

      # Method 1: Safe navigation
      email1 = data&.dig(:user, :email)

      # Method 2: Fetch with default
      email2 = data&.fetch(:user, {})&.fetch(:email, nil)

      # Method 3: Custom safe accessor
      def safe_get(obj, *keys)
        keys.reduce(obj) do |current, key|
          case current
          when Hash
            current[key]
          when Array
            current[key] if key.is_a?(Integer) && key >= 0
          else
            nil
          end
        end
      end

      email3 = safe_get(data, :user, :email)

      # Method 4: Nil object pattern
      class NilUser
        def email; nil; end
        def name; "Anonymous"; end
      end

      user_obj = data&.[](:user) || NilUser.new
      email4 = user_obj.respond_to?(:email) ? user_obj.email : nil

      puts "  Safe navigation: #{email1.inspect}"
      puts "  Fetch method: #{email2.inspect}"
      puts "  Custom safe get: #{email3.inspect}"
      puts "  Nil object: #{email4.inspect}"
    end
  end

  def self.demonstrate_best_practice_patterns
    puts "\n=== Best Practice Patterns ==="

    class UserService
      def self.format_user_display(user_data)
        # Pattern 1: Early return for nil
        return "No user data" unless user_data

        # Pattern 2: Safe navigation with meaningful defaults
        name = user_data&.dig(:profile, :display_name) ||
               user_data&.dig(:profile, :full_name) ||
               user_data&.[](:username) ||
               "Anonymous User"

        email = user_data&.[](:email)
        avatar = user_data&.dig(:profile, :avatar, :url) || "/images/default-avatar.png"

        # Pattern 3: Conditional formatting
        email_display = email ? " (#{email})" : ""

        # Pattern 4: Safe string operations
        bio = user_data&.dig(:profile, :bio)&.strip
        bio_preview = bio&.length&.> 50 ? "#{bio[0..47]}..." : bio

        {
          display_name: name,
          contact: "#{name}#{email_display}",
          avatar_url: avatar,
          bio_preview: bio_preview
        }
      end

      def self.validate_user_data(user_data)
        # Pattern 5: Validation with safe navigation
        errors = []

        # Required field validation
        name = user_data&.dig(:profile, :display_name) || user_data&.[](:username)
        errors << "Name is required" if name&.strip&.empty? || name.nil?

        email = user_data&.[](:email)
        errors << "Email is required" if email&.strip&.empty? || email.nil?
        errors << "Email format invalid" if email && !email&.include?("@")

        # Optional field validation
        bio = user_data&.dig(:profile, :bio)
        errors << "Bio too long" if bio&.length&.> 500

        phone = user_data&.dig(:contact, :phone)
        errors << "Invalid phone format" if phone && !phone&.match?(/^\+?[\d\s\-\(\)]+$/)

        {
          valid: errors.empty?,
          errors: errors,
          data: {
            name: name,
            email: email,
            bio: bio,
            phone: phone
          }
        }
      end
    end

    # Test the patterns
    test_users = [
      {
        username: "alice123",
        email: "alice@example.com",
        profile: {
          display_name: "Alice Smith",
          bio: "Software developer passionate about Ruby and web development.",
          avatar: { url: "https://example.com/avatar1.jpg" }
        },
        contact: { phone: "+1-555-0123" }
      },
      {
        email: "bob@example.com",
        profile: { bio: "" }
        # Missing name and other fields
      },
      {}  # Empty user data
    ]

    test_users.each_with_index do |user, i|
      puts "\nUser #{i + 1}:"

      display_info = UserService.format_user_display(user)
      validation_result = UserService.validate_user_data(user)

      puts "  Display: #{display_info[:display_name]}"
      puts "  Contact: #{display_info[:contact]}"
      puts "  Bio: #{display_info[:bio_preview].inspect}"
      puts "  Valid: #{validation_result[:valid]}"
      puts "  Errors: #{validation_result[:errors]}" unless validation_result[:errors].empty?
    end
  end
end

# PerformanceAndAlternatives.performance_comparison  # Uncomment to run benchmark
PerformanceAndAlternatives.demonstrate_alternatives
PerformanceAndAlternatives.demonstrate_best_practice_patterns