first commit

.gitignore

@@ -0,0 +1,2 @@
+node_modules
+coverage

.travis.yml

@@ -0,0 +1,14 @@
+language: node_js
+
+node_js:
+  - stable
+  - 7.5.0
+
+install:
+  - npm install
+
+script:
+  - npm run cover
+
+# send coverage data to Coveralls
+after_script: "cat coverage/lcov.info | node_modules/coveralls/bin/coveralls.js"

LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Pierre-Emmanuel Lévesque
+
+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.

README.md

@@ -0,0 +1,129 @@
+[![Build Status](https://travis-ci.org/pelevesque/has_required_substrings_at_sums.svg?branch=master)](https://travis-ci.org/pelevesque/has_required_substrings_at_sums)
+[![Coverage Status](https://coveralls.io/repos/github/pelevesque/has_required_substrings_at_sums/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/has_required_substrings_at_sums?branch=master)
+[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)
+
+# has_required_substrings_at_sums
+
+Checks if a string has required substrings after given sums.
+
+## Node Repository
+
+https://www.npmjs.com/package/@pelevesque/has_required_substrings_at_sums
+
+## Installation
+
+`npm install @pelevesque/has_required_substrings_at_sums`
+
+## Tests
+
+### Standard Style & Unit Tests
+
+`npm test`
+
+### Unit Tests & Coverage
+
+`npm run cover`
+
+## Usage
+
+### Parameters
+
+```js
+str                (required)
+requiredSubstrings (required)
+options            (optional) default = { substringsToDigits = null, sumPlainDigits = true,  allowSubstringBleeding = false }
+```
+
+### Requiring
+
+```js
+const hasRequiredSubstringsAtSums = require('@pelevesque/has_required_substrings_at_sums')
+```
+
+### Basic Usage
+
+@see https://github.com/pelevesque/sum-digits to understand how the sum is calculated.
+
+`requiredSubstrings` is an object of sum -> substring pairs. `true` is returned
+if all substrings are found directly following their associated sums.
+
+```js
+const str = '123a45'
+const requiredSubstrings = { 1: 'a' }
+const result = hasRequiredSubstringsAtSums(str, requiredSubstrings)
+// result === false
+```
+
+```js
+const str = '123a45'
+const requiredSubstrings = { 6: 'a' }
+const result = hasRequiredSubstringsAtSums(str, requiredSubstrings)
+// result === true
+```
+
+```js
+const str = '123man45dinosaur'
+const requiredSubstrings = { 6: 'man', 15: 'dinosaur' }
+const result = hasRequiredSubstringsAtSums(str, requiredSubstrings)
+// result === true
+```
+
+```js
+// the substring must come directly after the sum (here b is directly after the sum, not a)
+const str = '123ba45'
+const requiredSubstrings = { 6: 'a' }
+const result = hasRequiredSubstringsAtSums(str, requiredSubstrings)
+// result === false
+```
+
+### SubstringsToDigits
+
+You can use the `substringsToDigits` object to give numeric values to substrings
+so that they are counted during summing.
+
+```js
+const str = '123!$$$a'
+const requiredSubstrings = { 15: 'a' }
+const substringsToDigits = { '!': 4, '$$$': 5 }
+const result = hasRequiredSubstringsAtSums(str, requiredSubstrings, {
+  substringsToDigits: substringsToDigits
+})
+// result === true
+```
+
+### SumPlainDigits Flag
+
+You can set the `sumPlainDigits` flag to false if you only want to sum
+`substringsToDigits`.
+
+In the following example, `1`, `2`, and `3` are not summed.
+
+```js
+const str = '123!a'
+const requiredSubstrings = { 4: 'a' }
+const substringsToDigits = { '!': 4 }
+const sumPlainDigits = false
+const result = hasRequiredSubstringsAtSums(str, requiredSubstrings, {
+  substringsToDigits: substringsToDigits,
+  sumPlainDigits: sumPlainDigits
+})
+// result === true
+```
+
+### AllowSubstringBleeding Flag
+
+The `allowSubstringBleeding` flag is `false` by default. It it used when you want
+to allow the last required substring to be incomplete if the string is too short.
+In the following example, the last substring `canal` starts after the right sum,
+but remains incomplete since the string ends. Normally this would return `false`.
+With `allowSubstringBleeding` set to `true`, it returns `true`.
+
+```js
+const str = '123can'
+const requiredSubstrings = { 6: 'canal' }
+const allowSubstringBleeding = true
+const result = hasRequiredSubstringsAtSums(str, requiredSubstrings, {
+  allowSubstringBleeding: allowSubstringBleeding
+})
+// result === true
+```

index.js

@@ -0,0 +1,39 @@
+'use strict'
+
+const sumDigits = require('@pelevesque/sum-digits')
+
+const isObjectEmpty = (obj) =>
+  Object.entries(obj).length === 0 && obj.constructor === Object
+
+module.exports = (str, requiredSubstrings,
+  {
+    substringsToDigits = null,
+    sumPlainDigits = true,
+    allowSubstringBleeding = false
+  } = {}
+) => {
+  if (isObjectEmpty(requiredSubstrings)) return true
+  if (!isObjectEmpty(requiredSubstrings) && str === '') return false
+  for (let i = 0, len = str.length; i < len; i++) {
+    const sum = sumDigits(str.substr(0, i + 1), {
+      substringsToDigits: substringsToDigits,
+      sumPlainDigits: sumPlainDigits
+    })
+    if (requiredSubstrings.hasOwnProperty(sum)) {
+      let substring = requiredSubstrings[sum]
+      if (allowSubstringBleeding) {
+        const substringMaxLength = str.length - i - 1
+        if (substring.length > substringMaxLength) {
+          substring = substring.substr(0, substringMaxLength)
+        }
+      }
+      const target = str.substr(i + 1, substring.length)
+      if (substring.localeCompare(target) !== 0) {
+        break
+      } else {
+        delete requiredSubstrings[sum]
+      }
+    }
+  }
+  return isObjectEmpty(requiredSubstrings)
+}