Module: MilkTea::Bindgen::Generator::GeneratorOverrides

Included in:
MilkTea::Bindgen::Generator
Defined in:
lib/milk_tea/bindings/bindgen/overrides.rb

Instance Method Summary collapse

Instance Method Details

#field_type_override(type_name, field_name) ⇒ Object 



15
16
17
 
# File 'lib/milk_tea/bindings/bindgen/overrides.rb', line 15

def field_type_override(type_name, field_name)
  @field_type_overrides.dig(type_name, field_name)
end

#function_param_type_override(function_name, param_name) ⇒ Object 



7
8
9
 
# File 'lib/milk_tea/bindings/bindgen/overrides.rb', line 7

def function_param_type_override(function_name, param_name)
  @function_param_type_overrides.dig(function_name, param_name)
end

#function_return_type_override(function_name) ⇒ Object 



11
12
13
 
# File 'lib/milk_tea/bindings/bindgen/overrides.rb', line 11

def function_return_type_override(function_name)
  @function_return_type_overrides[function_name]
end

#normalize_field_type_overrides(overrides) ⇒ Object

Raises:



43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/milk_tea/bindings/bindgen/overrides.rb', line 43

def normalize_field_type_overrides(overrides)
  return {} if overrides.nil?

  raise BindgenError, "field_type_overrides must be a hash" unless overrides.is_a?(Hash)

  overrides.each_with_object({}) do |(type_name, field_overrides), normalized|
    unless type_name.is_a?(String) || type_name.is_a?(Symbol)
      raise BindgenError, "field_type_overrides type names must be strings or symbols"
    end

    raise BindgenError, "field_type_overrides for #{type_name} must be a hash" unless field_overrides.is_a?(Hash)

    normalized[type_name.to_s] = field_overrides.each_with_object({}) do |(field_name, type), fields|
      unless field_name.is_a?(String) || field_name.is_a?(Symbol)
        raise BindgenError, "field_type_overrides field names must be strings or symbols"
      end

      raise BindgenError, "field_type_overrides for #{type_name}.#{field_name} must be a non-empty string" unless type.is_a?(String) && !type.empty?

      fields[field_name.to_s] = type
    end.freeze
  end.freeze
end

#normalize_function_param_type_overrides(overrides) ⇒ Object

Raises:



19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/milk_tea/bindings/bindgen/overrides.rb', line 19

def normalize_function_param_type_overrides(overrides)
  return {} if overrides.nil?

  raise BindgenError, "function_param_type_overrides must be a hash" unless overrides.is_a?(Hash)

  overrides.each_with_object({}) do |(function_name, param_overrides), normalized|
    unless function_name.is_a?(String) || function_name.is_a?(Symbol)
      raise BindgenError, "function_param_type_overrides function names must be strings or symbols"
    end

    raise BindgenError, "function_param_type_overrides for #{function_name} must be a hash" unless param_overrides.is_a?(Hash)

    normalized[function_name.to_s] = param_overrides.each_with_object({}) do |(param_name, type), params|
      unless param_name.is_a?(String) || param_name.is_a?(Symbol)
        raise BindgenError, "function_param_type_overrides parameter names must be strings or symbols"
      end

      raise BindgenError, "function_param_type_overrides for #{function_name}.#{param_name} must be a non-empty string" unless type.is_a?(String) && !type.empty?

      params[param_name.to_s] = type
    end.freeze
  end.freeze
end

#normalize_function_return_type_overrides(overrides) ⇒ Object

Raises:



114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
# File 'lib/milk_tea/bindings/bindgen/overrides.rb', line 114

def normalize_function_return_type_overrides(overrides)
  return {} if overrides.nil?

  raise BindgenError, "function_return_type_overrides must be a hash" unless overrides.is_a?(Hash)

  overrides.each_with_object({}) do |(function_name, type), normalized|
    unless function_name.is_a?(String) || function_name.is_a?(Symbol)
      raise BindgenError, "function_return_type_overrides function names must be strings or symbols"
    end

    raise BindgenError, "function_return_type_overrides for #{function_name} must be a non-empty string" unless type.is_a?(String) && !type.empty?

    normalized[function_name.to_s] = type
  end.freeze
end

#normalize_module_imports(imports) ⇒ Object

Raises:



67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/milk_tea/bindings/bindgen/overrides.rb', line 67

def normalize_module_imports(imports)
  return [] if imports.nil?
  raise BindgenError, "module_imports must be an array" unless imports.is_a?(Array)

  imports.map do |entry|
    raise BindgenError, "module_imports entries must be hashes" unless entry.is_a?(Hash)

    module_name = entry.fetch(:module_name) { entry.fetch("module_name", nil) }
    import_alias = entry.fetch(:alias) { entry.fetch("alias", nil) }
    raise BindgenError, "module_imports module_name must be a non-empty string" unless module_name.is_a?(String) && !module_name.empty?
    raise BindgenError, "module_imports alias must be a non-empty string" unless import_alias.is_a?(String) && !import_alias.empty?

    { module_name:, alias: import_alias }
  end.freeze
end

#normalize_type_name_overrides(overrides) ⇒ Object

Raises:



98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/milk_tea/bindings/bindgen/overrides.rb', line 98

def normalize_type_name_overrides(overrides)
  return {} if overrides.nil?
  raise BindgenError, "type_name_overrides must be a hash" unless overrides.is_a?(Hash)

  overrides.each_with_object({}) do |(type_name, visible_name), normalized|
    unless type_name.is_a?(String) || type_name.is_a?(Symbol)
      raise BindgenError, "type_name_overrides type names must be strings or symbols"
    end
    unless visible_name.is_a?(String) && !visible_name.empty?
      raise BindgenError, "type_name_overrides for #{type_name} must be a non-empty string"
    end

    normalized[type_name.to_s] = visible_name
  end.freeze
end

#normalize_type_overrides(overrides) ⇒ Object

Raises:



83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/milk_tea/bindings/bindgen/overrides.rb', line 83

def normalize_type_overrides(overrides)
  return {} if overrides.nil?
  raise BindgenError, "type_overrides must be a hash" unless overrides.is_a?(Hash)

  overrides.each_with_object({}) do |(type_name, mapped_type), normalized|
    unless type_name.is_a?(String) || type_name.is_a?(Symbol)
      raise BindgenError, "type_overrides type names must be strings or symbols"
    end

    raise BindgenError, "type_overrides for #{type_name} must be a non-empty string" unless mapped_type.is_a?(String) && !mapped_type.empty?

    normalized[type_name.to_s] = mapped_type
  end.freeze
end