de-compromise 0.0.9 → 0.1.0

package/src/03-three/numbers/api.js

@@ -0,0 +1,259 @@
+import parse from './parse/index.js'
+import format from './format/index.js'
+
+// return the nth elem of a doc
+export const getNth = (doc, n) => (typeof n === 'number' ? doc.eq(n) : doc)
+
+const api = function (View) {
+  /**   */
+  class Numbers extends View {
+    constructor(document, pointer, groups) {
+      super(document, pointer, groups)
+      this.viewType = 'Numbers'
+    }
+    parse(n) {
+      return getNth(this, n).map(parse)
+    }
+    get(n) {
+      return getNth(this, n).map(parse).map(o => o.num)
+    }
+    json(n) {
+      let doc = getNth(this, n)
+      return doc.map(p => {
+        let json = p.toView().json(n)[0]
+        let parsed = parse(p)
+        json.number = {
+          prefix: parsed.prefix,
+          num: parsed.num,
+          suffix: parsed.suffix,
+          hasComma: parsed.hasComma,
+        }
+        return json
+      }, [])
+    }
+    /** any known measurement unit, for the number */
+    units() {
+      return this.growRight('#Unit').match('#Unit$')
+    }
+    /** return only ordinal numbers */
+    isOrdinal() {
+      return this.if('#Ordinal')
+    }
+    /** return only cardinal numbers*/
+    isCardinal() {
+      return this.if('#Cardinal')
+    }
+
+    /** convert to numeric form like '8' or '8th' */
+    toNumber() {
+      let m = this.if('#TextValue')
+      let res = m.map(val => {
+        let obj = parse(val)
+        if (obj.num === null) {
+          return val
+        }
+        let fmt = val.has('#Ordinal') ? 'Ordinal' : 'Cardinal'
+        let str = format(obj, fmt)
+        if (str) {
+          val.replaceWith(str, { tags: true })
+          val.tag('NumericValue')
+        }
+        return val
+      })
+      return new Numbers(res.document, res.pointer)
+    }
+    /** convert to numeric form like 'eight' or 'eighth' */
+    toText() {
+      let m = this
+      let res = m.map(val => {
+        if (val.has('#TextValue')) {
+          return val
+        }
+        let obj = parse(val)
+        if (obj.num === null) {
+          return val
+        }
+        let fmt = val.has('#Ordinal') ? 'TextOrdinal' : 'TextCardinal'
+        let str = format(obj, fmt)
+        if (str) {
+          val.replaceWith(str, { tags: true })
+          val.tag('TextValue')
+        }
+        return val
+      })
+      return new Numbers(res.document, res.pointer)
+    }
+    /** convert ordinal to cardinal form, like 'eight', or '8' */
+    toCardinal() {
+      let m = this
+      let res = m.map(val => {
+        if (!val.has('#Ordinal')) {
+          return val
+        }
+        let obj = parse(val)
+        if (obj.num === null) {
+          return val
+        }
+        let fmt = val.has('#TextValue') ? 'TextCardinal' : 'Cardinal'
+        let str = format(obj, fmt)
+        if (str) {
+          val.replaceWith(str, { tags: true })
+          val.tag('Cardinal')
+        }
+        return val
+      })
+      return new Numbers(res.document, res.pointer)
+    }
+    /** convert cardinal to ordinal form, like 'eighth', or '8th' */
+    toOrdinal() {
+      let m = this
+      let res = m.map(val => {
+        if (val.has('#Ordinal')) {
+          return val
+        }
+        let obj = parse(val)
+        if (obj.num === null) {
+          return val
+        }
+        let fmt = val.has('#TextValue') ? 'TextOrdinal' : 'Ordinal'
+        let str = format(obj, fmt)
+        if (str) {
+          val.replaceWith(str, { tags: true })
+          val.tag('Ordinal')
+        }
+        return val
+      })
+      return new Numbers(res.document, res.pointer)
+    }
+
+    /** return only numbers that are == n */
+    isEqual(n) {
+      return this.filter((val) => {
+        let num = parse(val).num
+        return num === n
+      })
+    }
+    /** return only numbers that are > n*/
+    greaterThan(n) {
+      return this.filter((val) => {
+        let num = parse(val).num
+        return num > n
+      })
+    }
+    /** return only numbers that are < n*/
+    lessThan(n) {
+      return this.filter((val) => {
+        let num = parse(val).num
+        return num < n
+      })
+    }
+    /** return only numbers > min and < max */
+    between(min, max) {
+      return this.filter((val) => {
+        let num = parse(val).num
+        return num > min && num < max
+      })
+    }
+    /** set these number to n */
+    set(n) {
+      if (n === undefined) {
+        return this // don't bother
+      }
+      if (typeof n === 'string') {
+        n = parse(n).num
+      }
+      let m = this
+      let res = m.map((val) => {
+        let obj = parse(val)
+        obj.num = n
+        if (obj.num === null) {
+          return val
+        }
+        let fmt = val.has('#Ordinal') ? 'Ordinal' : 'Cardinal'
+        if (val.has('#TextValue')) {
+          fmt = val.has('#Ordinal') ? 'TextOrdinal' : 'TextCardinal'
+        }
+        let str = format(obj, fmt)
+        // re-group thousands - '1.234.567'
+        if (obj.hasComma && fmt === 'Cardinal') {
+          str = obj.num.toLocaleString('de-DE')
+        }
+        if (str) {
+          val = val.not('#Currency')
+          val.replaceWith(str, { tags: true })
+          // handle plural/singular unit
+          // agreeUnits(agree, val, obj)
+        }
+        return val
+      })
+      return new Numbers(res.document, res.pointer)
+    }
+    add(n) {
+      if (!n) {
+        return this // don't bother
+      }
+      if (typeof n === 'string') {
+        n = parse(n).num
+      }
+      let m = this
+      let res = m.map((val) => {
+        let obj = parse(val)
+        if (obj.num === null) {
+          return val
+        }
+        obj.num += n
+        let fmt = val.has('#Ordinal') ? 'Ordinal' : 'Cardinal'
+        if (obj.isText) {
+          fmt = val.has('#Ordinal') ? 'TextOrdinal' : 'TextCardinal'
+        }
+        let str = format(obj, fmt)
+        if (str) {
+          val.replaceWith(str, { tags: true })
+          // handle plural/singular unit
+          // agreeUnits(agree, val, obj)
+        }
+        return val
+      })
+      return new Numbers(res.document, res.pointer)
+    }
+    /** decrease each number by n*/
+    subtract(n, agree) {
+      return this.add(n * -1, agree)
+    }
+    /** increase each number by 1 */
+    increment(agree) {
+      return this.add(1, agree)
+    }
+    /** decrease each number by 1 */
+    decrement(agree) {
+      return this.add(-1, agree)
+    }
+    // overloaded - keep Numbers class
+    update(pointer) {
+      let m = new Numbers(this.document, pointer)
+      m._cache = this._cache // share this full thing
+      return m
+    }
+  }
+  // aliases
+  Numbers.prototype.isBetween = Numbers.prototype.between
+  Numbers.prototype.minus = Numbers.prototype.subtract
+  Numbers.prototype.plus = Numbers.prototype.add
+  Numbers.prototype.equals = Numbers.prototype.isEqual
+
+  View.prototype.numbers = function (n) {
+    let m = this.match('#Value+')
+    // most numbers are 1-term
+    // but very-large numbers get broken up 'zwei Millionen eins'
+    if (!m.has('(million|millionen|milliarde)')) {
+      m = m.terms()
+    }
+    // make sure splitter has run
+    m.compute('splitter')
+    m = getNth(m, n)
+    return new Numbers(this.document, m.pointer)
+  }
+  // alias
+  View.prototype.values = View.prototype.numbers
+}
+export default api

