Remove setup page and include that code in each example instead

Author: crandmck

docs/tasks/includes/_cpp-build.md

@@ -1,29 +1,43 @@
 This is an example of how to assign a manifest to an asset and sign the claim using C++:
 
 ```cpp
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <vector>
+#include <stdexcept>
+#include <openssl/evp.h>
+#include <openssl/pem.h>
+#include <openssl/err.h>
+#include "c2pa.hpp"
+#include "test_signer.hpp"
+
+using namespace std;
+namespace fs = std::filesystem;
+using namespace c2pa;
+
 const std::string manifest_json = R"{
     "claim_generator": "c2pa_c_test/0.1",
     "claim_generator_info": [
       {
-        "name": "c2pa-c test",
+        "name": "c2pa-c example",
         "version": "0.1"
       }
     ],
     "assertions": [
     {
-      "label": "c2pa.training-mining",
+      "label": "cawg.training-mining",
       "data": {
         "entries": {
-          "c2pa.ai_generative_training": { "use": "notAllowed" },
-          "c2pa.ai_inference": { "use": "notAllowed" },
-          "c2pa.ai_training": { "use": "notAllowed" },
-          "c2pa.data_mining": { "use": "notAllowed" }
+          "cawg.ai_generative_training": { "use": "notAllowed" },
+          "cawg.ai_inference": { "use": "notAllowed" },
+          "cawg.ai_training": { "use": "notAllowed" },
+          "cawg.data_mining": { "use": "notAllowed" }
         }
       }
     }
   ]
  };
 
 auto builder = Builder(manifest_json);
-
 ```

docs/tasks/includes/_cpp-get-resources.md

@@ -1,6 +1,24 @@
 This is how to get resources from a manifest using C++.
 
 ```cpp
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <vector>
+#include <stdexcept>
+#include <openssl/evp.h>
+#include <openssl/pem.h>
+#include <openssl/err.h>
+#include "c2pa.hpp"
+#include "test_signer.hpp"
+#include <nlohmann/json.hpp>
+
+// this example uses nlohmann json for parsing the manifest
+using json = nlohmann::json;
+using namespace std;
+namespace fs = std::filesystem;
+using namespace c2pa;
+
 string read_text_file(const fs::path &path)
 {
     ifstream file(path);
@@ -23,19 +41,6 @@ int main()
 
   try
       {
-          // load the manifest, certs, and private key
-      /* Commenting out, because not part of resource reading
-          string manifest_json = read_text_file(manifest_path).data();
-
-          string certs = read_text_file(certs_path).data();
-
-          // create a signer
-          Signer signer = Signer(&test_signer, Es256, certs, "http://timestamp.digicert.com");
-
-          auto builder = Builder(manifest_json);
-          auto manifest_data = builder.sign(image_path, output_path, signer);
-      */
-
           // read the new manifest and display the JSON
           auto reader = Reader(output_path);
 
@@ -56,14 +61,17 @@ int main()
               cout << "thumbnail written to" << thumbnail_path << endl;
           }
       }
+      
       catch (c2pa::Exception const &e)
       {
           cout << "C2PA Error: " << e.what() << endl;
       }
+
       catch (runtime_error const &e)
       {
           cout << "setup error" << e.what() << endl;
       }
+
       catch (json::parse_error const &e)
       {
           cout << "parse error " << e.what() << endl;

docs/tasks/includes/_cpp-read.md

@@ -2,16 +2,25 @@
 Use the `read_file` function to read C2PA data from the specified file. This function examines the specified asset file for C2PA data and returns a JSON report if it finds any; it throws exceptions on errors. If there are validation errors, the report includes a `validation_status` field.
 
 ```cpp
-auto json_store = C2pa::read_file("<ASSET_FILE>", "<DATA_DIR>")
-```
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <vector>
+#include <stdexcept>
+#include <openssl/evp.h>
+#include <openssl/pem.h>
+#include <openssl/err.h>
+#include "c2pa.hpp"
+#include "test_signer.hpp"
 
-Where:
+using namespace std;
+namespace fs = std::filesystem;
+using namespace c2pa;
 
-- `<ASSET_FILE>`- The asset file to read.
-- `<DATA_DIR>` - Optional path to data output directory; If provided, the function extracts any binary resources, such as thumbnails, icons, and C2PA data into that directory. These files are referenced by the identifier fields in the manifest store report.
+auto json_store = C2pa::read_file("work/media_file.jpg", "output/data_dir")
+```
 
