1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92
93. 93
94. 94

package jsonld

import (
	"encoding/json"
	"fmt"
	"strings"

	ap "github.com/mariusor/activitypub.go/activitypub"
)

var Ctx interface{}

// Ref basic type
type Ref string

// Context is the basic JSON-LD element. It is used to map terms to IRIs.
// Terms are case sensitive and any valid string that is not a reserved JSON-LD
// keyword can be used as a term.
type Context struct {
	URL      Ref        `jsonld:"@url,omitempty,collapsible"`
	Language ap.LangRef `jsonld:"@language,omitempty,collapsible"`
}

// Collapsible is an interface used by the JSON-LD marshaller to collapse a struct to one single value
type Collapsible interface {
	Collapse() []byte
}

// Ref returns a new Ref object based on Context URL
func (c *Context) Ref() Ref {
	return Ref(c.URL)
}

// Collapse returns the plain text collapsed value of the current Context object
func (c *Context) Collapse() []byte {
	return []byte(c.URL)
}

// MarshalText basic stringify function
func (r *Ref) MarshalText() ([]byte, error) {
	return []byte(*r), nil
}

// MarshalJSON returns the JSON document represented by the current Context
func (c *Context) MarshalJSON() ([]byte, error) {
	a := reflectToJSONValue(c)
	if a.isScalar {
		return json.Marshal(a.scalar)
	}
	return json.Marshal(a.object)
}

// UnmarshalJSON tries to load the Context from the incoming json value
func (c *Context) UnmarshalJSON(data []byte) error {
	if data[0] == '"' {
		// a quoted string - loading it to c.URL
		if data[len(data)-1] != '"' {
			return fmt.Errorf("invalid string value when unmarshalling Context value")
		}
		c.URL = Ref(data[1 : len(data)-1])
	}
	if data[0] == '{' {
		// an object - trying to load it to the struct
		if data[len(data)-1] != '}' {
			return fmt.Errorf("invalid object value when unmarshalling Context value")
		}

		var s scanner
		s.reset()
		var d decodeState
		d.scan = s
		d.init(data)

		d.scan.reset()

		t := d.valueInterface()

		for key, value := range t.(map[string]interface{}) {
			switch strings.ToLower(key) {
			case "@url":
				fallthrough
			case "url":
				c.URL = Ref(value.(string))
			case "@language":
				fallthrough
			case "language":
				c.Language = ap.LangRef(value.(string))
			default:
				return fmt.Errorf("unkown Context field %q", key)
			}
		}
	}
	return nil
}