[ISSUE#51]: getschema done

igned-off-by: ashish <ashishpatel0720@gmail.com>

Signed-off-by: ashish <ashishpatel0720@gmail.com>

Author: pateash

README.md

@@ -187,6 +187,13 @@ OPTIONS
 _See code: [src/commands/minify.ts](https://github.com/codingtools/cdt/blob/v0.1.5/src/commands/minify.ts)_
 <!-- commandsstop -->
 
+## Acknowledgement
+ * this cli uses following opensource libraries/services
+    * [bundlephobia](https://bundlephobia.com/)
+    * [avro-js](https://openbase.io/js/avro-js) 
+    * [avsc](https://github.com/mtth/avsc)
+    
+    And many others, great thanks to all the people involved in developnment and support :)
 
 ## Contribution
 

my.json

@@ -1,12 +1,12 @@
 import {Command, flags} from '@oclif/command'
-import * as avsc from 'avsc'
-import * as CryptoJS from 'crypto-js'
+import * as avro from 'avsc' // includes all from avro-js and some more
 
 import Logger from '../utilities/logger'
 import Utilities from '../utilities/utilities'
 
 export default class Avro extends Command {
   static description = 'Avro Utility command'
+  static SupportedCommands = ['get_schema', 'to_json', 'to_avro']
   static flags = {
     help: flags.help({char: 'h'}),
     file: flags.string({char: 'f' , description: 'input file path'}),
@@ -16,36 +16,58 @@ export default class Avro extends Command {
   }
 
   static args = [{name: 'command'}] // operation type
-
+  /*
+  *   input,output, and operation are all must
+  * */
   async run() {
     const {args, flags} = this.parse(Avro)
 
-    args.string = Utilities.getInputString(this, flags, args) // from either -s,-f or args
     this.checkParameters(flags, args)
     args.commandFunction = this.getCommandCaller(args)
+    args.commandFunction(flags, args)
   }
 
   // to check required parameters passed or not
   private checkParameters(flags: any, args: any) {
-    if (args.string === undefined || args.string === '')
-      Logger.error(this, 'Input is empty or not provided')
+    if (flags.file === undefined || flags.file === '')
+      Logger.error(this, 'Input file is not provided')
+    if (flags.output === undefined || args.output === '')
+      Logger.error(this, 'Output file is not provided')
     if (args.command === undefined || args.command === '')
-      Logger.error(this, 'command is empty or not provided')
+      Logger.error(this, 'Command is empty or not provided, supported:' + Avro.SupportedCommands)
   }
 
   private getCommandCaller(args: any) {
-    let supportedCommands = ['get_schema', 'to_json', 'to_avro']
-
     switch (args.command.toLowerCase()) {
-    case supportedCommands[0]:
-      return 'supported'
-    case supportedCommands[1]:
-      return 'supported'
-    case supportedCommands[2]:
-      return 'supported'
+    case Avro.SupportedCommands[0]:
+      return this.getSchema
+    case Avro.SupportedCommands[1]:
+      return this.toJson
+    case Avro.SupportedCommands[2]:
+      return this.toAvro
     default:
-      Logger.error(this, 'Unsupported Commands Mode, supported: ' + supportedCommands)
+      Logger.error(this, 'Unsupported Command, supported: ' + Avro.SupportedCommands)
     }
   }
 
+  private getSchema(flags: any, args: any) {
+    avro.createFileDecoder(flags.file)
+      .on('metadata', function (type) {
+        let output = type.schema()
+        let schemaStr = JSON.stringify(output, null, '\t')
+        Utilities.writeStringToFile(this, flags.output, schemaStr)
+      })
+
+  }
+  private toJson(flags: any, args: any) {
+    avro.createFileDecoder(flags.file)
+      .on('data', function (data) {
+        return data
+      })
+
+  }
+  private toAvro(flags: any, args: any) {
+
+  }
+
 }

src/commands/avro.ts

@@ -3,19 +3,43 @@ import {expect, test} from '@oclif/test'
 // TODO: add test for invalid package
 // test for valid with matching
 describe('avro', () => {
+  //todo if file is invalid
   test
     .stdout()
     .command(['avro'])
     .exit(0)
-    .it('if nothing passed', ctx => {
-      expect(ctx.stdout).to.contain('Input is empty or not provided')
+    .it('if input is not  passed', ctx => {
+      expect(ctx.stdout).to.contain('Input file is not provided')
     })
-
   test
     .stdout()
     .command(['avro', '-f' ,'test/resources/avro/test-tabular.avro'])
     .exit(0)
+    .it('if output is not passed', ctx => {
+      expect(ctx.stdout).to.contain('Output file is not provided')
+    })
+
+  test
+    .stdout()
+    .command(['avro', '-f' ,'test/resources/avro/test-tabular.avro', '-o', 'output_file.example'])
+    .exit(0)
     .it('if command not passed', ctx => {
-      expect(ctx.stdout).to.contain('command is empty or not provided')
+      expect(ctx.stdout).to.contain('Command is empty or not provided')
+    })
+
+  test
+    .stdout()
+    .command(['avro', '-f' ,'test/resources/avro/test-tabular.avro', '-o', 'output_file.example', 'unsupported_command'])
+    .exit(0)
+    .it('if command is invalid', ctx => {
+      expect(ctx.stdout).to.contain('Unsupported Command')
+    })
+
+  test
+    .stdout()
+    .command(['avro', '-f' ,'test/resources/avro/file_not_exists.avro', '-o', 'output_file.example', 'get_schema'])
+    .exit(0)
+    .it('if input file path is invalid', ctx => {
+      expect(ctx.stdout).to.contain('Unsupported Command')
     })
 })

test/commands/avro.test.ts

@@ -0,0 +1,26 @@
+{
+	"name": "Person",
+	"type": "record",
+	"fields": [
+		{
+			"name": "ID",
+			"type": "long"
+		},
+		{
+			"name": "First",
+			"type": "string"
+		},
+		{
+			"name": "Last",
+			"type": "string"
+		},
+		{
+			"name": "Phone",
+			"type": "string"
+		},
+		{
+			"name": "Age",
+			"type": "int"
+		}
+	]
+}