Class: OpenStruct

Inherits:
Object show all
Defined in:
lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/ostruct-0.5.5/lib/ostruct.rb

Overview

An OpenStruct is a data structure, similar to a Hash, that allows the definition of arbitrary attributes with their accompanying values. This is accomplished by using Ruby’s metaprogramming to define methods on the class itself.

Examples

require "ostruct"

person = OpenStruct.new
person.name = "John Smith"
person.age  = 70

person.name      # => "John Smith"
person.age       # => 70
person.address   # => nil

An OpenStruct employs a Hash internally to store the attributes and values and can even be initialized with one:

australia = OpenStruct.new(:country => "Australia", :capital => "Canberra")
  # => #<OpenStruct country="Australia", capital="Canberra">

Hash keys with spaces or characters that could normally not be used for method calls (e.g. ()[]*) will not be immediately available on the OpenStruct object as a method for retrieval or assignment, but can still be reached through the Object#send method or using [].

measurements = OpenStruct.new("length (in inches)" => 24)
measurements[:"length (in inches)"]       # => 24
measurements.send("length (in inches)")   # => 24

message = OpenStruct.new(:queued? => true)
message.queued?                           # => true
message.send("queued?=", false)
message.queued?                           # => false

Removing the presence of an attribute requires the execution of the delete_field method as setting the property value to nil will not remove the attribute.

first_pet  = OpenStruct.new(:name => "Rowdy", :owner => "John Smith")
second_pet = OpenStruct.new(:name => "Rowdy")

first_pet.owner = nil
first_pet                 # => #<OpenStruct name="Rowdy", owner=nil>
first_pet == second_pet   # => false

first_pet.delete_field(:owner)
first_pet                 # => #<OpenStruct name="Rowdy">
first_pet == second_pet   # => true

Ractor compatibility: A frozen OpenStruct with shareable values is itself shareable.

Caveats

An OpenStruct utilizes Ruby’s method lookup structure to find and define the necessary methods for properties. This is accomplished through the methods method_missing and define_singleton_method.

This should be a consideration if there is a concern about the performance of the objects that are created, as there is much more overhead in the setting of these properties compared to using a Hash or a Struct. Creating an open struct from a small Hash and accessing a few of the entries can be 200 times slower than accessing the hash directly.

This is a potential security issue; building OpenStruct from untrusted user data (e.g. JSON web request) may be susceptible to a “symbol denial of service” attack since the keys create methods and names of methods are never garbage collected.

This may also be the source of incompatibilities between Ruby versions:

o = OpenStruct.new
o.then # => nil in Ruby < 2.6, enumerator for Ruby >= 2.6

Builtin methods may be overwritten this way, which may be a source of bugs or security issues:

o = OpenStruct.new
o.methods # => [:to_h, :marshal_load, :marshal_dump, :each_pair, ...
o.methods = [:foo, :bar]
o.methods # => [:foo, :bar]

To help remedy clashes, OpenStruct uses only protected/private methods ending with ! and defines aliases for builtin public methods by adding a !:

o = OpenStruct.new(make: 'Bentley', class: :luxury)
o.class # => :luxury
o.class! # => OpenStruct

It is recommended (but not enforced) to not use fields ending in !; Note that a subclass’ methods may not be overwritten, nor can OpenStruct’s own methods ending with !.

For all these reasons, consider not using OpenStruct at all.

Direct Known Subclasses

WalShipper::Destination

Constant Summary collapse

VERSION = 
"0.5.5"
InspectKey =

:nodoc:

:__inspect_key__

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(hash = nil) ⇒ OpenStruct

Creates a new OpenStruct object. By default, the resulting OpenStruct object will have no attributes.

The optional hash, if given, will generate attributes and values (can be a Hash, an OpenStruct or a Struct). For example:

require "ostruct"
hash = { "country" => "Australia", :capital => "Canberra" }
data = OpenStruct.new(hash)

data   # => #<OpenStruct country="Australia", capital="Canberra">



