zaml 0.1.2

data/LICENSE

@@ -0,0 +1,14 @@
+Copyright (c) 2008 ZAML contributers
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.

data/README

@@ -0,0 +1,47 @@
+ZAML is faster YAML serialization for Ruby
+
+The Ruby YAML library is a full stack standard compliant
+implementation of the YAML protocol, while ZAML is an attempt to
+produce (effectively) the same output as YAML would have - but much
+faster and with cleaner code.
+
+ZAML has been benchmarked at up to %1600 faster than YAML:  
+http://gnomecoder.wordpress.com/2008/09/27/yaml-dump-1600-percent-faster/
+http://groups.google.com/group/rubyonrails-core/browse_thread/thread/3e33e31f57e23911/d2eedb7531a12e47?lnk=gst&q=zaml#d2eedb7531a12e47
+
+
+## Installation
+
+Add gemcutter to your sources if you haven't done so already:
+
+    sudo gem install gemcutter
+    gem tumble
+
+Install the gem:
+
+    sudo gem install zaml
+
+
+## Usage
+
+    require 'zaml'
+    foo = { :some => { :complicated => [:data, :structure] } }
+    File.open('output.yml', 'w') { |f| ZAML.dump(foo,f) }
+
+
+## License
+
+Copyright (c) 2008-2009 ZAML contributers
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.

data/lib/zaml.rb

