#67 Add is_*type* functions

.github/workflows/main.yml

@@ -18,15 +18,15 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - name: Run golangci-lint
-        uses: golangci/golangci-lint-action@v3.7.0
+        uses: golangci/golangci-lint-action@v6.1.1
         with:
-          version: v1.56.2
+          version: v1.61.0
           args: -v
 
   test:
     strategy:
       matrix:
-        go-version: [ '1.16.x', '1.17.x', '1.18.x', '1.19.x', '1.20.x' , '1.21.x' , '1.22.x' ]
+        go-version: [ '1.16.x', '1.17.x', '1.18.x', '1.19.x', '1.20.x' , '1.21.x' , '1.22.x' , '1.23.x' ]
         os: [ ubuntu-latest, macos-latest ]
     runs-on: ${{ matrix.os }}
     steps:
@@ -47,10 +47,10 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
-      - name: Setup Go 1.22.x on ubuntu-latest
+      - name: Setup Go 1.23.x on ubuntu-latest
         uses: actions/setup-go@v3
         with:
-          go-version: '1.22.x'
+          go-version: '1.23.x'
       - name: Setup Dependencies
         run: |
           go get golang.org/x/tools/cmd/cover

README.md

@@ -53,7 +53,7 @@ func main() {
 You can download `ajson` cli from the [release page](https://github.com/spyzhov/ajson/releases), or install from the source:
 
 ```shell script
-go get github.com/spyzhov/ajson/cmd/[email protected].4
+go get github.com/spyzhov/ajson/cmd/[email protected].5
 ```
 
 Usage:
@@ -321,6 +321,15 @@ Package has several predefined functions.
     first        Get first element  any
     floor        math.Floor         integers, floats
     gamma        math.Gamma         integers, floats
+    is_array     Is type Array      any
+    is_bool      Is type Bool       any
+    is_float     Is type Float      any
+    is_int       Is type Int        any
+    is_null      Is type Null       any
+    is_numeric   Is type Numeric    any
+    is_object    Is type Object     any
+    is_string    Is type String     any
+    is_uint      Is type Uint       any
     j0           math.J0            integers, floats
     j1           math.J1            integers, floats
     key          Key of element     string

buffer.go

@@ -41,14 +41,14 @@ const (
 	asterisk     byte = '*'
 	plus         byte = '+'
 	minus        byte = '-'
-	//division     byte = '/'
-	//exclamation  byte = '!'
-	//caret        byte = '^'
-	//signL        byte = '<'
-	//signG        byte = '>'
-	//signE        byte = '='
-	//ampersand    byte = '&'
-	//pipe         byte = '|'
+	// division     byte = '/'
+	// exclamation  byte = '!'
+	// caret        byte = '^'
+	// signL        byte = '<'
+	// signG        byte = '>'
+	// signE        byte = '='
+	// ampersand    byte = '&'
+	// pipe         byte = '|'
 	question byte = '?'
 )
 
@@ -88,11 +88,11 @@ func (b *buffer) next() (c byte, err error) {
 	return b.data[b.index], nil
 }
 
-func (b *buffer) slice(delta uint) ([]byte, error) {
-	if b.index+int(delta) > b.length {
+func (b *buffer) slice(delta int) ([]byte, error) {
+	if delta < 0 || b.index+delta > b.length {
 		return nil, io.EOF
 	}
-	return b.data[b.index : b.index+int(delta)], nil
+	return b.data[b.index : b.index+delta], nil
 }
 
 func (b *buffer) move(delta int) error {
@@ -648,7 +648,7 @@ func (b *buffer) operation() string {
 	// fixme: add additional order for comparison
 
 	for _, operation := range comparisonOperationsOrder() {
-		if bytes, ok := b.slice(uint(len(operation))); ok == nil {
+		if bytes, ok := b.slice(len(operation)); ok == nil {
 			if string(bytes) == operation {
 				current = operation
 				_ = b.move(len(operation) - 1) // error can't occupy here because of b.slice result

cmd/ajson/main.go

@@ -13,7 +13,7 @@ import (
 	"github.com/spyzhov/ajson"
 )
 
-var version = "v0.9.4"
+var version = "v0.9.5"
 
 func usage() {
 	text := ``

math.go

@@ -97,21 +97,21 @@ var (
 		"**": func(left *Node, right *Node) (result *Node, err error) {
 			lnum, rnum, err := _floats(left, right)
 			if err != nil {
-				return
+				return nil, err
 			}
 			return valueNode(nil, "power", Numeric, math.Pow(lnum, rnum)), nil
 		},
 		"*": func(left *Node, right *Node) (result *Node, err error) {
 			lnum, rnum, err := _floats(left, right)
 			if err != nil {
-				return
+				return nil, err
 			}
 			return valueNode(nil, "multiply", Numeric, float64(lnum*rnum)), nil
 		},
 		"/": func(left *Node, right *Node) (result *Node, err error) {
 			lnum, rnum, err := _floats(left, right)
 			if err != nil {
-				return
+				return nil, err
 			}
 			if rnum == 0 {
 				return nil, errorRequest("division by zero")
@@ -121,47 +121,47 @@ var (
 		"%": func(left *Node, right *Node) (result *Node, err error) {
 			lnum, err := left.getInteger()
 			if err != nil {
-				return
+				return nil, err
 			}
 			rnum, err := right.getInteger()
 			if err != nil {
-				return
+				return nil, err
 			}
 			return valueNode(nil, "remainder", Numeric, float64(lnum%rnum)), nil
 		},
 		"<<": func(left *Node, right *Node) (result *Node, err error) {
 			lnum, err := left.getInteger()
 			if err != nil {
-				return
+				return nil, err
 			}
 			rnum, err := right.getUInteger()
 			if err != nil {
-				return
+				return nil, err
 			}
 			return valueNode(nil, "left shift", Numeric, float64(lnum<<rnum)), nil
 		},
 		">>": func(left *Node, right *Node) (result *Node, err error) {
 			lnum, err := left.getInteger()
 			if err != nil {
-				return
+				return nil, err
 			}
 			rnum, err := right.getUInteger()
 			if err != nil {
-				return
+				return nil, err
 			}
 			return valueNode(nil, "right shift", Numeric, float64(lnum>>rnum)), nil
 		},
 		"&": func(left *Node, right *Node) (result *Node, err error) {
 			lnum, rnum, err := _ints(left, right)
 			if err != nil {
-				return
+				return nil, err
 			}
 			return valueNode(nil, "bitwise AND", Numeric, float64(lnum&rnum)), nil
 		},
 		"&^": func(left *Node, right *Node) (result *Node, err error) {
 			lnum, rnum, err := _ints(left, right)
 			if err != nil {
-				return
+				return nil, err
 			}
 			return valueNode(nil, "bit clear (AND NOT)", Numeric, float64(lnum&^rnum)), nil
 		},
@@ -182,14 +182,14 @@ var (
 		"-": func(left *Node, right *Node) (result *Node, err error) {
 			lnum, rnum, err := _floats(left, right)
 			if err != nil {
-				return
+				return nil, err
 			}
 			return valueNode(nil, "sub", Numeric, float64(lnum-rnum)), nil
 		},
 		"|": func(left *Node, right *Node) (result *Node, err error) {
 			lnum, rnum, err := _ints(left, right)
 			if err != nil {
-				return
+				return nil, err
 			}
 			return valueNode(nil, "bitwise OR", Numeric, float64(lnum|rnum)), nil
 		},
@@ -355,7 +355,7 @@ var (
 			}
 			num, err := node.getInteger()
 			if err != nil {
-				return
+				return nil, err
 			}
 			return valueNode(nil, "Pow10", Numeric, float64(math.Pow10(num))), nil
 		},
@@ -384,7 +384,7 @@ var (
 			}
 			num, err := node.getUInteger()
 			if err != nil {
-				return
+				return nil, err
 			}
 			return valueNode(nil, "factorial", Numeric, float64(mathFactorial(num))), nil
 		},
@@ -445,9 +445,9 @@ var (
 					if remainder != 0 {
 						size += 1 + remainder
 					}
-					var result []byte = make([]byte, size)
-					base64.StdEncoding.WithPadding(base64.NoPadding).Encode(result, []byte(sourceString))
-					return valueNode(nil, "b64encoden", String, string(result)), nil
+					var bytes = make([]byte, size)
+					base64.StdEncoding.WithPadding(base64.NoPadding).Encode(bytes, []byte(sourceString))
+					return valueNode(nil, "b64encoden", String, string(bytes)), nil
 				}
 			}
 			return valueNode(nil, "b64encoden", Null, nil), nil
@@ -462,9 +462,9 @@ var (
 					if remainder != 0 {
 						size += 4
 					}
-					var result []byte = make([]byte, size)
-					base64.StdEncoding.WithPadding(base64.StdPadding).Encode(result, []byte(sourceString))
-					return valueNode(nil, "b64encode", String, string(result)), nil
+					var bytes = make([]byte, size)
+					base64.StdEncoding.WithPadding(base64.StdPadding).Encode(bytes, []byte(sourceString))
+					return valueNode(nil, "b64encode", String, string(bytes)), nil
 				}
 			}
 			return valueNode(nil, "b64encode", Null, nil), nil
@@ -510,7 +510,7 @@ var (
 			}
 			num, err := node.GetNumeric()
 			if err != nil {
-				return
+				return nil, err
 			}
 			return valueNode(nil, "Rand", Numeric, randFunc()*num), nil
 		},
@@ -520,7 +520,7 @@ var (
 			}
 			num, err := node.getInteger()
 			if err != nil {
-				return
+				return nil, err
 			}
 			return valueNode(nil, "RandInt", Numeric, float64(randIntFunc(num))), nil
 		},
@@ -572,6 +572,74 @@ var (
 			}
 			return valueNode(nil, "key", Null, nil), nil
 		},
+		"is_null": func(node *Node) (result *Node, err error) {
+			if node == nil {
+				return valueNode(nil, "is_null", Null, nil), nil
+			}
+			return valueNode(nil, "is_null", Bool, node.IsNull()), nil
+		},
+		"is_numeric": func(node *Node) (result *Node, err error) {
+			if node == nil {
+				return valueNode(nil, "is_numeric", Null, nil), nil
+			}
+			return valueNode(nil, "is_numeric", Bool, node.IsNumeric()), nil
+		},
+		"is_int": func(node *Node) (result *Node, err error) {
+			if node == nil {
+				return valueNode(nil, "is_int", Null, nil), nil
+			}
+			_, err = node.getInteger()
+			if err != nil {
+				return valueNode(nil, "is_int", Bool, false), nil
+			}
+			return valueNode(nil, "is_int", Bool, true), nil
+		},
+		"is_uint": func(node *Node) (result *Node, err error) {
+			if node == nil {
+				return valueNode(nil, "is_uint", Null, nil), nil
+			}
+			_, err = node.getUInteger()
+			if err != nil {
+				return valueNode(nil, "is_uint", Bool, false), nil
+			}
+			return valueNode(nil, "is_uint", Bool, true), nil
+		},
+		"is_float": func(node *Node) (result *Node, err error) {
+			if node == nil {
+				return valueNode(nil, "is_float", Null, nil), nil
+			}
+			if node.IsNumeric() {
+				_, err = node.getInteger()
+				if err != nil {
+					return valueNode(nil, "is_float", Bool, true), nil
+				}
+			}
+			return valueNode(nil, "is_float", Bool, false), nil
+		},
+		"is_string": func(node *Node) (result *Node, err error) {
+			if node == nil {
+				return valueNode(nil, "is_string", Null, nil), nil
+			}
+			return valueNode(nil, "is_string", Bool, node.IsString()), nil
+		},
+		"is_bool": func(node *Node) (result *Node, err error) {
+			if node == nil {
+				return valueNode(nil, "is_bool", Null, nil), nil
+			}
+			return valueNode(nil, "is_bool", Bool, node.IsBool()), nil
+		},
+		"is_array": func(node *Node) (result *Node, err error) {
+			if node == nil {
+				return valueNode(nil, "is_array", Null, nil), nil
+			}
+			return valueNode(nil, "is_array", Bool, node.IsArray()), nil
+		},
+		"is_object": func(node *Node) (result *Node, err error) {
+			if node == nil {
+				return valueNode(nil, "is_object", Null, nil), nil
+			}
+			return valueNode(nil, "is_object", Bool, node.IsObject()), nil
+		},
 	}
 
 	constants = map[string]*Node{