Initial commit

Author: kunaltaitkar

.gitignore

@@ -0,0 +1 @@
+node_modules/

package.json

@@ -0,0 +1,30 @@
+{
+  "name": "vue-script-parser",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kunaltaitkar/vue-script-parser.git"
+  },
+  "keywords": [
+    "vue",
+    "vue-parser",
+    "vue-script",
+    "vue",
+    "script",
+    "javascript",
+    "vue",
+    "code",
+    "parser"
+  ],
+  "author": "Kunal Taitkar",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/kunaltaitkar/vue-script-parser/issues"
+  },
+  "homepage": "https://github.com/kunaltaitkar/vue-script-parser#readme"
+}

src/Demo.vue

@@ -0,0 +1,41 @@
+<template>
+  <div>
+    <div class="inline-div">
+      <p align="center">Input</p>
+      <textarea cols="91" @input="parseCode" rows="39" class="inline-txtarea" v-model="input"></textarea>
+    </div>
+    <div class="inline-div">
+      <p align="center">Output</p>
+      <textarea cols="91" rows="39" class="inline-txtarea" v-model="output"></textarea>
+    </div>
+  </div>
+</template>
+
+<script>
+import VueScriptParser from './plugin/index'
+export default {
+  data() {
+    return {
+      input: ``,
+      output: '{}',
+    }
+  },
+  methods: {
+    parseCode() {
+      let instance = new VueScriptParser(this.input)
+      this.output = JSON.stringify(instance, undefined, 2)
+    },
+  },
+}
+</script>
+
+<style>
+.inline-div {
+  display: inline-block;
+}
+.inline-txtarea {
+  resize: none;
+  border: 2px solid;
+  /* height:125px; */
+}
+</style>

src/plugin/common.js

@@ -0,0 +1,33 @@
+
+const scriptSectionProcessing = function (vueScript, regx) {
+    let methodsString = vueScript
+    if (regx) {
+        var extract = vueScript.match(regx)
+        methodsString = extract[0]
+    }
+    let stackP = []
+    let firstIndex = null
+    let lastIndex = null
+    for (let i = 0; i < methodsString.length; i++) {
+        if (methodsString[i] === '{') {
+            if (stackP.length === 0) {
+                firstIndex = i
+            }
+            stackP.push(methodsString[i])
+        }
+        if (methodsString[i] === '}') {
+            stackP.pop()
+            if (stackP.length === 0) {
+                lastIndex = i
+                break
+            }
+        }
+    }
+    return {
+        methodsString,
+        firstIndex,
+        lastIndex
+    }
+}
+
+export { scriptSectionProcessing }

src/plugin/data.js

