1.  Please do not post any solutions or spoiler discussion for this quiz until
48 hours have passed from the time on this message.

2.  Support Ruby Quiz by submitting ideas as often as you can:

http://www.rubyquiz.com/

3.  Enjoy!

Suggestion:  A [QUIZ] in the subject of emails about the problem helps everyone
on Ruby Talk follow the discussion.  Please reply to the original quiz message,
if you can.

-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- =-=-=

by Hans Fugal

More than a few times I've wished I could get a nice nested OpenStruct out of
YAML data, instead of the more unwieldy nested hashes. It's mostly a matter of
style. It's a straightforward task to convert a nested hash structure into a
nested OpenStruct, but it's the sort of task that you can do a lot of ways, and
I'll bet some of you can come up with more elegant and/or more efficient ways
than I have so far.

Here's a sample YAML document to get you started:

     ---
     foo: 1
     bar:
       baz: [1, 2, 3]
       quux: 42
       doctors:
         - William Hartnell
         - Patrick Troughton
         - Jon Pertwee
         - Tom Baker
         - Peter Davison
         - Colin Baker
         - Sylvester McCoy
         - Paul McGann
         - Christopher Eccleston
         - David Tennant
       a: {x: 1, y: 2, z: 3}
     table: walnut
     method: linseed oil
     type: contemporary
     id: 1234
     send: fedex

??

Ok, I cheated... Hans pointed me at the rubyquiz site before this
showed up in the list, so I got a head start. But in only 15 minutes,
I've got it solved, with only 18 lines (only 5 of those are in method
bodies), sans whitespace. Golfers... go!

I'd like to thank Hans for a really straightforward (such that I can
do it in my limited time), yet still interesting quiz!

I had a 7 line method, that became 6 lines, that became 4 lines...
became 2 really ugly lines if I can include and not count a helper
method to turn mapped Hashes back into Hashes.

My output, reformatted for prettiness (it also handles Ara's additions):

#<OpenStruct
  foo=1,
  bar=#<OpenStruct
    a=#<OpenStruct z=3, x=1, y=2>,
    quux=42,
    doctors=[
      "William Hartnell",
      "Patrick Troughton",
      "Jon Pertwee",
      "Tom Baker",
      "Peter Davison",
      "Colin Baker",
      "Sylvester McCoy",
      "Paul McGann",
      "Christopher Eccleston",
      "David Tennant"
    ],
    baz=[1, 2, 3]
  >

On Jun 2, 2006, at 3:59 PM, MenTaLguY wrote:

KYFD.

Regards,

Dan

Otherwise, in most cases I've seen, there simply isn't any room for an arbitrarily deep set of nested hashes in the schema -- either you'd get an error from a hash being in an unexpected place, or that recursive subtree would simply get ignored.

You might have to think about these sorts of things on rare occasions, but it's not the end of the world.

On Jun 2, 2006, at 5:25 PM, Berger, Daniel wrote:

To handle parameters that are the same as existant method names (i.e.
Ara's sample) requires removal of the 'unless' from new_ostruct_member:

def new_ostruct_member(name)
    name = name.to_sym
    meta = class << self; self; end
    meta.send(:define_method, name) { @table[name] }
    meta.send(:define_method, "#{name}=""#{name}=") { |x| @table[name] = x }
end

Regards,

% cat hash_to_open_struct2.rb
require 'yaml'
require 'ostruct'
class Object
   def hash_to_ostruct(visited = [])
     self
   end
end

class Array
   def hash_to_ostruct(visited = [])
     map { |x| x.hash_to_ostruct(visited) }
   end
end

class Hash
   def hash_to_ostruct(visited = [])
     os = OpenStruct.new
     each do |k, v|
       item = visited.find { |x| x.first.object_id == v.object_id }
       if item
        os.send("#{k}=", item.last)
       else
        os.send("#{k}=", v.hash_to_ostruct(visited + [ [self, os] ]))
       end
     end
     os
   end
end

yaml_source = <<YAML
---
foo: 1
bar:
   baz: [1, 2, 3]
   quux: 42
   doctors:
     - William Hartnell
     - Patrick Troughton
     - Jon Pertwee
     - Tom Baker
     - Peter Davison
     - Colin Baker
     - Sylvester McCoy
     - Paul McGann
     - Christopher Eccleston
     - David Tennant
     - {w: 1, t: 7}
   a: {x: 1, y: 2, z: 3}
YAML
evil_yaml = <<EVIL
---
&verily
lemurs:
   unite: *verily
   beneath:
     - patagonian
     - bread
     - products
thusly: [1, 2, 3, 4]
EVIL

loaded = YAML.load(yaml_source).hash_to_ostruct
p loaded.bar.doctors.last.w

evil_loaded = YAML.load(evil_yaml).hash_to_ostruct
p evil_loaded.lemurs.beneath
p evil_loaded.lemurs.unite.thusly

When I first read the quiz my thoughts intitally went to the usual
concepts and I considered the Hash#traverse method I wrote some time
ago (BTW this quiz helped me improve that method. Many thanks!) But I
have good bit of experience with YAML and I immediately had a second
thought which would allow me to solve the quiz very quickily and
easily. The solution is as follows (were s containes the yaml sample).

  YAML.add_builtin_type('map'){ |t,v| OpenStruct.new(v) }; o =
YAML.load(s)

But like I said, as clever as it may be, it doesn't work. For whatever
reason Syck doesn't handle it properly. Perhaps YAML's 'map' type is
too fundamental that it can't comply, or perhaps it's a bug. I don't
know. But it just end up returning the same old Hash.

Okay I thought. There's more than one way to skin a cat. And I came up
with this close to one-liner that works around the above problem in a
most clever way.

  i = YAML::load(s)
  def Hash.def to_yaml_type
    "!ruby/object:OpenStruct"
  end
  o = YAML::load(i.to_yaml)

The nice thing about this soluiton is that it uses a built-in library
(YAML/Syck) to do all the hard work --since Syck already understands
graphs it takes care of all those messy issues. Cool.

   class Hash
     def to_ostruct
       copy = dup
       copy.each do |key, value|
         copy[key] = value.to_ostruct if value.respond_to? :to_ostruct
       end
       return copy
     end
   end

  require 'yaml'
  require 'ostruct'

  class << YAML::DefaultResolver
    alias_method :_node_import, :node_import
    def node_import(node)
      o = _node_import(node)
      o.is_a?(Hash) ? OpenStruct.new(o) : o
    end
  end

I don't know if this will handle the crazier recursive YAML files,  
but it seems to be fine for normal ones.  My son actually struck on  
the OpenStruct#send being a problem with the presence of the 'send'  
key in the YAML.

-Rob

# RubyQuiz81: Hash to OpenStruct
# 2006-06-02

require 'ostruct'
require 'yaml'

class HashToOpenStruct
   def self.from_yaml(yamlfile)
     self.to_ostruct(YAML.load(File.open(yamlfile)))
   end

   def self.to_ostruct(h)
     c = OpenStruct.new
     h.each { |k,v| c.__send__("#{k}=".to_sym,
                               v.kind_of?(Hash) ? to_ostruct(v) : v) }
     c
   end
end

__END__