RbYAML 0.1.0 → 0.2.0

data/lib/rbyaml/types.rb

@@ -0,0 +1,146 @@
+# -*- mode: ruby; ruby-indent-level: 4 -*- vim: sw=4
+#
+# Classes required by the full core typeset
+#
+module RbYAML
+    #
+    # Default private type
+    #
+    class PrivateType
+        def self.tag_subclasses?; false; end
+        attr_accessor :type_id, :value
+        verbose, $VERBOSE = $VERBOSE, nil
+        def initialize( type, val )
+            @type_id = type; @value = val
+            @value.taguri = "x-private:#{ @type_id }"
+        end
+        def to_yaml_node( repr )
+            @value.to_yaml_node( repr )
+        end
+    ensure
+        $VERBOSE = verbose
+    end
+
+    #
+    # Default domain type
+    #
+    class DomainType
+        def self.tag_subclasses?; false; end
+        attr_accessor :domain, :type_id, :value
+        verbose, $VERBOSE = $VERBOSE, nil
+        def initialize( domain, type, val )
+            @domain = domain; @type_id = type; @value = val
+            @value.taguri = "tag:#{ @domain }:#{ @type_id }"
+        end
+        def to_yaml_node( repr )
+            @value.to_yaml_node( repr )
+        end
+    ensure
+        $VERBOSE = verbose
+    end
+
+    #
+    # Builtin collection: !omap
+    #
+    class Omap < ::Array
+        yaml_as "tag:yaml.org,2002:omap"
+        def yaml_initialize( tag, val )
+            if Array === val
+                val.each do |v|
+                    if Hash === v
+                        concat( v.to_a )		# Convert the map to a sequence
+                    else
+                        raise YAML::Error, "Invalid !omap entry: " + val.inspect
+                    end
+                end
+            else
+                raise YAML::Error, "Invalid !omap: " + val.inspect
+            end
+            self
+        end
+        def self.[]( *vals )
+
+            o = Omap.new
+            0.step( vals.length - 1, 2 ) do |i|
+                o[vals[i]] = vals[i+1]
+            end
+            o
+        end
+        def []( k )
+            self.assoc( k ).to_a[1]
+        end
+        def []=( k, *rest )
+            val, set = rest.reverse
+            if ( tmp = self.assoc( k ) ) and not set
+                tmp[1] = val
+            else
+                self << [ k, val ] 
+            end
+            val
+        end
+        def has_key?( k )
+            self.assoc( k ) ? true : false
+        end
+        def is_complex_yaml?
+            true
+        end
+        def to_yaml_node( repr )
+            RbYAML::quick_emit_node( self.object_id, repr ) do |out|
+                out.seq( taguri, self.collect {|v| Hash[*v]}, to_yaml_style )
+            end
+        end
+    end
+
+    #
+    # Builtin collection: !pairs
+    #
+    class Pairs < ::Array
+        yaml_as "tag:yaml.org,2002:pairs"
+        def yaml_initialize( tag, val )
+            if Array === val
+                val.each do |v|
+                    if Hash === v
+                        concat( v.to_a )		# Convert the map to a sequence
+                    else
+                        raise YAML::Error, "Invalid !pairs entry: " + val.inspect
+                    end
+                end
+            else
+                raise YAML::Error, "Invalid !pairs: " + val.inspect
+            end
+            self
+        end
+        def self.[]( *vals )
+            p = Pairs.new
+            0.step( vals.length - 1, 2 ) { |i|
+                p[vals[i]] = vals[i+1]
+            }
+            p
+        end
+        def []( k )
+            self.assoc( k ).to_a
+        end
+        def []=( k, val )
+            self << [ k, val ] 
+            val
+        end
+        def has_key?( k )
+            self.assoc( k ) ? true : false
+        end
+        def is_complex_yaml?
+            true
+        end
+        def to_yaml_node( repr )
+            RbYAML::quick_emit_node( self.object_id, opts ) do |out|
+                out.seq( taguri, self.collect {|v| Hash[*v]}, to_yaml_style )
+            end
+        end
+    end
+
+    #
+    # Builtin collection: !set
+    #
+    class Set < ::Hash
+        yaml_as "tag:yaml.org,2002:set"
+    end
+end

