Switch to local-path-provisioner.

This image will be shared by CI jobs rather than having a separate image for each, mirroring the developments I've done in natter.

.dockerignore

@@ -2,3 +2,4 @@
 target
 Cargo.lock
 notes/
+.lighthouse/

.lighthouse/pipeline-clippy.yaml

@@ -1,191 +0,0 @@
-apiVersion: tekton.dev/v1beta1
-kind: PipelineRun
-metadata:
-  name: clippy
-spec:
-  pipelineSpec:
-    params:
-      - name: image-name
-        description: The name for the built image
-        type: string
-      - name: path-to-image-context
-        description: The path to the build context
-        type: string
-      - name: path-to-dockerfile
-        description: The path to the Dockerfile
-        type: string
-      - name: GIT_USER_NAME
-        description: The username for git
-        type: string
-        default: "fluxcdbot"
-      - name: GIT_USER_EMAIL
-        description: The email for git
-        type: string
-        default: "fluxcdbot@users.noreply.github.com"
-    tasks:
-      - name: do-stuff
-        taskSpec:
-          metadata: {}
-          stepTemplate:
-            image: alpine:3.18
-            name: ""
-            resources:
-              requests:
-                cpu: 10m
-                memory: 600Mi
-            workingDir: /workspace/source
-          steps:
-            - image: alpine:3.18
-              name: do-stuff-step
-              script: |
-                #!/usr/bin/env sh
-                echo "hello world"
-      - name: report-pending
-        taskRef:
-          name: gitea-set-status
-        runAfter:
-          - fetch-repository
-        params:
-          - name: CONTEXT
-            value: "$(params.JOB_NAME)"
-          - name: REPO_FULL_NAME
-            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
-          - name: GITEA_HOST_URL
-            value: code.fizz.buzz
-          - name: SHA
-            value: "$(tasks.fetch-repository.results.commit)"
-          - name: DESCRIPTION
-            value: "Build $(params.JOB_NAME) has started"
-          - name: STATE
-            value: pending
-          - name: TARGET_URL
-            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
-      - name: fetch-repository
-        taskRef:
-          name: git-clone
-        workspaces:
-          - name: output
-            workspace: git-source
-        params:
-          - name: url
-            value: $(params.REPO_URL)
-          - name: revision
-            value: $(params.PULL_BASE_SHA)
-          - name: deleteExisting
-            value: "true"
-      - name: build-image
-        taskRef:
-          name: kaniko
-        params:
-          - name: IMAGE
-            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
-          - name: CONTEXT
-            value: $(params.path-to-image-context)
-          - name: DOCKERFILE
-            value: $(params.path-to-dockerfile)
-          - name: BUILDER_IMAGE
-            value: "gcr.io/kaniko-project/executor:v1.12.1"
-          - name: EXTRA_ARGS
-            value:
-              - --cache=true
-              - --cache-copy-layers
-              - --cache-repo=harbor.fizz.buzz/kanikocache/cache
-              - --use-new-run # Should result in a speed-up
-              - --reproducible # To remove timestamps so layer caching works.
-              - --snapshot-mode=redo
-              - --skip-unused-stages=true
-              - --registry-mirror=dockerhub.dockerhub.svc.cluster.local
-        workspaces:
-          - name: source
-            workspace: git-source
-          - name: dockerconfig
-            workspace: docker-credentials
-        runAfter:
-          - fetch-repository
-      - name: clippy
-        taskRef:
-          name: run-docker-image
-        workspaces:
-          - name: source
-            workspace: git-source
-          - name: cargo-cache
-            workspace: cargo-cache
-        runAfter:
-          - build-image
-        params:
-          - name: docker-image
-            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
-    finally:
-      - name: report-success
-        when:
-          - input: "$(tasks.status)"
-            operator: in
-            values: ["Succeeded", "Completed"]
-        taskRef:
-          name: gitea-set-status
-        params:
-          - name: CONTEXT
-            value: "$(params.JOB_NAME)"
-          - name: REPO_FULL_NAME
-            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
-          - name: GITEA_HOST_URL
-            value: code.fizz.buzz
-          - name: SHA
-            value: "$(tasks.fetch-repository.results.commit)"
-          - name: DESCRIPTION
-            value: "Build $(params.JOB_NAME) has succeeded"
-          - name: STATE
-            value: success
-          - name: TARGET_URL
-            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
-      - name: report-failure
-        when:
-          - input: "$(tasks.status)"
-            operator: in
-            values: ["Failed"]
-        taskRef:
-          name: gitea-set-status
-        params:
-          - name: CONTEXT
-            value: "$(params.JOB_NAME)"
-          - name: REPO_FULL_NAME
-            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
-          - name: GITEA_HOST_URL
-            value: code.fizz.buzz
-          - name: SHA
-            value: "$(tasks.fetch-repository.results.commit)"
-          - name: DESCRIPTION
-            value: "Build $(params.JOB_NAME) has failed"
-          - name: STATE
-            value: failure
-          - name: TARGET_URL
-            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
-    workspaces:
-      - name: git-source
-      - name: docker-credentials
-  workspaces:
-    - name: git-source
-      volumeClaimTemplate:
-        spec:
-          storageClassName: "nfs-client"
-          accessModes:
-            - ReadWriteOnce
-          resources:
-            requests:
-              storage: 10Gi
-      subPath: rust-source
-    - name: cargo-cache
-      persistentVolumeClaim:
-        claimName: organic-cargo-cache-clippy
-    - name: docker-credentials
-      secret:
-        secretName: harbor-plain
-  serviceAccountName: build-bot
-  timeout: 240h0m0s
-  params:
-    - name: image-name
-      value: "harbor.fizz.buzz/private/organic-clippy"
-    - name: path-to-image-context
-      value: docker/organic_clippy/
-    - name: path-to-dockerfile
-      value: docker/organic_clippy/Dockerfile

.lighthouse/pipeline-foreign-document-test.yaml

@@ -1,203 +0,0 @@
-apiVersion: tekton.dev/v1beta1
-kind: PipelineRun
-metadata:
-  name: rust-foreign-document-test
-spec:
-  pipelineSpec:
-    timeouts:
-      pipeline: "2h0m0s"
-      tasks: "1h0m40s"
-      finally: "0h30m0s"
-    params:
-      - name: image-name
-        description: The name for the built image
-        type: string
-      - name: path-to-image-context
-        description: The path to the build context
-        type: string
-      - name: path-to-dockerfile
-        description: The path to the Dockerfile
-        type: string
-    tasks:
-      - name: do-stuff
-        taskSpec:
-          metadata: {}
-          stepTemplate:
-            image: alpine:3.18
-            name: ""
-            resources:
-              requests:
-                cpu: 10m
-                memory: 600Mi
-            workingDir: /workspace/source
-          steps:
-            - image: alpine:3.18
-              name: do-stuff-step
-              script: |
-                #!/usr/bin/env sh
-                echo "hello world"
-      - name: report-pending
-        taskRef:
-          name: gitea-set-status
-        runAfter:
-          - fetch-repository
-        params:
-          - name: CONTEXT
-            value: "$(params.JOB_NAME)"
-          - name: REPO_FULL_NAME
-            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
-          - name: GITEA_HOST_URL
-            value: code.fizz.buzz
-          - name: SHA
-            value: "$(tasks.fetch-repository.results.commit)"
-          - name: DESCRIPTION
-            value: "Build $(params.JOB_NAME) has started"
-          - name: STATE
-            value: pending
-          - name: TARGET_URL
-            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
-      - name: fetch-repository
-        taskRef:
-          name: git-clone
-        workspaces:
-          - name: output
-            workspace: git-source
-        params:
-          - name: url
-            value: $(params.REPO_URL)
-          - name: revision
-            value: $(params.PULL_BASE_SHA)
-          - name: deleteExisting
-            value: "true"
-      - name: build-image
-        taskRef:
-          name: kaniko
-        params:
-          - name: IMAGE
-            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
-          - name: CONTEXT
-            value: $(params.path-to-image-context)
-          - name: DOCKERFILE
-            value: $(params.path-to-dockerfile)
-          - name: BUILDER_IMAGE
-            value: "gcr.io/kaniko-project/executor:v1.12.1"
-          - name: EXTRA_ARGS
-            value:
-              - --target=foreign-document-test
-              - --cache=true
-              - --cache-copy-layers
-              - --cache-repo=harbor.fizz.buzz/kanikocache/cache
-              - --use-new-run # Should result in a speed-up
-              - --reproducible # To remove timestamps so layer caching works.
-              - --snapshot-mode=redo
-              - --skip-unused-stages=true
-              - --registry-mirror=dockerhub.dockerhub.svc.cluster.local
-        workspaces:
-          - name: source
-            workspace: git-source
-          - name: dockerconfig
-            workspace: docker-credentials
-        runAfter:
-          - fetch-repository
-      - name: run-image
-        taskRef:
-          name: run-docker-image
-        workspaces:
-          - name: source
-            workspace: git-source
-          - name: cargo-cache
-            workspace: cargo-cache
-        runAfter:
-          - build-image
-        params:
-          - name: docker-image
-            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
-    finally:
-      - name: report-success
-        when:
-          - input: "$(tasks.status)"
-            operator: in
-            values: ["Succeeded", "Completed"]
-        taskRef:
-          name: gitea-set-status
-        params:
-          - name: CONTEXT
-            value: "$(params.JOB_NAME)"
-          - name: REPO_FULL_NAME
-            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
-          - name: GITEA_HOST_URL
-            value: code.fizz.buzz
-          - name: SHA
-            value: "$(tasks.fetch-repository.results.commit)"
-          - name: DESCRIPTION
-            value: "Build $(params.JOB_NAME) has succeeded"
-          - name: STATE
-            value: success
-          - name: TARGET_URL
-            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
-      - name: report-failure
-        when:
-          - input: "$(tasks.status)"
-            operator: in
-            values: ["Failed"]
-        taskRef:
-          name: gitea-set-status
-        params:
-          - name: CONTEXT
-            value: "$(params.JOB_NAME)"
-          - name: REPO_FULL_NAME
-            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
-          - name: GITEA_HOST_URL
-            value: code.fizz.buzz
-          - name: SHA
-            value: "$(tasks.fetch-repository.results.commit)"
-          - name: DESCRIPTION
-            value: "Build $(params.JOB_NAME) has failed"
-          - name: STATE
-            value: failure
-          - name: TARGET_URL
-            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
-      - name: cargo-cache-autoclean
-        taskRef:
-          name: run-docker-image
-        workspaces:
-          - name: source
-            workspace: git-source
-          - name: cargo-cache
-            workspace: cargo-cache
-        params:
-          - name: command
-            value: [cargo, cache, --autoclean]
-          - name: args
-            value: []
-          - name: docker-image
-            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
-    workspaces:
-      - name: git-source
-      - name: docker-credentials
-      - name: cargo-cache
-  workspaces:
-    - name: git-source
-      volumeClaimTemplate:
-        spec:
-          storageClassName: "nfs-client"
-          accessModes:
-            - ReadWriteOnce
-          resources:
-            requests:
-              storage: 10Gi
-      subPath: rust-source
-    - name: cargo-cache
-      persistentVolumeClaim:
-        claimName: organic-cargo-cache-test-foreign-document
-    - name: docker-credentials
-      secret:
-        secretName: harbor-plain
-  serviceAccountName: build-bot
-  params:
-    - name: image-name
-      value: "harbor.fizz.buzz/private/organic-test-foreign-document"
-    - name: path-to-image-context
-      value: docker/organic_test/
-    - name: path-to-dockerfile
-      value: docker/organic_test/Dockerfile

.lighthouse/pipeline-rust-build.yaml

@@ -1,284 +0,0 @@
-apiVersion: tekton.dev/v1beta1
-kind: PipelineRun
-metadata:
-  name: rust-build
-spec:
-  pipelineSpec:
-    params:
-      - name: image-name
-        description: The name for the built image
-        type: string
-      - name: path-to-image-context
-        description: The path to the build context
-        type: string
-      - name: path-to-dockerfile
-        description: The path to the Dockerfile
-        type: string
-    tasks:
-      - name: report-pending
-        taskRef:
-          name: gitea-set-status
-        runAfter:
-          - fetch-repository
-        params:
-          - name: CONTEXT
-            value: "$(params.JOB_NAME)"
-          - name: REPO_FULL_NAME
-            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
-          - name: GITEA_HOST_URL
-            value: code.fizz.buzz
-          - name: SHA
-            value: "$(tasks.fetch-repository.results.commit)"
-          - name: DESCRIPTION
-            value: "Build $(params.JOB_NAME) has started"
-          - name: STATE
-            value: pending
-          - name: TARGET_URL
-            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
-      - name: fetch-repository
-        taskRef:
-          name: git-clone
-        workspaces:
-          - name: output
-            workspace: git-source
-        params:
-          - name: url
-            value: $(params.REPO_URL)
-          - name: revision
-            value: $(params.PULL_BASE_SHA)
-          - name: deleteExisting
-            value: "true"
-      - name: build-image
-        taskRef:
-          name: kaniko
-        params:
-          - name: IMAGE
-            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
-          - name: CONTEXT
-            value: $(params.path-to-image-context)
-          - name: DOCKERFILE
-            value: $(params.path-to-dockerfile)
-          - name: BUILDER_IMAGE
-            value: "gcr.io/kaniko-project/executor:v1.12.1"
-          - name: EXTRA_ARGS
-            value:
-              - --cache=true
-              - --cache-copy-layers
-              - --cache-repo=harbor.fizz.buzz/kanikocache/cache
-              - --use-new-run # Should result in a speed-up
-              - --reproducible # To remove timestamps so layer caching works.
-              - --snapshot-mode=redo
-              - --skip-unused-stages=true
-              - --registry-mirror=dockerhub.dockerhub.svc.cluster.local
-        workspaces:
-          - name: source
-            workspace: git-source
-          - name: dockerconfig
-            workspace: docker-credentials
-        runAfter:
-          - fetch-repository
-      - name: run-image-none
-        taskRef:
-          name: run-docker-image
-        workspaces:
-          - name: source
-            workspace: git-source
-          - name: cargo-cache
-            workspace: cargo-cache
-        runAfter:
-          - build-image
-        params:
-          - name: args
-            value: ["--no-default-features"]
-          - name: docker-image
-            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
-      - name: run-image-tracing
-        taskRef:
-          name: run-docker-image
-        workspaces:
-          - name: source
-            workspace: git-source
-          - name: cargo-cache
-            workspace: cargo-cache
-        runAfter:
-          - run-image-none
-        params:
-          - name: args
-            value: ["--no-default-features", "--features", "tracing"]
-          - name: docker-image
-            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
-      - name: run-image-compare
-        taskRef:
-          name: run-docker-image
-        workspaces:
-          - name: source
-            workspace: git-source
-          - name: cargo-cache
-            workspace: cargo-cache
-        runAfter:
-          - run-image-tracing
-        params:
-          - name: args
-            value: ["--no-default-features", "--features", "compare"]
-          - name: docker-image
-            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
-      - name: run-image-default
-        taskRef:
-          name: run-docker-image
-        workspaces:
-          - name: source
-            workspace: git-source
-          - name: cargo-cache
-            workspace: cargo-cache
-        runAfter:
-          - run-image-compare
-        params:
-          - name: args
-            value: []
-          - name: docker-image
-            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
-      - name: run-image-tracing-compare
-        taskRef:
-          name: run-docker-image
-        workspaces:
-          - name: source
-            workspace: git-source
-          - name: cargo-cache
-            workspace: cargo-cache
-        runAfter:
-          - run-image-default
-        params:
-          - name: args
-            value: ["--no-default-features", "--features", "tracing,compare"]
-          - name: docker-image
-            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
-      - name: run-image-compare-foreign
-        taskRef:
-          name: run-docker-image
-        workspaces:
-          - name: source
-            workspace: git-source
-          - name: cargo-cache
-            workspace: cargo-cache
-        runAfter:
-          - run-image-tracing-compare
-        params:
-          - name: args
-            value:
-              [
-                "--no-default-features",
-                "--features",
-                "compare,foreign_document_test",
-              ]
-          - name: docker-image
-            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
-      - name: run-image-all
-        taskRef:
-          name: run-docker-image
-        workspaces:
-          - name: source
-            workspace: git-source
-          - name: cargo-cache
-            workspace: cargo-cache
-        runAfter:
-          - run-image-compare-foreign
-        params:
-          - name: args
-            value:
-              [
-                "--no-default-features",
-                "--features",
-                "tracing,compare,foreign_document_test",
-              ]
-          - name: docker-image
-            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
-    finally:
-      - name: report-success
-        when:
-          - input: "$(tasks.status)"
-            operator: in
-            values: ["Succeeded", "Completed"]
-        taskRef:
-          name: gitea-set-status
-        params:
-          - name: CONTEXT
-            value: "$(params.JOB_NAME)"
-          - name: REPO_FULL_NAME
-            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
-          - name: GITEA_HOST_URL
-            value: code.fizz.buzz
-          - name: SHA
-            value: "$(tasks.fetch-repository.results.commit)"
-          - name: DESCRIPTION
-            value: "Build $(params.JOB_NAME) has succeeded"
-          - name: STATE
-            value: success
-          - name: TARGET_URL
-            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
-      - name: report-failure
-        when:
-          - input: "$(tasks.status)"
-            operator: in
-            values: ["Failed"]
-        taskRef:
-          name: gitea-set-status
-        params:
-          - name: CONTEXT
-            value: "$(params.JOB_NAME)"
-          - name: REPO_FULL_NAME
-            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
-          - name: GITEA_HOST_URL
-            value: code.fizz.buzz
-          - name: SHA
-            value: "$(tasks.fetch-repository.results.commit)"
-          - name: DESCRIPTION
-            value: "Build $(params.JOB_NAME) has failed"
-          - name: STATE
-            value: failure
-          - name: TARGET_URL
-            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
-      - name: cargo-cache-autoclean
-        taskRef:
-          name: run-docker-image
-        workspaces:
-          - name: source
-            workspace: git-source
-          - name: cargo-cache
-            workspace: cargo-cache
-        params:
-          - name: command
-            value: [cargo, cache, --autoclean]
-          - name: args
-            value: []
-          - name: docker-image
-            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
-    workspaces:
-      - name: git-source
-      - name: docker-credentials
-      - name: cargo-cache
-  workspaces:
-    - name: git-source
-      volumeClaimTemplate:
-        spec:
-          storageClassName: "nfs-client"
-          accessModes:
-            - ReadWriteOnce
-          resources:
-            requests:
-              storage: 10Gi
-      subPath: rust-source
-    - name: cargo-cache
-      persistentVolumeClaim:
-        claimName: organic-cargo-cache-build
-    - name: docker-credentials
-      secret:
-        secretName: harbor-plain
-  serviceAccountName: build-bot
-  timeout: 240h0m0s
-  params:
-    - name: image-name
-      value: "harbor.fizz.buzz/private/organic-build"
-    - name: path-to-image-context
-      value: docker/organic_build/
-    - name: path-to-dockerfile
-      value: docker/organic_build/Dockerfile

.lighthouse/pipeline-rust-test.yaml

@@ -1,214 +0,0 @@
-apiVersion: tekton.dev/v1beta1
-kind: PipelineRun
-metadata:
-  name: rust-test
-spec:
-  pipelineSpec:
-    timeouts:
-      pipeline: "2h0m0s"
-      tasks: "1h0m40s"
-      finally: "0h30m0s"
-    params:
-      - name: image-name
-        description: The name for the built image
-        type: string
-      - name: path-to-image-context
-        description: The path to the build context
-        type: string
-      - name: path-to-dockerfile
-        description: The path to the Dockerfile
-        type: string
-    tasks:
-      - name: do-stuff
-        taskSpec:
-          metadata: {}
-          stepTemplate:
-            image: alpine:3.18
-            name: ""
-            resources:
-              requests:
-                cpu: 10m
-                memory: 600Mi
-            workingDir: /workspace/source
-          steps:
-            - image: alpine:3.18
-              name: do-stuff-step
-              script: |
-                #!/usr/bin/env sh
-                echo "hello world"
-      - name: report-pending
-        taskRef:
-          name: gitea-set-status
-        runAfter:
-          - fetch-repository
-        params:
-          - name: CONTEXT
-            value: "$(params.JOB_NAME)"
-          - name: REPO_FULL_NAME
-            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
-          - name: GITEA_HOST_URL
-            value: code.fizz.buzz
-          - name: SHA
-            value: "$(tasks.fetch-repository.results.commit)"
-          - name: DESCRIPTION
-            value: "Build $(params.JOB_NAME) has started"
-          - name: STATE
-            value: pending
-          - name: TARGET_URL
-            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
-      - name: fetch-repository
-        taskRef:
-          name: git-clone
-        workspaces:
-          - name: output
-            workspace: git-source
-        params:
-          - name: url
-            value: $(params.REPO_URL)
-          - name: revision
-            value: $(params.PULL_BASE_SHA)
-          - name: deleteExisting
-            value: "true"
-      - name: build-image
-        taskRef:
-          name: kaniko
-        params:
-          - name: IMAGE
-            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
-          - name: CONTEXT
-            value: $(params.path-to-image-context)
-          - name: DOCKERFILE
-            value: $(params.path-to-dockerfile)
-          - name: BUILDER_IMAGE
-            value: "gcr.io/kaniko-project/executor:v1.12.1"
-          - name: EXTRA_ARGS
-            value:
-              - --target=tester
-              - --cache=true
-              - --cache-copy-layers
-              - --cache-repo=harbor.fizz.buzz/kanikocache/cache
-              - --use-new-run # Should result in a speed-up
-              - --reproducible # To remove timestamps so layer caching works.
-              - --snapshot-mode=redo
-              - --skip-unused-stages=true
-              - --registry-mirror=dockerhub.dockerhub.svc.cluster.local
-        workspaces:
-          - name: source
-            workspace: git-source
-          - name: dockerconfig
-            workspace: docker-credentials
-        runAfter:
-          - fetch-repository
-      - name: run-image
-        taskRef:
-          name: run-docker-image
-        workspaces:
-          - name: source
-            workspace: git-source
-          - name: cargo-cache
-            workspace: cargo-cache
-        runAfter:
-          - build-image
-        params:
-          - name: args
-            value:
-              [
-                --no-default-features,
-                --features,
-                compare,
-                --no-fail-fast,
-                --lib,
-                --test,
-                test_loader,
-              ]
-          - name: docker-image
-            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
-    finally:
-      - name: report-success
-        when:
-          - input: "$(tasks.status)"
-            operator: in
-            values: ["Succeeded", "Completed"]
-        taskRef:
-          name: gitea-set-status
-        params:
-          - name: CONTEXT
-            value: "$(params.JOB_NAME)"
-          - name: REPO_FULL_NAME
-            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
-          - name: GITEA_HOST_URL
-            value: code.fizz.buzz
-          - name: SHA
-            value: "$(tasks.fetch-repository.results.commit)"
-          - name: DESCRIPTION
-            value: "Build $(params.JOB_NAME) has succeeded"
-          - name: STATE
-            value: success
-          - name: TARGET_URL
-            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
-      - name: report-failure
-        when:
-          - input: "$(tasks.status)"
-            operator: in
-            values: ["Failed"]
-        taskRef:
-          name: gitea-set-status
-        params:
-          - name: CONTEXT
-            value: "$(params.JOB_NAME)"
-          - name: REPO_FULL_NAME
-            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
-          - name: GITEA_HOST_URL
-            value: code.fizz.buzz
-          - name: SHA
-            value: "$(tasks.fetch-repository.results.commit)"
-          - name: DESCRIPTION
-            value: "Build $(params.JOB_NAME) has failed"
-          - name: STATE
-            value: failure
-          - name: TARGET_URL
-            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
-      - name: cargo-cache-autoclean
-        taskRef:
-          name: run-docker-image
-        workspaces:
-          - name: source
-            workspace: git-source
-          - name: cargo-cache
-            workspace: cargo-cache
-        params:
-          - name: command
-            value: [cargo, cache, --autoclean]
-          - name: args
-            value: []
-          - name: docker-image
-            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
-    workspaces:
-      - name: git-source
-      - name: docker-credentials
-      - name: cargo-cache
-  workspaces:
-    - name: git-source
-      volumeClaimTemplate:
-        spec:
-          storageClassName: "nfs-client"
-          accessModes:
-            - ReadWriteOnce
-          resources:
-            requests:
-              storage: 10Gi
-      subPath: rust-source
-    - name: cargo-cache
-      persistentVolumeClaim:
-        claimName: organic-cargo-cache-test
-    - name: docker-credentials
-      secret:
-        secretName: harbor-plain
-  serviceAccountName: build-bot
-  params:
-    - name: image-name
-      value: "harbor.fizz.buzz/private/organic-test"
-    - name: path-to-image-context
-      value: docker/organic_test/
-    - name: path-to-dockerfile
-      value: docker/organic_test/Dockerfile

.lighthouse/pipeline-rustfmt.yaml

@@ -1,230 +0,0 @@
-apiVersion: tekton.dev/v1beta1
-kind: PipelineRun
-metadata:
-  name: rustfmt
-spec:
-  pipelineSpec:
-    params:
-      - name: image-name
-        description: The name for the built image
-        type: string
-      - name: path-to-image-context
-        description: The path to the build context
-        type: string
-      - name: path-to-dockerfile
-        description: The path to the Dockerfile
-        type: string
-      - name: GIT_USER_NAME
-        description: The username for git
-        type: string
-        default: "fluxcdbot"
-      - name: GIT_USER_EMAIL
-        description: The email for git
-        type: string
-        default: "fluxcdbot@users.noreply.github.com"
-    tasks:
-      - name: do-stuff
-        taskSpec:
-          metadata: {}
-          stepTemplate:
-            image: alpine:3.18
-            name: ""
-            resources:
-              requests:
-                cpu: 10m
-                memory: 600Mi
-            workingDir: /workspace/source
-          steps:
-            - image: alpine:3.18
-              name: do-stuff-step
-              script: |
-                #!/usr/bin/env sh
-                echo "hello world"
-      - name: report-pending
-        taskRef:
-          name: gitea-set-status
-        runAfter:
-          - fetch-repository
-        params:
-          - name: CONTEXT
-            value: "$(params.JOB_NAME)"
-          - name: REPO_FULL_NAME
-            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
-          - name: GITEA_HOST_URL
-            value: code.fizz.buzz
-          - name: SHA
-            value: "$(tasks.fetch-repository.results.commit)"
-          - name: DESCRIPTION
-            value: "Build $(params.JOB_NAME) has started"
-          - name: STATE
-            value: pending
-          - name: TARGET_URL
-            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
-      - name: fetch-repository
-        taskRef:
-          name: git-clone
-        workspaces:
-          - name: output
-            workspace: git-source
-        params:
-          - name: url
-            value: $(params.REPO_URL)
-          - name: revision
-            value: $(params.PULL_BASE_SHA)
-          - name: deleteExisting
-            value: "true"
-      - name: build-image
-        taskRef:
-          name: kaniko
-        params:
-          - name: IMAGE
-            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
-          - name: CONTEXT
-            value: $(params.path-to-image-context)
-          - name: DOCKERFILE
-            value: $(params.path-to-dockerfile)
-          - name: BUILDER_IMAGE
-            value: "gcr.io/kaniko-project/executor:v1.12.1"
-          - name: EXTRA_ARGS
-            value:
-              - --cache=true
-              - --cache-copy-layers
-              - --cache-repo=harbor.fizz.buzz/kanikocache/cache
-              - --use-new-run # Should result in a speed-up
-              - --reproducible # To remove timestamps so layer caching works.
-              - --snapshot-mode=redo
-              - --skip-unused-stages=true
-              - --registry-mirror=dockerhub.dockerhub.svc.cluster.local
-        workspaces:
-          - name: source
-            workspace: git-source
-          - name: dockerconfig
-            workspace: docker-credentials
-        runAfter:
-          - fetch-repository
-      - name: rustfmt
-        taskRef:
-          name: run-docker-image
-        workspaces:
-          - name: source
-            workspace: git-source
-        runAfter:
-          - build-image
-        params:
-          - name: docker-image
-            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
-      - name: cargo-fix
-        taskRef:
-          name: run-docker-image
-        workspaces:
-          - name: source
-            workspace: git-source
-          - name: cargo-cache
-            workspace: cargo-cache
-        runAfter:
-          - rustfmt
-        params:
-          - name: command
-            value: ["cargo", "fix"]
-          - name: args
-            value: ["--allow-dirty"]
-          - name: docker-image
-            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
-      - name: commit-changes
-        taskRef:
-          name: git-cli
-        params:
-          - name: GIT_USER_NAME
-            value: $(params.GIT_USER_NAME)
-          - name: GIT_USER_EMAIL
-            value: $(params.GIT_USER_EMAIL)
-          - name: GIT_SCRIPT
-            value: |
-              pwd
-              git config --global --add safe.directory /workspace/source
-              git_status=$(git status --porcelain)
-              if [ -n "$git_status" ]; then
-                git commit -a -m "CI: autofix rust code."
-                git push origin HEAD:$(params.PULL_BASE_REF)
-              else
-                echo "No changes to commit."
-              fi
-        workspaces:
-          - name: source
-            workspace: git-source
-        runAfter:
-          - cargo-fix
-    finally:
-      - name: report-success
-        when:
-          - input: "$(tasks.status)"
-            operator: in
-            values: ["Succeeded", "Completed"]
-        taskRef:
-          name: gitea-set-status
-        params:
-          - name: CONTEXT
-            value: "$(params.JOB_NAME)"
-          - name: REPO_FULL_NAME
-            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
-          - name: GITEA_HOST_URL
-            value: code.fizz.buzz
-          - name: SHA
-            value: "$(tasks.fetch-repository.results.commit)"
-          - name: DESCRIPTION
-            value: "Build $(params.JOB_NAME) has succeeded"
-          - name: STATE
-            value: success
-          - name: TARGET_URL
-            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
-      - name: report-failure
-        when:
-          - input: "$(tasks.status)"
-            operator: in
-            values: ["Failed"]
-        taskRef:
-          name: gitea-set-status
-        params:
-          - name: CONTEXT
-            value: "$(params.JOB_NAME)"
-          - name: REPO_FULL_NAME
-            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
-          - name: GITEA_HOST_URL
-            value: code.fizz.buzz
-          - name: SHA
-            value: "$(tasks.fetch-repository.results.commit)"
-          - name: DESCRIPTION
-            value: "Build $(params.JOB_NAME) has failed"
-          - name: STATE
-            value: failure
-          - name: TARGET_URL
-            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
-    workspaces:
-      - name: git-source
-      - name: docker-credentials
-  workspaces:
-    - name: git-source
-      volumeClaimTemplate:
-        spec:
-          storageClassName: "nfs-client"
-          accessModes:
-            - ReadWriteOnce
-          resources:
-            requests:
-              storage: 10Gi
-      subPath: rust-source
-    - name: cargo-cache
-      persistentVolumeClaim:
-        claimName: organic-cargo-cache-fmt
-    - name: docker-credentials
-      secret:
-        secretName: harbor-plain
-  serviceAccountName: build-bot
-  timeout: 240h0m0s
-  params:
-    - name: image-name
-      value: "harbor.fizz.buzz/private/organic-fmt"
-    - name: path-to-image-context
-      value: docker/cargo_fmt/
-    - name: path-to-dockerfile
-      value: docker/cargo_fmt/Dockerfile

.lighthouse/triggers.yaml

@@ -1,39 +0,0 @@
-apiVersion: config.lighthouse.jenkins-x.io/v1alpha1
-kind: TriggerConfig
-spec:
-  postsubmits:
-    - name: rustfmt
-      source: "pipeline-rustfmt.yaml"
-      # Override https-based url from lighthouse events.
-      clone_uri: "git@code.fizz.buzz:talexander/organic.git"
-      branches:
-        - ^main$
-        - ^master$
-    - name: rust-test
-      source: "pipeline-rust-test.yaml"
-      # Override https-based url from lighthouse events.
-      clone_uri: "git@code.fizz.buzz:talexander/organic.git"
-      skip_branches:
-        # We already run on every commit, so running when the semver tags get pushed is causing needless double-processing.
-        - "^v[0-9]+\\.[0-9]+\\.[0-9]+$"
-    - name: rust-foreign-document-test
-      source: "pipeline-foreign-document-test.yaml"
-      # Override https-based url from lighthouse events.
-      clone_uri: "git@code.fizz.buzz:talexander/organic.git"
-      skip_branches:
-        # We already run on every commit, so running when the semver tags get pushed is causing needless double-processing.
-        - "^v[0-9]+\\.[0-9]+\\.[0-9]+$"
-    - name: rust-build
-      source: "pipeline-rust-build.yaml"
-      # Override https-based url from lighthouse events.
-      clone_uri: "git@code.fizz.buzz:talexander/organic.git"
-      skip_branches:
-        # We already run on every commit, so running when the semver tags get pushed is causing needless double-processing.
-        - "^v[0-9]+\\.[0-9]+\\.[0-9]+$"
-    - name: clippy
-      source: "pipeline-clippy.yaml"
-      # Override https-based url from lighthouse events.
-      clone_uri: "git@code.fizz.buzz:talexander/organic.git"
-      skip_branches:
-        # We already run on every commit, so running when the semver tags get pushed is causing needless double-processing.
-        - "^v[0-9]+\\.[0-9]+\\.[0-9]+$"

.webhook_bridge/pipeline-build-hash.yaml

