Add simple RDF graph.

datatypes.go

@@ -1,22 +1,22 @@
 package rdf
 
-import "fmt"
+import (
+ "fmt"
+ "math/big"
+ "strings"
+)
 
 type DataType string
 
 // INFO on datatypes: https://www.w3.org/TR/xmlschema11-2/type-hierarchy-201104.longdesc.html
 const (
- XSD = "http:https://www.w3.org/2001/XMLSchema#"
- XSDAnyType DataType = XSD + "anyType"
- XSDAnyURI DataType = XSD + "anyURI"
- XSDBase64Binary DataType = XSD + "base64Binary"
- XSDBoolean DataType = XSD + "boolean"
- XSDDate DataType = XSD + "date"
- XDSDecimal DataType = XSD + "decimal"
- XSDDouble DataType = XSD + "double"
- XSDDuration DataType = XSD + "duration"
- XSDFloat DataType = XSD + "float"
- XSDString DataType = XSD + "string"
+ XSD = "http:https://www.w3.org/2001/XMLSchema#"
+ XSDAnyType DataType = XSD + "anyType"
+ XSDBoolean DataType = XSD + "boolean"
+ XSDInteger DataType = XSD + "integer"
+ XSDDecimal DataType = XSD + "decimal"
+ XSDDouble DataType = XSD + "double"
+ XSDString DataType = XSD + "string"
  // TODO: add "other" build-in atomic types, e.g. dateTimeStamp etc.
 
  XSDNS = "http:https://www.w3.org/1999/02/22-rdf-syntax-ns#"
@@ -35,6 +35,27 @@ func (d DataType) NativeType(value string) (any, bool, error) {
  return value[0] == 't', true, nil
  }
  return nil, false, fmt.Errorf("invalid boolean value: %q", value)
+ case XSDInteger:
+ if i, ok := new(big.Int).SetString(value, 10); ok {
+ return i, true, nil
+ }
+ return nil, false, fmt.Errorf("invalid integer value: %q", value)
+ case XSDDecimal:
+ if strings.ContainsAny(value, "eE") {
+ return nil, false, fmt.Errorf("invalid decimal value: %q", value)
+ }
+ if f, ok := new(big.Float).SetString(value); ok {
+ return f, true, nil
+ }
+ return nil, false, fmt.Errorf("invalid decimal value: %q", value)
+ case XSDDouble:
+ if value == "INF" || value == "-INF" || value == "NaN" {
+ return value, true, nil
+ }
+ if f, ok := new(big.Float).SetString(value); ok {
+ return f, true, nil
+ }
+ return nil, false, fmt.Errorf("invalid decimal value: %q", value)
  default:
  return value, false, nil
  }
@@ -46,7 +67,6 @@ func (d DataType) Validate(v any, acceptString bool) bool {
  // TODO: validate string against the datatype.
  return true
  }
