Rename `articles` to `pages`.

Articles was a good name, but we want an `articles` category in
the future. `/pages/guides/` and `/pages/articles/` are clearer in name
than `/articles/guides/` and `/articles/articles/`.

16 files changed, 164 insertions, 163 deletions

diff --git a/pydis_site/apps/content/tests/test_utils.py b/pydis_site/apps/content/tests/test_utils.py
index 26b2bba9..e1f1b92a 100644
--- a/pydis_site/apps/content/tests/test_utils.py
+++ b/pydis_site/apps/content/tests/test_utils.py
@@ -13,20 +13,20 @@ BASE_PATH = Path(settings.BASE_DIR, "pydis_site", "apps", "content", "tests", "t
 
 
 class TestGetCategory(TestCase):
-    @override_settings(ARTICLES_PATH=BASE_PATH)
+    @override_settings(PAGES_PATH=BASE_PATH)
     def test_get_category_successfully(self):
         """Check does this get right data from category data file."""
         result = utils.get_category(["category"])
 
         self.assertEqual(result, {"name": "My Category", "description": "My Description"})
 
-    @override_settings(ARTICLES_PATH=BASE_PATH)
+    @override_settings(PAGES_PATH=BASE_PATH)
     def test_get_category_not_exists(self):
         """Check does this raise 404 error when category don't exists."""
         with self.assertRaises(Http404):
             utils.get_category(["invalid"])
 
-    @override_settings(ARTICLES_PATH=BASE_PATH)
+    @override_settings(PAGES_PATH=BASE_PATH)
     def test_get_category_not_directory(self):
         """Check does this raise 404 error when category isn't directory."""
         with self.assertRaises(Http404):
@@ -34,7 +34,7 @@ class TestGetCategory(TestCase):
 
 
 class TestGetCategories(TestCase):
-    @override_settings(ARTICLES_PATH=BASE_PATH)
+    @override_settings(PAGES_PATH=BASE_PATH)
     @patch("pydis_site.apps.content.utils.get_category")
     def test_get_categories(self, get_category_mock):
         """Check does this return test content categories."""
@@ -47,7 +47,7 @@ class TestGetCategories(TestCase):
             result, {"category": {"name": "My Category", "description": "My Description"}}
         )
 
-    @override_settings(ARTICLES_PATH=BASE_PATH)
+    @override_settings(PAGES_PATH=BASE_PATH)
     def test_get_categories_root_path(self):
         """Check does this doesn't call joinpath when getting root categories."""
         result = utils.get_categories()
@@ -55,7 +55,7 @@ class TestGetCategories(TestCase):
             result, {"category": {"name": "My Category", "description": "My Description"}}
         )
 
-    @override_settings(ARTICLES_PATH=BASE_PATH)
+    @override_settings(PAGES_PATH=BASE_PATH)
     def test_get_categories_in_category(self):
         """Check does this call joinpath when getting subcategories."""
         result = utils.get_categories(["category"])
@@ -64,11 +64,11 @@ class TestGetCategories(TestCase):
         )
 
 
-class TestGetArticles(TestCase):
-    @override_settings(ARTICLES_PATH=BASE_PATH)
-    def test_get_all_root_articles(self):
+class TestGetPages(TestCase):
+    @override_settings(PAGES_PATH=BASE_PATH)
+    def test_get_all_root_pages(self):
         """Check does this return all root level testing content."""
-        result = utils.get_articles()
+        result = utils.get_pages()
 
         for case in ["test", "test2"]:
             with self.subTest(guide=case):
@@ -77,10 +77,10 @@ class TestGetArticles(TestCase):
                 self.assertIn(case, result)
                 self.assertEqual(md.metadata, result[case])
 
-    @override_settings(ARTICLES_PATH=BASE_PATH)
-    def test_get_all_category_articles(self):
+    @override_settings(PAGES_PATH=BASE_PATH)
+    def test_get_all_category_pages(self):
         """Check does this return all category testing content."""
-        result = utils.get_articles(["category"])
+        result = utils.get_pages(["category"])
 
         md = markdown(BASE_PATH.joinpath("category", "test3.md").read_text(), extras=["metadata"])
 
@@ -88,11 +88,11 @@ class TestGetArticles(TestCase):
         self.assertEqual(md.metadata, result["test3"])
 
 
