Python path Examples

Example #1

File: style_reader_tests.py Project: bsteverink/python-mammoth

def document_matcher_is_mapped_to_html_path_using_fat_arrow():
    style_result = read_style("p => h1")
    assert_equal(
        styles.style(document_matchers.paragraph(), html_paths.path([html_paths.element(["h1"])])),
        style_result.value
    )
    assert_equal([], style_result.messages)

Example #2

def document_matcher_is_mapped_to_html_path_using_fat_arrow():
    style_result = read_style("p => h1")
    assert_equal(
        styles.style(document_matchers.paragraph(), html_paths.path([html_paths.element(["h1"])])),
        style_result.value
    )
    assert_equal([], style_result.messages)

Example #3

File: html_generation_tests.py Project: tianqj/python-mammoth

 def already_opened_elements_are_not_closed(self):
     generator = _create_html_generator()
     generator.start("strong")
     path = html_paths.path([html_paths.element(["em"])])
     append_html_path(generator, path)
     generator.text("Hello!")
     assert_equal('<strong><em>Hello!', generator.as_string())

Example #4

File: html_generation_tests.py Project: esperyong/python-mammoth

 def attributes_are_generated_when_satisfying_elements(self):
     generator = HtmlGenerator()
     path = html_paths.path(
         [html_paths.element(["p"], class_names=["tip"])])
     satisfy_html_path(generator, path)
     generator.text("Hello")
     assert_equal('<p class="tip">Hello', generator.html_string())

Example #5

 def elements_do_not_match_if_class_names_do_not_match(self):
     generator = _create_html_generator()
     generator.start("p", {"class": "help"})
     generator.text("Help")
     path = html_paths.path([html_paths.element(["p"], class_names=["tip"])])
     satisfy_html_path(generator, path)
     generator.text("Tip")
     assert_equal('<p class="help">Help</p><p class="tip">Tip', generator.as_string())

Example #6

File: html_generation_tests.py Project: CuchulainX/python-mammoth

 def no_elements_are_generated_if_all_path_elements_are_already_satisfied(self):
     generator = _create_html_generator()
     generator.start("p")
     generator.text("Hello")
     path = html_paths.path([html_paths.element(["p"])])
     satisfy_html_path(generator, path)
     generator.text("there")
     assert_equal('<p>Hellothere', generator.as_string())

Example #7

 def only_missing_elements_are_generated_to_satisfy_plain_path_elements(self):
     generator = _create_html_generator()
     generator.start("blockquote")
     generator.text("Hello")
     path = html_paths.path([html_paths.element(["blockquote"]), html_paths.element(["p"])])
     satisfy_html_path(generator, path)
     generator.text("there")
     assert_equal('<blockquote>Hello<p>there', generator.as_string())

Example #8

 def class_names_match_if_they_are_the_same(self):
     generator = _create_html_generator()
     generator.start("p", {"class": "tip"})
     generator.text("Help")
     path = html_paths.path([html_paths.element(["p"], class_names=["tip"])])
     satisfy_html_path(generator, path)
     generator.text("Tip")
     assert_equal('<p class="tip">HelpTip', generator.as_string())

Example #9

File: style_reader_tests.py Project: kmb232/python-mammoth

 def can_read_multiple_attributes_on_element(self):
     assert_equal(
         html_paths.path([
             html_paths.element(["li"], class_names=[],
                                extra_attributes={'id': 'one',
                                                  'type': 'i',
                                                  'name': 'test'})]),
         read_html_path("li{id=one,type=i,name=test}")
     )

Example #10

 def fresh_element_matches_nothing(self):
     generator = _create_html_generator()
     generator.start("blockquote")
     generator.start("p")
     generator.text("Hello")
     path = html_paths.path([html_paths.element(["blockquote"]), html_paths.element(["p"], fresh=True)])
     satisfy_html_path(generator, path)
     generator.text("there")
     assert_equal('<blockquote><p>Hello</p><p>there', generator.as_string())

Example #11

File: html_generation_tests.py Project: JoshBarr/python-mammoth

 def mismatched_elements_are_closed_to_satisfy_plain_path_elements(self):
     generator = HtmlGenerator()
     generator.start("blockquote")
     generator.start("span")
     generator.text("Hello")
     path = html_paths.path([html_paths.element(["blockquote"]), html_paths.element(["p"])])
     satisfy_html_path(generator, path)
     generator.text("there")
     assert_equal('<blockquote><span>Hello</span><p>there', generator.html_string())

Example #12

