acpt: add _Column.cells access scenario

Steve Canny · Steve Canny · commit 806dbd42fd39 · 2013-12-22T15:06:04.000-08:00
Along the way:

* rename and resequence _CellCollection to _RowCellCollection since
there will need to be a _ColumnCellCollection now
diff --git a/docx/table.py b/docx/table.py
@@ -63,32 +63,6 @@ def __init__(self, tc):
         self._tc = tc
 
 
-class _CellCollection(object):
-    """
-    Sequence of |_Cell| instances corresponding to the cells in a table row.
-    """
-    def __init__(self, tr):
-        super(_CellCollection, self).__init__()
-        self._tr = tr
-
-    def __getitem__(self, idx):
-        """
-        Provide indexed access, (e.g. 'cells[0]')
-        """
-        try:
-            tc = self._tr.tc_lst[idx]
-        except IndexError:
-            msg = "cell index [%d] is out of range" % idx
-            raise IndexError(msg)
-        return _Cell(tc)
-
-    def __iter__(self):
-        return (_Cell(tc) for tc in self._tr.tc_lst)
-
-    def __len__(self):
-        return len(self._tr.tc_lst)
-
-
 class _Column(object):
     """
     Table column
@@ -98,6 +72,13 @@ def __init__(self, gridCol):
         self._gridCol = gridCol
 
 
+class _ColumnCellCollection(object):
+    """
+    Sequence of |_Cell| instances corresponding to the cells in a table
+    column.
+    """
+
+
 class _ColumnCollection(object):
     """
     Sequence of |_Column| instances corresponding to the columns in a table.
@@ -146,7 +127,33 @@ def cells(self):
         """
         Sequence of |_Cell| instances corresponding to the cells in this row.
         """
-        return _CellCollection(self._tr)
+        return _RowCellCollection(self._tr)
+
+
+class _RowCellCollection(object):
+    """
+    Sequence of |_Cell| instances corresponding to the cells in a table row.
+    """
+    def __init__(self, tr):
+        super(_RowCellCollection, self).__init__()
+        self._tr = tr
+
+    def __getitem__(self, idx):
+        """
+        Provide indexed access, (e.g. 'cells[0]')
+        """
+        try:
+            tc = self._tr.tc_lst[idx]
+        except IndexError:
+            msg = "cell index [%d] is out of range" % idx
+            raise IndexError(msg)
+        return _Cell(tc)
+
+    def __iter__(self):
+        return (_Cell(tc) for tc in self._tr.tc_lst)
+
+    def __len__(self):
+        return len(self._tr.tc_lst)
 
 
 class _RowCollection(object):
diff --git a/features/steps/table.py b/features/steps/table.py
@@ -10,19 +10,20 @@
 
 from docx import Document
 from docx.table import (
-    _Cell, _CellCollection, _Column, _ColumnCollection, _Row, _RowCollection
+    _Cell, _Column, _ColumnCellCollection, _ColumnCollection, _Row,
+    _RowCellCollection, _RowCollection
 )
 
 from .helpers import test_docx
 
 
 # given ===================================================
 
-@given('a cell collection having two cells')
-def given_a_cell_collection_having_two_cells(context):
+@given('a column cell collection having two cells')
+def given_a_column_cell_collection_having_two_cells(context):
     docx_path = test_docx('blk-containing-table')
     document = Document(docx_path)
-    context.cells = document.body.tables[0].rows[0].cells
+    context.cells = document.body.tables[0].columns[0].cells
 
 
 @given('a column collection having two columns')
@@ -32,6 +33,13 @@ def given_a_column_collection_having_two_columns(context):
     context.columns = document.body.tables[0].columns
 
 
+@given('a row cell collection having two cells')
+def given_a_row_cell_collection_having_two_cells(context):
+    docx_path = test_docx('blk-containing-table')
+    document = Document(docx_path)
+    context.cells = document.body.tables[0].rows[0].cells
+
+
 @given('a row collection having two rows')
 def given_a_row_collection_having_two_rows(context):
     docx_path = test_docx('blk-containing-table')
@@ -55,6 +63,13 @@ def given_a_table_having_two_rows(context):
     context.table_ = document.body.tables[0]
 
 