data/lib/rbyaml/util.rb.~1.3.~

@@ -0,0 +1,38 @@
+class Object
+  def __is_str; false end
+  def __is_sym; false end
+  def __is_a; false end
+  def __is_int; false end
+end
+
+class String
+  def __is_str; true end
+end
+
+class Symbol
+  def __is_sym; true end
+end
+
+class Array
+  def __is_a; true end
+end
+
+class Integer
+  def __is_int; true end
+end
+
+class Fixnum
+  def __is_ascii_num
+    self <= ?9 && self >= ?0
+  end
+end
+
+module RbYAML
+  class PrivateType
+    attr_accessor :type_id, :value
+    def initialize( type, val )
+      @type_id = type; 
+      @value = val
+    end
+  end
+end

data/lib/rbyaml/yaml.rb

@@ -48,24 +48,24 @@ module RbYAML
     _load(stream, SafeLoader)
   end
 
-  def self._emit(events, stream=nil, dumper=Dumper,default_style=nil,default_flow_style=nil,canonical=nil, indent=nil, width=nil,line_break=nil)
+  def self._emit(events, stream=nil, dump=Dumper, opts={})
     if stream.nil?
       require 'stringio'
       stream = StringIO.new
     end
-    dumper = dumper.new(stream,default_style,default_flow_style,canonical,indent,width,line_break)
+    dumper = dump.new(stream,opts)
     for event in events
       dumper.emit(event)
     end        
     stream.string if StringIO === stream
   end
 
-  def self._serialize_all(nodes,stream=nil,dumper=Dumper,default_style=nil,default_flow_style=nil,canonical=nil,indent=nil,width=nil,line_break=nil,explicit_start=nil,explicit_end=nil,version=nil,tags=nil)
+  def self._serialize_all(nodes,stream=nil, dump=Dumper, opts={})
     if stream.nil?
       require 'stringio'
       stream = StringIO.new
     end
-    dumper = dumper.new(stream,default_style,default_flow_style,canonical,indent,width,line_break,version,tags,explicit_start,explicit_end)
+    dumper = dump.new(stream,opts)
     dumper.serializer.open
     for node in nodes
       dumper.serializer.serialize(node)
@@ -74,16 +74,16 @@ module RbYAML
     stream.string if StringIO === stream
   end
   
-  def self._serialize(node, stream=nil, dumper=Dumper, *kwds)
-    _serialize_all([node], stream, dumper, *kwds)
+  def self._serialize(node, stream=nil, dump=Dumper, opts={})
+    _serialize_all([node], stream, dump, opts)
   end
   
-  def self._dump_all(documents,stream=nil,dumper=Dumper,default_style=nil,default_flow_style=nil,canonical=nil,indent=nil,width=nil,line_break=nil,explicit_start=nil,explicit_end=nil,version=nil,tags=nil)
+  def self._dump_all(documents,stream=nil, dump=Dumper, opts={})
     if stream.nil?
       require 'stringio'
       stream = StringIO.new
     end
-    dumper = dumper.new(stream,default_style,default_flow_style,canonical,indent,width,line_break,version,tags,explicit_start,explicit_end)
+    dumper = dump.new(stream,opts)
     dumper.serializer.open
     for data in documents
       dumper.representer.represent(data)
@@ -92,42 +92,32 @@ module RbYAML
     stream.string if StringIO === stream
   end
 
-  def self._dump(data, stream=nil, dumper=Dumper, *kwds)
-    _dump_all([data], stream, dumper, *kwds)
+  def self._dump(data, stream=nil,dump=Dumper, opts={})
+    _dump_all([data], stream, dump, opts)
   end
   