@@ -0,0 +1,701 @@
+apiVersion: tekton.dev/v1
+kind: PipelineRun
+metadata:
+  name: build
+spec:
+  timeouts:
+    pipeline: "2h0m0s"
+    tasks: "1h0m0s"
+    finally: "0h30m0s"
+  taskRunTemplate:
+    serviceAccountName: build-bot
+  pipelineSpec:
+    params:
+      - name: image-name
+        description: The name for the built image
+        type: string
+      - name: target-name
+        description: The dockerfile target to build
+        type: string
+      - name: path-to-image-context
+        description: The path to the build context
+        type: string
+      - name: path-to-dockerfile
+        description: The path to the Dockerfile
+        type: string
+    tasks:
+      - name: report-pending
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/mirror/catalog.git # mirror of https://github.com/tektoncd/catalog.git
+            - name: revision
+              value: df36b3853a5657fd883015cdbf07ad6466918acf
+            - name: pathInRepo
+              value: task/gitea-set-status/0.1/gitea-set-status.yaml
+        params:
+          - name: CONTEXT
+            value: "$(params.JOB_NAME)"
+          - name: REPO_FULL_NAME
+            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
+          - name: GITEA_HOST_URL
+            value: code.fizz.buzz
+          - name: SHA
+            value: "$(tasks.fetch-repository.results.commit)"
+          - name: DESCRIPTION
+            value: "Build $(params.JOB_NAME) has started"
+          - name: STATE
+            value: pending
+          - name: TARGET_URL
+            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
+      - name: fetch-repository
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/mirror/catalog.git # mirror of https://github.com/tektoncd/catalog.git
+            - name: revision
+              value: df36b3853a5657fd883015cdbf07ad6466918acf
+            - name: pathInRepo
+              value: task/git-clone/0.9/git-clone.yaml
+        workspaces:
+          - name: output
+            workspace: git-source
+        params:
+          - name: url
+            value: $(params.REPO_URL)
+          - name: revision
+            value: $(params.PULL_BASE_SHA)
+          - name: deleteExisting
+            value: "true"
+      - name: get-git-commit-time
+        taskSpec:
+          metadata: {}
+          stepTemplate:
+            image: alpine:3.20
+            computeResources:
+              requests:
+                cpu: 10m
+                memory: 600Mi
+            workingDir: "$(workspaces.repo.path)"
+          results:
+            - name: unix-time
+              description: The time of the git commit in unix timestamp format.
+          steps:
+            - image: alpine/git:v2.34.2
+              name: detect-tag-step
+              script: |
+                #!/usr/bin/env sh
+                set -euo pipefail
+                echo -n "$(git log -1 --pretty=%ct)" | tee $(results.unix-time.path)
+        workspaces:
+          - name: repo
+            workspace: git-source
+        runAfter:
+          - fetch-repository
+      - name: build-image
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/talexander/personal_tekton_catalog.git
+            - name: revision
+              value: 7ee31a185243ee6da13dcd26a592c585b64c80e5
+            - name: pathInRepo
+              value: task/buildkit-rootless-daemonless/0.1/buildkit-rootless-daemonless.yaml
+        params:
+          - name: OUTPUT
+            value: >-
+              type=image,"name=$(params.image-name):latest,$(params.image-name):$(tasks.fetch-repository.results.commit)",push=true,compression=zstd,compression-level=22,oci-mediatypes=true
+          - name: CONTEXT
+            value: $(params.path-to-image-context)
+          - name: DOCKERFILE
+            value: $(params.path-to-dockerfile)
+          - name: EXTRA_ARGS
+            value:
+              - "--opt"
+              - "target=$(params.target-name)"
+              - --import-cache
+              - "type=registry,ref=$(params.image-name):buildcache"
+              - --export-cache
+              - "type=registry,ref=$(params.image-name):buildcache,mode=max,compression=zstd,compression-level=22,rewrite-timestamp=true,image-manifest=true,oci-mediatypes=true"
+              - --opt
+              - build-arg:SOURCE_DATE_EPOCH=$(tasks.get-git-commit-time.results.unix-time)
+          - name: BUILDKITD_TOML
+            value: |
+              debug = true
+              [registry."docker.io"]
+                mirrors = ["dockerhub.dockerhub.svc.cluster.local"]
+              [registry."dockerhub.dockerhub.svc.cluster.local"]
+                http = true
+                insecure = true
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: dockerconfig
+            workspace: docker-credentials
+        runAfter:
+          - fetch-repository
+      #############
+      - name: run-image-none
+        taskSpec:
+          metadata: {}
+          params:
+            - name: docker-image
+              type: string
+              description: Docker image to run.
+              default: alpine:3.18
+          stepTemplate:
+            image: alpine:3.18
+            name: ""
+            resources:
+              requests:
+                cpu: 10m
+                memory: 60Mi
+            workingDir: /workspace/source
+          workspaces:
+            - name: source
+              mountPath: /source
+            - name: cargo-cache
+              mountPath: /usr/local/cargo/registry
+              optional: true
+          steps:
+            - name: run
+              image: $(params.docker-image)
+              workingDir: "$(workspaces.source.path)"
+              command: ["cargo", "build"]
+              args: ["--no-default-features"]
+              env:
+                - name: CARGO_TARGET_DIR
+                  value: /target
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+            subPath: none
+        runAfter:
+          - build-image
+        params:
+          - name: docker-image
+            value: "$(tasks.build-image.results.IMAGE_URL[1])"
+      #############
+      - name: run-image-tracing
+        taskSpec:
+          metadata: {}
+          params:
+            - name: docker-image
+              type: string
+              description: Docker image to run.
+              default: alpine:3.18
+          stepTemplate:
+            image: alpine:3.18
+            name: ""
+            resources:
+              requests:
+                cpu: 10m
+                memory: 60Mi
+            workingDir: /workspace/source
+          workspaces:
+            - name: source
+              mountPath: /source
+            - name: cargo-cache
+              mountPath: /usr/local/cargo/registry
+              optional: true
+          steps:
+            - name: run
+              image: $(params.docker-image)
+              workingDir: "$(workspaces.source.path)"
+              command: ["cargo", "build"]
+              args: ["--no-default-features", "--features", "tracing"]
+              env:
+                - name: CARGO_TARGET_DIR
+                  value: /target
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+            subPath: tracing
+        runAfter:
+          - run-image-none
+        params:
+          - name: docker-image
+            value: "$(tasks.build-image.results.IMAGE_URL[1])"
+      #############
+      - name: run-image-compare
+        taskSpec:
+          metadata: {}
+          params:
+            - name: docker-image
+              type: string
+              description: Docker image to run.
+              default: alpine:3.18
+          stepTemplate:
+            image: alpine:3.18
+            name: ""
+            resources:
+              requests:
+                cpu: 10m
+                memory: 60Mi
+            workingDir: /workspace/source
+          workspaces:
+            - name: source
+              mountPath: /source
+            - name: cargo-cache
+              mountPath: /usr/local/cargo/registry
+              optional: true
+          steps:
+            - name: run
+              image: $(params.docker-image)
+              workingDir: "$(workspaces.source.path)"
+              command: ["cargo", "build"]
+              args: ["--no-default-features", "--features", "compare"]
+              env:
+                - name: CARGO_TARGET_DIR
+                  value: /target
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+            subPath: compare
+        runAfter:
+          - run-image-tracing
+        params:
+          - name: docker-image
+            value: "$(tasks.build-image.results.IMAGE_URL[1])"
+      #############
+      - name: run-image-default
+        taskSpec:
+          metadata: {}
+          params:
+            - name: docker-image
+              type: string
+              description: Docker image to run.
+              default: alpine:3.18
+          stepTemplate:
+            image: alpine:3.18
+            name: ""
+            resources:
+              requests:
+                cpu: 10m
+                memory: 60Mi
+            workingDir: /workspace/source
+          workspaces:
+            - name: source
+              mountPath: /source
+            - name: cargo-cache
+              mountPath: /usr/local/cargo/registry
+              optional: true
+          steps:
+            - name: run
+              image: $(params.docker-image)
+              workingDir: "$(workspaces.source.path)"
+              command: ["cargo", "build"]
+              args: []
+              env:
+                - name: CARGO_TARGET_DIR
+                  value: /target
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+            subPath: default
+        runAfter:
+          - run-image-compare
+        params:
+          - name: docker-image
+            value: "$(tasks.build-image.results.IMAGE_URL[1])"
+      #############
+      - name: run-image-tracing-compare
+        taskSpec:
+          metadata: {}
+          params:
+            - name: docker-image
+              type: string
+              description: Docker image to run.
+              default: alpine:3.18
+          stepTemplate:
+            image: alpine:3.18
+            name: ""
+            resources:
+              requests:
+                cpu: 10m
+                memory: 60Mi
+            workingDir: /workspace/source
+          workspaces:
+            - name: source
+              mountPath: /source
+            - name: cargo-cache
+              mountPath: /usr/local/cargo/registry
+              optional: true
+          steps:
+            - name: run
+              image: $(params.docker-image)
+              workingDir: "$(workspaces.source.path)"
+              command: ["cargo", "build"]
+              args: ["--no-default-features", "--features", "tracing,compare"]
+              env:
+                - name: CARGO_TARGET_DIR
+                  value: /target
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+            subPath: tracing-compare
+        runAfter:
+          - run-image-default
+        params:
+          - name: docker-image
+            value: "$(tasks.build-image.results.IMAGE_URL[1])"
+      #############
+      - name: run-image-compare-foreign
+        taskSpec:
+          metadata: {}
+          params:
+            - name: docker-image
+              type: string
+              description: Docker image to run.
+              default: alpine:3.18
+          stepTemplate:
+            image: alpine:3.18
+            name: ""
+            resources:
+              requests:
+                cpu: 10m
+                memory: 60Mi
+            workingDir: /workspace/source
+          workspaces:
+            - name: source
+              mountPath: /source
+            - name: cargo-cache
+              mountPath: /usr/local/cargo/registry
+              optional: true
+          steps:
+            - name: run
+              image: $(params.docker-image)
+              workingDir: "$(workspaces.source.path)"
+              command: ["cargo", "build"]
+              args:
+                [
+                  "--no-default-features",
+                  "--features",
+                  "compare,foreign_document_test",
+                ]
+              env:
+                - name: CARGO_TARGET_DIR
+                  value: /target
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+            subPath: compare-foreign
+        runAfter:
+          - run-image-tracing-compare
+        params:
+          - name: docker-image
+            value: "$(tasks.build-image.results.IMAGE_URL[1])"
+      #############
+      - name: run-image-all
+        taskSpec:
+          metadata: {}
+          params:
+            - name: docker-image
+              type: string
+              description: Docker image to run.
+              default: alpine:3.18
+          stepTemplate:
+            image: alpine:3.18
+            name: ""
+            resources:
+              requests:
+                cpu: 10m
+                memory: 60Mi
+            workingDir: /workspace/source
+          workspaces:
+            - name: source
+              mountPath: /source
+            - name: cargo-cache
+              mountPath: /usr/local/cargo/registry
+              optional: true
+          steps:
+            - name: run
+              image: $(params.docker-image)
+              workingDir: "$(workspaces.source.path)"
+              command: ["cargo", "build"]
+              args:
+                [
+                  "--no-default-features",
+                  "--features",
+                  "tracing,compare,foreign_document_test",
+                ]
+              env:
+                - name: CARGO_TARGET_DIR
+                  value: /target
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+            subPath: all
+        runAfter:
+          - run-image-compare-foreign
+        params:
+          - name: docker-image
+            value: "$(tasks.build-image.results.IMAGE_URL[1])"
+      #############
+      - name: run-image-wasm
+        taskSpec:
+          metadata: {}
+          params:
+            - name: docker-image
+              type: string
+              description: Docker image to run.
+              default: alpine:3.18
+          stepTemplate:
+            image: alpine:3.18
+            name: ""
+            resources:
+              requests:
+                cpu: 10m
+                memory: 60Mi
+            workingDir: /workspace/source
+          workspaces:
+            - name: source
+              mountPath: /source
+            - name: cargo-cache
+              mountPath: /usr/local/cargo/registry
+              optional: true
+          steps:
+            - name: run
+              image: $(params.docker-image)
+              workingDir: "$(workspaces.source.path)"
+              command: ["cargo", "build"]
+              args:
+                [
+                  "--target",
+                  "wasm32-unknown-unknown",
+                  "--profile",
+                  "wasm",
+                  "--bin",
+                  "wasm",
+                  "--no-default-features",
+                  "--features",
+                  "wasm",
+                ]
+              env:
+                - name: CARGO_TARGET_DIR
+                  value: /target
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+            subPath: wasm
+        runAfter:
+          - run-image-all
+        params:
+          - name: docker-image
+            value: "$(tasks.build-image.results.IMAGE_URL[1])"
+      #############
+      - name: run-image-wasm-test
+        taskSpec:
+          metadata: {}
+          params:
+            - name: docker-image
+              type: string
+              description: Docker image to run.
+              default: alpine:3.18
+          stepTemplate:
+            image: alpine:3.18
+            name: ""
+            resources:
+              requests:
+                cpu: 10m
+                memory: 60Mi
+            workingDir: /workspace/source
+          workspaces:
+            - name: source
+              mountPath: /source
+            - name: cargo-cache
+              mountPath: /usr/local/cargo/registry
+              optional: true
+          steps:
+            - name: run
+              image: $(params.docker-image)
+              workingDir: "$(workspaces.source.path)"
+              command: ["cargo", "build"]
+              args:
+                [
+                  "--bin",
+                  "wasm_test",
+                  "--no-default-features",
+                  "--features",
+                  "wasm_test",
+                ]
+              env:
+                - name: CARGO_TARGET_DIR
+                  value: /target
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+            subPath: wasm-test
+        runAfter:
+          - run-image-wasm
+        params:
+          - name: docker-image
+            value: "$(tasks.build-image.results.IMAGE_URL[1])"
+      #############
+    finally:
+      - name: report-success
+        when:
+          - input: "$(tasks.status)"
+            operator: in
+            values: ["Succeeded", "Completed"]
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/mirror/catalog.git # mirror of https://github.com/tektoncd/catalog.git
+            - name: revision
+              value: df36b3853a5657fd883015cdbf07ad6466918acf
+            - name: pathInRepo
+              value: task/gitea-set-status/0.1/gitea-set-status.yaml
+        params:
+          - name: CONTEXT
+            value: "$(params.JOB_NAME)"
+          - name: REPO_FULL_NAME
+            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
+          - name: GITEA_HOST_URL
+            value: code.fizz.buzz
+          - name: SHA
+            value: "$(tasks.fetch-repository.results.commit)"
+          - name: DESCRIPTION
+            value: "Build $(params.JOB_NAME) has succeeded"
+          - name: STATE
+            value: success
+          - name: TARGET_URL
+            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
+      - name: report-failure
+        when:
+          - input: "$(tasks.status)"
+            operator: in
+            values: ["Failed"]
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/mirror/catalog.git # mirror of https://github.com/tektoncd/catalog.git
+            - name: revision
+              value: df36b3853a5657fd883015cdbf07ad6466918acf
+            - name: pathInRepo
+              value: task/gitea-set-status/0.1/gitea-set-status.yaml
+        params:
+          - name: CONTEXT
+            value: "$(params.JOB_NAME)"
+          - name: REPO_FULL_NAME
+            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
+          - name: GITEA_HOST_URL
+            value: code.fizz.buzz
+          - name: SHA
+            value: "$(tasks.fetch-repository.results.commit)"
+          - name: DESCRIPTION
+            value: "Build $(params.JOB_NAME) has failed"
+          - name: STATE
+            value: failure
+          - name: TARGET_URL
+            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
+      - name: cargo-cache-autoclean
+        taskSpec:
+          metadata: {}
+          params:
+            - name: docker-image
+              type: string
+              description: Docker image to run.
+              default: alpine:3.18
+            - name: cache-subdir
+              type: string
+              description: subPath used in the persistent volume for the cargo cache.
+          steptemplate:
+            image: alpine:3.18
+            name: ""
+            resources:
+              requests:
+                cpu: 10m
+                memory: 60Mi
+            workingDir: /workspace/source
+          workspaces:
+            - name: source
+              mountPath: /source
+            - name: cargo-cache
+              mountPath: /usr/local/cargo/registry
+              optional: true
+          steps:
+            - name: run
+              image: $(params.docker-image)
+              workingDir: "$(workspaces.source.path)"
+              command: ["ls", "$(workspaces.cargo-cache.path)"]
+              # command: [echo, $(params.cache-subdir)]
+              # command: [cargo, cache, --autoclean]
+              args: []
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+            subPath: $(params.cache-subdir)
+        params:
+          - name: docker-image
+            value: "$(tasks.build-image.results.IMAGE_URL[1])"
+          - name: cache-subdir
+            value: none
+        # matrix:
+        #   params:
+        #     - name: cache-subdir
+        #       value:
+        #         - none
+        #         - tracing
+        #         - compare
+        #         - default
+        #         - tracing-compare
+        #         - compare-foreign
+        #         - all
+        #         - wasm
+        #         - wasm-test
+    workspaces:
+      - name: git-source
+      - name: docker-credentials
+      - name: cargo-cache
+  workspaces:
+    - name: git-source
+      volumeClaimTemplate:
+        spec:
+          storageClassName: "local-path"
+          accessModes:
+            - ReadWriteOnce
+          resources:
+            requests:
+              storage: 10Gi
+      subPath: rust-source
+    - name: cargo-cache
+      persistentVolumeClaim:
+        claimName: organic-cargo-cache-build
+    - name: docker-credentials
+      secret:
+        secretName: harbor-plain
+  params:
+    - name: image-name
+      value: "harbor.fizz.buzz/private/organic-development-wasm"
+    - name: target-name
+      value: "wasm"
+    - name: path-to-image-context
+      value: .
+    - name: path-to-dockerfile
+      value: docker/organic_development/

.webhook_bridge/pipeline-foreign-document-test.yaml

@@ -0,0 +1,301 @@
+apiVersion: tekton.dev/v1
+kind: PipelineRun
+metadata:
+  name: foreign-document-test
+spec:
+  timeouts:
+    pipeline: "2h0m0s"
+    tasks: "1h0m40s"
+    finally: "0h30m0s"
+  taskRunTemplate:
+    serviceAccountName: build-bot
+  pipelineSpec:
+    params:
+      - name: image-name
+        description: The name for the built image
+        type: string
+      - name: target-name
+        description: The dockerfile target to build
+        type: string
+      - name: path-to-image-context
+        description: The path to the build context
+        type: string
+      - name: path-to-dockerfile
+        description: The path to the Dockerfile
+        type: string
+    tasks:
+      - name: report-pending
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/mirror/catalog.git # mirror of https://github.com/tektoncd/catalog.git
+            - name: revision
+              value: df36b3853a5657fd883015cdbf07ad6466918acf
+            - name: pathInRepo
+              value: task/gitea-set-status/0.1/gitea-set-status.yaml
+        params:
+          - name: CONTEXT
+            value: "$(params.JOB_NAME)"
+          - name: REPO_FULL_NAME
+            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
+          - name: GITEA_HOST_URL
+            value: code.fizz.buzz
+          - name: SHA
+            value: "$(tasks.fetch-repository.results.commit)"
+          - name: DESCRIPTION
+            value: "Build $(params.JOB_NAME) has started"
+          - name: STATE
+            value: pending
+          - name: TARGET_URL
+            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
+      - name: fetch-repository
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/mirror/catalog.git # mirror of https://github.com/tektoncd/catalog.git
+            - name: revision
+              value: df36b3853a5657fd883015cdbf07ad6466918acf
+            - name: pathInRepo
+              value: task/git-clone/0.9/git-clone.yaml
+        workspaces:
+          - name: output
+            workspace: git-source
+        params:
+          - name: url
+            value: $(params.REPO_URL)
+          - name: revision
+            value: $(params.PULL_BASE_SHA)
+          - name: deleteExisting
+            value: "true"
+      - name: get-git-commit-time
+        taskSpec:
+          metadata: {}
+          stepTemplate:
+            image: alpine:3.20
+            computeResources:
+              requests:
+                cpu: 10m
+                memory: 600Mi
+            workingDir: "$(workspaces.repo.path)"
+          results:
+            - name: unix-time
+              description: The time of the git commit in unix timestamp format.
+          steps:
+            - image: alpine/git:v2.34.2
+              name: detect-tag-step
+              script: |
+                #!/usr/bin/env sh
+                set -euo pipefail
+                echo -n "$(git log -1 --pretty=%ct)" | tee $(results.unix-time.path)
+        workspaces:
+          - name: repo
+            workspace: git-source
+        runAfter:
+          - fetch-repository
+      - name: build-image
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/talexander/personal_tekton_catalog.git
+            - name: revision
+              value: 7ee31a185243ee6da13dcd26a592c585b64c80e5
+            - name: pathInRepo
+              value: task/buildkit-rootless-daemonless/0.1/buildkit-rootless-daemonless.yaml
+        params:
+          - name: OUTPUT
+            value: >-
+              type=image,"name=$(params.image-name):latest,$(params.image-name):$(tasks.fetch-repository.results.commit)",push=true,compression=zstd,compression-level=22,oci-mediatypes=true
+          - name: CONTEXT
+            value: $(params.path-to-image-context)
+          - name: DOCKERFILE
+            value: $(params.path-to-dockerfile)
+          - name: EXTRA_ARGS
+            value:
+              - "--opt"
+              - "target=$(params.target-name)"
+              - --import-cache
+              - "type=registry,ref=$(params.image-name):buildcache"
+              - --export-cache
+              - "type=registry,ref=$(params.image-name):buildcache,mode=max,compression=zstd,compression-level=22,rewrite-timestamp=true,image-manifest=true,oci-mediatypes=true"
+              - --opt
+              - build-arg:SOURCE_DATE_EPOCH=$(tasks.get-git-commit-time.results.unix-time)
+          - name: BUILDKITD_TOML
+            value: |
+              debug = true
+              [registry."docker.io"]
+                mirrors = ["dockerhub.dockerhub.svc.cluster.local"]
+              [registry."dockerhub.dockerhub.svc.cluster.local"]
+                http = true
+                insecure = true
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: dockerconfig
+            workspace: docker-credentials
+        runAfter:
+          - fetch-repository
+      - name: run-test
+        taskSpec:
+          metadata: {}
+          params:
+            - name: docker-image
+              type: string
+              description: Docker image to run.
+              default: alpine:3.20
+          stepTemplate:
+            image: alpine:3.20
+            computeResources:
+              requests:
+                cpu: 10m
+                memory: 600Mi
+            workingDir: /workspace/source
+          workspaces:
+            - name: source
+              mountPath: /source
+            - name: cargo-cache
+              mountPath: /usr/local/cargo/registry
+              optional: true
+          steps:
+            - name: run
+              image: $(params.docker-image)
+              workingDir: "$(workspaces.source.path)"
+              env:
+                - name: CARGO_TARGET_DIR
+                  value: /target
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+        runAfter:
+          - build-image
+        params:
+          - name: docker-image
+            value: "$(tasks.build-image.results.IMAGE_URL[1])"
+    finally:
+      - name: report-success
+        when:
+          - input: "$(tasks.status)"
+            operator: in
+            values: ["Succeeded", "Completed"]
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/mirror/catalog.git # mirror of https://github.com/tektoncd/catalog.git
+            - name: revision
+              value: df36b3853a5657fd883015cdbf07ad6466918acf
+            - name: pathInRepo
+              value: task/gitea-set-status/0.1/gitea-set-status.yaml
+        params:
+          - name: CONTEXT
+            value: "$(params.JOB_NAME)"
+          - name: REPO_FULL_NAME
+            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
+          - name: GITEA_HOST_URL
+            value: code.fizz.buzz
+          - name: SHA
+            value: "$(tasks.fetch-repository.results.commit)"
+          - name: DESCRIPTION
+            value: "Build $(params.JOB_NAME) has succeeded"
+          - name: STATE
+            value: success
+          - name: TARGET_URL
+            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
+      - name: report-failure
+        when:
+          - input: "$(tasks.status)"
+            operator: in
+            values: ["Failed"]
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/mirror/catalog.git # mirror of https://github.com/tektoncd/catalog.git
+            - name: revision
+              value: df36b3853a5657fd883015cdbf07ad6466918acf
+            - name: pathInRepo
+              value: task/gitea-set-status/0.1/gitea-set-status.yaml
+        params:
+          - name: CONTEXT
+            value: "$(params.JOB_NAME)"
+          - name: REPO_FULL_NAME
+            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
+          - name: GITEA_HOST_URL
+            value: code.fizz.buzz
+          - name: SHA
+            value: "$(tasks.fetch-repository.results.commit)"
+          - name: DESCRIPTION
+            value: "Build $(params.JOB_NAME) has failed"
+          - name: STATE
+            value: failure
+          - name: TARGET_URL
+            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
+      - name: cargo-cache-autoclean
+        taskSpec:
+          metadata: {}
+          params:
+            - name: docker-image
+              type: string
+              description: Docker image to run.
+              default: alpine:3.20
+          stepTemplate:
+            image: alpine:3.20
+            computeResources:
+              requests:
+                cpu: 10m
+                memory: 600Mi
+            workingDir: /workspace/source
+          workspaces:
+            - name: source
+              mountPath: /source
+            - name: cargo-cache
+              mountPath: /usr/local/cargo/registry
+              optional: true
+          steps:
+            - name: run
+              image: $(params.docker-image)
+              workingDir: "$(workspaces.source.path)"
+              command: [cargo, cache, --autoclean]
+              args: []
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+        params:
+          - name: docker-image
+            value: "$(tasks.build-image.results.IMAGE_URL[1])"
+    workspaces:
+      - name: git-source
+      - name: docker-credentials
+      - name: cargo-cache
+  workspaces:
+    - name: git-source
+      volumeClaimTemplate:
+        spec:
+          storageClassName: "local-path"
+          accessModes:
+            - ReadWriteOnce
+          resources:
+            requests:
+              storage: 10Gi
+      subPath: rust-source
+    - name: cargo-cache
+      persistentVolumeClaim:
+        claimName: organic-cargo-cache-test-foreign-document
+    - name: docker-credentials
+      secret:
+        secretName: harbor-plain
+  params:
+    - name: image-name
+      value: "harbor.fizz.buzz/private/organic-test-foreign-document"
+    - name: target-name
+      value: "foreign-document"
+    - name: path-to-image-context
+      value: docker/organic_test/
+    - name: path-to-dockerfile
+      value: docker/organic_test/

.webhook_bridge/pipeline-format.yaml

@@ -0,0 +1,334 @@
+apiVersion: tekton.dev/v1
+kind: PipelineRun
+metadata:
+  name: rust-format
+spec:
+  timeouts:
+    pipeline: "2h0m0s"
+    tasks: "1h0m0s"
+    finally: "0h30m0s"
+  taskRunTemplate:
+    serviceAccountName: build-bot
+  pipelineSpec:
+    params:
+      - name: image-name
+        description: The name for the built image
+        type: string
+      - name: target-name
+        description: The dockerfile target to build
+        type: string
+      - name: path-to-image-context
+        description: The path to the build context
+        type: string
+      - name: path-to-dockerfile
+        description: The path to the Dockerfile
+        type: string
+    tasks:
+      - name: report-pending
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/mirror/catalog.git # mirror of https://github.com/tektoncd/catalog.git
+            - name: revision
+              value: df36b3853a5657fd883015cdbf07ad6466918acf
+            - name: pathInRepo
+              value: task/gitea-set-status/0.1/gitea-set-status.yaml
+        params:
+          - name: CONTEXT
+            value: "$(params.JOB_NAME)"
+          - name: REPO_FULL_NAME
+            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
+          - name: GITEA_HOST_URL
+            value: code.fizz.buzz
+          - name: SHA
+            value: "$(tasks.fetch-repository.results.commit)"
+          - name: DESCRIPTION
+            value: "Build $(params.JOB_NAME) has started"
+          - name: STATE
+            value: pending
+          - name: TARGET_URL
+            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
+      - name: fetch-repository
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/mirror/catalog.git # mirror of https://github.com/tektoncd/catalog.git
+            - name: revision
+              value: df36b3853a5657fd883015cdbf07ad6466918acf
+            - name: pathInRepo
+              value: task/git-clone/0.9/git-clone.yaml
+        workspaces:
+          - name: output
+            workspace: git-source
+        params:
+          - name: url
+            value: $(params.REPO_URL)
+          - name: revision
+            value: $(params.PULL_BASE_SHA)
+          - name: deleteExisting
+            value: "true"
+      - name: get-git-commit-time
+        taskSpec:
+          metadata: {}
+          stepTemplate:
+            image: alpine:3.20
+            computeResources:
+              requests:
+                cpu: 10m
+                memory: 600Mi
+            workingDir: "$(workspaces.repo.path)"
+          results:
+            - name: unix-time
+              description: The time of the git commit in unix timestamp format.
+          steps:
+            - image: alpine/git:v2.34.2
+              name: detect-tag-step
+              script: |
+                #!/usr/bin/env sh
+                set -euo pipefail
+                echo -n "$(git log -1 --pretty=%ct)" | tee $(results.unix-time.path)
+        workspaces:
+          - name: repo
+            workspace: git-source
+        runAfter:
+          - fetch-repository
+      - name: build-image
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/talexander/personal_tekton_catalog.git
+            - name: revision
+              value: 7ee31a185243ee6da13dcd26a592c585b64c80e5
+            - name: pathInRepo
+              value: task/buildkit-rootless-daemonless/0.1/buildkit-rootless-daemonless.yaml
+        params:
+          - name: OUTPUT
+            value: >-
+              type=image,"name=$(params.image-name):latest,$(params.image-name):$(tasks.fetch-repository.results.commit)",push=true,compression=zstd,compression-level=22,oci-mediatypes=true
+          - name: CONTEXT
+            value: $(params.path-to-image-context)
+          - name: DOCKERFILE
+            value: $(params.path-to-dockerfile)
+          - name: EXTRA_ARGS
+            value:
+              - "--opt"
+              - "target=$(params.target-name)"
+              - --import-cache
+              - "type=registry,ref=$(params.image-name):buildcache"
+              - --export-cache
+              - "type=registry,ref=$(params.image-name):buildcache,mode=max,compression=zstd,compression-level=22,rewrite-timestamp=true,image-manifest=true,oci-mediatypes=true"
+              - --opt
+              - build-arg:SOURCE_DATE_EPOCH=$(tasks.get-git-commit-time.results.unix-time)
+          - name: BUILDKITD_TOML
+            value: |
+              debug = true
+              [registry."docker.io"]
+                mirrors = ["dockerhub.dockerhub.svc.cluster.local"]
+              [registry."dockerhub.dockerhub.svc.cluster.local"]
+                http = true
+                insecure = true
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: dockerconfig
+            workspace: docker-credentials
+        runAfter:
+          - fetch-repository
+      - name: run-cargo-fmt
+        taskSpec:
+          metadata: {}
+          params:
+            - name: docker-image
+              type: string
+              description: Docker image to run.
+              default: alpine:3.20
+          stepTemplate:
+            image: alpine:3.20
+            computeResources:
+              requests:
+                cpu: 10m
+                memory: 600Mi
+            workingDir: /workspace/source
+          workspaces:
+            - name: source
+              mountPath: /source
+            - name: cargo-cache
+              mountPath: /usr/local/cargo/registry
+              optional: true
+          steps:
+            - name: run
+              image: $(params.docker-image)
+              workingDir: "$(workspaces.source.path)"
+              command: ["cargo", "fmt"]
+              args: []
+              env:
+                - name: CARGO_TARGET_DIR
+                  value: /target
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+        runAfter:
+          - build-image
+        params:
+          - name: docker-image
+            value: "$(tasks.build-image.results.IMAGE_URL[1])"
+      - name: commit-changes
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/mirror/catalog.git # mirror of https://github.com/tektoncd/catalog.git
+            - name: revision
+              value: df36b3853a5657fd883015cdbf07ad6466918acf
+            - name: pathInRepo
+              value: task/git-cli/0.4/git-cli.yaml
+        params:
+          - name: GIT_USER_NAME
+            value: fluxcdbot
+          - name: GIT_USER_EMAIL
+            value: "fluxcdbot@users.noreply.github.com"
+          - name: GIT_SCRIPT
+            value: |
+              pwd
+              git config --global --add safe.directory /workspace/source
+              git_status=$(git status --porcelain)
+              if [ -n "$git_status" ]; then
+                git commit -a -m "CI: autofix rust code."
+                git push origin HEAD:$(params.PULL_BASE_REF)
+              else
+                echo "No changes to commit."
+              fi
+        workspaces:
+          - name: source
+            workspace: git-source
+        runAfter:
+          - run-cargo-fmt
+    finally:
+      - name: report-success
+        when:
+          - input: "$(tasks.status)"
+            operator: in
+            values: ["Succeeded", "Completed"]
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/mirror/catalog.git # mirror of https://github.com/tektoncd/catalog.git
+            - name: revision
+              value: df36b3853a5657fd883015cdbf07ad6466918acf
+            - name: pathInRepo
+              value: task/gitea-set-status/0.1/gitea-set-status.yaml
+        params:
+          - name: CONTEXT
+            value: "$(params.JOB_NAME)"
+          - name: REPO_FULL_NAME
+            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
+          - name: GITEA_HOST_URL
+            value: code.fizz.buzz
+          - name: SHA
+            value: "$(tasks.fetch-repository.results.commit)"
+          - name: DESCRIPTION
+            value: "Build $(params.JOB_NAME) has succeeded"
+          - name: STATE
+            value: success
+          - name: TARGET_URL
+            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
+      - name: report-failure
+        when:
+          - input: "$(tasks.status)"
+            operator: in
+            values: ["Failed"]
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/mirror/catalog.git # mirror of https://github.com/tektoncd/catalog.git
+            - name: revision
+              value: df36b3853a5657fd883015cdbf07ad6466918acf
+            - name: pathInRepo
+              value: task/gitea-set-status/0.1/gitea-set-status.yaml
+        params:
+          - name: CONTEXT
+            value: "$(params.JOB_NAME)"
+          - name: REPO_FULL_NAME
+            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
+          - name: GITEA_HOST_URL
+            value: code.fizz.buzz
+          - name: SHA
+            value: "$(tasks.fetch-repository.results.commit)"
+          - name: DESCRIPTION
+            value: "Build $(params.JOB_NAME) has failed"
+          - name: STATE
+            value: failure
+          - name: TARGET_URL
+            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
+      - name: cargo-cache-autoclean
+        taskSpec:
+          metadata: {}
+          params:
+            - name: docker-image
+              type: string
+              description: Docker image to run.
+              default: alpine:3.20
+          stepTemplate:
+            image: alpine:3.20
+            computeResources:
+              requests:
+                cpu: 10m
+                memory: 600Mi
+            workingDir: /workspace/source
+          workspaces:
+            - name: source
+              mountPath: /source
+            - name: cargo-cache
+              mountPath: /usr/local/cargo/registry
+              optional: true
+          steps:
+            - name: run
+              image: $(params.docker-image)
+              workingDir: "$(workspaces.source.path)"
+              command: [cargo, cache, --autoclean]
+              args: []
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+        params:
+          - name: docker-image
+            value: "$(tasks.build-image.results.IMAGE_URL[1])"
+    workspaces:
+      - name: git-source
+      - name: docker-credentials
+      - name: cargo-cache
+  workspaces:
+    - name: git-source
+      volumeClaimTemplate:
+        spec:
+          storageClassName: "local-path"
+          accessModes:
+            - ReadWriteOnce
+          resources:
+            requests:
+              storage: 10Gi
+      subPath: rust-source
+    - name: cargo-cache
+      persistentVolumeClaim:
+        claimName: organic-cargo-cache-fmt
+    - name: docker-credentials
+      secret:
+        secretName: harbor-plain
+  params:
+    - name: image-name
+      value: "harbor.fizz.buzz/private/organic-development-format"
+    - name: target-name
+      value: "format"
+    - name: path-to-image-context
+      value: docker/organic_development/
+    - name: path-to-dockerfile
+      value: docker/organic_development/

.webhook_bridge/pipeline-rust-clippy.yaml