-class TestGetArticle(TestCase):
-    @override_settings(ARTICLES_PATH=BASE_PATH)
-    def test_get_root_article_success(self):
-        """Check does this return article HTML and metadata when root article exist."""
-        result = utils.get_article(["test"])
+class TestGetPage(TestCase):
+    @override_settings(PAGES_PATH=BASE_PATH)
+    def test_get_root_page_success(self):
+        """Check does this return page HTML and metadata when root page exist."""
+        result = utils.get_page(["test"])
 
         md = markdown(
             BASE_PATH.joinpath("test.md").read_text(),
@@ -107,18 +107,18 @@ class TestGetArticle(TestCase):
             ]
         )
 
-        self.assertEqual(result, {"article": str(md), "metadata": md.metadata})
+        self.assertEqual(result, {"page": str(md), "metadata": md.metadata})
 
-    @override_settings(ARTICLES_PATH=BASE_PATH)
-    def test_get_root_article_dont_exist(self):
-        """Check does this raise Http404 when root article don't exist."""
+    @override_settings(PAGES_PATH=BASE_PATH)
+    def test_get_root_page_dont_exist(self):
+        """Check does this raise Http404 when root page don't exist."""
         with self.assertRaises(Http404):
-            utils.get_article(["invalid"])
+            utils.get_page(["invalid"])
 
-    @override_settings(ARTICLES_PATH=BASE_PATH)
-    def test_get_category_article_success(self):
-        """Check does this return article HTML and metadata when category guide exist."""
-        result = utils.get_article(["category", "test3"])
+    @override_settings(PAGES_PATH=BASE_PATH)
+    def test_get_category_page_success(self):
+        """Check does this return page HTML and metadata when category guide exist."""
+        result = utils.get_page(["category", "test3"])
 
         md = markdown(
             BASE_PATH.joinpath("category", "test3.md").read_text(),
@@ -133,16 +133,16 @@ class TestGetArticle(TestCase):
             ]
         )
 
-        self.assertEqual(result, {"article": str(md), "metadata": md.metadata})
+        self.assertEqual(result, {"page": str(md), "metadata": md.metadata})
 
-    @override_settings(ARTICLES_PATH=BASE_PATH)
-    def test_get_category_article_dont_exist(self):
-        """Check does this raise Http404 when category article don't exist."""
+    @override_settings(PAGES_PATH=BASE_PATH)
+    def test_get_category_page_dont_exist(self):
+        """Check does this raise Http404 when category page don't exist."""
         with self.assertRaises(Http404):
-            utils.get_article(["category", "invalid"])
+            utils.get_page(["category", "invalid"])
 
-    @patch("pydis_site.settings.ARTICLES_PATH", new=BASE_PATH)
-    def test_get_category_article_category_dont_exist(self):
+    @patch("pydis_site.settings.PAGES_PATH", new=BASE_PATH)
+    def test_get_category_page_category_dont_exist(self):
         """Check does this raise Http404 when category don't exist."""
         with self.assertRaises(Http404):
-            utils.get_article(["invalid", "some-guide"])
+            utils.get_page(["invalid", "some-guide"])
diff --git a/pydis_site/apps/content/tests/test_views.py b/pydis_site/apps/content/tests/test_views.py
index 55bfb8ea..5ce18afb 100644
--- a/pydis_site/apps/content/tests/test_views.py
+++ b/pydis_site/apps/content/tests/test_views.py
@@ -6,143 +6,144 @@ from django.http import Http404
 from django.test import RequestFactory, TestCase, override_settings
 from django_hosts.resolvers import reverse
 
-from pydis_site.apps.content.views import ArticleOrCategoryView
+from pydis_site.apps.content.views import PageOrCategoryView
 
 BASE_PATH = Path(settings.BASE_DIR, "pydis_site", "apps", "content", "tests", "test_content")
 
 
-class TestArticlesIndexView(TestCase):
-    @patch("pydis_site.apps.content.views.articles.get_articles")
-    @patch("pydis_site.apps.content.views.articles.get_categories")
-    def test_articles_index_return_200(self, get_categories_mock, get_articles_mock):
+class TestPagesIndexView(TestCase):
+    @patch("pydis_site.apps.content.views.pages.get_pages")
+    @patch("pydis_site.apps.content.views.pages.get_categories")
+    def test_pages_index_return_200(self, get_categories_mock, get_page_mock):
         """Check that content index return HTTP code 200."""
         get_categories_mock.return_value = {}
-        get_articles_mock.return_value = {}
+        get_page_mock.return_value = {}
 
-        url = reverse('content:articles')
+        url = reverse('content:pages')
         response = self.client.get(url)
         self.assertEqual(response.status_code, 200)
