cloudcannon-jekyll-bookshop 2.0.0.pre.alpha.50 → 2.0.0.pre.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1290a552703bf872ecc6c91d8e704adbfcd984eee28af72d7154d4e837608728
-  data.tar.gz: 46e49232296188854d57ab0dcd01233a56ed05953e54d2c73f7785bbc24817d7
+  metadata.gz: bd8c2ba588f6b89fcf9cb861edf99800e194f5934d27f73d9d15dc2088d3913f
+  data.tar.gz: 4d8cd72ed22f8fe5906f46d4883be86b4f024aa3cbafc3df42e39d0133324e98
 SHA512:
-  metadata.gz: c0ea17c7fb415fb08bbbfa0f74ed2a7ceeeb478ce3801088717d98ce4acf6809b3c1719264d02a049570bce258c60f73c8201db71d87e670253bc1ab957c8610
-  data.tar.gz: 368ec0fee6b6a0f605ee5c14ed889cf0fcf08e67a8d134086b7f7025deea4f618bba9917ec24c2b812524b77394a5634ae9717c36b43c5480991c245fb9b48dc
+  metadata.gz: 5f6397f010efe1ce2a280cd9acb06646a685dfbb2c7ca6ed8037d3fd901ac58b577319683c3f653bbbfd67646d7bd553be9eb0a775583f168569313d80c5bf39
+  data.tar.gz: f87628966e928f57f30973a3fa99bf512fd603bc48e29a4a468f10e2a4a6dd9c68b5fe1df5a133c2739038efc0f81b796a67831e4c5ef6d8d6fadc19580d1194

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cloudcannon-jekyll-bookshop (2.0.0.pre.alpha.50)
+    cloudcannon-jekyll-bookshop (2.0.0.pre.beta.1)
       dry-inflector (>= 0.1, < 1.0)
       jekyll (>= 3.7, < 5.0)
       node-runner (>= 1.0, < 2.0)

data/cloudcannon-jekyll-bookshop.gemspec

@@ -13,10 +13,8 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
 
   # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  end
+  spec.files = Dir['**/*'].reject { |f| f.match(%r{^(test|spec|features)}) }
+
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]

data/lib/cloudcannon-jekyll-bookshop/structures.rb

@@ -30,7 +30,7 @@ module CloudCannonJekyllBookshop
         component = parse_bookshop_toml(path)
       rescue StandardError => e
         Jekyll.logger.error "Bookshop:",
-                            "❌ Error Parsing Story: #{f}"
+                            "❌ Error Parsing Story: #{e}"
         Jekyll.logger.error "",
                             e.message
       end
@@ -76,8 +76,8 @@ module CloudCannonJekyllBookshop
       @inflector = Dry::Inflector.new
       @node_bookshop = NodeRunner.new(
         <<~JAVASCRIPT
-          const {Version: TNVersion, RewriteTOML} = require('@bookshop/toml-narrator');
-          const {Version: CSVersion, TransformComponent, GetComponentKey, NiceLabel} = require('@bookshop/cloudcannon-structures');
+          const {Version: TNVersion, RewriteTOML} = require('#{__dir__}/../../node_modules/@bookshop/toml-narrator');
+          const {Version: CSVersion, TransformComponent, GetComponentKey, NiceLabel} = require('#{__dir__}/../../node_modules/@bookshop/cloudcannon-structures');
         JAVASCRIPT
       )
     end

data/lib/cloudcannon-jekyll-bookshop/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CloudCannonJekyllBookshop
-  VERSION = "2.0.0.pre.alpha.50"
+  VERSION = "2.0.0.pre.beta.1"
 end

data/node_modules/@bookshop/cloudcannon-structures/main.js

