Class: BiDiGenerate::Schema Private

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 939

def baked_discriminator?(field)
  field['type'].key?('const') && !field['type']['nullable']
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 636

def build_vendor_command(cmd, type_name, entry, namespace)
  shared = record_params(@types[type_name]['fields'])
  taken = shared.map(&:ruby_name)
  VendorCommand.new(
    method_name: BiDiGenerate.safe_method_name(BiDiGenerate.camel_to_snake(cmd['name'])),
    wire_name: cmd['method'],
    result_ref: cmd['result'] && structured_ref(cmd['result']['ref']),
    params_class: BiDiGenerate.type_class_name(type_name),
    shared_params: shared,
    vendor_params: entry['fields'].map { |field| vendor_param(field, namespace, taken) },
    spec_href: cmd['specHref']
  )
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 591

def command_wrapper_refs(domain)
  commands_for(domain).flat_map { |c| [c.dig('params', 'ref'), c.dig('result', 'ref')] }.compact.to_set
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 583

def commands_for(domain)
  @commands.select { |c| c['domain'] == domain }
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1165

def default_variant_enum_values(selector, by)
  default = selector['default']
  field = default && @types[default]['fields'].find { |f| f['wire'] == by }
  ref = field && field['type']['ref']
  ref && @types[ref] && @types[ref]['kind'] == 'enum' ? @types[ref]['values'] : []
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 914

def directionality(name)
  node = @types[name]
  {outbound: node['outbound'] ? true : false, inbound: node['inbound'] ? true : false}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1029

def discriminated_variants(selector)
  variants = selector['variants'].map do |variant|
    VariantIR.new(mode: :value, value: variant['value'], ref: ruby_path(variant['ref']), requires: nil)
  end
  return variants unless selector['default']

  variants << VariantIR.new(mode: :fallback, value: nil, ref: ruby_path(selector['default']), requires: nil)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 547

def domain_href(domain)
  @domains.dig(domain, 'specHref')
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 762

def domain_path(name)
  name.include?('.') ? ruby_path(name) : nil
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 609

