Python base.load_config函数代码示例

 def test_not_use_directory_urls(self):
     md_text = 'An [internal link](internal.md) to another document.'
     expected = '<p>An <a href="internal/index.html">internal link</a> to another document.</p>'
     config = load_config(pages=['index.md', 'internal.md'], use_directory_urls=False)
     page, nav = build_page(None, 'index.md', config, md_text)
     page.render(config, nav)
     self.assertEqual(page.content.strip(), expected.strip())

 def test_get_files_exclude_readme_with_index(self, tdir):
     config = load_config(docs_dir=tdir)
     files = get_files(config)
     expected = ['index.md', 'foo.md']
     self.assertIsInstance(files, Files)
     self.assertEqual(len(files), len(expected))
     self.assertEqual([f.src_path for f in files], expected)

 def test_populate_page_dirty_modified(self, site_dir):
     cfg = load_config(site_dir=site_dir)
     file = File('testing.md', cfg['docs_dir'], cfg['site_dir'], cfg['use_directory_urls'])
     page = Page('Foo', file, cfg)
     build._populate_page(page, cfg, Files([file]), dirty=True)
     self.assertTrue(page.markdown.startswith('# Welcome to MkDocs'))
     self.assertTrue(page.content.startswith('<h1 id="welcome-to-mkdocs">Welcome to MkDocs</h1>'))

    def test_copying_media(self):
        with TemporaryDirectory() as docs_dir, TemporaryDirectory() as site_dir:
            # Create a non-empty markdown file, image, html file, dot file and dot directory.
            f = open(os.path.join(docs_dir, 'index.md'), 'w')
            f.write(dedent("""
                page_title: custom title

                # Heading 1

                This is some text.

                # Heading 2

                And some more text.
            """))
            f.close()
            open(os.path.join(docs_dir, 'img.jpg'), 'w').close()
            open(os.path.join(docs_dir, 'example.html'), 'w').close()
            open(os.path.join(docs_dir, '.hidden'), 'w').close()
            os.mkdir(os.path.join(docs_dir, '.git'))
            open(os.path.join(docs_dir, '.git/hidden'), 'w').close()

            cfg = load_config(docs_dir=docs_dir, site_dir=site_dir)
            build.build(cfg)

            # Verify only the markdown (coverted to html) and the image are copied.
            self.assertTrue(os.path.isfile(os.path.join(site_dir, 'index.html')))
            self.assertTrue(os.path.isfile(os.path.join(site_dir, 'img.jpg')))
            self.assertTrue(os.path.isfile(os.path.join(site_dir, 'example.html')))
            self.assertFalse(os.path.isfile(os.path.join(site_dir, '.hidden')))
            self.assertFalse(os.path.isfile(os.path.join(site_dir, '.git/hidden')))

    def test_deploy_ignore_version(self, mock_import, check_version, get_remote, get_sha, is_repo):

        config = load_config(
            remote_branch='test',
        )
        gh_deploy.gh_deploy(config, ignore_version=True)
        check_version.assert_not_called()

 def test_ignore_external_link(self):
     md_text = 'An [external link](http://example.com/external.md).'
     expected = '<p>An <a href="http://example.com/external.md">external link</a>.</p>'
     config = load_config(pages=[{'Home': 'index.md'}])
     page, nav = build_page(None, 'index.md', config, md_text)
     page.render(config, nav)
     self.assertEqual(page.content.strip(), expected.strip())

    def test_BOM(self):
        docs_dir = tempfile.mkdtemp()
        site_dir = tempfile.mkdtemp()
        try:
            # Create an UTF-8 Encoded file with BOM (as Micorsoft editors do). See #1186.
            f = io.open(os.path.join(docs_dir, 'index.md'), 'w', encoding='utf-8-sig')
            f.write('# An UTF-8 encoded file with a BOM')
            f.close()

            cfg = load_config(
                docs_dir=docs_dir,
                site_dir=site_dir
            )
            build.build(cfg)

            # Verify that the file was generated properly.
            # If the BOM is not removed, Markdown will return:
            # `<p>\ufeff# An UTF-8 encoded file with a BOM</p>`.
            f = io.open(os.path.join(site_dir, 'index.html'), 'r', encoding='utf-8')
            output = f.read()
            f.close()
            self.assertTrue(
                '<h1 id="an-utf-8-encoded-file-with-a-bom">An UTF-8 encoded file with a BOM</h1>' in output
            )

        finally:
            shutil.rmtree(docs_dir)
            shutil.rmtree(site_dir)

 def test_convert_multiple_internal_links(self):
     md_text = '[First link](first.md) [second link](second.md).'
     expected = '<p><a href="first/">First link</a> <a href="second/">second link</a>.</p>'
     config = load_config(pages=['index.md', 'first.md', 'second.md'])
     page, nav = build_page(None, 'index.md', config, md_text)
     page.render(config, nav)
     self.assertEqual(page.content.strip(), expected.strip())

    def test_edit_uri_query_string(self):

        pages = [
            'index.md',
            'internal.md',
            'sub/internal.md',
            'sub1/sub2/internal.md',
        ]

        # Ensure query strings are supported
        repo_url = 'http://example.com'
        edit_uri = '?query=edit/master/docs/'

        site_navigation = nav.SiteNavigation(load_config(
            pages=pages,
            repo_url=repo_url,
            edit_uri=edit_uri,
            site_dir='site',
            site_url='',
            use_directory_urls=True
        ))

        expected_results = (
            repo_url + edit_uri + pages[0],
            repo_url + edit_uri + pages[1],
            repo_url + edit_uri + pages[2],
            repo_url + edit_uri + pages[3],
        )

        for idx, page in enumerate(site_navigation.walk_pages()):
            self.assertEqual(page.edit_url, expected_results[idx])

    def test_strict_mode_valid(self):
        pages = [
            'index.md',
            'internal.md',
            'sub/internal.md',
        ]

        md_text = "[test](internal.md)"

        config = load_config(pages=pages, strict=False)
        page, nav = build_page(None, 'index.md', config, md_text)
        page.render(config, nav)

        config = load_config(pages=pages, strict=True)
        page, nav = build_page(None, 'index.md', config, md_text)
        page.render(config, nav)

 def test_indented_toc(self):
     pages = [
         {'Home': 'index.md'},
         {'API Guide': [
             {'Running': 'api-guide/running.md'},
             {'Testing': 'api-guide/testing.md'},
             {'Debugging': 'api-guide/debugging.md'},
         ]},
         {'About': [
             {'Release notes': 'about/release-notes.md'},
             {'License': 'about/license.md'}
         ]}
     ]
     expected = dedent("""
     Home - /
     API Guide
         Running - /api-guide/running/
         Testing - /api-guide/testing/
         Debugging - /api-guide/debugging/
     About
         Release notes - /about/release-notes/
         License - /about/license/
     """)
     site_navigation = nav.SiteNavigation(load_config(pages=pages))
     self.assertEqual(str(site_navigation).strip(), expected)
     self.assertEqual(len(site_navigation.nav_items), 3)
     self.assertEqual(len(site_navigation.pages), 6)

    def test_edit_uri_sub_dir_missing_slash(self):

        pages = [
            'index.md',
            'internal.md',
            'sub/internal.md',
            'sub1/sub2/internal.md',
        ]

        # Basic test
        repo_url = 'http://example.com/foo'
        edit_uri = 'edit/master/docs'

        site_navigation = nav.SiteNavigation(load_config(
            pages=pages,
            repo_url=repo_url,
            edit_uri=edit_uri,
            site_dir='site',
            site_url='',
            use_directory_urls=True
        ))

        expected_results = (
            repo_url + '/' + edit_uri + '/' + pages[0],
            repo_url + '/' + edit_uri + '/' + pages[1],
            repo_url + '/' + edit_uri + '/' + pages[2],
            repo_url + '/' + edit_uri + '/' + pages[3],
        )

        for idx, page in enumerate(site_navigation.walk_pages()):
            self.assertEqual(page.edit_url, expected_results[idx])

    def test_force_abs_urls_with_base(self):
        """
        Verify force absolute URLs
        """

        pages = [
            'index.md',
            'api-guide/running.md',
            'about/notes.md',
            'about/sub/license.md',
        ]

        url_context = nav.URLContext()
        url_context.force_abs_urls = True
        url_context.base_path = '/foo/'
        nav_items, pages = nav._generate_site_navigation(load_config(pages=pages), url_context)

        self.assertEqual([n.title for n in nav_items],
                         ['Home', 'Running', 'Notes', 'License'])
        self.assertEqual([n.url for n in nav_items], [
            '/foo/',
            '/foo/api-guide/running/',
            '/foo/about/notes/',
            '/foo/about/sub/license/'
        ])

    def test_generate_site_navigation(self):
        """
        Verify inferring page titles based on the filename
        """

        pages = [
            'index.md',
            'api-guide/running.md',
            'about/notes.md',
            'about/sub/license.md',
        ]

        url_context = nav.URLContext()
        nav_items, pages = nav._generate_site_navigation(load_config(pages=pages), url_context)

        self.assertEqual([n.title for n in nav_items],
                         ['Home', 'Running', 'Notes', 'License'])
        self.assertEqual([n.url for n in nav_items], [
            '.',
            'api-guide/running/',
            'about/notes/',
            'about/sub/license/'
        ])
        self.assertEqual([p.title for p in pages],
                         ['Home', 'Running', 'Notes', 'License'])

 def test_base_url(self):
     pages = [
         'index.md'
     ]
     site_navigation = nav.SiteNavigation(load_config(pages=pages, use_directory_urls=False))
     base_url = site_navigation.url_context.make_relative('/')
     self.assertEqual(base_url, '.')