@@ -0,0 +1,313 @@
+apiVersion: tekton.dev/v1
+kind: PipelineRun
+metadata:
+  name: rust-clippy
+spec:
+  taskRunTemplate:
+    serviceAccountName: build-bot
+  timeouts:
+    pipeline: "2h0m0s"
+    tasks: "1h0m40s"
+    finally: "0h30m0s"
+  pipelineSpec:
+    params:
+      - name: image-name
+        description: The name for the built image
+        type: string
+      - name: target-name
+        description: The dockerfile target to build
+        type: string
+      - name: path-to-image-context
+        description: The path to the build context
+        type: string
+      - name: path-to-dockerfile
+        description: The path to the Dockerfile
+        type: string
+    tasks:
+      - name: report-pending
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/mirror/catalog.git # mirror of https://github.com/tektoncd/catalog.git
+            - name: revision
+              value: df36b3853a5657fd883015cdbf07ad6466918acf
+            - name: pathInRepo
+              value: task/gitea-set-status/0.1/gitea-set-status.yaml
+        params:
+          - name: CONTEXT
+            value: "$(params.JOB_NAME)"
+          - name: REPO_FULL_NAME
+            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
+          - name: GITEA_HOST_URL
+            value: code.fizz.buzz
+          - name: SHA
+            value: "$(tasks.fetch-repository.results.commit)"
+          - name: DESCRIPTION
+            value: "Build $(params.JOB_NAME) has started"
+          - name: STATE
+            value: pending
+          - name: TARGET_URL
+            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
+      - name: fetch-repository
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/mirror/catalog.git # mirror of https://github.com/tektoncd/catalog.git
+            - name: revision
+              value: df36b3853a5657fd883015cdbf07ad6466918acf
+            - name: pathInRepo
+              value: task/git-clone/0.9/git-clone.yaml
+        workspaces:
+          - name: output
+            workspace: git-source
+        params:
+          - name: url
+            value: $(params.REPO_URL)
+          - name: revision
+            value: $(params.PULL_BASE_SHA)
+          - name: deleteExisting
+            value: "true"
+      - name: get-git-commit-time
+        taskSpec:
+          metadata: {}
+          stepTemplate:
+            image: alpine:3.20
+            computeResources:
+              requests:
+                cpu: 10m
+                memory: 600Mi
+            workingDir: "$(workspaces.repo.path)"
+          results:
+            - name: unix-time
+              description: The time of the git commit in unix timestamp format.
+          steps:
+            - image: alpine/git:v2.34.2
+              name: detect-tag-step
+              script: |
+                #!/usr/bin/env sh
+                set -euo pipefail
+                echo -n "$(git log -1 --pretty=%ct)" | tee $(results.unix-time.path)
+        workspaces:
+          - name: repo
+            workspace: git-source
+        runAfter:
+          - fetch-repository
+      - name: build-image
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/talexander/personal_tekton_catalog.git
+            - name: revision
+              value: 7ee31a185243ee6da13dcd26a592c585b64c80e5
+            - name: pathInRepo
+              value: task/buildkit-rootless-daemonless/0.1/buildkit-rootless-daemonless.yaml
+        params:
+          - name: OUTPUT
+            value: >-
+              type=image,"name=$(params.image-name):latest,$(params.image-name):$(tasks.fetch-repository.results.commit)",push=true,compression=zstd,compression-level=22,oci-mediatypes=true
+          - name: CONTEXT
+            value: $(params.path-to-image-context)
+          - name: DOCKERFILE
+            value: $(params.path-to-dockerfile)
+          - name: EXTRA_ARGS
+            value:
+              - "--opt"
+              - "target=$(params.target-name)"
+              - --import-cache
+              - "type=registry,ref=$(params.image-name):buildcache"
+              - --export-cache
+              - "type=registry,ref=$(params.image-name):buildcache,mode=max,compression=zstd,compression-level=22,rewrite-timestamp=true,image-manifest=true,oci-mediatypes=true"
+              - --opt
+              - build-arg:SOURCE_DATE_EPOCH=$(tasks.get-git-commit-time.results.unix-time)
+          - name: BUILDKITD_TOML
+            value: |
+              debug = true
+              [registry."docker.io"]
+                mirrors = ["dockerhub.dockerhub.svc.cluster.local"]
+              [registry."dockerhub.dockerhub.svc.cluster.local"]
+                http = true
+                insecure = true
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: dockerconfig
+            workspace: docker-credentials
+        runAfter:
+          - fetch-repository
+      - name: run-cargo-clippy
+        taskSpec:
+          metadata: {}
+          params:
+            - name: docker-image
+              type: string
+              description: Docker image to run.
+              default: alpine:3.20
+          stepTemplate:
+            image: alpine:3.20
+            computeResources:
+              requests:
+                cpu: 10m
+                memory: 600Mi
+            workingDir: /workspace/source
+          workspaces:
+            - name: source
+              mountPath: /source
+            - name: cargo-cache
+              mountPath: /usr/local/cargo/registry
+              optional: true
+          steps:
+            - name: run
+              image: $(params.docker-image)
+              workingDir: "$(workspaces.source.path)"
+              command:
+                [
+                  "cargo",
+                  "clippy",
+                  "--no-deps",
+                  "--all-targets",
+                  "--all-features",
+                  "--",
+                  "-D",
+                  "warnings",
+                ]
+              args: []
+              env:
+                - name: CARGO_TARGET_DIR
+                  value: /target
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+        runAfter:
+          - build-image
+        params:
+          - name: docker-image
+            value: "$(tasks.build-image.results.IMAGE_URL[1])"
+    finally:
+      - name: report-success
+        when:
+          - input: "$(tasks.status)"
+            operator: in
+            values: ["Succeeded", "Completed"]
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/mirror/catalog.git # mirror of https://github.com/tektoncd/catalog.git
+            - name: revision
+              value: df36b3853a5657fd883015cdbf07ad6466918acf
+            - name: pathInRepo
+              value: task/gitea-set-status/0.1/gitea-set-status.yaml
+        params:
+          - name: CONTEXT
+            value: "$(params.JOB_NAME)"
+          - name: REPO_FULL_NAME
+            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
+          - name: GITEA_HOST_URL
+            value: code.fizz.buzz
+          - name: SHA
+            value: "$(tasks.fetch-repository.results.commit)"
+          - name: DESCRIPTION
+            value: "Build $(params.JOB_NAME) has succeeded"
+          - name: STATE
+            value: success
+          - name: TARGET_URL
+            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
+      - name: report-failure
+        when:
+          - input: "$(tasks.status)"
+            operator: in
+            values: ["Failed"]
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/mirror/catalog.git # mirror of https://github.com/tektoncd/catalog.git
+            - name: revision
+              value: df36b3853a5657fd883015cdbf07ad6466918acf
+            - name: pathInRepo
+              value: task/gitea-set-status/0.1/gitea-set-status.yaml
+        params:
+          - name: CONTEXT
+            value: "$(params.JOB_NAME)"
+          - name: REPO_FULL_NAME
+            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
+          - name: GITEA_HOST_URL
+            value: code.fizz.buzz
+          - name: SHA
+            value: "$(tasks.fetch-repository.results.commit)"
+          - name: DESCRIPTION
+            value: "Build $(params.JOB_NAME) has failed"
+          - name: STATE
+            value: failure
+          - name: TARGET_URL
+            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
+      - name: cargo-cache-autoclean
+        taskSpec:
+          metadata: {}
+          params:
+            - name: docker-image
+              type: string
+              description: Docker image to run.
+              default: alpine:3.20
+          stepTemplate:
+            image: alpine:3.20
+            computeResources:
+              requests:
+                cpu: 10m
+                memory: 600Mi
+            workingDir: /workspace/source
+          workspaces:
+            - name: source
+              mountPath: /source
+            - name: cargo-cache
+              mountPath: /usr/local/cargo/registry
+              optional: true
+          steps:
+            - name: run
+              image: $(params.docker-image)
+              workingDir: "$(workspaces.source.path)"
+              command: [cargo, cache, --autoclean]
+              args: []
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+        params:
+          - name: docker-image
+            value: "$(tasks.build-image.results.IMAGE_URL[1])"
+    workspaces:
+      - name: git-source
+      - name: docker-credentials
+      - name: cargo-cache
+  workspaces:
+    - name: git-source
+      volumeClaimTemplate:
+        spec:
+          storageClassName: "local-path"
+          accessModes:
+            - ReadWriteOnce
+          resources:
+            requests:
+              storage: 10Gi
+      subPath: rust-source
+    - name: cargo-cache
+      persistentVolumeClaim:
+        claimName: organic-cargo-cache-clippy
+    - name: docker-credentials
+      secret:
+        secretName: harbor-plain
+  params:
+    - name: image-name
+      value: "harbor.fizz.buzz/private/organic-development-clippy"
+    - name: target-name
+      value: "clippy"
+    - name: path-to-image-context
+      value: docker/organic_development/
+    - name: path-to-dockerfile
+      value: docker/organic_development/

.webhook_bridge/pipeline-rust-test.yaml

@@ -0,0 +1,312 @@
+apiVersion: tekton.dev/v1
+kind: PipelineRun
+metadata:
+  name: rust-test
+spec:
+  timeouts:
+    pipeline: "2h0m0s"
+    tasks: "1h0m40s"
+    finally: "0h30m0s"
+  taskRunTemplate:
+    serviceAccountName: build-bot
+  pipelineSpec:
+    params:
+      - name: image-name
+        description: The name for the built image
+        type: string
+      - name: target-name
+        description: The dockerfile target to build
+        type: string
+      - name: path-to-image-context
+        description: The path to the build context
+        type: string
+      - name: path-to-dockerfile
+        description: The path to the Dockerfile
+        type: string
+    tasks:
+      - name: report-pending
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/mirror/catalog.git # mirror of https://github.com/tektoncd/catalog.git
+            - name: revision
+              value: df36b3853a5657fd883015cdbf07ad6466918acf
+            - name: pathInRepo
+              value: task/gitea-set-status/0.1/gitea-set-status.yaml
+        params:
+          - name: CONTEXT
+            value: "$(params.JOB_NAME)"
+          - name: REPO_FULL_NAME
+            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
+          - name: GITEA_HOST_URL
+            value: code.fizz.buzz
+          - name: SHA
+            value: "$(tasks.fetch-repository.results.commit)"
+          - name: DESCRIPTION
+            value: "Build $(params.JOB_NAME) has started"
+          - name: STATE
+            value: pending
+          - name: TARGET_URL
+            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
+      - name: fetch-repository
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/mirror/catalog.git # mirror of https://github.com/tektoncd/catalog.git
+            - name: revision
+              value: df36b3853a5657fd883015cdbf07ad6466918acf
+            - name: pathInRepo
+              value: task/git-clone/0.9/git-clone.yaml
+        workspaces:
+          - name: output
+            workspace: git-source
+        params:
+          - name: url
+            value: $(params.REPO_URL)
+          - name: revision
+            value: $(params.PULL_BASE_SHA)
+          - name: deleteExisting
+            value: "true"
+      - name: get-git-commit-time
+        taskSpec:
+          metadata: {}
+          stepTemplate:
+            image: alpine:3.20
+            computeResources:
+              requests:
+                cpu: 10m
+                memory: 600Mi
+            workingDir: "$(workspaces.repo.path)"
+          results:
+            - name: unix-time
+              description: The time of the git commit in unix timestamp format.
+          steps:
+            - image: alpine/git:v2.34.2
+              name: detect-tag-step
+              script: |
+                #!/usr/bin/env sh
+                set -euo pipefail
+                echo -n "$(git log -1 --pretty=%ct)" | tee $(results.unix-time.path)
+        workspaces:
+          - name: repo
+            workspace: git-source
+        runAfter:
+          - fetch-repository
+      - name: build-image
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/talexander/personal_tekton_catalog.git
+            - name: revision
+              value: 7ee31a185243ee6da13dcd26a592c585b64c80e5
+            - name: pathInRepo
+              value: task/buildkit-rootless-daemonless/0.1/buildkit-rootless-daemonless.yaml
+        params:
+          - name: OUTPUT
+            value: >-
+              type=image,"name=$(params.image-name):latest,$(params.image-name):$(tasks.fetch-repository.results.commit)",push=true,compression=zstd,compression-level=22,oci-mediatypes=true
+          - name: CONTEXT
+            value: $(params.path-to-image-context)
+          - name: DOCKERFILE
+            value: $(params.path-to-dockerfile)
+          - name: EXTRA_ARGS
+            value:
+              - "--opt"
+              - "target=$(params.target-name)"
+              - --import-cache
+              - "type=registry,ref=$(params.image-name):buildcache"
+              - --export-cache
+              - "type=registry,ref=$(params.image-name):buildcache,mode=max,compression=zstd,compression-level=22,rewrite-timestamp=true,image-manifest=true,oci-mediatypes=true"
+              - --opt
+              - build-arg:SOURCE_DATE_EPOCH=$(tasks.get-git-commit-time.results.unix-time)
+          - name: BUILDKITD_TOML
+            value: |
+              debug = true
+              [registry."docker.io"]
+                mirrors = ["dockerhub.dockerhub.svc.cluster.local"]
+              [registry."dockerhub.dockerhub.svc.cluster.local"]
+                http = true
+                insecure = true
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: dockerconfig
+            workspace: docker-credentials
+        runAfter:
+          - fetch-repository
+      - name: run-cargo-test
+        taskSpec:
+          metadata: {}
+          params:
+            - name: docker-image
+              type: string
+              description: Docker image to run.
+              default: alpine:3.20
+          stepTemplate:
+            image: alpine:3.20
+            computeResources:
+              requests:
+                cpu: 10m
+                memory: 600Mi
+            workingDir: /workspace/source
+          workspaces:
+            - name: source
+              mountPath: /source
+            - name: cargo-cache
+              mountPath: /usr/local/cargo/registry
+              optional: true
+          steps:
+            - name: run
+              image: $(params.docker-image)
+              workingDir: "$(workspaces.source.path)"
+              command: [cargo, test]
+              args:
+                [
+                  --no-default-features,
+                  --features,
+                  "compare,wasm_test",
+                  --no-fail-fast,
+                  --lib,
+                  --test,
+                  test_loader,
+                ]
+              env:
+                - name: CARGO_TARGET_DIR
+                  value: /target
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+        runAfter:
+          - build-image
+        params:
+          - name: docker-image
+            value: "$(tasks.build-image.results.IMAGE_URL[1])"
+    finally:
+      - name: report-success
+        when:
+          - input: "$(tasks.status)"
+            operator: in
+            values: ["Succeeded", "Completed"]
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/mirror/catalog.git # mirror of https://github.com/tektoncd/catalog.git
+            - name: revision
+              value: df36b3853a5657fd883015cdbf07ad6466918acf
+            - name: pathInRepo
+              value: task/gitea-set-status/0.1/gitea-set-status.yaml
+        params:
+          - name: CONTEXT
+            value: "$(params.JOB_NAME)"
+          - name: REPO_FULL_NAME
+            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
+          - name: GITEA_HOST_URL
+            value: code.fizz.buzz
+          - name: SHA
+            value: "$(tasks.fetch-repository.results.commit)"
+          - name: DESCRIPTION
+            value: "Build $(params.JOB_NAME) has succeeded"
+          - name: STATE
+            value: success
+          - name: TARGET_URL
+            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
+      - name: report-failure
+        when:
+          - input: "$(tasks.status)"
+            operator: in
+            values: ["Failed"]
+        taskRef:
+          resolver: git
+          params:
+            - name: url
+              value: https://code.fizz.buzz/mirror/catalog.git # mirror of https://github.com/tektoncd/catalog.git
+            - name: revision
+              value: df36b3853a5657fd883015cdbf07ad6466918acf
+            - name: pathInRepo
+              value: task/gitea-set-status/0.1/gitea-set-status.yaml
+        params:
+          - name: CONTEXT
+            value: "$(params.JOB_NAME)"
+          - name: REPO_FULL_NAME
+            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
+          - name: GITEA_HOST_URL
+            value: code.fizz.buzz
+          - name: SHA
+            value: "$(tasks.fetch-repository.results.commit)"
+          - name: DESCRIPTION
+            value: "Build $(params.JOB_NAME) has failed"
+          - name: STATE
+            value: failure
+          - name: TARGET_URL
+            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
+      - name: cargo-cache-autoclean
+        taskSpec:
+          metadata: {}
+          params:
+            - name: docker-image
+              type: string
+              description: Docker image to run.
+              default: alpine:3.20
+          stepTemplate:
+            image: alpine:3.20
+            computeResources:
+              requests:
+                cpu: 10m
+                memory: 600Mi
+            workingDir: /workspace/source
+          workspaces:
+            - name: source
+              mountPath: /source
+            - name: cargo-cache
+              mountPath: /usr/local/cargo/registry
+              optional: true
+          steps:
+            - name: run
+              image: $(params.docker-image)
+              workingDir: "$(workspaces.source.path)"
+              command: [cargo, cache, --autoclean]
+              args: []
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+        params:
+          - name: docker-image
+            value: "$(tasks.build-image.results.IMAGE_URL[1])"
+    workspaces:
+      - name: git-source
+      - name: docker-credentials
+      - name: cargo-cache
+  workspaces:
+    - name: git-source
+      volumeClaimTemplate:
+        spec:
+          storageClassName: "local-path"
+          accessModes:
+            - ReadWriteOnce
+          resources:
+            requests:
+              storage: 10Gi
+      subPath: rust-source
+    - name: cargo-cache
+      persistentVolumeClaim:
+        claimName: organic-cargo-cache-test
+    - name: docker-credentials
+      secret:
+        secretName: harbor-plain
+  params:
+    - name: image-name
+      value: "harbor.fizz.buzz/private/organic-test"
+    - name: target-name
+      value: "tester"
+    - name: path-to-image-context
+      value: docker/organic_test/
+    - name: path-to-dockerfile
+      value: docker/organic_test/

.webhook_bridge/webhook_bridge.toml

@@ -0,0 +1,31 @@
+version = "0.0.1"
+
+[[push]]
+  name = "rust-test"
+  source = "pipeline-rust-test.yaml"
+  clone_uri = "git@code.fizz.buzz:talexander/organic.git"
+  skip_branches = [ "^v[0-9]+\\.[0-9]+\\.[0-9]+$" ]
+
+[[push]]
+  name = "foreign-document-test"
+  source = "pipeline-foreign-document-test.yaml"
+  clone_uri = "git@code.fizz.buzz:talexander/organic.git"
+  branches = [ "^main$", "^master$" ]
+
+[[push]]
+  name = "clippy"
+  source = "pipeline-rust-clippy.yaml"
+  clone_uri = "git@code.fizz.buzz:talexander/organic.git"
+  skip_branches = [ "^v[0-9]+\\.[0-9]+\\.[0-9]+$" ]
+
+[[push]]
+  name = "format"
+  source = "pipeline-format.yaml"
+  clone_uri = "git@code.fizz.buzz:talexander/organic.git"
+  skip_branches = [ "^v[0-9]+\\.[0-9]+\\.[0-9]+$" ]
+
+[[push]]
+  name = "build"
+  source = "pipeline-build-hash.yaml"
+  clone_uri = "git@code.fizz.buzz:talexander/organic.git"
+  branches = [ "^main$", "^master$" ]

Cargo.toml

@@ -1,8 +1,9 @@
 # cargo-features = ["profile-rustflags"]
+cargo-features = ["codegen-backend"]
 
 [package]
 name = "organic"
-version = "0.1.12"
+version = "0.1.16"
 authors = ["Tom Alexander <tom@fizz.buzz>"]
 description = "An org-mode parser."
 edition = "2021"
@@ -39,17 +40,33 @@ path = "src/lib.rs"
   path = "src/bin_foreign_document_test.rs"
   required-features = ["foreign_document_test"]
 
+[[bin]]
+  name = "wasm"
+  path = "src/bin_wasm.rs"
+  required-features = ["wasm"]
+
+[[bin]]
+  # This bin exists for development purposes only. The real target of this crate is the library.
+  name = "wasm_test"
+  path = "src/bin_wasm_test.rs"
+  required-features = ["wasm_test"]
+
 [dependencies]
 futures = { version = "0.3.28", optional = true }
+gloo-utils = "0.2.0"
 nom = "7.1.1"
 opentelemetry = { version = "0.20.0", optional = true, default-features = false, features = ["trace", "rt-tokio"] }
 opentelemetry-otlp = { version = "0.13.0", optional = true }
 opentelemetry-semantic-conventions = { version = "0.12.0", optional = true }
+serde = { version = "1.0.193", optional = true, features = ["derive"] }
+serde-wasm-bindgen = { version = "0.6.3", optional = true }
+serde_json = { version = "1.0.108", optional = true }
 tokio = { version = "1.30.0", optional = true, default-features = false, features = ["rt", "rt-multi-thread"] }
 tracing = { version = "0.1.37", optional = true }
 tracing-opentelemetry = { version = "0.20.0", optional = true }
 tracing-subscriber = { version = "0.3.17", optional = true, features = ["env-filter"] }
 walkdir = { version = "2.3.3", optional = true }
+wasm-bindgen = { version = "0.2.89", optional = true }
 
 [build-dependencies]
 walkdir = "2.3.3"
@@ -60,6 +77,8 @@ compare = ["tokio/process", "tokio/macros"]
 foreign_document_test = ["compare", "dep:futures", "tokio/sync", "dep:walkdir", "tokio/process"]
 tracing = ["dep:opentelemetry", "dep:opentelemetry-otlp", "dep:opentelemetry-semantic-conventions", "dep:tokio", "dep:tracing", "dep:tracing-opentelemetry", "dep:tracing-subscriber"]
 event_count = []
+wasm = ["dep:serde", "dep:wasm-bindgen", "dep:serde-wasm-bindgen"]
+wasm_test = ["wasm", "dep:serde_json", "tokio/process", "tokio/macros"]
 
 # Optimized build for any sort of release.
 [profile.release-lto]
@@ -79,3 +98,15 @@ strip = "symbols"
 inherits = "release"
 lto = true
 debug = true
+
+[profile.wasm]
+inherits = "release"
+lto = true
+strip = true
+
+[profile.dev]
+codegen-backend = "cranelift"
+
+[profile.dev.package."*"]
+codegen-backend = "llvm"
+opt-level = 3

Makefile

@@ -7,6 +7,7 @@ MAKEFLAGS += --no-builtin-rules
 TESTJOBS := 4
 OS:=$(shell uname -s)
 RELEASEFLAGS :=
+WASMTARGET := bundler # or web
 
 ifeq ($(OS),Linux)
   TESTJOBS:=$(shell nproc)
@@ -21,51 +22,83 @@ ifeq ($(origin .RECIPEPREFIX), undefined)
 endif
 .RECIPEPREFIX = >
 
+.PHONY: help
+help: ## List the available make targets.
+> @grep -h "##" $(MAKEFILE_LIST) | grep -v grep | sed -E 's/^([^:]*): *## */\1:  /'
+
 .PHONY: build
-build:
+build: ## Make a debug build of the project.
 > cargo build
 
 .PHONY: release
-release:
+release: ## Make an optimized build of the project.
 > cargo build --release $(RELEASEFLAGS)
 
+.PHONY: wasm
+wasm: ## Build the parser as wasm.
+> cargo build --target=wasm32-unknown-unknown --profile wasm --bin wasm --features wasm
+> wasm-bindgen --target $(WASMTARGET) --out-dir target/wasm32-unknown-unknown/js target/wasm32-unknown-unknown/wasm/wasm.wasm
+
 .PHONY: clean
-clean:
+clean: ## Delete the built binaries.
 > cargo clean
+> $(MAKE) -C docker/organic_development TARGET=builder clean
+> $(MAKE) -C docker/organic_development TARGET=format clean
+> $(MAKE) -C docker/organic_development TARGET=clippy clean
+> $(MAKE) -C docker/organic_development TARGET=wasm clean
+> $(MAKE) -C docker/organic_test TARGET=tester build
 
 .PHONY: format
-format:
-> $(MAKE) -C docker/cargo_fmt run
+format: ## Format the code.
+> cargo fmt
 
-.PHONY: dockerclippy
-dockerclippy:
-> $(MAKE) -C docker/organic_clippy run
+.PHONY: docker_format
+docker_format: ## Format the code using docker.
+> $(MAKE) -C docker/organic_development TARGET=format build
+> docker run --rm -i -t --mount type=tmpfs,destination=/tmp -v "$(shell readlink -f .):/source" --workdir=/source --env CARGO_TARGET_DIR=/target -v "organic-cargo-registry:/usr/local/cargo/registry" organic-development-format cargo fmt
+
+.PHONY: docker_clippy
+docker_clippy: ## Lint the code using docker.
+> $(MAKE) -C docker/organic_development TARGET=clippy build
+> docker run --rm -i -t --mount type=tmpfs,destination=/tmp -v "$(shell readlink -f .):/source" --workdir=/source --env CARGO_TARGET_DIR=/target -v "organic-cargo-registry:/usr/local/cargo/registry" organic-development-clippy cargo clippy --no-deps --all-targets --all-features -- -D warnings
 
 .PHONY: clippy
-clippy:
+clippy: ## Lint the code.
 > cargo clippy --no-deps --all-targets --all-features -- -D warnings
 
 .PHONY: test
-test:
+test: ## Run the test suite.
 > cargo test --no-default-features --features compare --no-fail-fast --lib --test test_loader -- --test-threads $(TESTJOBS)
 
-.PHONY: dockertest
-dockertest:
-> $(MAKE) -C docker/organic_test
+.PHONY: doc
+doc: ## Generate documentation.
+> cargo doc --no-deps --open --lib --release --all-features
+
+.PHONY: docker_test
+docker_test: ## Run the test suite using docker.
+> $(MAKE) -C docker/organic_test TARGET=tester build
 > docker run --init --rm -i -t --read-only -v "$$(readlink -f ./):/source:ro" --mount type=tmpfs,destination=/tmp --mount source=cargo-cache,target=/usr/local/cargo/registry --mount source=rust-cache,target=/target --env CARGO_TARGET_DIR=/target -w /source organic-test --no-default-features --features compare --no-fail-fast --lib --test test_loader -- --test-threads $(TESTJOBS)
 
-.PHONY: buildtest
-buildtest:
+.PHONY: docker_wasm_test
+docker_wasm_test: ## Run the test suite with wasm tests.
+> $(MAKE) -C docker/organic_test TARGET=tester build
+> docker run --init --rm -i -t --read-only -v "$$(readlink -f ./):/source:ro" --mount type=tmpfs,destination=/tmp --mount source=cargo-cache,target=/usr/local/cargo/registry --mount source=rust-cache,target=/target --env CARGO_TARGET_DIR=/target -w /source organic-test --no-default-features --features compare,wasm_test --no-fail-fast --lib --test test_loader autogen_wasm_ -- --test-threads $(TESTJOBS)
+
+.PHONY: build_test
+build_test:
 > cargo build --no-default-features
 > cargo build --no-default-features --features compare
 > cargo build --no-default-features --features tracing
 > cargo build --no-default-features --features compare,tracing
 > cargo build --no-default-features --features compare,foreign_document_test
 > cargo build --no-default-features --features compare,tracing,foreign_document_test
+> cargo build --target wasm32-unknown-unknown --profile wasm --bin wasm --no-default-features --features wasm
+> cargo build --bin wasm_test --no-default-features --features wasm_test
 
 .PHONY: foreign_document_test
 foreign_document_test:
-> $(MAKE) -C docker/organic_test run_foreign_document_test
+> $(MAKE) -C docker/organic_test TARGET=foreign-document build
+> docker run --init --rm -i -t --read-only -v "$$(readlink -f ./):/source:ro" --mount type=tmpfs,destination=/tmp --mount source=cargo-cache,target=/usr/local/cargo/registry --mount source=rust-cache,target=/target --env CARGO_TARGET_DIR=/target -w /source organic-test-foreign-document
 
 .PHONY: dockerclean
 dockerclean:

README.md

@@ -10,17 +10,16 @@ Currently, Organic parses most documents the same as the official org-mode parse
 
 ### Project Goals
 - We aim to provide perfect parity with the emacs org-mode parser. In that regard, any document that parses differently between Emacs and Organic is considered a bug.
-- The parser should have minimal dependencies. This should reduce effort w.r.t.: security audits, legal compliance, portability.
-- The parser should be usable everywhere. In the interest of getting org-mode used in as many places as possible, this parser should be usable by everyone everywhere. This means:
+- The parser should have minimal dependencies.
+- The parser should be usable everywhere. In the interest of getting org used in as many places as possible, this parser should be usable by everyone everywhere. This means:
   - It must have a permissive license.
-  - We will investigate compiling to WASM. This is an important goal of the project and will definitely happen, but only after the parser has a more stable API.
+  - It compiles to both natively and to wasm.
   - We will investigate compiling to a C library for native linking to other code. This is more of a maybe-goal for the project.
 ### Project Non-Goals
 - This project will not include an elisp engine since that would drastically increase the complexity of the code. Any features requiring an elisp engine will not be implemented (for example, Emacs supports embedded eval expressions in documents but this parser will never support that).
 - This project is exclusively an org-mode **parser**. This limits its scope to roughly the output of `(org-element-parse-buffer)`. It will not render org-mode documents in other formats like HTML or LaTeX.
 ### Project Maybe-Goals
 - table.el support. Currently we support org-mode tables but org-mode also allows table.el tables. So far, their use in org-mode documents seems rather uncommon so this is a low-priority feature.
-- Document editing support. I do not anticipate any advanced editing features to make editing ergonomic, but it should be relatively easy to be able to parse an org-mode document and serialize it back into org-mode. This would enable cool features to be built on top of the library like auto-formatters. To accomplish this feature, We'd have to capture all of the various separators and whitespace that we are currently simply throwing away. This would add many additional fields to the parsed structs and it would add more noise to the parsers themselves, so I do not want to approach this feature until the parser is more complete since it would make modifications and refactoring more difficult.
 ### Supported Versions
 This project targets the version of Emacs and Org-mode that are built into the [organic-test docker image](docker/organic_test/Dockerfile). This is newer than the version of Org-mode that shipped with Emacs 29.1. The parser itself does not depend on Emacs or Org-mode though, so this only matters for development purposes when running the automated tests that compare against upstream Org-mode.
 

build.rs

@@ -26,7 +26,7 @@ fn main() {
                 dir_entry.file_type().is_file()
                     && Path::new(dir_entry.file_name())
                         .extension()
-                        .map(|ext| ext.to_ascii_lowercase() == "org")
+                        .map(|ext| ext.eq_ignore_ascii_case("org"))
                         .unwrap_or(false)
             }
             Err(_) => true,

docker/cargo_fmt/Dockerfile

@@ -1,6 +0,0 @@
-FROM rustlang/rust:nightly-alpine3.17
-
-RUN apk add --no-cache musl-dev
-RUN rustup component add rustfmt
-
-ENTRYPOINT ["cargo", "fmt"]

docker/cargo_fmt/Makefile

@@ -1,36 +0,0 @@
-IMAGE_NAME:=cargo-fmt
-# REMOTE_REPO:=harbor.fizz.buzz/private
-
-.PHONY: all
-all: build push
-
-.PHONY: build
-build:
-	docker build -t $(IMAGE_NAME) -f Dockerfile .
-
-.PHONY: push
-push:
-ifdef REMOTE_REPO
-	docker tag $(IMAGE_NAME) $(REMOTE_REPO)/$(IMAGE_NAME)
-	docker push $(REMOTE_REPO)/$(IMAGE_NAME)
-else
-	@echo "REMOTE_REPO not defined, not pushing to a remote repo."
-endif
-
-.PHONY: clean
-clean:
-	docker rmi $(IMAGE_NAME)
-ifdef REMOTE_REPO
-	docker rmi $(REMOTE_REPO)/$(IMAGE_NAME)
-else
-	@echo "REMOTE_REPO not defined, not removing from remote repo."
-endif
-
-# NOTE: This target will write to folders underneath the git-root
-.PHONY: run
-run: build
-	docker run --rm --init --read-only --mount type=tmpfs,destination=/tmp -v "$$(readlink -f ../../):/source" --workdir=/source $(IMAGE_NAME)
-
-.PHONY: shell
-shell: build
-	docker run --rm -i -t --entrypoint /bin/sh --mount type=tmpfs,destination=/tmp -v "$$(readlink -f ../../):/source" --workdir=/source $(IMAGE_NAME)

docker/organic_build/Dockerfile

@@ -1,6 +0,0 @@
-FROM rustlang/rust:nightly-alpine3.17
-
-RUN apk add --no-cache musl-dev
-RUN cargo install --locked --no-default-features --features ci-autoclean cargo-cache
-
-ENTRYPOINT ["cargo", "build"]

docker/organic_build/Makefile

@@ -1,37 +0,0 @@
-IMAGE_NAME:=organic-build
-# REMOTE_REPO:=harbor.fizz.buzz/private
-
-.PHONY: all
-all: build push
-
-.PHONY: build
-build:
-	docker build -t $(IMAGE_NAME) -f Dockerfile .
-
-.PHONY: push
-push:
-ifdef REMOTE_REPO
-	docker tag $(IMAGE_NAME) $(REMOTE_REPO)/$(IMAGE_NAME)
-	docker push $(REMOTE_REPO)/$(IMAGE_NAME)
-else
-	@echo "REMOTE_REPO not defined, not pushing to a remote repo."
-endif
-
-.PHONY: clean
-clean:
-	docker rmi $(IMAGE_NAME)
-ifdef REMOTE_REPO
-	docker rmi $(REMOTE_REPO)/$(IMAGE_NAME)
-else
-	@echo "REMOTE_REPO not defined, not removing from remote repo."
-endif
-	docker volume rm cargo-cache
-
-# NOTE: This target will write to folders underneath the git-root
-.PHONY: run
-run: build
-	docker run --rm --init --read-only --mount type=tmpfs,destination=/tmp -v "$$(readlink -f ../../):/source" --workdir=/source --mount source=cargo-cache,target=/usr/local/cargo/registry $(IMAGE_NAME)
-
-.PHONY: shell
-shell: build
-	docker run --rm -i -t --entrypoint /bin/sh --mount type=tmpfs,destination=/tmp -v "$$(readlink -f ../../):/source" --workdir=/source --mount source=cargo-cache,target=/usr/local/cargo/registry $(IMAGE_NAME)

docker/organic_clippy/Dockerfile

@@ -1,5 +0,0 @@
-FROM rustlang/rust:nightly-alpine3.17
-
-RUN apk add --no-cache musl-dev
-
-ENTRYPOINT ["cargo", "clippy", "--no-deps", "--all-targets", "--all-features", "--", "-D", "warnings"]

docker/organic_clippy/Makefile

@@ -1,37 +0,0 @@
-IMAGE_NAME:=organic-clippy
-# REMOTE_REPO:=harbor.fizz.buzz/private
-
-.PHONY: all
-all: build push
-
-.PHONY: build
-build:
-	docker build -t $(IMAGE_NAME) -f Dockerfile .
-
-.PHONY: push
-push:
-ifdef REMOTE_REPO
-	docker tag $(IMAGE_NAME) $(REMOTE_REPO)/$(IMAGE_NAME)
-	docker push $(REMOTE_REPO)/$(IMAGE_NAME)
-else
-	@echo "REMOTE_REPO not defined, not pushing to a remote repo."
-endif
-
-.PHONY: clean
-clean:
-	docker rmi $(IMAGE_NAME)
-ifdef REMOTE_REPO
-	docker rmi $(REMOTE_REPO)/$(IMAGE_NAME)
-else
-	@echo "REMOTE_REPO not defined, not removing from remote repo."
-endif
-	docker volume rm rust-cache cargo-cache
-
-# NOTE: This target will write to folders underneath the git-root
-.PHONY: run
-run: build
-	docker run --rm --init --read-only --mount type=tmpfs,destination=/tmp -v "$$(readlink -f ../../):/source:ro" --workdir=/source --mount source=cargo-cache,target=/usr/local/cargo/registry --mount source=rust-cache,target=/target --env CARGO_TARGET_DIR=/target $(IMAGE_NAME)
-
-.PHONY: shell
-shell: build
-	docker run --rm -i -t --entrypoint /bin/sh --mount type=tmpfs,destination=/tmp -v "$$(readlink -f ../../):/source:ro" --workdir=/source --mount source=cargo-cache,target=/usr/local/cargo/registry --mount source=rust-cache,target=/target --env CARGO_TARGET_DIR=/target $(IMAGE_NAME)

docker/organic_development/Dockerfile

@@ -0,0 +1,20 @@
+# syntax=docker/dockerfile:1
+ARG ALPINE_VERSION="3.20"
+
+FROM rustlang/rust:nightly-alpine$ALPINE_VERSION AS builder
+
+RUN apk add --no-cache musl-dev
+RUN --mount=type=tmpfs,target=/tmp --mount=type=cache,target=/usr/local/cargo/registry,sharing=locked cargo install --locked --no-default-features --features ci-autoclean cargo-cache
+RUN rustup component add rustc-codegen-cranelift
+
+FROM builder AS format
+
+RUN rustup component add rustfmt
+
+FROM builder AS clippy
+
+RUN rustup component add clippy
+
+FROM builder AS wasm
+
+RUN rustup target add wasm32-unknown-unknown

