Module: Legion::Extensions::Llm::Utils

Defined in:
lib/legion/extensions/llm/utils.rb

Overview

Provides utility functions for data manipulation within the Legion::Extensions::Llm library

Class Method Summary collapse

Class Method Details

.deep_dup(value) ⇒ Object 



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/legion/extensions/llm/utils.rb', line 65

def deep_dup(value)
  case value
  when Hash
    value.each_with_object({}) do |(key, val), duped|
      duped[deep_dup(key)] = deep_dup(val)
    end
  when Array
    value.map { |item| deep_dup(item) }
  else
    begin
      value.dup
    rescue TypeError
      value
    end
  end
end

.deep_merge(original, overrides) ⇒ Object

Recursive merge with the safer dup-before-merge policy (10 U7): neither input is mutated.



35
36
37
38
39
40
41
42
43
 
# File 'lib/legion/extensions/llm/utils.rb', line 35

def deep_merge(original, overrides)
  deep_dup(original || {}).merge(deep_dup(overrides || {})) do |_key, original_value, overrides_value|
    if original_value.is_a?(Hash) && overrides_value.is_a?(Hash)
      deep_merge(original_value, overrides_value)
    else
      overrides_value
    end
  end
end

.deep_stringify_keys(value) ⇒ Object 



82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/legion/extensions/llm/utils.rb', line 82

def deep_stringify_keys(value)
  case value
  when Hash
    value.each_with_object({}) do |(key, val), result|
      result[key.to_s] = deep_stringify_keys(val)
    end
  when Array
    value.map { |item| deep_stringify_keys(item) }
  when Symbol
    value.to_s
  else
    value
  end
end

.deep_symbolize_keys(value) ⇒ Object 



97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/legion/extensions/llm/utils.rb', line 97

def deep_symbolize_keys(value)
  case value
  when Hash
    value.each_with_object({}) do |(key, val), result|
      symbolized_key = key.respond_to?(:to_sym) ? key.to_sym : key
      result[symbolized_key] = deep_symbolize_keys(val)
    end
  when Array
    value.map { |item| deep_symbolize_keys(item) }
  else
    value
  end
end

.localhost_url?(url) ⇒ Boolean

The one host-locality detector (10 §1E): localhost/loopback by host, accepting full URLs and bare host values.

Returns:

  • (Boolean) 


47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/legion/extensions/llm/utils.rb', line 47

def localhost_url?(url)
  require 'uri'
  text = url.to_s.strip
  return false if text.empty?

  host =
    begin
      parsed = text.match?(%r{\A[a-z][a-z0-9+.-]*://}) ? URI.parse(text) : URI.parse("http://#{text}")
      parsed.host
    rescue URI::InvalidURIError
      text.split(%r{[:/\s]}, 2).first
    end
  return false if host.nil? || host.empty?

  normalized = host.delete_prefix('[').delete_suffix(']').downcase
  %w[localhost 127.0.0.1 ::1].include?(normalized)
end

.to_date(value) ⇒ Object 



27
28
29
30
31
 
# File 'lib/legion/extensions/llm/utils.rb', line 27

def to_date(value)
  return unless value

  value.is_a?(Date) ? value : Date.parse(value.to_s)
end

.to_safe_array(item) ⇒ Object 



10
11
12
13
14
15
16
17
18
19
 
# File 'lib/legion/extensions/llm/utils.rb', line 10

def to_safe_array(item)
  case item
  when Array
    item
  when Hash
    [item]
  else
    Array(item)
  end
end

.to_time(value) ⇒ Object 



21
22
23
24
25
 
# File 'lib/legion/extensions/llm/utils.rb', line 21

def to_time(value)
  return unless value

  value.is_a?(Time) ? value : Time.parse(value.to_s)
end