Object
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.
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.
measurements = OpenStruct.new("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
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.
frozen_string_literal: true
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">
# File ostruct.rb, line 93 def initialize(hash=nil) @table = {} if hash hash.each_pair do |k, v| k = k.to_sym @table[k] = v end end end
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
# File ostruct.rb, line 355 def ==(other) return false unless other.kind_of?(OpenStruct) @table == other.table! end
Returns the value of an attribute.
require "ostruct" person = OpenStruct.new("name" => "John Smith", "age" => 70) person[:age] # => 70, same as person.age
# File ostruct.rb, line 240 def [](name) @table[name.to_sym] end
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
# File ostruct.rb, line 255 def []=(name, value) modifiable?[new_ostruct_member!(name)] = value end
Removes the named field from the object. Returns the value that the field contained if it was defined.
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>
# File ostruct.rb, line 304 def delete_field(name) sym = name.to_sym begin singleton_class.remove_method(sym, "#{sym}=") rescue NameError end @table.delete(sym) do raise NameError.new("no field `#{sym}' in #{self}", sym) end end
Extracts the nested value specified by the sequence of name
objects by calling dig
at each step, returning
nil
if any intermediate step is nil
.
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 data = OpenStruct.new(:array => [1, [2, 3]]) data.dig(:array, 1, 0) # => 2 data.dig(:array, 0, 0) # TypeError: Integer does not have #dig method
# File ostruct.rb, line 279 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
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"]]
# File ostruct.rb, line 146 def each_pair return to_enum(__method__) { @table.size } unless block_given? @table.each_pair{|p| yield p} self end
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?.
# File ostruct.rb, line 365 def eql?(other) return false unless other.kind_of?(OpenStruct) @table.eql?(other.table!) end
# File ostruct.rb, line 196 def freeze @table.each_key {|key| new_ostruct_member!(key)} super end
Computes a hash code for this OpenStruct. Two OpenStruct objects with the same content will have the same hash code (and will compare using eql?).
See also Object#hash.
# File ostruct.rb, line 375 def hash @table.hash end
Returns a string containing a detailed summary of the keys and values.
# File ostruct.rb, line 320 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
Provides marshalling support for use by the Marshal library.
# File ostruct.rb, line 155 def marshal_dump @table end
Provides marshalling support for use by the Marshal library.
# File ostruct.rb, line 162 def marshal_load(x) @table = x end
Converts the OpenStruct to a hash with keys representing each attribute (as symbols) and their corresponding values.
If a block is given, the results of the block on each pair of the receiver will be used as pairs.
require "ostruct" data = OpenStruct.new("country" => "Australia", :capital => "Canberra") data.to_h # => {:country => "Australia", :capital => "Canberra" } data.to_h {|name, value| [name.to_s, value.upcase] } # => {"country" => "AUSTRALIA", "capital" => "CANBERRA" }
# File ostruct.rb, line 126 def to_h(&block) if block_given? @table.to_h(&block) else @table.dup end end