docker/organic_development/Makefile

@@ -0,0 +1,36 @@
+SHELL := bash
+.ONESHELL:
+.SHELLFLAGS := -eu -o pipefail -c
+.DELETE_ON_ERROR:
+MAKEFLAGS += --warn-undefined-variables
+MAKEFLAGS += --no-builtin-rules
+
+ifeq ($(origin .RECIPEPREFIX), undefined)
+  $(error This Make does not support .RECIPEPREFIX. Please use GNU Make 4.0 or later)
+endif
+.RECIPEPREFIX = >
+
+TARGET := builder
+IMAGE_NAME := organic-development
+ifneq ($(TARGET),builder)
+  IMAGE_NAME := $(IMAGE_NAME)-$(TARGET)
+endif
+
+.PHONY: help
+help:
+> @grep -h "##" $(MAKEFILE_LIST) | grep -v grep | sed -E 's/^([^:]*): *## */\1:  /'
+
+.PHONY: build
+build: ## Build the docker image.
+> docker build --tag $(IMAGE_NAME) --target=$(TARGET) --file Dockerfile .
+> docker volume create organic-cargo-registry
+
+.PHONY: shell
+shell: ## Launch an interactive shell inside the docker image with the source repository mounted at /source.
+shell: build
+> docker run --rm -i -t --entrypoint /bin/sh --mount type=tmpfs,destination=/tmp -v "$$(readlink -f ../../):/source" --workdir=/source --env CARGO_TARGET_DIR=/target -v "organic-cargo-registry:/usr/local/cargo/registry" $(IMAGE_NAME)
+
+.PHONY: clean
+clean: ## Remove the docker image and volume.
+> docker rmi $(IMAGE_NAME)
+> docker volume rm organic-cargo-registry

docker/organic_test/Dockerfile

@@ -1,10 +1,25 @@
-FROM alpine:3.17 AS build
+# syntax=docker/dockerfile:1
+ARG ALPINE_VERSION="3.20"
+
+# ARG EMACS_REPO=https://git.savannah.gnu.org/git/emacs.git
+ARG EMACS_REPO=https://code.fizz.buzz/mirror/emacs.git
+
+ARG EMACS_VERSION=emacs-29.1
+
+# ARG ORG_MODE_REPO=https://git.savannah.gnu.org/git/emacs/org-mode.git
+ARG ORG_MODE_REPO=https://code.fizz.buzz/mirror/org-mode.git
+
+ARG ORG_VERSION=abf5156096c06ee5aa05795c3dc5a065f76ada97
+
+
+FROM alpine:$ALPINE_VERSION AS build
 RUN apk add --no-cache build-base musl-dev git autoconf make texinfo gnutls-dev ncurses-dev gawk libgccjit-dev
 
 
 FROM build AS build-emacs
-ARG EMACS_VERSION=emacs-29.1
-RUN git clone --depth 1 --branch $EMACS_VERSION https://git.savannah.gnu.org/git/emacs.git /root/emacs
+ARG EMACS_VERSION
+ARG EMACS_REPO
+RUN git clone --depth 1 --branch $EMACS_VERSION $EMACS_REPO /root/emacs
 WORKDIR /root/emacs
 RUN mkdir /root/dist
 RUN ./autogen.sh
@@ -14,23 +29,25 @@ RUN make DESTDIR="/root/dist" install
 
 
 FROM build AS build-org-mode
-ARG ORG_VERSION=abf5156096c06ee5aa05795c3dc5a065f76ada97
-COPY --from=build-emacs /root/dist/ /
+ARG ORG_VERSION
+ARG ORG_MODE_REPO
+COPY --link --from=build-emacs /root/dist/ /
 RUN mkdir /root/dist
 # Savannah does not allow fetching specific revisions, so we're going to have to put unnecessary load on their server by cloning main and then checking out the revision we want.
-RUN git clone https://git.savannah.gnu.org/git/emacs/org-mode.git /root/org-mode && git -C /root/org-mode checkout $ORG_VERSION
-# RUN mkdir /root/org-mode && git -C /root/org-mode init --initial-branch=main && git -C /root/org-mode remote add origin https://git.savannah.gnu.org/git/emacs/org-mode.git && git -C /root/org-mode fetch origin $ORG_VERSION && git -C /root/org-mode checkout FETCH_HEAD
+RUN git clone $ORG_MODE_REPO /root/org-mode && git -C /root/org-mode checkout $ORG_VERSION
+# RUN mkdir /root/org-mode && git -C /root/org-mode init --initial-branch=main && git -C /root/org-mode remote add origin $ORG_REPO && git -C /root/org-mode fetch origin $ORG_VERSION && git -C /root/org-mode checkout FETCH_HEAD
 WORKDIR /root/org-mode
 RUN make compile
 RUN make DESTDIR="/root/dist" install
 
 
-FROM rustlang/rust:nightly-alpine3.17 AS tester
+FROM rustlang/rust:nightly-alpine$ALPINE_VERSION AS tester
 ENV LANG=en_US.UTF-8
 RUN apk add --no-cache musl-dev ncurses gnutls libgccjit
-RUN cargo install --locked --no-default-features --features ci-autoclean cargo-cache
-COPY --from=build-emacs /root/dist/ /
-COPY --from=build-org-mode /root/dist/ /
+RUN --mount=type=tmpfs,target=/tmp --mount=type=cache,target=/usr/local/cargo/registry,sharing=locked cargo install --locked --no-default-features --features ci-autoclean cargo-cache
+RUN rustup component add rustc-codegen-cranelift
+COPY --link --from=build-emacs /root/dist/ /
+COPY --link --from=build-org-mode /root/dist/ /
 
 ENTRYPOINT ["cargo", "test"]
 
@@ -100,13 +117,13 @@ RUN mkdir -p $LITERATE_BUILD_EMACS_PATH && git -C $LITERATE_BUILD_EMACS_PATH ini
 # unused/aws.org contains invalid paths for setupfile which causes both upstream org-mode and Organic to error out.
 RUN rm $LITERATE_BUILD_EMACS_PATH/unused/aws.org
 
-FROM tester as foreign-document-test
+FROM tester as foreign-document
 RUN apk add --no-cache bash coreutils
 RUN mkdir /foreign_documents
-COPY --from=foreign-document-gather /foreign_documents/howardabrams /foreign_documents/howardabrams
-COPY --from=foreign-document-gather /foreign_documents/doomemacs /foreign_documents/doomemacs
-COPY --from=foreign-document-gather /foreign_documents/worg /foreign_documents/worg
-COPY --from=foreign-document-gather /foreign_documents/literate_build_emacs /foreign_documents/literate_build_emacs
-COPY --from=build-org-mode /root/org-mode /foreign_documents/org-mode
-COPY --from=build-emacs /root/emacs /foreign_documents/emacs
+COPY --link --from=foreign-document-gather /foreign_documents/howardabrams /foreign_documents/howardabrams
+COPY --link --from=foreign-document-gather /foreign_documents/doomemacs /foreign_documents/doomemacs
+COPY --link --from=foreign-document-gather /foreign_documents/worg /foreign_documents/worg
+COPY --link --from=foreign-document-gather /foreign_documents/literate_build_emacs /foreign_documents/literate_build_emacs
+COPY --link --from=build-org-mode /root/org-mode /foreign_documents/org-mode
+COPY --link --from=build-emacs /root/emacs /foreign_documents/emacs
 ENTRYPOINT ["cargo", "run", "--bin", "foreign_document_test", "--features", "compare,foreign_document_test", "--profile", "release-lto"]

docker/organic_test/Makefile

@@ -1,44 +1,36 @@
-IMAGE_NAME:=organic-test
-# REMOTE_REPO:=harbor.fizz.buzz/private
+SHELL := bash
+.ONESHELL:
+.SHELLFLAGS := -eu -o pipefail -c
+.DELETE_ON_ERROR:
+MAKEFLAGS += --warn-undefined-variables
+MAKEFLAGS += --no-builtin-rules
 
-.PHONY: all
-all: build push
+ifeq ($(origin .RECIPEPREFIX), undefined)
+  $(error This Make does not support .RECIPEPREFIX. Please use GNU Make 4.0 or later)
+endif
+.RECIPEPREFIX = >
+
+TARGET := tester
+IMAGE_NAME := organic-test
+ifneq ($(TARGET),tester)
+  IMAGE_NAME := $(IMAGE_NAME)-$(TARGET)
+endif
+
+.PHONY: help
+help:
+> @grep -h "##" $(MAKEFILE_LIST) | grep -v grep | sed -E 's/^([^:]*): *## */\1:  /'
 
 .PHONY: build
-build:
-	docker build -t $(IMAGE_NAME) -f Dockerfile --target tester .
-
-.PHONY: build_foreign_document_test
-build_foreign_document_test:
-	docker build -t $(IMAGE_NAME)-foreign-document -f Dockerfile --target foreign-document-test .
-
-.PHONY: push
-push:
-ifdef REMOTE_REPO
-	docker tag $(IMAGE_NAME) $(REMOTE_REPO)/$(IMAGE_NAME)
-	docker push $(REMOTE_REPO)/$(IMAGE_NAME)
-else
-	@echo "REMOTE_REPO not defined, not pushing to a remote repo."
-endif
-
-.PHONY: clean
-clean:
-	docker rmi $(IMAGE_NAME)
-ifdef REMOTE_REPO
-	docker rmi $(REMOTE_REPO)/$(IMAGE_NAME)
-else
-	@echo "REMOTE_REPO not defined, not removing from remote repo."
-endif
-	docker volume rm rust-cache cargo-cache
-
-.PHONY: run
-run: build
-	docker run --rm --init --read-only --mount type=tmpfs,destination=/tmp -v "$$(readlink -f ../../):/source:ro" --workdir=/source --mount source=cargo-cache,target=/usr/local/cargo/registry --mount source=rust-cache,target=/target --env CARGO_TARGET_DIR=/target $(IMAGE_NAME) --no-default-features --features compare --no-fail-fast --lib --test test_loader
+build: ## Build the docker image.
+> docker build --tag $(IMAGE_NAME) --target=$(TARGET) --file Dockerfile .
+> docker volume create organic-cargo-registry
 
 .PHONY: shell
+shell: ## Launch an interactive shell inside the docker image with the source repository mounted at /source.
 shell: build
-	docker run --rm -i -t --entrypoint /bin/sh --mount type=tmpfs,destination=/tmp -v "$$(readlink -f ../../):/source:ro" --workdir=/source --mount source=cargo-cache,target=/usr/local/cargo/registry --mount source=rust-cache,target=/target --env CARGO_TARGET_DIR=/target $(IMAGE_NAME)
+> docker run --rm -i -t --entrypoint /bin/sh --mount type=tmpfs,destination=/tmp -v "$$(readlink -f ../../):/source" --workdir=/source --env CARGO_TARGET_DIR=/target -v "organic-cargo-registry:/usr/local/cargo/registry" $(IMAGE_NAME)
 
-.PHONY: run_foreign_document_test
-run_foreign_document_test: build_foreign_document_test
-	docker run --rm --init --read-only --mount type=tmpfs,destination=/tmp -v "$$(readlink -f ../../):/source:ro" --workdir=/source --mount source=cargo-cache,target=/usr/local/cargo/registry --mount source=rust-cache,target=/target --env CARGO_TARGET_DIR=/target $(IMAGE_NAME)-foreign-document
+.PHONY: clean
+clean: ## Remove the docker image and volume.
+> docker rmi $(IMAGE_NAME)
+> docker volume rm organic-cargo-registry

org_mode_samples/document/only_line_breaks.org

@@ -0,0 +1,4 @@
+
+
+
+

org_mode_samples/document/post_blank.org

@@ -0,0 +1,5 @@
+* foo
+
+
+
+

org_mode_samples/greater_element/property_drawer/empty.org

@@ -1,3 +1,32 @@
+* Empty
+:PROPERTIES:
+:END:
+* Single new line
 :PROPERTIES:
 
+:END:
+* Single line with spaces
+:PROPERTIES:
+      
+:END:
+* Many lines, first line without spaces
+:PROPERTIES:
+
+
+
+
+:END:
+* Many lines, first line with spaces
+:PROPERTIES:
+      
+
+
+
+:END:
+* Many lines, first line with spaces, later line with spaces
+:PROPERTIES:
+      
+
+    
+
 :END:

org_mode_samples/lesser_element/babel_call/simple.org

@@ -5,3 +5,5 @@
 #+call: dolar cat(dog)
 
 #+call: (bat)
+
+#+call:

org_mode_samples/lesser_element/fixed_width_area/blank_line_in_middle.org

@@ -0,0 +1,3 @@
+: foo
+:
+: bar

org_mode_samples/lesser_element/fixed_width_area/list_post_blank.org

@@ -0,0 +1,6 @@
+1. foo
+   #+begin_src text
+
+   #+end_src
+
+2. baz

org_mode_samples/object/regular_link/jump_to_line_number.org

@@ -0,0 +1 @@
+[[file:simple.org::2]]

org_mode_samples/object/regular_link/tramp_link.org

@@ -0,0 +1 @@
+[[/ssh:admin@test.example:important/file.pdf]]

org_mode_samples/object/target/simple.org

@@ -0,0 +1,3 @@
+<<FOO>> bar
+
+[[FOO][baz]]

org_mode_samples/sections_and_headings/heading_with_subheading_post_blank.org

@@ -0,0 +1,5 @@
+* foo
+
+** bar
+
+* baz

scripts/build_all_feature_flag_combinations.bash

@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+#
+# Time running a single parse without invoking a compare with emacs.
+set -euo pipefail
+IFS=$'\n\t'
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+: ${PROFILE:="debug"}
+
+############## Setup #########################
+
+function cleanup {
+    for f in "${folders[@]}"; do
+        log "Deleting $f"
+        rm -rf "$f"
+    done
+}
+folders=()
+for sig in EXIT INT QUIT HUP TERM; do
+  trap "set +e; cleanup" "$sig"
+done
+
+function die {
+    local status_code="$1"
+    shift
+    (>&2 echo "${@}")
+    exit "$status_code"
+}
+
+function log {
+    (>&2 echo "${@}")
+}
+
+############## Program #########################
+
+function main {
+    if [ "$#" -gt 0 ]; then
+        export CARGO_TARGET_DIR="$1"
+    else
+        local work_directory=$(mktemp -d -t 'organic.XXXXXX')
+        folders+=("$work_directory")
+        export CARGO_TARGET_DIR="$work_directory"
+    fi
+    local features=(compare foreign_document_test tracing event_count wasm wasm_test)
+    ENABLED_FEATURES= for_each_combination "${features[@]}"
+}
+
+function for_each_combination {
+    local additional_flags=()
+    if [ "$PROFILE" = "dev" ] || [ "$PROFILE" = "debug" ]; then
+        PROFILE="debug"
+    else
+        additional_flags+=(--profile "$PROFILE")
+    fi
+
+
+    local flag=$1
+    shift
+
+    if [ "$#" -gt 0 ]; then
+        ENABLED_FEATURES="$ENABLED_FEATURES" for_each_combination "${@}"
+    elif [ -z "$ENABLED_FEATURES" ]; then
+        (cd "$DIR/../" && printf "\n\n\n========== no features ==========\n\n\n" && set -x && cargo build "${additional_flags[@]}" --no-default-features)
+    else
+        (cd "$DIR/../" && printf "\n\n\n========== %s ==========\n\n\n" "${ENABLED_FEATURES:1}" && set -x && cargo build "${additional_flags[@]}" --no-default-features --features "${ENABLED_FEATURES:1}")
+    fi
+
+    ENABLED_FEATURES="$ENABLED_FEATURES,$flag"
+    if [ "$#" -gt 0 ]; then
+        ENABLED_FEATURES="$ENABLED_FEATURES" for_each_combination "${@}"
+    else
+        (cd "$DIR/../" && printf "\n\n\n========== %s ==========\n\n\n" "${ENABLED_FEATURES:1}" && set -x && cargo build "${additional_flags[@]}" --no-default-features --features "${ENABLED_FEATURES:1}")
+    fi
+}
+
+main "${@}"

scripts/run_docker_wasm_compare.bash

@@ -0,0 +1,111 @@
+#!/usr/bin/env bash
+#
+set -euo pipefail
+IFS=$'\n\t'
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+: ${SHELL:="NO"} # or YES to launch a shell instead of running the test
+: ${TRACE:="NO"} # or YES to send traces to jaeger
+: ${BACKTRACE:="NO"} # or YES to print a rust backtrace when panicking
+: ${NO_COLOR:=""} # Set to anything to disable color output
+: ${PROFILE:="debug"}
+
+REALPATH=$(command -v uu-realpath || command -v realpath)
+MAKE=$(command -v gmake || command -v make)
+
+############## Setup #########################
+
+function die {
+    local status_code="$1"
+    shift
+    (>&2 echo "${@}")
+    exit "$status_code"
+}
+
+function log {
+    (>&2 echo "${@}")
+}
+
+############## Program #########################
+
+function main {
+    build_container
+    launch_container "${@}"
+}
+
+function build_container {
+    $MAKE -C "$DIR/../docker/organic_test"
+}
+
+function launch_container {
+    local additional_flags=()
+    local features=(wasm_test)
+
+    if [ "$NO_COLOR" != "" ]; then
+        additional_flags+=(--env "NO_COLOR=$NO_COLOR")
+    fi
+
+    if [ "$TRACE" = "YES" ]; then
+        # We use the host network so it can talk to jaeger hosted at 127.0.0.1
+        additional_flags+=(--network=host --env RUST_LOG=debug)
+        features+=(tracing)
+    fi
+
+    if [ "$SHELL" != "YES" ]; then
+        additional_flags+=(--read-only)
+    else
+        additional_flags+=(-t)
+    fi
+
+    if [ "$BACKTRACE" = "YES" ]; then
+        additional_flags+=(--env RUST_BACKTRACE=full)
+    fi
+
+    if [ "$SHELL" = "YES" ]; then
+        exec docker run "${additional_flags[@]}" --init --rm -i --mount type=tmpfs,destination=/tmp -v "/:/input:ro" -v "$($REALPATH "$DIR/../"):/source:ro" --mount source=cargo-cache,target=/usr/local/cargo/registry --mount source=rust-cache,target=/target --env CARGO_TARGET_DIR=/target -w /source --entrypoint "" organic-test /bin/sh
+    fi
+
+    local features_joined
+    features_joined=$(IFS=","; echo "${features[*]}")
+
+    local build_flags=()
+    if [ "$PROFILE" = "dev" ] || [ "$PROFILE" = "debug" ]; then
+        PROFILE="debug"
+    else
+        build_flags+=(--profile "$PROFILE")
+    fi
+
+
+    if [ $# -gt 0 ]; then
+        # If we passed in args, we need to forward them along
+        for path in "${@}"; do
+            local full_path
+            full_path=$($REALPATH "$path")
+            init_script=$(cat <<EOF
+set -euo pipefail
+IFS=\$'\n\t'
+
+cargo build --bin wasm_test --no-default-features --features "$features_joined" ${build_flags[@]}
+exec /target/${PROFILE}/wasm_test "/input${full_path}"
+EOF
+                       )
+            docker run "${additional_flags[@]}" --init --rm -i --mount type=tmpfs,destination=/tmp -v "/:/input:ro"  -v "$($REALPATH "$DIR/../"):/source:ro" --mount source=cargo-cache,target=/usr/local/cargo/registry --mount source=rust-cache,target=/target --env CARGO_TARGET_DIR=/target -w /source --entrypoint "" organic-test sh -c "$init_script"
+        done
+    else
+        local current_directory init_script
+        current_directory=$(pwd)
+        init_script=$(cat <<EOF
+set -euo pipefail
+IFS=\$'\n\t'
+
+cargo build --bin wasm_test --no-default-features --features "$features_joined" ${build_flags[@]}
+cd /input${current_directory}
+exec /target/${PROFILE}/wasm_test
+EOF
+                       )
+
+        docker run "${additional_flags[@]}" --init --rm -i --mount type=tmpfs,destination=/tmp -v "/:/input:ro" -v "$($REALPATH "$DIR/../"):/source:ro" --mount source=cargo-cache,target=/usr/local/cargo/registry --mount source=rust-cache,target=/target --env CARGO_TARGET_DIR=/target -w /source --entrypoint "" organic-test sh -c "$init_script"
+    fi
+}
+
+main "${@}"

src/bin_compare.rs

@@ -1,3 +1,4 @@
+#![feature(exit_status_error)]
 #![feature(round_char_boundary)]
 #![feature(exact_size_is_empty)]
 use std::io::Read;

src/bin_wasm.rs

@@ -0,0 +1,10 @@
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen]
+pub fn parse_org(org_contents: &str) -> wasm_bindgen::JsValue {
+    organic::wasm_cli::parse_org(org_contents)
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    Ok(())
+}

src/bin_wasm_test.rs

@@ -0,0 +1,62 @@
+#![feature(exact_size_is_empty)]
+#![feature(exit_status_error)]
+use std::io::Read;
+
+use organic::wasm_test::wasm_run_anonymous_compare;
+use organic::wasm_test::wasm_run_compare_on_file;
+
+#[cfg(feature = "tracing")]
+use crate::init_tracing::init_telemetry;
+#[cfg(feature = "tracing")]
+use crate::init_tracing::shutdown_telemetry;
+#[cfg(feature = "tracing")]
+mod init_tracing;
+
+#[cfg(not(feature = "tracing"))]
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let rt = tokio::runtime::Runtime::new()?;
+    rt.block_on(async {
+        let main_body_result = main_body().await;
+        main_body_result
+    })
+}
+
+#[cfg(feature = "tracing")]
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let rt = tokio::runtime::Runtime::new()?;
+    rt.block_on(async {
+        init_telemetry()?;
+        let main_body_result = main_body().await;
+        shutdown_telemetry()?;
+        main_body_result
+    })
+}
+
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
+async fn main_body() -> Result<(), Box<dyn std::error::Error>> {
+    let args = std::env::args().skip(1);
+    if args.is_empty() {
+        let org_contents = read_stdin_to_string()?;
+        if wasm_run_anonymous_compare(org_contents).await? {
+        } else {
+            Err("Diff results do not match.")?;
+        }
+        Ok(())
+    } else {
+        for arg in args {
+            if wasm_run_compare_on_file(arg).await? {
+            } else {
+                Err("Diff results do not match.")?;
+            }
+        }
+        Ok(())
+    }
+}
+
+fn read_stdin_to_string() -> Result<String, Box<dyn std::error::Error>> {
+    let mut stdin_contents = String::new();
+    std::io::stdin()
+        .lock()
+        .read_to_string(&mut stdin_contents)?;
+    Ok(stdin_contents)
+}

src/compare/compare.rs

@@ -1,16 +1,16 @@
 use std::path::Path;
 
 use crate::compare::diff::compare_document;
-use crate::compare::diff::DiffResult;
-use crate::compare::parse::emacs_parse_anonymous_org_document;
-use crate::compare::parse::emacs_parse_file_org_document;
-use crate::compare::parse::get_emacs_version;
-use crate::compare::parse::get_org_mode_version;
-use crate::compare::sexp::sexp;
 use crate::context::GlobalSettings;
 use crate::context::LocalFileAccessInterface;
 use crate::parser::parse_file_with_settings;
 use crate::parser::parse_with_settings;
+use crate::util::cli::emacs_parse_anonymous_org_document;
+use crate::util::cli::emacs_parse_file_org_document;
+use crate::util::cli::print_versions;
+use crate::util::elisp::sexp;
+use crate::util::terminal::foreground_color;
+use crate::util::terminal::reset_color;
 
 pub async fn run_anonymous_compare<P: AsRef<str>>(
     org_contents: P,
@@ -68,8 +68,8 @@ pub async fn run_anonymous_compare_with_settings<'g, 's, P: AsRef<str>>(
     } else if !silent {
         println!(
             "{color}Entire document passes.{reset}",
-            color = DiffResult::foreground_color(0, 255, 0),
-            reset = DiffResult::reset_color(),
+            color = foreground_color(0, 255, 0),
+            reset = reset_color(),
         );
     }
 
@@ -121,19 +121,10 @@ pub async fn run_compare_on_file_with_settings<'g, 's, P: AsRef<Path>>(
     } else if !silent {
         println!(
             "{color}Entire document passes.{reset}",
-            color = DiffResult::foreground_color(0, 255, 0),
-            reset = DiffResult::reset_color(),
+            color = foreground_color(0, 255, 0),
+            reset = reset_color(),
         );
     }
 
     Ok(true)
 }
-
-async fn print_versions() -> Result<(), Box<dyn std::error::Error>> {
-    eprintln!("Using emacs version: {}", get_emacs_version().await?.trim());
-    eprintln!(
-        "Using org-mode version: {}",
-        get_org_mode_version().await?.trim()
-    );
-    Ok(())
-}

src/compare/compare_field.rs

@@ -9,8 +9,6 @@ use super::diff::artificial_owned_diff_scope;
 use super::diff::compare_ast_node;
 use super::diff::DiffEntry;
 use super::diff::DiffStatus;
-use super::sexp::unquote;
-use super::sexp::Token;
 use super::util::get_property;
 use super::util::get_property_numeric;
 use super::util::get_property_quoted_string;
@@ -20,6 +18,8 @@ use crate::types::CharOffsetInLine;
 use crate::types::LineNumber;
 use crate::types::RetainLabels;
 use crate::types::SwitchNumberLines;
+use crate::util::elisp::unquote;
+use crate::util::elisp::Token;
 
 #[derive(Debug)]
 pub(crate) enum EmacsField<'s> {

src/compare/diff.rs

@@ -16,10 +16,6 @@ use super::compare_field::compare_property_retain_labels;
 use super::compare_field::compare_property_set_of_quoted_string;
 use super::compare_field::compare_property_single_ast_node;
 use super::compare_field::compare_property_unquoted_atom;
-use super::elisp_fact::ElispFact;
-use super::elisp_fact::GetElispFact;
-use super::sexp::unquote;
-use super::sexp::Token;
 use super::util::affiliated_keywords_names;
 use super::util::assert_no_children;
 use super::util::compare_additional_properties;
@@ -57,7 +53,6 @@ use crate::types::FixedWidthArea;
 use crate::types::FootnoteDefinition;
 use crate::types::FootnoteReference;
 use crate::types::FootnoteReferenceType;
-use crate::types::GetStandardProperties;
 use crate::types::Heading;
 use crate::types::HorizontalRule;
 use crate::types::Hour;
@@ -110,6 +105,12 @@ use crate::types::Verbatim;
 use crate::types::VerseBlock;
 use crate::types::WarningDelayType;
 use crate::types::Year;
+use crate::util::elisp::unquote;
+use crate::util::elisp::Token;
+use crate::util::elisp_fact::ElispFact;
+use crate::util::elisp_fact::GetElispFact;
+use crate::util::terminal::foreground_color;
+use crate::util::terminal::reset_color;
 
 #[derive(Debug)]
 pub enum DiffEntry<'b, 's> {
@@ -201,21 +202,21 @@ impl<'b, 's> DiffResult<'b, 's> {
                     if self.has_bad_children() {
                         format!(
                             "{color}BADCHILD{reset}",
-                            color = DiffResult::foreground_color(255, 255, 0),
-                            reset = DiffResult::reset_color(),
+                            color = foreground_color(255, 255, 0),
+                            reset = reset_color(),
                         )
                     } else {
                         format!(
                             "{color}GOOD{reset}",
-                            color = DiffResult::foreground_color(0, 255, 0),
-                            reset = DiffResult::reset_color(),
+                            color = foreground_color(0, 255, 0),
+                            reset = reset_color(),
                         )
                     }
                 }
                 DiffStatus::Bad => format!(
                     "{color}BAD{reset}",
-                    color = DiffResult::foreground_color(255, 0, 0),
-                    reset = DiffResult::reset_color(),
+                    color = foreground_color(255, 0, 0),
+                    reset = reset_color(),
                 ),
             }
         };
@@ -240,45 +241,6 @@ impl<'b, 's> DiffResult<'b, 's> {
             .iter()
             .any(|child| child.is_immediately_bad() || child.has_bad_children())
     }
