Merge pull request #7 from danielenricocahall/styling

PEP8 Styling + Pythonic Refactors
close #3

Author: btwael

superstring/superstring.py

@@ -1,64 +1,59 @@
 SUPERSTRING_MINIMAL_LENGTH = 48
 
+
 class SuperStringBase(object):
     def length(self):
         pass
 
     def lower(self):
         if self.length() < SUPERSTRING_MINIMAL_LENGTH:
-            return SuperString(self.toPrintable().lower())
+            return SuperString(self.to_printable().lower())
         return SuperStringLower(self)
 
     def upper(self):
         if self.length() < SUPERSTRING_MINIMAL_LENGTH:
-            return SuperString(self.toPrintable().upper())
+            return SuperString(self.to_printable().upper())
         return SuperStringUpper(self)
 
-    def characterAt(self, index):
+    def character_at(self, index):
         pass
 
-    def split(self, separator = " "):
+    def split(self, separator=" "):
         result = []
         previous = 0
         i = 0
         while i < self.length():
-            gonext = False
-            j = 0
-            while j < len(separator):
-                if self.characterAt(i + j) != separator[j]:
-                    gonext = True
+            for j in range(len(separator)):
+                if self.character_at(i + j) != separator[j]:
                     break
-                j = j + 1
-            if not gonext:
+            else:
                 result.append(self.substring(previous, i))
                 previous = i + len(separator)
             i = i + 1
         result.append(self.substring(previous))
         return result
 
-    def substring(self, startIndex, endIndex = None):
-        # TODO: if the substring is to short: copy
-        if startIndex == None:
-            startIndex = 0
-        if endIndex == None:
-            endIndex = self.length()
-        if startIndex == 0 and endIndex == self.length():
+    def substring(self, start_index, end_index=None):
+        # TODO: if the substring is to short: copys
+        start_index = start_index if start_index is not None else 0
+        end_index = end_index if end_index is not None else self.length()
+        if start_index == 0 and end_index == self.length():
             return self
-        if endIndex - startIndex < SUPERSTRING_MINIMAL_LENGTH:
-            return SuperString(self.toPrintable(startIndex, endIndex = endIndex))
-        return SuperStringSubstring(self, startIndex, endIndex)
+        if end_index - start_index < SUPERSTRING_MINIMAL_LENGTH:
+            return SuperString(self.to_printable(start_index, end_index=end_index))
+        return SuperStringSubstring(self, start_index, end_index)
 
     def strip(self):
         i = 0
-        while self.characterAt(i) == ' ':
+        while self.character_at(i) == ' ':
             i = i + 1
-        startIndex = i
+        start_index = i
         i = self.length() - 1
-        while self.characterAt(i) == ' ':
+        while self.character_at(i) == ' ':
             i = i - 1
-        return self.substring(startIndex, i + 1)
+        return self.substring(start_index, i + 1)
 
-    def toPrintable(self, startIndex = None, endIndex = None):
+    def to_printable(self, start_index=None, end_index=None):
         pass
 
     def __len__(self):
@@ -70,35 +65,33 @@ def __add__(self, right):
         return SuperStringConcatenation(self, right)
 
     def __str__(self):
-        return self.toPrintable()
+        return self.to_printable()
 
     def __getitem__(self, key):
         if isinstance(key, slice):
             start = key.start if key.start > 0 else self.length() + key.start
             stop = key.stop if key.stop > 0 else self.length() + key.stop
             return self.substring(start, end_index=stop)
-        return self.characterAt(key)
+        return self.character_at(key)
+
 
 class SuperString(SuperStringBase):
     def __init__(self, content):
         self._content = content
 
     def length(self):
-        if not hasattr(self,'_length'):
+        if not hasattr(self, '_length'):
             self._length = len(self._content)
         return self._length
 
-    def characterAt(self, index):
+    def character_at(self, index):
         return self._content[index]
 
-    def toPrintable(self, startIndex = None, endIndex = None):
-        if startIndex != None:
-            if endIndex == None:
-                endIndex = self.length()
-            return self._content[startIndex:endIndex]
-        elif endIndex != None:
-            return self._content[0:endIndex]
-        return self._content
+    def to_printable(self, start_index=None, end_index=None):
+        start_index = start_index if start_index is not None else 0
+        end_index = end_index if end_index is not None else self.length()
+        return self._content[start_index:end_index]
+
 
 class SuperStringConcatenation(SuperStringBase):
     def __init__(self, left, right):
