Class: OpenStruct
- Inherits:
-
Object
- Object
- OpenStruct
- Defined in:
- 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.
measurements = OpenStruct.new("length (in inches)" => 24)
measurements.send("length (in inches)") # => 24
= OpenStruct.new(:queued? => true)
.queued? # => true
.send("queued?=", false)
.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
Implementation
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.
Constant Summary collapse
- InspectKey =
:nodoc:
:__inspect_key__
Instance Method Summary collapse
-
#==(other) ⇒ Object
Compares this object and
other
for equality. -
#[](name) ⇒ Object
:call-seq: ostruct -> object.
-
#[]=(name, value) ⇒ Object
:call-seq: ostruct = obj -> obj.
-
#delete_field(name) ⇒ Object
Removes the named field from the object.
-
#dig(name, *names) ⇒ Object
:call-seq: ostruct.dig(name, …) -> object.
-
#each_pair ⇒ Object
:call-seq: ostruct.each_pair {|name, value| block } -> ostruct ostruct.each_pair -> Enumerator.
-
#eql?(other) ⇒ Boolean
Compares this object and
other
for equality. - #freeze ⇒ Object
-
#hash ⇒ Object
Computes a hash code for this OpenStruct.
-
#initialize(hash = nil) ⇒ OpenStruct
constructor
Creates a new OpenStruct object.
-
#initialize_copy(orig) ⇒ Object
Duplicates an OpenStruct object’s Hash table.
-
#inspect ⇒ Object
(also: #to_s)
Returns a string containing a detailed summary of the keys and values.
-
#marshal_dump ⇒ Object
Provides marshalling support for use by the Marshal library.
-
#marshal_load(x) ⇒ Object
Provides marshalling support for use by the Marshal library.
-
#method_missing(mid, *args) ⇒ Object
:nodoc:.
-
#respond_to_missing?(mid, include_private = false) ⇒ Boolean
:nodoc:.
-
#to_h ⇒ Object
Converts the OpenStruct to a hash with keys representing each attribute (as symbols) and their corresponding values.
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">
91 92 93 94 95 96 97 98 99 |
# File 'lib/ostruct.rb', line 91 def initialize(hash=nil) @table = {} if hash hash.each_pair do |k, v| k = k.to_sym @table[k] = v end end end |
Dynamic Method Handling
This class handles dynamic methods through the method_missing method
#method_missing(mid, *args) ⇒ Object
:nodoc:
199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 |
# File 'lib/ostruct.rb', line 199 def method_missing(mid, *args) # :nodoc: len = args.length if mname = mid[/.*(?==\z)/m] if len != 1 raise ArgumentError, "wrong number of arguments (#{len} for 1)", caller(1) end modifiable?[new_ostruct_member!(mname)] = args[0] elsif len == 0 # and /\A[a-z_]\w*\z/ =~ mid # if @table.key?(mid) new_ostruct_member!(mid) unless frozen? @table[mid] end else begin super rescue NoMethodError => err err.backtrace.shift raise end end 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
346 347 348 349 |
# File 'lib/ostruct.rb', line 346 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.
require "ostruct"
person = OpenStruct.new("name" => "John Smith", "age" => 70)
person[:age] # => 70, same as person.age
231 232 233 |
# File 'lib/ostruct.rb', line 231 def [](name) @table[name.to_sym] end |
#[]=(name, value) ⇒ Object
: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
246 247 248 |
# File 'lib/ostruct.rb', line 246 def []=(name, value) modifiable?[new_ostruct_member!(name)] = value end |
#delete_field(name) ⇒ Object
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>
295 296 297 298 299 300 301 302 303 304 |
# File 'lib/ostruct.rb', line 295 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, *names) ⇒ Object
:call-seq:
ostruct.dig(name, ...) -> object
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
270 271 272 273 274 275 276 277 |
# File 'lib/ostruct.rb', line 270 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"]]
131 132 133 134 135 |
# File 'lib/ostruct.rb', line 131 def each_pair return to_enum(__method__) { @table.size } unless block_given? @table.each_pair{|p| yield p} self 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?.
356 357 358 359 |
# File 'lib/ostruct.rb', line 356 def eql?(other) return false unless other.kind_of?(OpenStruct) @table.eql?(other.table!) end |
#freeze ⇒ Object
189 190 191 192 |
# File 'lib/ostruct.rb', line 189 def freeze @table.each_key {|key| new_ostruct_member!(key)} super end |
#hash ⇒ Object
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.
366 367 368 |
# File 'lib/ostruct.rb', line 366 def hash @table.hash end |
#initialize_copy(orig) ⇒ Object
Duplicates an OpenStruct object’s Hash table.
102 103 104 105 |
# File 'lib/ostruct.rb', line 102 def initialize_copy(orig) # :nodoc: super @table = @table.dup end |
#inspect ⇒ Object Also known as: to_s
Returns a string containing a detailed summary of the keys and values.
311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 |
# File 'lib/ostruct.rb', line 311 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.
140 141 142 |
# File 'lib/ostruct.rb', line 140 def marshal_dump @table end |
#marshal_load(x) ⇒ Object
Provides marshalling support for use by the Marshal library.
147 148 149 |
# File 'lib/ostruct.rb', line 147 def marshal_load(x) @table = x end |
#respond_to_missing?(mid, include_private = false) ⇒ Boolean
:nodoc:
194 195 196 197 |
# File 'lib/ostruct.rb', line 194 def respond_to_missing?(mid, include_private = false) # :nodoc: mname = mid.to_s.chomp("=").to_sym @table&.key?(mname) || super end |
#to_h ⇒ Object
Converts the OpenStruct to a hash with keys representing each attribute (as symbols) and their corresponding values.
require "ostruct"
data = OpenStruct.new("country" => "Australia", :capital => "Canberra")
data.to_h # => {:country => "Australia", :capital => "Canberra" }
115 116 117 |
# File 'lib/ostruct.rb', line 115 def to_h @table.dup end |