Class: Pdfrb::Model::Cos::Dictionary

# File 'lib/pdfrb/model/cos/dictionary.rb', line 204

def initialize(value = {}, oid: 0, gen: 0, document: nil)
  value ||= {}
  unless value.is_a?(::Hash)
    raise ArgumentError, "Dictionary value must be a Hash, got #{value.class}"
  end

  super(value, oid: oid, gen: gen, document: document)
  apply_required_defaults
end

Class Method Details

.apply_arlington_definition(definition) ⇒ `Object`

Merge the TSV's field definitions into the class's field set (ArlingtonBacked#arlington_object hook).

# File 'lib/pdfrb/model/cos/dictionary.rb', line 78

def apply_arlington_definition(definition)
  definition.each_field do |field_def|
    define_field_from_arlington(field_def)
  end
end

.arlington_default(field_def) ⇒ `Object`

# File 'lib/pdfrb/model/cos/dictionary.rb', line 168

def arlington_default(field_def)
  raw = field_def.default_value
  return nil if raw.nil?
  return raw unless raw.is_a?(::String)

  if raw.start_with?("[") && raw.end_with?("]")
    return raw[1..-2].split.then { |tokens| tokens.map { |t| arlington_scalar(t) } }
  end

  scalar = arlington_scalar(raw)
  return scalar.to_sym if scalar.is_a?(::String) && field_def.types_raw.include?("name")

  scalar
end

.arlington_key_to_symbol(key) ⇒ `Object`



158
159
160

# File 'lib/pdfrb/model/cos/dictionary.rb', line 158

def arlington_key_to_symbol(key)
  key.to_sym
end

.arlington_one_type_to_ruby(t) ⇒ `Object`

# File 'lib/pdfrb/model/cos/dictionary.rb', line 137

def arlington_one_type_to_ruby(t)
  case t
  when :boolean then [TrueClass, FalseClass]
  when :integer then Integer
  when :number then [Integer, Float]
  when :name then Symbol
  when :string, :"string-ascii", :"string-text" then String
  when :"string-byte" then Fields::PDFByteString
  when :array then Pdfrb::Model::PdfArray
  when :dictionary then Pdfrb::Model::Cos::Dictionary
  when :stream then Pdfrb::Model::Cos::Stream
  when :null then NilClass
  when :date then Fields::PDFDate
  when :rectangle then Pdfrb::Model::Rectangle
  when :matrix then Pdfrb::Model::Matrix
  when :bitmask then Integer
  when :"name-tree", :"number-tree" then Pdfrb::Model::Cos::Dictionary
  end
end

.arlington_required?(field_def) ⇒ `Boolean`



163
164
165

# File 'lib/pdfrb/model/cos/dictionary.rb', line 163

def arlington_required?(field_def)
  field_def.required_literal == true
end

.arlington_scalar(token) ⇒ `Object`

TSV default cells are raw strings; convert per scalar shape so typed access returns Integer/Symbol/etc.

# File 'lib/pdfrb/model/cos/dictionary.rb', line 186

def arlington_scalar(token)
  case token
  when "true" then true
  when "false" then false
  when "null" then nil
  when /\A-?\d+\z/ then Integer(token, 10)
  when /\A-?\d+\.\d+\z/ then Float(token)
  else token
  end
end

.arlington_types_to_ruby(field_def) ⇒ `Object`



132
133
134

# File 'lib/pdfrb/model/cos/dictionary.rb', line 132

def arlington_types_to_ruby(field_def)
  field_def.types.map { |t| arlington_one_type_to_ruby(t) }.flatten.compact.uniq
end

.arlington_version(field_def) ⇒ `Object`



198
199
200

# File 'lib/pdfrb/model/cos/dictionary.rb', line 198

def arlington_version(field_def)
  field_def.since_version.to_s
end

.define_field(pdf_name, type:, required: false, default: nil, indirect: nil, allowed_values: nil, version: "1.0", arlington: nil) ⇒ `Object`

Declare a field on this class. Mirrors HexaPDF's define_field shape; we add an arlington: slot for the source FieldDefinition.

# File 'lib/pdfrb/model/cos/dictionary.rb', line 46

def define_field(pdf_name, type:, required: false, default: nil,
                 indirect: nil, allowed_values: nil, version: "1.0",
                 arlington: nil)
  own_fields[pdf_name] = Fields::Field.new(
    pdf_name, type: type, required: required, default: default,
    indirect: indirect, allowed_values: allowed_values,
    version: version, arlington: arlington
  )
end

.define_field_from_arlington(field_def) ⇒ `Object`

Merge Arlington field metadata with any hand-coded define_field declaration. Hand-coded fields win: if the class already declares this key explicitly (with a type), we rebuild the Field preserving the hand-coded type/default/required and only attach the Arlington def for reference.

# File 'lib/pdfrb/model/cos/dictionary.rb', line 96

def define_field_from_arlington(field_def)
  types = arlington_types_to_ruby(field_def)
  return if types.empty?

  key = arlington_key_to_symbol(field_def.key)
  existing = own_fields[key]
  if existing
    own_fields[key] = merged_field(existing, field_def)
    return
  end

  define_field(
    key,
    type: types.length == 1 ? types.first : types,
    required: arlington_required?(field_def),
    default: arlington_default(field_def),
    version: arlington_version(field_def),
    arlington: field_def
  )
end

.each_field ⇒ `Object`

Iterate (name, Field) pairs across the inheritance chain. A subclass field with the same name shadows (replaces) the inherited one entirely.

# File 'lib/pdfrb/model/cos/dictionary.rb', line 67

def each_field
  return enum_for(:each_field) unless block_given?

  if superclass <= Pdfrb::Model::Cos::Dictionary
    superclass.each_field { |n, f| yield n, f unless own_fields.key?(n) }
  end
  own_fields.each { |n, f| yield n, f }
end

.field(name) ⇒ `Object`

Look up a field by name; walks the inheritance chain.

# File 'lib/pdfrb/model/cos/dictionary.rb', line 57

def field(name)
  return own_fields[name] if own_fields.key?(name)
  return superclass.field(name) if superclass <= Pdfrb::Model::Cos::Dictionary

  nil
end

.lookup_type(symbol) ⇒ `Object`



39
40
41

# File 'lib/pdfrb/model/cos/dictionary.rb', line 39

def lookup_type(symbol)
  TYPE_MAP[symbol]
end

.merged_field(existing, field_def) ⇒ `Object`

# File 'lib/pdfrb/model/cos/dictionary.rb', line 118

def merged_field(existing, field_def)
  Fields::Field.new(
    existing.pdf_name,
    type: existing.type,
    required: existing.required,
    default: existing.default,
    indirect: existing.indirect,
    allowed_values: existing.allowed_values,
    version: arlington_version(field_def),
    arlington: field_def
  )
end

.own_fields ⇒ `Object`



85
86
87

# File 'lib/pdfrb/model/cos/dictionary.rb', line 85

def own_fields
  @own_fields ||= {}
end

.register_type(symbol, klass = self) ⇒ `Object`

# File 'lib/pdfrb/model/cos/dictionary.rb', line 34

def register_type(symbol, klass = self)
  TYPE_MAP[symbol] = klass
  klass.define_type(symbol) unless klass.pdf_type
end

.type_map ⇒ `Object`

/Type-symbol -> Dictionary subclass. Populated by register_type. Used by Document#wrap to dispatch.



30
31
32

# File 'lib/pdfrb/model/cos/dictionary.rb', line 30

def type_map
  TYPE_MAP
end

Instance Method Details

#[](name) ⇒ `Object`

Typed access. Resolves References, wraps in field-specific subclass, applies default, runs converters.

# File 'lib/pdfrb/model/cos/dictionary.rb', line 216

def [](name)
  name = name.to_sym unless name.is_a?(::Symbol)
  field = self.class.field(name)
  data = @value[name]
  data = field.default if data.nil? && field&.default?
  return nil if data.nil?

  data = dereference(data)
  data = data.value if unbox_object?(data)

  return data unless field

  converted = Fields.apply(field, data, document)
  if converted
    @value[name] = converted
    converted
  else
    data
  end
end

#[]=(name, value) ⇒ `Object`

Raises:

(ArgumentError)

# File 'lib/pdfrb/model/cos/dictionary.rb', line 237

def []=(name, value)
  raise ArgumentError, "Dictionary keys must be Symbols" unless name.is_a?(::Symbol)

  @value[name] = value
end

#delete(name) ⇒ `Object`

# File 'lib/pdfrb/model/cos/dictionary.rb', line 248

def delete(name)
  name = name.to_sym unless name.is_a?(::Symbol)
  @value.delete(name)
end

#each ⇒ `Object`

Iterate (Symbol, processed-value) pairs. Slower than #each_raw because it runs the full accessor pipeline; use that when you don't need wrapping.

# File 'lib/pdfrb/model/cos/dictionary.rb', line 256

def each
  return enum_for(:each) unless block_given?

  @value.each_key { |k| yield(k, self[k]) }
  self
end

#each_raw ⇒ `Object`

Iterate (Symbol, raw-value) pairs without accessor pipeline.

# File 'lib/pdfrb/model/cos/dictionary.rb', line 264

def each_raw
  return enum_for(:each_raw) unless block_given?

  @value.each { |k, v| yield(k, v) }
  self
end

#empty? ⇒ `Boolean`

272	# File 'lib/pdfrb/model/cos/dictionary.rb', line 272 def empty?; @value.empty?; end

#key?(name) ⇒ `Boolean`

# File 'lib/pdfrb/model/cos/dictionary.rb', line 243

def key?(name)
  name = name.to_sym unless name.is_a?(::Symbol)
  !@value[name].nil?
end

#keys ⇒ `Object`

271	# File 'lib/pdfrb/model/cos/dictionary.rb', line 271 def keys; @value.keys; end

#pdf_type ⇒ `Object`



274
275
276

# File 'lib/pdfrb/model/cos/dictionary.rb', line 274

def pdf_type
  self.class.pdf_type || self[:Type]
end

#validate ⇒ `Object`

Walk every declared field and yield (message, correctable) for each violation. Returns an Enumerator if no block given.

# File 'lib/pdfrb/model/cos/dictionary.rb', line 280

def validate
  return enum_for(:validate) unless block_given?

  self.class.each_field do |name, field|
    validate_one(name, field) { |*a| yield(*a) }
  end
end

Class: Pdfrb::Model::Cos::Dictionary

Overview

Direct Known Subclasses

Instance Attribute Summary

Attributes inherited from Object

Class Method Summary collapse

Instance Method Summary collapse

Methods included from ArlingtonBacked

Methods inherited from Object

Constructor Details

#initialize(value = {}, oid: 0, gen: 0, document: nil) ⇒ Dictionary

Class Method Details

.apply_arlington_definition(definition) ⇒ Object

.arlington_default(field_def) ⇒ Object

.arlington_key_to_symbol(key) ⇒ Object

.arlington_one_type_to_ruby(t) ⇒ Object

.arlington_required?(field_def) ⇒ Boolean

.arlington_scalar(token) ⇒ Object

.arlington_types_to_ruby(field_def) ⇒ Object

.arlington_version(field_def) ⇒ Object

.define_field(pdf_name, type:, required: false, default: nil, indirect: nil, allowed_values: nil, version: "1.0", arlington: nil) ⇒ Object

.define_field_from_arlington(field_def) ⇒ Object

.each_field ⇒ Object

.field(name) ⇒ Object

.lookup_type(symbol) ⇒ Object

.merged_field(existing, field_def) ⇒ Object

.own_fields ⇒ Object

.register_type(symbol, klass = self) ⇒ Object

.type_map ⇒ Object