From a706d6ddac4d79e20621e97ee83ad8ef919aebe6 Mon Sep 17 00:00:00 2001 From: why Date: Fri, 11 Jul 2003 23:56:42 +0000 Subject: BaseEmitter left out as well. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@4068 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- lib/yaml/baseemitter.rb | 241 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 241 insertions(+) create mode 100644 lib/yaml/baseemitter.rb diff --git a/lib/yaml/baseemitter.rb b/lib/yaml/baseemitter.rb new file mode 100644 index 0000000000..007ee7be5e --- /dev/null +++ b/lib/yaml/baseemitter.rb @@ -0,0 +1,241 @@ +# +# BaseEmitter +# + +require 'yaml/constants' +require 'yaml/encoding' +require 'yaml/error' + +module YAML + + module BaseEmitter + + def options( opt = nil ) + if opt + @options[opt] || YAML::DEFAULTS[opt] + else + @options + end + end + + def options=( opt ) + @options = opt + end + + # + # Emit binary data + # + def binary_base64( value ) + self << "!binary " + self.node_text( [value].pack("m"), '|' ) + end + + # + # Emit plain, normal flowing text + # + def node_text( value, block = '>' ) + @seq_map = false + valx = value.dup + if options(:UseBlock) + block = '|' + elsif not options(:UseFold) and valx =~ /\n[ \t]/ and not valx =~ /#{YAML::ESCAPE_CHAR}/ + block = '|' + end + str = block.dup + if valx =~ /\n\Z\n/ + str << "+" + elsif valx =~ /\Z\n/ + else + str << "-" + end + if valx =~ /#{YAML::ESCAPE_CHAR}/ + valx = YAML::escape( valx ) + end + if valx =~ /\A[ \t#]/ + str << options(:Indent).to_s + end + if block == '>' + valx = fold( valx ) + end + self << str + indent_text( valx ) + "\n" + end + + # + # Emit a simple, unqouted string + # + def simple( value ) + @seq_map = false + self << value.to_s + end + + # + # Emit double-quoted string + # + def double( value ) + "\"#{YAML.escape( value )}\"" + end + + # + # Emit single-quoted string + # + def single( value ) + "'#{value}'" + end + + # + # Write a text block with the current indent + # + def indent_text( text ) + return "" if text.to_s.empty? + spacing = " " * ( level * options(:Indent) ) + return "\n" + text.gsub( /^([^\n])/, "#{spacing}\\1" ) + end + + # + # Write a current indent + # + def indent + #p [ self.id, @level, :INDENT ] + return " " * ( level * options(:Indent) ) + end + + # + # Add indent to the buffer + # + def indent! + self << indent + end + + # + # Folding paragraphs within a column + # + def fold( value ) + value.gsub!( /\A\n+/, '' ) + folded = $&.to_s + width = (0..options(:BestWidth)) + while not value.empty? + last = value.index( /(\n+)/ ) + chop_s = false + if width.include?( last ) + last += $1.length - 1 + elsif width.include?( value.length ) + last = value.length + else + last = value.rindex( /[ \t]/, options(:BestWidth) ) + chop_s = true + end + folded += value.slice!( 0, width.include?( last ) ? last + 1 : options(:BestWidth) ) + folded.chop! if chop_s + folded += "\n" unless value.empty? + end + folded + end + + # + # Quick mapping + # + def map( type, &e ) + val = Mapping.new + e.call( val ) + self << "#{type} " if type.length.nonzero? + + # + # Empty hashes + # + if val.length.zero? + self << "{}" + @seq_map = false + else + # FIXME + # if @buffer.length == 1 and options(:UseHeader) == false and type.length.zero? + # @headless = 1 + # end + + defkey = @options.delete( :DefaultKey ) + if defkey + seq_map_shortcut + self << "= : " + defkey.to_yaml( :Emitter => self ) + end + + # + # Emit the key and value + # + val.each { |v| + seq_map_shortcut + if v[0].is_complex_yaml? + self << "? " + end + v[0].to_yaml( :Emitter => self ) + if v[0].is_complex_yaml? + self << "\n" + indent! + end + self << ": " + v[1].to_yaml( :Emitter => self ) + } + end + end + + def seq_map_shortcut + # FIXME: seq_map needs to work with the new anchoring system + # if @seq_map + # @anchor_extras[@buffer.length - 1] = "\n" + indent + # @seq_map = false + # else + self << "\n" + indent! + # end + end + + # + # Quick sequence + # + def seq( type, &e ) + @seq_map = false + val = Sequence.new + e.call( val ) + self << "#{type} " if type.length.nonzero? + + # + # Empty arrays + # + if val.length.zero? + self << "[]" + else + # FIXME + # if @buffer.length == 1 and options(:UseHeader) == false and type.length.zero? + # @headless = 1 + # end + + # + # Emit the key and value + # + val.each { |v| + self << "\n" + indent! + self << "- " + @seq_map = true if v.class == Hash + v.to_yaml( :Emitter => self ) + } + end + end + + end + + # + # Emitter helper classes + # + class Mapping < Array + def add( k, v ) + push [k, v] + end + end + + class Sequence < Array + def add( v ) + push v + end + end + +end -- cgit v1.2.3