@@ -0,0 +1,152 @@
+var pkg = require('./package.json');
+// Pluralize is vendored for distribution to the generator plugins
+const pluralize = require('./vendored-pluralize.js');
+
+// Generates the bookshop key used to reference this component
+// Turns "a/b/b.bookshop.toml" into "a/b"
+const GetComponentKey = (componentPath) => {
+    let base = componentPath.replace(/^.*components\//, '').split(".")[0];
+    let parts = base.split("/");
+    const l = parts.length;
+    if (l >= 2 && parts[l-1] === parts[l-2]) {
+        parts.pop();
+        base = parts.join("/");
+    }
+    return base;
+}
+
+const NiceLabel = (key) => {
+    return key.split(/-|_|\//)
+        .filter(part => part.length)
+        .map(part => part[0].toUpperCase() + part.slice(1)).join(" ");
+}
+
+// Main function that takes in an entire Bookshop component structure
+// and returns a set of structures to add to CloudCannon
+const TransformComponent = (path, component) => {
+    const result = {
+        value: {
+            _bookshop_name: GetComponentKey(path)
+        },
+        label: NiceLabel(GetComponentKey(path)), // Used as a fallback when no label is supplied inside [component]
+        array_structures: [],
+        ...component["component"]
+    }
+    if (component["props"]) {
+        TransformComponentProps(component["props"], result, null);
+    }
+    if (!result["_hidden"] && !result["array_structures"].includes("bookshop_components")) {
+        result["array_structures"].push("bookshop_components");
+    }
+    
+    const results = [result];
+    
+    delete result["_hidden"];
+    delete result["raw_fields"];
+    
+    return results;
+}
+
+// Recursive function for processing the [props] section of a bookshop component spec,
+// and populating sub-structures, comments, select data, et cetera.
+const TransformComponentProps = (props, structure, value_context) => {
+    ["_select_data","_array_structures","_comments","value"].forEach(k => {
+        structure[k] = structure[k] || {};
+    });
+
+    value_context = value_context || structure["value"];
+    Object.entries(props).forEach(([key, value]) => {
+        if (Object.hasOwnProperty.call(value_context, key)) return;
+
+        if (Array.isArray(value)) {
+            TransformArray(key, value, structure, value_context);
+            return;
+        }
+
+        if (value && typeof value === "object") {
+            TransformObject(key, value, structure, value_context);
+            return;
+        }
+
+        if (value === true || value === false) {
+            value_context[key] = value;
+            return;
+        }
+
+        if (/--bookshop_comment/.test(key)) {
+            const base_key = key.split(/--bookshop_comment/)[0];
+            if (!base_key.length) return;
+            structure["_comments"][base_key] = value;
+            return;
+        }
+
+        value_context[key] = null;
+    });
+}
+
+// Handle an object somewhere within the large props object
+// If reserved bookshop keys lie within, the object is treated as a value
+// Otherwise, recurse into it as a normal object
+const TransformObject = (key, obj, structure, value_context) => {
+    const comment = GetCommentFromObject(obj);
+    if (comment) {
+        structure["_comments"][key] = comment;
+    }
+
+    if (Object.hasOwnProperty.call(obj, "select")) {
+        value_context[key] = obj["default"] ?? null;
+        structure["_select_data"][pluralize(key)] = obj["select"]
+        return
+    }
+
+    if (Object.hasOwnProperty.call(obj, "preview") || Object.hasOwnProperty.call(obj, "default")) {
+        value_context[key] = obj["default"] ?? null;
+        return
+    }
+
+    value_context[key] = {};
+    TransformComponentProps(obj, structure, value_context[key]);
+}
+
+// Handle an array somewhere within the large props object
+// If it is an object array, create a sub-structure based on the first array item
+const TransformArray = (key, array, structure, value_context) => {
+    if (array[0] && typeof array[0] === "object") {
+        if (array[0]["--bookshop_comment"]) {
+            structure["_comments"][key] = array[0]["--bookshop_comment"];
+        }
+
+        if (Array.isArray(structure["raw_fields"]) && structure["raw_fields"].includes(key)) {
+            value_context[key] = null;
+            return
+        }
+
+        const singular_title = NiceLabel(pluralize.singular(key));
+        structure["_array_structures"][key] = {
+            values: [{
+                label: singular_title,
+                icon: "add_box",
+                value: {}
+            }]
+        }
+
+        TransformComponentProps(array[0], 
+            structure["_array_structures"][key]["values"][0], 
+            structure["_array_structures"][key]["values"][0]["value"]);
+    }
+    value_context[key] = [];
+}
+
+const GetCommentFromObject = (object) => {
+    return object["--bookshop_comment"]
+    || object["select--bookshop_comment"]
+    || object["preview--bookshop_comment"]
+    || object["default--bookshop_comment"]
+}
+
+module.exports = {
+    Version: () => pkg.version,
+    TransformComponent,
+    GetComponentKey,
+    NiceLabel,
+}

data/node_modules/@bookshop/cloudcannon-structures/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@bookshop/cloudcannon-structures",
+  "version": "2.0.0-beta.1",
+  "description": "Convert a Bookshop object into a CloudCannon structure",
+  "main": "main.js",
+  "scripts": {
+    "test": "ava -v"
+  },
+  "files": [
+    "main.js",
+    "vendored-pluralize.js"
+  ],
+  "author": "@bglw",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@bookshop/toml-narrator": "file:../toml-narrator",
+    "@ltd/j-toml": "^1.12.2",
+    "ava": "^3.15.0",
+    "pluralize": "^8.0.0"
+  },
+  "engines": {
+    "npm": "please-use-yarn"
+  }
+}