-
-    pub(crate) fn foreground_color(red: u8, green: u8, blue: u8) -> String {
-        if DiffResult::should_use_color() {
-            format!(
-                "\x1b[38;2;{red};{green};{blue}m",
-                red = red,
-                green = green,
-                blue = blue
-            )
-        } else {
-            String::new()
-        }
-    }
-
-    #[allow(dead_code)]
-    pub(crate) fn background_color(red: u8, green: u8, blue: u8) -> String {
-        if DiffResult::should_use_color() {
-            format!(
-                "\x1b[48;2;{red};{green};{blue}m",
-                red = red,
-                green = green,
-                blue = blue
-            )
-        } else {
-            String::new()
-        }
-    }
-
-    pub(crate) fn reset_color() -> &'static str {
-        if DiffResult::should_use_color() {
-            "\x1b[0m"
-        } else {
-            ""
-        }
-    }
-
-    fn should_use_color() -> bool {
-        !std::env::var("NO_COLOR").is_ok_and(|val| !val.is_empty())
-    }
 }
 
 impl<'b, 's> DiffLayer<'b, 's> {
@@ -296,14 +258,14 @@ impl<'b, 's> DiffLayer<'b, 's> {
         let status_text = if self.has_bad_children() {
             format!(
                 "{color}BADCHILD{reset}",
-                color = DiffResult::foreground_color(255, 255, 0),
-                reset = DiffResult::reset_color(),
+                color = foreground_color(255, 255, 0),
+                reset = reset_color(),
             )
         } else {
             format!(
                 "{color}GOOD{reset}",
-                color = DiffResult::foreground_color(0, 255, 0),
-                reset = DiffResult::reset_color(),
+                color = foreground_color(0, 255, 0),
+                reset = reset_color(),
             )
         };
         println!(
@@ -413,7 +375,7 @@ pub(crate) fn compare_ast_node<'b, 's>(
             name: rust.get_elisp_fact().get_elisp_name(),
             message: Some(e.to_string()),
             children: Vec::new(),
-            rust_source: rust.get_standard_properties().get_source(),
+            rust_source: rust.get_source(),
             emacs_token: emacs,
         }
         .into()
@@ -1576,7 +1538,7 @@ fn compare_example_block<'b, 's>(
         [],
         (
             EmacsField::Required(":value"),
-            |r| Some(r.get_contents()),
+            |r| Some(r.get_value()),
             compare_property_quoted_string
         ),
         (
@@ -1654,7 +1616,7 @@ fn compare_export_block<'b, 's>(
         ),
         (
             EmacsField::Required(":value"),
-            |r| Some(r.get_contents()),
+            |r| Some(r.get_value()),
             compare_property_quoted_string
         )
     ) {
@@ -1702,7 +1664,7 @@ fn compare_src_block<'b, 's>(
         ),
         (
             EmacsField::Required(":value"),
-            |r| Some(r.get_contents()),
+            |r| Some(r.get_value()),
             compare_property_quoted_string
         ),
         (

src/compare/mod.rs

@@ -2,10 +2,7 @@
 mod compare;
 mod compare_field;
 mod diff;
-mod elisp_fact;
 mod macros;
-mod parse;
-mod sexp;
 mod util;
 pub use compare::run_anonymous_compare;
 pub use compare::run_anonymous_compare_with_settings;

src/compare/util.rs

@@ -8,15 +8,15 @@ use super::compare_field::compare_property_quoted_string;
 use super::compare_field::ComparePropertiesResult;
 use super::diff::DiffEntry;
 use super::diff::DiffStatus;
-use super::elisp_fact::GetElispFact;
-use super::sexp::Token;
 use crate::compare::diff::compare_ast_node;
-use crate::compare::sexp::unquote;
 use crate::types::AffiliatedKeywordValue;
 use crate::types::AstNode;
 use crate::types::GetAffiliatedKeywords;
-use crate::types::GetStandardProperties;
 use crate::types::StandardProperties;
+use crate::util::elisp::get_emacs_standard_properties;
+use crate::util::elisp::unquote;
+use crate::util::elisp::Token;
+use crate::util::elisp_fact::GetElispFact;
 
 /// Check if the child string slice is a slice of the parent string slice.
 fn is_slice_of(parent: &str, child: &str) -> bool {
@@ -30,32 +30,29 @@ fn is_slice_of(parent: &str, child: &str) -> bool {
 /// Get the byte offset into source that the rust object exists at.
 ///
 /// These offsets are zero-based unlike the elisp ones.
-fn get_rust_byte_offsets<'b, 's, S: StandardProperties<'s> + ?Sized>(
-    original_document: &'s str,
-    rust_ast_node: &'b S,
-) -> (usize, usize) {
-    let rust_object_source = rust_ast_node.get_source();
-    debug_assert!(is_slice_of(original_document, rust_object_source));
-    let offset = rust_object_source.as_ptr() as usize - original_document.as_ptr() as usize;
-    let end = offset + rust_object_source.len();
+fn get_rust_byte_offsets(original_document: &str, subset: &str) -> (usize, usize) {
+    debug_assert!(is_slice_of(original_document, subset));
+    let offset = subset.as_ptr() as usize - original_document.as_ptr() as usize;
+    let end = offset + subset.len();
     (offset, end)
 }
 
 pub(crate) fn compare_standard_properties<
     'b,
     's,
-    S: GetStandardProperties<'s> + GetElispFact<'s> + ?Sized,
+    S: StandardProperties<'s> + GetElispFact<'s> + ?Sized,
 >(
     original_document: &'s str,
     emacs: &'b Token<'s>,
     rust: &'b S,
 ) -> Result<(), Box<dyn std::error::Error>> {
     assert_name(emacs, rust.get_elisp_fact().get_elisp_name())?;
-    assert_bounds(original_document, emacs, rust.get_standard_properties())?;
+    assert_bounds(original_document, emacs, rust)?;
+    assert_post_blank(emacs, rust)?;
     Ok(())
 }
 
-pub(crate) fn assert_name<S: AsRef<str>>(
+fn assert_name<S: AsRef<str>>(
     emacs: &Token<'_>,
     name: S,
 ) -> Result<(), Box<dyn std::error::Error>> {
@@ -78,101 +75,75 @@ pub(crate) fn assert_name<S: AsRef<str>>(
 /// Assert that the character ranges defined by upstream org-mode's :standard-properties match the slices in Organic's StandardProperties.
 ///
 /// This does **not** handle plain text because plain text is a special case.
-pub(crate) fn assert_bounds<'b, 's, S: StandardProperties<'s> + ?Sized>(
+fn assert_bounds<'b, 's, S: StandardProperties<'s> + ?Sized>(
     original_document: &'s str,
     emacs: &'b Token<'s>,
     rust: &'b S,
 ) -> Result<(), Box<dyn std::error::Error>> {
     let standard_properties = get_emacs_standard_properties(emacs)?; // 1-based
-    let (begin, end) = (
-        standard_properties
-            .begin
-            .ok_or("Token should have a begin.")?,
-        standard_properties.end.ok_or("Token should have an end.")?,
-    );
-    let (rust_begin, rust_end) = get_rust_byte_offsets(original_document, rust); // 0-based
-    let rust_begin_char_offset = original_document[..rust_begin].chars().count() + 1; // 1-based
-    let rust_end_char_offset =
-        rust_begin_char_offset + original_document[rust_begin..rust_end].chars().count(); // 1-based
-    if rust_begin_char_offset != begin || rust_end_char_offset != end {
-        Err(format!("Rust bounds (in chars) ({rust_begin}, {rust_end}) do not match emacs bounds ({emacs_begin}, {emacs_end})", rust_begin = rust_begin_char_offset, rust_end = rust_end_char_offset, emacs_begin=begin, emacs_end=end))?;
+
+    // Check begin/end
+    {
+        let (begin, end) = (
+            standard_properties
+                .begin
+                .ok_or("Token should have a begin.")?,
+            standard_properties.end.ok_or("Token should have an end.")?,
+        );
+        let (rust_begin, rust_end) = get_rust_byte_offsets(original_document, rust.get_source()); // 0-based
+        let rust_begin_char_offset = original_document[..rust_begin].chars().count() + 1; // 1-based
+        let rust_end_char_offset =
+            rust_begin_char_offset + original_document[rust_begin..rust_end].chars().count(); // 1-based
+        if rust_begin_char_offset != begin || rust_end_char_offset != end {
+            Err(format!("Rust bounds (in chars) ({rust_begin}, {rust_end}) do not match emacs bounds ({emacs_begin}, {emacs_end})", rust_begin = rust_begin_char_offset, rust_end = rust_end_char_offset, emacs_begin=begin, emacs_end=end))?;
+        }
+    }
+
+    // Check contents-begin/contents-end
+    {
+        if let Some(rust_contents) = rust.get_contents() {
+            let (begin, end) = (
+                standard_properties
+                    .contents_begin
+                    .ok_or("Token should have a contents-begin.")?,
+                standard_properties
+                    .contents_end
+                    .ok_or("Token should have an contents-end.")?,
+            );
+            let (rust_begin, rust_end) = get_rust_byte_offsets(original_document, rust_contents); // 0-based
+            let rust_begin_char_offset = original_document[..rust_begin].chars().count() + 1; // 1-based
+            let rust_end_char_offset =
+                rust_begin_char_offset + original_document[rust_begin..rust_end].chars().count(); // 1-based
+            if rust_begin_char_offset != begin || rust_end_char_offset != end {
+                Err(format!("Rust contents bounds (in chars) ({rust_begin}, {rust_end}) do not match emacs contents bounds ({emacs_begin}, {emacs_end})", rust_begin = rust_begin_char_offset, rust_end = rust_end_char_offset, emacs_begin=begin, emacs_end=end))?;
+            }
+        } else if standard_properties.contents_begin.is_some()
+            || standard_properties.contents_end.is_some()
+        {
+            Err(format!("Rust contents is None but emacs contents bounds are ({emacs_begin:?}, {emacs_end:?})", emacs_begin=standard_properties.contents_begin, emacs_end=standard_properties.contents_end))?;
+        }
     }
 
     Ok(())
 }
 
-struct EmacsStandardProperties {
-    begin: Option<usize>,
-    #[allow(dead_code)]
-    post_affiliated: Option<usize>,
-    #[allow(dead_code)]
-    contents_begin: Option<usize>,
-    #[allow(dead_code)]
-    contents_end: Option<usize>,
-    end: Option<usize>,
-    #[allow(dead_code)]
-    post_blank: Option<usize>,
-}
+/// Assert that the post blank matches between emacs and organic.
+///
+/// This does **not** handle plain text because plain text is a special case.
+fn assert_post_blank<'b, 's, S: StandardProperties<'s> + ?Sized>(
+    emacs: &'b Token<'s>,
+    rust: &'b S,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let standard_properties = get_emacs_standard_properties(emacs)?; // 1-based
+    let rust_post_blank = rust.get_post_blank();
+    let emacs_post_blank = standard_properties
+        .post_blank
+        .ok_or("Token should have a post-blank.")?;
+    if rust_post_blank as usize != emacs_post_blank {
+        Err(format!("Rust post-blank {rust_post_blank} does not match emacs post-blank ({emacs_post_blank})", rust_post_blank = rust_post_blank, emacs_post_blank = emacs_post_blank))?;
+    }
 
-fn get_emacs_standard_properties(
-    emacs: &Token<'_>,
-) -> Result<EmacsStandardProperties, Box<dyn std::error::Error>> {
-    let children = emacs.as_list()?;
-    let attributes_child = children.get(1).ok_or("Should have an attributes child.")?;
-    let attributes_map = attributes_child.as_map()?;
-    let standard_properties = attributes_map.get(":standard-properties");
-    Ok(if standard_properties.is_some() {
-        let mut std_props = standard_properties
-            .expect("if statement proves its Some")
-            .as_vector()?
-            .iter();
-        let begin = maybe_token_to_usize(std_props.next())?;
-        let post_affiliated = maybe_token_to_usize(std_props.next())?;
-        let contents_begin = maybe_token_to_usize(std_props.next())?;
-        let contents_end = maybe_token_to_usize(std_props.next())?;
-        let end = maybe_token_to_usize(std_props.next())?;
-        let post_blank = maybe_token_to_usize(std_props.next())?;
-        EmacsStandardProperties {
-            begin,
-            post_affiliated,
-            contents_begin,
-            contents_end,
-            end,
-            post_blank,
-        }
-    } else {
-        let begin = maybe_token_to_usize(attributes_map.get(":begin").copied())?;
-        let end = maybe_token_to_usize(attributes_map.get(":end").copied())?;
-        let contents_begin = maybe_token_to_usize(attributes_map.get(":contents-begin").copied())?;
-        let contents_end = maybe_token_to_usize(attributes_map.get(":contents-end").copied())?;
-        let post_blank = maybe_token_to_usize(attributes_map.get(":post-blank").copied())?;
-        let post_affiliated =
-            maybe_token_to_usize(attributes_map.get(":post-affiliated").copied())?;
-        EmacsStandardProperties {
-            begin,
-            post_affiliated,
-            contents_begin,
-            contents_end,
-            end,
-            post_blank,
-        }
-    })
-}
-
-fn maybe_token_to_usize(
-    token: Option<&Token<'_>>,
-) -> Result<Option<usize>, Box<dyn std::error::Error>> {
-    Ok(token
-        .map(|token| token.as_atom())
-        .map_or(Ok(None), |r| r.map(Some))?
-        .and_then(|val| {
-            if val == "nil" {
-                None
-            } else {
-                Some(val.parse::<usize>())
-            }
-        })
-        .map_or(Ok(None), |r| r.map(Some))?)
+    Ok(())
 }
 
 /// Get a named property from the emacs token.
@@ -241,7 +212,7 @@ where
 pub(crate) fn compare_children<'b, 's, 'x, RC>(
     source: &'s str,
     emacs: &'b Token<'s>,
-    rust_children: &'x Vec<RC>,
+    rust_children: &'x [RC],
     child_status: &mut Vec<DiffEntry<'b, 's>>,
     this_status: &mut DiffStatus,
     message: &mut Option<String>,

src/context/global_settings.rs

@@ -71,9 +71,7 @@ pub struct EntityDefinition<'a> {
 
 impl<'g, 's> GlobalSettings<'g, 's> {
     fn new() -> GlobalSettings<'g, 's> {
-        debug_assert!(
-            DEFAULT_ORG_ENTITIES.is_sorted_by(|a, b| b.name.len().partial_cmp(&a.name.len()))
-        );
+        debug_assert!(DEFAULT_ORG_ENTITIES.is_sorted_by(|a, b| a.name.len() >= b.name.len()));
         GlobalSettings {
             radio_targets: Vec::new(),
             file_access: &LocalFileAccessInterface {

src/error/error.rs

@@ -6,9 +6,9 @@ pub(crate) type Res<T, U> = IResult<T, U, CustomError>;
 
 #[derive(Debug)]
 pub enum CustomError {
-    Static(&'static str),
-    IO(std::io::Error),
-    Parser(ErrorKind),
+    Static(#[allow(dead_code)] &'static str),
+    IO(#[allow(dead_code)] std::io::Error),
+    Parser(#[allow(dead_code)] ErrorKind),
 }
 
 impl<I: std::fmt::Debug> ParseError<I> for CustomError {

src/event_count/database.rs

@@ -24,10 +24,10 @@ pub(crate) fn record_event(event_type: EventType, input: OrgSource<'_>) {
     *db.entry(key).or_insert(0) += 1;
 }
 
-pub fn report(original_document: &str) {
+pub(crate) fn report(original_document: &str) {
     let mut db = GLOBAL_DATA.lock().unwrap();
     let db = db.get_or_insert_with(HashMap::new);
-    let mut results: Vec<_> = db.iter().map(|(k, v)| (k, v)).collect();
+    let mut results: Vec<_> = db.iter().collect();
     results.sort_by_key(|(_k, v)| *v);
     // This would put the most common at the top, but that is a pain when there is already a lot of output from the parser.
     // results.sort_by(|(_ak, av), (_bk, bv)| bv.cmp(av));

src/event_count/mod.rs

@@ -2,5 +2,5 @@ mod database;
 mod event_type;
 
 pub(crate) use database::record_event;
-pub use database::report;
+pub(crate) use database::report;
 pub(crate) use event_type::EventType;

src/lib.rs

@@ -1,8 +1,9 @@
 #![feature(exit_status_error)]
 #![feature(trait_alias)]
 #![feature(path_file_prefix)]
-#![feature(is_sorted)]
 #![feature(test)]
+#![feature(iter_intersperse)]
+#![feature(exact_size_is_empty)]
 // TODO: #![warn(missing_docs)]
 #![allow(clippy::bool_assert_comparison)] // Sometimes you want the long form because its easier to see at a glance.
 
@@ -10,11 +11,20 @@ extern crate test;
 
 #[cfg(feature = "compare")]
 pub mod compare;
+pub mod parse_cli;
+#[cfg(any(feature = "compare", feature = "wasm", feature = "wasm_test"))]
+mod util;
+#[cfg(any(feature = "wasm", feature = "wasm_test"))]
+mod wasm;
+#[cfg(any(feature = "wasm", feature = "wasm_test"))]
+pub mod wasm_cli;
+#[cfg(feature = "wasm_test")]
+pub mod wasm_test;
 
 mod context;
 mod error;
 #[cfg(feature = "event_count")]
-pub mod event_count;
+mod event_count;
 mod iter;
 pub mod parser;
 pub mod types;

src/main.rs

@@ -1,12 +1,4 @@
-#![feature(round_char_boundary)]
-#![feature(exact_size_is_empty)]
-use std::io::Read;
-use std::path::Path;
-
-use ::organic::parser::parse;
-use organic::parser::parse_with_settings;
-use organic::settings::GlobalSettings;
-use organic::settings::LocalFileAccessInterface;
+use organic::parse_cli::main_body;
 
 #[cfg(feature = "tracing")]
 use crate::init_tracing::init_telemetry;
@@ -30,55 +22,3 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         main_body_result
     })
 }
-
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-fn main_body() -> Result<(), Box<dyn std::error::Error>> {
-    let args = std::env::args().skip(1);
-    if args.is_empty() {
-        let org_contents = read_stdin_to_string()?;
-        run_anonymous_parse(org_contents)
-    } else {
-        for arg in args {
-            run_parse_on_file(arg)?
-        }
-        Ok(())
-    }
-}
-
-fn read_stdin_to_string() -> Result<String, Box<dyn std::error::Error>> {
-    let mut stdin_contents = String::new();
-    std::io::stdin()
-        .lock()
-        .read_to_string(&mut stdin_contents)?;
-    Ok(stdin_contents)
-}
-
-fn run_anonymous_parse<P: AsRef<str>>(org_contents: P) -> Result<(), Box<dyn std::error::Error>> {
-    let org_contents = org_contents.as_ref();
-    let rust_parsed = parse(org_contents)?;
-    println!("{:#?}", rust_parsed);
-    #[cfg(feature = "event_count")]
-    organic::event_count::report(org_contents);
-    Ok(())
-}
-
-fn run_parse_on_file<P: AsRef<Path>>(org_path: P) -> Result<(), Box<dyn std::error::Error>> {
-    let org_path = org_path.as_ref();
-    let parent_directory = org_path
-        .parent()
-        .ok_or("Should be contained inside a directory.")?;
-    let org_contents = std::fs::read_to_string(org_path)?;
-    let org_contents = org_contents.as_str();
-    let file_access_interface = LocalFileAccessInterface {
-        working_directory: Some(parent_directory.to_path_buf()),
-    };
-    let global_settings = GlobalSettings {
-        file_access: &file_access_interface,
-        ..Default::default()
-    };
-    let rust_parsed = parse_with_settings(org_contents, &global_settings)?;
-    println!("{:#?}", rust_parsed);
-    #[cfg(feature = "event_count")]
-    organic::event_count::report(org_contents);
-    Ok(())
-}

src/parse_cli/mod.rs

@@ -0,0 +1,59 @@
+use std::io::Read;
+use std::path::Path;
+
+use crate::parser::parse;
+use crate::parser::parse_with_settings;
+use crate::settings::GlobalSettings;
+use crate::settings::LocalFileAccessInterface;
+
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
+pub fn main_body() -> Result<(), Box<dyn std::error::Error>> {
+    let args = std::env::args().skip(1);
+    if args.is_empty() {
+        let org_contents = read_stdin_to_string()?;
+        run_anonymous_parse(org_contents)
+    } else {
+        for arg in args {
+            run_parse_on_file(arg)?
+        }
+        Ok(())
+    }
+}
+
+fn read_stdin_to_string() -> Result<String, Box<dyn std::error::Error>> {
+    let mut stdin_contents = String::new();
+    std::io::stdin()
+        .lock()
+        .read_to_string(&mut stdin_contents)?;
+    Ok(stdin_contents)
+}
+
+fn run_anonymous_parse<P: AsRef<str>>(org_contents: P) -> Result<(), Box<dyn std::error::Error>> {
+    let org_contents = org_contents.as_ref();
+    let rust_parsed = parse(org_contents)?;
+    println!("{:#?}", rust_parsed);
+    #[cfg(feature = "event_count")]
+    crate::event_count::report(org_contents);
+    Ok(())
+}
+
+fn run_parse_on_file<P: AsRef<Path>>(org_path: P) -> Result<(), Box<dyn std::error::Error>> {
+    let org_path = org_path.as_ref();
+    let parent_directory = org_path
+        .parent()
+        .ok_or("Should be contained inside a directory.")?;
+    let org_contents = std::fs::read_to_string(org_path)?;
+    let org_contents = org_contents.as_str();
+    let file_access_interface = LocalFileAccessInterface {
+        working_directory: Some(parent_directory.to_path_buf()),
+    };
+    let global_settings = GlobalSettings {
+        file_access: &file_access_interface,
+        ..Default::default()
+    };
+    let rust_parsed = parse_with_settings(org_contents, &global_settings)?;
+    println!("{:#?}", rust_parsed);
+    #[cfg(feature = "event_count")]
+    crate::event_count::report(org_contents);
+    Ok(())
+}

src/parser/angle_link.rs

@@ -47,7 +47,7 @@ pub(crate) fn angle_link<'b, 'g, 'r, 's>(
         parser_with_context!(parse_angle_link)(context),
     ))(remaining)?;
     let (remaining, _) = tag(">")(remaining)?;
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
@@ -59,6 +59,7 @@ pub(crate) fn angle_link<'b, 'g, 'r, 's>(
             raw_link: raw_link.into(),
             search_option: parsed_link.search_option,
             application: parsed_link.application,
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }

src/parser/babel_call.rs

@@ -4,7 +4,6 @@ use nom::bytes::complete::tag_no_case;
 use nom::character::complete::anychar;
 use nom::character::complete::one_of;
 use nom::character::complete::space0;
-use nom::combinator::consumed;
 use nom::combinator::opt;
 use nom::combinator::peek;
 use nom::combinator::recognize;
@@ -43,32 +42,10 @@ where
     start_of_line(remaining)?;
     let (remaining, _) = tuple((space0, tag("#+"), tag_no_case("call"), tag(":")))(remaining)?;
 
-    if let Ok((remaining, (_, line_break))) = tuple((space0, org_line_ending))(remaining) {
-        let (remaining, _trailing_ws) =
-            maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
-        let source = get_consumed(input, remaining);
-        return Ok((
-            remaining,
-            BabelCall {
-                source: Into::<&str>::into(source),
-                affiliated_keywords: parse_affiliated_keywords(
-                    context.get_global_settings(),
-                    affiliated_keywords,
-                ),
-                value: Into::<&str>::into(line_break.take(0)),
-                call: None,
-                inside_header: None,
-                arguments: None,
-                end_header: None,
-            },
-        ));
-    }
-
     let (remaining, _ws) = space0(remaining)?;
-    let (remaining, (value, babel_call_value)) = consumed(babel_call_value)(remaining)?;
-    let (remaining, _ws) = tuple((space0, org_line_ending))(remaining)?;
+    let (remaining, babel_call_value) = babel_call_value(remaining)?;
 
-    let (remaining, _trailing_ws) =
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
 
@@ -80,17 +57,22 @@ where
                 context.get_global_settings(),
                 affiliated_keywords,
             ),
-            value: Into::<&str>::into(value).trim_end(),
+            value: Into::<&str>::into(babel_call_value.value),
             call: babel_call_value.call.map(Into::<&str>::into),
             inside_header: babel_call_value.inside_header.map(Into::<&str>::into),
             arguments: babel_call_value.arguments.map(Into::<&str>::into),
             end_header: babel_call_value.end_header.map(Into::<&str>::into),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }
 
 #[derive(Debug)]
 struct BabelCallValue<'s> {
+    /// The entire string to the right of "#+call: " without the trailing line break.
+    value: OrgSource<'s>,
+
+    /// The function name which may contain a line break if there are no headers/arguments.
     call: Option<OrgSource<'s>>,
     inside_header: Option<OrgSource<'s>>,
     arguments: Option<OrgSource<'s>>,
@@ -99,13 +81,45 @@ struct BabelCallValue<'s> {
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn babel_call_value<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, BabelCallValue<'s>> {
-    let (remaining, call) = opt(babel_call_call)(input)?;
-    let (remaining, inside_header) = opt(inside_header)(remaining)?;
-    let (remaining, arguments) = opt(arguments)(remaining)?;
-    let (remaining, end_header) = opt(end_header)(remaining)?;
+    alt((
+        babel_call_value_without_headers,
+        babel_call_value_with_headers,
+    ))(input)
+}
+
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
+fn babel_call_value_without_headers<'s>(
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, BabelCallValue<'s>> {
+    let (remaining, value) = babel_call_call_with_headers(input)?;
+    let (remaining, _ws) = tuple((space0, org_line_ending))(remaining)?;
+    let call = get_consumed(input, remaining);
     Ok((
         remaining,
         BabelCallValue {
+            value,
+            call: Some(call),
+            inside_header: None,
+            arguments: None,
+            end_header: None,
+        },
+    ))
+}
+
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
+fn babel_call_value_with_headers<'s>(
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, BabelCallValue<'s>> {
+    let (remaining, call) = opt(babel_call_call_with_headers)(input)?;
+    let (remaining, inside_header) = opt(inside_header)(remaining)?;
+    let (remaining, arguments) = opt(arguments)(remaining)?;
+    let (remaining, end_header) = opt(end_header)(remaining)?;
+    let value = get_consumed(input, remaining);
+    let (remaining, _ws) = tuple((space0, org_line_ending))(remaining)?;
+    Ok((
+        remaining,
+        BabelCallValue {
+            value,
             call,
             inside_header,
             arguments: arguments.flatten(),
@@ -115,14 +129,15 @@ fn babel_call_value<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, BabelCallVal
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-fn babel_call_call<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
+fn babel_call_call_with_headers<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
+    // When babel call contains no arguments or headers (for example: "#+call: lorem ipsum\n") then the trailing line break is part of the call. Otherwise, it is not.
     verify(
         recognize(many_till(
             anychar,
-            alt((
-                peek(recognize(one_of("[("))),
+            peek(alt((
+                recognize(one_of("[(")),
                 recognize(tuple((space0, org_line_ending))),
-            )),
+            ))),
         )),
         |s| s.len() > 0,
     )(input)
@@ -232,19 +247,3 @@ fn impl_balanced_bracket<
     };
     Ok((remaining, contents))
 }
-
-#[cfg(test)]
-mod tests {
-    use nom::combinator::opt;
-
-    use super::*;
-
-    #[test]
-    fn simple_call() -> Result<(), Box<dyn std::error::Error>> {
-        let input = OrgSource::new("()");
-        let (remaining, call) = opt(babel_call_call)(input)?;
-        assert_eq!(Into::<&str>::into(remaining), "()");
-        assert!(call.is_none());
-        Ok(())
-    }
-}

src/parser/bullshitium.rs

@@ -63,6 +63,7 @@ pub(crate) fn broken_end<'b, 'g, 'r, 's>(
         match paragraph.children.first_mut() {
             Some(Object::PlainText(plain_text)) => {
                 plain_text.source = input.get_until_end_of_str(plain_text.source).into();
+                paragraph.contents = Some(input.get_until_end_of_str(plain_text.source).into());
             }
             Some(obj) => {
                 panic!("Unhandled first object type inside bullshitium {:?}", obj);
@@ -73,14 +74,18 @@ pub(crate) fn broken_end<'b, 'g, 'r, 's>(
         };
         Ok((remaining, paragraph))
     } else {
-        let (remaining, _trailing_ws) =
+        let (remaining, post_blank) =
             maybe_consume_trailing_whitespace_if_not_exiting(context, lead_in_remaining)?;
 
+        let body = Into::<&str>::into(input.get_until(lead_in_remaining));
+
         Ok((
             remaining,
             Paragraph::of_text(
                 input.get_until(remaining).into(),
-                input.get_until(lead_in_remaining).into(),
+                body,
+                if !body.is_empty() { Some(body) } else { None },
+                post_blank.map(Into::<&str>::into),
             ),
         ))
     }
@@ -119,6 +124,7 @@ pub(crate) fn broken_dynamic_block<'b, 'g, 'r, 's>(
         match paragraph.children.first_mut() {
             Some(Object::PlainText(plain_text)) => {
                 plain_text.source = input.get_until_end_of_str(plain_text.source).into();
+                paragraph.contents = Some(input.get_until_end_of_str(plain_text.source).into());
             }
             Some(obj) => {
                 panic!("Unhandled first object type inside bullshitium {:?}", obj);
@@ -129,14 +135,18 @@ pub(crate) fn broken_dynamic_block<'b, 'g, 'r, 's>(
         };
         Ok((remaining, paragraph))
     } else {
-        let (remaining, _trailing_ws) =
+        let (remaining, post_blank) =
             maybe_consume_trailing_whitespace_if_not_exiting(context, lead_in_remaining)?;
 
+        let body = Into::<&str>::into(input.get_until(lead_in_remaining));
+
         Ok((
             remaining,
             Paragraph::of_text(
                 input.get_until(remaining).into(),
-                input.get_until(lead_in_remaining).into(),
+                body,
+                if !body.is_empty() { Some(body) } else { None },
+                post_blank.map(Into::<&str>::into),
             ),
         ))
     }

src/parser/citation.rs

@@ -46,16 +46,22 @@ pub(crate) fn citation<'b, 'g, 'r, 's>(
     let (remaining, prefix) =
         must_balance_bracket(opt(parser_with_context!(global_prefix)(context)))(remaining)?;
 
+    let contents_begin = remaining;
     let (remaining, references) =
         separated_list1(tag(";"), parser_with_context!(citation_reference)(context))(remaining)?;
+    let contents_end = {
+        let (rem, _) = opt(tag(";"))(remaining)?;
+        rem
+    };
     let (remaining, suffix) = must_balance_bracket(opt(map(
         tuple((tag(";"), parser_with_context!(global_suffix)(context))),
         |(_, suffix)| suffix,
     )))(remaining)?;
     let (remaining, _) = tag("]")(remaining)?;
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
+    let contents = contents_begin.get_until(contents_end);
     Ok((
         remaining,
         Citation {
@@ -64,6 +70,8 @@ pub(crate) fn citation<'b, 'g, 'r, 's>(
             prefix: prefix.unwrap_or(Vec::new()),
             suffix: suffix.unwrap_or(Vec::new()),
             children: references,
+            contents: Into::<&str>::into(contents),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }
@@ -211,7 +219,6 @@ mod tests {
     use crate::context::List;
     use crate::parser::element_parser::element;
     use crate::types::Element;
-    use crate::types::GetStandardProperties;
     use crate::types::StandardProperties;
 
     #[test]
@@ -227,10 +234,7 @@ mod tests {
             _ => panic!("Should be a paragraph!"),
         };
         assert_eq!(Into::<&str>::into(remaining), "");
-        assert_eq!(
-            first_paragraph.get_standard_properties().get_source(),
-            "[cite:@foo]"
-        );
+        assert_eq!(first_paragraph.get_source(), "[cite:@foo]");
         assert_eq!(first_paragraph.children.len(), 1);
 
         match first_paragraph

src/parser/clock.rs

@@ -40,7 +40,7 @@ pub(crate) fn clock<'b, 'g, 'r, 's>(
     let (remaining, (timestamp, duration)) = clock_timestamp(context, remaining)?;
     let (remaining, _) = tuple((space0, org_line_ending))(remaining)?;
 
-    let (remaining, _trailing_ws) =
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
@@ -54,6 +54,7 @@ pub(crate) fn clock<'b, 'g, 'r, 's>(
             } else {
                 ClockStatus::Running
             },
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }
@@ -81,7 +82,7 @@ fn clock_timestamp<'b, 'g, 'r, 's>(
             |(timestamp, duration)| (timestamp, duration.map(Into::<&str>::into)),
         ),
         map(
-            parser_with_context!(inactive_timestamp)(context),
+            parser_with_context!(inactive_timestamp(true))(context),
             |timestamp| (timestamp, None),
         ),
     ))(input)

src/parser/comment.rs

@@ -46,7 +46,7 @@ pub(crate) fn comment<'b, 'g, 'r, 's>(
     let (remaining, mut remaining_lines) =
         many0(preceded(not(exit_matcher), comment_line_matcher))(remaining)?;
 
-    let (remaining, _trailing_ws) =
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     let mut value = Vec::with_capacity(remaining_lines.len() + 1);
@@ -67,6 +67,7 @@ pub(crate) fn comment<'b, 'g, 'r, 's>(
         Comment {
             source: source.into(),
             value,
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }
@@ -105,7 +106,6 @@ mod tests {
     use super::*;
     use crate::context::bind_context;
     use crate::context::Context;
-    use crate::context::ContextElement;
     use crate::context::GlobalSettings;
     use crate::context::List;
 

src/parser/diary_sexp.rs

@@ -31,7 +31,7 @@ where
     let (remaining, value) = recognize(tuple((tag("%%("), is_not("\r\n"))))(remaining)?;
     let (remaining, _eol) = org_line_ending(remaining)?;
 
-    let (remaining, _trailing_ws) =
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
@@ -43,6 +43,7 @@ where
                 affiliated_keywords,
             ),
             value: Into::<&str>::into(value),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }

src/parser/document.rs

@@ -3,6 +3,7 @@ use std::path::Path;
 use nom::combinator::all_consuming;
 use nom::combinator::opt;
 use nom::multi::many0;
+use nom::InputTake;
 
 use super::headline::heading;
 use super::in_buffer_settings::apply_in_buffer_settings;
@@ -181,8 +182,10 @@ fn _document<'b, 'g, 'r, 's>(
     let zeroth_section_matcher = parser_with_context!(zeroth_section)(context);
     let heading_matcher = parser_with_context!(heading(0))(context);
     let (remaining, _blank_lines) = many0(blank_line)(input)?;
+    let contents_begin = remaining;
     let (remaining, zeroth_section) = opt(zeroth_section_matcher)(remaining)?;
     let (remaining, children) = many0(heading_matcher)(remaining)?;
+    let contents = get_consumed(contents_begin, remaining);
     let source = get_consumed(input, remaining);
     Ok((
         remaining,
@@ -192,6 +195,11 @@ fn _document<'b, 'g, 'r, 's>(
             path: None,
             zeroth_section,
             children,
+            contents: if contents.len() > 0 {
+                Into::<&str>::into(contents)
+            } else {
+                Into::<&str>::into(remaining.take(0))
+            },
         },
     ))
 }

src/parser/drawer.rs

@@ -4,6 +4,7 @@ use nom::bytes::complete::tag_no_case;
 use nom::bytes::complete::take_while;
 use nom::character::complete::line_ending;
 use nom::character::complete::space0;
+use nom::combinator::consumed;
 use nom::combinator::eof;
 use nom::combinator::not;
 use nom::combinator::recognize;
@@ -12,7 +13,9 @@ use nom::sequence::tuple;
 
 use super::affiliated_keyword::parse_affiliated_keywords;
 use super::org_source::OrgSource;
+use super::paragraph::empty_paragraph;
 use super::util::maybe_consume_trailing_whitespace_if_not_exiting;
+use crate::context::bind_context;
 use crate::context::parser_with_context;
 use crate::context::ContextElement;
 use crate::context::ExitClass;
@@ -21,7 +24,6 @@ use crate::context::RefContext;
 use crate::error::CustomError;
 use crate::error::Res;
 use crate::parser::element_parser::element;
-use crate::parser::util::blank_line;
 use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
 use crate::parser::util::immediate_in_section;
@@ -30,7 +32,6 @@ use crate::parser::util::WORD_CONSTITUENT_CHARACTERS;
 use crate::types::Drawer;
 use crate::types::Element;
 use crate::types::Keyword;
-use crate::types::Paragraph;
 
 #[cfg_attr(
     feature = "tracing",
@@ -70,29 +71,12 @@ where
     let parser_context = context.with_additional_node(&contexts[0]);
     let parser_context = parser_context.with_additional_node(&contexts[1]);
     let parser_context = parser_context.with_additional_node(&contexts[2]);
+    let (remaining, (contents, children)) =
+        consumed(parser_with_context!(children)(&parser_context))(remaining)?;
 
-    let element_matcher = parser_with_context!(element(true))(&parser_context);
-    let exit_matcher = parser_with_context!(exit_matcher_parser)(&parser_context);
-    let (remaining, children) = match tuple((
-        not(exit_matcher),
-        blank_line,
-        many_till(blank_line, exit_matcher),
-    ))(remaining)
-    {
-        Ok((remain, (_not_immediate_exit, first_line, (_trailing_whitespace, _exit_contents)))) => {
-            let source = get_consumed(remaining, remain);
-            let element = Element::Paragraph(Paragraph::of_text(source.into(), first_line.into()));
-            (remain, vec![element])
-        }
-        Err(_) => {
-            let (remaining, (children, _exit_contents)) =
-                many_till(element_matcher, exit_matcher)(remaining)?;
-            (remaining, children)
-        }
-    };
     let (remaining, _end) = drawer_end(&parser_context, remaining)?;
 
-    let (remaining, _trailing_ws) =
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
 
@@ -106,10 +90,34 @@ where
             ),
             drawer_name: drawer_name.into(),
             children,
+            contents: Some(contents.into()),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }
 
+#[cfg_attr(
+    feature = "tracing",
+    tracing::instrument(ret, level = "debug", skip(context))
+)]
+fn children<'b, 'g, 'r, 's>(
+    context: RefContext<'b, 'g, 'r, 's>,
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, Vec<Element<'s>>> {
+    let element_matcher = parser_with_context!(element(true))(context);
+    let exit_matcher = parser_with_context!(exit_matcher_parser)(context);
+
+    if let Ok((remaining, (_not_exit, empty_para))) =
+        tuple((not(exit_matcher), bind_context!(empty_paragraph, context)))(input)
+    {
+        return Ok((remaining, vec![Element::Paragraph(empty_para)]));
+    }
+
+    let (remaining, (children, _exit_contents)) = many_till(element_matcher, exit_matcher)(input)?;
+
+    Ok((remaining, children))
+}
+
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn name<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
     take_while(|c| WORD_CONSTITUENT_CHARACTERS.contains(c) || "-_".contains(c))(input)

src/parser/dynamic_block.rs

@@ -6,20 +6,20 @@ use nom::character::complete::anychar;
 use nom::character::complete::line_ending;
 use nom::character::complete::space0;
 use nom::character::complete::space1;
-use nom::combinator::consumed;
 use nom::combinator::eof;
 use nom::combinator::not;
 use nom::combinator::opt;
 use nom::combinator::peek;
 use nom::combinator::recognize;
-use nom::multi::many0;
 use nom::multi::many_till;
-use nom::sequence::preceded;
 use nom::sequence::tuple;
 
 use super::affiliated_keyword::parse_affiliated_keywords;
+use super::greater_block::leading_blank_lines_end;
 use super::org_source::OrgSource;
+use super::paragraph::empty_paragraph;
 use super::util::maybe_consume_trailing_whitespace_if_not_exiting;
+use crate::context::bind_context;
 use crate::context::parser_with_context;
 use crate::context::ContextElement;
 use crate::context::ExitClass;
@@ -28,7 +28,6 @@ use crate::context::RefContext;
 use crate::error::CustomError;
 use crate::error::Res;
 use crate::parser::element_parser::element;
-use crate::parser::util::blank_line;
 use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
 use crate::parser::util::immediate_in_section;
@@ -36,7 +35,6 @@ use crate::parser::util::start_of_line;
 use crate::types::DynamicBlock;
 use crate::types::Element;
 use crate::types::Keyword;
-use crate::types::Paragraph;
 
 #[cfg_attr(
     feature = "tracing",
@@ -81,23 +79,25 @@ where
     let element_matcher = parser_with_context!(element(true))(&parser_context);
     let exit_matcher = parser_with_context!(exit_matcher_parser)(&parser_context);
     not(exit_matcher)(remaining)?;
-    let (remaining, leading_blank_lines) = opt(consumed(tuple((
-        blank_line,
-        many0(preceded(not(exit_matcher), blank_line)),
-    ))))(remaining)?;
-    let leading_blank_lines =
-        leading_blank_lines.map(|(source, (first_line, _remaining_lines))| {
-            Element::Paragraph(Paragraph::of_text(source.into(), first_line.into()))
-        });
+    let contents_begin = remaining;
+    let blank_line_context = ContextElement::ExitMatcherNode(ExitMatcherNode {
+        class: ExitClass::Alpha,
+        exit_matcher: &leading_blank_lines_end,
+    });
+    let blank_line_context = parser_context.with_additional_node(&blank_line_context);
+
+    let (remaining, leading_blank_lines) =
+        opt(bind_context!(empty_paragraph, &blank_line_context))(remaining)?;
     let (remaining, (mut children, _exit_contents)) =
         many_till(element_matcher, exit_matcher)(remaining)?;
     if let Some(lines) = leading_blank_lines {
-        children.insert(0, lines);
+        children.insert(0, Element::Paragraph(lines));
     }
+    let contents = get_consumed(contents_begin, remaining);
 
     let (remaining, _end) = dynamic_block_end(&parser_context, remaining)?;
 
-    let (remaining, _trailing_ws) =
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
@@ -111,6 +111,12 @@ where
             block_name: name.into(),
             parameters: parameters.map(|val| val.into()),
             children,
+            contents: if contents.len() > 0 {
+                Some(Into::<&str>::into(contents))
+            } else {
+                None
+            },
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }

src/parser/entity.rs

@@ -28,7 +28,7 @@ pub(crate) fn entity<'b, 'g, 'r, 's>(
     let (remaining, _) = tag("\\")(input)?;
     let (remaining, (entity_definition, entity_name, use_brackets)) = name(context, remaining)?;
 
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
 
     let source = get_consumed(input, remaining);
@@ -43,6 +43,7 @@ pub(crate) fn entity<'b, 'g, 'r, 's>(
             ascii: entity_definition.ascii,
             utf8: entity_definition.utf8,
             use_brackets,
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }

src/parser/export_snippet.rs

@@ -39,7 +39,7 @@ pub(crate) fn export_snippet<'b, 'g, 'r, 's>(
         parser_with_context!(contents)(&parser_context),
     )))(remaining)?;
     let (remaining, _) = tag("@@")(remaining)?;
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
@@ -48,6 +48,7 @@ pub(crate) fn export_snippet<'b, 'g, 'r, 's>(
             source: source.into(),
             backend: backend_name.into(),
             contents: backend_contents.map(|(_colon, backend_contents)| backend_contents.into()),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }

src/parser/fixed_width_area.rs

@@ -2,12 +2,15 @@ use nom::branch::alt;
 use nom::bytes::complete::tag;
 use nom::character::complete::anychar;
 use nom::character::complete::space0;
+use nom::combinator::map;
 use nom::combinator::not;
+use nom::combinator::peek;
 use nom::combinator::recognize;
 use nom::multi::many0;
 use nom::multi::many_till;
 use nom::sequence::preceded;
 use nom::sequence::tuple;
+use nom::InputTake;
 
 use super::affiliated_keyword::parse_affiliated_keywords;
 use super::org_source::OrgSource;
@@ -35,28 +38,25 @@ pub(crate) fn fixed_width_area<'b, 'g, 'r, 's, AK>(
 where
     AK: IntoIterator<Item = Keyword<'s>>,
 {
-    let fixed_width_area_line_matcher = parser_with_context!(fixed_width_area_line)(context);
     let exit_matcher = parser_with_context!(exit_matcher_parser)(context);
-    let (remaining, first_line) = fixed_width_area_line_matcher(remaining)?;
-    let (remaining, mut remaining_lines) =
-        many0(preceded(not(exit_matcher), fixed_width_area_line_matcher))(remaining)?;
+    let (remaining, first_line) = fixed_width_area_line(remaining)?;
+    let (remaining, remaining_lines) = many0(preceded(
+        not(tuple((org_line_ending, exit_matcher))),
+        map(
+            tuple((org_line_ending, fixed_width_area_line)),
+            |(_line_ending, line_contents)| line_contents,
+        ),
+    ))(remaining)?;
 
-    let (remaining, _trailing_ws) =
+    let post_blank_begin = remaining;
+    let (remaining, _first_line_break) = org_line_ending(remaining)?;
+    let (remaining, _additional_post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
+    let post_blank = get_consumed(post_blank_begin, remaining);
     let source = get_consumed(input, remaining);
     let mut value = Vec::with_capacity(remaining_lines.len() + 1);
-    let last_line = remaining_lines.pop();
-    if let Some(last_line) = last_line {
-        value.push(Into::<&str>::into(first_line));
-        value.extend(remaining_lines.into_iter().map(Into::<&str>::into));
-        let last_line = Into::<&str>::into(last_line);
-        // Trim the line ending from the final line.
-        value.push(&last_line[..(last_line.len() - 1)])
-    } else {
-        // Trim the line ending from the only line.
-        let only_line = Into::<&str>::into(first_line);
-        value.push(&only_line[..(only_line.len() - 1)])
-    }
+    value.push(Into::<&str>::into(first_line));
+    value.extend(remaining_lines.into_iter().map(Into::<&str>::into));
     Ok((
         remaining,
         FixedWidthArea {
@@ -66,25 +66,24 @@ where
                 affiliated_keywords,
             ),
             value,
+            post_blank: if post_blank.len() > 0 {
+                Some(Into::<&str>::into(post_blank))
+            } else {
+                None
+            },
         },
     ))
 }
 
-#[cfg_attr(
-    feature = "tracing",
-    tracing::instrument(ret, level = "debug", skip(_context))
-)]
-fn fixed_width_area_line<'b, 'g, 'r, 's>(
-    _context: RefContext<'b, 'g, 'r, 's>,
-    input: OrgSource<'s>,
-) -> Res<OrgSource<'s>, OrgSource<'s>> {
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
+fn fixed_width_area_line<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
     start_of_line(input)?;
     let (remaining, _) = tuple((space0, tag(":")))(input)?;
-    if let Ok((remaining, line_break)) = org_line_ending(remaining) {
-        return Ok((remaining, line_break));
+    if let Ok((_remain, _line_break)) = org_line_ending(remaining) {
+        return Ok((remaining, remaining.take(0)));
     }
     let (remaining, _) = tag(" ")(remaining)?;
-    let (remaining, value) = recognize(many_till(anychar, org_line_ending))(remaining)?;
+    let (remaining, value) = recognize(many_till(anychar, peek(org_line_ending)))(remaining)?;
     Ok((remaining, value))
 }
 

src/parser/footnote_definition.rs

@@ -75,6 +75,7 @@ where
     let parser_context = parser_context.with_additional_node(&contexts[2]);
     let element_matcher = parser_with_context!(element(true))(&parser_context);
     let exit_matcher = parser_with_context!(exit_matcher_parser)(&parser_context);
+    let before_contents = remaining;
     let (mut remaining, (mut children, _exit_contents)) =
         many_till(include_input(element_matcher), exit_matcher)(remaining)?;
 
@@ -90,13 +91,16 @@ where
         }
     }
 
-    let (remaining, _trailing_ws) =
+    let contents = get_consumed(before_contents, remaining);
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
         remaining,
         FootnoteDefinition {
             source: source.into(),
+            contents: Some(contents.into()),
+            post_blank: post_blank.map(Into::<&str>::into),
             affiliated_keywords: parse_affiliated_keywords(
                 context.get_global_settings(),
                 affiliated_keywords,
@@ -160,7 +164,7 @@ mod tests {
     use crate::context::Context;
     use crate::context::GlobalSettings;
     use crate::context::List;
-    use crate::types::GetStandardProperties;
+    use crate::types::StandardProperties;
 
     #[test]
     fn two_paragraphs() {
@@ -181,17 +185,13 @@ line footnote.",
             footnote_definition_matcher(remaining).expect("Parse second footnote_definition.");
         assert_eq!(Into::<&str>::into(remaining), "");
         assert_eq!(
-            first_footnote_definition
-                .get_standard_properties()
-                .get_source(),
+            first_footnote_definition.get_source(),
             "[fn:1] A footnote.
 
 "
         );
         assert_eq!(
-            second_footnote_definition
-                .get_standard_properties()
-                .get_source(),
+            second_footnote_definition.get_source(),
             "[fn:2] A multi-
 
 line footnote."
@@ -216,9 +216,7 @@ not in the footnote.",
             footnote_definition_matcher(input).expect("Parse first footnote_definition");
         assert_eq!(Into::<&str>::into(remaining), "not in the footnote.");
         assert_eq!(
-            first_footnote_definition
-                .get_standard_properties()
-                .get_source(),
+            first_footnote_definition.get_source(),
             "[fn:2] A multi-
 
 line footnote.

src/parser/footnote_reference.rs

@@ -2,6 +2,7 @@ use nom::branch::alt;
 use nom::bytes::complete::tag;
 use nom::bytes::complete::tag_no_case;
 use nom::combinator::all_consuming;
+use nom::combinator::consumed;
 use nom::combinator::map_parser;
 use nom::combinator::verify;
 use nom::multi::many1;
@@ -59,7 +60,7 @@ fn anonymous_footnote<'b, 'g, 'r, 's>(
     let initial_context = ContextElement::document_context();
     let initial_context = Context::new(context.get_global_settings(), List::new(&initial_context));
 
-    let (remaining, children) = map_parser(
+    let (remaining, (contents, children)) = consumed(map_parser(
         verify(
             parser_with_context!(text_until_exit)(&parser_context),
             |text| text.len() > 0,
@@ -69,17 +70,19 @@ fn anonymous_footnote<'b, 'g, 'r, 's>(
                 &initial_context,
             )))(i)
         }),
-    )(remaining)?;
+    ))(remaining)?;
 
     let (remaining, _) = tag("]")(remaining)?;
 
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
         remaining,
         FootnoteReference {
             source: source.into(),
+            contents: Some(contents.into()),
+            post_blank: post_blank.map(Into::<&str>::into),
             label: None,
             definition: children,
         },
@@ -106,7 +109,7 @@ fn inline_footnote<'b, 'g, 'r, 's>(
     let initial_context = ContextElement::document_context();
     let initial_context = Context::new(context.get_global_settings(), List::new(&initial_context));
 
-    let (remaining, children) = map_parser(
+    let (remaining, (contents, children)) = consumed(map_parser(
         verify(
             parser_with_context!(text_until_exit)(&parser_context),
             |text| text.len() > 0,
@@ -116,17 +119,19 @@ fn inline_footnote<'b, 'g, 'r, 's>(
                 &initial_context,
             )))(i)
         }),
-    )(remaining)?;
+    ))(remaining)?;
 
     let (remaining, _) = tag("]")(remaining)?;
 
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
         remaining,
         FootnoteReference {
             source: source.into(),
+            contents: Some(contents.into()),
+            post_blank: post_blank.map(Into::<&str>::into),
             label: Some(label_contents.into()),
             definition: children,
         },
@@ -144,13 +149,15 @@ fn footnote_reference_only<'b, 'g, 'r, 's>(
     let (remaining, _) = tag_no_case("[fn:")(input)?;
     let (remaining, label_contents) = label(remaining)?;
     let (remaining, _) = tag("]")(remaining)?;
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
         remaining,
         FootnoteReference {
             source: source.into(),
+            contents: None,
+            post_blank: post_blank.map(Into::<&str>::into),
             label: Some(label_contents.into()),
             definition: Vec::with_capacity(0),
         },

src/parser/greater_block.rs

@@ -5,22 +5,21 @@ use nom::character::complete::anychar;
 use nom::character::complete::line_ending;
 use nom::character::complete::space0;
 use nom::character::complete::space1;
-use nom::combinator::consumed;
 use nom::combinator::eof;
 use nom::combinator::not;
 use nom::combinator::opt;
 use nom::combinator::peek;
 use nom::combinator::recognize;
 use nom::combinator::verify;
-use nom::multi::many0;
 use nom::multi::many_till;
-use nom::sequence::preceded;
 use nom::sequence::tuple;
 
 use super::affiliated_keyword::parse_affiliated_keywords;
 use super::org_source::OrgSource;
+use super::paragraph::empty_paragraph;
 use super::util::in_section;
 use super::util::maybe_consume_trailing_whitespace_if_not_exiting;
+use crate::context::bind_context;
 use crate::context::parser_with_context;
 use crate::context::ContextElement;
 use crate::context::ContextMatcher;
@@ -37,7 +36,6 @@ use crate::parser::util::start_of_line;
 use crate::types::CenterBlock;
 use crate::types::Element;
 use crate::types::Keyword;
-use crate::types::Paragraph;
 use crate::types::QuoteBlock;
 use crate::types::SpecialBlock;
 
@@ -102,7 +100,7 @@ fn center_block<'b, 'g, 'r, 's, AK>(
 where
     AK: IntoIterator<Item = Keyword<'s>>,
 {
-    let (remaining, (source, children)) = greater_block_body(
+    let (remaining, body) = greater_block_body(
         context,
         input,
         pre_affiliated_keywords_input,
@@ -112,12 +110,14 @@ where
     Ok((
         remaining,
         Element::CenterBlock(CenterBlock {
-            source,
+            source: body.source,
             affiliated_keywords: parse_affiliated_keywords(
                 context.get_global_settings(),
                 affiliated_keywords,
             ),
-            children,
+            children: body.children,
+            contents: body.contents,
+            post_blank: body.post_blank,
         }),
     ))
 }
@@ -135,7 +135,7 @@ fn quote_block<'b, 'g, 'r, 's, AK>(
 where
     AK: IntoIterator<Item = Keyword<'s>>,
 {
-    let (remaining, (source, children)) = greater_block_body(
+    let (remaining, body) = greater_block_body(
         context,
         input,
         pre_affiliated_keywords_input,
@@ -145,12 +145,14 @@ where
     Ok((
         remaining,
         Element::QuoteBlock(QuoteBlock {
-            source,
+            source: body.source,
             affiliated_keywords: parse_affiliated_keywords(
                 context.get_global_settings(),
                 affiliated_keywords,
             ),
-            children,
+            children: body.children,
+            contents: body.contents,
+            post_blank: body.post_blank,
         }),
     ))
 }
@@ -196,7 +198,7 @@ where
     AK: IntoIterator<Item = Keyword<'s>>,
 {
     let (remaining, parameters) = opt(tuple((space1, parameters)))(input)?;
-    let (remaining, (source, children)) = greater_block_body(
+    let (remaining, body) = greater_block_body(
         context,
         remaining,
         pre_affiliated_keywords_input,
@@ -206,18 +208,28 @@ where
     Ok((
         remaining,
         Element::SpecialBlock(SpecialBlock {
-            source,
+            source: body.source,
             affiliated_keywords: parse_affiliated_keywords(
                 context.get_global_settings(),
                 affiliated_keywords,
             ),
-            children,
+            children: body.children,
             block_type: name,
             parameters: parameters.map(|(_, parameters)| Into::<&str>::into(parameters)),
+            contents: body.contents,
+            post_blank: body.post_blank,
         }),
     ))
 }
 
+#[derive(Debug)]
+struct GreaterBlockBody<'s> {
+    source: &'s str,
+    children: Vec<Element<'s>>,
+    contents: Option<&'s str>,
+    post_blank: Option<&'s str>,
+}
+
 #[cfg_attr(
     feature = "tracing",
     tracing::instrument(ret, level = "debug", skip(context))
@@ -228,7 +240,7 @@ fn greater_block_body<'c, 'b, 'g, 'r, 's>(
     pre_affiliated_keywords_input: OrgSource<'s>,
     name: &'c str,
     context_name: &'c str,
-) -> Res<OrgSource<'s>, (&'s str, Vec<Element<'s>>)> {
+) -> Res<OrgSource<'s>, GreaterBlockBody<'s>> {
     if in_section(context, context_name) {
         return Err(nom::Err::Error(CustomError::Static(
             "Cannot nest objects of the same element",
@@ -250,28 +262,43 @@ fn greater_block_body<'c, 'b, 'g, 'r, 's>(
     let element_matcher = parser_with_context!(element(true))(&parser_context);
     let exit_matcher = parser_with_context!(exit_matcher_parser)(&parser_context);
     not(exit_matcher)(remaining)?;
-    let (remaining, leading_blank_lines) = opt(consumed(tuple((
-        blank_line,
-        many0(preceded(not(exit_matcher), blank_line)),
-    ))))(remaining)?;
-    let leading_blank_lines =
-        leading_blank_lines.map(|(source, (first_line, _remaining_lines))| {
-            Element::Paragraph(Paragraph::of_text(source.into(), first_line.into()))
-        });
+    let contents_begin = remaining;
+
+    let blank_line_context = ContextElement::ExitMatcherNode(ExitMatcherNode {
+        class: ExitClass::Alpha,
+        exit_matcher: &leading_blank_lines_end,
+    });
+    let blank_line_context = parser_context.with_additional_node(&blank_line_context);
+
+    let (remaining, leading_blank_lines) =
+        opt(bind_context!(empty_paragraph, &blank_line_context))(remaining)?;
     let (remaining, (mut children, _exit_contents)) =
         many_till(element_matcher, exit_matcher)(remaining)?;
     if let Some(lines) = leading_blank_lines {
-        children.insert(0, lines);
+        children.insert(0, Element::Paragraph(lines));
     }
+    let contents = get_consumed(contents_begin, remaining);
 
     let (remaining, _end) = exit_with_name(&parser_context, remaining)?;
 
     // Not checking if parent exit matcher is causing exit because the greater_block_end matcher asserts we matched a full greater block
 
-    let (remaining, _trailing_ws) =
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(pre_affiliated_keywords_input, remaining);
-    Ok((remaining, (Into::<&str>::into(source), children)))
+    Ok((
+        remaining,
+        GreaterBlockBody {
+            source: Into::<&str>::into(source),
+            children,
+            contents: if contents.len() > 0 {
+                Some(Into::<&str>::into(contents))
+            } else {
+                None
+            },
+            post_blank: post_blank.map(Into::<&str>::into),
+        },
+    ))
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
@@ -307,3 +334,14 @@ fn _greater_block_end<'b, 'g, 'r, 's, 'c>(
     let source = get_consumed(input, remaining);
     Ok((remaining, source))
 }
+
+#[cfg_attr(
+    feature = "tracing",
+    tracing::instrument(ret, level = "debug", skip(_context))
+)]
+pub(crate) fn leading_blank_lines_end<'b, 'g, 'r, 's, 'c>(
+    _context: RefContext<'b, 'g, 'r, 's>,
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, OrgSource<'s>> {
+    recognize(not(blank_line))(input)
+}

src/parser/headline.rs

@@ -66,6 +66,8 @@ fn _heading<'b, 'g, 'r, 's>(
     let (remaining, pre_headline) = headline(context, input, parent_star_count)?;
     let section_matcher = bind_context!(section, context);
     let heading_matcher = bind_context!(heading(pre_headline.star_count), context);
+    let (contents_begin, _) = opt(many0(blank_line))(remaining)?;
+    let maybe_post_blank = get_consumed(remaining, contents_begin);
     let (remaining, maybe_section) =
         opt(map(section_matcher, DocumentElement::Section))(remaining)?;
     let (remaining, _ws) = opt(tuple((start_of_line, many0(blank_line))))(remaining)?;
@@ -75,14 +77,15 @@ fn _heading<'b, 'g, 'r, 's>(
         // If the section has a planning then the timestamp values are copied to the heading.
         if let DocumentElement::Section(inner_section) = &section {
             if let Some(Element::Planning(planning)) = inner_section.children.first() {
-                scheduled = planning.scheduled.clone();
-                deadline = planning.deadline.clone();
-                closed = planning.closed.clone();
+                scheduled.clone_from(&planning.scheduled);
+                deadline.clone_from(&planning.deadline);
+                closed.clone_from(&planning.closed);
             }
         }
         children.insert(0, section);
     }
-    let remaining = if children.is_empty() {
+    let has_children = !children.is_empty();
+    let remaining = if !has_children {
         // Support empty headings
         let (remain, _ws) = many0(blank_line)(remaining)?;
         remain
@@ -91,6 +94,7 @@ fn _heading<'b, 'g, 'r, 's>(
     };
     let is_archived = pre_headline.tags.contains(&"ARCHIVE");
 
+    let contents = get_consumed(contents_begin, remaining);
     let source = get_consumed(input, remaining);
     Ok((
         remaining,
@@ -112,6 +116,16 @@ fn _heading<'b, 'g, 'r, 's>(
             scheduled,
             deadline,
             closed,
+            contents: if contents.len() > 0 {
+                Some(Into::<&str>::into(contents))
+            } else {
+                None
+            },
+            post_blank: if has_children {
+                None
+            } else {
+                Some(Into::<&str>::into(maybe_post_blank))
+            },
         },
     ))
 }

src/parser/horizontal_rule.rs

@@ -38,7 +38,7 @@ where
         space0,
         alt((line_ending, eof)),
     )))(remaining)?;
-    let (remaining, _trailing_ws) =
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
@@ -49,6 +49,7 @@ where
                 context.get_global_settings(),
                 affiliated_keywords,
             ),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }

src/parser/inline_babel_call.rs

@@ -38,7 +38,7 @@ pub(crate) fn inline_babel_call<'b, 'g, 'r, 's>(
     let (remaining, arguments) = argument(context, remaining)?;
     let (remaining, end_header) = opt(parser_with_context!(header)(context))(remaining)?;
     let value = get_consumed(input, remaining);
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
@@ -54,6 +54,7 @@ pub(crate) fn inline_babel_call<'b, 'g, 'r, 's>(
                 None
             },
             end_header: end_header.map(Into::<&str>::into),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }

src/parser/inline_source_block.rs

@@ -38,7 +38,7 @@ pub(crate) fn inline_source_block<'b, 'g, 'r, 's>(
     let (remaining, language) = lang(context, remaining)?;
     let (remaining, parameters) = opt(parser_with_context!(header)(context))(remaining)?;
     let (remaining, value) = body(context, remaining)?;
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
@@ -48,6 +48,7 @@ pub(crate) fn inline_source_block<'b, 'g, 'r, 's>(
             language: language.into(),
             parameters: parameters.map(Into::<&str>::into),
             value: value.into(),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }

src/parser/keyword.rs

@@ -58,6 +58,7 @@ fn _filtered_keyword<'s, F: Fn(OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s
                 affiliated_keywords: AffiliatedKeywords::default(), // To be populated by the caller if this keyword is in a context to support affiliated keywords.
                 key: parsed_key.into(),
                 value: "",
+                post_blank: None,
             },
         ));
     }
@@ -71,6 +72,7 @@ fn _filtered_keyword<'s, F: Fn(OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s
             affiliated_keywords: AffiliatedKeywords::default(), // To be populated by the caller if this keyword is in a context to support affiliated keywords.
             key: parsed_key.into(),
             value: parsed_value.into(),
+            post_blank: None,
         },
     ))
 }
@@ -89,12 +91,13 @@ where
     AK: IntoIterator<Item = Keyword<'s>>,
 {
     let (remaining, mut kw) = filtered_keyword(regular_keyword_key)(remaining)?;
-    let (remaining, _trailing_ws) =
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     kw.affiliated_keywords =
         parse_affiliated_keywords(context.get_global_settings(), affiliated_keywords);
     kw.source = Into::<&str>::into(source);
+    kw.post_blank = post_blank.map(Into::<&str>::into);
     Ok((remaining, kw))
 }
 
@@ -221,7 +224,6 @@ mod tests {
     use test::Bencher;
 
     use super::*;
-    use crate::parser::OrgSource;
 
     #[bench]
     fn bench_affiliated_keyword(b: &mut Bencher) {

src/parser/latex_environment.rs

@@ -57,7 +57,7 @@ where
     let (remaining, _end) = latex_environment_end_specialized(&parser_context, remaining)?;
     let value_end = remaining;
 
-    let (remaining, _trailing_ws) =
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     let value = get_consumed(value_start, value_end);
@@ -70,6 +70,7 @@ where
                 affiliated_keywords,
             ),
             value: value.into(),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }

src/parser/latex_fragment.rs

@@ -39,7 +39,7 @@ pub(crate) fn latex_fragment<'b, 'g, 'r, 's>(
         parser_with_context!(bordered_dollar_fragment)(context),
     ))(input)?;
     let value = get_consumed(input, remaining);
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
@@ -47,6 +47,7 @@ pub(crate) fn latex_fragment<'b, 'g, 'r, 's>(
         LatexFragment {
             source: source.into(),
             value: value.into(),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }

src/parser/lesser_block.rs

@@ -80,22 +80,28 @@ where
     let object_matcher = parser_with_context!(standard_set_object)(&parser_context);
     let exit_matcher = parser_with_context!(exit_matcher_parser)(&parser_context);
     // Check for a completely empty block
-    let (remaining, children) = match consumed(many_till(blank_line, exit_matcher))(remaining) {
-        Ok((remaining, (whitespace, (_children, _exit_contents)))) => (
-            remaining,
-            vec![Object::PlainText(PlainText {
-                source: whitespace.into(),
-            })],
-        ),
-        Err(_) => {
-            let (remaining, (children, _exit_contents)) =
-                many_till(object_matcher, exit_matcher)(remaining)?;
-            (remaining, children)
-        }
-    };
+    let (remaining, contents, children) =
+        match consumed(many_till(blank_line, exit_matcher))(remaining) {
+            Ok((remaining, (whitespace, (_children, _exit_contents)))) => (
+                remaining,
+                whitespace,
+                if whitespace.len() > 0 {
+                    vec![Object::PlainText(PlainText {
+                        source: whitespace.into(),
+                    })]
+                } else {
+                    Vec::new()
+                },
+            ),
+            Err(_) => {
+                let (remaining, (contents, (children, _exit_contents))) =
+                    consumed(many_till(object_matcher, exit_matcher))(remaining)?;
+                (remaining, contents, children)
+            }
+        };
     let (remaining, _end) = lesser_block_end_specialized(&parser_context, remaining)?;
 
-    let (remaining, _trailing_ws) =
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
@@ -108,6 +114,8 @@ where
             ),
             data: parameters.map(Into::<&str>::into),
             children,
+            contents: Into::<&str>::into(contents),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }
@@ -144,7 +152,7 @@ where
     let (remaining, contents) = parser_with_context!(text_until_exit)(&parser_context)(remaining)?;
     let (remaining, _end) = lesser_block_end_specialized(&parser_context, remaining)?;
 
-    let (remaining, _trailing_ws) =
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
@@ -156,6 +164,7 @@ where
                 affiliated_keywords,
             ),
             contents: contents.into(),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }
@@ -205,7 +214,7 @@ where
     let (remaining, contents) = text_until_exit(&parser_context, remaining)?;
     let (remaining, _end) = lesser_block_end_specialized(&parser_context, remaining)?;
 
-    let (remaining, _trailing_ws) =
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     let (switches, number_lines, preserve_indent, retain_labels, use_labels, label_format) = {
@@ -236,7 +245,8 @@ where
             retain_labels,
             use_labels,
             label_format,
-            contents: Into::<&str>::into(contents),
+            value: Into::<&str>::into(contents),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }
@@ -279,7 +289,7 @@ where
     let (remaining, contents) = text_until_exit(&parser_context, remaining)?;
     let (remaining, _end) = lesser_block_end_specialized(&parser_context, remaining)?;
 
-    let (remaining, _trailing_ws) =
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
@@ -292,7 +302,8 @@ where
             ),
             export_type: export_type.map(Into::<&str>::into),
             data: parameters.map(Into::<&str>::into),
-            contents: Into::<&str>::into(contents),
+            value: Into::<&str>::into(contents),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }
@@ -334,7 +345,7 @@ where
     let (remaining, contents) = text_until_exit(&parser_context, remaining)?;
     let (remaining, _end) = lesser_block_end_specialized(&parser_context, remaining)?;
 
-    let (remaining, _trailing_ws) =
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     let (switches, number_lines, preserve_indent, retain_labels, use_labels, label_format) = {
@@ -371,7 +382,8 @@ where
             retain_labels,
             use_labels,
             label_format,
-            contents: Into::<&str>::into(contents),
+            value: Into::<&str>::into(contents),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }

src/parser/org_macro.rs

@@ -32,7 +32,7 @@ pub(crate) fn org_macro<'b, 'g, 'r, 's>(
     let (remaining, macro_args) = opt(parser_with_context!(org_macro_args)(context))(remaining)?;
     let (remaining, _) = tag("}}}")(remaining)?;
     let macro_value = get_consumed(input, remaining);
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
 
     let source = get_consumed(input, remaining);
@@ -47,6 +47,7 @@ pub(crate) fn org_macro<'b, 'g, 'r, 's>(
                 .map(|arg| arg.into())
                 .collect(),
             value: Into::<&str>::into(macro_value),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }

src/parser/paragraph.rs

@@ -1,5 +1,8 @@
 use nom::branch::alt;
+use nom::character::complete::space1;
+use nom::combinator::consumed;
 use nom::combinator::eof;
+use nom::combinator::opt;
 use nom::combinator::recognize;
 use nom::combinator::verify;
 use nom::multi::many1;
@@ -12,6 +15,7 @@ use super::org_source::OrgSource;
 use super::util::blank_line;
 use super::util::get_consumed;
 use super::util::maybe_consume_trailing_whitespace_if_not_exiting;
+use super::util::org_line_ending;
 use crate::context::parser_with_context;
 use crate::context::ContextElement;
 use crate::context::ExitClass;
@@ -45,14 +49,14 @@ where
     let standard_set_object_matcher = parser_with_context!(standard_set_object)(&parser_context);
     let exit_matcher = parser_with_context!(exit_matcher_parser)(&parser_context);
 
-    let (remaining, (children, _exit_contents)) = verify(
+    let (remaining, (contents, (children, _exit_contents))) = consumed(verify(
         many_till(standard_set_object_matcher, exit_matcher),
         |(children, _exit_contents)| !children.is_empty(),
-    )(remaining)?;
+    ))(remaining)?;
 
     // Not checking parent exit matcher because if there are any children matched then we have a valid paragraph.
 
-    let (remaining, _trailing_ws) =
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
 
@@ -60,6 +64,8 @@ where
         remaining,
         Paragraph {
             source: source.into(),
+            contents: Some(contents.into()),
+            post_blank: post_blank.map(Into::<&str>::into),
             affiliated_keywords: parse_affiliated_keywords(
                 context.get_global_settings(),
                 affiliated_keywords,
@@ -69,6 +75,57 @@ where
     ))
 }
 
+#[cfg_attr(
+    feature = "tracing",
+    tracing::instrument(ret, level = "debug", skip(context))
+)]
+pub(crate) fn empty_paragraph<'b, 'g, 'r, 's>(
+    context: RefContext<'b, 'g, 'r, 's>,
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, Paragraph<'s>> {
+    // If it is just a single newline then source, contents, and post-blank are "\n".
+    // If it has multiple newlines then contents is the first "\n" and post-blank is all the new lines.
+    // If there are any spaces on the first line then post-blank excludes the first line.
+
+    let exit_matcher = parser_with_context!(exit_matcher_parser)(context);
+
+    let (remaining, first_line_with_spaces) =
+        opt(recognize(tuple((space1, org_line_ending))))(input)?;
+
+    let post_blank_begin = remaining;
+
+    if let Some(first_line_with_spaces) = first_line_with_spaces {
+        let (remaining, _additional_lines) =
+            recognize(many_till(blank_line, exit_matcher))(remaining)?;
+        let post_blank = get_consumed(post_blank_begin, remaining);
+        let source = get_consumed(input, remaining);
+        Ok((
+            remaining,
+            Paragraph::of_text(
+                Into::<&str>::into(source),
+                Into::<&str>::into(first_line_with_spaces),
+                Some(Into::<&str>::into(first_line_with_spaces)),
+                Some(Into::<&str>::into(post_blank)),
+            ),
+        ))
+    } else {
+        let (remaining, first_line) = blank_line(remaining)?;
+        let (remaining, _additional_lines) =
+            recognize(many_till(blank_line, exit_matcher))(remaining)?;
+        let post_blank = get_consumed(post_blank_begin, remaining);
+        let source = get_consumed(input, remaining);
+        Ok((
+            remaining,
+            Paragraph::of_text(
+                Into::<&str>::into(source),
+                Into::<&str>::into(first_line),
+                Some(Into::<&str>::into(first_line)),
+                Some(Into::<&str>::into(post_blank)),
+            ),
+        ))
+    }
+}
+
 #[cfg_attr(
     feature = "tracing",
     tracing::instrument(ret, level = "debug", skip(context))
@@ -96,7 +153,8 @@ mod tests {
     use crate::context::List;
     use crate::parser::element_parser::element;
     use crate::parser::org_source::OrgSource;
-    use crate::types::GetStandardProperties;
+    use crate::parser::paragraph::empty_paragraph;
+    use crate::types::StandardProperties;
 
     #[test]
     fn two_paragraphs() {
@@ -109,13 +167,20 @@ mod tests {
         let (remaining, second_paragraph) =
             paragraph_matcher(remaining).expect("Parse second paragraph.");
         assert_eq!(Into::<&str>::into(remaining), "");
-        assert_eq!(
-            first_paragraph.get_standard_properties().get_source(),
-            "foo bar baz\n\n"
-        );
-        assert_eq!(
-            second_paragraph.get_standard_properties().get_source(),
-            "lorem ipsum"
-        );
+        assert_eq!(first_paragraph.get_source(), "foo bar baz\n\n");
+        assert_eq!(second_paragraph.get_source(), "lorem ipsum");
+    }
+
+    #[test]
+    fn paragraph_whitespace() {
+        let input = OrgSource::new("\n");
+        let global_settings = GlobalSettings::default();
+        let initial_context = ContextElement::document_context();
+        let initial_context = Context::new(&global_settings, List::new(&initial_context));
+        let paragraph_matcher = bind_context!(empty_paragraph, &initial_context);
+        let (remaining, paragraph) = paragraph_matcher(input).expect("Parse paragraph");
+        assert_eq!(Into::<&str>::into(remaining), "");
+        assert_eq!(paragraph.get_source(), "\n");
+        assert_eq!(paragraph.get_contents(), Some("\n"));
     }
 }

src/parser/plain_link.rs

@@ -54,7 +54,7 @@ pub(crate) fn plain_link<'b, 'g, 'r, 's>(
     let (remaining, _) = pre(context, input)?;
     let (remaining, path_plain) = parse_path_plain(context, remaining)?;
     peek(parser_with_context!(post)(context))(remaining)?;
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
@@ -66,6 +66,7 @@ pub(crate) fn plain_link<'b, 'g, 'r, 's>(
             raw_link: path_plain.raw_link,
             search_option: path_plain.search_option,
             application: path_plain.application,
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }

src/parser/plain_list.rs

@@ -7,6 +7,7 @@ use nom::character::complete::multispace1;
 use nom::character::complete::one_of;
 use nom::character::complete::space0;
 use nom::character::complete::space1;
+use nom::combinator::consumed;
 use nom::combinator::eof;
 use nom::combinator::map;
 use nom::combinator::not;
@@ -152,6 +153,7 @@ where
     let mut children = Vec::new();
     let mut first_item_indentation: Option<IndentationLevel> = None;
     let mut first_item_list_type: Option<PlainListType> = None;
+    let contents_begin = remaining;
     let mut remaining = remaining;
 
     // The final list item does not consume trailing blank lines (which instead get consumed by the list). We have three options here:
@@ -195,7 +197,8 @@ where
         )));
     }
 
-    let (remaining, _trailing_ws) =
+    let contents = get_consumed(contents_begin, remaining);
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
@@ -208,6 +211,8 @@ where
             ),
             list_type: first_item_list_type.expect("Plain lists require at least one element."),
             children: children.into_iter().map(|(_start, item)| item).collect(),
+            contents: Some(Into::<&str>::into(contents)),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }
@@ -265,7 +270,7 @@ fn plain_list_item<'b, 'g, 'r, 's>(
     let maybe_contentless_item: Res<OrgSource<'_>, ()> =
         detect_contentless_item_contents(&parser_context, remaining);
     if let Ok((_rem, _ws)) = maybe_contentless_item {
-        let (remaining, _trailing_ws) = if tuple((
+        let (remaining, post_blank) = if tuple((
             blank_line,
             bind_context!(final_item_whitespace_cutoff, context),
         ))(remaining)
@@ -291,6 +296,12 @@ fn plain_list_item<'b, 'g, 'r, 's>(
                         .unwrap_or(Vec::new()),
                     pre_blank: 0,
                     children: Vec::new(),
+                    contents: None,
+                    post_blank: if post_blank.len() > 0 {
+                        Some(Into::<&str>::into(post_blank))
+                    } else {
+                        None
+                    },
                 },
             ),
         ));
@@ -301,13 +312,13 @@ fn plain_list_item<'b, 'g, 'r, 's>(
         .filter(|b| *b == b'\n')
         .count();
 
-    let (remaining, (children, _exit_contents)) = many_till(
+    let (remaining, (contents, (children, _exit_contents))) = consumed(many_till(
         include_input(bind_context!(element(true), &parser_context)),
         bind_context!(exit_matcher_parser, &parser_context),
-    )(remaining)?;
+    ))(remaining)?;
 
     // We have to use the parser_context here to include the whitespace cut-off
-    let (remaining, _trailing_ws) =
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(&final_whitespace_context, remaining)?;
 
     let source = get_consumed(input, remaining);
@@ -329,6 +340,12 @@ fn plain_list_item<'b, 'g, 'r, 's>(
                 pre_blank: PlainListItemPreBlank::try_from(pre_blank)
                     .expect("pre-blank cannot be larger than 2."),
                 children: children.into_iter().map(|(_start, item)| item).collect(),
+                contents: if contents.len() > 0 {
+                    Some(contents.into())
+                } else {
+                    None
+                },
+                post_blank: post_blank.map(Into::<&str>::into),
             },
         ),
     ));
@@ -629,7 +646,7 @@ mod tests {
     use crate::context::Context;
     use crate::context::GlobalSettings;
     use crate::context::List;
-    use crate::types::GetStandardProperties;
+    use crate::types::StandardProperties;
 
     #[test]
     fn plain_list_item_empty() {
@@ -640,7 +657,7 @@ mod tests {
         let plain_list_item_matcher = bind_context!(plain_list_item, &initial_context);
         let (remaining, (_, result)) = plain_list_item_matcher(input).unwrap();
         assert_eq!(Into::<&str>::into(remaining), "");
-        assert_eq!(result.get_standard_properties().get_source(), "1.");
+        assert_eq!(result.get_source(), "1.");
     }
 
     #[test]
@@ -652,7 +669,7 @@ mod tests {
         let plain_list_item_matcher = bind_context!(plain_list_item, &initial_context);
         let (remaining, (_, result)) = plain_list_item_matcher(input).unwrap();
         assert_eq!(Into::<&str>::into(remaining), "");
-        assert_eq!(result.get_standard_properties().get_source(), "1. foo");
+        assert_eq!(result.get_source(), "1. foo");
     }
 
     #[test]
@@ -664,7 +681,7 @@ mod tests {
         let (remaining, result) =
             plain_list(std::iter::empty(), input, &initial_context, input).unwrap();
         assert_eq!(Into::<&str>::into(remaining), "");
-        assert_eq!(result.get_standard_properties().get_source(), "1.");
+        assert_eq!(result.get_source(), "1.");
     }
 
     #[test]
@@ -676,7 +693,7 @@ mod tests {
         let (remaining, result) =
             plain_list(std::iter::empty(), input, &initial_context, input).unwrap();
         assert_eq!(Into::<&str>::into(remaining), "");
-        assert_eq!(result.get_standard_properties().get_source(), "1. foo");
+        assert_eq!(result.get_source(), "1. foo");
     }
 
     #[test]
@@ -721,7 +738,7 @@ mod tests {
             plain_list_matcher(input).expect("Should parse the plain list successfully.");
         assert_eq!(Into::<&str>::into(remaining), "   ipsum\n");
         assert_eq!(
-            result.get_standard_properties().get_source(),
+            result.get_source(),
             r#"1. foo
 2. bar
    baz
@@ -749,7 +766,7 @@ baz"#,
             plain_list_matcher(input).expect("Should parse the plain list successfully.");
         assert_eq!(Into::<&str>::into(remaining), "baz");
         assert_eq!(
-            result.get_standard_properties().get_source(),
+            result.get_source(),
             r#"1. foo
    1. bar
 
@@ -782,7 +799,7 @@ dolar"#,
             plain_list_matcher(input).expect("Should parse the plain list successfully.");
         assert_eq!(Into::<&str>::into(remaining), "dolar");
         assert_eq!(
-            result.get_standard_properties().get_source(),
+            result.get_source(),
             r#"1. foo
 
    bar

src/parser/plain_text.rs

@@ -143,7 +143,7 @@ mod tests {
     use crate::context::GlobalSettings;
     use crate::context::List;
     use crate::parser::object_parser::detect_standard_set_object_sans_plain_text;
-    use crate::types::GetStandardProperties;
+    use crate::types::StandardProperties;
 
     #[test]
     fn plain_text_simple() {
@@ -160,9 +160,6 @@ mod tests {
         )(input)
         .unwrap();
         assert_eq!(Into::<&str>::into(remaining), "");
-        assert_eq!(
-            result.get_standard_properties().get_source(),
-            Into::<&str>::into(input)
-        );
+        assert_eq!(result.get_source(), Into::<&str>::into(input));
     }
 }

src/parser/planning.rs

@@ -33,7 +33,7 @@ pub(crate) fn planning<'b, 'g, 'r, 's>(
         many1(parser_with_context!(planning_parameter)(context))(remaining)?;
     let (remaining, _trailing_ws) = tuple((space0, org_line_ending))(remaining)?;
 
-    let (remaining, _trailing_ws) =
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
 
@@ -62,6 +62,7 @@ pub(crate) fn planning<'b, 'g, 'r, 's>(
             scheduled,
             deadline,
             closed,
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }

src/parser/property_drawer.rs

@@ -6,6 +6,7 @@ use nom::character::complete::anychar;
 use nom::character::complete::line_ending;
 use nom::character::complete::space0;
 use nom::character::complete::space1;
+use nom::combinator::consumed;
 use nom::combinator::eof;
 use nom::combinator::opt;
 use nom::combinator::recognize;
@@ -64,14 +65,11 @@ pub(crate) fn property_drawer<'b, 'g, 'r, 's>(
     let parser_context = context.with_additional_node(&contexts[0]);
     let parser_context = parser_context.with_additional_node(&contexts[1]);
     let parser_context = parser_context.with_additional_node(&contexts[2]);
-
-    let node_property_matcher = parser_with_context!(node_property)(&parser_context);
-    let exit_matcher = parser_with_context!(exit_matcher_parser)(&parser_context);
-    let (remaining, (children, _exit_contents)) =
-        many_till(node_property_matcher, exit_matcher)(remaining)?;
+    let (remaining, (contents, children)) =
+        consumed(parser_with_context!(children)(&parser_context))(remaining)?;
     let (remaining, _end) = property_drawer_end(&parser_context, remaining)?;
 
-    let (remaining, _trailing_ws) =
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
 
@@ -80,10 +78,31 @@ pub(crate) fn property_drawer<'b, 'g, 'r, 's>(
         PropertyDrawer {
             source: source.into(),
             children,
+            contents: if contents.len() > 0 {
+                Some(contents.into())
+            } else {
+                None
+            },
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }
 
+#[cfg_attr(
+    feature = "tracing",
+    tracing::instrument(ret, level = "debug", skip(context))
+)]
+fn children<'b, 'g, 'r, 's>(
+    context: RefContext<'b, 'g, 'r, 's>,
+    input: OrgSource<'s>,
+) -> Res<OrgSource<'s>, Vec<NodeProperty<'s>>> {
+    let node_property_matcher = parser_with_context!(node_property)(context);
+    let exit_matcher = parser_with_context!(exit_matcher_parser)(context);
+    let (remaining, (children, _exit_contents)) =
+        many_till(node_property_matcher, exit_matcher)(input)?;
+    Ok((remaining, children))
+}
+
 #[cfg_attr(
     feature = "tracing",
     tracing::instrument(ret, level = "debug", skip(_context))

src/parser/radio_link.rs

@@ -39,7 +39,7 @@ pub(crate) fn radio_link<'b, 'g, 'r, 's>(
         let rematched_target = rematch_target(context, radio_target, input);
         if let Ok((remaining, rematched_target)) = rematched_target {
             let path = get_consumed(input, remaining);
-            let (remaining, _) = space0(remaining)?;
+            let (remaining, post_blank) = space0(remaining)?;
             let source = get_consumed(input, remaining);
             return Ok((
                 remaining,
@@ -47,6 +47,11 @@ pub(crate) fn radio_link<'b, 'g, 'r, 's>(
                     source: source.into(),
                     children: rematched_target,
                     path: path.into(),
+                    post_blank: if post_blank.len() > 0 {
+                        Some(Into::<&str>::into(post_blank))
+                    } else {
+                        None
+                    },
                 },
             ));
         }
@@ -134,7 +139,7 @@ pub(crate) fn radio_target<'b, 'g, 'r, 's>(
     ))(remaining)?;
 
     let (remaining, _closing) = tag(">>>")(remaining)?;
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
@@ -142,6 +147,7 @@ pub(crate) fn radio_target<'b, 'g, 'r, 's>(
         RadioTarget {
             source: source.into(),
             value: raw_value.into(),
+            post_blank: post_blank.map(Into::<&str>::into),
             children,
         },
     ))
@@ -169,14 +175,12 @@ pub(crate) trait RematchObject<'x> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::context::Context;
     use crate::context::GlobalSettings;
-    use crate::context::List;
     use crate::parser::element_parser::element;
     use crate::types::Bold;
     use crate::types::Element;
-    use crate::types::GetStandardProperties;
     use crate::types::PlainText;
+    use crate::types::StandardProperties;
 
     #[test]
     fn plain_text_radio_target() -> Result<(), Box<dyn std::error::Error>> {
@@ -195,10 +199,7 @@ mod tests {
             _ => panic!("Should be a paragraph!"),
         };
         assert_eq!(Into::<&str>::into(remaining), "");
-        assert_eq!(
-            first_paragraph.get_standard_properties().get_source(),
-            "foo bar baz"
-        );
+        assert_eq!(first_paragraph.get_source(), "foo bar baz");
         assert_eq!(first_paragraph.children.len(), 3);
         match first_paragraph
             .children
@@ -206,7 +207,7 @@ mod tests {
             .expect("Len already asserted to be 3.")
         {
             Object::RadioLink(inner) => {
-                assert_eq!(inner.get_standard_properties().get_source(), "bar ");
+                assert_eq!(inner.get_source(), "bar ");
                 assert_eq!(inner.path, "bar");
                 assert_eq!(inner.children.len(), 1);
                 let child = inner
@@ -214,7 +215,7 @@ mod tests {
                     .first()
                     .expect("Length already asserted to be 1.");
                 assert!(matches!(child, Object::PlainText(_)));
-                assert_eq!(child.get_standard_properties().get_source(), "bar");
+                assert_eq!(child.get_source(), "bar");
             }
             _ => {
                 return Err("Child should be a radio link.".into());
@@ -228,6 +229,8 @@ mod tests {
         let input = OrgSource::new("foo *bar* baz");
         let radio_target_match = vec![Object::Bold(Bold {
             source: "*bar*",
+            contents: "bar",
+            post_blank: Some(" "),
             children: vec![Object::PlainText(PlainText { source: "bar" })],
         })];
         let global_settings = GlobalSettings {
@@ -244,10 +247,7 @@ mod tests {
             _ => panic!("Should be a paragraph!"),
         };
         assert_eq!(Into::<&str>::into(remaining), "");
-        assert_eq!(
-            first_paragraph.get_standard_properties().get_source(),
-            "foo *bar* baz"
-        );
+        assert_eq!(first_paragraph.get_source(), "foo *bar* baz");
         assert_eq!(first_paragraph.children.len(), 3);
         match first_paragraph
             .children
@@ -255,7 +255,7 @@ mod tests {
             .expect("Len already asserted to be 3.")
         {
             Object::RadioLink(inner) => {
-                assert_eq!(inner.get_standard_properties().get_source(), "*bar* ");
+                assert_eq!(inner.get_source(), "*bar* ");
                 assert_eq!(inner.path, "*bar* ");
                 assert_eq!(inner.children.len(), 1);
                 let child = inner
@@ -263,7 +263,7 @@ mod tests {
                     .first()
                     .expect("Length already asserted to be 1.");
                 assert!(matches!(child, Object::Bold(_)));
-                assert_eq!(child.get_standard_properties().get_source(), "*bar* ");
+                assert_eq!(child.get_source(), "*bar* ");
             }
             _ => {
                 return Err("Child should be a radio link.".into());

src/parser/regular_link.rs

@@ -73,7 +73,7 @@ fn regular_link_without_description<'b, 'g, 'r, 's>(
     let (remaining, _opening_bracket) = tag("[[")(input)?;
     let (remaining, path) = pathreg(context, remaining)?;
     let (remaining, _closing_bracket) = tag("]]")(remaining)?;
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
@@ -84,6 +84,8 @@ fn regular_link_without_description<'b, 'g, 'r, 's>(
             path: path.path,
             raw_link: path.raw_link,
             search_option: path.search_option,
+            contents: None,
+            post_blank: post_blank.map(Into::<&str>::into),
             children: Vec::new(),
             application: path.application,
         },
@@ -101,9 +103,10 @@ fn regular_link_with_description<'b, 'g, 'r, 's>(
     let (remaining, _opening_bracket) = tag("[[")(input)?;
     let (remaining, path) = pathreg(context, remaining)?;
     let (remaining, _closing_bracket) = tag("][")(remaining)?;
-    let (remaining, description) = description(context, remaining)?;
+    let (remaining, (contents, description)) =
+        consumed(parser_with_context!(description)(context))(remaining)?;
     let (remaining, _closing_bracket) = tag("]]")(remaining)?;
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
@@ -114,6 +117,8 @@ fn regular_link_with_description<'b, 'g, 'r, 's>(
             path: path.path,
             raw_link: path.raw_link,
             search_option: path.search_option,
+            contents: Some(Into::<&str>::into(contents)),
+            post_blank: post_blank.map(Into::<&str>::into),
             children: description,
             application: path.application,
         },

src/parser/section.rs

@@ -72,7 +72,7 @@ pub(crate) fn zeroth_section<'b, 'g, 'r, 's>(
         }
     }
 
-    let (remaining, _trailing_ws) =
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
 
     let source = get_consumed(input, remaining);
@@ -80,6 +80,7 @@ pub(crate) fn zeroth_section<'b, 'g, 'r, 's>(
         remaining,
         Section {
             source: source.into(),
+            post_blank: post_blank.map(Into::<&str>::into),
             children,
         },
     ))
@@ -128,7 +129,7 @@ pub(crate) fn section<'b, 'g, 'r, 's>(
         children.insert(0, ele)
     }
 
-    let (remaining, _trailing_ws) =
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
 
     let source = get_consumed(input, remaining);
@@ -136,6 +137,7 @@ pub(crate) fn section<'b, 'g, 'r, 's>(
         remaining,
         Section {
             source: source.into(),
+            post_blank: post_blank.map(Into::<&str>::into),
             children,
         },
     ))

src/parser/statistics_cookie.rs

@@ -40,7 +40,7 @@ fn percent_statistics_cookie<'b, 'g, 'r, 's>(
         tag("%]"),
     )))(input)?;
     let value = get_consumed(input, remaining);
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
@@ -48,6 +48,7 @@ fn percent_statistics_cookie<'b, 'g, 'r, 's>(
         StatisticsCookie {
             source: source.into(),
             value: value.into(),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }
@@ -68,7 +69,7 @@ fn fraction_statistics_cookie<'b, 'g, 'r, 's>(
         tag("]"),
     )))(input)?;
     let value = get_consumed(input, remaining);
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
@@ -76,6 +77,7 @@ fn fraction_statistics_cookie<'b, 'g, 'r, 's>(
         StatisticsCookie {
             source: source.into(),
             value: value.into(),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }

src/parser/subscript_and_superscript.rs

@@ -3,6 +3,7 @@ use nom::bytes::complete::tag;
 use nom::bytes::complete::take_while;
 use nom::character::complete::anychar;
 use nom::character::complete::one_of;
+use nom::combinator::consumed;
 use nom::combinator::map;
 use nom::combinator::not;
 use nom::combinator::opt;
@@ -54,17 +55,20 @@ pub(crate) fn subscript<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Subscript<'s>> {
-    // We check for the underscore first before checking the pre-character as a minor optimization to avoid walking up the context tree to find the document root unnecessarily.
     let (remaining, _) = tag("_")(input)?;
     pre(input)?;
     let (remaining, body) = script_body(context, remaining)?;
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
 
-    let (use_brackets, body) = match body {
-        ScriptBody::Braceless(text) => (false, vec![Object::PlainText(PlainText { source: text })]),
-        ScriptBody::WithBraces(body) => (true, body),
+    let (use_brackets, contents, body) = match body {
+        ScriptBody::Braceless(text) => (
+            false,
+            text,
+            vec![Object::PlainText(PlainText { source: text })],
+        ),
+        ScriptBody::WithBraces(contents, body) => (true, contents, body),
     };
 
     Ok((
@@ -72,6 +76,8 @@ pub(crate) fn subscript<'b, 'g, 'r, 's>(
         Subscript {
             source: source.into(),
             use_brackets,
+            contents,
+            post_blank: post_blank.map(Into::<&str>::into),
             children: body,
         },
     ))
@@ -89,13 +95,17 @@ pub(crate) fn superscript<'b, 'g, 'r, 's>(
     let (remaining, _) = tag("^")(input)?;
     pre(input)?;
     let (remaining, body) = script_body(context, remaining)?;
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
 
-    let (use_brackets, body) = match body {
-        ScriptBody::Braceless(text) => (false, vec![Object::PlainText(PlainText { source: text })]),
-        ScriptBody::WithBraces(body) => (true, body),
+    let (use_brackets, contents, body) = match body {
+        ScriptBody::Braceless(text) => (
+            false,
+            text,
+            vec![Object::PlainText(PlainText { source: text })],
+        ),
+        ScriptBody::WithBraces(contents, body) => (true, contents, body),
     };
 
     Ok((
@@ -103,6 +113,8 @@ pub(crate) fn superscript<'b, 'g, 'r, 's>(
         Superscript {
             source: source.into(),
             use_brackets,
+            contents,
+            post_blank: post_blank.map(Into::<&str>::into),
             children: body,
         },
     ))
@@ -117,7 +129,7 @@ fn pre<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
 #[derive(Debug)]
 enum ScriptBody<'s> {
     Braceless(&'s str),
-    WithBraces(Vec<Object<'s>>),
+    WithBraces(&'s str, Vec<Object<'s>>),
 }
 
 #[cfg_attr(
@@ -135,9 +147,10 @@ fn script_body<'b, 'g, 'r, 's>(
         map(parser_with_context!(script_alphanum)(context), |body| {
             ScriptBody::Braceless(body.into())
         }),
-        map(parser_with_context!(script_with_braces)(context), |body| {
-            ScriptBody::WithBraces(body)
-        }),
+        map(
+            parser_with_context!(script_with_braces)(context),
+            |(contents, body)| ScriptBody::WithBraces(Into::<&str>::into(contents), body),
+        ),
         map(
             parser_with_context!(script_with_parenthesis)(context),
             |body| ScriptBody::Braceless(body.into()),
@@ -195,7 +208,7 @@ fn end_script_alphanum_character<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>,
 fn script_with_braces<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
-) -> Res<OrgSource<'s>, Vec<Object<'s>>> {
+) -> Res<OrgSource<'s>, (OrgSource<'s>, Vec<Object<'s>>)> {
     let (remaining, _) = tag("{")(input)?;
     let exit_with_depth = script_with_braces_end(remaining.get_brace_depth());
     let parser_context = ContextElement::ExitMatcherNode(ExitMatcherNode {
@@ -204,13 +217,13 @@ fn script_with_braces<'b, 'g, 'r, 's>(
     });
     let parser_context = context.with_additional_node(&parser_context);
 
-    let (remaining, (children, _exit_contents)) = many_till(
+    let (remaining, (contents, (children, _exit_contents))) = consumed(many_till(
         parser_with_context!(standard_set_object)(&parser_context),
         parser_with_context!(exit_matcher_parser)(&parser_context),
-    )(remaining)?;
+    ))(remaining)?;
 
     let (remaining, _) = tag("}")(remaining)?;
-    Ok((remaining, children))
+    Ok((remaining, (contents, children)))
 }
 
 fn script_with_braces_end(starting_brace_depth: BracketDepth) -> impl ContextMatcher {

src/parser/table.rs

@@ -3,6 +3,7 @@ use nom::bytes::complete::is_not;
 use nom::bytes::complete::tag;
 use nom::character::complete::line_ending;
 use nom::character::complete::space0;
+use nom::combinator::consumed;
 use nom::combinator::not;
 use nom::combinator::opt;
 use nom::combinator::peek;
@@ -67,13 +68,13 @@ where
     let org_mode_table_row_matcher = parser_with_context!(org_mode_table_row)(&parser_context);
     let exit_matcher = parser_with_context!(exit_matcher_parser)(&parser_context);
 
-    let (remaining, (children, _exit_contents)) =
-        many_till(org_mode_table_row_matcher, exit_matcher)(remaining)?;
+    let (remaining, (contents, (children, _exit_contents))) =
+        consumed(many_till(org_mode_table_row_matcher, exit_matcher))(remaining)?;
 
     let (remaining, formulas) =
         many0(parser_with_context!(table_formula_keyword)(context))(remaining)?;
 
-    let (remaining, _trailing_ws) =
+    let (remaining, post_blank) =
         maybe_consume_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
 
@@ -87,6 +88,8 @@ where
             ),
             formulas,
             children,
+            contents: Into::<&str>::into(contents),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }
@@ -150,6 +153,7 @@ fn org_mode_table_row_rule<'b, 'g, 'r, 's>(
         TableRow {
             source: source.into(),
             children: Vec::new(),
+            contents: None,
         },
     ))
 }
@@ -164,8 +168,8 @@ fn org_mode_table_row_regular<'b, 'g, 'r, 's>(
 ) -> Res<OrgSource<'s>, TableRow<'s>> {
     start_of_line(input)?;
     let (remaining, _) = tuple((space0, tag("|")))(input)?;
-    let (remaining, children) =
-        many1(parser_with_context!(org_mode_table_cell)(context))(remaining)?;
+    let (remaining, (contents, children)) =
+        consumed(many1(parser_with_context!(org_mode_table_cell)(context)))(remaining)?;
     let (remaining, _tail) = recognize(tuple((space0, org_line_ending)))(remaining)?;
     let source = get_consumed(input, remaining);
     Ok((
@@ -173,6 +177,11 @@ fn org_mode_table_row_regular<'b, 'g, 'r, 's>(
         TableRow {
             source: source.into(),
             children,
+            contents: if contents.len() > 0 {
+                Some(Into::<&str>::into(contents))
+            } else {
+                None
+            },
         },
     ))
 }
@@ -194,12 +203,12 @@ fn org_mode_table_cell<'b, 'g, 'r, 's>(
         parser_with_context!(table_cell_set_object)(&parser_context);
     let exit_matcher = parser_with_context!(exit_matcher_parser)(&parser_context);
     let (remaining, _) = space0(input)?;
-    let (remaining, (children, _exit_contents)) = verify(
+    let (remaining, (contents, (children, _exit_contents))) = consumed(verify(
         many_till(table_cell_set_object_matcher, exit_matcher),
         |(children, exit_contents)| {
             !children.is_empty() || Into::<&str>::into(exit_contents).ends_with('|')
         },
-    )(remaining)?;
+    ))(remaining)?;
 
     let (remaining, _tail) = org_mode_table_cell_end(&parser_context, remaining)?;
 
@@ -210,6 +219,7 @@ fn org_mode_table_cell<'b, 'g, 'r, 's>(
         TableCell {
             source: source.into(),
             children,
+            contents: Into::<&str>::into(contents),
         },
     ))
 }

src/parser/target.rs

@@ -46,7 +46,7 @@ pub(crate) fn target<'b, 'g, 'r, 's>(
         )));
     }
     let (remaining, _) = tag(">>")(remaining)?;
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
 
@@ -55,6 +55,7 @@ pub(crate) fn target<'b, 'g, 'r, 's>(
         Target {
             source: source.into(),
             value: body.into(),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }

src/parser/text_markup.rs

@@ -3,11 +3,13 @@ use nom::bytes::complete::tag;
 use nom::character::complete::anychar;
 use nom::character::complete::multispace1;
 use nom::character::complete::one_of;
-use nom::character::complete::space0;
+use nom::character::complete::space1;
 use nom::combinator::all_consuming;
+use nom::combinator::consumed;
 use nom::combinator::map;
 use nom::combinator::map_parser;
 use nom::combinator::not;
+use nom::combinator::opt;
 use nom::combinator::peek;
 use nom::combinator::recognize;
 use nom::combinator::verify;
@@ -76,12 +78,14 @@ fn bold<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Bold<'s>> {
-    let (remaining, children) = text_markup_object("*")(context, input)?;
+    let (remaining, (contents, children, post_blank)) = text_markup_object("*")(context, input)?;
     let source = get_consumed(input, remaining);
     Ok((
         remaining,
         Bold {
             source: source.into(),
+            contents: contents.into(),
+            post_blank: post_blank.map(Into::<&str>::into),
             children,
         },
     ))
@@ -95,12 +99,14 @@ fn italic<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Italic<'s>> {
-    let (remaining, children) = text_markup_object("/")(context, input)?;
+    let (remaining, (contents, children, post_blank)) = text_markup_object("/")(context, input)?;
     let source = get_consumed(input, remaining);
     Ok((
         remaining,
         Italic {
             source: source.into(),
+            contents: contents.into(),
+            post_blank: post_blank.map(Into::<&str>::into),
             children,
         },
     ))
@@ -114,12 +120,14 @@ fn underline<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Underline<'s>> {
-    let (remaining, children) = text_markup_object("_")(context, input)?;
+    let (remaining, (contents, children, post_blank)) = text_markup_object("_")(context, input)?;
     let source = get_consumed(input, remaining);
     Ok((
         remaining,
         Underline {
             source: source.into(),
+            contents: contents.into(),
+            post_blank: post_blank.map(Into::<&str>::into),
             children,
         },
     ))
@@ -133,12 +141,14 @@ fn strike_through<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, StrikeThrough<'s>> {
-    let (remaining, children) = text_markup_object("+")(context, input)?;
+    let (remaining, (contents, children, post_blank)) = text_markup_object("+")(context, input)?;
     let source = get_consumed(input, remaining);
     Ok((
         remaining,
         StrikeThrough {
             source: source.into(),
+            contents: contents.into(),
+            post_blank: post_blank.map(Into::<&str>::into),
             children,
         },
     ))
@@ -152,13 +162,14 @@ fn verbatim<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Verbatim<'s>> {
-    let (remaining, contents) = text_markup_string("=")(context, input)?;
+    let (remaining, (contents, post_blank)) = text_markup_string("=")(context, input)?;
     let source = get_consumed(input, remaining);
     Ok((
         remaining,
         Verbatim {
             source: source.into(),
             contents: contents.into(),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }
@@ -171,13 +182,14 @@ fn code<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Code<'s>> {
-    let (remaining, contents) = text_markup_string("~")(context, input)?;
+    let (remaining, (contents, post_blank)) = text_markup_string("~")(context, input)?;
     let source = get_consumed(input, remaining);
     Ok((
         remaining,
         Code {
             source: source.into(),
             contents: contents.into(),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }
@@ -187,8 +199,10 @@ fn text_markup_object(
 ) -> impl for<'b, 'g, 'r, 's> Fn(
     RefContext<'b, 'g, 'r, 's>,
     OrgSource<'s>,
-) -> Res<OrgSource<'s>, Vec<Object<'s>>>
-       + '_ {
+) -> Res<
+    OrgSource<'s>,
+    (OrgSource<'s>, Vec<Object<'s>>, Option<OrgSource<'s>>),
+> + '_ {
     move |context, input: OrgSource<'_>| _text_markup_object(context, input, marker_symbol)
 }
 
@@ -200,7 +214,7 @@ fn _text_markup_object<'b, 'g, 'r, 's, 'c>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
     marker_symbol: &'c str,
-) -> Res<OrgSource<'s>, Vec<Object<'s>>> {
+) -> Res<OrgSource<'s>, (OrgSource<'s>, Vec<Object<'s>>, Option<OrgSource<'s>>)> {
     let (remaining, _) = pre(context, input)?;
     let (remaining, open) = tag(marker_symbol)(remaining)?;
     let (remaining, _peek_not_whitespace) =
@@ -215,7 +229,7 @@ fn _text_markup_object<'b, 'g, 'r, 's, 'c>(
     let initial_context = ContextElement::document_context();
     let initial_context = Context::new(context.get_global_settings(), List::new(&initial_context));
 
-    let (remaining, children) = map_parser(
+    let (remaining, (contents, children)) = consumed(map_parser(
         verify(
             parser_with_context!(text_until_exit)(&parser_context),
             |text| text.len() > 0,
@@ -225,7 +239,7 @@ fn _text_markup_object<'b, 'g, 'r, 's, 'c>(
                 &initial_context,
             )))(i)
         }),
-    )(remaining)?;
+    ))(remaining)?;
 
     {
         #[cfg(feature = "tracing")]
@@ -240,9 +254,9 @@ fn _text_markup_object<'b, 'g, 'r, 's, 'c>(
     }
 
     let (remaining, _close) = text_markup_end_specialized(context, remaining)?;
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
-    Ok((remaining, children))
+    Ok((remaining, (contents, children, post_blank)))
 }
 
 fn text_markup_string(
@@ -250,7 +264,7 @@ fn text_markup_string(
 ) -> impl for<'b, 'g, 'r, 's> Fn(
     RefContext<'b, 'g, 'r, 's>,
     OrgSource<'s>,
-) -> Res<OrgSource<'s>, OrgSource<'s>>
+) -> Res<OrgSource<'s>, (OrgSource<'s>, Option<OrgSource<'s>>)>
        + '_ {
     move |context, input: OrgSource<'_>| _text_markup_string(context, input, marker_symbol)
 }
@@ -263,7 +277,7 @@ fn _text_markup_string<'b, 'g, 'r, 's, 'c>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
     marker_symbol: &'c str,
-) -> Res<OrgSource<'s>, OrgSource<'s>> {
+) -> Res<OrgSource<'s>, (OrgSource<'s>, Option<OrgSource<'s>>)> {
     let (remaining, _) = pre(context, input)?;
     let (remaining, open) = tag(marker_symbol)(remaining)?;
     let (remaining, _peek_not_whitespace) =
@@ -296,9 +310,9 @@ fn _text_markup_string<'b, 'g, 'r, 's, 'c>(
     }
 
     let (remaining, _close) = text_markup_end_specialized(context, remaining)?;
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
-    Ok((remaining, contents))
+    Ok((remaining, (contents, post_blank)))
 }
 
 #[cfg_attr(
@@ -382,13 +396,15 @@ impl<'x> RematchObject<'x> for Bold<'x> {
         _context: RefContext<'b, 'g, 'r, 's>,
         input: OrgSource<'s>,
     ) -> Res<OrgSource<'s>, Object<'s>> {
-        let (remaining, children) =
+        let (remaining, (contents, children, post_blank)) =
             _rematch_text_markup_object(_context, input, "*", &self.children)?;
         let source = get_consumed(input, remaining);
         Ok((
             remaining,
             Object::Bold(Bold {
                 source: source.into(),
+                contents: contents.into(),
+                post_blank: post_blank.map(Into::<&str>::into),
                 children,
             }),
         ))
@@ -405,13 +421,15 @@ impl<'x> RematchObject<'x> for Italic<'x> {
         _context: RefContext<'b, 'g, 'r, 's>,
         input: OrgSource<'s>,
     ) -> Res<OrgSource<'s>, Object<'s>> {
-        let (remaining, children) =
+        let (remaining, (contents, children, post_blank)) =
             _rematch_text_markup_object(_context, input, "/", &self.children)?;
         let source = get_consumed(input, remaining);
         Ok((
             remaining,
             Object::Italic(Italic {
                 source: source.into(),
+                contents: contents.into(),
+                post_blank: post_blank.map(Into::<&str>::into),
                 children,
             }),
         ))
@@ -428,13 +446,15 @@ impl<'x> RematchObject<'x> for Underline<'x> {
         _context: RefContext<'b, 'g, 'r, 's>,
         input: OrgSource<'s>,
     ) -> Res<OrgSource<'s>, Object<'s>> {
-        let (remaining, children) =
+        let (remaining, (contents, children, post_blank)) =
             _rematch_text_markup_object(_context, input, "_", &self.children)?;
         let source = get_consumed(input, remaining);
         Ok((
             remaining,
             Object::Underline(Underline {
                 source: source.into(),
+                contents: contents.into(),
+                post_blank: post_blank.map(Into::<&str>::into),
                 children,
             }),
         ))
@@ -451,13 +471,15 @@ impl<'x> RematchObject<'x> for StrikeThrough<'x> {
         _context: RefContext<'b, 'g, 'r, 's>,
         input: OrgSource<'s>,
     ) -> Res<OrgSource<'s>, Object<'s>> {
-        let (remaining, children) =
+        let (remaining, (contents, children, post_blank)) =
             _rematch_text_markup_object(_context, input, "+", &self.children)?;
         let source = get_consumed(input, remaining);
         Ok((
             remaining,
             Object::StrikeThrough(StrikeThrough {
                 source: source.into(),
+                contents: contents.into(),
+                post_blank: post_blank.map(Into::<&str>::into),
                 children,
             }),
         ))
@@ -473,7 +495,7 @@ fn _rematch_text_markup_object<'b, 'g, 'r, 's, 'x>(
     input: OrgSource<'s>,
     marker_symbol: &'static str,
     original_match_children: &'x Vec<Object<'x>>,
-) -> Res<OrgSource<'s>, Vec<Object<'s>>> {
+) -> Res<OrgSource<'s>, (OrgSource<'s>, Vec<Object<'s>>, Option<OrgSource<'s>>)> {
     let (remaining, _) = pre(context, input)?;
     let (remaining, open) = tag(marker_symbol)(remaining)?;
     let (remaining, _peek_not_whitespace) = peek(not(multispace1))(remaining)?;
@@ -484,6 +506,7 @@ fn _rematch_text_markup_object<'b, 'g, 'r, 's, 'x>(
     });
     let parser_context = context.with_additional_node(&parser_context);
 
+    let contents_begin = remaining;
     let (remaining, children) =
         // TODO: This doesn't really check the exit matcher between each object. I think it may be possible to construct an org document that parses incorrectly with the current code.
         rematch_target(&parser_context, original_match_children, remaining)?;
@@ -499,8 +522,10 @@ fn _rematch_text_markup_object<'b, 'g, 'r, 's, 'x>(
             )));
         }
     }
+    let contents_end = remaining;
+    let contents = contents_begin.get_until(contents_end);
 
     let (remaining, _close) = text_markup_end_specialized(context, remaining)?;
-    let (remaining, _trailing_whitespace) = space0(remaining)?;
-    Ok((remaining, children))
+    let (remaining, post_blank) = opt(space1)(remaining)?;
+    Ok((remaining, (contents, children, post_blank)))
 }

src/parser/timestamp.rs

@@ -53,8 +53,8 @@ pub(crate) fn timestamp<'b, 'g, 'r, 's>(
         parser_with_context!(inactive_time_range_timestamp)(context),
         parser_with_context!(active_date_range_timestamp)(context),
         parser_with_context!(inactive_date_range_timestamp)(context),
-        parser_with_context!(active_timestamp)(context),
-        parser_with_context!(inactive_timestamp)(context),
+        parser_with_context!(active_timestamp(true))(context),
+        parser_with_context!(inactive_timestamp(true))(context),
     ))(input)
 }
 