package/src/03-three/numbers/data.js

@@ -0,0 +1,77 @@
+let data = {
+  ones: [
+    [1, 'eins', 'erste'],
+    [2, 'zwei', 'zweite'],
+    [3, 'drei', 'dritte'],
+    [4, 'vier', 'vierte'],
+    [5, 'fünf', 'fünfte'],
+    [6, 'sechs', 'sechste'],
+    [7, 'sieben', 'siebente'], //siebte
+    [8, 'acht', 'achte'],
+    [9, 'neun', 'neunte'],
+  ],
+  teens: [
+    [10, 'zehn', 'zehnte'],
+    [11, 'elf', 'elfte'],
+    [12, 'zwölf', 'zwölfte'],
+    [13, 'dreizehn', 'dreizehnte'],
+    [14, 'vierzehn', 'vierzehnte'],
+    [15, 'fünfzehn', 'fünfzehnte'],
+    [16, 'sechzehn', 'sechzehnte'],
+    [17, 'siebzehn', 'siebzehnte'],
+    [18, 'achtzehn', 'achtzehnte'],
+    [19, 'neunzehn', 'neunzehnte'],
+  ],
+  tens: [
+    [20, 'zwanzig', 'zwanzigste'],
+    [30, 'dreißig', 'dreißigste'],
+    [40, 'vierzig', 'vierzigste'],
+    [50, 'fünfzig', 'fünfzigste'],
+    [60, 'sechzig', 'sechzigste'],
+    [70, 'siebzig', 'siebzigste'],
+    [80, 'achtzig', 'achtzigste'],
+    [90, 'neunzig', 'neunzigste'],
+  ],
+  hundreds: [
+    [100, 'einhundert', 'hundertste'],
+    // [101, 'einhunderteins', 'hunderterste'],
+    [200, 'zweihundert', 'zweihundertste'],
+    [300, 'dreihundert', 'dreihundertste'],
+    [400, 'vierhundert', 'vierhundertste'],
+    [500, 'fünfhundert', 'fünfhundertste'],
+    [600, 'sechshundert', 'sechshundertste'],
+    [700, 'siebenhundert', 'siebenhundertste'],
+    [800, 'achthundert', 'achthundertste'],
+    [900, 'neunhundert', 'neunhundertste'],
+  ],
+  multiples: [
+    [100, 'hundert', 'hundertste'],
+    [1000, 'tausend', 'tausendste'],
+    [100000, 'hunderttausend', 'hunderttausendste'],
+    [1000000, 'million', 'millionste'],
+  ]
+}
+const toCardinal = {}
+const toOrdinal = {}
+const toNumber = {}
+
+Object.keys(data).forEach(k => {
+  data[k].forEach(a => {
+    let [num, w, ord] = a
+    toCardinal[ord] = w
+    toOrdinal[w] = ord
+    toNumber[w] = num
+  })
+})
+
+const isMultiple = new Set(data.multiples.map(a => a[1]))
+
+// misc
+toNumber.ein = 1 // eins - ein
+toNumber.hunderteins = 101
+toCardinal.siebte = 'sieben'
+toCardinal.hunderterste = 'hunderteins'
+toOrdinal.hunderteins = 'hunderterste'
+
+
+export { data, toCardinal, toOrdinal, toNumber, isMultiple }

