cloudcannon-jekyll-bookshop 2.0.0.pre.alpha.50 → 2.0.0.pre.alpha.51

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1290a552703bf872ecc6c91d8e704adbfcd984eee28af72d7154d4e837608728
-  data.tar.gz: 46e49232296188854d57ab0dcd01233a56ed05953e54d2c73f7785bbc24817d7
+  metadata.gz: 9ef366c531882bb8bac078097d5e9cea956f1ebf8987d6ed90b2cc79d9d14905
+  data.tar.gz: d41ff47e21fd66b3d95aa55887ed26b37f3bd0f597316adc5859a5f942a17475
 SHA512:
-  metadata.gz: c0ea17c7fb415fb08bbbfa0f74ed2a7ceeeb478ce3801088717d98ce4acf6809b3c1719264d02a049570bce258c60f73c8201db71d87e670253bc1ab957c8610
-  data.tar.gz: 368ec0fee6b6a0f605ee5c14ed889cf0fcf08e67a8d134086b7f7025deea4f618bba9917ec24c2b812524b77394a5634ae9717c36b43c5480991c245fb9b48dc
+  metadata.gz: dacddcac6459b59abe23a9c45f349463aed9b6f96b5fb31e158e324e1c186ab8c4ede41657faf3f56dab855a96bc0b377954faa3c57c3bdc8177b9b77a95c88e
+  data.tar.gz: 20f366066b80e654d28adaa7fd20bdceb235e9bb72585be7d260315283ce70f3b97d938301980194db41820f4453b2c37569d42dad3a70047bb35685ad001d6e

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.alpha.51)
       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

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.alpha.51"
 end

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

