shinkansen-rails 1.0.18

package/.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+npm run pre-commit

package/README.md

@@ -0,0 +1,36 @@
+## `shinkansen-rails`
+
+# Shinkansen Rails
+
+*Rails* transforms objects into strings to be consumed by `<Link />` components for *React Router*.
+
+## Usage
+
+```javascript
+import {
+  Rails
+} from 'shinkansen-rails'
+```
+
+*Rails* exposes the methods `pattern`, `go`, `to`, and `rail`.
+
+```javascript
+export class Rails {
+  static pattern () { }
+  static go () { }
+  static to () { }
+  static rail () { }
+}
+```
+
+- `pattern` returns a string which is the transformation pattern
+- `go` returns a boolean which describes whether an object can be transformed by the pattern
+- `to` returns a string which is the product of that transformation
+- `rail` caches and returns a product of `to`
+
+The method `rail` should be used whenever the computation is (or expected to be) idempotent.
+
+## See also
+
+- [Shinkansen Gears](https://github.com/modernpoacher/shinkansen-gears)
+- [Shinkansen Pantograph](https://github.com/modernpoacher/shinkansen-pantograph)

package/babel.config.js

@@ -0,0 +1,61 @@
+const debug = require('debug')
+
+const log = debug('shinkansen-rails')
+
+const {
+  env: {
+    NODE_ENV = 'development'
+  }
+} = process
+
+log('`shinkansen` is awake')
+
+function env () {
+  log({ NODE_ENV })
+
+  return (
+    NODE_ENV === 'production'
+  )
+}
+
+const presets = [
+  [
+    '@babel/env', {
+      targets: {
+        node: '12.19.0',
+        browsers: [
+          'last 4 versions',
+          'safari >= 9',
+          'ios >= 8',
+          'ie >= 9',
+          '> 2%'
+        ]
+      },
+      useBuiltIns: 'usage',
+      corejs: 3
+    }
+  ]
+]
+
+const plugins = [
+  '@babel/proposal-export-default-from',
+  '@babel/proposal-class-properties',
+  [
+    'module-resolver', {
+      alias: {
+        'shinkansen-rails': './src'
+      }
+    }
+  ]
+]
+
+module.exports = (api) => {
+  if (api) api.cache.using(env)
+
+  return {
+    compact: true,
+    comments: false,
+    presets,
+    plugins
+  }
+}

package/index.js

@@ -0,0 +1,7 @@
+const debug = require('debug')
+
+const log = debug('shinkansen-rails')
+
+log('`rails` is awake')
+
+module.exports = require('./lib')

package/lib/index.js

@@ -0,0 +1 @@
+"use strict";require("core-js/modules/es.object.define-property.js");Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"Rails",{enumerable:true,get:function get(){return _rails["default"];}});var _rails=_interopRequireDefault(require("./rails"));function _interopRequireDefault(obj){return obj&&obj.__esModule?obj:{"default":obj};}

package/lib/rails/index.js

@@ -0,0 +1 @@
+"use strict";require("core-js/modules/es.object.define-property.js");Object.defineProperty(exports,"__esModule",{value:true});exports.rail=_rail;exports.go=_go;exports.to=_to;exports["default"]=exports.get=exports.has=exports.any=void 0;require("core-js/modules/es.array.iterator.js");require("core-js/modules/es.map.js");require("core-js/modules/es.object.to-string.js");require("core-js/modules/es.string.iterator.js");require("core-js/modules/web.dom-collections.iterator.js");require("core-js/modules/es.reflect.own-keys.js");require("core-js/modules/es.reflect.has.js");require("core-js/modules/es.reflect.get.js");require("core-js/modules/es.regexp.exec.js");require("core-js/modules/es.string.replace.js");require("core-js/modules/es.string.trim.js");require("core-js/modules/es.string.match.js");function _classCallCheck(instance,Constructor){if(!(instance instanceof Constructor)){throw new TypeError("Cannot call a class as a function");}}function _defineProperties(target,props){for(var i=0;i<props.length;i++){var descriptor=props[i];descriptor.enumerable=descriptor.enumerable||false;descriptor.configurable=true;if("value"in descriptor)descriptor.writable=true;Object.defineProperty(target,descriptor.key,descriptor);}}function _createClass(Constructor,protoProps,staticProps){if(protoProps)_defineProperties(Constructor.prototype,protoProps);if(staticProps)_defineProperties(Constructor,staticProps);return Constructor;}var _pattern;var map=new Map();var PATTERN='/:alpha/:omega';var CHAR32=String.fromCharCode(32);var CHAR45=String.fromCharCode(45);var any=function any(o){return!!Reflect.ownKeys(o).length;};exports.any=any;var has=function has(o,k){return Reflect.has(o,k);};exports.has=has;var get=function get(o,k){return Reflect.get(o,k);};exports.get=get;function _rail(s){return s.toLowerCase().replace(/[^\w\-\d]/g,CHAR32).trim().replace(/[\s]+/g,CHAR45).replace(/[\s\s|\-\-]+/g,CHAR45);}function _go(o,s){var b=any(o);if(b){var k;var a=s.match(/(\w+)/g);while(b&&(k=a.shift())){b=has(o,k);}}return b;}function _to(o,s){return s.replace(/(?::)(\w+)/g,function(m,k){return m?has(o,k)?get(o,k):m:m;});}var Rails=function(){function Rails(){_classCallCheck(this,Rails);}_createClass(Rails,null,[{key:"pattern",value:function pattern(p){return p?_pattern=String(p):_pattern||(_pattern=PATTERN);}},{key:"rail",value:function rail(s){var k=String(s);if(map.has(k))return map.get(k);var S=_rail(k);map.set(k,S);return S;}},{key:"go",value:function go(){var o=arguments.length>0&&arguments[0]!==undefined?arguments[0]:{};var s=arguments.length>1&&arguments[1]!==undefined?arguments[1]:Rails.pattern();return any(o)?(s=String(s))?_go(o,s):false:false;}},{key:"to",value:function to(){var o=arguments.length>0&&arguments[0]!==undefined?arguments[0]:{};var s=arguments.length>1&&arguments[1]!==undefined?arguments[1]:Rails.pattern();return any(o)?(s=String(s))?_to(o,s):s:s;}}]);return Rails;}();exports["default"]=Rails;

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "shinkansen-rails",
+  "version": "1.0.18",
+  "description": "Shinkansen Rails",
+  "keywords": [
+    "Shinkansen",
+    "Rails",
+    "Zashiki Karakuri",
+    "Zashiki",
+    "Karakuri"
+  ],
+  "main": "./index.js",
+  "author": "Jonathan Perry for Modern Poacher Limited <modernpoacher@modernpoacher.com>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=12.19.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com/modernpoacher/shinkansen-rails.git"
+  },
+  "scripts": {
+    "prepublishOnly": "cross-env NODE_ENV=production npm run build",
+    "prebuild": "npm run clean",
+    "build": "npm run babel",
+    "build:watch": "npm run babel:watch",
+    "clean": "rimraf lib",
+    "babel": "babel src -d lib",
+    "babel:watch": "npm run build -- -w",
+    "lint": "eslint .",
+    "lint:fix": "npm run lint -- --fix",
+    "test": "NODE_ENV=test mocha -r @babel/register test --recursive",
+    "pre-commit": "npm run lint && npm test && npm run build && git add lib"
+  },
+  "dependencies": {
+    "debug": "^4.3.2"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.15.4",
+    "@babel/core": "^7.15.5",
+    "@babel/eslint-parser": "^7.15.4",
+    "@babel/plugin-proposal-class-properties": "^7.14.5",
+    "@babel/plugin-proposal-export-default-from": "^7.14.5",
+    "@babel/preset-env": "^7.15.6",
+    "@babel/register": "^7.15.3",
+    "babel-loader": "^8.2.2",
+    "babel-plugin-module-resolver": "^4.1.0",
+    "chai": "^4.3.4",
+    "core-js": "^3.17.3",
+    "cross-env": "^7.0.3",
+    "eslint": "^7.32.0",
+    "eslint-config-standard": "^16.0.3",
+    "eslint-import-resolver-babel-module": "^5.3.1",
+    "eslint-plugin-import": "^2.24.2",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^5.1.0",
+    "husky": "^7.0.2",
+    "mocha": "^9.1.1",
+    "rimraf": "^3.0.2",
+    "sinon": "^11.1.2",
+    "sinon-chai": "^3.7.0"
+  }
+}