-For example:
+Where:
 
-```cpp
-auto json_store = C2pa::read_file("work/media_file.jpg", "output/data_dir")
-```
+- `work/media_file.jpg` is the asset file to read.
+- `output/data_dir` is the optional path to data output directory; If provided, the function extracts any binary resources, such as thumbnails, icons, and C2PA data into that directory. These files are referenced by the identifier fields in the manifest store report.

docs/tasks/includes/_js-get-resources.md

@@ -5,15 +5,25 @@ That JavaScript library is being extensively revised so the APIs used here may c
 The example below shows how to get resources from manifest data using the JavaScript library.
 
 ```js
+const version = '0.27.1';
+const sampleImage = 'my_image.jpg'
+
 import { createC2pa, selectProducer } from 'c2pa';
 import wasmSrc from 'c2pa/dist/assets/wasm/toolkit_bg.wasm?url';
 import workerSrc from 'c2pa/dist/c2pa.worker.js?url';
 import { parseISO } from 'date-fns';
-
-const sampleImage =
-  'https://raw.githubusercontent.com/contentauth/c2pa-js/main/tools/testing/fixtures/images/CAICAI.jpg';
+import { createC2pa } from 'https://cdn.jsdelivr.net/npm/c2pa@${version}/+esm';
 
 (async () => {
+  // Initialize the c2pa-js SDK
+  const c2pa = await createC2pa({
+    wasmSrc:
+      'https://cdn.jsdelivr.net/npm/c2pa@${version}/dist/assets/wasm/toolkit_bg.wasm',
+    workerSrc:
+      'https://cdn.jsdelivr.net/npm/c2pa@${version}/dist/c2pa.worker.min.js',
+  });
+
+  
   let output: string[] = [];
 
   const c2pa = await createC2pa({
@@ -54,6 +64,7 @@ const sampleImage =
         </tr>
       `;
     });
