Merge branch 'feature/standards-compliant' into 'master'

Feature/standards compliant

See merge request !1

Makefile

@@ -11,7 +11,7 @@ COVER_DIR=cover
 
 # Package lists
 TOPLEVEL_PKG := jsh
-CMD_LIST := jsh/ps
+CMD_LIST := jsh/ps jsh/free jsh/ls
 
 # List building
 ALL_LIST = $(TOPLEVEL_PKG) $(CMD_LIST)

common.go

@@ -4,25 +4,27 @@ package jsh
 
 import (
 	"encoding/json"
+	"fmt"
 )
 
-type JshOutput struct {
+type JshFrame struct {
 	StdOut interface{}
 	StdErr interface{}
 }
 
 // Size prefixes as integers, using binary representation
 type Unit int
+
 const (
-	B Unit = 2 ^ 0
+	B  Unit = 2 ^ 0
 	KB Unit = 2 ^ 10
 	MB Unit = 2 ^ 20
 	GB Unit = 2 ^ 30
 	TB Unit = 2 ^ 40
 )
 
-// Converts a Jshoutput into a JSON string
-func (j JshOutput) ToJson() *string {
+// Converts a JshFrame into a JSON string
+func (j JshFrame) ToJson() *string {
 	jsonOut, err := json.Marshal(j)
 	if err != nil {
 		panic(err)
@@ -30,3 +32,25 @@ func (j JshOutput) ToJson() *string {
 	jsonString := string(jsonOut)
 	return &jsonString
 }
+
+// goroutine for outputing frames. Pass it a channel of pointers to JshFrames,
+// and it will send "true" to the done channel once you close the queue channel.
+func OutputFrames(queue chan *JshFrame, done chan bool) {
+	fmt.Printf("[")
+	isFirst := true
+	for {
+		frame, more := <-queue
+		if more {
+			if !isFirst {
+				fmt.Printf(",")
+			} else {
+				isFirst = false
+			}
+			fmt.Printf(*frame.ToJson())
+		} else {
+			fmt.Printf("]\n")
+			done <- true
+			return
+		}
+	}
+}

free.go

@@ -3,6 +3,6 @@
 package jsh
 
 type MemStat struct {
-	Stat int
+	Stat  int
 	Units Unit
 }

free/main.go

@@ -6,8 +6,8 @@ import (
 	"flag"
 	"fmt"
 	"jsh"
-	"regexp"
 	"os"
+	"regexp"
 	"strconv"
 )
 
@@ -23,8 +23,10 @@ func convertUnit(stringUnit string) (jsh.Unit, error) {
 		return jsh.GB, nil
 	case "tB":
 		return jsh.TB, nil
+	case "":
+		return jsh.B, nil
 	default:
-		return 0, errors.New(fmt.Sprintln("Unknown unit %s", stringUnit))
+		return 0, errors.New(fmt.Sprintf("Unknown unit: %s\n", stringUnit))
 	}
 }
 
@@ -53,10 +55,10 @@ func parseLine(line string) (string, jsh.MemStat, error) {
 	return key, jsh.MemStat{val, unit}, nil
 }
 
-func parseMemInfo() jsh.JshOutput {
+func parseMemInfo() jsh.JshFrame {
 	file, err := os.Open("/proc/meminfo")
 	if err != nil {
-		return jsh.JshOutput{[]string{}, []error{err}}
+		return jsh.JshFrame{[]string{}, []error{err}}
 	}
 	defer file.Close()
 
@@ -72,13 +74,20 @@ func parseMemInfo() jsh.JshOutput {
 		memInfo[key] = val
 	}
 
-	finalOut := jsh.JshOutput{memInfo, errors}
+	// Wrap with array
+	stdOut := []map[string]jsh.MemStat{memInfo}
+	finalOut := jsh.JshFrame{stdOut, errors}
 	return finalOut
 }
 
 func runJsonMode() {
 	output := parseMemInfo()
-	fmt.Println("%s", *output.ToJson())
+	queue := make(chan *jsh.JshFrame)
+	done := make(chan bool)
+	go jsh.OutputFrames(queue, done)
+	queue <- &output
+	close(queue)
+	<-done
 }
 
 func main() {

ls/main.go

@@ -1,76 +1,75 @@
 package main
 
 import (
-  "io/ioutil"
-  "fmt"
-  "flag"
-  "log"
-  "syscall"
-  "strconv"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"strconv"
+	"syscall"
 )
 
-
-func get_fileinfo(f string, size bool, mode bool, inode bool) string{
-  var stat syscall.Stat_t
-  var ret string 
-  ret = "{\"name\":\"" + f + "\""
-  if err := syscall.Stat(f, &stat); err != nil {
-    log.Fatal(err)
-  }
-  if(size){
-    ret = ret + ", \"size\":" + strconv.FormatInt(stat.Size,10)
-  }
-  if(mode){
-    ret = ret + ", \"mode\":" + strconv.Itoa(int(stat.Mode))
-  }
-  if(inode){
-    ret = ret + ", \"inode\":" + strconv.FormatUint(stat.Ino,10)
-  }
-  ret = ret + "}"
-  return ret 
+func get_fileinfo(f string, size bool, mode bool, inode bool) string {
+	var stat syscall.Stat_t
+	var ret string
+	ret = "{\"files\": [{\"name\":\"" + f + "\""
+	if err := syscall.Stat(f, &stat); err != nil {
+		log.Fatal(err)
+	}
+	if size {
+		ret = ret + ", \"size\":" + strconv.FormatInt(stat.Size, 10)
+	}
+	if mode {
+		ret = ret + ", \"mode\":" + strconv.Itoa(int(stat.Mode))
+	}
+	if inode {
+		ret = ret + ", \"inode\":" + strconv.FormatUint(stat.Ino, 10)
+	}
+	ret = ret + "}]}"
+	return ret
 }
 
 func main() {
-  // here be the ls flags
+	// here be the ls flags
 
-  var a_flag bool                      // all files, even ones starting with .
-  var mode_flag bool                   // flags
-  var inode_flag bool		       // inode
-  var size_flag	bool		       // size
-  var first = true
+	var a_flag bool     // all files, even ones starting with .
+	var mode_flag bool  // flags
+	var inode_flag bool // inode
+	var size_flag bool  // size
+	var first = true
 
-  flag.BoolVar(&a_flag, "a", false, "lists all files in directory, even hidden ones")
-  flag.BoolVar(&mode_flag, "f", false, "include flags for file")  
-  flag.BoolVar(&inode_flag, "i", false, "include flags for file")  
-  flag.BoolVar(&size_flag, "s", false, "include flags for file")  
-  // end ls flag
+	flag.BoolVar(&a_flag, "a", false, "lists all files in directory, even hidden ones")
+	flag.BoolVar(&mode_flag, "f", false, "include flags for file")
+	flag.BoolVar(&inode_flag, "i", false, "include flags for file")
+	flag.BoolVar(&size_flag, "s", false, "include flags for file")
+	// end ls flag
 
-  flag.Parse()
-  root := "."//flag.Arg(0)
-  dir,_ := ioutil.ReadDir(root)
+	flag.Parse()
+	root := "." //flag.Arg(0)
+	dir, _ := ioutil.ReadDir(root)
 
-  fmt.Printf("[\n")
+	fmt.Printf("[{\"StdOut\": [\n")
 
-  if(!a_flag){
-    for _,entry := range dir{
-      if(entry.Name()[0]!='.'){
-        if(!first){
-          fmt.Printf(",")
-        }else{
-          first = false
+	if !a_flag {
+		for _, entry := range dir {
+			if entry.Name()[0] != '.' {
+				if !first {
+					fmt.Printf(",")
+				} else {
+					first = false
+				}
+				fmt.Printf("%s\n", get_fileinfo(entry.Name(), size_flag, mode_flag, inode_flag))
+			}
+		}
+	} else {
+		for _, entry := range dir {
+			if !first {
+				fmt.Printf(",")
+			} else {
+				first = false
+			}
+			fmt.Printf("%s\n", get_fileinfo(entry.Name(), size_flag, mode_flag, inode_flag))
+		}
 	}
-        fmt.Printf("%s\n", get_fileinfo(entry.Name(), size_flag, mode_flag, inode_flag))
-      }  
-    }
-  }else{
-    for _,entry := range dir{
-        if(!first){
-          fmt.Printf(",")
-        }else{
-          first = false
-	}
-        fmt.Printf("%s\n", get_fileinfo(entry.Name(), size_flag, mode_flag, inode_flag))
-    }
-  }
-  fmt.Printf("]\n")
+	fmt.Printf("], \"StdErr\": []}]\n")
 }

ps/main.go

@@ -25,11 +25,16 @@ func PsOutputToProcesses(out string) *[]jsh.Process {
 
 func runJsonMode() {
 	// Run procps-ng "ps" with full output
-	psOut := string(*jsh.FallbackWithArgs("/usr/bin/ps",  []string{"auxww"}))
-
+	psOut := string(*jsh.FallbackWithArgs("/usr/bin/ps", []string{"auxww"}))
 	processesPtr := PsOutputToProcesses(psOut)
-	finalOut := jsh.JshOutput{*processesPtr, []string{}}
-	fmt.Printf("%s", *finalOut.ToJson())
+	frame := jsh.JshFrame{*processesPtr, []string{}}
+
+	queue := make(chan *jsh.JshFrame)
+	done := make(chan bool)
+	go jsh.OutputFrames(queue, done)
+	queue <- &frame
+	close(queue)
+	<-done
 }
 
 func main() {

utils.go

@@ -2,9 +2,9 @@ package jsh
 
 import (
 	"math"
-	"unicode"
 	"os"
 	"os/exec"
+	"unicode"
 )
 
 // FieldsN slices s into substrings after each instance of a whitespace