@@ -69,7 +69,7 @@ fn diary_timestamp<'b, 'g, 'r, 's>(
     let (remaining, _) = tag("<%%(")(input)?;
     let (remaining, _body) = sexp(context, remaining)?;
     let (remaining, _) = tag(")>")(remaining)?;
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
 
@@ -85,6 +85,7 @@ fn diary_timestamp<'b, 'g, 'r, 's>(
             end_time: None,
             repeater: None,
             warning_delay: None,
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }
@@ -125,13 +126,23 @@ fn sexp_end<'b, 'g, 'r, 's>(
     alt((tag(")>"), recognize(one_of(">\n"))))(input)
 }
 
+const fn active_timestamp(
+    allow_post_blank: bool,
+) -> impl for<'b, 'g, 'r, 's> Fn(
+    RefContext<'b, 'g, 'r, 's>,
+    OrgSource<'s>,
+) -> Res<OrgSource<'s>, Timestamp<'s>> {
+    move |context, input| impl_active_timestamp(context, input, allow_post_blank)
+}
+
 #[cfg_attr(
     feature = "tracing",
     tracing::instrument(ret, level = "debug", skip(context))
 )]
-fn active_timestamp<'b, 'g, 'r, 's>(
+fn impl_active_timestamp<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
+    allow_post_blank: bool,
 ) -> Res<OrgSource<'s>, Timestamp<'s>> {
     let (remaining, _) = tag("<")(input)?;
     let (remaining, start) = date(context, remaining)?;
@@ -159,8 +170,11 @@ fn active_timestamp<'b, 'g, 'r, 's>(
     )))(remaining)?;
     let (remaining, _) = tag(">")(remaining)?;
 
