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 and 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. For example:

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

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



86
87
88
89
90
91
92
93
94
 
# File 'lib/ostruct.rb', line 86

def initialize(hash=nil)
  @table = {}
  if hash
    for k,v in hash
      @table[k.to_sym] = v
      new_ostruct_member(k)
    end
  end
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(mid, *args) ⇒ Object

:nodoc:



165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'lib/ostruct.rb', line 165

def method_missing(mid, *args) # :nodoc:
  mname = mid.id2name
  len = args.length
  if mname.chomp!('=') && mid != :[]=
    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 && mid != :[]
    @table[mid]
  else
    raise NoMethodError, "undefined method `#{mid}' for #{self}", caller(1)
  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 object's Hash tables are equal.



232
233
234
235
 
# File 'lib/ostruct.rb', line 232

def ==(other)
  return false unless(other.kind_of?(OpenStruct))
  return @table == other.table
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'



190
191
192
193
194
 
# File 'lib/ostruct.rb', line 190

def delete_field(name)
  sym = name.to_sym
  singleton_class.__send__(:remove_method, sym, "#{name}=")
  @table.delete sym
end

#initialize_copy(orig) ⇒ Object

Duplicate an OpenStruct object members.



97
98
99
100
 
# File 'lib/ostruct.rb', line 97

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

#inspect ⇒ Object Also known as: to_s

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



201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
 
# File 'lib/ostruct.rb', line 201

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_dump ⇒ Object

Provides marshalling support for use by the Marshal library. Returning the underlying Hash table that contains the functions defined as the keys and the values assigned to them.

require 'ostruct'

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

person.marshal_dump # => { :name => 'John Smith', :age => 70 }



115
116
117
 
# File 'lib/ostruct.rb', line 115

def marshal_dump
  @table
end

#marshal_load(x) ⇒ Object

Provides marshalling support for use by the Marshal library. Accepting a Hash of keys and values which will be used to populate the internal table

require 'ostruct'

event = OpenStruct.new
hash = { 'time' => Time.now, 'title' => 'Birthday Party' }
event.marshal_load(hash)
event.title # => 'Birthday Party'



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

def marshal_load(x)
  @table = x
  @table.each_key{|key| new_ostruct_member(key)}
end

#new_ostruct_member(name) ⇒ Object

new_ostruct_member is used internally to defined properties on the OpenStruct. It does this by using the metaprogramming function define_method for both the getter method and the setter method.



154
155
156
157
158
159
160
161
162
163
 
# File 'lib/ostruct.rb', line 154

def new_ostruct_member(name)
  name = name.to_sym
  unless self.respond_to?(name)
    class << self; self; end.class_eval do
      define_method(name) { @table[name] }
      define_method("#{name}=") { |x| modifiable[name] = x }
    end
  end
  name
end