py: string: make __getitem__ and __contains__ work and unit tests

Author: ncw

notes.txt

@@ -12,7 +12,6 @@ Limitations
   * \N{...} escapes not implemented
   * Interactive interpreter does single lines only
   * compile(..., "single") not working
-  * string[x] wrong for unicode strings (easy fix)
   * lots of builtins still to implement
 
 Todo

py/int.go

@@ -200,6 +200,11 @@ func convertToInt(other Object) (Int, bool) {
 		} else {
 			return Int(0), true
 		}
+		// case Float:
+		// 	ib := Int(b)
+		// 	if Float(ib) == b {
+		// 		return ib, true
+		// 	}
 	}
 	return 0, false
 }

py/internal.go

@@ -103,7 +103,7 @@ func IndexIntCheck(a Object, max int) (int, error) {
 		i += max
 	}
 	if i < 0 || i >= max {
-		return 0, ExceptionNewf(IndexError, "list index out of range")
+		return 0, ExceptionNewf(IndexError, "index out of range")
 	}
 	return i, nil
 }

py/sequence.go

@@ -113,6 +113,18 @@ func Send(self, value Object) (Object, error) {
 
 // SequenceContains returns True if obj is in seq
 func SequenceContains(seq, obj Object) (found bool, err error) {
+	if I, ok := seq.(I__contains__); ok {
+		result, err := I.M__contains__(obj)
+		if err != nil {
+			return false, err
+		}
+		return result == True, nil
+	} else if result, ok, err := TypeCall1(seq, "__contains__", obj); ok {
+		if err != nil {
+			return false, err
+		}
+		return result == True, nil
+	}
 	var loopErr error
 	err = Iterate(seq, func(item Object) bool {
 		var eq Object

py/string.go

@@ -9,7 +9,9 @@
 package py
 
 import (
+	"bytes"
 	"fmt"
+	"strings"
 	"unicode/utf8"
 )
 
@@ -42,8 +44,13 @@ func (s String) M__bool__() (Object, error) {
 	return NewBool(len(s) > 0), nil
 }
 
+// len returns length of the string in unicode characters
+func (s String) len() int {
+	return utf8.RuneCountInString(string(s))
+}
+
 func (s String) M__len__() (Object, error) {
-	return Int(utf8.RuneCountInString(string(s))), nil
+	return Int(s.len()), nil
 }
 
 func (a String) M__add__(other Object) (Object, error) {
@@ -66,11 +73,14 @@ func (a String) M__iadd__(other Object) (Object, error) {
 
 func (a String) M__mul__(other Object) (Object, error) {
 	if b, ok := convertToInt(other); ok {
-		newString := String("")
+		if b < 0 {
+			b = 0
+		}
+		var out bytes.Buffer
 		for i := 0; i < int(b); i++ {
-			newString += a
+			out.WriteString(string(a))
 		}
-		return newString, nil
+		return String(out.String()), nil
 	}
 	return NotImplemented, nil
 }
@@ -164,28 +174,83 @@ func (a String) M__imod__(other Object) (Object, error) {
 	return a.M__mod__(other)
 }
 
+// Returns position in string of n-th character
+//
+// returns end of string if not found
+func (s String) pos(n int) int {
+	characterNumber := 0
+	for i, _ := range s {
+		if characterNumber == n {
+			return i
+		}
+		characterNumber++
+	}
+	return len(s)
+}
+
+// slice returns the slice of this string using character positions
+//
+// length should be the length of the string in unicode characters
+func (s String) slice(start, stop, length int) String {
+	if start >= stop {
+		return String("")
+	}
+	if length == len(s) {
+		return s[start:stop] // ascii only
+	}
+	if start <= 0 && stop >= length {
+		return s
+	}
+	startI := s.pos(start)
+	stopI := s[startI:].pos(stop-start) + startI
+	return s[startI:stopI]
+}
+
 func (s String) M__getitem__(key Object) (Object, error) {
-	// FIXME doesn't take into account unicode yet - ASCII only!!!
+	length := s.len()
+	asciiOnly := length == len(s)
 	if slice, ok := key.(*Slice); ok {
-		start, stop, step, slicelength, err := slice.GetIndices(len(s))
+		start, stop, step, slicelength, err := slice.GetIndices(length)
 		if err != nil {
 			return nil, err
 		}
 		if step == 1 {
 			// Return a subslice since strings are immutable
-			return s[start:stop], nil
+			return s.slice(start, stop, length), nil
+		}
+		if asciiOnly {
+			newString := make([]byte, slicelength)
+			for i, j := start, 0; j < slicelength; i, j = i+step, j+1 {
+				newString[j] = s[i]
+			}
+			return String(newString), nil
 		}
-		newString := make([]byte, slicelength)
+		// Unpack the string into a []rune to do this for speed
+		runeString := []rune(string(s))
+		newString := make([]rune, slicelength)
 		for i, j := start, 0; j < slicelength; i, j = i+step, j+1 {
-			newString[j] = s[i]
+			newString[j] = runeString[i]
 		}
 		return String(newString), nil
 	}
-	i, err := IndexIntCheck(key, len(s))
+	i, err := IndexIntCheck(key, length)
 	if err != nil {
 		return nil, err
 	}
-	return s[i : i+1], nil
+	if asciiOnly {
+		return s[i : i+1], nil
+	}
+	s = s[s.pos(i):]
+	_, runeSize := utf8.DecodeRuneInString(string(s))
+	return s[:runeSize], nil
+}
+
+func (s String) M__contains__(item Object) (Object, error) {
+	needle, ok := item.(String)
+	if !ok {
+		return nil, ExceptionNewf(TypeError, "'in <string>' requires string as left operand, not %s", item.Type().Name)
+	}
+	return NewBool(strings.Contains(string(s), string(needle))), nil
 }
 
 // Check stringerface is satisfied
@@ -197,3 +262,4 @@ var _ I__imod__ = String("")
 var _ I__len__ = String("")
 var _ I__bool__ = String("")
 var _ I__getitem__ = String("")
+var _ I__contains__ = String("")

py/tests/int.py

@@ -1,20 +1,12 @@
+from libtest import assertRaises
+
 tenE5 = 10**5
 tenE30 = 10**30
 minInt = -9223372036854775807 - 1
 negativeMinInt = 9223372036854775808
 minIntMinus1 = -9223372036854775809
 maxInt = 9223372036854775807
 maxIntPlus1 = 9223372036854775808
-def assertRaises(expecting, s, base=None):
-    try:
-        if base is None:
-            int(s)
-        else:
-            int(s, base=base)
-    except expecting as e:
-        pass
-    else:
-        assert False, "%s not raised" % (expecting,)
 
 doc="test overflow"
 assert int("1000000000000000000") == 10**18
@@ -100,38 +92,38 @@ def assertRaises(expecting, s, base=None):
 assert int("F", 16) == 15
 assert int("0xF", 16) == 15
 assert int("0XF", 0) == 15
-assertRaises(ValueError, "0xF", 10)
+assertRaises(ValueError, int, "0xF", 10)
 
 assert int("77", 8) == 63
 assert int("0o77", 0) == 63
 assert int("0O77", 8) == 63
-assertRaises(ValueError, "0o77", 10)
+assertRaises(ValueError, int, "0o77", 10)
 
 assert int("11", 2) == 3
 assert int("0b11", 0) == 3
 assert int("0B11", 2) == 3
-assertRaises(ValueError, "0b11", 10)
+assertRaises(ValueError, int, "0b11", 10)
 
 doc="errors"
-assertRaises(ValueError, "07", 0)
-assertRaises(ValueError, "", 0)
-assertRaises(ValueError, "  ", 0)
-assertRaises(ValueError, "+", 0)
-assertRaises(ValueError, "-", 0)
-assertRaises(ValueError, "0x", 0)
-assertRaises(ValueError, "+ 1", 0)
-assertRaises(ValueError, "- 1", 0)
-assertRaises(ValueError, "a", 0)
-assertRaises(ValueError, "a", 10)
-assertRaises(ValueError, "£", 0)
-assertRaises(ValueError, "100000000000000000000000000000000000000000000000000000a", 0)
-assertRaises(ValueError, "10", base=1)
-assertRaises(ValueError, "10", base=-1)
-assertRaises((OverflowError, ValueError), "10", base=100000000000000000000000000000000000000000000)
-assertRaises(TypeError, 1.5, 10)
-assertRaises(TypeError, 1.5, 0)
-assertRaises(TypeError, ...)
-assertRaises(TypeError, ..., 10)
+assertRaises(ValueError, int, "07", 0)
+assertRaises(ValueError, int, "", 0)
+assertRaises(ValueError, int, "  ", 0)
+assertRaises(ValueError, int, "+", 0)
+assertRaises(ValueError, int, "-", 0)
+assertRaises(ValueError, int, "0x", 0)
+assertRaises(ValueError, int, "+ 1", 0)
+assertRaises(ValueError, int, "- 1", 0)
+assertRaises(ValueError, int, "a", 0)
+assertRaises(ValueError, int, "a", 10)
+assertRaises(ValueError, int, "£", 0)
+assertRaises(ValueError, int, "100000000000000000000000000000000000000000000000000000a", 0)
+assertRaises(ValueError, int, "10", base=1)
+assertRaises(ValueError, int, "10", base=-1)
+assertRaises((OverflowError, ValueError), int, "10", base=100000000000000000000000000000000000000000000)
+assertRaises(TypeError, int, 1.5, 10)
+assertRaises(TypeError, int, 1.5, 0)
+assertRaises(TypeError, int, ...)
+assertRaises(TypeError, int, ..., 10)
 
 doc="conversions"
 i = int(1E30)

py/tests/libtest.py

@@ -0,0 +1,21 @@
+"""
+Simple test harness
+"""
+
+def assertRaises(expecting, fn, *args, **kwargs):
+    """Check the exception was raised - don't check the text"""
+    try:
+        fn(*args, **kwargs)
+    except expecting as e:
+        pass
+    else:
+        assert False, "%s not raised" % (expecting,)
+
+def assertRaisesText(expecting, text, fn, *args, **kwargs):
+    """Check the exception with text in is raised"""
+    try:
+        fn(*args, **kwargs)
+    except expecting as e:
+        assert text in e.args[0], "'%s' not found in '%s'" % (text, e.args[0])
+    else:
+        assert False, "%s not raised" % (expecting,)