string: Add escaping for the POSIX Shell.

[nit.git] / lib / standard / string.nit

diff --git a/lib/standard/string.nit b/lib/standard/string.nit
index f78c0ac..28ad7b5 100644 (file)
--- a/lib/standard/string.nit
+++ b/lib/standard/string.nit
@@ -181,8 +181,25 @@ abstract class Text
        #
        #     assert "abcd".has_substring("bc",1)            ==  true
        #     assert "abcd".has_substring("bc",2)            ==  false
+       #
+       # Returns true iff all characters of `str` are presents
+       # at the expected index in `self.`
+       # The first character of `str` being at `pos`, the second
+       # character being at `pos+1` and so on...
+       #
+       # This means that all characters of `str` need to be inside `self`.
+       #
+       #     assert "abcd".has_substring("xab", -1)         == false
+       #     assert "abcd".has_substring("cdx", 2)          == false
+       #
+       # And that the empty string is always a valid substring.
+       #
+       #     assert "abcd".has_substring("", 2)             == true
+       #     assert "abcd".has_substring("", 200)           == true
        fun has_substring(str: String, pos: Int): Bool
        do
+               if str.is_empty then return true
+               if pos < 0 or pos + str.length > length then return false
                var myiter = self.chars.iterator_from(pos)
                var itsiter = str.chars.iterator
                while myiter.is_ok and itsiter.is_ok do
@@ -369,6 +386,33 @@ abstract class Text
        #     assert "\na\nb\tc\t".trim          == "a\nb\tc"
        fun trim: SELFTYPE do return (self.l_trim).r_trim
 
+       # Justify a 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)
+       #
+       #     assert "hello".justify(10, 0.0)  == "hello     "
+       #     assert "hello".justify(10, 1.0)  == "     hello"
+       #     assert "hello".justify(10, 0.5)  == "  hello   "
+       #
+       # If `length` is not enough, `self` is returned as is.
+       #
+       #     assert "hello".justify(2, 0.0)   == "hello"
+       #
+       # 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): SELFTYPE
+       do
+               var diff = length - self.length
+               if diff <= 0 then return self
+               assert left >= 0.0 and left <= 1.0
+               var before = (diff.to_f * left).to_i
+               return " " * before + self + " " * (diff-before)
+       end
+
        # Mangle a string to be a unique string only made of alphanumeric characters
        fun to_cmangle: String
        do
@@ -450,6 +494,27 @@ abstract class Text
        #     assert "\n\"'\\\{\}".escape_to_nit      == "\\n\\\"\\'\\\\\\\{\\\}"
        fun escape_to_nit: String do return escape_more_to_c("\{\}")
 
+       # Escape to POSIX Shell (sh).
+       #
+       # Abort if the text contains a null byte.
+       #
+       #     assert "\n\"'\\\{\}0".escape_to_sh == "'\n\"'\\''\\\{\}0'"
+       fun escape_to_sh: String do
+               var b = new FlatBuffer
+               b.chars.add '\''
+               for i in [0..length[ do
+                       var c = chars[i]
+                       if c == '\'' then
+                               b.append("'\\''")
+                       else
+                               assert without_null_byte: c != '\0'
+                               b.add(c)
+                       end
+               end
+               b.chars.add '\''
+               return b.to_s
+       end
+
        # Return a string where Nit escape sequences are transformed.
        #
        #     var s = "\\n"
@@ -693,11 +758,6 @@ private abstract class StringCharView
 
        private var target: SELFTYPE
 
-       private init(tgt: SELFTYPE)
-       do
-               target = tgt
-       end
-
        redef fun is_empty do return target.is_empty
 
        redef fun length do return target.length
@@ -739,6 +799,8 @@ abstract class String
 
        fun insert_at(s: String, pos: Int): SELFTYPE is abstract
 
+       redef fun substrings: Iterator[String] is abstract
+
        # Returns a reversed version of self
        #
        #     assert "hello".reversed  == "olleh"
@@ -869,8 +931,6 @@ private class FlatSubstringsIter
 
        var tgt: nullable FlatText
 
-       init(tgt: FlatText) do self.tgt = tgt
-
        redef fun item do
                assert is_ok
                return tgt.as(not null)
@@ -2061,7 +2121,6 @@ extern class NativeString `{ char* `}
        do
                assert length >= 0
                var str = new FlatString.with_infos(self, length, 0, length - 1)
-               str.real_items = self
                return str
        end
 
@@ -2071,7 +2130,8 @@ extern class NativeString `{ char* `}
                var new_self = calloc_string(length + 1)
                copy_to(new_self, length, 0, 0)
                var str = new FlatString.with_infos(new_self, length, 0, length - 1)
-               str.real_items = self
+               new_self[length] = '\0'
+               str.real_items = new_self
                return str
        end
 end