+@given('a table column having two cells')
+def given_a_table_column_having_two_cells(context):
+    docx_path = test_docx('blk-containing-table')
+    document = Document(docx_path)
+    context.column = document.body.tables[0].columns[0]
+
+
 @given('a table row having two cells')
 def given_a_table_row_having_two_cells(context):
     docx_path = test_docx('blk-containing-table')
@@ -73,14 +88,6 @@ def then_can_access_cell_using_its_row_and_col_indices(context):
             assert isinstance(cell, _Cell)
 
 
-@then('I can access a collection cell by index')
-def then_can_access_collection_cell_by_index(context):
-    cells = context.cells
-    for idx in range(2):
-        cell = cells[idx]
-        assert isinstance(cell, _Cell)
-
-
 @then('I can access a collection column by index')
 def then_can_access_collection_column_by_index(context):
     columns = context.columns
@@ -97,11 +104,34 @@ def then_can_access_collection_row_by_index(context):
         assert isinstance(row, _Row)
 
 
+@then('I can access a column cell by index')
+def then_can_access_column_cell_by_index(context):
+    cells = context.cells
+    for idx in range(2):
+        cell = cells[idx]
+        assert isinstance(cell, _Cell)
+
+
+@then('I can access a row cell by index')
+def then_can_access_row_cell_by_index(context):
+    cells = context.cells
+    for idx in range(2):
+        cell = cells[idx]
+        assert isinstance(cell, _Cell)
+
+
+@then('I can access the cell collection of the column')
+def then_can_access_cell_collection_of_column(context):
+    column = context.column
+    cells = column.cells
+    assert isinstance(cells, _ColumnCellCollection)
+
+
 @then('I can access the cell collection of the row')
 def then_can_access_cell_collection_of_row(context):
     row = context.row
     cells = row.cells
-    assert isinstance(cells, _CellCollection)
+    assert isinstance(cells, _RowCellCollection)
 
 
 @then('I can access the column collection of the table')
@@ -118,15 +148,22 @@ def then_can_access_row_collection_of_table(context):
     assert isinstance(rows, _RowCollection)
 
 
-@then('I can get the length of the cell collection')
-def then_can_get_length_of_cell_collection(context):
+@then('I can get the length of the column cell collection')
+def then_can_get_length_of_column_cell_collection(context):
+    column = context.column
+    cells = column.cells
+    assert len(cells) == 2
+
+
+@then('I can get the length of the row cell collection')
+def then_can_get_length_of_row_cell_collection(context):
     row = context.row
     cells = row.cells
     assert len(cells) == 2
 
 
-@then('I can iterate over the cell collection')
-def then_can_iterate_over_cell_collection(context):
+@then('I can iterate over the column cells')
+def then_can_iterate_over_the_column_cells(context):
     cells = context.cells
     actual_count = 0
     for cell in cells:
@@ -145,6 +182,16 @@ def then_can_iterate_over_column_collection(context):
     assert actual_count == 2
 
 
+@then('I can iterate over the row cells')
+def then_can_iterate_over_the_row_cells(context):
+    cells = context.cells
+    actual_count = 0
+    for cell in cells:
+        actual_count += 1
+        assert isinstance(cell, _Cell)
+    assert actual_count == 2
+
+
 @then('I can iterate over the row collection')
 def then_can_iterate_over_row_collection(context):
     rows = context.rows
diff --git a/features/tbl-item-access.feature b/features/tbl-item-access.feature
@@ -23,15 +23,27 @@ Feature: Access table rows, columns, and cells
       Then I can iterate over the column collection
        And I can access a collection column by index
 
+  @wip
+  Scenario: Access cell collection of table column
+     Given a table column having two cells
+      Then I can access the cell collection of the column
+       And I can get the length of the column cell collection
+
   Scenario: Access cell collection of table row
      Given a table row having two cells
       Then I can access the cell collection of the row
-       And I can get the length of the cell collection
+       And I can get the length of the row cell collection
+
+  @wip
+  Scenario: Access cell in column cell collection
+     Given a column cell collection having two cells
+      Then I can iterate over the column cells
+       And I can access a column cell by index
 
-  Scenario: Access cell in cell collection
-     Given a cell collection having two cells
-      Then I can iterate over the cell collection
-       And I can access a collection cell by index
+  Scenario: Access cell in row cell collection
+     Given a row cell collection having two cells
+      Then I can iterate over the row cells
+       And I can access a row cell by index
 
   Scenario: Access cell in table
      Given a table having two rows
