summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorakr <akr@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>2001-12-24 17:38:33 +0000
committerakr <akr@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>2001-12-24 17:38:33 +0000
commita2ba32fab9b2bc0d968cfd77f62385beff67042d (patch)
tree6509e67f3b25a24630f75800e75d7c6bb994a86c
parent428269821916bf8ed7c058340640edd8105cf599 (diff)
lib/pp.rb lib/prettyprint.rb: new file.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@1936 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
-rw-r--r--MANIFEST2
-rw-r--r--lib/pp.rb549
-rw-r--r--lib/prettyprint.rb681
3 files changed, 1232 insertions, 0 deletions
diff --git a/MANIFEST b/MANIFEST
index 099506d..bff2d85 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -164,6 +164,8 @@ lib/ostruct.rb
lib/parsearg.rb
lib/parsedate.rb
lib/ping.rb
+lib/pp.rb
+lib/prettyprint.rb
lib/profile.rb
lib/pstore.rb
lib/rational.rb
diff --git a/lib/pp.rb b/lib/pp.rb
new file mode 100644
index 0000000..7178c5c
--- /dev/null
+++ b/lib/pp.rb
@@ -0,0 +1,549 @@
+# $Id$
+
+=begin
+= Pretty-printer for Ruby objects.
+
+== Which seems better?
+
+non-pretty-printed output by (({p})) is:
+ #<PP:0x806486c @stack=[], @nest=[0], @buf=#<PP::Group:0x8064844 @tail=0, @singleline_length=9, @buf=[#<PP::Group:0x80647cc @tail=0, @singleline_length=9, @buf=[#<PP::Text:0x8064768 @text="[">, #<PP::Group:0x80646c8 @tail=1, @singleline_length=1, @buf=[#<PP::Text:0x8064664 @text="1">]>, #<PP::Text:0x80646b4 @text=",">, #<PP::Breakable:0x8064650 @indent=1, @sep=" ">, #<PP::Group:0x8064614 @tail=1, @singleline_length=1, @buf=[#<PP::Text:0x80645b0 @text="2">]>, #<PP::Text:0x8064600 @text=",">, #<PP::Breakable:0x806459c @indent=1, @sep=" ">, #<PP::Group:0x8064560 @tail=1, @singleline_length=1, @buf=[#<PP::Text:0x80644fc @text="3">]>, #<PP::Text:0x806472c @text="]">]>]>>
+
+pretty-printed output by (({pp})) is:
+ #<PP:0x403279c
+ @buf=
+ #<PP::Group:0x4032666
+ @buf=
+ [#<PP::Group:0x4032666
+ @buf=
+ [#<PP::Text:0x40326de @text="[">,
+ #<PP::Group:0x4032666
+ @buf=[#<PP::Text:0x40326de @text="1">],
+ @singleline_length=1,
+ @tail=1>,
+ #<PP::Text:0x40326de @text=",">,
+ #<PP::Breakable:0x40326b6 @indent=1, @sep=" ">,
+ #<PP::Group:0x4032666
+ @buf=[#<PP::Text:0x40326de @text="2">],
+ @singleline_length=1,
+ @tail=1>,
+ #<PP::Text:0x40326de @text=",">,
+ #<PP::Breakable:0x40326b6 @indent=1, @sep=" ">,
+ #<PP::Group:0x4032666
+ @buf=[#<PP::Text:0x40326de @text="3">],
+ @singleline_length=1,
+ @tail=1>,
+ #<PP::Text:0x40326de @text="]">],
+ @singleline_length=9,
+ @tail=0>],
+ @singleline_length=9,
+ @tail=0>,
+ @nest=[0],
+ @stack=[]>
+
+I like the latter. If you do too, this library is for you.
+
+== Usage
+
+: pp(obj)
+ output ((|obj|)) to (({$>})) in pretty printed format.
+
+== Customized output
+To define your customized pretty printing function for your class,
+redefine a method (({pretty_print(((|pp|)))})) in the class.
+It takes an argument ((|pp|)) which is an instance of the class ((<PP>)).
+The method should use PP#text, PP#breakable, PP#nest, PP#group and
+PP#pp to print the object.
+
+= PP
+== super class
+((<PrettyPrint>))
+
+== class methods
+--- PP.pp(obj[, width[, out]])
+ outputs ((|obj|)) to ((|out|)) in pretty printed format of
+ ((|width|)) columns in width.
+
+--- PP.sharing_detection
+ returns the sharing detection flag as boolean value.
+ It is false by default.
+
+--- PP.sharing_detection = value
+ sets the sharing detection flag.
+
+== methods
+--- pp(obj)
+ adds ((|obj|)) to the pretty printing buffer
+ using Object#pretty_print or Object#pretty_print_cycled.
+
+ Object#pretty_print_cycled is used when ((|obj|)) is already
+ printed, a.k.a the object reference chain has a cycle.
+
+= Object
+--- pretty_print(pp)
+ is a default pretty printing method for general objects.
+
+ If (({self})) has a customized (redefined) (({inspect})) method,
+ the result of (({self.inspect})) is used but it obviously has no
+ line break hints.
+
+ This module provides predefined pretty_print() methods for some of
+ the most commonly used built-in classes for convenience.
+
+--- pretty_print_cycled(pp)
+ is a default pretty printing method for general objects that are
+ detected as part of a cycle.
+=end
+
+require 'prettyprint'
+
+module Kernel
+ private
+ def pp(*objs)
+ objs.each {|obj|
+ PP.pp(obj)
+ }
+ end
+end
+
+class PP < PrettyPrint
+ def PP.pp(obj, width=79, out=$>)
+ pp = PP.new
+ pp.guard_inspect_key {pp.pp obj}
+ pp.format(out, width)
+ out << "\n"
+ end
+
+ @@sharing_detection = false
+ def PP.sharing_detection
+ return @@sharing_detection
+ end
+
+ def PP.sharing_detection=(val)
+ @@sharing_detection = val
+ end
+
+ def initialize
+ super
+ @sharing_detection = @@sharing_detection
+ end
+
+ InspectKey = :__inspect_key__
+
+ def guard_inspect_key
+ if Thread.current[InspectKey] == nil
+ Thread.current[InspectKey] = []
+ end
+
+ save = Thread.current[InspectKey]
+
+ begin
+ Thread.current[InspectKey] = []
+ yield
+ ensure
+ Thread.current[InspectKey] = save
+ end
+ end
+
+ def pp(obj)
+ id = obj.__id__
+
+ if Thread.current[InspectKey].include? id
+ group {obj.pretty_print_cycled self}
+ return
+ end
+
+ begin
+ Thread.current[InspectKey] << id
+ group {obj.pretty_print self}
+ ensure
+ Thread.current[InspectKey].pop unless @sharing_detection
+ end
+ end
+
+ def pp_object(obj)
+ group {
+ text '#<'
+ nest(1) {
+ text obj.class.name
+ text ':'
+ text sprintf('0x%x', obj.__id__)
+ first = true
+ obj.instance_variables.sort.each {|v|
+ if first
+ first = false
+ else
+ text ','
+ end
+ breakable
+ group {
+ text v
+ text '='
+ nest(1) {
+ breakable ''
+ pp(obj.instance_eval v)
+ }
+ }
+ }
+ }
+ text '>'
+ }
+ end
+
+ def pp_hash(obj)
+ group {
+ text '{'
+ nest(1) {
+ first = true
+ obj.each {|k, v|
+ if first
+ first = false
+ else
+ text ","
+ breakable
+ end
+ group {
+ pp k
+ text '=>'
+ nest(1) {
+ group {
+ breakable ''
+ pp v
+ }
+ }
+ }
+ }
+ }
+ text '}'
+ }
+ end
+
+ module ObjectMixin
+ # 1. specific pretty_print
+ # 2. specific inspect
+ # 3. generic pretty_print
+
+ Key = :__pp_instead_of_inspect__
+
+ def pretty_print(pp)
+ # specific pretty_print is not defined, try specific inspect.
+ begin
+ old = Thread.current[Key]
+ result1 = sprintf('#<%s:0x%x pretty_printed>', self.class.name, self.__id__)
+ Thread.current[Key] = [pp, result1]
+ result2 = ObjectMixin.pp_call_inspect(self)
+ ensure
+ Thread.current[Key] = old
+ end
+
+ unless result1.equal? result2
+ pp.text result2
+ end
+ end
+
+ def ObjectMixin.pp_call_inspect(obj); obj.inspect; end
+ CallInspectFrame = "#{__FILE__}:#{__LINE__ - 1}:in `pp_call_inspect'"
+
+ def inspect
+ if CallInspectFrame == caller[0]
+ # specific inspect is also not defined, use generic pretty_print.
+ pp, result = Thread.current[Key]
+ pp.pp_object(self)
+ result
+ else
+ super
+ end
+ end
+
+ def pretty_print_cycled(pp)
+ pp.text sprintf("#<%s:0x%x", self.class.name, self.__id__)
+ pp.breakable
+ pp.text sprintf("...>")
+ end
+ end
+end
+
+[Numeric, FalseClass, TrueClass, Module].each {|c|
+ c.class_eval {
+ def pretty_print(pp)
+ pp.text self.to_s
+ end
+ }
+}
+
+class Array
+ def pretty_print(pp)
+ pp.text "["
+ pp.nest(1) {
+ first = true
+ self.each {|v|
+ if first
+ first = false
+ else
+ pp.text ","
+ pp.breakable
+ end
+ pp.pp v
+ }
+ }
+ pp.text "]"
+ end
+
+ def pretty_print_cycled(pp)
+ pp.text(empty? ? '[]' : '[...]')
+ end
+end
+
+class Hash
+ def pretty_print(pp)
+ pp.pp_hash self
+ end
+
+ def pretty_print_cycled(pp)
+ pp.text(empty? ? '{}' : '{...}')
+ end
+end
+
+class << ENV
+ def pretty_print(pp)
+ pp.pp_hash self
+ end
+end
+
+class Struct
+ def pretty_print(pp)
+ pp.text sprintf("#<%s", self.class.name)
+ pp.nest(1) {
+ first = true
+ self.members.each {|member|
+ if first
+ first = false
+ else
+ pp.text ","
+ end
+ pp.breakable
+ pp.group {
+ pp.text member.to_s
+ pp.text '='
+ pp.nest(1) {
+ pp.breakable ''
+ pp.pp self[member]
+ }
+ }
+ }
+ }
+ pp.text ">"
+ end
+
+ def pretty_print_cycled(pp)
+ pp.text sprintf("#<%s:...>", self.class.name)
+ end
+end
+
+class Range
+ def pretty_print(pp)
+ pp.pp self.begin
+ pp.breakable ''
+ pp.text(self.exclude_end? ? '...' : '..')
+ pp.breakable ''
+ pp.pp self.end
+ end
+end
+
+class File
+ class Stat
+ def pretty_print(pp)
+ require 'etc.so'
+ pp.nest(1) {
+ pp.text "#<"
+ pp.text self.class.name
+ pp.breakable; pp.text "dev="; pp.pp self.dev; pp.text ','
+ pp.breakable; pp.text "ino="; pp.pp self.ino; pp.text ','
+ pp.breakable
+ pp.group {
+ m = self.mode
+ pp.text "mode="; pp.pp m
+ pp.breakable
+ pp.text sprintf("(0%o %s %c%c%c%c%c%c%c%c%c)",
+ m, self.ftype,
+ (m & 0400 == 0 ? ?- : ?r),
+ (m & 0200 == 0 ? ?- : ?w),
+ (m & 0100 == 0 ? (m & 04000 == 0 ? ?- : ?S) :
+ (m & 04000 == 0 ? ?x : ?s)),
+ (m & 0040 == 0 ? ?- : ?r),
+ (m & 0020 == 0 ? ?- : ?w),
+ (m & 0010 == 0 ? (m & 02000 == 0 ? ?- : ?S) :
+ (m & 02000 == 0 ? ?x : ?s)),
+ (m & 0004 == 0 ? ?- : ?r),
+ (m & 0002 == 0 ? ?- : ?w),
+ (m & 0001 == 0 ? (m & 01000 == 0 ? ?- : ?T) :
+ (m & 01000 == 0 ? ?x : ?t)))
+ pp.text ','
+ }
+ pp.breakable; pp.text "nlink="; pp.pp self.nlink; pp.text ','
+ pp.breakable
+ pp.group {
+ pp.text "uid="; pp.pp self.uid
+ begin
+ name = Etc.getpwuid(self.uid).name
+ pp.breakable; pp.text "(#{name})"
+ rescue ArgumentError
+ end
+ pp.text ','
+ }
+ pp.breakable
+ pp.group {
+ pp.text "gid="; pp.pp self.gid
+ begin
+ name = Etc.getgrgid(self.gid).name
+ pp.breakable; pp.text "(#{name})"
+ rescue ArgumentError
+ end
+ pp.text ','
+ }
+ pp.breakable; pp.text "rdev="; pp.pp self.rdev; pp.text ','
+ pp.breakable; pp.text "size="; pp.pp self.size; pp.text ','
+ pp.breakable; pp.text "blksize="; pp.pp self.blksize; pp.text ','
+ pp.breakable; pp.text "blocks="; pp.pp self.blocks; pp.text ','
+ pp.breakable
+ pp.group {
+ t = self.atime
+ pp.text "atime="; pp.pp t
+ pp.breakable; pp.text "(#{t.tv_sec})"
+ pp.text ','
+ }
+ pp.breakable
+ pp.group {
+ t = self.mtime
+ pp.text "mtime="; pp.pp t
+ pp.breakable; pp.text "(#{t.tv_sec})"
+ pp.text ','
+ }
+ pp.breakable
+ pp.group {
+ t = self.ctime
+ pp.text "ctime="; pp.pp t
+ pp.breakable; pp.text "(#{t.tv_sec})"
+ }
+ pp.text ">"
+ }
+ end
+ end
+end
+
+class Object
+ include PP::ObjectMixin
+end
+
+[Numeric, Symbol, FalseClass, TrueClass, NilClass, Module].each {|c|
+ c.class_eval {
+ alias :pretty_print_cycled :pretty_print
+ }
+}
+
+if __FILE__ == $0
+ require 'runit/testcase'
+ require 'runit/cui/testrunner'
+
+ class PPTest < RUNIT::TestCase
+ def test_list0123_12
+ assert_equal("[0, 1, 2, 3]\n", PP.pp([0,1,2,3], 12, ''))
+ end
+
+ def test_list0123_11
+ assert_equal("[0,\n 1,\n 2,\n 3]\n", PP.pp([0,1,2,3], 11, ''))
+ end
+ end
+
+ class HasInspect
+ def initialize(a)
+ @a = a
+ end
+
+ def inspect
+ return "<inspect:#{@a.inspect}>"
+ end
+ end
+
+ class HasPrettyPrint
+ def initialize(a)
+ @a = a
+ end
+
+ def pretty_print(pp)
+ pp.text "<pretty_print:"
+ pp.pp @a
+ pp.text ">"
+ end
+ end
+
+ class HasBoth
+ def initialize(a)
+ @a = a
+ end
+
+ def inspect
+ return "<inspect:#{@a.inspect}>"
+ end
+
+ def pretty_print(pp)
+ pp.text "<pretty_print:"
+ pp.pp @a
+ pp.text ">"
+ end
+ end
+
+ class PPInspectTest < RUNIT::TestCase
+ def test_hasinspect
+ a = HasInspect.new(1)
+ assert_equal("<inspect:1>\n", PP.pp(a, 79, ''))
+ end
+
+ def test_hasprettyprint
+ a = HasPrettyPrint.new(1)
+ assert_equal("<pretty_print:1>\n", PP.pp(a, 79, ''))
+ end
+
+ def test_hasboth
+ a = HasBoth.new(1)
+ assert_equal("<pretty_print:1>\n", PP.pp(a, 79, ''))
+ end
+ end
+
+ class PPCycleTest < RUNIT::TestCase
+ def test_array
+ a = []
+ a << a
+ assert_equal("[[...]]\n", PP.pp(a, 79, ''))
+ end
+
+ def test_hash
+ a = {}
+ a[0] = a
+ assert_equal("{0=>{...}}\n", PP.pp(a, 79, ''))
+ end
+
+ S = Struct.new("S", :a, :b)
+ def test_struct
+ a = S.new(1,2)
+ a.b = a
+ assert_equal("#<Struct::S a=1, b=#<Struct::S:...>>\n", PP.pp(a, 79, ''))
+ end
+
+ def test_object
+ a = Object.new
+ a.instance_eval {@a = a}
+ hex = '0x' + ('%x'%a.id)
+ assert_equal("#<Object:#{hex} @a=#<Object:#{hex} ...>>\n", PP.pp(a, 79, ''))
+ end
+
+ def test_withinspect
+ a = []
+ a << HasInspect.new(a)
+ assert_equal("[<inspect:[...]>]\n", PP.pp(a, 79, ''))
+ end
+ end
+
+ RUNIT::CUI::TestRunner.run(PPTest.suite)
+ RUNIT::CUI::TestRunner.run(PPInspectTest.suite)
+ RUNIT::CUI::TestRunner.run(PPCycleTest.suite)
+end
diff --git a/lib/prettyprint.rb b/lib/prettyprint.rb
new file mode 100644
index 0000000..6d4a6f9
--- /dev/null
+++ b/lib/prettyprint.rb
@@ -0,0 +1,681 @@
+# $Id$
+
+=begin
+= PrettyPrint
+The class implements pretty printing algorithm.
+It finds line breaks and nice indentations for grouped structure.
+
+By default, the class assumes that primitive elements are strings and
+each byte in the strings have single column in width.
+But it can be used for other situasions
+by giving suitable arguments for some methods:
+newline object and space generation block for (({PrettyPrint.new})),
+optional width argument for (({PrettyPrint#text})),
+(({PrettyPrint#breakable})), etc.
+There are several candidates to use them:
+text formatting using proportional fonts,
+multibyte characters which has columns diffrent to number of bytes,
+non-string formatting, etc.
+
+== class methods
+--- PrettyPrint.new([newline]) [{|width| ...}]
+ creates a buffer for pretty printing.
+
+ ((|newline|)) is used for line breaks.
+ (({"\n"})) is used if it is not specified.
+
+ The block is used to generate spaces.
+ (({{|width| ' ' * width}})) is used if it is not given.
+
+== methods
+--- text(obj[, width])
+ adds ((|obj|)) as a text of ((|width|)) columns in width.
+
+ If ((|width|)) is not specified, (({((|obj|)).length})) is used.
+
+--- breakable([sep[, width]])
+ tells "you can break a line here if necessary", and a
+ ((|width|))-column text ((|sep|)) is inserted if a line is not
+ broken at the point.
+
+ If ((|sep|)) is not specified, (({" "})) is used.
+
+ If ((|width|)) is not specified, (({((|sep|)).length})) is used.
+ You will have to specify this when ((|sep|)) is a multibyte
+ character, for example.
+
+--- nest(indent) {...}
+ increases left margin after newline with ((|indent|)) for line breaks added in the block.
+
+--- group {...}
+ groups line break hints added in the block.
+
+--- format(out[, width])
+ outputs buffered data to ((|out|)).
+ It tries to restrict the line length to ((|width|)) but it may
+ overflow.
+
+ If ((|width|)) is not specified, 79 is assumed.
+
+ ((|out|)) must have a method named (({<<})) which accepts
+ a first argument ((|obj|)) of (({PrettyPrint#text})),
+ a first argument ((|sep|)) of (({PrettyPrint#breakable})),
+ a first argument ((|newline|)) of (({PrettyPrint.new})),
+ and
+ a result of a given block for (({PrettyPrint.new})).
+
+== Bugs
+* Line breaks in a group is constrained to whether all line break hints are
+ to be breaked or not. Maybe, non-constrained version of
+ PrettyPrint#group should be provided to filling multi lines.
+
+* Box based formatting?
+
+== References
+Strictly Pretty, Christian Lindig, March 2000,
+((<URL:http://www.gaertner.de/~lindig/papers/strictly-pretty.html>))
+
+A prettier printer, Philip Wadler, March 1998,
+((<URL:http://cm.bell-labs.com/cm/cs/who/wadler/topics/recent.html#prettier>))
+
+=end
+
+class PrettyPrint
+ def initialize(newline="\n", &genspace)
+ @newline = newline
+ @genspace = genspace || lambda {|n| ' ' * n}
+ @buf = Group.new
+ @nest = [0]
+ @stack = []
+ end
+
+ def text(obj, width=obj.length)
+ @buf << Text.new(obj, width)
+ end
+
+ def breakable(sep=' ', width=sep.length)
+ @buf << Breakable.new(sep, width, @nest.last, @newline, @genspace)
+ end
+
+ def nest(indent)
+ nest_enter(indent)
+ begin
+ yield
+ ensure
+ nest_leave
+ end
+ end
+
+ def nest_enter(indent)
+ @nest << @nest.last + indent
+ end
+
+ def nest_leave
+ @nest.pop
+ end
+
+ def group
+ group_enter
+ begin
+ yield
+ ensure
+ group_leave
+ end
+ end
+
+ def group_enter
+ g = Group.new
+ @buf << g
+ @stack << @buf
+ @buf = g
+ end
+
+ def group_leave
+ @buf = @stack.pop
+ end
+
+ def format(out, width=79)
+ tails = [[-1, 0]]
+ @buf.update_tails(tails, 0)
+ @buf.multiline_output(out, 0, 0, width)
+ end
+
+ class Text
+ def initialize(text, width)
+ @text = text
+ @width = width
+ end
+
+ def update_tails(tails, group)
+ tails[-1][1] += @width
+ end
+
+ def singleline_width
+ return @width
+ end
+
+ def singleline_output(out)
+ out << @text
+ end
+
+ def multiline_output(out, group, margin, width)
+ singleline_output(out)
+ return margin + singleline_width
+ end
+ end
+
+ class Breakable
+ def initialize(sep, width, indent, newline, genspace)
+ @sep = sep
+ @width = width
+ @indent = indent
+ @newline = newline
+ @genspace = genspace
+ end
+
+ def update_tails(tails, group)
+ if group == tails[-1][0]
+ tails[-2][1] += @width + tails[-1][1]
+ tails[-1][1] = 0
+ else
+ tails[-1][1] += @width
+ tails << [group, 0]
+ end
+ end
+
+ def singleline_width
+ return @width
+ end
+
+ def singleline_output(out)
+ out << @sep
+ end
+
+ def multiline_output(out, group, margin, width)
+ out << @newline
+ out << @genspace.call(@indent)
+ return @indent
+ end
+ end
+
+ class Group
+ def initialize
+ @buf = []
+ @singleline_width = nil
+ end
+
+ def <<(obj)
+ @buf << obj
+ end
+
+ def update_tails(tails, group)
+ @tail = tails.empty? ? 0 : tails[-1][1]
+ len = 0
+ @buf.reverse_each {|obj|
+ obj.update_tails(tails, group + 1)
+ len += obj.singleline_width
+ }
+ @singleline_width = len
+ while !tails.empty? && group <= tails[-1][0]
+ tails[-2][1] += tails[-1][1]
+ tails.pop
+ end
+ end
+
+ def singleline_width
+ return @singleline_width
+ end
+
+ def singleline_output(out)
+ @buf.each {|obj| obj.singleline_output(out)}
+ end
+
+ def multiline_output(out, group, margin, width)
+ if margin + singleline_width + @tail <= width
+ singleline_output(out)
+ margin += singleline_width
+ else
+ @buf.each {|obj|
+ margin = obj.multiline_output(out, group + 1, margin, width)
+ }
+ end
+ return margin
+ end
+ end
+end
+
+if __FILE__ == $0
+ require 'runit/testcase'
+ require 'runit/cui/testrunner'
+
+ class WadlerExample < RUNIT::TestCase
+ def setup
+ @hello = PrettyPrint.new
+ @hello.group {
+ @hello.group {
+ @hello.group {
+ @hello.group {
+ @hello.text 'hello'; @hello.breakable; @hello.text 'a'
+ }
+ @hello.breakable; @hello.text 'b'
+ }
+ @hello.breakable; @hello.text 'c'
+ }
+ @hello.breakable; @hello.text 'd'
+ }
+
+ @tree = Tree.new("aaaa", Tree.new("bbbbb", Tree.new("ccc"),
+ Tree.new("dd")),
+ Tree.new("eee"),
+ Tree.new("ffff", Tree.new("gg"),
+ Tree.new("hhh"),
+ Tree.new("ii")))
+ end
+
+ def test_hello_00_06
+ expected = <<'End'.chomp
+hello
+a
+b
+c
+d
+End
+ @hello.format(out='', 0); assert_equal(expected, out)
+ @hello.format(out='', 6); assert_equal(expected, out)
+ end
+
+ def test_hello_07_08
+ expected = <<'End'.chomp
+hello a
+b
+c
+d
+End
+ @hello.format(out='', 7); assert_equal(expected, out)
+ @hello.format(out='', 8); assert_equal(expected, out)
+ end
+
+ def test_hello_09_10
+ expected = <<'End'.chomp
+hello a b
+c
+d
+End
+ @hello.format(out='', 9); assert_equal(expected, out)
+ @hello.format(out='', 10); assert_equal(expected, out)
+ end
+
+ def test_hello_11_12
+ expected = <<'End'.chomp
+hello a b c
+d
+End
+ @hello.format(out='', 11); assert_equal(expected, out)
+ @hello.format(out='', 12); assert_equal(expected, out)
+ end
+
+ def test_hello_13
+ expected = <<'End'.chomp
+hello a b c d
+End
+ @hello.format(out='', 13); assert_equal(expected, out)
+ end
+
+ def test_tree_00_19
+ pp = PrettyPrint.new
+ @tree.show(pp)
+ expected = <<'End'.chomp
+aaaa[bbbbb[ccc,
+ dd],
+ eee,
+ ffff[gg,
+ hhh,
+ ii]]
+End
+ pp.format(out='', 0); assert_equal(expected, out)
+ pp.format(out='', 19); assert_equal(expected, out)
+ end
+
+ def test_tree_20_22
+ pp = PrettyPrint.new
+ @tree.show(pp)
+ expected = <<'End'.chomp
+aaaa[bbbbb[ccc, dd],
+ eee,
+ ffff[gg,
+ hhh,
+ ii]]
+End
+ pp.format(out='', 20); assert_equal(expected, out)
+ pp.format(out='', 22); assert_equal(expected, out)
+ end
+
+ def test_tree_23_43
+ pp = PrettyPrint.new
+ @tree.show(pp)
+ expected = <<'End'.chomp
+aaaa[bbbbb[ccc, dd],
+ eee,
+ ffff[gg, hhh, ii]]
+End
+ pp.format(out='', 23); assert_equal(expected, out)
+ pp.format(out='', 43); assert_equal(expected, out)
+ end
+
+ def test_tree_44
+ pp = PrettyPrint.new
+ @tree.show(pp)
+ pp.format(out='', 44)
+ assert_equal(<<'End'.chomp, out)
+aaaa[bbbbb[ccc, dd], eee, ffff[gg, hhh, ii]]
+End
+ end
+
+ def test_tree_alt_00_18
+ pp = PrettyPrint.new
+ @tree.altshow(pp)
+ expected = <<'End'.chomp
+aaaa[
+ bbbbb[
+ ccc,
+ dd
+ ],
+ eee,
+ ffff[
+ gg,
+ hhh,
+ ii
+ ]
+]
+End
+ pp.format(out='', 0); assert_equal(expected, out)
+ pp.format(out='', 18); assert_equal(expected, out)
+ end
+
+ def test_tree_alt_19_20
+ pp = PrettyPrint.new
+ @tree.altshow(pp)
+ expected = <<'End'.chomp
+aaaa[
+ bbbbb[ ccc, dd ],
+ eee,
+ ffff[
+ gg,
+ hhh,
+ ii
+ ]
+]
+End
+ pp.format(out='', 19); assert_equal(expected, out)
+ pp.format(out='', 20); assert_equal(expected, out)
+ end
+
+ def test_tree_alt_20_49
+ pp = PrettyPrint.new
+ @tree.altshow(pp)
+ expected = <<'End'.chomp
+aaaa[
+ bbbbb[ ccc, dd ],
+ eee,
+ ffff[ gg, hhh, ii ]
+]
+End
+ pp.format(out='', 21); assert_equal(expected, out)
+ pp.format(out='', 49); assert_equal(expected, out)
+ end
+
+ def test_tree_alt_50
+ pp = PrettyPrint.new
+ @tree.altshow(pp)
+ expected = <<'End'.chomp
+aaaa[ bbbbb[ ccc, dd ], eee, ffff[ gg, hhh, ii ] ]
+End
+ pp.format(out='', 50); assert_equal(expected, out)
+ end
+
+ class Tree
+ def initialize(string, *children)
+ @string = string
+ @children = children
+ end
+
+ def show(pp)
+ pp.group {
+ pp.text @string
+ pp.nest(@string.length) {
+ unless @children.empty?
+ pp.text '['
+ pp.nest(1) {
+ first = true
+ @children.each {|t|
+ if first
+ first = false
+ else
+ pp.text ','
+ pp.breakable
+ end
+ t.show(pp)
+ }
+ }
+ pp.text ']'
+ end
+ }
+ }
+ end
+
+ def altshow(pp)
+ pp.group {
+ pp.text @string
+ unless @children.empty?
+ pp.text '['
+ pp.nest(2) {
+ pp.breakable
+ first = true
+ @children.each {|t|
+ if first
+ first = false
+ else
+ pp.text ','
+ pp.breakable
+ end
+ t.altshow(pp)
+ }
+ }
+ pp.breakable
+ pp.text ']'
+ end
+ }
+ end
+
+ end
+ end
+
+ class StrictPrettyExample < RUNIT::TestCase
+ def setup
+ @pp = PrettyPrint.new
+ @pp.group {
+ @pp.group {@pp.nest(2) {
+ @pp.text "if"; @pp.breakable;
+ @pp.group {
+ @pp.nest(2) {
+ @pp.group {@pp.text "a"; @pp.breakable; @pp.text "=="}
+ @pp.breakable; @pp.text "b"}}}}
+ @pp.breakable
+ @pp.group {@pp.nest(2) {
+ @pp.text "then"; @pp.breakable;
+ @pp.group {
+ @pp.nest(2) {
+ @pp.group {@pp.text "a"; @pp.breakable; @pp.text "<<"}
+ @pp.breakable; @pp.text "2"}}}}
+ @pp.breakable
+ @pp.group {@pp.nest(2) {
+ @pp.text "else"; @pp.breakable;
+ @pp.group {
+ @pp.nest(2) {
+ @pp.group {@pp.text "a"; @pp.breakable; @pp.text "+"}
+ @pp.breakable; @pp.text "b"}}}}}
+ end
+
+ def test_00_04
+ expected = <<'End'.chomp
+if
+ a
+ ==
+ b
+then
+ a
+ <<
+ 2
+else
+ a
+ +
+ b
+End
+ @pp.format(out='', 0); assert_equal(expected, out)
+ @pp.format(out='', 4); assert_equal(expected, out)
+ end
+
+ def test_05
+ expected = <<'End'.chomp
+if
+ a
+ ==
+ b
+then
+ a
+ <<
+ 2
+else
+ a +
+ b
+End
+ @pp.format(out='', 5); assert_equal(expected, out)
+ end
+
+ def test_06
+ expected = <<'End'.chomp
+if
+ a ==
+ b
+then
+ a <<
+ 2
+else
+ a +
+ b
+End
+ @pp.format(out='', 6); assert_equal(expected, out)
+ end
+
+ def test_07
+ expected = <<'End'.chomp
+if
+ a ==
+ b
+then
+ a <<
+ 2
+else
+ a + b
+End
+ @pp.format(out='', 7); assert_equal(expected, out)
+ end
+
+ def test_08
+ expected = <<'End'.chomp
+if
+ a == b
+then
+ a << 2
+else
+ a + b
+End
+ @pp.format(out='', 8); assert_equal(expected, out)
+ end
+
+ def test_09
+ expected = <<'End'.chomp
+if a == b
+then
+ a << 2
+else
+ a + b
+End
+ @pp.format(out='', 9); assert_equal(expected, out)
+ end
+
+ def test_10
+ expected = <<'End'.chomp
+if a == b
+then
+ a << 2
+else a + b
+End
+ @pp.format(out='', 10); assert_equal(expected, out)
+ end
+
+ def test_11_31
+ expected = <<'End'.chomp
+if a == b
+then a << 2
+else a + b
+End
+ @pp.format(out='', 11); assert_equal(expected, out)
+ @pp.format(out='', 15); assert_equal(expected, out)
+ @pp.format(out='', 31); assert_equal(expected, out)
+ end
+
+ def test_32
+ expected = <<'End'.chomp
+if a == b then a << 2 else a + b
+End
+ @pp.format(out='', 32); assert_equal(expected, out)
+ end
+
+ end
+
+ class TailGroup < RUNIT::TestCase
+ def test_1
+ pp = PrettyPrint.new
+ pp.group {
+ pp.group {
+ pp.text "abc"
+ pp.breakable
+ pp.text "def"
+ }
+ pp.group {
+ pp.text "ghi"
+ pp.breakable
+ pp.text "jkl"
+ }
+ }
+ pp.format(out='', 10)
+ assert_equal("abc\ndefghi jkl", out)
+ end
+ end
+
+ class NonString < RUNIT::TestCase
+ def setup
+ @pp = PrettyPrint.new('newline') {|n| "#{n} spaces"}
+ @pp.text(3, 3)
+ @pp.breakable(1, 1)
+ @pp.text(3, 3)
+ end
+
+ def test_6
+ @pp.format(out=[], 6)
+ assert_equal([3, "newline", "0 spaces", 3], out)
+ end
+
+ def test_7
+ @pp.format(out=[], 7)
+ assert_equal([3, 1, 3], out)
+ end
+
+ end
+
+ RUNIT::CUI::TestRunner.run(WadlerExample.suite)
+ RUNIT::CUI::TestRunner.run(StrictPrettyExample.suite)
+ RUNIT::CUI::TestRunner.run(TailGroup.suite)
+ RUNIT::CUI::TestRunner.run(NonString.suite)
+end