Psych::Visitors::ToRuby

 
               # File psych/lib/psych/visitors/to_ruby.rb, line 12
def initialize ss = ScalarScanner.new
  super()
  @st = {}
  @ss = ss
  @domain_types = Psych.domain_types
end
            

 
               # File psych/lib/psych/visitors/to_ruby.rb, line 19
def accept target
  result = super
  return result if @domain_types.empty? || !target.tag

  key = target.tag.sub(/^[!\/]*/, '').sub(/(,\d+)\//, '\1:')
  key = "tag:#{key}" unless key =~ /^(tag:|x-private)/

  if @domain_types.key? key
    value, block = @domain_types[key]
    return block.call value, result
  end

  result
end
            

 
               # File psych/lib/psych/visitors/to_ruby.rb, line 245
def visit_Psych_Nodes_Alias o
  @st.fetch(o.anchor) { raise BadAlias, "Unknown alias: #{o.anchor}" }
end
            

 
               # File psych/lib/psych/visitors/to_ruby.rb, line 237
def visit_Psych_Nodes_Document o
  accept o.root
end
            

 
               # File psych/lib/psych/visitors/to_ruby.rb, line 139
def visit_Psych_Nodes_Mapping o
  return revive(Psych.load_tags[o.tag], o) if Psych.load_tags[o.tag]
  return revive_hash({}, o) unless o.tag

  case o.tag
  when /^!(?:str|ruby\/string)(?::(.*))?/, 'tag:yaml.org,2002:str'
    klass = resolve_class($1)
    members = Hash[*o.children.map { |c| accept c }]
    string = members.delete 'str'

    if klass
      string = klass.allocate.replace string
      register(o, string)
    end

    init_with(string, members.map { |k,v| [k.to_s.sub(/^@/, ''),v] }, o)
  when /^!ruby\/array:(.*)$/
    klass = resolve_class($1)
    list  = register(o, klass.allocate)

    members = Hash[o.children.map { |c| accept c }.each_slice(2).to_a]
    list.replace members['internal']

    members['ivars'].each do |ivar, v|
      list.instance_variable_set ivar, v
    end
    list
  when /^!ruby\/struct:?(.*)?$/
    klass = resolve_class($1)

    if klass
      s = register(o, klass.allocate)

      members = {}
      struct_members = s.members.map { |x| x.to_sym }
      o.children.each_slice(2) do |k,v|
        member = accept(k)
        value  = accept(v)
        if struct_members.include?(member.to_sym)
          s.send("#{member}=", value)
        else
          members[member.to_s.sub(/^@/, '')] = value
        end
      end
      init_with(s, members, o)
    else
      members = o.children.map { |c| accept c }
      h = Hash[*members]
      Struct.new(*h.map { |k,v| k.to_sym }).new(*h.map { |k,v| v })
    end

  when '!ruby/range'
    h = Hash[*o.children.map { |c| accept c }]
    register o, Range.new(h['begin'], h['end'], h['excl'])

  when /^!ruby\/exception:?(.*)?$/
    h = Hash[*o.children.map { |c| accept c }]

    e = build_exception((resolve_class($1) || Exception),
                        h.delete('message'))
    init_with(e, h, o)

  when '!set', 'tag:yaml.org,2002:set'
    set = Psych::Set.new
    @st[o.anchor] = set if o.anchor
    o.children.each_slice(2) do |k,v|
      set[accept(k)] = accept(v)
    end
    set

  when '!ruby/object:Complex'
    h = Hash[*o.children.map { |c| accept c }]
    register o, Complex(h['real'], h['image'])

  when '!ruby/object:Rational'
    h = Hash[*o.children.map { |c| accept c }]
    register o, Rational(h['numerator'], h['denominator'])

  when /^!ruby\/object:?(.*)?$/
    name = $1 || 'Object'
    obj = revive((resolve_class(name) || Object), o)
    obj

  when /^!map:(.*)$/, /^!ruby\/hash:(.*)$/
    revive_hash resolve_class($1).new, o

  when '!omap', 'tag:yaml.org,2002:omap'
    map = register(o, Psych::Omap.new)
    o.children.each_slice(2) do |l,r|
      map[accept(l)] = accept r
    end
    map

  else
    revive_hash({}, o)
  end
end
            

 
               # File psych/lib/psych/visitors/to_ruby.rb, line 103
def visit_Psych_Nodes_Scalar o
  register o, deserialize(o)
end
            

 
               # File psych/lib/psych/visitors/to_ruby.rb, line 107
def visit_Psych_Nodes_Sequence o
  if klass = Psych.load_tags[o.tag]
    instance = klass.allocate

    if instance.respond_to?(:init_with)
      coder = Psych::Coder.new(o.tag)
      coder.seq = o.children.map { |c| accept c }
      instance.init_with coder
    end

    return instance
  end

  case o.tag
  when '!omap', 'tag:yaml.org,2002:omap'
    map = register(o, Psych::Omap.new)
    o.children.each { |a|
      map[accept(a.children.first)] = accept a.children.last
    }
    map
  when /^!(?:seq|ruby\/array):(.*)$/
    klass = resolve_class($1)
    list  = register(o, klass.allocate)
    o.children.each { |c| list.push accept c }
    list
  else
    list = register(o, [])
    o.children.each { |c| list.push accept c }
    list
  end
end
            

 
               # File psych/lib/psych/visitors/to_ruby.rb, line 241
def visit_Psych_Nodes_Stream o
  o.children.map { |c| accept c }
end