compromise-speech 0.0.1

package/src/compute/syllables/postProcess.js

@@ -0,0 +1,107 @@
+const starts_with_single_vowel_combos = /^(eu)/i
+const joining_consonant_vowel = /^[^aeiou]e([^d]|$)/
+const cvcv_same_consonant = /^([^aeiouy])[aeiouy]\1[aeiouy]/
+const cvcv_same_vowel = /^[^aeiouy]([aeiouy])[^aeiouy]\1/
+const cvcv_known_consonants = /^([tg][aeiouy]){2}/
+const only_one_or_more_c = /^[^aeiouy]+$/
+
+const ends_with_vowel = /[aeiouy]$/
+const starts_with_consonant_vowel = /^[^aeiouy]h?[aeiouy]/
+
+const ones = [
+  /^[^aeiou]?ion/,
+  /^[^aeiou]?ised/,
+  /^[^aeiou]?iled/,
+
+  // -ing, -ent
+  /[aeiou]n[gt]$/,
+
+  // -ate, -age
+  /\wa[gt]e$/,
+]
+
+//suffix fixes
+const postprocess = function (arr) {
+  //trim whitespace
+  arr = arr.map(function (w) {
+    return w.trim()
+  })
+  arr = arr.filter(function (w) {
+    return w !== ''
+  })
+  // if (arr.length > 2) {
+  //   return arr;
+  // }
+  let l = arr.length
+  if (l > 1) {
+    let suffix = arr[l - 2] + arr[l - 1]
+    for (let i = 0; i < ones.length; i++) {
+      if (suffix.match(ones[i])) {
+        arr[l - 2] = arr[l - 2] + arr[l - 1]
+        arr.pop()
+      }
+    }
+  }
+
+  // since the open syllable detection is overzealous,
+  // sometimes need to rejoin incorrect splits
+  if (arr.length > 1) {
+    let first_is_open =
+      (arr[0].length === 1 || arr[0].match(starts_with_consonant_vowel)) &&
+      arr[0].match(ends_with_vowel)
+    let second_is_joining = arr[1].match(joining_consonant_vowel)
+
+    if (first_is_open && second_is_joining) {
+      let possible_combination = arr[0] + arr[1]
+      let probably_separate_syllables =
+        possible_combination.match(cvcv_same_consonant) ||
+        possible_combination.match(cvcv_same_vowel) ||
+        possible_combination.match(cvcv_known_consonants)
+
+      if (!probably_separate_syllables) {
+        arr[0] = arr[0] + arr[1]
+        arr.splice(1, 1)
+      }
+    }
+  }
+
+  if (arr.length > 1) {
+    let second_to_last_is_open =
+      arr[arr.length - 2].match(starts_with_consonant_vowel) &&
+      arr[arr.length - 2].match(ends_with_vowel)
+    let last_is_joining =
+      arr[arr.length - 1].match(joining_consonant_vowel) &&
+      ones.every(re => !arr[arr.length - 1].match(re))
+
+    if (second_to_last_is_open && last_is_joining) {
+      let possible_combination = arr[arr.length - 2] + arr[arr.length - 1]
+      let probably_separate_syllables =
+        possible_combination.match(cvcv_same_consonant) ||
+        possible_combination.match(cvcv_same_vowel) ||
+        possible_combination.match(cvcv_known_consonants)
+
+      if (!probably_separate_syllables) {
+        arr[arr.length - 2] = arr[arr.length - 2] + arr[arr.length - 1]
+        arr.splice(arr.length - 1, 1)
+      }
+    }
+  }
+
+  if (arr.length > 1) {
+    let single = arr[0] + arr[1]
+    if (single.match(starts_with_single_vowel_combos)) {
+      arr[0] = single
+      arr.splice(1, 1)
+    }
+  }
+
+  if (arr.length > 1) {
+    if (arr[arr.length - 1].match(only_one_or_more_c)) {
+      arr[arr.length - 2] = arr[arr.length - 2] + arr[arr.length - 1]
+      arr.splice(arr.length - 1, 1)
+    }
+  }
+
+  return arr
+}
+export default postprocess

package/src/compute/syllables/syllables.js

