Readded classes.js as file, modified files to work with new path

utils/classes.js

@@ -0,0 +1,509 @@
+var debugLogger = null
+
+function initLogger (logger) {
+  debugLogger = logger
+}
+
+function debugLog (msg, name, lvl) {
+  if (debugLogger) {
+    debugLogger(msg, name, lvl)
+  }
+}
+
+const commonUselessAnswerParts = [
+  'A helyes válasz az ',
+  'A helyes válasz a ',
+  'A helyes válaszok: ',
+  'A helyes válaszok:',
+  'A helyes válasz: ',
+  'A helyes válasz:',
+  'The correct answer is:',
+  '\''
+]
+const commonUselessStringParts = [
+  ',',
+  '\\.',
+  ':',
+  '!',
+  '\\+',
+  '\\s*\\.'
+]
+const specialChars = [ '&', '\\+' ]
+const lengthDiffMultiplier = 10 /* Percent minus for length difference */
+const minMatchAmmount = 60 /* Minimum ammount to consider that two questions match during answering */
+
+const assert = (val) => {
+  if (!val) { throw new Error('Assertion failed') }
+}
+
+class StringUtils {
+  GetSubjNameWithoutYear (subjName) {
+    let t = subjName.split(' - ')
+    if (t[0].match(/^[0-9]{4}\/[0-9]{2}\/[0-9]{1}$/i)) {
+      return t[1] || subjName
+    } else {
+      return subjName
+    }
+  }
+
+  RemoveStuff (value, removableStrings, toReplace) {
+    removableStrings.forEach((x) => {
+      var regex = new RegExp(x, 'g')
+      value = value.replace(regex, toReplace || '')
+    })
+    return value
+  }
+
+  SimplifyQuery (q) {
+    assert(q)
+
+    var result = q.replace(/\n/g, ' ').replace(/\s/g, ' ')
+    return this.RemoveUnnecesarySpaces(result)
+  }
+
+  ShortenString (toShorten, ammount) {
+    assert(toShorten)
+
+    var result = ''
+    var i = 0
+    while (i < toShorten.length && i < ammount) {
+      result += toShorten[i]
+      i++
+    }
+    return result
+  }
+
+  ReplaceCharsWithSpace (val, char) {
+    assert(val)
+    assert(char)
+
+    var toremove = this.NormalizeSpaces(val)
+
+    var regex = new RegExp(char, 'g')
+    toremove = toremove.replace(regex, ' ')
+
+    return this.RemoveUnnecesarySpaces(toremove)
+  }
+
+  // removes whitespace from begining and and, and replaces multiple spaces with one space
+  RemoveUnnecesarySpaces (toremove) {
+    assert(toremove)
+
+    toremove = this.NormalizeSpaces(toremove)
+    while (toremove.includes('  ')) {
+      toremove = toremove.replace(/ {2}/g, ' ')
+    }
+    return toremove.trim()
+  }
+
+  // simplifies a string for easier comparison
+  SimplifyStringForComparison (value) {
+    assert(value)
+
+    value = this.RemoveUnnecesarySpaces(value).toLowerCase()
+    return this.RemoveStuff(value, commonUselessStringParts)
+  }
+
+  RemoveSpecialChars (value) {
+    assert(value)
+
+    return this.RemoveStuff(value, specialChars, ' ')
+  }
+
+  // if the value is empty, or whitespace
+  EmptyOrWhiteSpace (value) {
+    // replaces /n-s with "". then replaces spaces with "". if it equals "", then its empty, or only consists of white space
+    if (value === undefined) { return true }
+    return (value.replace(/\n/g, '').replace(/ /g, '').replace(/\s/g, ' ') === '')
+  }
+
+  // damn nonbreaking space
+  NormalizeSpaces (input) {
+    assert(input)
+
+    return input.replace(/\s/g, ' ')
+  }
+
+  CompareString (s1, s2) {
+    if (!s1 || !s2) {
+      if (!s1 && !s2) {
+        return 100
+      } else {
+        return 0
+      }
+    }
+
+    s1 = this.SimplifyStringForComparison(s1).split(' ')
+    s2 = this.SimplifyStringForComparison(s2).split(' ')
+    var match = 0
+    for (var i = 0; i < s1.length; i++) {
+      if (s2.includes(s1[i])) { match++ }
+    }
+    var percent = Math.round(((match / s1.length) * 100).toFixed(2)) // matched words percent
+    var lengthDifference = Math.abs(s2.length - s1.length)
+    percent -= lengthDifference * lengthDiffMultiplier
+    if (percent < 0) { percent = 0 }
+    return percent
+  }
+
+  AnswerPreProcessor (value) {
+    assert(value)
+
+    return this.RemoveStuff(
+      value, commonUselessAnswerParts)
+  }
+
+  // 'a. pécsi sör' -> 'pécsi sör'
+  RemoveAnswerLetters (value) {
+    assert(value)
+
+    let s = value.split('. ')
+    if (s[0].length < 2 && s.length > 1) {
+      s.shift()
+      return s.join(' ')
+    } else {
+      return value
+    }
+  }
+
+  SimplifyQA (value, mods) {
+    if (!value) { return }
+
+    const reducer = (res, fn) => {
+      return fn(res)
+    }
+
+    return mods.reduce(reducer, value)
+  }
+
+  SimplifyAnswer (value) {
+    return this.SimplifyQA(
+      value,
+      [
+        this.RemoveSpecialChars.bind(this),
+        this.RemoveUnnecesarySpaces.bind(this),
+        this.AnswerPreProcessor.bind(this),
+        this.RemoveAnswerLetters.bind(this)
+      ])
+  }
+
+  SimplifyQuestion (value) {
+    return this.SimplifyQA(
+      value,
+      [
+        this.RemoveSpecialChars.bind(this),
+        this.RemoveUnnecesarySpaces.bind(this)
+      ])
+  }
+
+  SimplifyStack (stack) {
+    return this.SimplifyQuery(stack)
+  }
+}
+
+const SUtils = new StringUtils()
+
+class Question {
+  constructor (q, a, data) {
+    this.Q = SUtils.SimplifyQuestion(q)
+    this.A = SUtils.SimplifyAnswer(a)
+    this.data = { ...data }
+  }
+
+  toString () {
+    if (this.data.type !== 'simple') {
+      return '?' + this.Q + '\n!' + this.A + '\n>' + JSON.stringify(this.data)
+    } else {
+      return '?' + this.Q + '\n!' + this.A
+    }
+  }
+
+  HasQuestion () {
+    return this.Q !== undefined
+  }
+
+  HasAnswer () {
+    return this.A !== undefined
+  }
+
+  HasImage () {
+    return this.data.type === 'image'
+  }
+
+  IsComplete () {
+    return this.HasQuestion() && this.HasAnswer()
+  }
+
+  CompareImage (data2) {
+    return SUtils.CompareString(this.data.images.join(' '), data2.images.join(' '))
+  }
+
+  // returns -1 if botth is simple
+  CompareData (qObj) {
+    try {
+      if (qObj.data.type === this.data.type) {
+        let dataType = qObj.data.type
+        if (dataType === 'simple') {
+          return -1
+        } else if (dataType === 'image') {
+          return this.CompareImage(qObj.data)
+        } else {
+          debugLog(`Unhandled data type ${dataType}`, 'Compare question data', 1)
+          debugLog(qObj, 'Compare question data', 2)
+        }
+      } else {
+        return 0
+      }
+    } catch (e) {
+      debugLog('Error comparing data', 'Compare question data', 1)
+      debugLog(e.message, 'Compare question data', 1)
+      debugLog(e, 'Compare question data', 2)
+    }
+    return 0
+  }
+
+  CompareQuestion (qObj) {
+    return SUtils.CompareString(this.Q, qObj.Q)
+  }
+
+  CompareAnswer (qObj) {
+    return SUtils.CompareString(this.A, qObj.A)
+  }
+
+  // TODO: return q / a / data match for debuging
+  Compare (q2, data) {
+    assert(q2)
+    let qObj
+
+    if (typeof q2 === 'string') {
+      qObj = {
+        Q: q2,
+        data: data
+      }
+    } else {
+      qObj = q2
+    }
+
+    const qMatch = this.CompareQuestion(qObj)
+    const aMatch = this.CompareAnswer(qObj)
+    // -1 if botth questions are simple
+    const dMatch = this.CompareData(qObj)
+
+    let avg = -1
+    if (qObj.A) {
+      if (dMatch === -1) {
+        avg = (qMatch + aMatch) / 2
+      } else {
+        avg = (qMatch + aMatch + dMatch) / 3
+      }
+    } else {
+      if (dMatch === -1) {
+        avg = qMatch
+      } else {
+        avg = (qMatch + dMatch) / 2
+      }
+    }
+
+    return {
+      qMatch: qMatch,
+      aMatch: aMatch,
+      dMatch: dMatch,
+      avg: avg
+    }
+  }
+}
+
+class Subject {
+  constructor (n) {
+    assert(n)
+
+    this.Name = n
+    this.Questions = []
+  }
+
+  setIndex (i) {
+    this.index = i
+  }
+
+  getIndex () {
+    return this.index
+  }
+
+  get length () {
+    return this.Questions.length
+  }
+
+  AddQuestion (q) {
+    assert(q)
+
+    this.Questions.push(q)
+  }
+
+  getSubjNameWithoutYear () {
+    return SUtils.GetSubjNameWithoutYear(this.Name)
+  }
+
+  getYear () {
+    let t = this.Name.split(' - ')[0]
+    if (t.match(/^[0-9]{4}\/[0-9]{2}\/[0-9]{1}$/i)) {
+      return t
+    } else {
+      return ''
+    }
+  }
+
+  Search (q, data) {
+    assert(q)
+
+    var r = []
+    for (let i = 0; i < this.length; i++) {
+      let percent = this.Questions[i].Compare(q, data)
+      if (percent.avg > minMatchAmmount) {
+        r.push({
+          q: this.Questions[i],
+          match: percent.avg,
+          detailedMatch: percent
+        })
+      }
+    }
+
+    for (let i = 0; i < r.length; i++) {
+      for (var j = i; j < r.length; j++) {
+        if (r[i].match < r[j].match) {
+          var tmp = r[i]
+          r[i] = r[j]
+          r[j] = tmp
+        }
+      }
+    }
+
+    return r
+  }
+
+  toString () {
+    var r = []
+    for (var i = 0; i < this.Questions.length; i++) { r.push(this.Questions[i].toString()) }
+    return '+' + this.Name + '\n' + r.join('\n')
+  }
+}
+
+class QuestionDB {
+  constructor () {
+    this.Subjects = []
+  }
+
+  get length () {
+    return this.Subjects.length
+  }
+
+  AddQuestion (subj, q) {
+    debugLog('Adding new question with subjName: ' + subj, 'qdb add', 1)
+    debugLog(q, 'qdb add', 3)
+    assert(subj)
+
+    var i = 0
+    while (i < this.Subjects.length &&
+      !subj.toLowerCase().includes(this.Subjects[i].getSubjNameWithoutYear().toLowerCase())) {
+      i++
+    }
+
+    if (i < this.Subjects.length) {
+      debugLog('Adding new question to existing subject', 'qdb add', 1)
+      this.Subjects[i].AddQuestion(q)
+    } else {
+      debugLog('Creating new subject for question', 'qdb add', 1)
+      const n = new Subject(subj)
+      n.AddQuestion(q)
+      this.Subjects.push(n)
+    }
+  }
+
+  SimplifyQuestion (q) {
+    if (typeof q === 'string') {
+      return SUtils.SimplifyQuestion(q)
+    } else {
+      q.Q = SUtils.SimplifyQuestion(q.Q)
+      q.A = SUtils.SimplifyQuestion(q.A)
+      return q
+    }
+  }
+
+  Search (q, subjName, data) {
+    assert(q)
+    debugLog('Searching for question', 'qdb search', 1)
+    debugLog('Question:', 'qdb search', 2)
+    debugLog(q, 'qdb search', 2)
+    debugLog(`Subject name: ${subjName}`, 'qdb search', 2)
+    debugLog('Data:', 'qdb search', 2)
+    debugLog(data || q.data, 'qdb search', 2)
+
+    if (!data) {
+      data = q.data || { type: 'simple' }
+    }
+    if (!subjName) {
+      subjName = ''
+      debugLog('No subject name as param!', 'qdb search', 1)
+    }
+    q = this.SimplifyQuestion(q)
+
+    var r = []
+    this.Subjects.forEach((subj) => {
+      if (subjName.toLowerCase().includes(subj.getSubjNameWithoutYear().toLowerCase())) {
+        debugLog(`Searching in ${subj.Name} `, 2)
+        r = r.concat(subj.Search(q, data))
+      }
+    })
+
+    // FIXME: try to remove this? but this is also a good backup plan so idk
+    if (r.length === 0) {
+      debugLog('Reqults length is zero when comparing names, trying all subjects', 'qdb search', 1)
+      this.Subjects.forEach((subj) => {
+        r = r.concat(subj.Search(q, data))
+      })
+      if (r.length > 0) {
+        debugLog(`FIXME: '${subjName}' gave no result but '' did!`, 'qdb search', 1)
+        console.error(`FIXME: '${subjName}' gave no result but '' did!`)
+      }
+    }
+
+    for (let i = 0; i < r.length; i++) {
+      for (var j = i; j < r.length; j++) {
+        if (r[i].match < r[j].match) {
+          var tmp = r[i]
+          r[i] = r[j]
+          r[j] = tmp
+        }
+      }
+    }
+
+    debugLog(`QDB search result length: ${r.length}`, 'qdb search', 1)
+    return r
+  }
+
+  AddSubject (subj) {
+    assert(subj)
+
+    var i = 0
+    while (i < this.length && subj.Name !== this.Subjects[i].Name) { i++ }
+
+    if (i < this.length) {
+      this.Subjects.concat(subj.Questions)
+    } else {
+      this.Subjects.push(subj)
+    }
+  }
+
+  toString () {
+    var r = []
+    for (var i = 0; i < this.Subjects.length; i++) { r.push(this.Subjects[i].toString()) }
+    return r.join('\n\n')
+  }
+}
+
+module.exports.StringUtils = StringUtils // TODO: export singleton string utils, remove nea StringUtils from other files
+module.exports.SUtils = SUtils
+module.exports.Question = Question
+module.exports.Subject = Subject
+module.exports.QuestionDB = QuestionDB
+module.exports.minMatchAmmount = minMatchAmmount
+module.exports.initLogger = initLogger