package/src/03-three/numbers/format/index.js

@@ -0,0 +1,27 @@
+import toText from './toText.js'
+import { toOrdinal } from '../data.js'
+
+
+const formatNumber = function (parsed, fmt) {
+  if (fmt === 'TextOrdinal') {
+    let words = toText(parsed.num)
+    let last = words[words.length - 1]
+    words[words.length - 1] = toOrdinal[last]
+    return words.join('')
+  }
+  if (fmt === 'TextCardinal') {
+    return toText(parsed.num).join('')
+  }
+  // numeric formats
+  // '55e'
+  if (fmt === 'Ordinal') {
+    let str = String(parsed.num)
+    return str += '.'
+  }
+  if (fmt === 'Cardinal') {
+    // german decimals use a comma - '12,5'
+    return String(parsed.num).replace('.', ',')
+  }
+  return String(parsed.num || '').replace('.', ',')
+}
+export default formatNumber

package/src/03-three/numbers/format/toText.js

@@ -0,0 +1,118 @@
+import { data } from '../data.js'
+let tens = data.tens.reverse()
+let teens = data.teens.reverse()
+let ones = data.ones.reverse()
+let hundreds = data.hundreds.reverse()
+
+
+const doThousands = function (num) {
+  let words = []
+  // hunderttausend
+  if (num >= 100000) {
+    for (let i = 0; i < ones.length; i += 1) {
+      if (num >= ones[i][0] * 100000) {
+        let found = ones[i][0] === 1 ? 'ein' : ones[i][1]
+        words.push(found)
+        words.push('hunderttausend')
+        num -= teens[i][0] * 100000
+      }
+    }
+  }
+  // eleven-thousand...
+  if (num >= 10000) {
+    for (let i = 0; i < teens.length; i += 1) {
+      if (num >= teens[i][0] * 1000) {
+        words.push(teens[i][1])
+        words.push('tausend')
+        num -= teens[i][0] * 1000
+      }
+    }
+  }
+  // dreitausend, viertausend...
+  for (let i = 0; i < ones.length; i += 1) {
+    if (num >= ones[i][0] * 1000) {
+      let found = ones[i][0] === 1 ? 'ein' : ones[i][1]
+      return [found, 'tausend']
+    }
+  }
+  return words
+}
+
+const doHundreds = function (num) {
+  let words = []
+  for (let i = 0; i < hundreds.length; i += 1) {
+    if (num >= hundreds[i][0]) {
+      words.push(hundreds[i][1])
+      num -= hundreds[i][0]
+      break
+    }
+  }
+  return words
+}
+
+// 23 -> '[drei][und][zwanzig]'
+const twoDigit = function (num) {
+  let words = []
+  // ninety, eighty ...
+  for (let i = 0; i < tens.length; i += 1) {
+    if (num >= tens[i][0]) {
+      words.push(tens[i][1])
+      num -= tens[i][0]
+    }
+  }
+  // found nothing? look for teens
+  if (words.length === 0) {
+    for (let i = 0; i < teens.length; i += 1) {
+      if (num === teens[i][0]) {
+        return [teens[i][1]] //these don't combine
+      }
+    }
+  }
+  // look for ones to add on
+  for (let i = 0; i < ones.length; i += 1) {
+    if (num === ones[i][0]) {
+      // drei und zwanzig
+      if (words.length === 1) {
+        // use '[ein][und][zwanzig]', not 'eins..'
+        let found = ones[i][0] === 1 ? 'ein' : ones[i][1]
+        return [found, 'und', words[0]]
+      }
+      // just 'drei'
+      if (words.length === 0) {
+        return [ones[i][1]]
+      }
+    }
+  }
+  return words
+}
+
+
+// turn 130 into '[ein][hundert][dreißig]'
+const toText = function (num) {
+  let words = []
+  if (num === 0) {
+    return ['null']
+  }
+  if (num < 0) {
+    words.push('moins')
+    num = Math.abs(num)
+  }
+  // do '[sieben][tausend]'
+  if (num >= 1000) {
+    let res = doThousands(num)
+    words = words.concat(res)
+    num %= 1000
+  }
+  // do '[zwei][hundert]'
+  if (num >= 100) {
+    let res = doHundreds(num)
+    words = words.concat(res)
+    num %= 100
+  }
+  // do '[drei][und][zwanzig]'
+  if (num > 0) {
+    words = words.concat(twoDigit(num))
+  }
+  return words
+}
+export default toText