@@ -0,0 +1,90 @@
+//chop a string into pronounced syllables
+import postProcess from './postProcess.js'
+
+const all_spaces = / +/g
+const ends_with_vowel = /[aeiouy]$/
+const starts_with_consonant_vowel = /^[^aeiouy]h?[aeiouy]/
+const starts_with_e_then_specials = /^e[sm]/
+const starts_with_e = /^e/
+const ends_with_noisy_vowel_combos = /(eo|eu|ia|oa|ua|ui)$/i
+const aiouy = /[aiouy]/
+const ends_with_ee = /ee$/
+// const whitespace_dash = /\s\-/
+
+//method is nested because it's called recursively
+const doWord = function (w) {
+  let all = []
+  let chars = w.split('')
+  let before = ''
+  let after = ''
+  let current = ''
+  for (let i = 0; i < chars.length; i++) {
+    before = chars.slice(0, i).join('')
+    current = chars[i]
+    after = chars.slice(i + 1, chars.length).join('')
+    let candidate = before + chars[i]
+
+    //it's a consonant that comes after a vowel
+    if (before.match(ends_with_vowel) && !current.match(ends_with_vowel)) {
+      if (after.match(starts_with_e_then_specials)) {
+        candidate += 'e'
+        after = after.replace(starts_with_e, '')
+      }
+      all.push(candidate)
+      return all.concat(doWord(after))
+    }
+
+    //unblended vowels ('noisy' vowel combinations)
+    if (candidate.match(ends_with_noisy_vowel_combos)) {
+      //'io' is noisy, not in 'ion'
+      all.push(before)
+      all.push(current)
+      return all.concat(doWord(after)) //recursion
+    }
+
+    // if candidate is followed by a CV, assume consecutive open syllables
+    if (candidate.match(ends_with_vowel) && after.match(starts_with_consonant_vowel)) {
+      all.push(candidate)
+      return all.concat(doWord(after))
+    }
+  }
+  //if still running, end last syllable
+  if (w.match(aiouy) || w.match(ends_with_ee)) {
+    //allow silent trailing e
+    all.push(w)
+  } else if (w) {
+    let last = all.length - 1
+    if (last < 0) {
+      last = 0
+    }
+    all[last] = (all[last] || '') + w //append it to the last one
+  }
+  return all
+}
+
+let syllables = function (str) {
+  let all = []
+  if (!str) {
+    return all
+  }
+  str = str.replace(/[.,?]/g, '')
+  str.split(all_spaces).map(s => {
+    all = all.concat(doWord(s))
+  })
+
+  // str.split(whitespace_dash).forEach(doWord)
+  all = postProcess(all)
+
+  //for words like 'tree' and 'free'
+  if (all.length === 0) {
+    all = [str]
+  }
+  //filter blanks
+  all = all.filter(s => s)
+
+  return all
+}
+
+// console.log(syllables('civilised'))
+
+export default syllables

package/src/plugin.js

@@ -0,0 +1,7 @@
+import compute from './compute/index.js'
+import api from './api.js'
+
+export default {
+  api,
+  compute
+}

package/tests/_lib.js

@@ -0,0 +1,13 @@
+/* eslint-disable no-console */
+import build from '../../../builds/one/compromise-one.mjs'
+import src from '../../../src/one.js'
+let nlp = src
+import speech from '../src/plugin.js'
+
+// import dateBuild from '../builds/compromise-speech.js'
+if (process.env.TESTENV === 'prod') {
+  console.warn('== production build test 🚀 ==')
+  nlp = build
+}
+nlp.plugin(speech)
+export default nlp

package/tests/soundsLike.test.js

@@ -0,0 +1,21 @@
+import test from 'tape'
+import nlp from './_lib.js'
+
+test('soundsLike-tests', function (t) {
+  let arr = [
+    ['phil collins', 'fil kolins'],
+    ['Philadelphia freedom', 'filatelfia fretom'],
+    ['Shine on me', 'shine on me'],
+    ['peace of mind', 'pease of mint'],
+    ['Yes I do', 'yes i to'],
+    ['Zapped me', 'sapet me'],
+    ['Right between the eyes', 'rit betwen the eyes'],
+    // ['But the times have changed', 'but the times hafe kshanjet'],
+  ]
+  arr.forEach((a) => {
+    let doc = nlp(a[0])
+    let str = doc.soundsLike({})[0].join(' ')
+    t.equal(str, a[1], a[0])
+  })
+  t.end()
+})

package/tests/syllables.test.js

@@ -0,0 +1,73 @@
+import test from 'tape'
+import nlp from './_lib.js'
+
+const words = [
+  'sud den ly',
+  'con sti pa tion',
+  'di a bo lic',
+  'fa ted',
+  'ge ne tic',
+  'hy giene',
+  'o ma ha',
+  'i mi ta ted',
+  'tree',
+  'ci vi lised',
+  'went',
+  'to ge ther',
+  'tog gle',
+  'move ment',
+  'mo ment',
+  'do nate',
+  'vi king',
+  'wat tage',
+  'con gre gate',
+  'some thing',
+  'sales man',
+  're sour ces',
+  'eve ry thing',
+  'eve ry bo dy',
+  'hole',
+  'ho ly',
+  'sec ret',
+  'cause',
+  'fate',
+  'fates',
+  'eu lo gy',
+  'e on',
+  'rea sons',
+  'and',
+  'hoc key',
+  'wild',
+  'fun',
+  'fun ny',
+  'hor ses',
+  'cal ga ry',
+  'tor na do',
+  'pen',
+  'stu dy',
+  'ja mai ca',
+  'tri ni dad',
+  'ca na da',
+  'i ran',
+  'i raq',
+  'sau di a ra bi a',
+  'clin ton',
+  'hub ris',
+  'tur key',
+  'cor si ca',
+  'dev iled',
+  // 'horse',
+  // 'chance',
+  // 'peo ple'
+]
+
+test('test length', function (t) {
+  words.forEach(sep => {
+    let str = sep.replace(/ /g, '')
+    let doc = nlp(str)
+    let have = doc.syllables()[0]
+    let want = sep.split(/ /g)
+    t.equal(have.length, want.length, str)
+  })
+  t.end()
+})