v.1.0 ready for your review

n2y/blocks.py

@@ -570,8 +570,17 @@ def to_pandoc(self):
         return self.children_to_pandoc()
 
 
-class LinkToPageBlock(WarningBlock):
-    pass
+class LinkToPageBlock(Block):
+    # Invoking warning, for backward compatibility with existing 
+    # installations, which will lack the plugin. 
+    # TODO: right? 
+
+    WarningBlock()
+
+    # It is expected that the functionality will be overwritten by an internal plugin, if 
+    # such plugin is included in the client's specific distribution
+
+
 
 
 def render_with_caption(content_ast, caption_ast):

n2y/notion_mocks.py

@@ -110,6 +110,15 @@ def mock_file(url):
     }
 
 
+def mock_link_to_page_block(linked_page_id):
+    # TODO: This function is trivial and I believe unnecessary, as 
+    # the representation of the block itself, in this case, is trivial.  QUESTION Right?
+    return {
+        'id': linked_page_id,
+        'type': "page_id",
+    }
+
+
 def mock_property_value(property_value_type, content):
     return {
         'id': mock_id(),

n2y/plugins/linktopage.py

@@ -0,0 +1,38 @@
+import logging
+
+from n2y.blocks import Block
+
+logger = logging.getLogger(__name__)
+
+class LinkToPage(Block):
+    """
+    Replace page link with the content of the linked-to page.
+
+    """
+    def __init__(self, client, notion_data, page, get_children=False):
+
+        super().__init__(client, page, notion_data, get_children)
+
+    def to_pandoc(self):
+        assert self.linked_page_id is not None
+
+        try:
+            self.client.get_page(self.linked_page_id) 
+            # Although out of the scope of the project at hand, get_page_or_database() 
+            # could be used in place of get_page, to cover the linked database case. 
+            # Might be an unnecessary step here. 
+            self.rich_text = self.client.wrap_notion_rich_text_array(self.notion_data["rich_text"], self)
+
+            # It's all about calling the proper method. 
+            content = self.rich_text.to_pandoc()
+
+        except PermissionError:
+            msg = 'Permission denied when attempting to access linked page having id [%s]'
+            logger.warning(msg, self.notion_data)
+
+
+notion_classes = {
+    "blocks": {
+        "link_to_page": LinkToPage,
+    }
+}

n2y/test.py

@@ -0,0 +1,55 @@
+import logging
+
+from n2y import notion
+
+from n2y.plugins import linktopage
+
+"""
+For testing only
+Launch n2y programmatically, with specified arguments.
+"""
+
+logging.basicConfig()
+
+global logger
+
+logger = logging.getLogger(__name__)
+
+logger.critical("At least I'm logging!")
+
+
+#  Constants to be put in .env file or the equivalent.  But then again, this is just a test. 
+access_token = "secret_gke3p6v6mCWl7UmEjnTAoTCet3BxLQaWZeSWicWA1a8"
+linked_page_id = "56850767f7b645baaffddfc1ff617db1"
+plugin_id = 'n2y.plugins.linktopage'
+
+
+# Just curious to have a look at these data elements.
+raw_args = [linked_page_id, '--plugin', plugin_id]
+#-> Nice!  a tidy string of argument values, including our own linked_page_id.
+
+# Another way to initialize arguments to our liking. 
+args = raw_args
+
+# Bare bones client.
+cl = notion.Client(
+    access_token
+)
+
+# Now we are able to instatiantate our page object. 
+cl.get_page(linked_page_id)
+
+
+page = cl.get_page(linked_page_id)
+
+# Here we have a notion type of child_page and the notion page id that we fed it. 
+cl.get_block(linked_page_id, page)
+
+# This one gets it from Client, the top class.
+## using the Client.get_block method, as above
+## Now just to insert it into the page. 
+
+
+
+x = linktopage
+

tests/test_blocks.py

@@ -10,7 +10,7 @@
     CodeBlock, BulletList, OrderedList, Decimal, Period, Meta, Pandoc, Link,
     HorizontalRule, BlockQuote, Image, MetaString, Table, TableHead, TableBody,
     TableFoot, RowHeadColumns, Row, Cell, RowSpan, ColSpan, ColWidthDefault, AlignDefault,
-    Caption, Math, DisplayMath
+    Caption, Math, DisplayMath, 
 )
 
 from n2y.notion import Client
