Class: Anthropic::Internal::Type::HashOf Abstract Private

Inherits:
Object
  • Object
show all
Includes:
Converter, Util::SorbetRuntimeSupport
Defined in:
lib/anthropic/internal/type/hash_of.rb

Overview

This class is part of a private API. You should avoid using this class if possible, as it may be removed or be changed in the future.

This class is abstract.

Hash of items of a given type.

Generic:

  • Elem

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Util::SorbetRuntimeSupport

#const_missing, #define_sorbet_constant!, #sorbet_constant_defined?, to_sorbet_type

Methods included from Converter

coerce, dump, inspect, meta_info, new_coerce_state, type_info

Constructor Details

#initialize(type_info, spec = {}) ⇒ HashOf

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns a new instance of HashOf.



169
170
171
172
173
 
# File 'lib/anthropic/internal/type/hash_of.rb', line 169

def initialize(type_info, spec = {})
  @item_type_fn = Anthropic::Internal::Type::Converter.type_info(type_info || spec)
  @meta = Anthropic::Internal::Type::Converter.meta_info(type_info, spec)
  @nilable = spec.fetch(:nil?, false)
end

Class Method Details

.[](type_info, spec = {}) ⇒ self

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



34
 
# File 'lib/anthropic/internal/type/hash_of.rb', line 34

def self.[](...) = new(...)

Instance Method Details

#==(other) ⇒ Boolean 



63
64
65
66
67
 
# File 'lib/anthropic/internal/type/hash_of.rb', line 63

def ==(other)
  # rubocop:disable Layout/LineLength
  other.is_a?(Anthropic::Internal::Type::HashOf) && other.nilable? == nilable? && other.item_type == item_type
  # rubocop:enable Layout/LineLength
end

#===(other) ⇒ Boolean 



41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/anthropic/internal/type/hash_of.rb', line 41

def ===(other)
  type = item_type
  case other
  in Hash
    other.all? do |key, val|
      case [key, val]
      in [Symbol | String, ^type]
        true
      else
        false
      end
    end
  else
    false
  end
end

#coerce(value, state:) ⇒ Hash{Symbol=>Object}, Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/anthropic/internal/type/hash_of.rb', line 91

def coerce(value, state:)
  exactness = state.fetch(:exactness)

  unless value.is_a?(Hash)
    exactness[:no] += 1
    state[:error] = TypeError.new("#{value.class} can't be coerced into #{Hash}")
    return value
  end

  target = item_type
  exactness[:yes] += 1
  value
    .to_h do |key, val|
      k = key.is_a?(String) ? key.to_sym : key
      v =
        case [nilable?, val]
        in [true, nil]
          exactness[:yes] += 1
          nil
        else
          Anthropic::Internal::Type::Converter.coerce(target, val, state: state)
        end

      exactness[:no] += 1 unless k.is_a?(Symbol)
      [k, v]
    end
end

#dump(value, state:) ⇒ Hash{Symbol=>Object}, Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



128
129
130
131
132
133
134
135
136
137
 
# File 'lib/anthropic/internal/type/hash_of.rb', line 128

def dump(value, state:)
  target = item_type
  if value.is_a?(Hash)
    value.transform_values do
      Anthropic::Internal::Type::Converter.dump(target, _1, state: state)
    end
  else
    super
  end
end

#hash ⇒ Integer 



72
 
# File 'lib/anthropic/internal/type/hash_of.rb', line 72

def hash = [self.class, item_type].hash

#inspect(depth: 0) ⇒ String

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



180
181
182
183
184
 
# File 'lib/anthropic/internal/type/hash_of.rb', line 180

def inspect(depth: 0)
  items = Anthropic::Internal::Type::Converter.inspect(item_type, depth: depth.succ)

  "#{self.class}[#{[items, nilable? ? 'nil' : nil].compact.join(' | ')}]"
end

#to_sorbet_type ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



142
143
144
 
# File 'lib/anthropic/internal/type/hash_of.rb', line 142

def to_sorbet_type
  T::Hash[Anthropic::Internal::Util::SorbetRuntimeSupport.to_sorbet_type(item_type)]
end