data/node_modules/@bookshop/cloudcannon-structures/vendored-pluralize.js

@@ -0,0 +1,503 @@
+/* global define */
+
+(function (root, pluralize) {
+  /* istanbul ignore else */
+  if (typeof require === 'function' && typeof exports === 'object' && typeof module === 'object') {
+    // Node.
+    module.exports = pluralize();
+  } else if (typeof define === 'function' && define.amd) {
+    // AMD, registers as an anonymous module.
+    define(function () {
+      return pluralize();
+    });
+  } else {
+    // Browser global.
+    root.pluralize = pluralize();
+  }
+})(this, function () {
+  // Rule storage - pluralize and singularize need to be run sequentially,
+  // while other rules can be optimized using an object for instant lookups.
+  var pluralRules = [];
+  var singularRules = [];
+  var uncountables = {};
+  var irregularPlurals = {};
+  var irregularSingles = {};
+
+  /**
+   * Sanitize a pluralization rule to a usable regular expression.
+   *
+   * @param  {(RegExp|string)} rule
+   * @return {RegExp}
+   */
+  function sanitizeRule (rule) {
+    if (typeof rule === 'string') {
+      return new RegExp('^' + rule + '$', 'i');
+    }
+
+    return rule;
+  }
+
+  /**
+   * Pass in a word token to produce a function that can replicate the case on
+   * another word.
+   *
+   * @param  {string}   word
+   * @param  {string}   token
+   * @return {Function}
+   */
+  function restoreCase (word, token) {
+    // Tokens are an exact match.
+    if (word === token) return token;
+
+    // Lower cased words. E.g. "hello".
+    if (word === word.toLowerCase()) return token.toLowerCase();
+
+    // Upper cased words. E.g. "WHISKY".
+    if (word === word.toUpperCase()) return token.toUpperCase();
+
+    // Title cased words. E.g. "Title".
+    if (word[0] === word[0].toUpperCase()) {
+      return token.charAt(0).toUpperCase() + token.substr(1).toLowerCase();
+    }
+
+    // Lower cased words. E.g. "test".
+    return token.toLowerCase();
+  }
+
+  /**
+   * Interpolate a regexp string.
+   *
+   * @param  {string} str
+   * @param  {Array}  args
+   * @return {string}
+   */
+  function interpolate (str, args) {
+    return str.replace(/\$(\d{1,2})/g, function (match, index) {
+      return args[index] || '';
+    });
+  }
+
+  /**
+   * Replace a word using a rule.
+   *
+   * @param  {string} word
+   * @param  {Array}  rule
+   * @return {string}
+   */
+  function replace (word, rule) {
+    return word.replace(rule[0], function (match, index) {
+      var result = interpolate(rule[1], arguments);
+
+      if (match === '') {
+        return restoreCase(word[index - 1], result);
+      }
+
+      return restoreCase(match, result);
+    });
+  }
+
+  /**
+   * Sanitize a word by passing in the word and sanitization rules.
+   *
+   * @param  {string}   token
+   * @param  {string}   word
+   * @param  {Array}    rules
+   * @return {string}
+   */
+  function sanitizeWord (token, word, rules) {
+    // Empty string or doesn't need fixing.
+    if (!token.length || uncountables.hasOwnProperty(token)) {
+      return word;
+    }
+
+    var len = rules.length;
+
+    // Iterate over the sanitization rules and use the first one to match.
+    while (len--) {
+      var rule = rules[len];
+
+      if (rule[0].test(word)) return replace(word, rule);
+    }
+
+    return word;
+  }
+
+  /**
+   * Replace a word with the updated word.
+   *
+   * @param  {Object}   replaceMap
+   * @param  {Object}   keepMap
+   * @param  {Array}    rules
+   * @return {Function}
+   */
+  function replaceWord (replaceMap, keepMap, rules) {
+    return function (word) {
+      // Get the correct token and case restoration functions.
+      var token = word.toLowerCase();
+
+      // Check against the keep object map.
+      if (keepMap.hasOwnProperty(token)) {
+        return restoreCase(word, token);
+      }
+
+      // Check against the replacement map for a direct word replacement.
+      if (replaceMap.hasOwnProperty(token)) {
+        return restoreCase(word, replaceMap[token]);
+      }
+
+      // Run all the rules against the word.
+      return sanitizeWord(token, word, rules);
+    };
+  }
+
+  /**
+   * Check if a word is part of the map.
+   */
+  function checkWord (replaceMap, keepMap, rules, bool) {
+    return function (word) {
+      var token = word.toLowerCase();
+
+      if (keepMap.hasOwnProperty(token)) return true;
+      if (replaceMap.hasOwnProperty(token)) return false;
+
+      return sanitizeWord(token, token, rules) === token;
+    };
+  }
+
+  /**
+   * Pluralize or singularize a word based on the passed in count.
+   *
+   * @param  {string}  word      The word to pluralize
+   * @param  {number}  count     How many of the word exist
+   * @param  {boolean} inclusive Whether to prefix with the number (e.g. 3 ducks)
+   * @return {string}
+   */
+  function pluralize (word, count, inclusive) {
+    var pluralized = count === 1
+      ? pluralize.singular(word) : pluralize.plural(word);
+
+    return (inclusive ? count + ' ' : '') + pluralized;
+  }
+
+  /**
+   * Pluralize a word.
+   *
+   * @type {Function}
+   */
+  pluralize.plural = replaceWord(
+    irregularSingles, irregularPlurals, pluralRules
+  );
+
+  /**
+   * Check if a word is plural.
+   *
+   * @type {Function}
+   */
+  pluralize.isPlural = checkWord(
+    irregularSingles, irregularPlurals, pluralRules
+  );
+
+  /**
+   * Singularize a word.
+   *
+   * @type {Function}
+   */
+  pluralize.singular = replaceWord(
+    irregularPlurals, irregularSingles, singularRules
+  );
+
+  /**
+   * Check if a word is singular.
+   *
+   * @type {Function}
+   */
+  pluralize.isSingular = checkWord(
+    irregularPlurals, irregularSingles, singularRules
+  );
+
+  /**
+   * Add a pluralization rule to the collection.
+   *
+   * @param {(string|RegExp)} rule
+   * @param {string}          replacement
+   */
+  pluralize.addPluralRule = function (rule, replacement) {
+    pluralRules.push([sanitizeRule(rule), replacement]);
+  };
+
+  /**
+   * Add a singularization rule to the collection.
+   *
+   * @param {(string|RegExp)} rule
+   * @param {string}          replacement
+   */
+  pluralize.addSingularRule = function (rule, replacement) {
+    singularRules.push([sanitizeRule(rule), replacement]);
+  };
+
+  /**
+   * Add an uncountable word rule.
+   *
+   * @param {(string|RegExp)} word
+   */
+  pluralize.addUncountableRule = function (word) {
+    if (typeof word === 'string') {
+      uncountables[word.toLowerCase()] = true;
+      return;
+    }
+
+    // Set singular and plural references for the word.
+    pluralize.addPluralRule(word, '$0');
+    pluralize.addSingularRule(word, '$0');
+  };
+
+  /**
+   * Add an irregular word definition.
+   *
+   * @param {string} single
+   * @param {string} plural
+   */
+  pluralize.addIrregularRule = function (single, plural) {
+    plural = plural.toLowerCase();
+    single = single.toLowerCase();
+
+    irregularSingles[single] = plural;
+    irregularPlurals[plural] = single;
+  };
+
+  /**
+   * Irregular rules.
+   */
+  [
+    // Pronouns.
+    ['I', 'we'],
+    ['me', 'us'],
+    ['he', 'they'],
+    ['she', 'they'],
+    ['them', 'them'],
+    ['myself', 'ourselves'],
+    ['yourself', 'yourselves'],
+    ['itself', 'themselves'],
+    ['herself', 'themselves'],
+    ['himself', 'themselves'],
+    ['themself', 'themselves'],
+    ['is', 'are'],
+    ['was', 'were'],
+    ['has', 'have'],
+    ['this', 'these'],
+    ['that', 'those'],
+    // Words ending in with a consonant and `o`.
+    ['echo', 'echoes'],
+    ['dingo', 'dingoes'],
+    ['volcano', 'volcanoes'],
+    ['tornado', 'tornadoes'],
+    ['torpedo', 'torpedoes'],
+    // Ends with `us`.
+    ['genus', 'genera'],
+    ['viscus', 'viscera'],
+    // Ends with `ma`.
+    ['stigma', 'stigmata'],
+    ['stoma', 'stomata'],
+    ['dogma', 'dogmata'],
+    ['lemma', 'lemmata'],
+    ['schema', 'schemata'],
+    ['anathema', 'anathemata'],
+    // Other irregular rules.
+    ['ox', 'oxen'],
+    ['axe', 'axes'],
+    ['die', 'dice'],
+    ['yes', 'yeses'],
+    ['foot', 'feet'],
+    ['eave', 'eaves'],
+    ['goose', 'geese'],
+    ['tooth', 'teeth'],
+    ['quiz', 'quizzes'],
+    ['human', 'humans'],
+    ['proof', 'proofs'],
+    ['carve', 'carves'],
+    ['valve', 'valves'],
+    ['looey', 'looies'],
+    ['thief', 'thieves'],
+    ['groove', 'grooves'],
+    ['pickaxe', 'pickaxes'],
+    ['passerby', 'passersby']
+  ].forEach(function (rule) {
+    return pluralize.addIrregularRule(rule[0], rule[1]);
+  });
+
+  /**
+   * Pluralization rules.
+   */
+  [
+    [/s?$/i, 's'],
+    [/[^\u0000-\u007F]$/i, '$0'],
+    [/([^aeiou]ese)$/i, '$1'],
+    [/(ax|test)is$/i, '$1es'],
+    [/(alias|[^aou]us|t[lm]as|gas|ris)$/i, '$1es'],
+    [/(e[mn]u)s?$/i, '$1s'],
+    [/([^l]ias|[aeiou]las|[ejzr]as|[iu]am)$/i, '$1'],
+    [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, '$1i'],
+    [/(alumn|alg|vertebr)(?:a|ae)$/i, '$1ae'],
+    [/(seraph|cherub)(?:im)?$/i, '$1im'],
+    [/(her|at|gr)o$/i, '$1oes'],
+    [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|automat|quor)(?:a|um)$/i, '$1a'],
+    [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)(?:a|on)$/i, '$1a'],
+    [/sis$/i, 'ses'],
+    [/(?:(kni|wi|li)fe|(ar|l|ea|eo|oa|hoo)f)$/i, '$1$2ves'],
+    [/([^aeiouy]|qu)y$/i, '$1ies'],
+    [/([^ch][ieo][ln])ey$/i, '$1ies'],
+    [/(x|ch|ss|sh|zz)$/i, '$1es'],
+    [/(matr|cod|mur|sil|vert|ind|append)(?:ix|ex)$/i, '$1ices'],
+    [/\b((?:tit)?m|l)(?:ice|ouse)$/i, '$1ice'],
+    [/(pe)(?:rson|ople)$/i, '$1ople'],
+    [/(child)(?:ren)?$/i, '$1ren'],
+    [/eaux$/i, '$0'],
+    [/m[ae]n$/i, 'men'],
+    ['thou', 'you']
+  ].forEach(function (rule) {
+    return pluralize.addPluralRule(rule[0], rule[1]);
+  });
+
+  /**
+   * Singularization rules.
+   */
+  [
+    [/s$/i, ''],
+    [/(ss)$/i, '$1'],
+    [/(wi|kni|(?:after|half|high|low|mid|non|night|[^\w]|^)li)ves$/i, '$1fe'],
+    [/(ar|(?:wo|[ae])l|[eo][ao])ves$/i, '$1f'],
+    [/ies$/i, 'y'],
+    [/\b([pl]|zomb|(?:neck|cross)?t|coll|faer|food|gen|goon|group|lass|talk|goal|cut)ies$/i, '$1ie'],
+    [/\b(mon|smil)ies$/i, '$1ey'],
+    [/\b((?:tit)?m|l)ice$/i, '$1ouse'],
+    [/(seraph|cherub)im$/i, '$1'],
+    [/(x|ch|ss|sh|zz|tto|go|cho|alias|[^aou]us|t[lm]as|gas|(?:her|at|gr)o|[aeiou]ris)(?:es)?$/i, '$1'],
+    [/(analy|diagno|parenthe|progno|synop|the|empha|cri|ne)(?:sis|ses)$/i, '$1sis'],
+    [/(movie|twelve|abuse|e[mn]u)s$/i, '$1'],
+    [/(test)(?:is|es)$/i, '$1is'],
+    [/(alumn|syllab|vir|radi|nucle|fung|cact|stimul|termin|bacill|foc|uter|loc|strat)(?:us|i)$/i, '$1us'],
+    [/(agend|addend|millenni|dat|extrem|bacteri|desiderat|strat|candelabr|errat|ov|symposi|curricul|quor)a$/i, '$1um'],
+    [/(apheli|hyperbat|periheli|asyndet|noumen|phenomen|criteri|organ|prolegomen|hedr|automat)a$/i, '$1on'],
+    [/(alumn|alg|vertebr)ae$/i, '$1a'],
+    [/(cod|mur|sil|vert|ind)ices$/i, '$1ex'],
+    [/(matr|append)ices$/i, '$1ix'],
+    [/(pe)(rson|ople)$/i, '$1rson'],
+    [/(child)ren$/i, '$1'],
+    [/(eau)x?$/i, '$1'],
+    [/men$/i, 'man']
+  ].forEach(function (rule) {
+    return pluralize.addSingularRule(rule[0], rule[1]);
+  });
+
+  /**
+   * Uncountable rules.
+   */
+  [
+    // Singular words with no plurals.
+    'adulthood',
+    'advice',
+    'agenda',
+    'aid',
+    'aircraft',
+    'alcohol',
+    'ammo',
+    'analytics',
+    'anime',
+    'athletics',
+    'audio',
+    'bison',
+    'blood',
+    'bream',
+    'buffalo',
+    'butter',
+    'carp',
+    'cash',
+    'chassis',
+    'chess',
+    'clothing',
+    'cod',
+    'commerce',
+    'cooperation',
+    'corps',
+    'debris',
+    'diabetes',
+    'digestion',
+    'elk',
+    'energy',
+    'equipment',
+    'excretion',
+    'expertise',
+    'firmware',
+    'flounder',
+    'fun',
+    'gallows',
+    'garbage',
+    'graffiti',
+    'hardware',
+    'headquarters',
+    'health',
+    'herpes',
+    'highjinks',
+    'homework',
+    'housework',
+    'information',
+    'jeans',
+    'justice',
+    'kudos',
+    'labour',
+    'literature',
+    'machinery',
+    'mackerel',
+    'mail',
+    'media',
+    'mews',
+    'moose',
+    'music',
+    'mud',
+    'manga',
+    'news',
+    'only',
+    'personnel',
+    'pike',
+    'plankton',
+    'pliers',
+    'police',
+    'pollution',
+    'premises',
+    'rain',
+    'research',
+    'rice',
+    'salmon',
+    'scissors',
+    'series',
+    'sewage',
+    'shambles',
+    'shrimp',
+    'software',
+    'species',
+    'staff',
+    'swine',
+    'tennis',
+    'traffic',
+    'transportation',
+    'trout',
+    'tuna',
+    'wealth',
+    'welfare',
+    'whiting',
+    'wildebeest',
+    'wildlife',
+    'you',
+    /pok[eé]mon$/i,
+    // Regexes.
+    /[^aeiou]ese$/i, // "chinese", "japanese"
+    /deer$/i, // "deer", "reindeer"
+    /fish$/i, // "fish", "blowfish", "angelfish"
+    /measles$/i,
+    /o[iu]s$/i, // "carnivorous"
+    /pox$/i, // "chickpox", "smallpox"
+    /sheep$/i
+  ].forEach(pluralize.addUncountableRule);
+
+  return pluralize;
+});