@@ -0,0 +1,151 @@
+var pkg = require('./package.json');
+const pluralize = require('pluralize');
+
+// Generates the bookshop key used to reference this component
+// Turns "a/b/b.bookshop.toml" into "a/b"
+const GetComponentKey = (componentPath) => {
+    let base = componentPath.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/node_modules/pluralize/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Blake Embrey (hello@blakeembrey.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/node_modules/@bookshop/cloudcannon-structures/node_modules/pluralize/Readme.md

@@ -0,0 +1,100 @@
+# Pluralize
+
+[![NPM version][npm-image]][npm-url]
+[![NPM downloads][downloads-image]][downloads-url]
+[![Build status][travis-image]][travis-url]
+[![Test coverage][coveralls-image]][coveralls-url]
+![File Size][filesize-url]
+[![CDNJS][cdnjs-image]][cdnjs-url]
+
+> Pluralize and singularize any word.
+
+## Installation
+
+```
+npm install pluralize --save
+yarn add pluralize
+bower install pluralize --save
+```
+
+### Node
+
+```javascript
+var pluralize = require('pluralize')
+```
+
+### AMD
+
+```javascript
+define(function (require, exports, module) {
+  var pluralize = require('pluralize')
+})
+```
+
+### `<script>` tag
+
+```html
+<script src="pluralize.js"></script>
+```
+
+## Why?
+
+This module uses a pre-defined list of rules, applied in order, to singularize or pluralize a given word. There are many cases where this is useful, such as any automation based on user input. For applications where the word(s) are known ahead of time, you can use a simple ternary (or function) which would be a much lighter alternative.
+
+## Usage
+
+* `word: string` The word to pluralize
+* `count: number` How many of the word exist
+* `inclusive: boolean` Whether to prefix with the number (e.g. 3 ducks)
+
+Examples:
+
+```javascript
+pluralize('test') //=> "tests"
+pluralize('test', 0) //=> "tests"
+pluralize('test', 1) //=> "test"
+pluralize('test', 5) //=> "tests"
+pluralize('test', 1, true) //=> "1 test"
+pluralize('test', 5, true) //=> "5 tests"
+pluralize('蘋果', 2, true) //=> "2 蘋果"
+
+// Example of new plural rule:
+pluralize.plural('regex') //=> "regexes"
+pluralize.addPluralRule(/gex$/i, 'gexii')
+pluralize.plural('regex') //=> "regexii"
+
+// Example of new singular rule:
+pluralize.singular('singles') //=> "single"
+pluralize.addSingularRule(/singles$/i, 'singular')
+pluralize.singular('singles') //=> "singular"
+
+// Example of new irregular rule, e.g. "I" -> "we":
+pluralize.plural('irregular') //=> "irregulars"
+pluralize.addIrregularRule('irregular', 'regular')
+pluralize.plural('irregular') //=> "regular"
+
+// Example of uncountable rule (rules without singular/plural in context):
+pluralize.plural('paper') //=> "papers"
+pluralize.addUncountableRule('paper')
+pluralize.plural('paper') //=> "paper"
+
+// Example of asking whether a word looks singular or plural:
+pluralize.isPlural('test') //=> false
+pluralize.isSingular('test') //=> true
+```
+
+## License
+
+MIT
+
+[npm-image]: https://img.shields.io/npm/v/pluralize.svg?style=flat
+[npm-url]: https://npmjs.org/package/pluralize
+[downloads-image]: https://img.shields.io/npm/dm/pluralize.svg?style=flat
+[downloads-url]: https://npmjs.org/package/pluralize
+[travis-image]: https://img.shields.io/travis/blakeembrey/pluralize.svg?style=flat
+[travis-url]: https://travis-ci.org/blakeembrey/pluralize
+[coveralls-image]: https://img.shields.io/coveralls/blakeembrey/pluralize.svg?style=flat
+[coveralls-url]: https://coveralls.io/r/blakeembrey/pluralize?branch=master
+[filesize-url]: https://img.shields.io/github/size/blakeembrey/pluralize/pluralize.js.svg?style=flat
+[cdnjs-image]: https://img.shields.io/cdnjs/v/pluralize.svg
+[cdnjs-url]: https://cdnjs.com/libraries/pluralize

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

@@ -0,0 +1,40 @@
+{
+  "name": "pluralize",
+  "version": "8.0.0",
+  "description": "Pluralize and singularize any word",
+  "main": "pluralize.js",
+  "files": [
+    "pluralize.js"
+  ],
+  "scripts": {
+    "lint": "semistandard",
+    "test-spec": "mocha -R spec --bail",
+    "test-cov": "istanbul cover node_modules/mocha/bin/_mocha -- -R spec --bail",
+    "test": "npm run lint && npm run test-cov"
+  },
+  "repository": "https://github.com/blakeembrey/pluralize.git",
+  "keywords": [
+    "plural",
+    "plurals",
+    "pluralize",
+    "singular",
+    "singularize",
+    "inflection"
+  ],
+  "author": {
+    "name": "Blake Embrey",
+    "email": "hello@blakeembrey.com",
+    "url": "http://blakeembrey.me"
+  },
+  "license": "MIT",
+  "readmeFilename": "Readme.md",
+  "engines": {
+    "node": ">=4"
+  },
+  "devDependencies": {
+    "chai": "^4.0.0",
+    "istanbul": "^0.4.5",
+    "mocha": "^5.0.0",
+    "semistandard": "^12.0.0"
+  }
+}

data/node_modules/@bookshop/cloudcannon-structures/node_modules/pluralize/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/cloudcannon-structures/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@bookshop/cloudcannon-structures",
+  "version": "2.0.0-alpha.51",
+  "description": "Convert a Bookshop object into a CloudCannon structure",
+  "main": "main.js",
+  "scripts": {
+    "test": "jest"
+  },
+  "files": [
+    "main.js"
+  ],
+  "author": "@bglw",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@bookshop/toml-narrator": "file:../toml-narrator",
+    "@ltd/j-toml": "^1.12.2",
+    "jest": "^27.0.6"
+  },
+  "jest": {
+    "setupFiles": [
+      "./util/test-helpers.js"
+    ]
+  },
+  "dependencies": {
+    "pluralize": "^8.0.0"
+  },
+  "bundledDependencies": [
+    "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,25 @@
+{
+  "name": "@bookshop/toml-narrator",
+  "version": "2.0.0-alpha.51",
+  "description": "Rewrite Bookshop TOML files to preserve comments",
+  "main": "main.js",
+  "scripts": {
+    "test": "jest"
+  },
+  "files": [
+    "main.js"
+  ],
+  "author": "@bglw",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "jest": "^27.0.6"
+  },
+  "jest": {
+    "setupFiles": [
+      "./util/test-helpers.js"
+    ]
+  }
+}

metadata

@@ -1,7 +1,7 @@
 --- !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.alpha.51
 platform: ruby
 authors:
 - Liam Bigelow
@@ -145,7 +145,6 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rubocop.yml"
 - Gemfile
 - Gemfile.lock
 - Rakefile
@@ -155,6 +154,14 @@ 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/node_modules/pluralize/LICENSE
+- node_modules/@bookshop/cloudcannon-structures/node_modules/pluralize/Readme.md
+- node_modules/@bookshop/cloudcannon-structures/node_modules/pluralize/package.json
+- node_modules/@bookshop/cloudcannon-structures/node_modules/pluralize/pluralize.js
+- node_modules/@bookshop/cloudcannon-structures/package.json
+- 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