def test_compile_reg_put_replace_whole_tree(self):
        root = self.tree_with_paragraphs()

        change2a = {
            'action': 'PUT',
            'node': {
                'text': 'new text',
                'label': ['205', '2', 'a'],
                'node_type': 'regtext'}}

        change2a1 = {
            'action': 'PUT',
            'node': {
                'text': '2a1 text',
                'label': ['205', '2', 'a', '1'],
                'node_type': 'regtext'}}

        notice_changes = {
            '205-2-a-1': [change2a1],
            '205-2-a': [change2a]
        }

        reg = compiler.compile_regulation(root, notice_changes)

        added_node = find(reg, '205-2-a')
        self.assertEqual(added_node.text, 'new text')

        deeper = find(reg, '205-2-a-1')
        self.assertEqual(deeper.text, '2a1 text')

    def test_compile_designate(self):
        root = self.tree_with_subparts()
        change = {
            'action': 'POST',
            'subpart': ['205', 'Subpart', 'B'],
            'node': {
                'text': '2 text',
                'label': ['205', '2'],
                'node_type': 'regtext'}}

        notice_changes = {'205-2': [change]}
        reg = compiler.compile_regulation(root, notice_changes)

        subpart_b = find(reg, '205-Subpart-B')
        self.assertEqual(len(subpart_b.children), 1)

        subpart_a = find(reg, '205-Subpart-A')
        self.assertEqual(len(subpart_a.children), 0)

        change = {
            'action': 'DESIGNATE',
            'destination': ['205', 'Subpart', 'A']}

        notice_changes = {'205-2': [change]}

        new_reg = compiler.compile_regulation(reg, notice_changes)

        self.assertEqual(None, find(new_reg, '205-Subpart-B'))

        subpart_a = find(new_reg, '205-Subpart-A')
        self.assertEqual(len(subpart_a.children), 1)

    def test_compile_designate(self):
        root = self.tree_with_subparts()
        change = {
            "action": "POST",
            "subpart": ["205", "Subpart", "B"],
            "node": Node(text="2 text", label=["205", "2"], node_type=Node.REGTEXT),
        }

        notice_changes = {"205-2": [change]}
        reg = compiler.compile_regulation(root, notice_changes)

        subpart_b = find(reg, "205-Subpart-B")
        self.assertEqual(len(subpart_b.children), 1)

        subpart_a = find(reg, "205-Subpart-A")
        self.assertEqual(len(subpart_a.children), 0)

        change = {"action": "DESIGNATE", "destination": ["205", "Subpart", "A"]}

        notice_changes = {"205-2": [change]}

        new_reg = compiler.compile_regulation(reg, notice_changes)

        self.assertEqual(None, find(new_reg, "205-Subpart-B"))

        subpart_a = find(new_reg, "205-Subpart-A")
        self.assertEqual(len(subpart_a.children), 1)

    def test_create_empty(self):
        root = self.tree_with_paragraphs()
        reg_tree = compiler.RegulationTree(root)
        reg_tree.create_empty_node("205-4-a")

        node = find(reg_tree.tree, "205-4-a")
        self.assertNotEqual(None, node)
        self.assertEqual(node.label, ["205", "4", "a"])
        self.assertEqual(node.node_type, Node.REGTEXT)

        node = Node(label=["205", "M2"], title="Appendix M2", node_type=Node.APPENDIX)
        reg_tree.add_node(node)
        reg_tree.create_empty_node("205-M2-1")
        node = find(reg_tree.tree, "205-M2-1")
        self.assertNotEqual(None, node)
        self.assertEqual(node.label, ["205", "M2", "1"])
        self.assertEqual(node.node_type, Node.APPENDIX)

        node = Node(label=["205", Node.INTERP_MARK], title="Supplement I", node_type=Node.INTERP)
        reg_tree.add_node(node)
        reg_tree.create_empty_node("205-3-Interp")
        node = find(reg_tree.tree, "205-3-Interp")
        self.assertNotEqual(None, node)
        self.assertEqual(node.label, ["205", "3", Node.INTERP_MARK])
        self.assertEqual(node.node_type, Node.INTERP)

    def test_create_empty(self):
        root = self.tree_with_paragraphs()
        reg_tree = compiler.RegulationTree(root)
        reg_tree.create_empty_node('205-4-a')

        node = find(reg_tree.tree, '205-4-a')
        self.assertNotEqual(None, node)
        self.assertEqual(node.label, ['205', '4', 'a'])
        self.assertEqual(node.node_type, Node.REGTEXT)

        node = Node(label=['205', 'M2'], title='Appendix M2',
                    node_type=Node.APPENDIX)
        reg_tree.add_node(node)
        reg_tree.create_empty_node('205-M2-1')
        node = find(reg_tree.tree, '205-M2-1')
        self.assertNotEqual(None, node)
        self.assertEqual(node.label, ['205', 'M2', '1'])
        self.assertEqual(node.node_type, Node.APPENDIX)

        node = Node(label=['205', Node.INTERP_MARK], title='Supplement I',
                    node_type=Node.INTERP)
        reg_tree.add_node(node)
        reg_tree.create_empty_node('205-3-Interp')
        node = find(reg_tree.tree, '205-3-Interp')
        self.assertNotEqual(None, node)
        self.assertEqual(node.label, ['205', '3', Node.INTERP_MARK])
        self.assertEqual(node.node_type, Node.INTERP)

    def move_to_subpart(self, label, subpart_label):
        """ Move an existing node to another subpart. If the new subpart
        doesn't exist, create it. """
        if len(label.split('-')) != 2:
            logger.error(
                "Trying to move a non-section into a subpart: %s -> %s",
                label, subpart_label)
            return

        destination = find(self.tree, '-'.join(subpart_label))

        if destination is None:
            destination = self.create_new_subpart(subpart_label)

        subpart_with_node = find_parent(self.tree, label)

        if destination and subpart_with_node:
            node = find(subpart_with_node, label)
            other_children = [c for c in subpart_with_node.children
                              if c.label_id() != label]
            subpart_with_node.children = other_children
            destination.children = self.add_child(destination.children, node)

            if not subpart_with_node.children:
                self.delete('-'.join(subpart_with_node.label))

 def test_compile_reg_move_wrong_reg(self):
     """Changes applied to other regulations shouldn't affect the
     regulation we care about, even if that has the same textual prefix"""
     root = self.tree_with_paragraphs()
     notice_changes = {"2055-2-a": [{"action": "MOVE", "destination": ["2055", "2", "b"]}]}
     reg = compiler.compile_regulation(root, notice_changes)
     self.assertEqual(find(reg, "205-2-a").text, "n2a")
     self.assertEqual(find(reg, "205-2-b").text, "n2b")
     self.assertEqual(find(reg, "2055-2-b"), None)

    def test_delete_section_in_subpart(self):
        """Verify that we can delete a section within a subpart"""
        root = self.tree_with_subparts()
        root.children[0].children = [Node(label=['205', '12'])]
        reg_tree = compiler.RegulationTree(root)

        self.assertNotEqual(None, find(reg_tree.tree, '205-12'))
        reg_tree.delete('205-12')
        self.assertEqual(None, find(reg_tree.tree, '205-12'))

    def add_section(self, node, subpart_label):
        """ Add a new section to a subpart. """

        existing = find(self.tree, node.label_id())
        if existing and is_reserved_node(existing):
            logging.warning('Replacing reserved node: {0}'.format(node.label_id()))
            self.replace_node_and_subtree(node)
        else:
            subpart = find(self.tree, '-'.join(subpart_label))
            subpart.children = self.add_child(subpart.children, node)

 def test_compile_reg_move_wrong_reg(self):
     """Changes applied to other regulations shouldn't affect the
     regulation we care about, even if that has the same textual prefix"""
     root = self.tree_with_paragraphs()
     notice_changes = {'2055-2-a': [{'action': 'MOVE',
                                    'destination': ['2055', '2', 'b']}]}
     reg = compiler.compile_regulation(root, notice_changes)
     self.assertEqual(find(reg, '205-2-a').text, 'n2a')
     self.assertEqual(find(reg, '205-2-b').text, 'n2b')
     self.assertEqual(find(reg, '2055-2-b'), None)

    def test_delete(self):
        root = self.tree_with_paragraphs()
        reg_tree = compiler.RegulationTree(root)

        self.assertNotEqual(None, find(reg_tree.tree, '205-2-a'))
        reg_tree.delete('205-2-a')
        self.assertEqual(None, find(reg_tree.tree, '205-2-a'))

        # Verify this doesn't cause an error
        reg_tree.delete('205-2-a')

    def test_replace_node_heading(self):
        root = self.tree_with_paragraphs()
        n2a = find(root, "205-2-a")
        n2a.text = "Previous keyterm. Remainder."
        reg_tree = compiler.RegulationTree(root)

        change = {"node": Node(text="Replaced.")}
        reg_tree.replace_node_heading("205-2-a", change)

        changed_node = find(reg_tree.tree, "205-2-a")
        self.assertEqual(changed_node.text, "Replaced. Remainder.")

    def test_replace_node_heading(self):
        root = self.tree_with_paragraphs()
        n2a = find(root, '205-2-a')
        n2a.text = 'Previous keyterm. Remainder.'
        reg_tree = compiler.RegulationTree(root)

        change = {'node': {'text': 'Replaced.'}}
        reg_tree.replace_node_heading('205-2-a', change)

        changed_node = find(reg_tree.tree, '205-2-a')
        self.assertEqual(changed_node.text, 'Replaced. Remainder.')

    def test_move_to_subpart(self):
        sect5, sect7 = Node(label=["111", "5"]), Node(label=["111", "7"])
        sub_a = Node(label=["111", "Subpart", "A"], node_type=Node.SUBPART, children=[sect5])
        sub_b = Node(label=["111", "Subpart", "B"], node_type=Node.SUBPART, children=[sect7])

        root = Node(children=[sub_a, sub_b], label=["111"])
        tree = compiler.RegulationTree(root)
        tree.move_to_subpart("111-5", sub_b.label)
        sub_b = find(tree.tree, "111-Subpart-B")
        sect5, sect7 = find(tree.tree, "111-5"), find(tree.tree, "111-7")
        self.assertEqual([sub_b], tree.tree.children)
        self.assertEqual([sect5, sect7], sub_b.children)

    def test_reserve_existing(self):
        root = self.tree_with_paragraphs()
        reg_tree = compiler.RegulationTree(root)

        before_reserve = find(reg_tree.tree, '205-2-a')
        self.assertNotEqual(before_reserve.text, '[Reserved]')

        n2 = Node('[Reserved]', label=['205', '2'])
        reg_tree.reserve('205-2', n2)
        after_reserve = find(reg_tree.tree, '205-2')
        self.assertEqual(after_reserve.text, '[Reserved]')

        reserve_child = find(reg_tree.tree, '205-2-a')
        self.assertEqual(None, reserve_child)

    def test_move_to_subpart(self):
        sect5, sect7 = Node(label=['111', '5']), Node(label=['111', '7'])
        sub_a = Node(label=['111', 'Subpart', 'A'], node_type=Node.SUBPART,
                     children=[sect5])
        sub_b = Node(label=['111', 'Subpart', 'B'], node_type=Node.SUBPART,
                     children=[sect7])

        root = Node(children=[sub_a, sub_b], label=['111'])
        tree = compiler.RegulationTree(root)
        tree.move_to_subpart('111-5', sub_b.label)
        sub_b = find(tree.tree, '111-Subpart-B')
        sect5, sect7 = find(tree.tree, '111-5'), find(tree.tree, '111-7')
        self.assertEqual([sub_b], tree.tree.children)
        self.assertEqual([sect5, sect7], sub_b.children)

    def test_add_node_reserved(self):
        root = self.tree_with_paragraphs()
        reserved_node = Node('[Reserved]', label=['205', '2', 'a', '1'])
        n2a = find(root, '205-2-a')
        n2a.children = [reserved_node]

        reg_tree = compiler.RegulationTree(root)

        parent = find(reg_tree.tree, '205-2-a')
        self.assertEqual(len(parent.children), 1)
        new_node = Node('(i) new content', label=['205', '2', 'a', '1'])
        reg_tree.add_node(new_node)

        added_node = find(reg_tree.tree, '205-2-a-1')
        self.assertEqual(added_node.text, '(i) new content')
        self.assertEqual(len(parent.children), 1)

    def test_get_parent(self):
        root = self.tree_with_paragraphs()
        reg_tree = compiler.RegulationTree(root)

        node = find(reg_tree.tree, '205-2-a')
        parent = reg_tree.get_parent(node)
        self.assertEqual(parent.label, ['205', '2'])