package/src/03-three/numbers/parse/fromText.js

@@ -0,0 +1,52 @@
+import { toCardinal, toNumber, isMultiple } from '../data.js'
+
+const parseNumbers = function (terms = []) {
+  let sum = 0
+  let carry = 0
+  let minus = false
+
+  let words = terms[0].splits || []
+  // console.log(words)
+  let tags = terms[0].tags
+  for (let i = 0; i < words.length; i += 1) {
+    let w = words[i]
+
+    if (w === 'minus') {
+      minus = true
+      continue
+    }
+    // ...  [ein][und][zwanzig]
+    if (w === 'und') {
+      continue
+    }
+    // 'huitieme'
+    if (tags.has('Ordinal')) {
+      w = toCardinal[w] || w
+    }
+    // 'hundert'
+    if (isMultiple.has(w)) {
+      let mult = toNumber[w] || 1
+      if (carry === 0) {
+        carry = 1
+      }
+      sum += mult * carry
+      carry = 0
+      continue
+    }
+    // 'fünf'
+    if (toNumber.hasOwnProperty(w)) {
+      carry += toNumber[w]
+      // console.log(w, carry)
+    }
+  }
+  // include any remaining
+  if (carry !== 0) {
+    sum += carry
+  }
+  // make it all negative
+  if (minus === true) {
+    sum *= -1
+  }
+  return sum
+}
+export default parseNumbers