@@ -108,44 +101,43 @@ def __init__(self, left, right):
     def length(self):
         return self._left.length() + self._right.length()
 
-    def characterAt(self, index):
-        leftLen = self._left.length()
-        if index < leftLen:
+    def character_at(self, index):
+        left_len = self._left.length()
+        if index < left_len:
             return self._left[index]
-        return self._right[index - leftLen]
-
-    def toPrintable(self, startIndex = None, endIndex = None):
-        if startIndex == None:
-            startIndex = 0
-        if endIndex == None:
-            endIndex = self.length()
-        leftLen = self._left.length()
-        if endIndex < leftLen:
-            return self._left.toPrintable(startIndex = startIndex, endIndex = endIndex)
-        elif startIndex > leftLen:
-            return self._right.toPrintable(startIndex = startIndex - leftLen, endIndex = endIndex - leftLen)
-        return self._left.toPrintable(startIndex = startIndex) + self._right.toPrintable(endIndex = endIndex - leftLen)
+        return self._right[index - left_len]
+
+    def to_printable(self, start_index=None, end_index=None):
+        start_index = start_index if start_index is not None else 0
+        end_index = end_index if end_index is not None else self.length()
+        left_len = self._left.length()
+        if end_index < left_len:
+            return self._left.to_printable(start_index=start_index, end_index=end_index)
+        elif start_index > left_len:
+            return self._right.to_printable(start_index=start_index - left_len, end_index=end_index - left_len)
+        return self._left.to_printable(start_index=start_index) + self._right.to_printable(
+            end_index=end_index - left_len)
+
 
 class SuperStringSubstring(SuperStringBase):
-    def __init__(self, base, startIndex, endIndex):
+    def __init__(self, base, start_index, end_index):
         self._base = base
-        self._startIndex = startIndex
-        self._endIndex = endIndex
+        self._start_index = start_index
+        self._end_index = end_index
 
     def length(self):
-        return self._endIndex - self._startIndex
+        return self._end_index - self._start_index
+
+    def character_at(self, index):
+        return self._base.character_at(self._start_index + index)
 
-    def characterAt(self, index):
-        return self._base.characterAt(self._startIndex + index)
+    def to_printable(self, start_index=None, end_index=None):
+        start_index = start_index if start_index is not None else 0
+        end_index = end_index if end_index is not None else self.length()
+        start_index += self._start_index
+        end_index += self._start_index
+        return self._base.to_printable(start_index, end_index=end_index)
 
-    def toPrintable(self, startIndex = None, endIndex = None):
-        if startIndex == None:
-            startIndex = 0
-        if endIndex == None:
-            endIndex = self.length()
-        startIndex += self._startIndex
-        endIndex += self._startIndex
-        return self._base.toPrintable(startIndex, endIndex = endIndex)
 
 class SuperStringLower(SuperStringBase):
     def __init__(self, base):
@@ -154,11 +146,12 @@ def __init__(self, base):
     def length(self):
         return self._base.length()
 
-    def characterAt(self, index):
-        return self._base.characterAt(index).lower()
+    def character_at(self, index):
+        return self._base.character_at(index).lower()
+
+    def to_printable(self, start_index=None, end_index=None):
+        return self._base.to_printable(start_index, end_index).lower()
 
-    def toPrintable(self, startIndex = None, endIndex = None):
-        return self._base.toPrintable(startIndex, endIndex).lower()
 
 class SuperStringUpper(SuperStringBase):
     def __init__(self, base):
@@ -167,8 +160,8 @@ def __init__(self, base):
     def length(self):
         return self._base.length()
 
-    def characterAt(self, index):
-        return self._base.characterAt(index).upper()
+    def character_at(self, index):
+        return self._base.character_at(index).upper()
 
-    def toPrintable(self, startIndex = None, endIndex = None):
-        return self._base.toPrintable(startIndex, endIndex).upper()
+    def to_printable(self, start_index=None, end_index=None):
+        return self._base.to_printable(start_index, end_index).upper()

test/unit/test_superstring_functions.py

@@ -14,7 +14,7 @@ def test_length(super_string):
 
 
 def test_character_at(super_string):
-    assert super_string.characterAt(0) == "t"
+    assert super_string.character_at(0) == "t"
     assert super_string[0] == "t"
 
 
@@ -24,4 +24,4 @@ def test_split(super_string):
 
 
 def test_strip():
-    assert SuperString("   TESTING     ").strip()._content == "TESTING"
+    assert SuperString("   TESTING     ").strip()._content == "TESTING"