@@ -0,0 +1,318 @@
+#
+# ZAML -- A partial replacement for YAML, writen with speed and code clarity
+#         in mind.  ZAML fixes one YAML bug (loading Exceptions) and provides 
+#         a replacement for YAML.dump() unimaginatively called ZAML.dump(),
+#         which is faster on all known cases and an order of magnitude faster 
+#         with complex structures.
+#
+# http://github.com/hallettj/zaml
+#
+# Authors: Markus Roberts, Jesse Hallett, Ian McIntosh, Igal Koshevoy, Simon Chiang
+# 
+
+require 'yaml'
+
+class ZAML
+    VERSION = "0.1.2"
+    #
+    # Class Methods
+    #
+    def self.dump(stuff, where='')
+        z = new
+        stuff.to_zaml(z)
+        where << z.to_s
+        end
+    #
+    # Instance Methods
+    #
+    def initialize
+        @result = []
+        @indent = nil
+        @structured_key_prefix = nil
+        Label.counter_reset
+        emit('--- ')
+        end
+    def nested(tail='  ')
+        old_indent = @indent
+        @indent = "#{@indent || "\n"}#{tail}"
+        yield
+        @indent = old_indent
+        end
+    class Label
+        #
+        # YAML only wants objects in the datastream once; if the same object 
+        #    occurs more than once, we need to emit a label ("&idxxx") on the 
+        #    first occurrence and then emit a back reference (*idxxx") on any
+        #    subsequent occurrence(s). 
+        #
+        # To accomplish this we keeps a hash (by object id) of the labels of
+        #    the things we serialize as we begin to serialize them.  The labels
+        #    initially serialize as an empty string (since most objects are only
+        #    going to be be encountered once), but can be changed to a valid 
+        #    (by assigning it a number) the first time it is subsequently used, 
+        #    if it ever is.  Note that we need to do the label setup BEFORE we 
+        #    start to serialize the object so that circular structures (in 
+        #    which we will encounter a reference to the object as we serialize 
+        #    it can be handled).
+        #
+        def self.counter_reset
+            @@previously_emitted_object = {}
+            @@next_free_label_number = 0
+            end
+        def initialize(obj,indent)
+            @indent = indent
+            @this_label_number = nil
+            @@previously_emitted_object[obj.object_id] = self
+            end
+        def to_s
+            @this_label_number ? ('&id%03d%s' % [@this_label_number, @indent]) : ''
+            end
+        def reference
+            @this_label_number ||= (@@next_free_label_number += 1)
+            @reference         ||= '*id%03d' % @this_label_number
+            end
+        def self.for(obj)
+            @@previously_emitted_object[obj.object_id]
+            end
+        end
+    def new_label_for(obj)
+        Label.new(obj,(Hash === obj || Array === obj) ? "#{@indent || "\n"}  " : ' ')
+        end
+    def first_time_only(obj)
+        if label = Label.for(obj)
+            emit(label.reference)
+          else
+            if @structured_key_prefix and not obj.is_a? String
+                emit(@structured_key_prefix) 
+                @structured_key_prefix = nil
+                end
+            emit(new_label_for(obj))
+            yield
+          end
+        end
+    def emit(s)
+        @result << s
+        @recent_nl = false unless s.kind_of?(Label)
+        end
+    def nl(s='')
+        emit(@indent || "\n") unless @recent_nl 
+        emit(s)
+        @recent_nl = true
+        end
+    def to_s
+        @result.join
+        end
+    def prefix_structured_keys(x)
+        @structured_key_prefix = x
+        yield
+        nl unless @structured_key_prefix
+        @structured_key_prefix = nil
+        end
+    end
+
+################################################################
+#
+#   Behavior for custom classes
+#
+################################################################
+
+class Object
+    def to_yaml_properties
+        instance_variables.sort        # Default YAML behavior
+        end
+    def zamlized_class_name(root)
+        "!ruby/#{root.name.downcase}#{self.class == root ? '' : ":#{self.class.name}"}"
+        end
+    def to_zaml(z)
+        z.first_time_only(self) {
+            z.emit(zamlized_class_name(Object)) 
+            z.nested {
+                instance_variables = to_yaml_properties
+                if instance_variables.empty?
+                    z.emit(" {}")
+                  else
+                    instance_variables.each { |v|
+                        z.nl
+                        v[1..-1].to_zaml(z)       # Remove leading '@'
+                        z.emit(': ')
+                        instance_variable_get(v).to_zaml(z)
+                        }
+                  end
+                }
+            }
+        end
+    end
+
+################################################################
+#
+#   Behavior for built-in classes
+#
+################################################################
+
+class NilClass
+    def to_zaml(z)
+        z.emit('')        # NOTE: blank turns into nil in YAML.load
+        end
+    end
+
+class Symbol
+    def to_zaml(z)
+        z.emit(self.inspect)
+        end
+    end
+
+class TrueClass
+    def to_zaml(z)
+        z.emit('true')
+        end
+    end
+
+class FalseClass
+    def to_zaml(z)
+        z.emit('false')
+        end
+    end
+
+class Numeric
+    def to_zaml(z)
+        z.emit(self)
+        end
+    end
+
+class Regexp
+    def to_zaml(z)
+        z.first_time_only(self) { z.emit("#{zamlized_class_name(Regexp)} #{inspect}") }
+        end
+    end
+
+class Exception
+    def to_zaml(z)
+        z.emit(zamlized_class_name(Exception))
+        z.nested {
+            z.nl("message: ")
+            message.to_zaml(z)
+            }
+        end
+    #
+    # Monkey patch for buggy Exception restore in YAML
+    #
+    #     This makes it work for now but is not very future-proof; if things
+    #     change we'll most likely want to remove this.  To mitigate the risks
+    #     as much as possible, we test for the bug before appling the patch.
+    #
+    if respond_to? :yaml_new and yaml_new(self, :tag, "message" => "blurp").message != "blurp"
+        def self.yaml_new( klass, tag, val )
+            o = YAML.object_maker( klass, {} ).exception(val.delete( 'message'))
+            val.each_pair do |k,v|
+                o.instance_variable_set("@#{k}", v)
+                end
+            o
+            end
+        end
+    end
+
+class String
+    ZAML_ESCAPES = %w{\x00 \x01 \x02 \x03 \x04 \x05 \x06 \a \x08 \t \n \v \f \r \x0e \x0f \x10 \x11 \x12 \x13 \x14 \x15 \x16 \x17 \x18 \x19 \x1a \e \x1c \x1d \x1e \x1f }
+    def escaped_for_zaml
+        gsub( /\x5C/, "\\\\\\" ).  # Demi-kludge for Maglev/rubinius; the regexp should be /\\/ but parsetree chokes on that.
+        gsub( /"/, "\\\"" ).
+        gsub( /([\x00-\x1F])/ ) { |x| ZAML_ESCAPES[ x.unpack("C")[0] ] }.
+        gsub( /([\x80-\xFF])/ ) { |x| "\\x#{x.unpack("C")[0].to_s(16)}" }
+        end
+    def to_zaml(z)
+        z.first_time_only(self) { 
+            num = '[-+]?(0x)?\d+\.?\d*'
+            case
+              when self == ''
+                z.emit('""')
+              # when self =~ /[\x00-\x08\x0B\x0C\x0E-\x1F\x80-\xFF]/
+              #   z.emit("!binary |\n")
+              #   z.emit([self].pack("m*"))
+              when (
+                    (self =~ /\A(true|false|yes|no|on|null|off|#{num}(:#{num})*|!|=|~)$/i) or 
+                    (self =~ /\A\n* /) or
+                    (self =~ /\s$/) or
+                    (self =~ /^[>|][-+\d]*\s/i) or
+                    (self[-1..-1] =~ /\s/) or 
+                    (self =~ /[\x00-\x08\x0B\x0C\x0E-\x1F\x80-\xFF]/) or
+                    (self =~ /[,\[\]\{\}\r\t]|:\s|\s#/) or 
+                    (self =~ /\A([-:?!#&*'"]|<<|%.+:.)/) 
+                    )
+                z.emit("\"#{escaped_for_zaml}\"")
+              when self =~ /\n/
+                if self[-1..-1] == "\n" then z.emit('|+') else z.emit('|-') end
+                z.nested { split("\n",-1).each { |line| z.nl; z.emit(line.chomp("\n")) } }
+                z.nl
+              else 
+                z.emit(self)
+              end
+            }
+        end
+    end
+
+class Hash
+    def to_zaml(z)
+        z.first_time_only(self) { 
+            z.nested {
+                if empty?
+                    z.emit('{}')
+                  else
+                    each_pair { |k, v|
+                        z.nl
+                        z.prefix_structured_keys('? ') { k.to_zaml(z) }
+                        z.emit(': ')
+                        v.to_zaml(z)
+                        }
+                  end
+                }
+            }
+        end
+    end
+
+class Array
+    def to_zaml(z)
+        z.first_time_only(self) {
+            z.nested { 
+                if empty?
+                    z.emit('[]')
+                  else
+                    each { |v| z.nl('- '); v.to_zaml(z) }
+                  end
+                } 
+            }
+        end
+    end
+
+class Time
+    def to_zaml(z)
+        # 2008-12-06 10:06:51.373758 -07:00
+        ms = ("%0.6f" % (usec * 1e-6)).sub(/^\d+\./,'')
+        offset = "%+0.2i:%0.2i" % [utc_offset / 3600, (utc_offset / 60) % 60]
+        z.emit(self.strftime("%Y-%m-%d %H:%M:%S.#{ms} #{offset}"))
+        end
+    end
+
+class Date
+    def to_zaml(z)
+        z.emit(strftime('%Y-%m-%d'))
+        end
+    end
+
+class Range
+    def to_zaml(z)
+        z.first_time_only(self) {
+            z.emit(zamlized_class_name(Range)) 
+            z.nested {
+                z.nl
+                z.emit('begin: ')
+                z.emit(first)
+                z.nl
+                z.emit('end: ')
+                z.emit(last)
+                z.nl
+                z.emit('excl: ')
+                z.emit(exclude_end?)
+                }
+            }
+        end
+    end

data/test/zaml_benchmarks.rb

@@ -0,0 +1,171 @@
+require 'test/unit'
+require 'benchmark'
+require 'yaml'
+require 'tempfile'
+
+require 'zaml'
+
+class My_class
+    def initialize
+        @string = 'string...'
+        @self = self
+        @do_not_store_me = '*************** SHOULD NOT SHOW UP IN OUTPUT ***************'
+        end
+    def to_yaml_properties
+        ['@string', '@self']
+        end
+    end
+
+class ZamlBenchmarks < Test::Unit::TestCase
+    #
+    # dump various data tests
+    #
+    my_range = 7..13
+    my_obj = My_class.new
+    my_dull_object = Object.new
+    my_bob = 'bob'
+    my_exception = Exception.new("Error message")
+    my_runtime_error = RuntimeError.new("This is a runtime error exception")
+    wright_joke = %q{
+  
+      I was in the grocery store. I saw a sign that said "pet supplies". 
+  
+      So I did.
+  
+      Then I went outside and saw a sign that said "compact cars".
+  
+      -- Steven Wright
+    }
+    a_box_of_cheese = [:cheese]
+    
+    DATA = [1, my_range, my_obj, my_bob, my_dull_object, 2, 'test', "   funky\n test\n", true, false, 
+      {my_obj => 'obj is the key!'}, 
+      {:bob => 6.8, :sam => 9.7, :subhash => {:sh1 => 'one', :sh2 => 'two'}}, 
+      6, my_bob, my_obj, my_range, 'bob', 1..10, 0...8]
+    
+    MORE_DATA = [{
+      :a_regexp => /a.*(b+)/im,
+      :an_exception => my_exception,
+      :a_runtime_error => my_runtime_error, 
+      :a_long_string => wright_joke}]
+    
+    NESTED_ARRAYS = [
+      [:one, 'One'],
+      [:two, 'Two'],
+      a_box_of_cheese,
+      [:three, 'Three'],
+      [:four, 'Four'],
+      a_box_of_cheese,
+      [:five, 'Five'],
+      [:six, 'Six']]
+      
+    COMPLEX_DATA = {
+      :data => DATA,
+      :more_data => MORE_DATA,
+      :nested_arrays => NESTED_ARRAYS
+    }
+  
+    HASH = {
+      'str' => 'value', 
+      :sym => :value, 
+      :true => true,
+      :false => false,
+      :int => 100,
+      :float => 1.1
+    }
+    def test_dump_time
+        puts
+        puts "dump:"
+        Benchmark.bm do |x|
+            n = 100
+            GC.start; x.report('yaml') { n.times { YAML.dump(HASH, "") } }
+            GC.start; x.report('zaml') { n.times { ZAML.dump(HASH, "") } }
+            end
+        end
+    def test_dump_time_for_complex_data
+        puts
+        puts "dump time for complex data:"
+        Benchmark.bm do |x|
+            n = 100
+            GC.start; x.report('yaml') { n.times { YAML.dump(COMPLEX_DATA, "") } }
+            GC.start; x.report('zaml') { n.times { ZAML.dump(COMPLEX_DATA, "") } }
+            end
+        end
+    def test_dump_time_for_big_data
+        puts
+        puts "dump time for big data:"
+        Benchmark.bm do |x|
+            n = 100
+            [10,100,1000].each { |s|
+                big_data = (1..s).collect { |i| [My_class.new,COMPLEX_DATA] }
+                print "s = #{s}\n"
+                GC.start; x.report('yaml') { n.times { YAML.dump(big_data, "") } }
+                GC.start; x.report('zaml') { n.times { ZAML.dump(big_data, "") } }
+                n = n/10
+                }
+            end
+        end
+    def test_deeply_nested_arrays
+        branch = []
+        root = [branch]
+        (1..10000).each { |i|
+            case
+              when i % 3 == 0   then branch << i
+              when 1 % 5 == 0   then branch << [i]
+              else                   branch = [];     root << branch
+              end
+            }
+        puts
+        puts "dump time for deeply nested arrays:"
+        Benchmark.bm do |x|
+            n = 10
+            GC.start; x.report('yaml') { n.times { YAML.dump(root, "") } }
+            GC.start; x.report('zaml') { n.times { ZAML.dump(root, "") } }
+            end
+        end
+    def test_lots_of_back_refs
+        leaves = ['a string',[:an,:array,:of,:symbols],{:this=>'is a hash'},0..9,'a'*10000]
+        branch = []
+        root = [branch]
+        (1..500000).each { |i|
+            case
+              when i % 3 == 0   then branch << leaves[i % leaves.length]
+              when 1 % 5 == 0   then branch << leaves
+              when 1 % 2 == 0   then branch << root[i % root.length]
+              else                   branch = []; root << branch
+              end
+            }
+        puts
+        puts "dump time for lots of back references:"
+        Benchmark.bm do |x|
+            GC.start; x.report('yaml') { YAML.dump(root, "") }
+            GC.start; x.report('zaml') { ZAML.dump(root, "") }
+            end
+        end
+    class A_node
+        attr_accessor :value,:factors,:gcd_pairs
+        def initialize(v)
+            @value = v
+            @factors = []
+            @gcd_pairs = []
+            end
+        end
+    def gcd(a,b)
+        (b == 0) ? a : gcd(b,a % b)
+        end
+    def test_nest_of_objects
+        my_mess = []
+        n = 1000
+        (0..n).each { |i| my_mess << A_node.new(i) }
+        (1..n).each { |i| 
+            (2..(n/i)).each { |j| my_mess[j].factors << my_mess[i]  }
+            (i..n).each { |j| my_mess[gcd(i,j)].gcd_pairs << [i,j] }
+            }
+        puts
+        puts "dump time for big, tangled nest of objects:"
+        Benchmark.bm do |x|
+            GC.start; x.report('yaml') { YAML.dump(my_mess, "") }
+            GC.start; x.report('zaml') { ZAML.dump(my_mess, "") }
+            end
+        end
+    end

data/test/zaml_test.rb

@@ -0,0 +1,420 @@
+require 'test/unit'
+require 'yaml'
+require 'zaml'
+
+class My_class
+    def initialize
+        @string = 'string...'
+        @self = self
+        @do_not_store_me = '*************** SHOULD NOT SHOW UP IN OUTPUT ***************'
+        end
+    def to_yaml_properties
+        ['@string', '@self']
+        end
+    end
+
+class ZamlDumpTest < Test::Unit::TestCase
+    #
+    # This class and the test helper which follow embody what we mean by YAML compatibility.
+    #     When we do a round-trip dump->load we expect
+    #        1) that the data from ZAML.dump will come back correctly
+    #            1a) all vales will be correct
+    #            1b) only data that should be dumped is
+    #            1c) object identity is preseved
+    #        2) if YAML.dump also works by these standards the dumped data should 
+    #           generally look like what yaml.rb produces, minus unneeded whitespace
+    #           (trailing blanks, etc.)
+    class Equivalency < Hash
+        attr_reader :result,:message
+        def self.test(a,b)
+            new.test(a,b)
+            end
+        def test(a,b)
+            @result = equivalent(a,b)
+            self
+            end
+        def note_failure(msg)
+            (@message ||= '') << msg
+            false
+            end
+        def same_class(a,b)
+            (a.class == b.class) or note_failure("Saw a #{a.class} but expected a #{b.class}\n")
+            end
+        def seen_either_before(a,b)
+            result = (has_key?(a.object_id) or has_key?(b.object_id))
+            (self[a.object_id] = self[b.object_id] = size) unless result or a.is_a? Numeric
+            result
+            end
+        def matched_before(a,b)
+            (self[a.object_id] == self[b.object_id]) or note_failure("#{a.inspect} and #{b.inspect} should refer to the same object.\n")
+            end
+        def same_object(a,b)
+            a.object_id == b.object_id
+            end
+        def guess_maping(a,b)
+            result = {}
+            a.delete_if { |xa| result[xa] = b.delete(xa) }
+            raise "Too many odd keys in a test hash to tell if the results are correct." if a.length > 1
+            a.each      { |xa| result[xa] = b.pop }
+            result
+            end
+        def same_properties(a,b)
+            @what_we_are_looking_at ||= []
+            return true if @what_we_are_looking_at.include? [a.object_id,b.object_id]
+            @what_we_are_looking_at.push [a.object_id,b.object_id]
+            result = case a
+              when Array 
+                (a.length == b.length) and a.zip(b).all? { |ia,ib| equivalent(ia,ib) }
+              when Hash 
+                key_map = guess_maping(a.keys,b.keys)
+                a.keys.length == b.keys.length and a.keys.all? {|a_k|
+                     b_k = key_map[a_k]
+                     equivalent(a_k,b_k) and equivalent(a[a_k],b[b_k])
+                     }
+              when Exception
+                equivalent(a.message,b.message)
+              when Time,Date,Numeric,nil,true,false,Range,Symbol,String,Regexp
+                a == b
+              else
+                a.to_yaml_properties.all? { |p| equivalent(a.instance_variable_get(p),b.instance_variable_get(p)) }
+              end or note_failure("Expected:\n #{b.inspect}\n but got:\n #{a.inspect}\n")
+            @what_we_are_looking_at.pop
+            result
+            end 
+        def equivalent(a,b)
+            seen_either_before(a,b) ? matched_before(a,b) : (same_object(a,b) or (same_class(a,b) and same_properties(a,b)))
+            end
+        end
+    def stripped(x)
+        x.gsub(/ +$/,'').chomp.chomp.gsub(/\n+/,"\n")
+        end
+    def dump_test(obj)
+        z_load = YAML.load(z_dump = ZAML.dump(obj)) rescue "ZAML produced something YAML can't load."
+        y_load = YAML.load(y_dump = YAML.dump(obj)) rescue "YAML failed to eat it's own dogfood"
+        context = {}
+        test = Equivalency.test(z_load,obj)
+        assert_block("Reload discrepancy:\n#{test.message}\nZAML:\"\n#{z_dump}\"\nYAML:\"\n#{y_dump}\"\n\n") { test.result }
+#         if Equivalency.test(y_load,obj).result and not obj.is_a? String
+#             assert_equal stripped(y_dump),stripped(z_dump), "Dump discrepancy"
+#             end
+        end
+    #
+    # dump tests
+    #
+      
+    def test_dump_object
+        dump_test(Object.new)
+        dump_test(My_class.new)
+        end
+      
+    def test_dump_nil
+        dump_test(nil)
+        end
+      
+    def test_dump_symbol
+        dump_test(:sym)
+        end
+      
+    def test_dump_true
+        dump_test(true)
+        end
+      
+    def test_dump_false
+        dump_test(false)
+        end
+      
+    def test_dump_numeric
+        dump_test(1)
+        dump_test(1.1)
+        end
+      
+    def test_dump_exception
+        dump_test(Exception.new('error message'))
+        dump_test(ArgumentError.new('error message'))
+        end
+      
+    def test_dump_regexp
+        dump_test(/abc/)
+        dump_test(/a.*(b+)/im)
+        end
+      
+
+    def test_dump_short_strings
+        #
+        every_character = (0..255).collect { |n| n.chr }
+        letters = 'a'..'z'
+        some_characters = (0..128).collect { |n| n.chr } - ('A'..'Z').to_a - ('b'..'z').to_a - ('1'..'9').to_a
+        fewer_characters = some_characters - every_character[1..31] + ["\n","\r","\t","\e"] - [127.chr,128.chr]
+        #
+        every_character.each { |c1| dump_test c1 }
+        every_character.each { |c1| dump_test "> "+c1 }
+        every_character.each { |c1| every_character.each { |c2| dump_test c1+c2 }} 
+        letters.each { |c1| 
+            letters.each { |c2| 
+                print c1,c2,' ',8.chr*3
+                STDOUT.flush
+                letters.each { |c3|
+                    dump_test c1+c2+c3
+                    letters.each { |c4| dump_test c1+c2+c3+c4 }
+                    }
+                }
+            GC.start
+            } if false  #slow
+        some_characters.each { |c1| 
+            some_characters.each { |c2|
+                print((c1+c2).inspect,'        ',8.chr*((c1+c2).inspect.length+8))
+                STDOUT.flush
+                some_characters.each { |c3|
+                    some_characters.each { |c4| dump_test c1+c2+c3+c4 }
+                    }
+                GC.start
+                } 
+            } if false #slower
+        fewer_characters.each { |c1| 
+            fewer_characters.each { |c2|
+                print((c1+c2).inspect,'        ',8.chr*((c1+c2).inspect.length+8))
+                STDOUT.flush
+                fewer_characters.each { |c3|
+                    fewer_characters.each { |c4|
+                        fewer_characters.each { |c5| dump_test c1+c2+c3+c4+c5 }
+                        }
+                    GC.start
+                    } 
+                } 
+            } if false #very slow
+        end
+    def test_system_dict_words
+        system_dict = '/usr/share/dict/words'
+        File.readlines(system_dict).each { |w| dump_test w.chomp } if File.exists?(system_dict)
+        end
+    def test_dump_tricky_strings
+        dump_test("")
+        dump_test("#")
+        dump_test("!")
+        dump_test("~")
+        dump_test("=")
+        dump_test("\n")
+        dump_test("\n0")
+        dump_test("\n!")
+        dump_test("!\n")
+        dump_test("##")
+        dump_test("###")
+        dump_test("2:7")
+        dump_test("1:1 x")
+        dump_test(">")
+        dump_test(">>")
+        dump_test("> >")
+        dump_test("> !")
+        dump_test(">++ !")
+        dump_test(">0+ !")
+        dump_test("| |")
+        dump_test("0:0")
+        dump_test("1:2:3")
+        dump_test("+1:2:3")
+        dump_test("1:-2:+3")
+        dump_test("%.:.")
+        dump_test("%.:/")
+        end
+    def test_dump_string
+        dump_test('str')
+        dump_test("   leading and trailing whitespace   ")
+    
+        dump_test("a string \n with newline")
+        dump_test("a string with 'quotes'")
+        dump_test("a string with \"double quotes\"")
+        dump_test("a string with \\ escape")
+        
+        dump_test("a really long string" * 10)
+        dump_test("a really long string \n with newline" * 10)
+        dump_test("a really long string with 'quotes'" * 10)
+        dump_test("a really long string with \"double quotes\"" * 10)
+        dump_test("a really long string with \\ escape" * 10)
+        
+        dump_test("string with binary data \x00 \x01 \x02")
+        dump_test("   funky\n test\n")
+        dump_test('"')
+        dump_test("'")
+        dump_test('\\')
+        dump_test("k: v")
+        dump_test(":goo")
+        dump_test("? foo")
+        dump_test("{khkjh}")
+        dump_test("[ha]")
+        dump_test("- - (text) - -")
+        dump_test("\n\n \n  \n   x\n  y\n z\n!\n")
+        end
+    
+    def test_dump_strings_that_resemble_literals
+        dump_test("true")
+        dump_test("false")
+        dump_test("null")
+        dump_test("yes")
+        dump_test("no")
+        dump_test("on")
+        dump_test("off")
+        dump_test("nil")
+        dump_test("3")
+        dump_test("3.14")
+        dump_test("1e-6")
+        dump_test("0x345")
+        dump_test("-0x345")
+        dump_test("1e5")
+        end
+      
+    def test_dump_time
+        dump_test(Time.now)
+        end
+      
+    def test_dump_date
+        dump_test(Date.strptime('2008-08-08'))
+        end
+      
+    def test_dump_range
+        dump_test(1..10)
+        dump_test('a'...'b')
+        end
+      
+    #
+    # hash
+    #
+      
+    def test_dump_simple_hash
+        dump_test({:key => 'value'})
+        end
+      
+    HASH = {
+        :nil => nil,
+        :sym => :value, 
+        :true => true,
+        :false => false,
+        :int => 100,
+        :float => 1.1,
+        :regexp => /abc/,
+        'str' => 'value', 
+        :range => 1..10
+        }
+      
+    ARRAY = [nil, :sym, true, false, 100, 1.1, /abc/, 'str', 1..10]
+      
+    def test_dump_hash
+        dump_test(HASH)
+        end
+      
+    def test_dump_simple_nested_hash
+        dump_test({:hash => {:key => 'value'}, :array => [1,2,3]})
+        end
+      
+    def test_dump_nested_hash
+        dump_test(HASH.merge(:hash => {:hash => {:key => 'value'}}, :array => [[1,2,3]]))
+        end
+      
+    def test_dump_self_referential_hash
+        array = ARRAY + [ARRAY]
+        dump_test(HASH.merge(:hash => HASH, :array => array))
+        end
+      
+    def test_dump_singlular_self_referential_hash
+        hash = {}
+        hash[hash] = hash
+        dump_test(hash)
+        end
+      
+    #
+    # array
+    #
+      
+    def test_dump_simple_array
+        dump_test([1,2,3])
+        end
+       
+    def test_dump_array
+        dump_test(ARRAY)
+        end
+      
+    def test_dump_simple_nested_array
+        dump_test([{:key => 'value'}, [1,2,3]])
+        end
+      
+    def test_dump_nested_array
+        dump_test(ARRAY.concat([{:array => [1,2,3]}, [[1,2,3]]]))
+        end
+      
+    def test_dump_self_referential_array
+        array = ARRAY + [ARRAY, HASH.merge(:hash => HASH)]
+        dump_test(array)
+        end
+      
+    def test_dump_singlular_self_referential_array
+        array = []
+        array << array
+        dump_test(array)
+        end
+      
+    #
+    # dump various data tests
+    #
+      
+    my_range = 7..13
+    my_obj = My_class.new
+    my_dull_object = Object.new
+    my_bob = 'bob'
+    my_exception = Exception.new("Error message")
+    my_runtime_error = RuntimeError.new("This is a runtime error exception")
+    wright_joke = %q{
+    
+        I was in the grocery store. I saw a sign that said "pet supplies". 
+    
+        So I did.
+    
+        Then I went outside and saw a sign that said "compact cars".
+    
+        -- Steven Wright
+        }
+    a_box_of_cheese = [:cheese]
+    DATA = [1, my_range, my_obj, my_bob, my_dull_object, 2, 'test', "   funky\n test\n", true, false, 
+        {my_obj => 'obj is the key!'}, 
+        {:bob => 6.8, :sam => 9.7, :subhash => {:sh1 => 'one', :sh2 => 'two'}}, 
+        6, my_bob, my_obj, my_range, 'bob', 1..10, 0...8]
+    MORE_DATA = [{
+        :a_regexp => /a.*(b+)/im,
+        :an_exception => my_exception,
+        :a_runtime_error => my_runtime_error, 
+        :a_long_string => wright_joke}
+        ]
+    NESTED_ARRAYS = [
+        [:one, 'One'],
+        [:two, 'Two'],
+        a_box_of_cheese,
+        [:three, 'Three'],
+        [:four, 'Four'],
+        a_box_of_cheese,
+        [:five, 'Five'],
+        [:six, 'Six']
+        ]
+    COMPLEX_DATA = {
+        :data => DATA,
+        :more_data => MORE_DATA,
+        :nested_arrays => NESTED_ARRAYS
+        }
+    def test_dump_DATA
+        dump_test(DATA)
+        end
+    def test_dump_MORE_DATA
+        dump_test(MORE_DATA)
+        end
+    def test_dump_NESTED_ARRAYS
+        dump_test(NESTED_ARRAYS)
+        end
+    def test_dump_COMPLEX_DATA
+        dump_test(COMPLEX_DATA)
+        end
+    def test_indentation_array_edge_cases
+        dump_test({[]=>[]})
+        dump_test([[]])
+        dump_test([[[],[]]])
+        end
+    def test_string_identity
+        a = 'str'
+        dump_test([a,a])
+        end
+    end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: zaml
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+platform: ruby
+authors: 
+- Markus Roberts
+- Jesse Hallett
+- Ian McIntosh
+- Igal Koshevoy
+- Simon Chiang
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-03 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: A partial replacement for YAML, writen with speed and code clarity in mind.  ZAML fixes one YAML bug (loading Exceptions) and provides a replacement for YAML.dump() unimaginatively called ZAML.dump(), which is faster on all known cases and an order of magnitude faster with complex structures.
+email: zaml@googlegroups.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- README
+- LICENSE
+- lib/zaml.rb
+- test/zaml_benchmarks.rb
+- test/zaml_test.rb
+has_rdoc: true
+homepage: http://github.com/hallettj/zaml
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 3
+summary: A partial replacement for YAML, writen with speed and code clarity in mind.
+test_files: 
+- test/zaml_benchmarks.rb
+- test/zaml_test.rb