data/node_modules/@bookshop/toml-narrator/main.js

@@ -0,0 +1,30 @@
+var pkg = require('./package.json');
+module.exports = {
+    Version: () => pkg.version,
+    RewriteTOML: (input_toml) => {
+        return input_toml.split(`\n`).map(line => {
+            // some_variable.etc = "some value" #: Some comment
+            const isVariableComment = /^[a-z0-9\-_\.\s]+=.*?#.+?$/i;
+            // [some_section] #: Some comment
+            const isBlockComment = /^\s*?\[.*?#.+?$/i;
+
+            const extractComment = /#:([^#]+)$/i;
+            const extractVariable = /^\s*?([a-z0-9\-_\.]+)\s?=/i;
+
+            if (isVariableComment.test(line)) {
+                const [, comment] = extractComment.exec(line) || [];
+                const [, variable_name] = extractVariable.exec(line) || [];
+                if (!comment || !variable_name) return line;
+
+                return `${variable_name}--bookshop_comment = "${comment.trim()}"\n${line}`
+            } else if (isBlockComment.test(line)) {
+                const [, comment] = extractComment.exec(line) || [];
+                if (!comment) return line;
+
+                return `${line}\n--bookshop_comment = "${comment.trim()}"`
+            } else {
+                return line;
+            }
+        }).join(`\n`);
+    }
+}

data/node_modules/@bookshop/toml-narrator/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@bookshop/toml-narrator",
+  "version": "2.0.0-beta.1",
+  "description": "Rewrite Bookshop TOML files to preserve comments",
+  "main": "main.js",
+  "scripts": {
+    "test": "ava -v"
+  },
+  "files": [
+    "main.js"
+  ],
+  "author": "@bglw",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "ava": "^3.15.0"
+  },
+  "engines": {
+    "npm": "please-use-yarn"
+  }
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cloudcannon-jekyll-bookshop
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre.alpha.50
+  version: 2.0.0.pre.beta.1
 platform: ruby
 authors:
 - Liam Bigelow
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-07-26 00:00:00.000000000 Z
+date: 2021-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jekyll
@@ -145,7 +145,6 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rubocop.yml"
 - Gemfile
 - Gemfile.lock
 - Rakefile