-        get_articles_mock.assert_called_once()
+        get_page_mock.assert_called_once()
         get_categories_mock.assert_called_once()
 
 
-class TestArticleOrCategoryView(TestCase):
-    @override_settings(ARTICLES_PATH=BASE_PATH)
-    @patch("pydis_site.apps.content.views.article_category.utils.get_article")
-    @patch("pydis_site.apps.content.views.article_category.utils.get_category")
-    def test_article_return_code_200(self, get_category_mock, get_article_mock):
-        get_article_mock.return_value = {"guide": "test", "metadata": {}}
+class TestPageOrCategoryView(TestCase):
+    @override_settings(PAGES_PATH=BASE_PATH)
+    @patch("pydis_site.apps.content.views.page_category.utils.get_page")
+    @patch("pydis_site.apps.content.views.page_category.utils.get_category")
+    @patch("pydis_site.apps.content.views.page_category.utils.get_github_information")
+    def test_page_return_code_200(self, get_category_mock, get_page_mock):
+        get_page_mock.return_value = {"guide": "test", "metadata": {}}
 
-        url = reverse("content:article_category", args=["test2"])
+        url = reverse("content:page_category", args=["test2"])
         response = self.client.get(url)
         self.assertEqual(response.status_code, 200)
         get_category_mock.assert_not_called()
-        get_article_mock.assert_called_once()
+        get_page_mock.assert_called_once()
 
-    @patch("pydis_site.apps.content.views.article_category.utils.get_article")
-    @patch("pydis_site.apps.content.views.article_category.utils.get_category")
-    @override_settings(ARTICLES_PATH=BASE_PATH)
-    def test_article_return_404(self, get_category_mock, get_article_mock):
-        """Check that return code is 404 when invalid article provided."""
-        get_article_mock.side_effect = Http404("Article not found.")
+    @patch("pydis_site.apps.content.views.page_category.utils.get_page")
+    @patch("pydis_site.apps.content.views.page_category.utils.get_category")
+    @override_settings(PAGES_PATH=BASE_PATH)
+    def test_page_return_404(self, get_category_mock, get_page_mock):
+        """Check that return code is 404 when invalid page provided."""
+        get_page_mock.side_effect = Http404("Page not found.")
 
-        url = reverse("content:article_category", args=["invalid-guide"])
+        url = reverse("content:page_category", args=["invalid-guide"])
         response = self.client.get(url)
         self.assertEqual(response.status_code, 404)
-        get_article_mock.assert_not_called()
+        get_page_mock.assert_not_called()
         get_category_mock.assert_not_called()
 
-    @patch("pydis_site.apps.content.views.article_category.utils.get_category")
-    @patch("pydis_site.apps.content.views.article_category.utils.get_articles")
-    @patch("pydis_site.apps.content.views.article_category.utils.get_categories")
-    @override_settings(ARTICLES_PATH=BASE_PATH)
+    @patch("pydis_site.apps.content.views.page_category.utils.get_category")
+    @patch("pydis_site.apps.content.views.page_category.utils.get_pages")
+    @patch("pydis_site.apps.content.views.page_category.utils.get_categories")
+    @override_settings(PAGES_PATH=BASE_PATH)
     def test_valid_category_code_200(
             self,
             get_categories_mock,
-            get_articles_mock,
+            get_pages_mock,
             get_category_mock
     ):
         """Check that return code is 200 when visiting valid category."""
         get_category_mock.return_value = {"name": "test", "description": "test"}
-        get_articles_mock.return_value = {}
+        get_pages_mock.return_value = {}
 
-        url = reverse("content:article_category", args=["category"])
+        url = reverse("content:page_category", args=["category"])
         response = self.client.get(url)
 
         self.assertEqual(response.status_code, 200)
-        get_articles_mock.assert_called_once()
+        get_pages_mock.assert_called_once()
         get_category_mock.assert_called_once()
         get_categories_mock.assert_called_once()
 
-    @patch("pydis_site.apps.content.views.article_category.utils.get_category")
-    @patch("pydis_site.apps.content.views.article_category.utils.get_articles")
-    @patch("pydis_site.apps.content.views.article_category.utils.get_categories")
-    @override_settings(ARTICLES_PATH=BASE_PATH)
+    @patch("pydis_site.apps.content.views.page_category.utils.get_category")
+    @patch("pydis_site.apps.content.views.page_category.utils.get_pages")
+    @patch("pydis_site.apps.content.views.page_category.utils.get_categories")
+    @override_settings(PAGES_PATH=BASE_PATH)
     def test_invalid_category_code_404(
             self,
             get_categories_mock,
-            get_articles_mock,
+            get_pages_mock,
             get_category_mock
     ):
         """Check that return code is 404 when trying to visit invalid category."""
         get_category_mock.side_effect = Http404("Category not found.")
 
