fix: generate any kind of file

ipetinate · May 22, 2024 · 5b5756f · 5b5756f
1 parent 9b43fbb
commit 5b5756f
Show file tree

Hide file tree

Showing 10 changed files with 143 additions and 59 deletions.
diff --git a/.clingon/templates/docs/ReactHookDoc.md b/.clingon/templates/docs/ReactHookDoc.md
@@ -0,0 +1,5 @@
+# ResourceName
+
+> My hok doc
+
+- Test generate with MD file
diff --git a/.clingon/templates/functions/AsyncFunction.spec.ts b/.clingon/templates/functions/AsyncFunction.spec.ts
@@ -0,0 +1,7 @@
+describe('ResourceName', () => {
+  it("work's properly", async () => {
+    const result = await ResourceName()
+
+    expect(result).toBeTruthy()
+  })
+})
diff --git a/.clingon/templates/functions/AsyncFunction.ts b/.clingon/templates/functions/AsyncFunction.ts
@@ -0,0 +1,5 @@
+type Props = {}
+
+export async function ResourceName(props: Props) {
+  return new Promise<boolean>((resolve) => resolve(true))
+}
diff --git a/.clingon/templates/meta.yaml b/.clingon/templates/meta.yaml
@@ -1,5 +1,6 @@
 - identifier: component
   folderWrapper: true
+  case: 'PascalCase'
   resource:
     path: 'src/components'
     template: './ReactComponent/Component.tsx'
@@ -11,17 +12,19 @@
     template: './ReactComponent/Component.stories.tsx'
 
 - identifier: async-function
+  case: 'kebab-case'
   resource:
     path: src/utils
-    template: './Functions/AsyncFunction.ts'
+    template: './functions/AsyncFunction.ts'
   test:
     path: src/utils
-    template: './Functions/AsyncFunction.spec.ts'
+    template: './functions/AsyncFunction.spec.ts'
 
 - identifier: markdown
+  case: 'UPPERCASE'
   resource:
     path: src/docs
-    template: './Docs/ReactHookDoc.md'
+    template: './docs/ReactHookDoc.md'
 
 - identifier: nvmrc
   resource:

diff --git a/src/generators/scaffold-template.js b/src/generators/scaffold-template.js
@@ -52,31 +52,33 @@ function checkPaths(name, template) {
       story: false
     }
 
-    const resourcePath = template.folderWrapper
-      ? join(template.resource.path, name)
-      : template.resource.path
-    const storyPath = template.folderWrapper
-      ? join(template.story.path, name)
-      : template.story.path
-    const testPath = template.folderWrapper
-      ? join(template.test.path, name)
-      : template.test.path
+    const resourcePath = template?.folderWrapper
+      ? join(template?.resource?.path, name)
+      : template?.resource?.path
+
+    const storyPath = template?.folderWrapper
+      ? join(template?.story?.path, name)
+      : template?.story?.path
+
+    const testPath = template?.folderWrapper
+      ? join(template?.test?.path, name)
+      : template?.test?.path
 
     targets.resource = checkDirectoriesTree(splitPathString(resourcePath))
 