-  def self._safe_dump_all(documents, stream=nil, *kwds)
-    _dump_all(documents, stream, SafeDumper, *kwds)
-  end
-  
-  def self._safe_dump(data, stream=nil, *kwds)
-    _dump_all([data], stream, SafeDumper, *kwds)
-  end
-
-  def self._add_implicit_resolver(tag, regexp, first=nil, loader=Loader, dumper=Dumper)
-    loader.add_implicit_resolver(tag, regexp, first)
-    dumper.add_implicit_resolver(tag, regexp, first)
+  def self._add_implicit_resolver(tag, regexp, first=nil, resolver=BaseResolver)
+    resolver.add_implicit_resolver(tag, regexp, first)
   end
 
-  def self._add_path_resolver(tag, path, kind=nil, loader=Loader, dumper=Dumper)
-    loader.add_path_resolver(tag, path, kind)
-    lumper.add_path_resolver(tag, path, kind)
+  def self._add_path_resolver(tag, path, kind=nil, resolver=BaseResolver)
+    resolver.add_path_resolver(tag, path, kind)
   end
   
-  def self._add_constructor(tag, constructor, loader=Loader)
-    loader.add_constructor(tag, constructor)
+  def self._add_constructor(tag, constructor, ctor=Constructor)
+    ctor.add_constructor(tag, constructor)
   end
 
-  def self._add_multi_constructor(tag_prefix, multi_constructor, loader=Loader)
-    loader.add_multi_constructor(tag_prefix, multi_constructor)
+  def self._add_multi_constructor(tag_prefix, multi_constructor, ctor=Constructor)
+    ctor.add_multi_constructor(tag_prefix, multi_constructor)
   end
 
-  def self._add_representer(data_type, representer, dumper=Dumper)
-    dumper.add_representer(data_type, representer)
+  def self._add_representer(data_type, representer, rep=BaseRepresenter)
+    rep.add_representer(data_type, representer)
   end
 
-  def self._add_multi_representer(data_type, multi_representer, dumper=Dumper)
-    dumper.add_multi_representer(data_type, multi_representer)
+  def self._add_multi_representer(data_type, multi_representer, rep=BaseRepresenter)
+    rep.add_multi_representer(data_type, multi_representer)
   end
 
   def self._dump_ruby_object(data, dumper=Dumper)

data/lib/rbyaml/{yaml.rb.~1.2.~ → yaml.rb.~1.5.~}

@@ -12,32 +12,32 @@ require 'rbyaml/dumper'
 module RbYAML
   def self._scan(stream, loader=Loader)
     l = loader.new(stream)
-    yield l.get_token while l.check_token
+    yield l.scanner.get_token while l.scanner.check_token
   end
 
   def self._parse(stream, loader=Loader)
     l = loader.new(stream)
-    yield l.get_event while l.check_event
+    yield l.parser.get_event while l.parser.check_event
   end
 
   def self._compose(stream, loader=Loader)
     l = loader.new(stream)
-    l.get_node if l.check_node
+    l.composer.get_node if l.composer.check_node
   end
 
   def self._compose_all(stream, loader=Loader)
     l = loader.new(stream)
-    yield l.get_node while l.check_node
+    yield l.composer.get_node while l.composer.check_node
   end
 
   def self._load_all(stream, loader=Loader)
     l = loader.new(stream)
-    yield l.get_data while l.check_data
+    yield l.constructor.get_data while l.constructor.check_data
   end
   
   def self._load(stream, loader=Loader)
     l = loader.new(stream)
-    l.get_data if l.check_data
+    l.constructor.get_data if l.constructor.check_data
   end
 
   def self._safe_load_all(stream)
@@ -60,17 +60,17 @@ module RbYAML
     stream.string if StringIO === stream
   end
 
-  def self._serialize_all(nodes,stream=nil,dumper=Dumper,default_style=nil,default_flow_style=nil,canonical=nil,indent=nil,width=nil,line_break=nil,explicit_start=nil,explicit_end=nil,version=nil,tags=nil)
+  def self._serialize_all(nodes,stream=nil,dumper=Dumper,default_style=nil,default_flow_style=nil,canonical=nil,indent=nil,width=nil,line_break=nil,explicit_start=true,explicit_end=nil,version=nil,tags=nil)
     if stream.nil?
       require 'stringio'
       stream = StringIO.new
     end