diff --git a/tests/test_table.py b/tests/test_table.py
@@ -9,8 +9,8 @@
 import pytest
 
 from docx.table import (
-    _Cell, _CellCollection, _Column, _ColumnCollection, _Row, _RowCollection,
-    Table
+    _Cell, _Column, _ColumnCollection, _Row, _RowCellCollection,
+    _RowCollection, Table
 )
 
 from .oxml.unitdata.table import a_gridCol, a_tbl, a_tblGrid, a_tc, a_tr
@@ -71,48 +71,6 @@ def table(self):
         return table
 
 
-class Describe_CellCollection(object):
-
-    def it_can_iterate_over_its__Cell_instances(self, cell_count_fixture):
-        cells, cell_count = cell_count_fixture
-        actual_count = 0
-        for cell in cells:
-            assert isinstance(cell, _Cell)
-            actual_count += 1
-        assert actual_count == cell_count
-
-    def it_knows_how_many_cells_it_contains(self, cell_count_fixture):
-        cells, cell_count = cell_count_fixture
-        assert len(cells) == cell_count
-
-    def it_provides_indexed_access_to_cells(self, cell_count_fixture):
-        cells, cell_count = cell_count_fixture
-        for idx in range(-cell_count, cell_count):
-            cell = cells[idx]
-            assert isinstance(cell, _Cell)
-
-    def it_raises_on_indexed_access_out_of_range(self, cell_count_fixture):
-        cells, cell_count = cell_count_fixture
-        too_low = -1 - cell_count
-        too_high = cell_count
-        with pytest.raises(IndexError):
-            cells[too_low]
-        with pytest.raises(IndexError):
-            cells[too_high]
-
-    # fixtures -------------------------------------------------------
-
-    @pytest.fixture
-    def cell_count_fixture(self):
-        cell_count = 2
-        tr_bldr = a_tr().with_nsdecls()
-        for idx in range(cell_count):
-            tr_bldr.with_child(a_tc())
-        tr = tr_bldr.element
-        cells = _CellCollection(tr)
-        return cells, cell_count
-
-
 class Describe_ColumnCollection(object):
 
     def it_knows_how_many_columns_it_contains(self, columns_fixture):
@@ -157,7 +115,7 @@ class Describe_Row(object):
     def it_provides_access_to_the_row_cells(self, cells_access_fixture):
         row = cells_access_fixture
         cells = row.cells
-        assert isinstance(cells, _CellCollection)
+        assert isinstance(cells, _RowCellCollection)
 
     # fixtures -------------------------------------------------------
 
@@ -168,6 +126,48 @@ def cells_access_fixture(self):
         return row
 
 
+class Describe_RowCellCollection(object):
+
+    def it_can_iterate_over_its__Cell_instances(self, cell_count_fixture):
+        cells, cell_count = cell_count_fixture
+        actual_count = 0
+        for cell in cells:
+            assert isinstance(cell, _Cell)
+            actual_count += 1
+        assert actual_count == cell_count
+
+    def it_knows_how_many_cells_it_contains(self, cell_count_fixture):
+        cells, cell_count = cell_count_fixture
+        assert len(cells) == cell_count
+
+    def it_provides_indexed_access_to_cells(self, cell_count_fixture):
+        cells, cell_count = cell_count_fixture
+        for idx in range(-cell_count, cell_count):
+            cell = cells[idx]
+            assert isinstance(cell, _Cell)
+
+    def it_raises_on_indexed_access_out_of_range(self, cell_count_fixture):
+        cells, cell_count = cell_count_fixture
+        too_low = -1 - cell_count
+        too_high = cell_count
+        with pytest.raises(IndexError):
+            cells[too_low]
+        with pytest.raises(IndexError):
+            cells[too_high]
+
+    # fixtures -------------------------------------------------------
+
+    @pytest.fixture
+    def cell_count_fixture(self):
+        cell_count = 2
+        tr_bldr = a_tr().with_nsdecls()
+        for idx in range(cell_count):
+            tr_bldr.with_child(a_tc())
+        tr = tr_bldr.element
+        cells = _RowCellCollection(tr)
+        return cells, cell_count
+
+
 class Describe_RowCollection(object):
 
     def it_knows_how_many_rows_it_contains(self, rows_fixture):
