Added UCL Object construction functions

These functions wrap around libucl's ucl_object_from* functions.
Additional tests were added to the test suite in object_test.go to test
that these new functions operate correctly.

Author: draringi

object.go

@@ -217,15 +217,49 @@ const (
 	StringParseBoolean StringFlag = C.UCL_STRING_PARSE_BOOLEAN
 	// StringParseInt tells the converter to parse the inputted string as an integer
 	StringParseInt StringFlag = C.UCL_STRING_PARSE_INT
-	// StringParseDouble tells the converter to parse the inputted string as a floating-point number
+	// StringParseDouble tells the converter to parse the inputted string as a
+	// floating-point number
 	StringParseDouble StringFlag = C.UCL_STRING_PARSE_DOUBLE
-	// StringParseTime tells the converter to parse the inputted string as a time value, and treat as a floating-point number.
+	// StringParseTime tells the converter to parse the inputted string as a time value,
+	// and treat as a floating-point number.
 	StringParseTime StringFlag = C.UCL_STRING_PARSE_TIME
-	// StringParseNumber tells the converter to parse the inputted string as a number (integer, floating-point or time)
+	// StringParseNumber tells the converter to parse the inputted string as a number
+	// (integer, floating-point or time)
 	StringParseNumber StringFlag = C.UCL_STRING_PARSE_TIME
 	// StringParse tells the converter to parse the inputted string
 	StringParse StringFlag = C.UCL_STRING_PARSE
-	// StringParseBytes tells the converter to parse the inputted string as being in bytes notation
-	// (e.g. 10k = 10*1024, not 10*1000)
+	// StringParseBytes tells the converter to parse the inputted string as being in
+	// bytes notation (e.g. 10k = 10*1024, not 10*1000)
 	StringParseBytes StringFlag = C.UCL_STRING_PARSE_BYTES
 )
+
+// NewObject creates a new UCL Object from a string, JSON escaping it in the process
+func NewObject(data string) *Object {
+	obj := C.ucl_object_fromlstring(C.CString(data), C.size_t(len(data)))
+	return &Object{object: obj}
+}
+
+// NewFormattedObject creates a new UCL Object from a string, according to the instructions
+// given in the flags
+func NewFormattedObject(data string, flags StringFlag) *Object {
+	obj := C.ucl_object_fromstring_common(C.CString(data), C.size_t(len(data)), uint32(flags))
+	return &Object{object: obj}
+}
+
+// NewIntegerObject creates a new UCL Object from a 64-bit integer
+func NewIntegerObject(data int64) *Object {
+	obj := C.ucl_object_fromint(C.int64_t(data))
+	return &Object{object: obj}
+}
+
+// NewDoubleObject creates a new UCL Object from a 64-bit floating-point number
+func NewDoubleObject(data float64) *Object {
+	obj := C.ucl_object_fromdouble(C.double(data))
+	return &Object{object: obj}
+}
+
+// NewBoolObject creates a new UCL Object from a boolean
+func NewBoolObject(data bool) *Object {
+	obj := C.ucl_object_frombool(C.bool(data))
+	return &Object{object: obj}
+}

object_test.go

@@ -234,3 +234,97 @@ func TestObjectToFloat_negativeOneThird(t *testing.T) {
 		t.Fatalf("bad: %#v, expected: %v", v.ToFloat(), g)
 	}
 }
+
+func TestIntToObject(t *testing.T) {
+	var testValue int64 = 42
+	obj := NewIntegerObject(testValue)
+	defer obj.Close()
+	v := obj.ToInt()
+	if v != testValue {
+		t.Fatalf("bad: %d, expected: %d", v, testValue)
+	}
+}
+
+func TestBoolToObject(t *testing.T) {
+	objTrue := NewBoolObject(true)
+	defer objTrue.Close()
+	if !objTrue.ToBool() {
+		t.Fatalf("bad: false, expected: true")
+	}
+	objFalse := NewBoolObject(false)
+	defer objFalse.Close()
+	if objFalse.ToBool() {
+		t.Fatalf("bad: true, expected: false")
+	}
+}
+
+func TestFloatToObject(t *testing.T) {
+	testValue := -1.0 / 3.0
+	obj := NewDoubleObject(testValue)
+	defer obj.Close()
+	if obj.ToFloat() != testValue {
+		t.Fatalf("bad: %#v, expected: %v", obj.ToFloat(), testValue)
+	}
+}
+
+func TestSimpleStringToObject(t *testing.T) {
+	s := "Hello World!"
+	obj := NewObject(s)
+	defer obj.Close()
+	if obj.ToString() != s {
+		t.Fatalf("bad: \"%s\", expected: \"%s\"", obj.ToString(), s)
+	}
+}
+
+func TestJSONEscapeStringToObject(t *testing.T) {
+	inputString := "complex\tstring\nfrom\"hell\""
+	escapedString := "complex\\tstring\\nfrom\\\"hell\\\""
+	obj := NewObject(inputString)
+	defer obj.Close()
+	if obj.ToString() != escapedString {
+		t.Fatalf("bad: \"%s\", expected: \"%s\"", obj.ToString(), escapedString)
+	}
+}
+
+func TestStringIntToObject(t *testing.T) {
+	var i int64 = 42
+	s := "42"
+	obj := NewFormattedObject(s, StringParseInt)
+	defer obj.Close()
+	if obj.ToInt() != i {
+		t.Fatalf("bad: %d, expected: %d", obj.ToInt(), i)
+	}
+}
+
+func TestStringFloatToObject(t *testing.T) {
+	expectedValue := -1.0 / 3.0
+	testString := "-0.3333333333333333148296162562473909929394721984863281"
+	obj := NewFormattedObject(testString, StringParseDouble)
+	defer obj.Close()
+	if obj.ToFloat() != expectedValue {
+		t.Fatalf("bad: %#v, expected: %v", obj.ToFloat(), expectedValue)
+	}
+}
+
+func TestStringBoolToObject(t *testing.T) {
+	objFalse := NewFormattedObject("false", StringParseBoolean)
+	defer objFalse.Close()
+	if objFalse.ToBool() {
+		t.Fatal("bad: true, expected: false")
+	}
+	objTrue := NewFormattedObject("true", StringParseBoolean)
+	defer objTrue.Close()
+	if !objTrue.ToBool() {
+		t.Fatal("bad: false, expected: true")
+	}
+}
+
+func TestStringTrimToObject(t *testing.T) {
+	rawString := "  Hello World\n\t\n\t\n\t  "
+	expectedResult := "Hello World"
+	obj := NewFormattedObject(rawString, StringTrim)
+	defer obj.Close()
+	if obj.ToString() != expectedResult {
+		t.Fatalf("bad: \"%s\", expected: \"%s\"", obj.ToString(), expectedResult)
+	}
+}