X-Git-Url: http://nitlanguage.org

diff --git a/lib/core/text/abstract_text.nit b/lib/core/text/abstract_text.nit
index 405eb76..c15901e 100644
--- a/lib/core/text/abstract_text.nit
+++ b/lib/core/text/abstract_text.nit
@@ -495,18 +495,21 @@ abstract class Text
 		end
 	end
 
-	# Justify a self in a space of `length`
+	# Justify `self` in a space of `length`
 	#
 	# `left` is the space ratio on the left side.
 	# * 0.0 for left-justified (no space at the left)
 	# * 1.0 for right-justified (all spaces at the left)
 	# * 0.5 for centered (half the spaces at the left)
 	#
+	# `char`, or `' '` by default, is repeated to pad the empty space.
+	#
 	# Examples
 	#
 	#     assert "hello".justify(10, 0.0)  == "hello     "
 	#     assert "hello".justify(10, 1.0)  == "     hello"
 	#     assert "hello".justify(10, 0.5)  == "  hello   "
+	#     assert "hello".justify(10, 0.5, '.') == "..hello..."
 	#
 	# If `length` is not enough, `self` is returned as is.
 	#
@@ -515,13 +518,14 @@ abstract class Text
 	# REQUIRE: `left >= 0.0 and left <= 1.0`
 	# ENSURE: `self.length <= length implies result.length == length`
 	# ENSURE: `self.length >= length implies result == self`
-	fun justify(length: Int, left: Float): String
+	fun justify(length: Int, left: Float, char: nullable Char): String
 	do
+		var pad = (char or else ' ').to_s
 		var diff = length - self.length
 		if diff <= 0 then return to_s
 		assert left >= 0.0 and left <= 1.0
 		var before = (diff.to_f * left).to_i
-		return " " * before + self + " " * (diff-before)
+		return pad * before + self + pad * (diff-before)
 	end
 
 	# Mangle a string to be a unique string only made of alphanumeric characters and underscores.
@@ -615,7 +619,7 @@ abstract class Text
 				b.append("\\\\")
 			else if c.code_point < 32 then
 				b.add('\\')
-				var oct = c.code_point.to_base(8, false)
+				var oct = c.code_point.to_base(8)
 				# Force 3 octal digits since it is the
 				# maximum allowed in the C specification
 				if oct.length == 1 then
@@ -689,7 +693,7 @@ abstract class Text
 				b.add('\\')
 				b.add(c)
 			else if c.code_point < 32 or c == ';' or c == '|' or c == '\\' or c == '=' then
-				b.append("?{c.code_point.to_base(16, false)}")
+				b.append("?{c.code_point.to_base(16)}")
 			else
 				b.add(c)
 			end
@@ -1091,6 +1095,39 @@ abstract class Text
 		end
 	end
 
+	# Packs the content of a string in packs of `ln` chars.
+	# This variant ensures that only the last element might be smaller than `ln`
+	#
+	# ~~~nit
+	# var s = "abcdefghijklmnopqrstuvwxyz"
+	# assert s.pack_l(4) == ["abcd","efgh","ijkl","mnop","qrst","uvwx","yz"]
+	# ~~~
+	fun pack_l(ln: Int): Array[Text] do
+		var st = 0
+		var retarr = new Array[Text].with_capacity(length / ln + length % ln)
+		while st < length do
+			retarr.add(substring(st, ln))
+			st += ln
+		end
+		return retarr
+	end
+
+	# Packs the content of a string in packs of `ln` chars.
+	# This variant ensures that only the first element might be smaller than `ln`
+	#
+	# ~~~nit
+	# var s = "abcdefghijklmnopqrstuvwxyz"
+	# assert s.pack_r(4) == ["ab","cdef","ghij","klmn","opqr","stuv","wxyz"]
+	# ~~~
+	fun pack_r(ln: Int): Array[Text] do
+		var st = length
+		var retarr = new Array[Text].with_capacity(length / ln + length % ln)
+		while st >= 0 do
+			retarr.add(substring(st - ln, ln))
+			st -= ln
+		end
+		return retarr.reversed
+	end
 end
 
 # All kinds of array-based text representations.