@@ -0,0 +1,68 @@
+
+import Vue from 'vue'
+class Data {
+    constructor(vueScript = '') {
+        this.data = this.setData(vueScript)
+    }
+
+    setData (vueScript = '') {
+        let dataRegx = /data\s*\(\s*\)\s*\{\s*return\s*{([^]*)}/g
+        let processedData = this.extractAndUpdateData(vueScript, dataRegx)
+
+        let dataFunc = new Function('return {' + processedData.oldData + '}')
+        let vm = new Vue({
+            data: dataFunc
+        })
+
+
+        let result = []
+
+        Object.keys(vm._data).forEach(key => {
+            result.push({
+                key: key,
+                value: vm._data[key]
+            })
+        })
+
+
+        return result
+    }
+    extractAndUpdateData (vueScript, regx) {
+        let data = this.dataSectionProcessing(vueScript, regx)
+        let oldData = data.methodsString.substring(
+            data.firstIndex + 1,
+            data.lastIndex
+        )
+        return { oldData, data }
+    }
+    dataSectionProcessing (stringToBeProcessed, regx) {
+        let methodsString = stringToBeProcessed
+        if (regx) {
+            var extract = stringToBeProcessed.match(regx)
+            methodsString = extract[0]
+        }
+        let stackP = []
+        let firstIndex = null
+        let lastIndex = null
+        for (let i = 0; i < methodsString.length; i++) {
+            if (methodsString[i] === '{') {
+                if (stackP.length === 1) {
+                    firstIndex = i
+                }
+                stackP.push(methodsString[i])
+            }
+            if (methodsString[i] === '}') {
+                stackP.pop()
+                if (stackP.length === 1) {
+                    lastIndex = i
+                    break
+                }
+            }
+        }
+        return { methodsString, firstIndex, lastIndex }
+    }
+
+
+}
+
+export default Data

src/plugin/imports.js

@@ -0,0 +1,12 @@
+class Imports {
+    constructor(vueScript = '') {
+        this.imports = this.setImports(vueScript) || []
+    }
+    setImports (vueScript) {
+        return vueScript.match(/import .*/g)
+    }
+
+}
+
+
+export default Imports

src/plugin/index.js

@@ -0,0 +1,25 @@
+import Data from './data'
+import Methods from './methods'
+import Mounted from './mounted'
+import Imports from './imports'
+class VueScriptParser {
+    constructor(vueScript = '') {
+        //load imports
+        let importsProcessor = new Imports(vueScript)
+        this.imports = importsProcessor.imports
+
+        //load data
+        let dataProcessor = new Data(vueScript)
+        this.data = dataProcessor.data
+
+        //load mounted
+        let mountedProcessor = new Mounted(vueScript)
+        this.mounted = mountedProcessor.mounted
+
+        //load methods
+        let methodsProcessor = new Methods(vueScript)
+        this.methods = methodsProcessor.methods
+    }
+}
+
+export default VueScriptParser

src/plugin/methods.js

@@ -0,0 +1,106 @@
+import { scriptSectionProcessing } from './common'
+
+class Methods {
+    constructor(vueScript = '') {
+        this.methods = this.setMethod(vueScript)
+    }
+    setMethod (vueScript = '') {
+        let regx = /methods\s*:\s*{([^]*)}/g
+        let matchMethods = vueScript.match(regx)
+        if (!matchMethods) {
+            let data = scriptSectionProcessing(vueScript)
+
+            vueScript =
+                data.methodsString.substring(0, data.lastIndex) +
+                ',\n methods : {}\n' +
+                data.methodsString[data.lastIndex]
+        }
+        let methodsData = this.extractMethodsFromScript(regx, vueScript)
+
+        return methodsData || []
+
+    }
+    extractMethodsFromScript (regx, vueScript = '') {
+        let { methodsString, firstIndex, lastIndex } = scriptSectionProcessing(
+            vueScript,
+            regx
+        )
+        return this.makeArrayOfMethods(
+            methodsString.substring(firstIndex + 1, lastIndex)
+        )
+    }
+
+    makeArrayOfMethods (methodsStr) {
+        let methodDetails = []
+        let arrayOfFirstIndexes = []
+        let arrayOfLastIndexes = []
+        let bracesStk = []
+        let fIndex = 0
+        let lIndex = -2
+        var functionName = ''
+        if (methodsStr) {
+            for (let i = 0; i < methodsStr.length; i++) {
+                if (bracesStk.length === 0 && methodsStr[i] === '(') {
+                    functionName = methodsStr
+                        .substring(lIndex + 2, i)
+                        .split('\n')
+                        .join('')
+                        .split(' ')
+                        .join('')
+                }
+                if (methodsStr[i] === '{') {
+                    if (bracesStk.length === 0) {
+                        fIndex = i
+                        arrayOfFirstIndexes.push(fIndex)
+                    }
+                    bracesStk.push(methodsStr[i])
+                }
+                if (methodsStr[i] === '}') {
+                    bracesStk.pop()
+                    if (bracesStk.length === 0) {
+                        lIndex = i
+                        arrayOfLastIndexes.push(lIndex)
+                        var obj = {
+                            name: functionName,
+                            body: methodsStr.substring(fIndex + 1, lIndex),
+                            arguments: []
+                        }
+                        methodDetails.push(obj)
+                    }
+                }
+            }
+            for (let i = 0; i < arrayOfFirstIndexes.length; i++) {
+                if (i == 0) {
+                    methodDetails[i].arguments = this.collectArgs(
+                        methodsStr.substring(0, arrayOfFirstIndexes[i])
+                    )
+                } else {
+                    methodDetails[i].arguments = this.collectArgs(
+                        methodsStr.substring(
+                            arrayOfLastIndexes[i - 1] + 2,
+                            arrayOfFirstIndexes[i]
+                        )
+                    )
+                }
+            }
+            return methodDetails
+        }
+        return []
+    }
+    collectArgs (str) {
+        let firstParentheses = null
+        let lastParentheses = null
+        for (let i = 0; i < str.length; i++) {
+            if (str[i] == '(') {
+                firstParentheses = i
+            }
+            if (str[i] == ')') {
+                lastParentheses = i
+            }
+        }
+        return str.substring(firstParentheses + 1, lastParentheses).split(',')
+    }
+}
+
+
+export default Methods

src/plugin/mounted.js

@@ -0,0 +1,21 @@
+import { scriptSectionProcessing } from './common'
+class Mounted {
+    constructor(vueScript) {
+        let regx = /mounted\s*\(\s*\)\s*{([^]*)}/g
+        this.mounted = this.extractAndUpdateMounted(regx, vueScript)
+    }
+    extractAndUpdateMounted (regx, vueScript) {
+        let newScript = ''
+        let matchMounted = vueScript.match(regx)
+        if (!matchMounted) {
+            newScript = '\n mounted() { \n' + '\n}'
+        } else {
+            let data = scriptSectionProcessing(vueScript, regx)
+            newScript = data.methodsString.substring(data.firstIndex + 1, data.lastIndex)
+        }
+
+        return newScript
+    }
+}
+
+export default Mounted