text: add Run.bold setter

Steve Canny · Steve Canny · commit 6be61e434d4e · 2014-01-04T07:33:24.000-08:00
diff --git a/docx/oxml/shared.py b/docx/oxml/shared.py
@@ -186,6 +186,15 @@ def val(self):
             return True
         raise ValidationError("expected xsd:boolean, got '%s'" % val)
 
+    @val.setter
+    def val(self, value):
+        val = qn('w:val')
+        if bool(value) is True:
+            if val in self.attrib:
+                del self.attrib[val]
+        else:
+            self.set(val, '0')
+
 
 class CT_String(OxmlBaseElement):
     """
diff --git a/docx/oxml/text.py b/docx/oxml/text.py
@@ -209,6 +209,15 @@ def add_t(self, text):
         self.append(t)
         return t
 
+    def get_or_add_rPr(self):
+        """
+        Return the rPr child element, newly added if not present.
+        """
+        rPr = self.rPr
+        if rPr is None:
+            rPr = self._add_rPr()
+        return rPr
+
     @classmethod
     def new(cls):
         """
@@ -230,18 +239,46 @@ def t_lst(self):
         """
         return self.findall(qn('w:t'))
 
+    def _add_rPr(self):
+        """
+        Return a newly added rPr child element. Assumes one is not present.
+        """
+        rPr = CT_RPr.new()
+        self.insert(0, rPr)
+        return rPr
+
 
 class CT_RPr(OxmlBaseElement):
     """
     ``<w:rPr>`` element, containing the properties for a run.
     """
+    def add_b(self):
+        """
+        Return a newly added <w:b/> child element.
+        """
+        b = OxmlElement('w:b')
+        self.insert(0, b)
+        return b
+
     @property
     def b(self):
         """
         First ``<w:b>`` child element or None if none are present.
         """
         return self.find(qn('w:b'))
 
+    @classmethod
+    def new(cls):
+        """
+        Return a new ``<w:rPr>`` element.
+        """
+        return OxmlElement('w:rPr')
+
+    def remove_b(self):
+        b_lst = self.findall(qn('w:b'))
+        for b in b_lst:
+            self.remove(b)
+
 
 class CT_Text(OxmlBaseElement):
     """
diff --git a/docx/text.py b/docx/text.py
@@ -106,6 +106,15 @@ def bold(self):
             return None
         return b.val
 
+    @bold.setter
+    def bold(self, value):
+        rPr = self._r.get_or_add_rPr()
+        rPr.remove_b()
+        if value is not None:
+            b = rPr.add_b()
+            if bool(value) is False:
+                b.val = False
+
     @property
     def text(self):
         """
diff --git a/features/run-bold-italic.feature b/features/run-bold-italic.feature
@@ -3,19 +3,16 @@ Feature: Apply bold or italic to run
   As a python-docx developer
   I need a way to query and set bold and italic on a run
 
-  @wip
   Scenario: Apply bold to a run
     Given a run
      When I assign True to its bold property
      Then the run appears in bold typeface
 
-  @wip
   Scenario: Remove bold from a run
     Given a run having bold set on
      When I assign None to its bold property
      Then the run appears with its inherited bold setting
 
-  @wip
   Scenario: Set bold off unconditionally
     Given a run
      When I assign False to its bold property
diff --git a/tests/test_api.py b/tests/test_api.py
@@ -99,7 +99,6 @@ def it_can_add_a_table(self, add_table_fixture):
             add_table_fixture
         )
         table = document.add_table(rows, cols, style)
-        print(table)
         document_part_.add_table.assert_called_once_with(rows, cols)
         assert table.style == expected_style
         assert table == table_
diff --git a/tests/test_text.py b/tests/test_text.py
@@ -90,11 +90,15 @@ def text_prop_fixture(self):
 
 class DescribeRun(object):
 
-    def it_knows_if_its_bold(self, bold_fixture):
-        run, is_bold = bold_fixture
-        print('\n%s' % run._r.xml)
+    def it_knows_if_its_bold(self, bold_get_fixture):
+        run, is_bold = bold_get_fixture
         assert run.bold == is_bold
 
+    def it_can_change_its_bold_setting(self, bold_set_fixture):
+        run, bold_value, expected_xml = bold_set_fixture
+        run.bold = bold_value
+        assert run._r.xml == expected_xml
+
     def it_can_add_text(self, add_text_fixture):
         run, text_str, expected_xml, Text_ = add_text_fixture
         _text = run.add_text(text_str)
@@ -143,7 +147,7 @@ def add_text_fixture(self, run, Text_):
         return run, text_str, expected_xml, Text_
 
     @pytest.fixture(params=[True, False, None])
-    def bold_fixture(self, request):
+    def bold_get_fixture(self, request):
         is_bold = request.param
         r_bldr = an_r().with_nsdecls()
         if is_bold is not None:
@@ -156,6 +160,23 @@ def bold_fixture(self, request):
         run = Run(r)
         return run, is_bold
 
+    @pytest.fixture(params=[True, False, None])
+    def bold_set_fixture(self, request):
+        # run --------------------------
+        r = an_r().with_nsdecls().element
+        run = Run(r)
+        # bold_value -------------------
+        bold_value = request.param
+        # expected_xml -----------------
+        rPr_bldr = an_rPr()
+        if bold_value is not None:
+            b_bldr = a_b()
+            if bold_value is False:
+                b_bldr.with_val(0)
+            rPr_bldr.with_child(b_bldr)
+        expected_xml = an_r().with_nsdecls().with_child(rPr_bldr).xml()
+        return run, bold_value, expected_xml
+
     @pytest.fixture
     def run(self):
         r = an_r().with_nsdecls().element

Original file line number	Diff line number	Diff line change
`@@ -99,7 +99,6 @@ def it_can_add_a_table(self, add_table_fixture):`
`99`	`99`	`add_table_fixture`
`100`	`100`	`)`
`101`	`101`	`table = document.add_table(rows, cols, style)`
`102`		`- print(table)`
`103`	`102`	`document_part_.add_table.assert_called_once_with(rows, cols)`
`104`	`103`	`assert table.style == expected_style`
`105`	`104`	`assert table == table_`