@@ -1569,9 +1606,9 @@ redef class Int
 	# Returns a string describing error number
 	fun strerror: String do return strerror_ext.to_s
 
-	# Fill `s` with the digits in base `base` of `self` (and with the '-' sign if 'signed' and negative).
+	# Fill `s` with the digits in base `base` of `self` (and with the '-' sign if negative).
 	# assume < to_c max const of char
-	private fun fill_buffer(s: Buffer, base: Int, signed: Bool)
+	private fun fill_buffer(s: Buffer, base: Int)
 	do
 		var n: Int
 		# Sign
@@ -1603,14 +1640,30 @@ redef class Int
 		snprintf(nstr, strlen, "%ld", self);
 	`}
 
-	# return displayable int in base base and signed
-	fun to_base(base: Int, signed: Bool): String is abstract
+	# String representation of `self` in the given `base`
+	#
+	# ~~~
+	# assert 15.to_base(10) == "15"
+	# assert 15.to_base(16) == "f"
+	# assert 15.to_base(2) == "1111"
+	# assert (-10).to_base(3) == "-101"
+	# ~~~
+	fun to_base(base: Int): String
+	do
+		var l = digit_count(base)
+		var s = new Buffer
+		s.enlarge(l)
+		for x in [0..l[ do s.add(' ')
+		fill_buffer(s, base)
+		return s.to_s
+	end
+
 
 	# return displayable int in hexadecimal
 	#
 	#     assert 1.to_hex  == "1"
 	#     assert (-255).to_hex  == "-ff"
-	fun to_hex: String do return to_base(16,false)
+	fun to_hex: String do return to_base(16)
 end
 
 redef class Float
@@ -1703,7 +1756,7 @@ redef class Char
 	end
 
 	# Length of `self` in a UTF-8 String
-	private fun u8char_len: Int do
+	fun u8char_len: Int do
 		var c = self.code_point
 		if c < 0x80 then return 1
 		if c <= 0x7FF then return 2
@@ -2021,22 +2074,43 @@ do
 end
 
 redef class NativeString
-	# Returns `self` as a new String.
+	# Get a `String` from the data at `self` copied into Nit memory
+	#
+	# Require: `self` is a null-terminated string.
 	fun to_s_with_copy: String is abstract
 
-	# Returns `self` as a String of `length`.
+	# Get a `String` from `length` bytes at `self`
+	#
+	# The result may point to the data at `self` or
+	# it may make a copy in Nit controlled memory.
+	# This method should only be used when `self` was allocated by the Nit GC,
+	# or when manually controlling the deallocation of `self`.
 	fun to_s_with_length(length: Int): String is abstract
 
-	# Returns a new instance of `String` with self as `_items`
+	# Get a `String` from the raw `length` bytes at `self`
+	#
+	# The default value of `length` is the number of bytes before
+	# the first null character.
 	#
-	# /!\: Does not clean the items for compliance with UTF-8,
-	# Use only if you know what you are doing
-	fun to_s_unsafe(len: nullable Int): String is abstract
+	# The created `String` points to the data at `self`.
+	# This method should be used when `self` was allocated by the Nit GC,
+	# or when manually controlling the deallocation of `self`.
+	#
+	# /!\: This service does not clean the items for compliance with UTF-8,
+	# use only when the data has already been verified as valid UTF-8.
+	fun to_s_unsafe(length: nullable Int): String is abstract
 
-	# Returns `self` as a String with `bytelen` and `length` set
+	# Get a `String` from the raw `bytelen` bytes at `self` with `unilen` Unicode characters
+	#
+	# The created `String` points to the data at `self`.
+	# This method should be used when `self` was allocated by the Nit GC,
+	# or when manually controlling the deallocation of `self`.
+	#
+	# /!\: This service does not clean the items for compliance with UTF-8,
+	# use only when the data has already been verified as valid UTF-8.
 	#
-	# SEE: `abstract_text::Text` for more infos on the difference
-	# between `Text::bytelen` and `Text::length`
+	# SEE: `abstract_text::Text` for more info on the difference
+	# between `Text::bytelen` and `Text::length`.
 	fun to_s_full(bytelen, unilen: Int): String is abstract
 end