@@ -155,6 +154,11 @@ files:
 - lib/cloudcannon-jekyll-bookshop/page-without-a-file.rb
 - lib/cloudcannon-jekyll-bookshop/structures.rb
 - lib/cloudcannon-jekyll-bookshop/version.rb
+- node_modules/@bookshop/cloudcannon-structures/main.js
+- node_modules/@bookshop/cloudcannon-structures/package.json
+- node_modules/@bookshop/cloudcannon-structures/vendored-pluralize.js
+- node_modules/@bookshop/toml-narrator/main.js
+- node_modules/@bookshop/toml-narrator/package.json
 homepage: https://github.com/cloudcannon/bookshop
 licenses:
 - MIT

data/.rubocop.yml

@@ -1,27 +0,0 @@
-require: rubocop-jekyll
-
-inherit_gem:
-  rubocop-jekyll: .rubocop.yml
-
-AllCops:
-  TargetRubyVersion: 2.4
-  Include:
-    - lib/**/*.rb
-    - spec/**/*.rb
-
-  Exclude:
-    - .gitignore
-    - .rspec
-    - .rubocop.yml
-    - .travis.yml
-    - Gemfile.lock
-    - HISTORY.md
-    - LICENSE.txt
-    - README.md
-    - script/**/*
-    - vendor/**/*
-    - gemfiles/**/*
-
-Naming/MemoizedInstanceVariableName:
-  Exclude:
-    - lib/cloudcannon-jekyll-bookshop/page-without-a-file.rb