-    let (remaining, _trailing_whitespace) =
-        maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
+    let (remaining, post_blank) = if allow_post_blank {
+        maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?
+    } else {
+        (remaining, None)
+    };
     let source = get_consumed(input, remaining);
 
     Ok((
@@ -175,17 +189,28 @@ fn active_timestamp<'b, 'g, 'r, 's>(
             end_time: time.map(|(_, time)| time),
             repeater: repeater.map(|(_, repeater)| repeater),
             warning_delay: warning_delay.map(|(_, warning_delay)| warning_delay),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }
 
+pub(crate) const fn inactive_timestamp(
+    allow_post_blank: bool,
+) -> impl for<'b, 'g, 'r, 's> Fn(
+    RefContext<'b, 'g, 'r, 's>,
+    OrgSource<'s>,
+) -> Res<OrgSource<'s>, Timestamp<'s>> {
+    move |context, input| impl_inactive_timestamp(context, input, allow_post_blank)
+}
+
 #[cfg_attr(
     feature = "tracing",
     tracing::instrument(ret, level = "debug", skip(context))
 )]
-pub(crate) fn inactive_timestamp<'b, 'g, 'r, 's>(
+fn impl_inactive_timestamp<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
+    allow_post_blank: bool,
 ) -> Res<OrgSource<'s>, Timestamp<'s>> {
     let (remaining, _) = tag("[")(input)?;
     let (remaining, start) = date(context, remaining)?;
@@ -213,8 +238,11 @@ pub(crate) fn inactive_timestamp<'b, 'g, 'r, 's>(
     )))(remaining)?;
     let (remaining, _) = tag("]")(remaining)?;
 