File: style_reader_tests.py Project: kmb232/python-mammoth

 def can_read_all_the_things_on_element(self):
     assert_equal(
         html_paths.path([
             html_paths.element(["p"], class_names=["tip", "top"],
                                extra_attributes={'id': 'para',
                                                  'data': 'ordered',
                                                  'name': 'test'},
                                fresh=True)]),
         read_html_path("p.tip.top{id=para,data=ordered,name=test}:fresh")
     )

Example #13

File: html_generation_tests.py Project: esperyong/python-mammoth

 def mismatched_elements_are_closed_to_satisfy_plain_path_elements(self):
     generator = HtmlGenerator()
     generator.start("blockquote")
     generator.start("span")
     generator.text("Hello")
     path = html_paths.path(
         [html_paths.element(["blockquote"]),
          html_paths.element(["p"])])
     satisfy_html_path(generator, path)
     generator.text("there")
     assert_equal('<blockquote><span>Hello</span><p>there',
                  generator.html_string())

Example #14

def can_read_class_on_element():
    assert_equal(
        html_paths.path([html_paths.element(["p"], class_names=["tip"])]),
        read_html_path("p.tip"))

Example #15

def can_read_separator_for_elements():
    assert_equal(html_paths.path([html_paths.element(["p"], separator="x")]),
                 read_html_path("p:separator('x')"))

Example #16

File: style_reader_tests.py Project: esperyong/python-mammoth

 def can_read_single_element(self):
     assert_equal(
         html_paths.path([html_paths.element(["p"])]),
         read_html_path("p")
     )

Example #17

File: style_reader_tests.py Project: esperyong/python-mammoth

 def can_read_when_element_must_be_fresh(self):
     assert_equal(
         html_paths.path([html_paths.element(["p"], fresh=True)]),
         read_html_path("p:fresh")
     )

Example #18

File: style_reader_tests.py Project: esperyong/python-mammoth

 def can_read_multiple_classes_on_element(self):
     assert_equal(
         html_paths.path([html_paths.element(["p"], class_names=["tip", "help"])]),
         read_html_path("p.tip.help")
     )

Example #19

File: style_reader_tests.py Project: esperyong/python-mammoth

 def can_read_nested_elements(self):
     assert_equal(
         html_paths.path([html_paths.element(["ul"]), html_paths.element(["li"])]),
         read_html_path("ul > li")
     )

Example #20

File: style_reader_tests.py Project: esperyong/python-mammoth

 def can_read_choice_of_three_elements(self):
     assert_equal(
         html_paths.path([html_paths.element(["ul", "ol", "p"])]),
         read_html_path("ul|ol|p")
     )

Example #21

File: style_reader_tests.py Project: kmb232/python-mammoth

 def can_read_attribute_on_element(self):
     assert_equal(
         html_paths.path([html_paths.element(["li"], class_names=[],
                                             extra_attributes={'type': '1'})]),
         read_html_path("li{type=1}")
     )

Example #22

File: html_generation_tests.py Project: akkana/python-mammoth

 def attributes_are_generated_when_satisfying_elements(self):
     generator = _create_html_generator()
     path = html_paths.path([html_paths.element(["p"], class_names=["tip"])])
     satisfy_html_path(generator, path)
     generator.text("Hello")
     assert_equal('<p class="tip">Hello', generator.as_string())

Example #23

File: html_path_parser_tests.py Project: mwilliamson/python-mammoth

def can_read_class_on_element():
    assert_equal(
        html_paths.path([html_paths.element(["p"], class_names=["tip"])]),
        read_html_path("p.tip")
    )

Example #24

File: html_path_parser_tests.py Project: mwilliamson/python-mammoth

def can_read_choice_of_two_elements():
    assert_equal(
        html_paths.path([html_paths.element(["ul", "ol"])]),
        read_html_path("ul|ol")
    )

Example #25

File: style_reader_tests.py Project: esperyong/python-mammoth

def document_matcher_is_mapped_to_html_path_using_fat_arrow():
    assert_equal(
        styles.style(document_matchers.paragraph(), html_paths.path([html_paths.element(["h1"])])),
        read_style("p => h1")
    )

Example #26

File: html_path_parser_tests.py Project: mwilliamson/python-mammoth

def can_read_separator_for_elements():
    assert_equal(
        html_paths.path([html_paths.element(["p"], separator="x")]),
        read_html_path("p:separator('x')")
    )

Example #27

 def plain_elements_are_generated_to_satisfy_plain_path_elements(self):
     generator = _create_html_generator()
     path = html_paths.path([html_paths.element(["p"])])
     satisfy_html_path(generator, path)
     generator.text("Hello!")
     assert_equal('<p>Hello!', generator.as_string())

Example #28

def can_read_choice_of_two_elements():
    assert_equal(html_paths.path([html_paths.element(["ul", "ol"])]),
                 read_html_path("ul|ol"))