-    if (!targets.resource) {
+    if (!targets?.resource) {
       targets.resource = createDir(getTargetFullPath(resourcePath))
     }
 
-    if (template.test) {
+    if (template?.test) {
       targets.test = checkDirectoriesTree(splitPathString(testPath))
 
       if (!targets.test) {
         targets.resource = createDir(getTargetFullPath(testPath))
       }
     }
 
-    if (template.story) {
+    if (template?.story) {
       targets.story = checkDirectoriesTree(splitPathString(storyPath))
 
       if (!targets.story) {
@@ -105,18 +107,18 @@ function getTemplatesData({ name, template, targets }) {
 
   try {
     templatesContent.resource = readFileContent(
-      getTemplateFullPath(template.resource.template)
+      getTemplateFullPath(template?.resource?.template)
     )
 
-    if (template.test) {
+    if (template?.test) {
       templatesContent.test = readFileContent(
-        getTemplateFullPath(template.test.template)
+        getTemplateFullPath(template?.test?.template)
       )
     }
 
-    if (template.story) {
+    if (template?.story) {
       templatesContent.story = readFileContent(
-        getTemplateFullPath(template.story.template)
+        getTemplateFullPath(template?.story?.template)
       )
     }
 
@@ -137,27 +139,33 @@ function handleTemplateReplacements({
   templatesContent,
   targets
 }) {
-  name = convertCase('PascalCase', name)
+  if (!template.case) {
+    return { name, template, templatesContent, targets }
+  }
 
-  templatesContent.resource = templatesContent.resource.replace(
+  name = convertCase(template.case, name)
+
+  templatesContent.resource = templatesContent.resource?.replace(
     /ResourceName/g,
     name
   )
 
-  if (templatesContent.story) {
-    templatesContent.story = replaceContentFromSideResource(
-      name,
-      templatesContent.story,
-      template
-    )
-  }
-
-  if (templatesContent.test) {
+  if (templatesContent?.test) {
     templatesContent.test = replaceContentFromSideResource(
       name,
       templatesContent.test,
+      'test',
       template
     )
+
+    if (templatesContent?.story) {
+      templatesContent.story = replaceContentFromSideResource(
+        name,
+        templatesContent.story,
+        'story',
+        template
+      )
+    }
   }
 
   return { name, template, templatesContent, targets }
@@ -177,7 +185,7 @@ function createResources({ name, targets, template, templatesContent }) {
 
   if (targets.resource) {
     if (template.folderWrapper)
-      template.resource.path = join(template.resource.path, name)
+      template.resource.path = join(template.resource?.path, name)
 
     const fullPath = getFullPath(name, 'resource', template)
 
@@ -187,22 +195,22 @@ function createResources({ name, targets, template, templatesContent }) {
     )
   }
 
-  if (targets.test) {
+  if (targets?.test) {
     if (template.folderWrapper)
-      template.test.path = join(template.test.path, name)
+      template.test.path = join(template?.test?.path, name)
 
     const fullPath = getFullPath(name, 'test', template)
 
     created.test = createFileWithContent(fullPath, templatesContent.test)
   }
 
-  if (targets.story) {
+  if (targets?.story) {
     if (template.folderWrapper)
-      template.story.path = join(template.story.path, name)
+      template.story.path = join(template?.story?.path, name)
 
     const fullPath = getFullPath(name, 'story', template)
 
-    created.story = createFileWithContent(fullPath, templatesContent.story)
+    created.story = createFileWithContent(fullPath, templatesContent?.story)
   }
 
   return {

diff --git a/src/schemas/custom-template.js b/src/schemas/custom-template.js
@@ -15,14 +15,6 @@ export const templateResourceTypeMap = {
  */
 export const customTemplateTypeMap = {
   identifier: 'string',
-  folderWrapper: 'boolean',
-  resource: templateResourceTypeMap,
-  test: {
-    path: 'string',
-    template: 'string'
-  },
-  story: {
-    path: 'string',
-    template: 'string'
-  }
+  case: 'string',
+  resource: templateResourceTypeMap
 }
diff --git a/src/types.js b/src/types.js
@@ -92,14 +92,17 @@ import {
  *
  * @typedef {"class" | "functional"} ReactComponentVariant - React component type variant (class or functional)
  *
+ * @typedef {"camelCase" | "PascalCase" | "snake_case" | "kebab-case" | "CamelCase" | "UPPERCASE" | "lowercase"} TextCase - Case to convert strings
+ *
  * @typedef {{
  *    path: string
  *    template: string
  *  }} TemplateResource - Template resource definition
  *
  * @typedef {{
  *  identifier: string
- *  folderWrapper: boolean
+ *  case?: TextCase
+ *  folderWrapper?: boolean
  *  resource: TemplateResource
  *  test?: TemplateResource
  *  story?: TemplateResource

diff --git a/src/utils/scaffold-action.js b/src/utils/scaffold-action.js
@@ -80,7 +80,7 @@ export function getMetaFilePath() {
  * @returns {boolean} - Returns true if the template is valid, false otherwise.
  */
 export function validateTemplate(template) {
-  return validateObject(template, customTemplateTypeMap)
+  return validateObject(template, customTemplateTypeMap, true)
 }
 
 /**
@@ -109,14 +109,14 @@ export function getLastItem(text, pattern) {
   return pieces[pieces.length - 1]
 }
 
-export function replaceContentFromSideResource(name, content, template) {
+export function replaceContentFromSideResource(name, content, key, template) {
   const resourceNameReplaced = content.replace(/ResourceName/g, name)
 
   if (resourceNameReplaced) content = resourceNameReplaced
 
-  const { extension } = getFileNameFromMetadata(template.story.template)
+  const { extension } = getFileNameFromMetadata(template[key].template)
 
-  const fullPath = join(template.story.path, `${name}.${extension}`)
+  const fullPath = join(template[key].path, `${name}.${extension}`)
 
   content = replaceResourcePath(fullPath, content)
 

diff --git a/src/utils/string.js b/src/utils/string.js
@@ -25,20 +25,24 @@ export function boolAsText(bool) {
 /**
  * Convert a specific case to target case, e.g "MyResource" to "my_resource"
  *
- * @param {"camelCase" | "snake_case" | "PascalCase" | "kebab-case"} targetPattern Case target
+ * @param {import("../types").TextCase} targetPattern Case target
  * @param {string} inputString - String to be converted
  * @returns {string}
  */
 export function convertCase(targetPattern, inputString) {
   switch (targetPattern) {
+    case 'PascalCase':
+      return convertToPascalCase(inputString)
     case 'camelCase':
       return convertToCamelCase(inputString)
     case 'snake_case':
       return convertToSnakeCase(inputString)
-    case 'PascalCase':
-      return convertToPascalCase(inputString)
     case 'kebab-case':
       return convertToKebabCase(inputString)
+    case 'UPPERCASE':
+      return convertToUpperCase(inputString)
+    case 'lowercase':
+      return convertToLowerCase(inputString)
     default:
       throw new Error('Invalid target pattern.')
   }
@@ -64,6 +68,26 @@ export function convertToCamelCase(inputString) {
   return words.join('')
 }
 
+/**
+ * Convert a string on any case to a UPPERCASE
+ *
+ * @param {string} inputString String to be converted
+ * @returns {string}
+ */
+export function convertToUpperCase(inputString) {
+  return inputString.toUpperCase()
+}
+
+/**
+ * Convert a string on any case to a lowercase
+ *
+ * @param {string} inputString String to be converted
+ * @returns {string}
+ */
+export function convertToLowerCase(inputString) {
+  return inputString.toLowerCase()
+}
+
 /**
  * Convert a string on any case to a snake_case
  *

diff --git a/src/utils/string.test.js b/src/utils/string.test.js
@@ -9,7 +9,9 @@ import {
   convertToPascalCase,
   convertToKebabCase,
   convertToSnakeCase,
-  capitalizeLetter
+  capitalizeLetter,
+  convertToLowerCase,
+  convertToUpperCase
 } from './string.js'
 
 describe('String Utils', async () => {
@@ -81,6 +83,18 @@ describe('String Utils', async () => {
 
       assert.strictEqual(result, 'PascalCaseString')
     })
+
+    it('convert a string case: kebab-case -> lowercase', () => {
+      const result = convertCase('lowercase', 'PascalCaseString')
+
+      assert.strictEqual(result, 'pascalcasestring')
+    })
+
+    it('convert a string case: kebab-case -> UPPERCASE', () => {
+      const result = convertCase('UPPERCASE', 'PascalCaseString')
+
+      assert.strictEqual(result, 'PASCALCASESTRING')
+    })
   })
 
   describe('convert case individual utils', () => {
@@ -92,9 +106,18 @@ describe('String Utils', async () => {
     })
 
     it('convertToPascalCase', () => {
-      assert.strictEqual(convertToPascalCase('kebab-to-pascal'), 'KebabToPascal')
-      assert.strictEqual(convertToPascalCase('snake_to_pascal'), 'SnakeToPascal')
-      assert.strictEqual(convertToPascalCase('PascalToPascal'), 'PascalToPascal')
+      assert.strictEqual(
+        convertToPascalCase('kebab-to-pascal'),
+        'KebabToPascal'
+      )
+      assert.strictEqual(
+        convertToPascalCase('snake_to_pascal'),
+        'SnakeToPascal'
+      )
+      assert.strictEqual(
+        convertToPascalCase('PascalToPascal'),
+        'PascalToPascal'
+      )
       assert.strictEqual(convertToPascalCase('camelToPascal'), 'CamelToPascal')
     })
 
@@ -111,6 +134,20 @@ describe('String Utils', async () => {
       assert.strictEqual(convertToSnakeCase('PascalToSnake'), 'pascal_to_snake')
       assert.strictEqual(convertToSnakeCase('camelToSnake'), 'camel_to_snake')
     })
+
+    it('convertToUpperCase', () => {
+      assert.strictEqual(convertToUpperCase('kebab-to-upper'), 'KEBAB-TO-UPPER')
+      assert.strictEqual(convertToUpperCase('snake_to_upper'), 'SNAKE_TO_UPPER')
+      assert.strictEqual(convertToUpperCase('PascalToUpper'), 'PASCALTOUPPER')
+      assert.strictEqual(convertToUpperCase('camelToUpper'), 'CAMELTOUPPER')
+    })
+
+    it('convertToLowerCase', () => {
+      assert.strictEqual(convertToLowerCase('kebab-to-lower'), 'kebab-to-lower')
+      assert.strictEqual(convertToLowerCase('snake_to_lower'), 'snake_to_lower')
+      assert.strictEqual(convertToLowerCase('PascalToLower'), 'pascaltolower')
+      assert.strictEqual(convertToLowerCase('camelToLower'), 'cameltolower')
+    })
   })
 
   describe('capitalizeLetter', () => {