-    let (remaining, _trailing_whitespace) =
-        maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
+    let (remaining, post_blank) = if allow_post_blank {
+        maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?
+    } else {
+        (remaining, None)
+    };
     let source = get_consumed(input, remaining);
 
     Ok((
@@ -229,6 +257,7 @@ pub(crate) fn inactive_timestamp<'b, 'g, 'r, 's>(
             end_time: time.map(|(_, time)| time),
             repeater: repeater.map(|(_, repeater)| repeater),
             warning_delay: warning_delay.map(|(_, warning_delay)| warning_delay),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }
@@ -241,12 +270,12 @@ fn active_date_range_timestamp<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Timestamp<'s>> {
-    let (remaining, first_timestamp) = active_timestamp(context, input)?;
+    let (remaining, first_timestamp) = impl_active_timestamp(context, input, false)?;
     // TODO: Does the space0 at the end of the active/inactive timestamp parsers cause this to be incorrect? I could use a look-behind to make sure the preceding character is not whitespace
     let (remaining, _separator) = tag("--")(remaining)?;
-    let (remaining, second_timestamp) = active_timestamp(context, remaining)?;
+    let (remaining, second_timestamp) = impl_active_timestamp(context, remaining, false)?;
 
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
 
@@ -264,6 +293,7 @@ fn active_date_range_timestamp<'b, 'g, 'r, 's>(
             warning_delay: first_timestamp
                 .warning_delay
                 .or(second_timestamp.warning_delay),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }
@@ -302,7 +332,7 @@ fn active_time_range_timestamp<'b, 'g, 'r, 's>(
     )))(remaining)?;
     let (remaining, _) = tag(">")(remaining)?;
 
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
 
@@ -318,6 +348,7 @@ fn active_time_range_timestamp<'b, 'g, 'r, 's>(
             end_time: Some(second_time),
             repeater: repeater.map(|(_, repeater)| repeater),
             warning_delay: warning_delay.map(|(_, warning_delay)| warning_delay),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }
@@ -330,12 +361,12 @@ pub(crate) fn inactive_date_range_timestamp<'b, 'g, 'r, 's>(
     context: RefContext<'b, 'g, 'r, 's>,
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Timestamp<'s>> {
-    let (remaining, first_timestamp) = inactive_timestamp(context, input)?;
+    let (remaining, first_timestamp) = impl_inactive_timestamp(context, input, false)?;
     // TODO: Does the space0 at the end of the active/inactive timestamp parsers cause this to be incorrect? I could use a look-behind to make sure the preceding character is not whitespace
     let (remaining, _separator) = tag("--")(remaining)?;
-    let (remaining, second_timestamp) = inactive_timestamp(context, remaining)?;
+    let (remaining, second_timestamp) = impl_inactive_timestamp(context, remaining, false)?;
 
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
 
@@ -354,6 +385,7 @@ pub(crate) fn inactive_date_range_timestamp<'b, 'g, 'r, 's>(
             warning_delay: first_timestamp
                 .warning_delay
                 .or(second_timestamp.warning_delay),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }
@@ -392,7 +424,7 @@ pub(crate) fn inactive_time_range_timestamp<'b, 'g, 'r, 's>(
     )))(remaining)?;
     let (remaining, _) = tag("]")(remaining)?;
 
-    let (remaining, _trailing_whitespace) =
+    let (remaining, post_blank) =
         maybe_consume_object_trailing_whitespace_if_not_exiting(context, remaining)?;
     let source = get_consumed(input, remaining);
 
@@ -408,6 +440,7 @@ pub(crate) fn inactive_time_range_timestamp<'b, 'g, 'r, 's>(
             end_time: Some(second_time),
             repeater: repeater.map(|(_, repeater)| repeater),
             warning_delay: warning_delay.map(|(_, warning_delay)| warning_delay),
+            post_blank: post_blank.map(Into::<&str>::into),
         },
     ))
 }

src/parser/util.rs

@@ -81,14 +81,21 @@ pub(crate) fn maybe_consume_object_trailing_whitespace_if_not_exiting<'b, 'g, 'r
     input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Option<OrgSource<'s>>> {
     // We have to check exit matcher after each character because description list tags need to end with a space unconsumed (" ::").
-    let (remaining, _) = many_till(
+    let (remaining, post_blank) = recognize(many_till(
         one_of(" \t"),
         alt((
             peek(recognize(none_of(" \t"))),
             parser_with_context!(exit_matcher_parser)(context),
         )),
-    )(input)?;
-    Ok((remaining, None))
+    ))(input)?;
+    Ok((
+        remaining,
+        if post_blank.len() == 0 {
+            None
+        } else {
+            Some(post_blank)
+        },
+    ))
 }
 
 #[cfg_attr(

src/types/ast_node.rs

@@ -1,7 +1,9 @@
 use super::macros::to_ast_node;
 use super::CenterBlock;
+use super::PostBlank;
 use super::QuoteBlock;
 use super::SpecialBlock;
+use super::StandardProperties;
 use crate::types::AngleLink;
 use crate::types::BabelCall;
 use crate::types::Bold;
@@ -24,7 +26,6 @@ use crate::types::ExportSnippet;
 use crate::types::FixedWidthArea;
 use crate::types::FootnoteDefinition;
 use crate::types::FootnoteReference;
-use crate::types::GetStandardProperties;
 use crate::types::Heading;
 use crate::types::HorizontalRule;
 use crate::types::InlineBabelCall;
@@ -259,67 +260,193 @@ to_ast_node!(&'r Superscript<'s>, AstNode::Superscript);
 to_ast_node!(&'r TableCell<'s>, AstNode::TableCell);
 to_ast_node!(&'r Timestamp<'s>, AstNode::Timestamp);
 
-impl<'r, 's> GetStandardProperties<'s> for AstNode<'r, 's> {
-    fn get_standard_properties<'b>(&'b self) -> &'b dyn crate::types::StandardProperties<'s> {
+impl<'r, 's> StandardProperties<'s> for AstNode<'r, 's> {
+    fn get_source<'b>(&'b self) -> &'s str {
         match self {
-            AstNode::Document(inner) => *inner,
-            AstNode::Heading(inner) => *inner,
-            AstNode::Section(inner) => *inner,
-            AstNode::Paragraph(inner) => *inner,
-            AstNode::PlainList(inner) => *inner,
-            AstNode::PlainListItem(inner) => *inner,
-            AstNode::CenterBlock(inner) => *inner,
-            AstNode::QuoteBlock(inner) => *inner,
-            AstNode::SpecialBlock(inner) => *inner,
-            AstNode::DynamicBlock(inner) => *inner,
-            AstNode::FootnoteDefinition(inner) => *inner,
-            AstNode::Comment(inner) => *inner,
-            AstNode::Drawer(inner) => *inner,
-            AstNode::PropertyDrawer(inner) => *inner,
-            AstNode::NodeProperty(inner) => *inner,
-            AstNode::Table(inner) => *inner,
-            AstNode::TableRow(inner) => *inner,
-            AstNode::VerseBlock(inner) => *inner,
-            AstNode::CommentBlock(inner) => *inner,
-            AstNode::ExampleBlock(inner) => *inner,
-            AstNode::ExportBlock(inner) => *inner,
-            AstNode::SrcBlock(inner) => *inner,
-            AstNode::Clock(inner) => *inner,
-            AstNode::DiarySexp(inner) => *inner,
-            AstNode::Planning(inner) => *inner,
-            AstNode::FixedWidthArea(inner) => *inner,
-            AstNode::HorizontalRule(inner) => *inner,
-            AstNode::Keyword(inner) => *inner,
-            AstNode::BabelCall(inner) => *inner,
-            AstNode::LatexEnvironment(inner) => *inner,
-            AstNode::Bold(inner) => *inner,
-            AstNode::Italic(inner) => *inner,
-            AstNode::Underline(inner) => *inner,
-            AstNode::StrikeThrough(inner) => *inner,
-            AstNode::Code(inner) => *inner,
-            AstNode::Verbatim(inner) => *inner,
-            AstNode::PlainText(inner) => *inner,
-            AstNode::RegularLink(inner) => *inner,
-            AstNode::RadioLink(inner) => *inner,
-            AstNode::RadioTarget(inner) => *inner,
-            AstNode::PlainLink(inner) => *inner,
-            AstNode::AngleLink(inner) => *inner,
-            AstNode::OrgMacro(inner) => *inner,
-            AstNode::Entity(inner) => *inner,
-            AstNode::LatexFragment(inner) => *inner,
-            AstNode::ExportSnippet(inner) => *inner,
-            AstNode::FootnoteReference(inner) => *inner,
-            AstNode::Citation(inner) => *inner,
-            AstNode::CitationReference(inner) => *inner,
-            AstNode::InlineBabelCall(inner) => *inner,
-            AstNode::InlineSourceBlock(inner) => *inner,
-            AstNode::LineBreak(inner) => *inner,
-            AstNode::Target(inner) => *inner,
-            AstNode::StatisticsCookie(inner) => *inner,
-            AstNode::Subscript(inner) => *inner,
-            AstNode::Superscript(inner) => *inner,
-            AstNode::TableCell(inner) => *inner,
-            AstNode::Timestamp(inner) => *inner,
+            AstNode::Document(inner) => inner.get_source(),
+            AstNode::Heading(inner) => inner.get_source(),
+            AstNode::Section(inner) => inner.get_source(),
+            AstNode::Paragraph(inner) => inner.get_source(),
+            AstNode::PlainList(inner) => inner.get_source(),
+            AstNode::PlainListItem(inner) => inner.get_source(),
+            AstNode::CenterBlock(inner) => inner.get_source(),
+            AstNode::QuoteBlock(inner) => inner.get_source(),
+            AstNode::SpecialBlock(inner) => inner.get_source(),
+            AstNode::DynamicBlock(inner) => inner.get_source(),
+            AstNode::FootnoteDefinition(inner) => inner.get_source(),
+            AstNode::Comment(inner) => inner.get_source(),
+            AstNode::Drawer(inner) => inner.get_source(),
+            AstNode::PropertyDrawer(inner) => inner.get_source(),
+            AstNode::NodeProperty(inner) => inner.get_source(),
+            AstNode::Table(inner) => inner.get_source(),
+            AstNode::TableRow(inner) => inner.get_source(),
+            AstNode::VerseBlock(inner) => inner.get_source(),
+            AstNode::CommentBlock(inner) => inner.get_source(),
+            AstNode::ExampleBlock(inner) => inner.get_source(),
+            AstNode::ExportBlock(inner) => inner.get_source(),
+            AstNode::SrcBlock(inner) => inner.get_source(),
+            AstNode::Clock(inner) => inner.get_source(),
+            AstNode::DiarySexp(inner) => inner.get_source(),
+            AstNode::Planning(inner) => inner.get_source(),
+            AstNode::FixedWidthArea(inner) => inner.get_source(),
+            AstNode::HorizontalRule(inner) => inner.get_source(),
+            AstNode::Keyword(inner) => inner.get_source(),
+            AstNode::BabelCall(inner) => inner.get_source(),
+            AstNode::LatexEnvironment(inner) => inner.get_source(),
+            AstNode::Bold(inner) => inner.get_source(),
+            AstNode::Italic(inner) => inner.get_source(),
+            AstNode::Underline(inner) => inner.get_source(),
+            AstNode::StrikeThrough(inner) => inner.get_source(),
+            AstNode::Code(inner) => inner.get_source(),
+            AstNode::Verbatim(inner) => inner.get_source(),
+            AstNode::PlainText(inner) => inner.get_source(),
+            AstNode::RegularLink(inner) => inner.get_source(),
+            AstNode::RadioLink(inner) => inner.get_source(),
+            AstNode::RadioTarget(inner) => inner.get_source(),
+            AstNode::PlainLink(inner) => inner.get_source(),
+            AstNode::AngleLink(inner) => inner.get_source(),
+            AstNode::OrgMacro(inner) => inner.get_source(),
+            AstNode::Entity(inner) => inner.get_source(),
+            AstNode::LatexFragment(inner) => inner.get_source(),
+            AstNode::ExportSnippet(inner) => inner.get_source(),
+            AstNode::FootnoteReference(inner) => inner.get_source(),
+            AstNode::Citation(inner) => inner.get_source(),
+            AstNode::CitationReference(inner) => inner.get_source(),
+            AstNode::InlineBabelCall(inner) => inner.get_source(),
+            AstNode::InlineSourceBlock(inner) => inner.get_source(),
+            AstNode::LineBreak(inner) => inner.get_source(),
+            AstNode::Target(inner) => inner.get_source(),
+            AstNode::StatisticsCookie(inner) => inner.get_source(),
+            AstNode::Subscript(inner) => inner.get_source(),
+            AstNode::Superscript(inner) => inner.get_source(),
+            AstNode::TableCell(inner) => inner.get_source(),
+            AstNode::Timestamp(inner) => inner.get_source(),
+        }
+    }
+
+    fn get_contents<'b>(&'b self) -> Option<&'s str> {
+        match self {
+            AstNode::Document(inner) => inner.get_contents(),
+            AstNode::Heading(inner) => inner.get_contents(),
+            AstNode::Section(inner) => inner.get_contents(),
+            AstNode::Paragraph(inner) => inner.get_contents(),
+            AstNode::PlainList(inner) => inner.get_contents(),
+            AstNode::PlainListItem(inner) => inner.get_contents(),
+            AstNode::CenterBlock(inner) => inner.get_contents(),
+            AstNode::QuoteBlock(inner) => inner.get_contents(),
+            AstNode::SpecialBlock(inner) => inner.get_contents(),
+            AstNode::DynamicBlock(inner) => inner.get_contents(),
+            AstNode::FootnoteDefinition(inner) => inner.get_contents(),
+            AstNode::Comment(inner) => inner.get_contents(),
+            AstNode::Drawer(inner) => inner.get_contents(),
+            AstNode::PropertyDrawer(inner) => inner.get_contents(),
+            AstNode::NodeProperty(inner) => inner.get_contents(),
+            AstNode::Table(inner) => inner.get_contents(),
+            AstNode::TableRow(inner) => inner.get_contents(),
+            AstNode::VerseBlock(inner) => inner.get_contents(),
+            AstNode::CommentBlock(inner) => inner.get_contents(),
+            AstNode::ExampleBlock(inner) => inner.get_contents(),
+            AstNode::ExportBlock(inner) => inner.get_contents(),
+            AstNode::SrcBlock(inner) => inner.get_contents(),
+            AstNode::Clock(inner) => inner.get_contents(),
+            AstNode::DiarySexp(inner) => inner.get_contents(),
+            AstNode::Planning(inner) => inner.get_contents(),
+            AstNode::FixedWidthArea(inner) => inner.get_contents(),
+            AstNode::HorizontalRule(inner) => inner.get_contents(),
+            AstNode::Keyword(inner) => inner.get_contents(),
+            AstNode::BabelCall(inner) => inner.get_contents(),
+            AstNode::LatexEnvironment(inner) => inner.get_contents(),
+            AstNode::Bold(inner) => inner.get_contents(),
+            AstNode::Italic(inner) => inner.get_contents(),
+            AstNode::Underline(inner) => inner.get_contents(),
+            AstNode::StrikeThrough(inner) => inner.get_contents(),
+            AstNode::Code(inner) => inner.get_contents(),
+            AstNode::Verbatim(inner) => inner.get_contents(),
+            AstNode::PlainText(inner) => inner.get_contents(),
+            AstNode::RegularLink(inner) => inner.get_contents(),
+            AstNode::RadioLink(inner) => inner.get_contents(),
+            AstNode::RadioTarget(inner) => inner.get_contents(),
+            AstNode::PlainLink(inner) => inner.get_contents(),
+            AstNode::AngleLink(inner) => inner.get_contents(),
+            AstNode::OrgMacro(inner) => inner.get_contents(),
+            AstNode::Entity(inner) => inner.get_contents(),
+            AstNode::LatexFragment(inner) => inner.get_contents(),
+            AstNode::ExportSnippet(inner) => inner.get_contents(),
+            AstNode::FootnoteReference(inner) => inner.get_contents(),
+            AstNode::Citation(inner) => inner.get_contents(),
+            AstNode::CitationReference(inner) => inner.get_contents(),
+            AstNode::InlineBabelCall(inner) => inner.get_contents(),
+            AstNode::InlineSourceBlock(inner) => inner.get_contents(),
+            AstNode::LineBreak(inner) => inner.get_contents(),
+            AstNode::Target(inner) => inner.get_contents(),
+            AstNode::StatisticsCookie(inner) => inner.get_contents(),
+            AstNode::Subscript(inner) => inner.get_contents(),
+            AstNode::Superscript(inner) => inner.get_contents(),
+            AstNode::TableCell(inner) => inner.get_contents(),
+            AstNode::Timestamp(inner) => inner.get_contents(),
+        }
+    }
+
+    fn get_post_blank(&self) -> PostBlank {
+        match self {
+            AstNode::Document(inner) => inner.get_post_blank(),
+            AstNode::Heading(inner) => inner.get_post_blank(),
+            AstNode::Section(inner) => inner.get_post_blank(),
+            AstNode::Paragraph(inner) => inner.get_post_blank(),
+            AstNode::PlainList(inner) => inner.get_post_blank(),
+            AstNode::PlainListItem(inner) => inner.get_post_blank(),
+            AstNode::CenterBlock(inner) => inner.get_post_blank(),
+            AstNode::QuoteBlock(inner) => inner.get_post_blank(),
+            AstNode::SpecialBlock(inner) => inner.get_post_blank(),
+            AstNode::DynamicBlock(inner) => inner.get_post_blank(),
+            AstNode::FootnoteDefinition(inner) => inner.get_post_blank(),
+            AstNode::Comment(inner) => inner.get_post_blank(),
+            AstNode::Drawer(inner) => inner.get_post_blank(),
+            AstNode::PropertyDrawer(inner) => inner.get_post_blank(),
+            AstNode::NodeProperty(inner) => inner.get_post_blank(),
+            AstNode::Table(inner) => inner.get_post_blank(),
+            AstNode::TableRow(inner) => inner.get_post_blank(),
+            AstNode::VerseBlock(inner) => inner.get_post_blank(),
+            AstNode::CommentBlock(inner) => inner.get_post_blank(),
+            AstNode::ExampleBlock(inner) => inner.get_post_blank(),
+            AstNode::ExportBlock(inner) => inner.get_post_blank(),
+            AstNode::SrcBlock(inner) => inner.get_post_blank(),
+            AstNode::Clock(inner) => inner.get_post_blank(),
+            AstNode::DiarySexp(inner) => inner.get_post_blank(),
+            AstNode::Planning(inner) => inner.get_post_blank(),
+            AstNode::FixedWidthArea(inner) => inner.get_post_blank(),
+            AstNode::HorizontalRule(inner) => inner.get_post_blank(),
+            AstNode::Keyword(inner) => inner.get_post_blank(),
+            AstNode::BabelCall(inner) => inner.get_post_blank(),
+            AstNode::LatexEnvironment(inner) => inner.get_post_blank(),
+            AstNode::Bold(inner) => inner.get_post_blank(),
+            AstNode::Italic(inner) => inner.get_post_blank(),
+            AstNode::Underline(inner) => inner.get_post_blank(),
+            AstNode::StrikeThrough(inner) => inner.get_post_blank(),
+            AstNode::Code(inner) => inner.get_post_blank(),
+            AstNode::Verbatim(inner) => inner.get_post_blank(),
+            AstNode::PlainText(inner) => inner.get_post_blank(),
+            AstNode::RegularLink(inner) => inner.get_post_blank(),
+            AstNode::RadioLink(inner) => inner.get_post_blank(),
+            AstNode::RadioTarget(inner) => inner.get_post_blank(),
+            AstNode::PlainLink(inner) => inner.get_post_blank(),
+            AstNode::AngleLink(inner) => inner.get_post_blank(),
+            AstNode::OrgMacro(inner) => inner.get_post_blank(),
+            AstNode::Entity(inner) => inner.get_post_blank(),
+            AstNode::LatexFragment(inner) => inner.get_post_blank(),
+            AstNode::ExportSnippet(inner) => inner.get_post_blank(),
+            AstNode::FootnoteReference(inner) => inner.get_post_blank(),
+            AstNode::Citation(inner) => inner.get_post_blank(),
+            AstNode::CitationReference(inner) => inner.get_post_blank(),
+            AstNode::InlineBabelCall(inner) => inner.get_post_blank(),
+            AstNode::InlineSourceBlock(inner) => inner.get_post_blank(),
+            AstNode::LineBreak(inner) => inner.get_post_blank(),
+            AstNode::Target(inner) => inner.get_post_blank(),
+            AstNode::StatisticsCookie(inner) => inner.get_post_blank(),
+            AstNode::Subscript(inner) => inner.get_post_blank(),
+            AstNode::Superscript(inner) => inner.get_post_blank(),
+            AstNode::TableCell(inner) => inner.get_post_blank(),
+            AstNode::Timestamp(inner) => inner.get_post_blank(),
         }
     }
 }

src/types/document.rs

@@ -1,9 +1,9 @@
 use std::path::PathBuf;
 
 use super::Element;
-use super::GetStandardProperties;
 use super::NodeProperty;
 use super::Object;
+use super::PostBlank;
 use super::StandardProperties;
 use super::Timestamp;
 
@@ -17,6 +17,7 @@ pub struct Document<'s> {
     pub path: Option<PathBuf>,
     pub zeroth_section: Option<Section<'s>>,
     pub children: Vec<Heading<'s>>,
+    pub contents: &'s str,
 }
 
 #[derive(Debug)]
@@ -34,15 +35,19 @@ pub struct Heading<'s> {
     pub scheduled: Option<Timestamp<'s>>,
     pub deadline: Option<Timestamp<'s>>,
     pub closed: Option<Timestamp<'s>>,
+    pub contents: Option<&'s str>,
+    pub post_blank: Option<&'s str>,
 }
 
 #[derive(Debug)]
 pub struct Section<'s> {
     pub source: &'s str,
+    pub post_blank: Option<&'s str>,
     pub children: Vec<Element<'s>>,
 }
 
 #[derive(Debug)]
+#[allow(clippy::large_enum_variant)]
 pub enum DocumentElement<'s> {
     Heading(Heading<'s>),
     Section(Section<'s>),
@@ -54,41 +59,60 @@ pub enum TodoKeywordType {
     Done,
 }
 
-impl<'s> GetStandardProperties<'s> for DocumentElement<'s> {
-    fn get_standard_properties<'b>(&'b self) -> &'b dyn StandardProperties<'s> {
-        match self {
-            DocumentElement::Heading(inner) => inner,
-            DocumentElement::Section(inner) => inner,
-        }
-    }
-}
-
 impl<'s> StandardProperties<'s> for Document<'s> {
     fn get_source<'b>(&'b self) -> &'s str {
         self.source
     }
+
+    fn get_contents<'b>(&'b self) -> Option<&'s str> {
+        Some(self.contents)
+    }
+
+    fn get_post_blank(&self) -> PostBlank {
+        0
+    }
 }
 
 impl<'s> StandardProperties<'s> for Section<'s> {
     fn get_source<'b>(&'b self) -> &'s str {
         self.source
     }
+
+    fn get_contents<'b>(&'b self) -> Option<&'s str> {
+        Some(self.source)
+    }
+
+    fn get_post_blank(&self) -> PostBlank {
+        self.post_blank
+            .map(|text| text.lines().count())
+            .unwrap_or(0)
+            .try_into()
+            .expect("Too much post-blank to fit into a PostBlank.")
+    }
 }
 
 impl<'s> StandardProperties<'s> for Heading<'s> {
     fn get_source<'b>(&'b self) -> &'s str {
         self.source
     }
+
+    fn get_contents<'b>(&'b self) -> Option<&'s str> {
+        self.contents
+    }
+
+    fn get_post_blank(&self) -> PostBlank {
+        self.post_blank
+            .map(|text| text.lines().count())
+            .unwrap_or(0)
+            .try_into()
+            .expect("Too much post-blank to fit into a PostBlank.")
+    }
 }
 
 impl<'s> Heading<'s> {
     pub fn get_raw_value(&self) -> String {
         // TODO: I think this could just return a string slice instead of an owned string.
-        let title_source: String = self
-            .title
-            .iter()
-            .map(|obj| obj.get_standard_properties().get_source())
-            .collect();
+        let title_source: String = self.title.iter().map(|obj| obj.get_source()).collect();
         title_source
     }
 
@@ -132,3 +156,26 @@ impl<'s> Document<'s> {
             .flat_map(|property_drawer| property_drawer.children.iter())
     }
 }
+
+impl<'s> StandardProperties<'s> for DocumentElement<'s> {
+    fn get_source<'b>(&'b self) -> &'s str {
+        match self {
+            DocumentElement::Heading(inner) => inner.get_source(),
+            DocumentElement::Section(inner) => inner.get_source(),
+        }
+    }
+
+    fn get_contents<'b>(&'b self) -> Option<&'s str> {
+        match self {
+            DocumentElement::Heading(inner) => inner.get_contents(),
+            DocumentElement::Section(inner) => inner.get_contents(),
+        }
+    }
+
+    fn get_post_blank(&self) -> PostBlank {
+        match self {
+            DocumentElement::Heading(inner) => inner.get_post_blank(),
+            DocumentElement::Section(inner) => inner.get_post_blank(),
+        }
+    }
+}

src/types/element.rs

@@ -20,7 +20,7 @@ use super::lesser_element::SrcBlock;
 use super::lesser_element::VerseBlock;
 use super::CenterBlock;
 use super::Drawer;
-use super::GetStandardProperties;
+use super::PostBlank;
 use super::QuoteBlock;
 use super::SpecialBlock;
 use super::StandardProperties;
@@ -54,33 +54,91 @@ pub enum Element<'s> {
     LatexEnvironment(LatexEnvironment<'s>),
 }
 
-impl<'s> GetStandardProperties<'s> for Element<'s> {
-    fn get_standard_properties<'b>(&'b self) -> &'b dyn StandardProperties<'s> {
+impl<'s> StandardProperties<'s> for Element<'s> {
+    fn get_source<'b>(&'b self) -> &'s str {
         match self {
-            Element::Paragraph(inner) => inner,
-            Element::PlainList(inner) => inner,
-            Element::CenterBlock(inner) => inner,
-            Element::QuoteBlock(inner) => inner,
-            Element::SpecialBlock(inner) => inner,
-            Element::DynamicBlock(inner) => inner,
-            Element::FootnoteDefinition(inner) => inner,
-            Element::Comment(inner) => inner,
-            Element::Drawer(inner) => inner,
-            Element::PropertyDrawer(inner) => inner,
-            Element::Table(inner) => inner,
-            Element::VerseBlock(inner) => inner,
-            Element::CommentBlock(inner) => inner,
-            Element::ExampleBlock(inner) => inner,
-            Element::ExportBlock(inner) => inner,
-            Element::SrcBlock(inner) => inner,
-            Element::Clock(inner) => inner,
-            Element::DiarySexp(inner) => inner,
-            Element::Planning(inner) => inner,
-            Element::FixedWidthArea(inner) => inner,
-            Element::HorizontalRule(inner) => inner,
-            Element::Keyword(inner) => inner,
-            Element::BabelCall(inner) => inner,
-            Element::LatexEnvironment(inner) => inner,
+            Element::Paragraph(inner) => inner.get_source(),
+            Element::PlainList(inner) => inner.get_source(),
+            Element::CenterBlock(inner) => inner.get_source(),
+            Element::QuoteBlock(inner) => inner.get_source(),
+            Element::SpecialBlock(inner) => inner.get_source(),
+            Element::DynamicBlock(inner) => inner.get_source(),
+            Element::FootnoteDefinition(inner) => inner.get_source(),
+            Element::Comment(inner) => inner.get_source(),
+            Element::Drawer(inner) => inner.get_source(),
+            Element::PropertyDrawer(inner) => inner.get_source(),
+            Element::Table(inner) => inner.get_source(),
+            Element::VerseBlock(inner) => inner.get_source(),
+            Element::CommentBlock(inner) => inner.get_source(),
+            Element::ExampleBlock(inner) => inner.get_source(),
+            Element::ExportBlock(inner) => inner.get_source(),
+            Element::SrcBlock(inner) => inner.get_source(),
+            Element::Clock(inner) => inner.get_source(),
+            Element::DiarySexp(inner) => inner.get_source(),
+            Element::Planning(inner) => inner.get_source(),
+            Element::FixedWidthArea(inner) => inner.get_source(),
+            Element::HorizontalRule(inner) => inner.get_source(),
+            Element::Keyword(inner) => inner.get_source(),
+            Element::BabelCall(inner) => inner.get_source(),
+            Element::LatexEnvironment(inner) => inner.get_source(),
+        }
+    }
+
+    fn get_contents<'b>(&'b self) -> Option<&'s str> {
+        match self {
+            Element::Paragraph(inner) => inner.get_contents(),
+            Element::PlainList(inner) => inner.get_contents(),
+            Element::CenterBlock(inner) => inner.get_contents(),
+            Element::QuoteBlock(inner) => inner.get_contents(),
+            Element::SpecialBlock(inner) => inner.get_contents(),
+            Element::DynamicBlock(inner) => inner.get_contents(),
+            Element::FootnoteDefinition(inner) => inner.get_contents(),
+            Element::Comment(inner) => inner.get_contents(),
+            Element::Drawer(inner) => inner.get_contents(),
+            Element::PropertyDrawer(inner) => inner.get_contents(),
+            Element::Table(inner) => inner.get_contents(),
+            Element::VerseBlock(inner) => inner.get_contents(),
+            Element::CommentBlock(inner) => inner.get_contents(),
+            Element::ExampleBlock(inner) => inner.get_contents(),
+            Element::ExportBlock(inner) => inner.get_contents(),
+            Element::SrcBlock(inner) => inner.get_contents(),
+            Element::Clock(inner) => inner.get_contents(),
+            Element::DiarySexp(inner) => inner.get_contents(),
+            Element::Planning(inner) => inner.get_contents(),
+            Element::FixedWidthArea(inner) => inner.get_contents(),
+            Element::HorizontalRule(inner) => inner.get_contents(),
+            Element::Keyword(inner) => inner.get_contents(),
+            Element::BabelCall(inner) => inner.get_contents(),
+            Element::LatexEnvironment(inner) => inner.get_contents(),
+        }
+    }
+
+    fn get_post_blank(&self) -> PostBlank {
+        match self {
+            Element::Paragraph(inner) => inner.get_post_blank(),
+            Element::PlainList(inner) => inner.get_post_blank(),
+            Element::CenterBlock(inner) => inner.get_post_blank(),
+            Element::QuoteBlock(inner) => inner.get_post_blank(),
+            Element::SpecialBlock(inner) => inner.get_post_blank(),
+            Element::DynamicBlock(inner) => inner.get_post_blank(),
+            Element::FootnoteDefinition(inner) => inner.get_post_blank(),
+            Element::Comment(inner) => inner.get_post_blank(),
+            Element::Drawer(inner) => inner.get_post_blank(),
+            Element::PropertyDrawer(inner) => inner.get_post_blank(),
+            Element::Table(inner) => inner.get_post_blank(),
+            Element::VerseBlock(inner) => inner.get_post_blank(),
+            Element::CommentBlock(inner) => inner.get_post_blank(),
+            Element::ExampleBlock(inner) => inner.get_post_blank(),
+            Element::ExportBlock(inner) => inner.get_post_blank(),
+            Element::SrcBlock(inner) => inner.get_post_blank(),
+            Element::Clock(inner) => inner.get_post_blank(),
+            Element::DiarySexp(inner) => inner.get_post_blank(),
+            Element::Planning(inner) => inner.get_post_blank(),
+            Element::FixedWidthArea(inner) => inner.get_post_blank(),
+            Element::HorizontalRule(inner) => inner.get_post_blank(),
+            Element::Keyword(inner) => inner.get_post_blank(),
+            Element::BabelCall(inner) => inner.get_post_blank(),
+            Element::LatexEnvironment(inner) => inner.get_post_blank(),
         }
     }
 }

src/types/get_standard_properties.rs

@@ -1,12 +0,0 @@
-use super::StandardProperties;
-
-pub trait GetStandardProperties<'s> {
-    // TODO: Can I eliminate this dynamic dispatch, perhaps using nominal generic structs? Low prioritiy since this is not used during parsing.
-    fn get_standard_properties<'b>(&'b self) -> &'b dyn StandardProperties<'s>;
-}
-
-impl<'s, I: StandardProperties<'s>> GetStandardProperties<'s> for I {
-    fn get_standard_properties<'b>(&'b self) -> &'b dyn StandardProperties<'s> {
-        self
-    }
-}