class OpenStruct

# File ext/json/lib/json/add/ostruct.rb, line 10
def self.json_create(object)
  new(object['t'] || object[:t])
end

Deserializes JSON string by constructing new Struct object with values v serialized by to_json.

# File lib/ostruct.rb, line 89
def initialize(hash=nil)
  @table = {}
  if hash
    hash.each_pair do |k, v|
      k = k.to_sym
      @table[k] = v
      new_ostruct_member(k)
    end
  end
end

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 lib/ostruct.rb, line 293
def ==(other)
  return false unless other.kind_of?(OpenStruct)
  @table == other.table
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 lib/ostruct.rb, line 208
def [](name)
  @table[name.to_sym]
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 lib/ostruct.rb, line 223
def []=(name, value)
  modifiable[new_ostruct_member(name)] = value
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 ext/json/lib/json/add/ostruct.rb, line 16
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

Returns a hash, that will be turned into a JSON object and represent this object.

# File lib/ostruct.rb, line 243
def delete_field(name)
  sym = name.to_sym
  singleton_class.__send__(:remove_method, sym, "#{sym}=")
  @table.delete sym
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 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

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 lib/ostruct.rb, line 303
def eql?(other)
  return false unless other.kind_of?(OpenStruct)
  @table.eql?(other.table)
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 lib/ostruct.rb, line 313
def hash
  @table.hash
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 lib/ostruct.rb, line 254
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

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

# File lib/ostruct.rb, line 140
def marshal_dump
  @table
end

Provides marshalling support for use by the Marshal library.

# File lib/ostruct.rb, line 147
def marshal_load(x)
  @table = x
  @table.each_key{|key| new_ostruct_member(key)}
end

Provides marshalling support for use by the Marshal library.

# File lib/ostruct.rb, line 115
def to_h
  @table.dup
end

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" }

# File ext/json/lib/json/add/ostruct.rb, line 27
def to_json(*args)
  as_json.to_json(*args)
end

Stores class name (OpenStruct) with this struct's values v as a JSON string.

# File lib/ostruct.rb, line 156
def modifiable
  begin
    @modifiable = true
  rescue
    raise RuntimeError, "can't modify frozen #{self.class}", caller(3)
  end
  @table
end

Used internally to check if the OpenStruct is able to be modified before granting access to the internal Hash table to be modified.

# File lib/ostruct.rb, line 171
def new_ostruct_member(name)
  name = name.to_sym
  unless respond_to?(name)
    define_singleton_method(name) { @table[name] }
    define_singleton_method("#{name}=") { |x| modifiable[name] = x }
  end
  name
end

Used internally to defined properties on the OpenStruct. It does this by using the metaprogramming function define_singleton_method for both the getter method and the setter method.