-    dumper = dumper.new(stream,default_style,default_flow_style,canonical,indent,width,line_break,version,tags,explicit_start,explicit_end)
-    dumper.open
+    dumper = dumper.new(stream,default_style,default_flow_style,canonical,indent,width,line_break,explicit_start,explicit_end,version,tags)
+    dumper.serializer.open
     for node in nodes
-      dumper.serialize(node)
+      dumper.serializer.serialize(node)
     end
-    dumper.close
+    dumper.serializer.close
     stream.string if StringIO === stream
   end
   
@@ -78,17 +78,17 @@ module RbYAML
     _serialize_all([node], stream, dumper, *kwds)
   end
   
-  def self._dump_all(documents,stream=nil,dumper=Dumper,default_style=nil,default_flow_style=nil,canonical=nil,indent=nil,width=nil,line_break=nil,explicit_start=nil,explicit_end=nil,version=nil,tags=nil)
+  def self._dump_all(documents,stream=nil,dumper=Dumper,default_style=nil,default_flow_style=nil,canonical=nil,indent=nil,width=nil,line_break=nil,explicit_start=true,explicit_end=nil,version=nil,tags=nil)
     if stream.nil?
       require 'stringio'
       stream = StringIO.new
     end
-    dumper = dumper.new(stream,default_style,default_flow_style,canonical,indent,width,line_break,version,tags,explicit_start,explicit_end)
-    dumper.open
+    dumper = dumper.new(stream,default_style,default_flow_style,canonical,indent,width,line_break,explicit_start,explicit_end,version,tags)
+    dumper.serializer.open
     for data in documents
-      dumper.represent(data)
+      dumper.representer.represent(data)
     end
-    dumper.close
+    dumper.serializer.close
     stream.string if StringIO === stream
   end
 
@@ -111,7 +111,7 @@ module RbYAML
 
   def self._add_path_resolver(tag, path, kind=nil, loader=Loader, dumper=Dumper)
     loader.add_path_resolver(tag, path, kind)
-    lumper.add_path_resolver(tag, path, kind)
+    dumper.add_path_resolver(tag, path, kind)
   end
   
   def self._add_constructor(tag, constructor, loader=Loader)

data/test/load_one.rb

@@ -0,0 +1,6 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'rbyaml'
+require 'pp'  
+      
+pp open(File.expand_path(ARGV[0]),"r") {|f| RbYAML.load(f)}

data/test/load_one_yaml.rb

@@ -0,0 +1,6 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'yaml'
+require 'pp'
+        
+pp open(File.expand_path(ARGV[0]),"r") {|f| YAML.load(f)}

data/test/output_events.rb

@@ -0,0 +1,9 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'rbyaml'
+
+x = File.read(ARGV[0])
+RbYAML::Parser.new(RbYAML::Scanner.new(StringIO.new(x))).each_event { |eve| 
+  puts "org.jvyaml.events.#{eve.class.to_s.split('::').last}"
+}
+

data/test/test_add_ctor.rb

@@ -0,0 +1,51 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'ostruct'
+require 'rbyaml'
+
+class TrueClass; def to_sym; :true end; end and class FalseClass; def to_sym; :false end; end
+
+data  = <<-"END"
+---
+x: 1
+y: 2
+z: 3
+END
+
+datay = <<-"END"
+---
+&verily
+lemurs:
+  unite: *verily
+  beneath:
+    - patagonian
+    - bread
+    - products
+thusly: [1, 2, 3, 4] 
+END
+
+datax = <<-"END"
+---
+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, w: 2, z: 3}
+END
+
+RbYAML.add_builtin_ctor("map") {|ctor,node|
+  OpenStruct.new(ctor.construct_mapping(node))
+}
+
+puts RbYAML.load(data)