添加变量名转换工具 #44

README.md

@@ -89,6 +89,7 @@ npm run serve -adapter=utools
 - [moment](https://momentjs.com/)
 - [vue-codemirror](https://www.npmjs.com/package/vue-codemirror)
 - [sm-crypto](https://github.com/JuneAndGreen/sm-crypto)
+- [camelcaseplugin](https://github.com/netnexus/camelcaseplugin)
 
  > 当然项目中还使用很多不知道姓名的大神的代码, 在这里就不一一感谢
  

src/config.js

@@ -10,14 +10,12 @@ const tool = [
     {
         'name': 'hash',
         'title': '哈希(hash)',
-        'cat': ['encryption'],
-        'keyword': ['md5', 'sha1', 'sha256', 'sha512', 'sm3']
+        'cat': ['encryption']
     },
     {
         'name': 'encrypt',
         'title': '加密/解密',
-        'cat': ['encryption'],
-        'keyword': ['AES', 'DES', 'RC4', 'Rabbit', 'TripleDes', 'sm2']
+        'cat': ['encryption']
     },
     {'name': 'base64', 'title': 'BASE64编码', 'cat': ['encryption']},
     {'name': 'json', 'title': 'JSON工具', 'cat': ['conversion', 'serialize']},
@@ -40,9 +38,18 @@ const tool = [
     {'name': 'uuid', 'title': 'UUID生成', 'cat': ['other']},
     {'name': 'jsonToObject', 'title': 'JSON转实体类', 'cat': ['conversion', 'serialize']},
     {'name': 'ascii', 'title': 'ascii转换', 'cat': ['conversion']},
+    {'name': 'variableConversion', 'title': '变量名转换', 'cat': ['conversion']},
 ]
 
+const utools = {
+    keyword: {
+        hash: ['md5', 'sha1', 'sha256', 'sha512', 'sm3'],
+        encrypt: ['AES', 'DES', 'RC4', 'Rabbit', 'TripleDes', 'sm2']
+    }
+}
+
 module.exports = {
     category,
-    tool
+    tool,
+    utools
 }
\ No newline at end of file

src/tool.router.js

@@ -97,6 +97,10 @@ const routes = [
     {
         path: '/tool/ascii',
         component: r => require(['./views/tool/ascii.vue'], r)
+    },
+    {
+        path: '/tool/variableConversion',
+        component: r => require(['./views/tool/variableConversion.vue'], r)
     }
 ]
 

src/tool.vue

@@ -193,7 +193,7 @@ export default {
                     return h('Input', {
                         props: {
                             type:"textarea",
-                            rows:"10",
+                            rows:10,
                             value: JSON.stringify(historyFactory(this.currentTool).get(index), null, "\t"),
                         }
                     })

src/tool/adapter.js

@@ -47,7 +47,7 @@ const utoolsConfigWrite = () => {
                     "cmds": ['ctool', '程序开发常用工具']
                 },
                 ...toolConfig.tool.map((item) => {
-                    let keyword = item.hasOwnProperty("keyword") ? item['keyword'] : [];
+                    let keyword = toolConfig['keyword'].hasOwnProperty(item.name) ? toolConfig['keyword'][item.name] : [];
                     return {
                         "code": "ctool-" + item.name,
                         "explain": item.title,

src/views/tool/library/varCamelCase.js

+// 算法来源 https://github.com/netnexus/camelcaseplugin
+
+const SPACE_CASE = 'spaceCaseToPascalCaseSpace'  // 转换过程  space case to Camel Case
+const PASCAL_CASE_SPACE = 'pascalCaseSpaceToKebabCase'  // 转换过程  Camel Case to kebab-case
+const KEBAB_CASE = 'kebabCaseToUpperSnakeCase'  // 转换过程  kebab-case to SNAKE_CASE
+const UPPER_SNAKE_CASE = 'upperSnakeCaseToPascalCase'  // 转换过程  SNAKE_CASE to CamelCase
+const PASCAL_CASE = 'pascalCaseToCamelCase'  // 转换过程  CamelCase to camelCase
+const CAMEL_CASE = 'camelCaseToLowerSnakeCase'  // 转换过程  camelCase to snake_case
+const LOWER_SNAKE_CASE = 'lowerSnakeCaseToSpaceCase'  // 转换过程  snake_case to space case
+
+const isUpperCase = (str, first = false) => {
+    if (first === false) {
+        return str.toUpperCase() === str;
+    }
+    return str.substr(0, 1).toUpperCase() === str.substr(0, 1)
+        && (str.length === 1 || str.substr(1, 1).toLowerCase() === str.substr(1, 1));
+}
+
+const isLowerCase = (str, first = false) => {
+    if (first === false) {
+        return str.toLowerCase() === str;
+    }
+    return str.substr(0, 1).toLowerCase() === str.substr(0, 1);
+}
+const firstToUpper = (str) => {
+    return str.replace(str[0], str[0].toUpperCase());
+}
+const firstToLower = (str) => {
+    return str.replace(str[0], str[0].toLowerCase());
+}
+
+const getMethodName = (str) => {
+    str = str.trim();
+    if (isLowerCase(str) && str.indexOf('_') !== -1) {
+        return LOWER_SNAKE_CASE;
+    }
+    if (isLowerCase(str) && str.indexOf('-') !== -1) {
+        return KEBAB_CASE;
+    }
+    if (isLowerCase(str) && str.indexOf(' ') !== -1) {
+        return SPACE_CASE;
+    }
+    if (isUpperCase(str, true) && str.indexOf(' ') !== -1) {
+        return PASCAL_CASE_SPACE;
+    }
+    if (isUpperCase(str) && str.indexOf('_') !== -1) {
+        return UPPER_SNAKE_CASE;
+    }
+    if (isUpperCase(str, true) && str.indexOf('_') === -1 && str.indexOf(' ') === -1 && str.indexOf('0') === -1) {
+        return PASCAL_CASE;
+    }
+    return CAMEL_CASE;
+}
+
+class Conversion {
+    constructor(str) {
+        this.setStr(str);
+
+    }
+
+    setStr(str) {
+        this.str = str.trim()
+        return this;
+    }
+
+    // space case to Camel Case
+    spaceCaseToPascalCaseSpace() {
+        return this.str.split(' ').map((str) => {
+            return firstToUpper(str)
+        }).join(' ').trim()
+    }
+
+    // Camel Case to kebab-case
+    pascalCaseSpaceToKebabCase() {
+        return this.str.replace(/ /g, "-").toLowerCase().trim();
+    }
+
+    // kebab-case to SNAKE_CASE
+    kebabCaseToUpperSnakeCase() {
+        return this.str.toUpperCase().replace(/-/g, "_").trim()
+    }
+
+    // SNAKE_CASE to PascalCase
+    upperSnakeCaseToPascalCase() {
+        return this.str.split('_').map((str) => {
+            return firstToUpper(str.toLowerCase())
+        }).join('').trim()
+    }
+
+    // PascalCase to camelCase
+    pascalCaseToCamelCase() {
+        return firstToLower(this.str).trim()
+    }
+
+    // camelCase to snake_case
+    camelCaseToLowerSnakeCase() {
+        let temp = "";
+        for (let i = 0; i < this.str.length; i++) {
+            let c = this.str.substr(i, 1);
+            if (isUpperCase(this.str.substr(i, 1))) {
+                temp = temp + '_';
+            }
+            temp = temp + c.toLowerCase();
+        }
+        return temp.trim();
+    }
+
+
+    // snake_case to space case
+    lowerSnakeCaseToSpaceCase() {
+        return this.str.replace(/_/g, " ").trim();
+    }
+
+    get() {
+        let methods = [
+            SPACE_CASE,
+            PASCAL_CASE_SPACE,
+            KEBAB_CASE,
+            UPPER_SNAKE_CASE,
+            PASCAL_CASE,
+            CAMEL_CASE,
+            LOWER_SNAKE_CASE,
+        ];
+        let current = methods.indexOf(getMethodName(this.str));
+        let executeMethods;
+        if (current === 0) {
+            executeMethods = methods;
+        } else {
+            executeMethods = [...methods.slice(current), ...methods.slice(0, current)]
+        }
+        let result = {};
+        let str = this.str;
+        for (let i = 0; i < executeMethods.length; i++) {
+            str = this.setStr(str)[executeMethods[i]](str);
+            result[executeMethods[i]] = str;
+        }
+        return result;
+    }
+}
+
+const resultKey = [
+    {key: SPACE_CASE, name: 'Var Name'},
+    {key: PASCAL_CASE_SPACE, name: 'var-name'},
+    {key: KEBAB_CASE, name: 'VAR_NAME'},
+    {key: UPPER_SNAKE_CASE, name: 'VarName'},
+    {key: PASCAL_CASE, name: 'varName'},
+    {key: CAMEL_CASE, name: 'var_name'},
+    {key: LOWER_SNAKE_CASE, name: 'var name'},
+]
+export default {
+    resultKey,
+    convent: (str) => {
+        let result = {
+            [SPACE_CASE]: [],
+            [PASCAL_CASE_SPACE]: [],
+            [KEBAB_CASE]: [],
+            [UPPER_SNAKE_CASE]: [],
+            [PASCAL_CASE]: [],
+            [CAMEL_CASE]: [],
+            [LOWER_SNAKE_CASE]: [],
+        };
+        let list = str.split("\n").map((_str) => {
+            return _str.trim()
+        }).filter((_str) => !!_str);
+        for (let item of list) {
+            let conversion = new Conversion(item)
+            let conversionResult = conversion.get()
+            for (let key of Object.keys(conversionResult)) {
+                result[key].push(conversionResult[key])
+            }
+        }
+        for (let key of Object.keys(result)) {
+            result[key] = result[key].join("\n");
+        }
+        return result;
+    }
+}
\ No newline at end of file

src/views/tool/variableConversion.vue

+<template>
+    <div>
+        <Row :gutter="10">
+            <Col span="6" style="margin-top: 10px">
+                <Card :padding="0">
+                    <p slot="title">输入变量名</p>
+                    <template slot="extra">
+                        <Button size="small" type="primary" @click="handle()">转换
+                        </Button>
+                    </template>
+                    <Input v-model="current.input" :rows="4" type="textarea" placeholder="变量名 一行一个"></Input>
+                </Card>
+            </Col>
+            <Col span="6" v-for="(item,key) in resultColumns" :key="key" style="margin-top: 10px">
+                <Card :padding="0">
+                    <p slot="title">{{ item.title }}</p>
+                    <Input v-model="current.output[item.key]" :rows="4" type="textarea"></Input>
+                </Card>
+            </Col>
+        </Row>
+    </div>
+</template>
+<script>
+import varCamelCase from "./library/varCamelCase"
+
+export default {
+    computed: {
+        resultColumns() {
+            return varCamelCase.resultKey.map((item) => {
+                return {
+                    title: item.name,
+                    key: item.key
+                }
+            });
+        },
+    },
+    created() {
+        this.current = Object.assign(this.current, this.$getToolData("input"))
+    },
+    methods: {
+        handle() {
+            if (!this.current.input) {
+                return;
+            }
+            this.current.output = varCamelCase.convent(this.current.input)
+            this.$saveToolData(this.current);
+        }
+    },
+    data() {
+        return {
+            current: {
+                input: "",
+                output: [],
+            }
+        }
+    },
+}
+</script>
\ No newline at end of file