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 person.age person.address
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")
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)"]
measurements.send("length (in inches)")
message = OpenStruct.new(:queued? => true)
message.queued?
message.send("queued?=", false)
message.queued?
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 first_pet == second_pet first_pet.delete_field(:owner) first_pet first_pet == second_pet
Ractor compatibility: A frozen OpenStruct with shareable values is itself shareable.
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
Builtin methods may be overwritten this way, which may be a source of bugs or security issues:
o = OpenStruct.new o.methods o.methods = [:foo, :bar] o.methods
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 o.class!
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.
json_create(object) click to toggle source
Deserializes JSON string by constructing new Struct object with values t serialized by to_json.
def self.json_create(object) new(object['t'] || object[:t]) end
new(hash=nil) click to toggle source
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
def initialize(hash=nil)
if hash
update_to_values!(hash)
else
@table = {}
end
end Public Instance Methods
==(other) click to toggle source
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
first_pet == third_pet
def ==(other) return false unless other.kind_of?(OpenStruct) @table == other.table! end
ostruct[name] → object click to toggle source
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]
def [](name) @table[name.to_sym] end
ostruct[name] = obj → obj click to toggle source
Sets the value of an attribute.
require "ostruct"
person = OpenStruct.new("name" => "John Smith", "age" => 70)
person[:age] = 42
person.age
def []=(name, value) name = name.to_sym new_ostruct_member!(name) @table[name] = value end
as_json(*) click to toggle source
Returns a hash, that will be turned into a JSON object and represent this object.
def as_json(*)
klass = self.class.name
klass.to_s.empty? and raise JSON::JSONError, "Only named structs are supported!"
{
JSON.create_id => klass,
't' => table,
}
end
delete_field(name) click to toggle source
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")
person
Setting the value to nil will not remove the attribute:
person.pension = nil person
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
dig(name, *identifiers) → object click to toggle source
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")
person.dig(:business_address, "zip")
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 {|name, value| block } → ostruct click to toggle source
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
def each_pair
return to_enum(__method__) { @table.size } unless block_given?
@table.each_pair{|p| yield p}
self
end
eql?(other) click to toggle source
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?.
def eql?(other) return false unless other.kind_of?(OpenStruct) @table.eql?(other.table!) end
freeze() click to toggle source
def freeze @table.freeze super end
inspect() click to toggle source
Returns a string containing a detailed summary of the keys and values.
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
to_h → hash click to toggle source
to_h {|name, value| block } → hash
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
data.to_h {|name, value| [name.to_s, value.upcase] }
def to_h(&block)
if block
@table.to_h(&block)
else
@table.dup
end
end
to_json(*args) click to toggle source
Stores class name (OpenStruct) with this struct's values t as a JSON string.
def to_json(*args) as_json.to_json(*args) endPrivate Instance Methods
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4