package/src/03-three/numbers/parse/index.js

@@ -0,0 +1,63 @@
+import fromText from './fromText.js'
+
+const fromNumber = function (m) {
+  // use the raw text - normalization strips the german decimal-comma
+  let str = (m.text() || m.text('normal')).toLowerCase().trim()
+  str = str.replace(/(e|er)$/, '')
+  // get prefix/suffix
+  let arr = str.split(/([0-9.,]*)/)
+  let [prefix, num] = arr
+  let suffix = arr.slice(2).join('')
+  // german format - '.' groups thousands, ',' marks the decimal
+  num = num.replace(/[.,]$/, '')
+  let hasComma = /\d\.\d/.test(num)
+  num = num.replace(/\./g, '').replace(/,/, '.')
+  if (num !== '' && m.length < 2) {
+    num = Number(num)
+    //ensure that num is an actual number
+    if (typeof num !== 'number' || isNaN(num)) {
+      num = null
+    } else if (/-$/.test(prefix)) {
+      num = num * -1
+    }
+    // strip an ordinal off the suffix
+    if (suffix === 'e' || suffix === 'er') {
+      suffix = ''
+    }
+  }
+  return {
+    hasComma,
+    prefix,
+    num,
+    suffix,
+  }
+}
+
+const parseNumber = function (m) {
+  let terms = m.docs[0]
+  let num = null
+  let prefix = ''
+  let suffix = ''
+  let hasComma = false
+  let isText = m.has('#TextValue')
+  if (isText) {
+    num = fromText(terms)
+  } else {
+    let res = fromNumber(m)
+    prefix = res.prefix
+    suffix = res.suffix
+    num = res.num
+    hasComma = res.hasComma
+  }
+  return {
+    hasComma,
+    prefix,
+    num,
+    suffix,
+    isText,
+    isOrdinal: m.has('#Ordinal'),
+    isFraction: m.has('#Fraction'),
+    isMoney: m.has('#Money'),
+  }
+}
+export default parseNumber

package/src/03-three/numbers/plugin.js

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

package/src/03-three/verbs/api.js

@@ -0,0 +1,41 @@
+export const getNth = (doc, n) => (typeof n === 'number' ? doc.eq(n) : doc)
+
+// get root form of adjective
+const getRoot = function (m) {
+  let r = m.not('(#Adverb|#Auxiliary|#Modal)')
+  r = r.eq(0).compute('root')
+  return r.text('root')
+}
+
+const api = function (View) {
+  class Verbs extends View {
+    constructor(document, pointer, groups) {
+      super(document, pointer, groups)
+      this.viewType = 'Verbs'
+    }
+    conjugate(n) {
+      const methods = this.methods.two.transform.verb
+      const { toPresent, toPast, toSubjunctive1, toSubjunctive2, toImperative, toPastParticiple, toPresentParticiple } = methods
+      return getNth(this, n).map(m => {
+        let str = getRoot(m, methods)
+        return {
+          infinitive: str,
+          presentTense: toPresent(str),
+          pastTense: toPast(str),
+          subjunctive1: toSubjunctive1(str),
+          subjunctive2: toSubjunctive2(str),
+          imperative: toImperative(str),
+          pastParticiple: toPastParticiple(str),
+          presentParticiple: toPresentParticiple(str)
+        }
+      }, [])
+    }
+  }
+
+  View.prototype.verbs = function (n) {
+    let m = this.match('#Verb+')
+    m = getNth(m, n)
+    return new Verbs(this.document, m.pointer)
+  }
+}
+export default api

package/src/03-three/verbs/plugin.js

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

package/src/_lib.js

@@ -0,0 +1,4 @@
+// console.log('local-path')
+// import nlp from '/Users/spencer/mountain/compromise/src/one.js'
+import nlp from 'compromise/one'
+export default nlp

package/src/_version.js

@@ -0,0 +1 @@
+export default '0.1.0'