126
127
128
129
130
131
132
 
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/ostruct-0.5.5/lib/ostruct.rb', line 126

def initialize(hash=nil)
  if hash
    update_to_values!(hash)
  else
    @table = {}
  end
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(mid, *args) ⇒ Object (private)

:nodoc:



262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
 
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/ostruct-0.5.5/lib/ostruct.rb', line 262

private def method_missing(mid, *args) # :nodoc:
  len = args.length
  if mname = mid[/.*(?==\z)/m]
    if len != 1
      raise! ArgumentError, "wrong number of arguments (given #{len}, expected 1)", caller(1)
    end
    set_ostruct_member_value!(mname, args[0])
  elsif len == 0
    @table[mid]
  else
    begin
      super
    rescue NoMethodError => err
      err.backtrace.shift
      raise!
    end
  end
end

Instance Attribute Details

#table ⇒ Object (readonly) Also known as: table!

:nodoc:



394
395
396
 
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/ostruct-0.5.5/lib/ostruct.rb', line 394

def table
  @table
end

Instance Method Details

#==(other) ⇒ Object

Compares this object and other for equality. An OpenStruct is equal to other when other is an OpenStruct and the two objects’ Hash tables are equal.

require "ostruct"
first_pet  = OpenStruct.new("name" => "Rowdy")
second_pet = OpenStruct.new(:name  => "Rowdy")
third_pet  = OpenStruct.new("name" => "Rowdy", :age => nil)

first_pet == second_pet   # => true
first_pet == third_pet    # => false



411
412
413
414
 
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/ostruct-0.5.5/lib/ostruct.rb', line 411

def ==(other)
  return false unless other.kind_of?(OpenStruct)
  @table == other.table!
end

#[](name) ⇒ Object

:call-seq:

ostruct[name]  -> object

Returns the value of an attribute, or nil if there is no such attribute.

require "ostruct"
person = OpenStruct.new("name" => "John Smith", "age" => 70)
person[:age]   # => 70, same as person.age



291
292
293
 
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/ostruct-0.5.5/lib/ostruct.rb', line 291

def [](name)
  @table[name.to_sym]
end

#[]=(name, value) ⇒ Object Also known as: set_ostruct_member_value!

:call-seq:

ostruct[name] = obj  -> obj

Sets the value of an attribute.

require "ostruct"
person = OpenStruct.new("name" => "John Smith", "age" => 70)
person[:age] = 42   # equivalent to person.age = 42
person.age          # => 42



306
307
308
309
310
 
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/ostruct-0.5.5/lib/ostruct.rb', line 306

def []=(name, value)
  name = name.to_sym
  new_ostruct_member!(name)
  @table[name] = value
end

#delete_field(name, &block) ⇒ Object

Removes the named field from the object and returns the value the field contained if it was defined. You may optionally provide a block. If the field is not defined, the result of the block is returned, or a NameError is raised if no block was given.

require "ostruct"

person = OpenStruct.new(name: "John", age: 70, pension: 300)

person.delete_field!("age")  # => 70
person                       # => #<OpenStruct name="John", pension=300>

Setting the value to nil will not remove the attribute:

person.pension = nil
person                 # => #<OpenStruct name="John", pension=nil>

person.delete_field('number')  # => NameError

person.delete_field('number') { 8675_309 } # => 8675309



359
360
361
362
363
364
365
366
367
368
369
 
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/ostruct-0.5.5/lib/ostruct.rb', line 359

def delete_field(name, &block)
  sym = name.to_sym
  begin
    singleton_class.remove_method(sym, "#{sym}=")
  rescue NameError
  end
  @table.delete(sym) do
    return yield if block
    raise! NameError.new("no field `#{sym}' in #{self}", sym)
  end
end

#dig(name, *names) ⇒ Object

:call-seq:

ostruct.dig(name, *identifiers) -> object

Finds and returns the object in nested objects that is specified by name and identifiers. The nested objects may be instances of various classes. See Dig Methods.

Examples:

