Class: OpenStruct

Inherits:
Object
  • Object
show all
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.pension = 300

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

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

australia = OpenStruct.new(:country => "Australia", :population => 20_000_000)
p australia   # -> <OpenStruct country="Australia" population=20000000>

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

measurements = OpenStruct.new("length (in inches)" => 24)
measurements.send("length (in inches)")  # -> 24

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

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

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

first_pet == second_pet   # -> false

first_pet.delete_field(:owner)
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 method method_missing and define_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

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", :population => 20_000_000 }
data = OpenStruct.new(hash)

p data        # -> <OpenStruct country="Australia" population=20000000>


93
94
95
96
97
98
99
100
101
# File 'lib/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

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(mid, *args) ⇒ Object

:nodoc:



189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
# File 'lib/ostruct.rb', line 189

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
    if @table.key?(mid)
      new_ostruct_member(mid)
      @table[mid]
    end
  else
    err = NoMethodError.new "undefined method `#{mid}' for #{self}", mid, args
    err.set_backtrace caller(1)
    raise err
  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.



303
304
305
306
# File 'lib/ostruct.rb', line 303

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

#[](name) ⇒ Object

Returns the value of a member.

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


213
214
215
# File 'lib/ostruct.rb', line 213

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

#[]=(name, value) ⇒ Object

Sets the value of a member.

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


224
225
226
# File 'lib/ostruct.rb', line 224

def []=(name, value)
  modifiable[new_ostruct_member(name)] = value
end

#delete_field(name) ⇒ Object

Remove the named field from the object. Returns the value that the field contained if it was defined.

require 'ostruct'

person = OpenStruct.new('name' => 'John Smith', 'age' => 70)

person.delete_field('name')  # => 'John Smith'


256
257
258
259
260
261
262
263
264
265
# File 'lib/ostruct.rb', line 256

def delete_field(name)
  sym = name.to_sym
  begin
    singleton_class.__send__(: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

Retrieves the value object corresponding to the each name objects repeatedly.

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


237
238
239
240
241
242
243
244
# File 'lib/ostruct.rb', line 237

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_pairObject

Yields all attributes (as a symbol) along with the corresponding values or returns an enumerator if not block is given. Example:

require 'ostruct'
data = OpenStruct.new("country" => "Australia", :population => 20_000_000)
data.each_pair.to_a  # => [[:country, "Australia"], [:population, 20000000]]


131
132
133
134
# File 'lib/ostruct.rb', line 131

def each_pair
  return to_enum(__method__) { @table.size } unless block_given?
  @table.each_pair{|p| yield p}
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)


313
314
315
316
# File 'lib/ostruct.rb', line 313

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

#freezeObject



179
180
181
182
# File 'lib/ostruct.rb', line 179

def freeze
  @table.each_key {|key| new_ostruct_member(key)}
  super
end

#hashObject

Compute a hash-code for this OpenStruct. Two hashes with the same content will have the same hash code (and will be eql?).



321
322
323
# File 'lib/ostruct.rb', line 321

def hash
  @table.hash
end

#initialize_copy(orig) ⇒ Object

Duplicate an OpenStruct object members.



104
105
106
107
# File 'lib/ostruct.rb', line 104

def initialize_copy(orig)
  super
  @table = @table.dup
end

#inspectObject Also known as: to_s

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



272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
# File 'lib/ostruct.rb', line 272

def inspect
  str = "#<#{self.class}"

  ids = (Thread.current[InspectKey] ||= [])
  if ids.include?(object_id)
    return str << ' ...>'
  end

  ids << object_id
  begin
    first = true
    for k,v in @table
      str << "," unless first
      first = false
      str << " #{k}=#{v.inspect}"
    end
    return str << '>'
  ensure
    ids.pop
  end
end

#marshal_dumpObject

Provides marshalling support for use by the Marshal library.



139
140
141
# File 'lib/ostruct.rb', line 139

def marshal_dump
  @table
end

#marshal_load(x) ⇒ Object

Provides marshalling support for use by the Marshal library.



146
147
148
# File 'lib/ostruct.rb', line 146

def marshal_load(x)
  @table = x
end

#respond_to_missing?(mid, include_private = false) ⇒ Boolean

Returns:

  • (Boolean)


184
185
186
187
# File 'lib/ostruct.rb', line 184

def respond_to_missing?(mid, include_private = false)
  mname = mid.to_s.chomp("=").to_sym
  @table.key?(mname) || super
end

#to_hObject

Converts the OpenStruct to a hash with keys representing each attribute (as symbols) and their corresponding values Example:

require 'ostruct'
data = OpenStruct.new("country" => "Australia", :population => 20_000_000)
data.to_h   # => {:country => "Australia", :population => 20000000 }


118
119
120
# File 'lib/ostruct.rb', line 118

def to_h
  @table.dup
end