-
  switch d {
  case XSDAnyType:
  return true
@@ -56,6 +76,18 @@ func (d DataType) Validate(v any, acceptString bool) bool {
  case XSDBoolean:
  _, ok := v.(bool)
  return ok
+ case XSDInteger:
+ _, ok := v.(*big.Int)
+ return ok
+ case XSDDecimal:
+ _, ok := v.(*big.Float)
+ return ok
+ case XSDDouble:
+ if _, ok := v.(*big.Float); ok {
+ return true
+ }
+ _, ok := v.(string)
+ return ok && (v == "INF" || v == "-INF" || v == "NaN")
  default:
  return false
  }

datatypes_test.go

@@ -0,0 +1,54 @@
+package rdf
+
+import "testing"
+
+// https://www.w3.org/TR/xmlschema-2/#decimal
+func TestDataType_NativeType_decimal(t *testing.T) {
+ for _, test := range []string{
+ "-1", "12678967", "+100000", "210",
+ "-1.23", "12678967.543233", "+100000.00", "210",
+ } {
+ if _, ok, err := XSDDecimal.NativeType(test); !ok || err != nil {
+ t.Errorf("XSDDecimal.NativeType(%q) = %v, %v; want %v, nil", test, ok, err, true)
+ }
+ }
+ for _, test := range []string{
+ "-1E4", "1267.43233E12", "12.78e-2", "INF",
+ } {
+ if _, ok, err := XSDDecimal.NativeType(test); ok || err == nil {
+ t.Errorf("XSDDecimal.NativeType(%q) = %v, %v; want %v, nil", test, ok, err, false)
+ }
+ }
+}
+
+// https://www.w3.org/TR/xmlschema-2/#double
+func TestDataType_NativeType_double(t *testing.T) {
+ for _, test := range []string{
+ "-1", "12678967", "+100000", "210",
+ "-1.23", "12678967.543233", "+100000.00", "210",
+ "-1E4", "1267.43233E12", "12.78e-2", "12", "-0", "0", "INF",
+ } {
+ if _, ok, err := XSDDouble.NativeType(test); !ok || err != nil {
+ t.Errorf("XSDDouble.NativeType(%q) = %v, %v; want %v, nil", test, ok, err, true)
+ }
+ }
+}
+
+// https://www.w3.org/TR/xmlschema-2/#integer
+func TestDataType_NativeType_integer(t *testing.T) {
+ for _, test := range []string{
+ "-1", "12678967", "+100000", "210",
+ } {
+ if _, ok, err := XSDInteger.NativeType(test); !ok || err != nil {
+ t.Errorf("XSDInteger.NativeType(%q) = %v, %v; want %v, nil", test, ok, err, true)
+ }
+ }
+ for _, test := range []string{
+ "-1.23", "12678967.543233", "+100000.00",
+ "-1E4", "1267.43233E12", "12.78e-2", "INF",
+ } {
+ if _, ok, err := XSDInteger.NativeType(test); ok || err == nil {
+ t.Errorf("XSDInteger.NativeType(%q) = %v, %v; want %v, nil", test, ok, err, false)
+ }
+ }
+}

graph.go

@@ -0,0 +1,72 @@
+package rdf
+
+type Graph struct {
+ triples map[*Triple]struct{}
+}
+
+func NewGraph(ts ...*Triple) *Graph {
+ triples := make(map[*Triple]struct{})
+ for _, t := range ts {
+ triples[t] = struct{}{}
+ }
+ return &Graph{triples}
+}
+
+func (g *Graph) Add(s, p, o Node) {
+ t := &Triple{s, p, o}
+ g.triples[t] = struct{}{}
+}
+
+// Find returns the first triple matching the given pattern.
+func (g *Graph) Find(s, p, o Node) *Triple {
+ for t := range g.triples {
+ if (s == nil || t.Subject == s) &&
+ (p == nil || t.Predicate == p) &&
+ (o == nil || t.Object == o) {
+ return t
+ }
+ }
+ return nil
+}
+
+// FindAll returns all triples matching the given pattern.
+func (g *Graph) FindAll(s, p, o Node) []*Triple {
+ var triples []*Triple
+ for t := range g.iter() {
+ if (s == nil || t.Subject == s) &&
+ (p == nil || t.Predicate == p) &&
+ (o == nil || t.Object == o) {
+ triples = append(triples, t)
+ }
+ }
+ return triples
+}
+
+func (g *Graph) Remove(t *Triple) {
+ delete(g.triples, t)
+}
+
+func (g *Graph) iter() chan *Triple {
+ ch := make(chan *Triple)
+ go func() {
+ for t := range g.triples {
+ ch <- t
+ }
+ close(ch)
+ }()
+ return ch
+}
+
+type Triple struct {
+ Subject Node
+ Predicate Node
+ Object Node
+}
+
+func NewTriple(s, p, o Node) *Triple {
+ return &Triple{s, p, o}
+}
+
+func (t *Triple) Equal(other *Triple) bool {
+ return t.Subject.Equal(other.Subject) && t.Predicate.Equal(other.Predicate) && t.Object.Equal(other.Object)
+}

graph_test.go

@@ -0,0 +1,37 @@
+package rdf
+
+import "testing"
+
+func TestGraph(t *testing.T) {
+ var (
+ a = &BlankNode{"a"}
+ b = &BlankNode{"b"}
+ c = &BlankNode{"c"}
+ )
+
+ abc := NewTriple(a, b, c)
+ abb := NewTriple(a, b, b)
+ aaa := NewTriple(a, a, a)
+
+ g := NewGraph(abc, abb, aaa)
+
+ if triple := g.Find(nil, nil, nil); triple != abc {
+ t.Error("expected abc")
+ }
+ if triple := g.Find(a, b, c); triple != abc {
+ t.Error("expected abc")
+ }
+ if triple := g.Find(a, a, a); t == nil || triple != aaa {
+ t.Error("expected aaa")
+ }
+ if triple := g.Find(nil, a, nil); triple != aaa {
+ t.Error("expected aaa")
+ }
+
+ if len(g.FindAll(a, nil, nil)) != 3 {
+ t.Error("expected 3 triples")
+ }
+ if len(g.FindAll(nil, b, nil)) != 2 {
+ t.Error("expected 2 triples")
+ }
+}

node.go

@@ -10,6 +10,17 @@ type BlankNode struct {
  Attribute string
 }
 
+func (b *BlankNode) Equal(other Node) bool {
+ if other, ok := other.(*BlankNode); ok {
+ return b.Attribute == other.Attribute
+ }
+ return false
+}
+
+func (b *BlankNode) GetValue() string {
+ return b.Attribute
+}
+
 func (b *BlankNode) toObject(_ bool) (map[string]any, error) {
  return map[string]any{
  "@id": b.Attribute,
@@ -20,6 +31,17 @@ type IRIReference struct {
  Value string
 }
 
+func (r *IRIReference) Equal(other Node) bool {
+ if other, ok := other.(*IRIReference); ok {
+ return r.Value == other.Value
+ }
+ return false
+}
+
+func (r *IRIReference) GetValue() string {
+ return r.Value
+}
+
 func (r *IRIReference) toObject(_ bool) (map[string]any, error) {
  return map[string]any{
  "@id": r.Value,
@@ -36,6 +58,17 @@ type Literal struct {
  Language string
 }
 
+func (l *Literal) Equal(other Node) bool {
+ if other, ok := other.(*Literal); ok {
+ return l.Value == other.Value && l.Datatype == other.Datatype && l.Language == other.Language
+ }
+ return false
+}
+
+func (l *Literal) GetValue() string {
+ return l.Value
+}
+
 func (l *Literal) toObject(nativeTypes bool) (map[string]any, error) {
  if l.Language != "" {
  if l.Datatype != "" && l.Datatype != XSDNSString {
@@ -68,10 +101,15 @@ func (l *Literal) toObject(nativeTypes bool) (map[string]any, error) {
 }
 
 type Node interface {
+ // GetValue returns the value of the node.
+ GetValue() string
+ // Equal returns true if the two nodes are equal.
+ Equal(other Node) bool
+
  toObject(nativeTypes bool) (map[string]any, error)
 }
 
-func FromObject(obj any, acceptString bool) (Node, error) {
+func fromObject(obj any, acceptString bool) (Node, error) {
  var id string
  switch obj := obj.(type) {
  case map[string]any:
@@ -80,7 +118,7 @@ func FromObject(obj any, acceptString bool) (Node, error) {
  Value: fmt.Sprintf("%v", v),
  Datatype: XSDString,
  }
- if datatype, ok := obj["@datatype"]; ok {
+ if datatype, ok := obj["@type"]; ok {
  s, ok := datatype.(string)
  if !ok {
  return nil, fmt.Errorf("invalid @datatype attribute: %T", datatype)
@@ -90,6 +128,20 @@ func FromObject(obj any, acceptString bool) (Node, error) {
  if !literal.Datatype.Validate(v, acceptString) {
  return nil, fmt.Errorf("invalid @value for datatype %s: %v", literal.Datatype, v)
  }
+
+ if language, ok := obj["@language"]; ok {
+ s, ok := language.(string)
+ if !ok {
+ return nil, fmt.Errorf("invalid @language attribute: %T", language)
+ }
+ literal.Language = s
+ if literal.Datatype != "" && literal.Datatype != XSDNSString {
+ return nil, fmt.Errorf("invalid datatype for language literal: %s", literal.Datatype)
+ }
+ if literal.Datatype == "" {
+ literal.Datatype = XSDNSString
+ }
+ }
  return literal, nil
  }
 

node_test.go

@@ -20,7 +20,7 @@ func TestFromObject_blankNode(t *testing.T) {
  if err := json.Unmarshal([]byte(test), &m); err != nil {
  t.Fatal(err)
  }
- n, err := FromObject(m, false)
+ n, err := fromObject(m, false)
  if err != nil {
  t.Fatal(err)
  }
@@ -43,7 +43,7 @@ func TestFromObject_iriReference(t *testing.T) {
  if err := json.Unmarshal([]byte(test), &m); err != nil {
  t.Fatal(err)
  }
- n, err := FromObject(m, false)
+ n, err := fromObject(m, false)
  if err != nil {
  t.Fatal(err)
  }