def domain_relative_path(name)
  prefix = "#{BiDiGenerate.snake_to_class_name(BiDiGenerate.camel_to_snake(name.split('.', 2).first))}::"
  ruby_path(name).sub(/\A#{Regexp.escape(prefix)}/, '')
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 579

def domains
  (@commands + @events).map { |entry| entry['domain'] }.uniq
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1122

def enum_const(field_type)
  ref = field_type['ref'] || field_type.dig('list', 'ref')
  return unless ref && @types[ref] && @types[ref]['kind'] == 'enum'

  BiDiGenerate.enum_const_path(ref)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 692

def enums_for(domain)
  @types.filter_map do |name, type|
    next unless type['kind'] == 'enum'
    next unless name.start_with?("#{domain}.")

    pairs = type['values'].map { |v| [BiDiGenerate.enum_key(v), v.to_s] }
    Enum.new(constant_name: BiDiGenerate.screaming_snake(name.sub("#{domain}.", '')), pairs: pairs,
             spec_href: type['specHref'])
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 742

def envelope_synthetic?(type)
  return false unless type['synthetic']

  owner = @types[type['owner']]
  owner && owner['kind'] == 'record' && message_envelope?(owner)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 705

def error_codes
  @types.dig('ErrorCode', 'values') || []
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 671

def events_for(domain)
  @events.select { |e| e['domain'] == domain }
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 943

def field_ir(field)
  resolved = resolve(field['type'])
  ruby_name = BiDiGenerate.safe_field_name(BiDiGenerate.camel_to_snake(field['name']))
  FieldIR.new(ruby_name: ruby_name, wire_key: field['wire'],
              required: field['required'], nullable: resolved[:nullable],
              ref: resolved[:ref], list: resolved[:list], enum: enum_const(field['type']),
              primitive: leaf_primitive(field['type']), scalar: resolved[:scalar],
              const: leaf_const(field['type']), rbs: resolved[:rbs])
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1188

def guard_union_dispatch_keys_simple!(selector, ref)
  keys = selector['by'] ? [selector['by']] : (selector['ordered'] || []).flat_map { |arm| arm['requires'] }
  camel = keys.reject { |k| BiDiGenerate.camel_to_snake(k) == k }
  return if camel.empty?

  raise "union command param #{ref} dispatches on non-snake wire key(s) #{camel.inspect}; " \
        'Union.build matches kwargs to dispatch keys by symbol, so give the outbound ' \
        'dispatch an explicit wire<->ruby mapping before shipping this.'
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 957

def leaf_const(node, seen = {})
  return node['const'] if node.key?('const')
  return nil unless node.key?('ref')

  name = node['ref']
  type = @types[name]
  return nil if seen[name] || type.nil? || type['kind'] != 'alias'

  seen[name] = true
  leaf_const(type['type'], seen)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 974

def leaf_primitive(node, seen = {})
  return node['primitive'] if node.key?('primitive') && CHECKABLE_PRIMITIVES.include?(node['primitive'])
  return nil unless node.key?('ref')

  name = node['ref']
  type = @types[name]
  return nil if seen[name] || type.nil? || type['kind'] != 'alias'

  seen[name] = true
  leaf_primitive(type['type'], seen)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1174

def merged_params(variant_fields)
  all_fields = variant_fields.flatten
  all_fields.map { |f| f['wire'] }.uniq.map do |wire|
    field = all_fields.find { |f| f['wire'] == wire }
    required = variant_fields.all? { |fields| fields.any? { |f| f['wire'] == wire && f['required'] } }
    Param.new(ruby_name: BiDiGenerate.safe_field_name(BiDiGenerate.camel_to_snake(field['name'])),
              wire_name: wire, required: required, rbs: rbs_type(field['type']))
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 737

def message_envelope?(type)
  type['fields'].any? { |f| f['wire'] == 'method' && f['type'].key?('const') }
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 876

def named_type(name)
  {ref: domain_path(name), list: false, rbs: rbs_abs(ruby_path(name))}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 883

def named_union(name)
  {ref: domain_path(name), list: false, rbs: union_alias_path(name)}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 908

def nilable(type, flag)
  flag ? BiDiGenerate.rbs_nilable(type) : type
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1038

def ordered_variants(selector)
  (selector['ordered'] || []).map do |arm|
    VariantIR.new(mode: :presence, value: nil, ref: ruby_path(arm['ref']), requires: arm['requires'])
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 679

def params_for(params_ref)
  return [] unless params_ref

  type = @types[params_ref['ref']]
  return nil unless type

  case type['kind']
  when 'record' then record_params(type['fields'])
  when 'union' then union_params(type, params_ref['ref'])
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 769

def plain_refs(node)
  case node['kind']
  when 'record'
    refs = node['fields'].flat_map { |f| refs_in_type(f['type']) }
    node['map'] ? refs + refs_in_type(node['map']) : refs
  when 'alias' then refs_in_type(node['type'])
  else []
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 600

def plainly_reached_types
  @plainly_reached_types ||= @types.each_value.with_object(Set.new) do |node, reached|
    plain_refs(node).each { |ref| reached << ref }
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 559

def promote_command_params_records!
  @commands.each do |cmd|
    ref = cmd.dig('params', 'ref')
    next unless ref

    type = @types[ref]
    promote_to_domain_type!(ref) if type && envelope_synthetic?(type)
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 571

def promote_to_domain_type!(name)
  type = @types[name]
  type&.delete('synthetic')
  type&.delete('owner')
  type&.delete('label')
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1115

def rbs_abs(path)
  "::Selenium::WebDriver::BiDi::Protocol::#{path}"
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1106

def rbs_const(value)
  case value
  when true, false then 'bool'
  when ::String then 'String'
  when ::Numeric then 'Numeric'
  else 'untyped'
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1080

def rbs_type(node)
  resolve(node)[:rbs]
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 919

def record_class(name, type)
  const = type['fields'].find { |f| baked_discriminator?(f) }
  discriminator = const && {ruby_name: BiDiGenerate.safe_field_name(BiDiGenerate.camel_to_snake(const['name'])),
                            wire: const['wire'], value: const['type']['const'],
                            rbs: rbs_const(const['type']['const'])}
  fields = type['fields'].reject { |f| baked_discriminator?(f) }.map { |f| field_ir(f) }
  # Every extensible type gets the extensions store: an undeclared wire key is preserved
  # and echoed back on any type the spec marks extensible, whether or not it is re-sendable.
  # Extensibility alone is the signal; send-reachability does not enter into it.
  TypeClass.new(ruby_name: BiDiGenerate.type_class_name(name), fields: fields,
                discriminator: discriminator, extensible: type['extensible'] ? true : false,
                schema_name: name, synthetic: type['synthetic'] ? true : false,
                owner: type['owner'], label: type['label'], spec_href: type['specHref'],
                **directionality(name))
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1068

def record_params(fields)
  fields.map do |field|
    Param.new(
      ruby_name: BiDiGenerate.safe_field_name(BiDiGenerate.camel_to_snake(field['name'])),
      wire_name: field['wire'],
      required: field['required'],
      enum: enum_const(field['type']),
      rbs: rbs_type(field['type'])
    )
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 782

def refs_in_type(node)
  return [] unless node
  return [node['ref']] if node['ref']
  return refs_in_type(node['list']) if node['list']
  return refs_in_type(node['map']) if node['map']
  return node['union'].flat_map { |arm| refs_in_type(arm) } if node['union']
  return node['record'].flat_map { |f| refs_in_type(f['type']) } if node['record']

  []
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 809

def resolve(node)
  nullable = node['nullable'] ? true : false
  if node.key?('list')
    element = resolve(node['list'])
    return {ref: element[:ref], list: true, nullable: nullable, scalar: element[:scalar],
            rbs: nilable("Array[#{element[:rbs]}]", nullable)}
  end
  if node.key?('ref')
    named = resolve_named(node['ref'])
    return {ref: named[:ref], list: named[:list], nullable: nullable, scalar: named[:scalar],
            rbs: nilable(named[:rbs], nullable)}
  end
  return resolve_union(node, nullable) if node.key?('union')

  {ref: nil, list: false, nullable: nullable, rbs: nilable(scalar_rbs(node), nullable)}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 857

def resolve_named(name, seen = {})
  return OPAQUE if name.nil? || seen[name]

  seen[name] = true
  type = @types[name]
  return OPAQUE unless type

  case type['kind']
  when 'record' then type['fields'].empty? ? OPAQUE : named_type(name)
  when 'union' then named_union(name)
  when 'enum' then {ref: nil, list: false, rbs: 'Symbol'}
  when 'alias' then resolve_named_alias(name, type['type'], seen)
  else OPAQUE
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 896

def resolve_named_alias(name, inner, seen)
  return named_union(name) if inner.key?('union')
  return resolve_named(inner['ref'], seen) if inner.key?('ref')

  if inner.key?('list')
    element = resolve(inner['list'])
    return {ref: element[:ref], list: true, scalar: element[:scalar], rbs: "Array[#{element[:rbs]}]"}
  end

  {ref: nil, list: false, rbs: scalar_rbs(inner)}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 832

def resolve_union(node, nullable)
  refs = node['union'].select { |arm| arm.key?('ref') }
  opaque = {ref: nil, list: false, nullable: nullable, rbs: nilable('untyped', nullable)}
  return opaque unless refs.one? && union_ref?(refs.first['ref'])

  named = resolve_named(refs.first['ref'])
  {ref: named[:ref], list: named[:list], nullable: nullable, scalar: node['scalar'],
   rbs: nilable('untyped', nullable)}
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 795

def ruby_path(name)
  type = @types[name]
  return BiDiGenerate.type_ruby_path(name) unless type && type['synthetic']

  "#{ruby_path(type['owner'])}::#{type['label']}"
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 758

def ruby_path_for(name) = ruby_path(name)

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1099

def scalar_rbs(node)
  return PRIMITIVE_RBS.fetch(node['primitive']) if node.key?('primitive')
  return rbs_const(node['const']) if node.key?('const')

  'untyped'
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 751

def structured_ref(name)
  resolved = resolve_named(name)
  resolved[:list] ? nil : resolved[:ref]
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 730

def suppressed_record?(type)
  message_envelope?(type) || envelope_synthetic?(type)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 667

def type_kind(ref)
  @types[ref]&.fetch('kind', nil)
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 714

def types_for(domain)
  prefix = "#{domain}."
  @types.filter_map do |name, type|
    next unless name.start_with?(prefix)

    case type['kind']
    when 'record' then record_class(name, type) unless type['fields'].empty? || suppressed_record?(type)
    when 'union' then union_class(name)
    when 'alias' then union_class(name) if type['type'].key?('union')
    end
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 890

def union_alias_path(name)
  segments = ruby_path(name).split('::')
  segments[-1] = BiDiGenerate.camel_to_snake(segments[-1])
  rbs_abs(segments.join('::'))
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 986

def union_class(name)
  type = @types[name]
  # A first-class union carries the schema's authoritative dispatch `selector`
  # (derived spec-faithfully, including null discriminators and the spec's choice
  # order); consume it rather than re-deriving and silently depending on emit
  # order. An alias-to-union (only input.Origin) has no selector — its const-string
  # arms aren't first-class types — so it keeps the structural re-derivation.
  klass = type['kind'] == 'union' ? union_from_selector(name, type['selector']) : union_from_alias(name)
  # A non-object_only union has a bare-scalar arm; only const-literal arms (scalar_values) are
  # modeled, so the runtime can validate an outbound scalar. A non-object_only union without them
  # is a shape the generator doesn't yet handle — fail here, at generation, not at a caller's runtime.
  if !klass.object_only && !klass.scalar_values?
    raise "non-object_only union #{name} has no scalar_values to validate its bare-scalar arm"
  end

  klass
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1049

def union_from_alias(name)
  spec = @types[name]
  consts = spec['type']['union'].filter_map { |arm| arm['ref'] }.to_h do |ref|
    const = @types[ref]['fields'].find { |f| f['type'].key?('const') }
    const || raise("alias-union #{name} arm #{ref} has no const discriminator to dispatch on")
    [ref, const]
  end
  variants = consts.map do |ref, const|
    VariantIR.new(mode: :value, value: const['type']['const'], ref: ruby_path(ref), requires: nil)
  end
  # An alias-union carries bare-scalar arms (input.Origin's "viewport"/"pointer"), so it
  # is never object_only — those arms must still pass a non-Hash payload through, but only
  # a value the schema pins in scalarValues (so a stray "banana" is still rejected outbound).
  UnionClass.new(ruby_name: BiDiGenerate.type_class_name(name),
                 discriminator_wire: consts.values.first['wire'], variants: variants, schema_name: name,
                 spec_href: spec['specHref'], object_only: spec['objectOnly'] ? true : false,
                 scalar_values: spec['type']['scalarValues'], **directionality(name))
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1011

def union_from_selector(name, selector)
  # A correlated union is resolved by request id, never the payload, so it carries
  # no dispatch — it must never be emitted (every one is a top-level result
  # grouping). Fail loudly if a future schema makes one domain-scoped rather than
  # emit a Union whose every parse would raise.
  if selector['correlated']
    raise "correlated union #{name} must not be emitted (resolved by request id, not payload)"
  end

  variants = selector['by'] ? discriminated_variants(selector) : ordered_variants(selector)
  raise "union #{name} selector yielded no dispatch variants" if variants.empty?

  UnionClass.new(ruby_name: BiDiGenerate.type_class_name(name),
                 discriminator_wire: selector['by'], variants: variants, schema_name: name,
                 spec_href: @types[name]['specHref'], object_only: @types[name]['objectOnly'] ? true : false,
                 **directionality(name))
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 1134

def union_params(type, ref = nil)
  variants = type['variants'].map { |variant_ref| @types[variant_ref] }
  return nil unless variants.all? { |v| v && v['kind'] == 'record' }

  selector = type['selector']
  guard_union_dispatch_keys_simple!(selector, ref)
  params = merged_params(variants.map { |v| v['fields'] })
  annotate_discriminator_enum!(params, selector)
  params
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 844

def union_ref?(name)
  type = @types[name]
  return false unless type
  return union_ref?(type['type']['ref']) if type['kind'] == 'alias' && type['type'].key?('ref')

  type['kind'] == 'union'
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 619

def vendor_modules_for(domain)
  parent = BiDiGenerate.snake_to_class_name(BiDiGenerate.camel_to_snake(domain))
  groups = Hash.new { |h, k| h[k] = [] }
  @vendor.each do |namespace, spec|
    (spec['extends'] || {}).each do |type_name, entry|
      cmd = @commands.find { |c| c.dig('params', 'ref') == type_name }
      next unless cmd && cmd['domain'] == domain

      groups[namespace] << build_vendor_command(cmd, type_name, entry, namespace)
    end
  end
  groups.map do |namespace, commands|
    VendorModule.new(name: BiDiGenerate.snake_to_class_name(namespace), namespace: namespace, parent: parent,
                     commands: commands)
  end
end

# File 'rb/lib/selenium/webdriver/bidi/support/bidi_generate.rb', line 654

def vendor_param(field, namespace, taken)
  stripped = field['name'].sub(/\A#{Regexp.escape(namespace)}:/, '')
  ruby_name = BiDiGenerate.safe_field_name(BiDiGenerate.camel_to_snake(stripped))
  ruby_name = BiDiGenerate.safe_field_name(BiDiGenerate.camel_to_snake(field['name'])) if taken.include?(ruby_name)
  Param.new(
    ruby_name: ruby_name,
    wire_name: field['wire'],
    required: field['required'],
    enum: enum_const(field['type']),
    rbs: rbs_type(field['type'])
  )
end