+
   } else {
     output.push(`
       <tr>
@@ -63,5 +74,33 @@ const sampleImage =
   }
 
   document.querySelector('#results tbody')!.innerHTML = output.join('');
+  
 })();
+```
+
+With an HTML page like this:
+
+```html
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="../../favicon.svg" />
+    <link rel="stylesheet" href="../../styles.css" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>active-manifest</title>
+  </head>
+  <body>
+    <table id="results">
+      <thead>
+        <th>Property</th>
+        <th>Value</th>
+      </thead>
+      <tbody>
+        <td colspan="3">Loading&hellip;</td>
+      </tbody>
+    </table>
+    <script type="module" src="./main.ts"></script>
+  </body>
+</html>
 ```

docs/tasks/includes/_js-read.md

@@ -9,6 +9,20 @@ Use [`c2pa.read`](../../docs/js-sdk/api/c2pa.c2pa#methods) to read manifest data
 - **validationStatus**: A list of any validation errors encountered. See [Validation](../../docs/js-sdk/guides/validation) for more information.
 
 ```js
+const version = '0.30.14';
+const sampleImage = '<IMAGE_URL>';
+
+import { createC2pa } from 'https://cdn.jsdelivr.net/npm/c2pa@${version}/+esm';
+
+(async () => {
+  // Initialize the c2pa-js SDK
+  const c2pa = await createC2pa({
+    wasmSrc:
+      'https://cdn.jsdelivr.net/npm/c2pa@${version}/dist/assets/wasm/toolkit_bg.wasm',
+    workerSrc:
+      'https://cdn.jsdelivr.net/npm/c2pa@${version}/dist/c2pa.worker.min.js',
+  });
+
   try {
     // Read in image and get a manifest store
     const { manifestStore } = await c2pa.read(sampleImage);
@@ -21,4 +35,4 @@ Use [`c2pa.read`](../../docs/js-sdk/api/c2pa.c2pa#methods) to read manifest data
     console.error('Error reading image:', err);
   }
 })();
-```
+```

docs/tasks/includes/_python-build.md

@@ -4,6 +4,16 @@ This is an example of how to assign a manifest to an asset and sign the claim us
 Use a `Builder` object to add a manifest to an asset.
 
 ```python
+# Import the C2PA Python package.
+from c2pa import *
+
+# Import standard general-purpose packages.
+import os
+import io
+import logging
+import json
+import base64
+
 try:
   # Define a function to sign the claim bytes.
   # In this case we are using a pre-defined sign_ps256 method, passing in our private cert.

docs/tasks/includes/_python-get-resources.md

@@ -6,6 +6,15 @@ Retrieve binary resources such as thumbnails from the manifest data, use the `re
 _NOTE: Need to add example of using `reader.resource_to_stream()`._
 
 ```py
+# Import the C2PA Python package.
+from c2pa import *
+
+# Import standard general-purpose packages.
+import os
+import io
+import logging
+import json
+
 try:
   # Create a reader from a file path.
   reader = c2pa.Reader.from_file("path/to/media_file.jpg")

docs/tasks/includes/_python-read.md

@@ -6,6 +6,15 @@ Use the `json()` method to return a JSON manifest report; If there are validatio
 An asset file may contain many manifests in a manifest store. The most recent manifest is identified by the value of the `active_manifest` field in the manifests map.
 
 ```py
+# Import the C2PA Python package.
+from c2pa import *
+
+# Import standard general-purpose packages.
+import os
+import io
+import logging
+import json
+
 try:
   # Create a reader from a file path.
   reader = c2pa.Reader.from_file("path/to/media_file.jpg")

docs/tasks/includes/_rust-build.md

@@ -3,9 +3,18 @@ This is an example of how to assign a manifest to an asset and sign the claim us
 This example is from [`c2pa-rs/sdk/examples/v2api.rs`](https://github.com/contentauth/c2pa-rs/blob/main/sdk/examples/v2api.rs#L88C5-L134C1):
 
 ```rust
-let json = manifest_def(title, format);
+use std::io::{Cursor, Seek};
+
+use anyhow::Result;
+use c2pa::{
+    crypto::raw_signature::SigningAlg, settings::Settings, validation_results::ValidationState,
+    Builder, CallbackSigner, Reader,
+};
+use serde_json::json;
 
+let json = manifest_def(title, format);
 let mut builder = Builder::from_json(&json)?;
+
 builder.add_ingredient_from_stream(
     json!({
         "title": parent_name,

docs/tasks/includes/_rust-get-resources.md

@@ -6,16 +6,28 @@ This is from [`resource_to_stream`](https://docs.rs/c2pa/latest/c2pa/struct.Read
 
 ```rust
 use c2pa::Reader;
-let stream = std::io::Cursor::new(Vec::new());
-let reader = Reader::from_file("path/to/file.jpg").unwrap();
-let manifest = reader.active_manifest().unwrap();
-let uri = &manifest.thumbnail_ref().unwrap().identifier;
-let bytes_written = reader.resource_to_stream(uri, stream).unwrap();
+#[cfg(feature = "file_io")]
+{
+    let stream = std::io::Cursor::new(Vec::new());
+    let reader = Reader::from_file("path/to/file.jpg").unwrap();
+    let manifest = reader.active_manifest().unwrap();
+    let uri = &manifest.thumbnail_ref().unwrap().identifier;
+    let bytes_written = reader.resource_to_stream(uri, stream).unwrap();
+}
 ```
 
 This is from [`c2pa-rs/examples/v2api.rs`](https://github.com/contentauth/c2pa-rs/blob/main/sdk/examples/v2api.rs#L138):
 
 ```rust
+use std::io::{Cursor, Seek};
+
+use anyhow::Result;
+use c2pa::{
+    crypto::raw_signature::SigningAlg, settings::Settings, validation_results::ValidationState,
+    Builder, CallbackSigner, Reader,
+};
+use serde_json::json;
+
 let reader = Reader::from_stream(format, &mut dest)?;
 
 // extract a thumbnail image from the ManifestStore