package/src/index.js

@@ -0,0 +1 @@
+export Rails from './rails'

package/src/rails/index.js

@@ -0,0 +1,112 @@
+let pattern
+
+const map = new Map()
+
+const PATTERN = '/:alpha/:omega'
+
+const CHAR32 = String.fromCharCode(32)
+const CHAR45 = String.fromCharCode(45)
+
+export const any = (o) => !!Reflect.ownKeys(o).length
+export const has = (o, k) => Reflect.has(o, k)
+export const get = (o, k) => Reflect.get(o, k)
+
+/**
+ *  Format simple latin character strings as URL compatible
+ *
+ *  @param {String} s   The string to convert
+ *  @return {String}    The string, converted
+ */
+export function rail (s) {
+  return (
+    s.toLowerCase().replace(/[^\w\-\d]/g, CHAR32).trim().replace(/[\s]+/g, CHAR45).replace(/[\s\s|\-\-]+/g, CHAR45)
+  )
+}
+
+/**
+ *  Interrogate parameters to determine whether or not components can be created
+ *
+ *  @param {Object} o   The object containing values for the 'pattern'
+ *  @param {String} s   The 'pattern' according to which URLs should be created
+ *  @param {Boolean} b  Whether the Rails can go
+ *  @return {Boolean}
+ *
+ *  @description
+ *
+ *  Split the pattern into useful strings (such that '/:alpha/:omega' becomes ['alpha', 'omega']
+ *    For each string in the array
+ *      If the string exists as a key in the object
+ *        If the boolean is true
+ *          set the boolean = whether the object has a property for that key
+ *            return that boolean (to the loop. It doesn't exit here)
+ *      Else set the boolean as false and return it (to the loop. It doesn't exit here, either)
+ *  Return the boolean
+ *
+ *  A `reduce` cannot break when `b` is false
+ */
+export function go (o, s) {
+  let b = any(o)
+
+  if (b) {
+    let k
+    const a = s.match(/(\w+)/g)
+    while (b && (k = a.shift())) b = has(o, k) // it is only necessary that the `o` has key `k`. Otherwise, `b = has(o, k) && !!get(o, k)` to enforce a truthy field value for field key `k`
+  }
+
+  return b
+}
+
+/**
+ *  Interrogate parameters for object field names
+ *
+ *  @param {Object} o   The object containing fields
+ *  @param {String} s   The string containing field names to be found
+ *  @return {String}
+ *
+ *  @description
+ *
+ *  A valid object is
+ *
+ *    { fieldName: 'field Value' }
+ *
+ *  A valid string is
+ *
+ *    /:fieldName
+ */
+export function to (o, s) {
+  return (
+    s.replace(/(?::)(\w+)/g, (m, k) => m ? has(o, k) ? get(o, k) : m : m)
+  )
+}
+
+/**
+ *  Rails.go()  Boolean
+ *  Rails.to()  String
+ */
+export default class Rails {
+  static pattern (p) {
+    return (
+      p ? (pattern = String(p)) : pattern || (pattern = PATTERN)
+    )
+  }
+
+  static rail (s) {
+    const k = String(s)
+    if (map.has(k)) return map.get(k)
+    const S = rail(k)
+    map.set(k, S)
+    return S
+  }
+
+  static go (o = {}, s = Rails.pattern()) {
+    return (
+      any(o) ? (s = String(s)) ? go(o, s) : false : false // return is s is truthy true then go else false
+    )
+  }
+
+  static to (o = {}, s = Rails.pattern()) {
+    return (
+      any(o) ? (s = String(s)) ? to(o, s) : s : s
+    )
+  }
+}