Merge e86566a into b86ead8

kenjutsu/kenjutsu.py

@@ -23,6 +23,7 @@
 
 
 import itertools
+import numbers
 import operator
 import math
 import warnings
@@ -55,6 +56,11 @@ def reformat_slice(a_slice, a_length=None):
     new_slice = a_slice
     if (new_slice is Ellipsis) or (new_slice == tuple()):
         new_slice = slice(None)
+    elif isinstance(a_slice, numbers.Integral):
+        if new_slice < 0:
+            new_slice = slice(new_slice, new_slice-1, -1)
+        else:
+            new_slice = slice(new_slice, new_slice+1, 1)
     elif not isinstance(a_slice, slice):
         raise ValueError(
             "Expected a `slice` type. Instead got `%s`." % str(a_slice)
@@ -123,6 +129,10 @@ def reformat_slice(a_slice, a_length=None):
             start = stop = 0
 
     new_slice = slice(start, stop, step)
+    if isinstance(a_slice, numbers.Integral):
+        if new_slice.start == new_slice.stop:
+            raise IndexError("Index out of range.")
+        new_slice = new_slice.start
 
     return(new_slice)
 
@@ -276,6 +286,11 @@ def len_slice(a_slice, a_length=None):
             4
     """
 
+    if isinstance(a_slice, numbers.Integral):
+        raise TypeError(
+            "An integral index does not provide an object with a length."
+        )
+
     new_slice = reformat_slice(a_slice, a_length)
 
     if new_slice.stop is None:
@@ -326,7 +341,8 @@ def len_slices(slices, lengths=None):
     lens = []
 
     for each_slice in new_slices:
-        lens.append(len_slice(each_slice))
+        if not isinstance(each_slice, numbers.Integral):
+            lens.append(len_slice(each_slice))
 
     lens = tuple(lens)
 

tests/test_kenjutsu.py

@@ -84,6 +84,27 @@ def test_reformat_slice(self):
                             len(each_range[a_slice])
                         )
 
+                if start is not None:
+                    a_slice = start
+
+                    rf_slice = kenjutsu.reformat_slice(a_slice)
+                    try:
+                        expect_result = each_range[a_slice]
+
+                        self.assertEqual(
+                            expect_result,
+                            each_range[rf_slice]
+                        )
+
+                        rf_slice = kenjutsu.reformat_slice(a_slice, size)
+                        self.assertEqual(
+                            expect_result,
+                            each_range[rf_slice]
+                        )
+                    except IndexError:
+                        with self.assertRaises(IndexError):
+                            kenjutsu.reformat_slice(a_slice, size)
+
             rf_slice = kenjutsu.reformat_slice(Ellipsis)
             self.assertEqual(
                 each_range[:],
@@ -202,6 +223,7 @@ def test_reformat_slices(self):
         )
 
         rf_slice = kenjutsu.reformat_slices((
+            -1,
             slice(None),
             slice(3, None),
             slice(None, 5),
@@ -210,6 +232,7 @@ def test_reformat_slices(self):
         self.assertEqual(
             rf_slice,
             (
+                -1,
                 slice(0, None, 1),
                 slice(3, None, 1),
                 slice(0, 5, 1),
@@ -219,16 +242,18 @@ def test_reformat_slices(self):
 
         rf_slice = kenjutsu.reformat_slices(
             (
+                -1,
                 slice(None),
                 slice(3, None),
                 slice(None, 5),
                 slice(None, None, 2)
             ),
-            (10, 13, 15, 20)
+            (12, 10, 13, 15, 20)
         )
         self.assertEqual(
             rf_slice,
             (
+                11,
                 slice(0, 10, 1),
                 slice(3, 13, 1),
                 slice(0, 5, 1),
@@ -343,6 +368,12 @@ def test_len_slice(self):
                             len(each_range[a_slice])
                         )
 
+                if start is not None:
+                    a_slice = start
+
+                    with self.assertRaises(TypeError):
+                        kenjutsu.len_slice(a_slice, size)
+
             self.assertEqual(
                 kenjutsu.len_slice(Ellipsis, size),
                 len(each_range[:])
@@ -389,12 +420,13 @@ def test_len_slices(self):
 
         l = kenjutsu.len_slices(
             (
+                -1,
                 slice(None),
                 slice(3, None),
                 slice(None, 5),
                 slice(None, None, 2)
             ),
-            (10, 13, 15, 20)
+            (12, 10, 13, 15, 20)
         )
         self.assertEqual(
             l,