require "ostruct"
address = OpenStruct.new("city" => "Anytown NC", "zip" => 12345)
person  = OpenStruct.new("name" => "John Smith", "address" => address)
person.dig(:address, "zip") # => 12345
person.dig(:business_address, "zip") # => nil



328
329
330
331
332
333
334
335
 
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/ostruct-0.5.5/lib/ostruct.rb', line 328

def dig(name, *names)
  begin
    name = name.to_sym
  rescue NoMethodError
    raise! TypeError, "#{name} is not a symbol nor a string"
  end
  @table.dig(name, *names)
end

#each_pair ⇒ Object

:call-seq:

ostruct.each_pair {|name, value| block }  -> ostruct
ostruct.each_pair                         -> Enumerator

Yields all attributes (as symbols) along with the corresponding values or returns an enumerator if no block is given.

require "ostruct"
data = OpenStruct.new("country" => "Australia", :capital => "Canberra")
data.each_pair.to_a   # => [[:country, "Australia"], [:capital, "Canberra"]]



199
200
201
202
203
 
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/ostruct-0.5.5/lib/ostruct.rb', line 199

def each_pair
  return to_enum(__method__) { @table.size } unless defined?(yield)
  @table.each_pair{|p| yield p}
  self
end

#encode_with(coder) ⇒ Object

Provides marshalling support for use by the YAML library.



434
435
436
437
438
439
440
441
442
 
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/ostruct-0.5.5/lib/ostruct.rb', line 434

def encode_with(coder) # :nodoc:
  @table.each_pair do |key, value|
    coder[key.to_s] = value
  end
  if @table.size == 1 && @table.key?(:table) # support for legacy format
    # in the very unlikely case of a single entry called 'table'
    coder['legacy_support!'] = true # add a bogus second entry
  end
end

#eql?(other) ⇒ Boolean

Compares this object and other for equality. An OpenStruct is eql? to other when other is an OpenStruct and the two objects’ Hash tables are eql?.

Returns:

  • (Boolean) 


421
422
423
424
 
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/ostruct-0.5.5/lib/ostruct.rb', line 421

def eql?(other)
  return false unless other.kind_of?(OpenStruct)
  @table.eql?(other.table!)
end

#freeze ⇒ Object 



257
258
259
260
 
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/ostruct-0.5.5/lib/ostruct.rb', line 257

def freeze
  @table.freeze
  super
end

#hash ⇒ Object

Computes a hash code for this OpenStruct.



427
428
429
 
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/ostruct-0.5.5/lib/ostruct.rb', line 427

def hash # :nodoc:
  @table.hash
end

#init_with(coder) ⇒ Object

Provides marshalling support for use by the YAML library.



447
448
449
450
451
452
453
454
455
456
 
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/ostruct-0.5.5/lib/ostruct.rb', line 447

def init_with(coder) # :nodoc:
  h = coder.map
  if h.size == 1 # support for legacy format
    key, val = h.first
    if key == 'table'
      h = val
    end
  end
  update_to_values!(h)
end

#inspect ⇒ Object Also known as: to_s

Returns a string containing a detailed summary of the keys and values.



376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
 
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/ostruct-0.5.5/lib/ostruct.rb', line 376

def inspect
  ids = (Thread.current[InspectKey] ||= [])
  if ids.include?(object_id)
    detail = ' ...'
  else
    ids << object_id
    begin
      detail = @table.map do |key, value|
        " #{key}=#{value.inspect}"
      end.join(',')
    ensure
      ids.pop
    end
  end
  ['#<', self.class!, detail, '>'].join
end

#marshal_dump ⇒ Object

Provides marshalling support for use by the Marshal library.



208
209
210
 
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/ostruct-0.5.5/lib/ostruct.rb', line 208

def marshal_dump # :nodoc:
  @table
end

#to_h(&block) ⇒ Object 



170
171
172
173
174
175
176
 
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/ostruct-0.5.5/lib/ostruct.rb', line 170

def to_h(&block)
  if block
    @table.to_h(&block)
  else
    @table.dup
  end
end