@@ -255,6 +255,62 @@ def test_code_block():
     assert markdown == "``` javascript\nconst a = 3\n```\n"
 
 
+def test_link_to_page_block():
+
+# As I've been asked to update the end-to-end tests, but not specifically the unit tests
+# changes to this file are out of scope.  Right? 
+
+
+    mock_page_id = "23143143243241423"
+
+    # This test is not about representing the block itself, which is only a page link.
+    # It's about testing that a mock page, linked to by a mock block, is processed as expected.
+
+    # Elaboration: As the link_to_page block is trivial, containing only the value of the link itself.
+    # And since representation of the page link in the pandoc output is not necessary --
+    # It is the contents of the linked page that is potentially
+    # represented, not the link to the page -- testing here would logically be limited to checking
+    # for proper conversion of the linked page.  However, such a test would be redundant, 
+    # as already handled in test-end-to-end.py
+
+    # Create the mock block of the linking page.
+    notion_block = mock_block("link_to_page", { 
+        "type": "link_to_page", 
+        "link_to_page": { "type": "page_id", "page_id": "{mock_page_id}" } 
+        })
+
+
+    # TODO: QUESTION What type of Notion block is a page?  Below, I use a
+    # paragraph block.  Is that correct? 
+
+    # Create a mock of the page to which the link points.
+    notion_page =  mock_block("paragraph", {
+        "rich_text": [{
+        "type": "text",
+        "text": {
+        "content": "Test content",
+        "link": null
+        }
+        }],
+        })
+
+    # Test the block itself.
+    pandoc_ast, markdown = process_block(notion_block)
+    # TODO: fill in for None, if I am wrong and unit tests are required. 
+    assert pandoc_ast == None
+    assert markdown == None
+
+    # Test the mock page to which the mock link_to_page links.
+    # We will be testing 
+    pandoc_ast, markdown = process_block(notion_page)
+    # TODO: fill in for None, if I am wrong and unit tests are required.
+    assert pandoc_ast == None
+    assert markdown == None
+
+
+
+
+
 def test_table_block():
     parent = mock_block("table", {
         "table_width": 2,

tests/test_end_to_end.py

@@ -172,6 +172,7 @@ def test_all_properties_database():
 
 
 def test_all_blocks_page_to_markdown(tmp_path):
+
     '''
     The page can be seen here:
     https://fresh-pencil-9f3.notion.site/Test-Page-5f18c7d7eda44986ae7d938a12817cc0
@@ -212,8 +213,12 @@ def test_all_blocks_page_to_markdown(tmp_path):
     assert "``` javascript\nCode Block\n```" in document_as_markdown
     assert lines.count("This is a synced block.") == 2
     assert "This is a synced block from another page." in lines
+    assert "This page is not shared with the integration." in lines
+
     assert all(column_strings_in_lines) or (column_string in lines)
 
+
+
     # a bookmark with a caption and without
     assert "<https://innolitics.com>" in lines
     assert "[Bookmark caption](https://innolitics.com)" in lines
@@ -256,6 +261,8 @@ def test_simple_page_to_markdown():
     assert "Page content" in document_as_markdown
 
 
+
+
 def test_builtin_plugins(tmp_path):
     '''
     The page can be seen here:
@@ -296,3 +303,15 @@ def test_builtin_plugins(tmp_path):
 def test_missing_object_exception():
     invalid_page_id = "11111111111111111111111111111111"
     assert run_n2y([invalid_page_id]) != 0
+
+
+def test_links_to_pages():
+
+    # This is exctly what test_all_blocks_page_to_markdown() does, so it
+    # doesn't make sense to do it again, but what else can we do to test 
+    # this capability?
+    # Unless we come up with a real purpose for this test, it probably doesn't make sense.
+    object_id = '6670dc17a7bc4426b91bca4cf3ac5623'
+    status, document_as_markdown, _ = run_n2y([object_id])
+    assert status == 0
+    assert "Page content" in document_as_markdown