-        url = reverse("content:article_category", args=["invalid-category"])
+        url = reverse("content:page_category", args=["invalid-category"])
         response = self.client.get(url)
 
         self.assertEqual(response.status_code, 404)
         get_category_mock.assert_not_called()
-        get_articles_mock.assert_not_called()
+        get_pages_mock.assert_not_called()
         get_categories_mock.assert_not_called()
 
-    @patch("pydis_site.apps.content.views.article_category.utils.get_article")
-    @patch("pydis_site.apps.content.views.article_category.utils.get_category")
-    @override_settings(ARTICLES_PATH=BASE_PATH)
-    def test_valid_category_article_code_200(
+    @patch("pydis_site.apps.content.views.page_category.utils.get_page")
+    @patch("pydis_site.apps.content.views.page_category.utils.get_category")
+    @override_settings(PAGES_PATH=BASE_PATH)
+    def test_valid_category_page_code_200(
             self,
             get_category_mock,
-            get_article_mock
+            get_page_mock
     ):
-        """Check that return code is 200 when visiting valid category article."""
-        get_article_mock.return_value = {"guide": "test", "metadata": {}}
+        """Check that return code is 200 when visiting valid category page."""
+        get_page_mock.return_value = {"guide": "test", "metadata": {}}
 
-        url = reverse("content:article_category", args=["category/test3"])
+        url = reverse("content:page_category", args=["category/test3"])
         response = self.client.get(url)
         self.assertEqual(response.status_code, 200)
-        get_article_mock.assert_called_once()
+        get_page_mock.assert_called_once()
         self.assertEqual(get_category_mock.call_count, 2)
 
-    @patch("pydis_site.apps.content.views.article_category.utils.get_article")
-    @patch("pydis_site.apps.content.views.article_category.utils.get_category")
-    @override_settings(ARTICLES_PATH=BASE_PATH)
-    def test_invalid_category_article_code_404(
+    @patch("pydis_site.apps.content.views.page_category.utils.get_page")
+    @patch("pydis_site.apps.content.views.page_category.utils.get_category")
+    @override_settings(PAGES_PATH=BASE_PATH)
+    def test_invalid_category_page_code_404(
             self,
             get_category_mock,
-            get_article_mock
+            get_page_mock
     ):
-        """Check that return code is 200 when trying to visit invalid category article."""
-        get_article_mock.side_effect = Http404("Article not found.")
+        """Check that return code is 200 when trying to visit invalid category page."""
+        get_page_mock.side_effect = Http404("Page not found.")
 
-        url = reverse("content:article_category", args=["category/invalid"])
+        url = reverse("content:page_category", args=["category/invalid"])
         response = self.client.get(url)
         self.assertEqual(response.status_code, 404)
-        get_article_mock.assert_not_called()
+        get_page_mock.assert_not_called()
         get_category_mock.assert_not_called()
 
-    @override_settings(ARTICLES_PATH=BASE_PATH)
-    def test_article_category_template_names(self):
-        """Check that this return category, article template or raise Http404."""
+    @override_settings(PAGES_PATH=BASE_PATH)
+    def test_page_category_template_names(self):
+        """Check that this return category, page template or raise Http404."""
         factory = RequestFactory()
         cases = [
             {"location": "category", "output": ["content/listing.html"]},
-            {"location": "test", "output": ["content/article.html"]},
+            {"location": "test", "output": ["content/page.html"]},
             {"location": "invalid", "output": None, "raises": Http404}
         ]
 
         for case in cases:
             with self.subTest(location=case["location"], output=case["output"]):
-                request = factory.get(f"/articles/{case['location']}")
-                instance = ArticleOrCategoryView()
+                request = factory.get(f"/pages/{case['location']}")
+                instance = PageOrCategoryView()
                 instance.request = request
                 instance.kwargs = {"location": case["location"]}
 
diff --git a/pydis_site/apps/content/urls.py b/pydis_site/apps/content/urls.py
index 49a5a2ef..1406f672 100644
--- a/pydis_site/apps/content/urls.py
+++ b/pydis_site/apps/content/urls.py
@@ -4,6 +4,6 @@ from . import views
 
 app_name = "content"
 urlpatterns = [
-    path("", views.ArticlesView.as_view(), name='articles'),
-    path("<path:location>/", views.ArticleOrCategoryView.as_view(), name='article_category'),
+    path("", views.PagesView.as_view(), name='pages'),
+    path("<path:location>/", views.PageOrCategoryView.as_view(), name='page_category'),
 ]
diff --git a/pydis_site/apps/content/utils.py b/pydis_site/apps/content/utils.py
index 305d26b5..db502a71 100644
--- a/pydis_site/apps/content/utils.py
+++ b/pydis_site/apps/content/utils.py
@@ -9,7 +9,7 @@ from markdown2 import markdown
 
 def get_category(path: List[str]) -> Dict[str, str]:
     """Load category information by name from _info.yml."""
-    path = settings.ARTICLES_PATH.joinpath(*path)
+    path = settings.PAGES_PATH.joinpath(*path)
     if not path.exists() or not path.is_dir():
         raise Http404("Category not found.")
 
@@ -20,10 +20,10 @@ def get_categories(path: Optional[List[str]] = None) -> Dict[str, Dict]:
     """Get all categories information."""
     categories = {}
     if path is None:
-        categories_path = settings.ARTICLES_PATH
+        categories_path = settings.PAGES_PATH
         path = []
     else:
-        categories_path = settings.ARTICLES_PATH.joinpath(*path)
+        categories_path = settings.PAGES_PATH.joinpath(*path)
 
     for name in categories_path.iterdir():
         if name.is_dir():
@@ -32,34 +32,34 @@ def get_categories(path: Optional[List[str]] = None) -> Dict[str, Dict]:
     return categories
 
 
-def get_articles(path: Optional[List[str]] = None) -> Dict[str, Dict]:
-    """Get all root or category articles."""
+def get_pages(path: Optional[List[str]] = None) -> Dict[str, Dict]:
+    """Get all root or category pages."""
     if path is None:
-        base_dir = settings.ARTICLES_PATH
+        base_dir = settings.PAGES_PATH
     else:
-        base_dir = settings.ARTICLES_PATH.joinpath(*path)
+        base_dir = settings.PAGES_PATH.joinpath(*path)
 
-    articles = {}
+    pages = {}
 
     for item in base_dir.iterdir():
         if item.is_file() and item.name.endswith(".md"):
             md = markdown(item.read_text(), extras=["metadata"])
-            articles[os.path.splitext(item.name)[0]] = md.metadata
+            pages[os.path.splitext(item.name)[0]] = md.metadata
 
-    return articles
+    return pages
 
 
-def get_article(path: List[str]) -> Dict[str, Union[str, Dict]]:
-    """Get one specific article. When category is specified, get it from there."""
-    article_path = settings.ARTICLES_PATH.joinpath(*path[:-1])
+def get_page(path: List[str]) -> Dict[str, Union[str, Dict]]:
+    """Get one specific page. When category is specified, get it from there."""
+    page_path = settings.PAGES_PATH.joinpath(*path[:-1])
 
     # We need to include extension MD
-    article_path = article_path.joinpath(f"{path[-1]}.md")
-    if not article_path.exists() or not article_path.is_file():
-        raise Http404("Article not found.")
+    page_path = page_path.joinpath(f"{path[-1]}.md")
+    if not page_path.exists() or not page_path.is_file():
+        raise Http404("Page not found.")
 
     html = markdown(
-        article_path.read_text(),
+        page_path.read_text(),
         extras=[
             "metadata",
             "fenced-code-blocks",
@@ -71,4 +71,4 @@ def get_article(path: List[str]) -> Dict[str, Union[str, Dict]]:
         ]
     )
 
-    return {"article": str(html), "metadata": html.metadata}
+    return {"page": str(html), "metadata": html.metadata}
diff --git a/pydis_site/apps/content/views/__init__.py b/pydis_site/apps/content/views/__init__.py
index f92660d6..740d98e9 100644
--- a/pydis_site/apps/content/views/__init__.py
+++ b/pydis_site/apps/content/views/__init__.py
@@ -1,4 +1,4 @@
-from .article_category import ArticleOrCategoryView
-from .articles import ArticlesView
+from .page_category import PageOrCategoryView
+from .pages import PagesView
 
-__all__ = ["ArticleOrCategoryView", "ArticlesView"]
+__all__ = ["PageOrCategoryView", "PagesView"]
diff --git a/pydis_site/apps/content/views/article_category.py b/pydis_site/apps/content/views/page_category.py
index 2a407b99..f00a79ee 100644
--- a/pydis_site/apps/content/views/article_category.py
+++ b/pydis_site/apps/content/views/page_category.py
@@ -7,18 +7,18 @@ from django.views.generic import TemplateView
 from pydis_site.apps.content import utils
 
 
-class ArticleOrCategoryView(TemplateView):
-    """Handles article and category pages."""
+class PageOrCategoryView(TemplateView):
+    """Handles pages and page categories."""
 
     def get_template_names(self) -> t.List[str]:
-        """Checks does this use article template or listing template."""
+        """Checks does this use page template or listing template."""
         location = self.kwargs["location"].split("/")
-        full_location = settings.ARTICLES_PATH.joinpath(*location)
+        full_location = settings.PAGES_PATH.joinpath(*location)
 
         if full_location.is_dir():
             template_name = "content/listing.html"
         elif full_location.with_suffix(".md").is_file():
-            template_name = "content/article.html"
+            template_name = "content/page.html"
         else:
             raise Http404
 
@@ -29,17 +29,17 @@ class ArticleOrCategoryView(TemplateView):
         context = super().get_context_data(**kwargs)
 
         location: list = self.kwargs["location"].split("/")
-        full_location = settings.ARTICLES_PATH.joinpath(*location)
+        full_location = settings.PAGES_PATH.joinpath(*location)
 
         if full_location.is_dir():
             context["category_info"] = utils.get_category(location)
-            context["content"] = utils.get_articles(location)
+            context["content"] = utils.get_pages(location)
             context["categories"] = utils.get_categories(location)
             # Add trailing slash here to simplify template
             context["path"] = "/".join(location) + "/"
             context["in_category"] = True
         elif full_location.with_suffix(".md").is_file():
-            article_result = utils.get_article(location)
+            page_result = utils.get_page(location)
 
             if len(location) > 1:
                 context["category_data"] = utils.get_category(location[:-1])
@@ -47,8 +47,8 @@ class ArticleOrCategoryView(TemplateView):
             else:
                 context["category_data"] = {"name": None, "raw_name": None}
 
-            context["article"] = article_result
-            context["relevant_links"] = article_result["metadata"].get("relevant_links", {})
+            context["page"] = page_result
+            context["relevant_links"] = page_result["metadata"].get("relevant_links", {})
         else:
             raise Http404
 
diff --git a/pydis_site/apps/content/views/articles.py b/pydis_site/apps/content/views/pages.py
index 999002d0..11ac0eeb 100644
--- a/pydis_site/apps/content/views/articles.py
+++ b/pydis_site/apps/content/views/pages.py
@@ -1,16 +1,16 @@
 from django.views.generic import TemplateView
 
-from pydis_site.apps.content.utils import get_articles, get_categories
+from pydis_site.apps.content.utils import get_pages, get_categories
 
 
-class ArticlesView(TemplateView):
-    """Shows all content and categories."""
+class PagesView(TemplateView):
+    """Shows all pages and categories."""
 
     template_name = "content/listing.html"
 
     def get_context_data(self, **kwargs) -> dict:
-        """Add articles and categories data to template context."""
+        """Add page and category data to template context."""
         context = super().get_context_data(**kwargs)
-        context["content"] = get_articles()
+        context["content"] = get_pages()
         context["categories"] = get_categories()
         return context
diff --git a/pydis_site/apps/events/urls.py b/pydis_site/apps/events/urls.py
index 9a65cf1f..601451da 100644
--- a/pydis_site/apps/events/urls.py
+++ b/pydis_site/apps/events/urls.py
@@ -1,9 +1,9 @@
 from django.urls import path
 
-from pydis_site.apps.events.views import IndexView, PageView
+from pydis_site.apps.events.views import IndexView, PagesView
 
 app_name = "events"
 urlpatterns = [
     path("", IndexView.as_view(), name="index"),
-    path("<path:path>/", PageView.as_view(), name="page"),
+    path("<path:path>/", PagesView.as_view(), name="page"),
 ]
diff --git a/pydis_site/apps/events/views/__init__.py b/pydis_site/apps/events/views/__init__.py
index 8a107e2f..6188f723 100644
--- a/pydis_site/apps/events/views/__init__.py
+++ b/pydis_site/apps/events/views/__init__.py
@@ -1,4 +1,4 @@
 from .index import IndexView
-from .page import PageView
+from .page import PagesView
 
-__all__ = ["IndexView", "PageView"]
+__all__ = ["IndexView", "PagesView"]
diff --git a/pydis_site/apps/events/views/page.py b/pydis_site/apps/events/views/page.py
index f4c37aeb..fbedd4e8 100644
--- a/pydis_site/apps/events/views/page.py
+++ b/pydis_site/apps/events/views/page.py
@@ -5,7 +5,7 @@ from django.http import Http404
 from django.views.generic import TemplateView
 
 
-class PageView(TemplateView):
+class PagesView(TemplateView):
     """Handles event pages showing."""
 
     def get_template_names(self) -> List[str]:
diff --git a/pydis_site/apps/home/urls.py b/pydis_site/apps/home/urls.py
index bd7c0625..3c716875 100644
--- a/pydis_site/apps/home/urls.py
+++ b/pydis_site/apps/home/urls.py
@@ -8,6 +8,6 @@ urlpatterns = [
     path('', HomeView.as_view(), name='home'),
     path('admin/', admin.site.urls),
     path('resources/', include('pydis_site.apps.resources.urls')),
-    path('articles/', include('pydis_site.apps.content.urls')),
+    path('pages/', include('pydis_site.apps.content.urls')),
     path('events/', include('pydis_site.apps.events.urls', namespace='events')),
 ]
diff --git a/pydis_site/settings.py b/pydis_site/settings.py
index d509d980..0b4d9fd1 100644
--- a/pydis_site/settings.py
+++ b/pydis_site/settings.py
@@ -287,4 +287,4 @@ SITE_REPOSITORY_OWNER = "python-discord"
 SITE_REPOSITORY_NAME = "site"
 SITE_REPOSITORY_BRANCH = "master"
 
-ARTICLES_PATH = Path(BASE_DIR, "pydis_site", "apps", "content", "resources", "content")
+PAGES_PATH = Path(BASE_DIR, "pydis_site", "apps", "content", "resources", "content")
diff --git a/pydis_site/static/css/content/articles.css b/pydis_site/static/css/content/page.css
index f46d6b15..f46d6b15 100644
--- a/pydis_site/static/css/content/articles.css
+++ b/pydis_site/static/css/content/page.css
diff --git a/pydis_site/templates/content/listing.html b/pydis_site/templates/content/listing.html
index 8c06bccc..39eae1c2 100644
--- a/pydis_site/templates/content/listing.html
+++ b/pydis_site/templates/content/listing.html
@@ -1,12 +1,12 @@
 {% extends 'base/base.html' %}
 {% load static %}
 
-{% block title %}{{ category_info.name|default:"Articles" }}{% endblock %}
+{% block title %}{{ category_info.name|default:"Pages" }}{% endblock %}
 {% block head %}
-    <meta property="og:title" content="Python Discord - {{ category_info.name|default:"Articles" }}" />
+    <meta property="og:title" content="Python Discord - {{ category_info.name|default:"Pages" }}" />
     <meta property="og:type" content="website" />
     <meta property="og:description" content="{{ category_info.description }}" />
-    <link rel="stylesheet" href="{% static "css/content/articles.css" %}">
+    <link rel="stylesheet" href="{% static "css/content/page.css" %}">
 {% endblock %}
 
 {% block content %}
@@ -17,12 +17,12 @@
             <nav class="breadcrumb is-pulled-left" aria-label="breadcrumbs">
                 <ul>
                     {% if in_category %}
-                        <li><a href="{% url "content:articles" %}">Articles</a></li>
+                        <li><a href="{% url "content:pages" %}">Pages</a></li>
                     {% endif %}
                     {% for item in breadcrumb_items %}
-                        <li><a href="{% url "content:article_category" location=item.path %}">{{ item.name }}</a></li>
+                        <li><a href="{% url "content:page_category" location=item.path %}">{{ item.name }}</a></li>
                     {% endfor %}
-                    <li class="is-active"><a href="#">{{ category_info.name|default:"Articles" }}</a></li>
+                    <li class="is-active"><a href="#">{{ category_info.name|default:"Pages" }}</a></li>
                 </ul>
             </nav>
         </div>
@@ -31,7 +31,7 @@
     <section class="section">
         <div class="container">
             <div class="content">
-                <h1>{{ category_info.name|default:"Articles" }}</h1>
+                <h1>{{ category_info.name|default:"Pages" }}</h1>
                 {% for category, data in categories.items %}
                     <div class="box" style="max-width: 800px;">
                         <span class="icon is-size-4 is-medium">
@@ -39,18 +39,18 @@
                         </span>
 
 
-                        <a href="{% url "content:article_category" location=path|add:category %}">
+                        <a href="{% url "content:page_category" location=path|add:category %}">
                             <span class="is-size-4 has-text-weight-bold">{{ data.name }}</span>
                         </a>
                         <p class="is-italic">{{ data.description }}</p>
                     </div>
                 {% endfor %}
-                {% for article, data in content.items %}
+                {% for page, data in content.items %}
                     <div class="box" style="max-width: 800px;">
                         <span class="icon is-size-4 is-medium">
                             <i class="{{ data.icon_class|default:"fab" }} {{ data.icon|default:"fa-python" }} is-size-3 is-black has-icon-padding" aria-hidden="true"></i>
                         </span>
-                        <a href="{% url "content:article_category" location=path|add:article %}">
+                        <a href="{% url "content:page_category" location=path|add:page %}">
                                 <span class="is-size-4 has-text-weight-bold">{{ data.title }}</span>
                         </a>
                         <p class="is-italic">{{ data.short_description }}</p>
diff --git a/pydis_site/templates/content/article.html b/pydis_site/templates/content/page.html
index 69d01a8d..3b0ebb5f 100644
--- a/pydis_site/templates/content/article.html
+++ b/pydis_site/templates/content/page.html
@@ -1,12 +1,12 @@
 {% extends 'base/base.html' %}
 {% load static %}
 
-{% block title %}{{ article.metadata.title }}{% endblock %}
+{% block title %}{{ page.metadata.title }}{% endblock %}
 {% block head %}
-  <meta property="og:title" content="Python Discord - {{ article.metadata.title }}" />
+  <meta property="og:title" content="Python Discord - {{ page.metadata.title }}" />
   <meta property="og:type" content="website" />
-  <meta property="og:description" content="{{ article.metadata.short_description }}" />
-  <link rel="stylesheet" href="{% static "css/content/articles.css" %}">
+  <meta property="og:description" content="{{ page.metadata.short_description }}" />
+  <link rel="stylesheet" href="{% static "css/content/page.css" %}">
   <link rel="stylesheet"
     href="//cdnjs.cloudflare.com/ajax/libs/highlight.js/10.7.1/styles/atom-one-dark-reasonable.min.css">
   <script src="//cdnjs.cloudflare.com/ajax/libs/highlight.js/10.7.1/highlight.min.js"></script>
@@ -20,11 +20,11 @@
         <div class="container">
             <nav class="breadcrumb is-pulled-left" aria-label="breadcrumbs">
                 <ul>
-                    <li><a href="{% url "content:articles" %}">Articles</a></li>
+                    <li><a href="{% url "content:pages" %}">Pages</a></li>
                     {% for item in breadcrumb_items %}
-                        <li><a href="{% url "content:article_category" location=item.path %}">{{ item.name }}</a></li>
+                        <li><a href="{% url "content:page_category" location=item.path %}">{{ item.name }}</a></li>
                     {% endfor %}
-                    <li class="is-active"><a href="#">{{ article.metadata.title }}</a></li>
+                    <li class="is-active"><a href="#">{{ page.metadata.title }}</a></li>
                 </ul>
             </nav>
         </div>
@@ -33,10 +33,10 @@
     <section class="section">
         <div class="content">
             <div class="container">
-                <h1 class="title">{{ article.metadata.title }}</h1>
+                <h1 class="title">{{ page.metadata.title }}</h1>
                 <div class="columns is-variable is-8">
                     <div class="column is-two-thirds">
-                        {{ article.article|safe }}
+                        {{ page.page|safe }}
                     </div>
                     <div class="column">
                         {% if relevant_links|length > 0 %}
diff --git a/pydis_site/templates/resources/resources.html b/pydis_site/templates/resources/resources.html
index 2dc88a8c..491bc55e 100644
--- a/pydis_site/templates/resources/resources.html
+++ b/pydis_site/templates/resources/resources.html
@@ -15,7 +15,7 @@
               <h1>Resources</h1>
 
               <div class="tile is-ancestor">
-                  <a class="tile is-parent" href="{% url "content:article_category" location="guides" %}">
+                  <a class="tile is-parent" href="{% url "content:page_category" location="guides" %}">
                       <article class="tile is-child box hero is-primary is-bold">
                           <p class="title is-size-1"><i class="fad fa-info-circle" aria-hidden="true"></i> Guides</p>
                           <p class="subtitle is-size-4">Made by us, for you</p>