def create_add_amendment(amendment):
    """ An amendment comes in with a whole tree structure. We break apart the
    tree here (this is what flatten does), convert the Node objects to JSON
    representations. This ensures that each amendment only acts on one node.
    In addition, this futzes with the change's field when stars are present.
    """

    nodes_list = []
    flatten_tree(nodes_list, amendment['node'])
    changes = [format_node(n, amendment) for n in nodes_list]

    for change in filter(lambda c: c.values()[0]['action'] == 'PUT', changes):
        label = change.keys()[0]
        node = struct.find(amendment['node'], label)
        text = node.text.strip()
        marker = marker_of(node)
        text = text[len(marker):].strip()
        # Text is stars, but this is not the root. Explicitly try to keep
        # this node
        if text == '* * *':
            change[label]['action'] = 'KEEP'

        # If text ends with a colon and is followed by stars, assume we are
        # only modifying the intro text
        if (text[-1:] == ':' and node.label == amendment['node'].label
                and node.source_xml is not None):
            following = node.source_xml.getnext()
            if following is not None and following.tag == 'STARS':
                change[label]['field'] = '[text]'

    return changes

    def test_replace_node_and_subtree(self):
        n1 = Node("n1", label=["205", "1"])
        n2 = Node("n2", label=["205", "2"])
        n4 = Node("n4", label=["205", "4"])

        n2a = Node("n2a", label=["205", "2", "a"])
        n2b = Node("n2b", label=["205", "2", "b"])
        n2.children = [n2a, n2b]

        root = Node("", label=["205"])
        root.children = [n1, n2, n4]

        reg_tree = compiler.RegulationTree(root)

        a2 = Node("a2", label=["205", "2"])
        a2e = Node("a2e", label=["205", "2", "e"])
        a2f = Node("a2f", label=["205", "2", "f"])
        a2.children = [a2e, a2f]

        reg_tree.replace_node_and_subtree(a2)

        new_tree = Node("", label=[205])
        new_tree.children = [n1, a2, n4]

        self.assertEqual(new_tree, reg_tree.tree)
        self.assertEqual(None, find(reg_tree.tree, "205-2-a"))