Added some lazy vendor list parsing code.

Author: dbemiller

.gitignore

@@ -0,0 +1 @@
+vendor/

Gopkg.lock

@@ -0,0 +1,30 @@
+# Gopkg.toml example
+#
+# Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
+# for detailed Gopkg.toml documentation.
+#
+# required = ["github.com/user/thing/cmd/thing"]
+# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
+#
+# [[constraint]]
+#   name = "github.com/user/project"
+#   version = "1.0.0"
+#
+# [[constraint]]
+#   name = "github.com/user/project2"
+#   branch = "dev"
+#   source = "github.com/myfork/project2"
+#
+# [[override]]
+#   name = "github.com/x/y"
+#   version = "2.4.0"
+#
+# [prune]
+#   non-go = false
+#   go-tests = true
+#   unused-packages = true
+
+
+[[constraint]]
+  name = "github.com/buger/jsonparser"
+  branch = "master"

Gopkg.toml

@@ -0,0 +1,82 @@
+package vendorlist
+
+import (
+	"strconv"
+
+	"github.com/buger/jsonparser"
+)
+
+// ParseLazily returns a view of the data which re-calculates things on each function call.
+// This is cheap, but operations on it will be relatively expensive.
+//
+// This is ideal if you just need to look up information about a single vendor.
+// If you need to make many calls to query lots of information about a vendor,
+// this is not an efficient way to do it.
+//
+// PRs for an eager parser are welcome.
+func ParseLazily(data []byte) VendorList {
+	return lazyVendorList(data)
+}
+
+type lazyVendorList []byte
+
+func (l lazyVendorList) Version() uint16 {
+	if val, ok := lazyParseInt(l, "vendorListVersion"); ok {
+		return uint16(val)
+	}
+	return 0
+}
+
+func (l lazyVendorList) Vendor(vendorID uint16) Vendor {
+	var vendorBytes []byte
+	jsonparser.ArrayEach(l, func(value []byte, dataType jsonparser.ValueType, offset int, err error) {
+		if val, ok := lazyParseInt(value, "id"); ok {
+			if uint16(val) == vendorID {
+				vendorBytes = value
+			}
+		}
+	}, "vendors")
+
+	if len(vendorBytes) > 0 {
+		return lazyVendor(vendorBytes)
+	}
+	return nil
+}
+
+type lazyVendor []byte
+
+func (l lazyVendor) Purpose(purposeID uint8) bool {
+	return idExists(l, int(purposeID), "purposeIds")
+}
+
+func (l lazyVendor) LegitimateInterest(purposeID uint8) bool {
+	return idExists(l, int(purposeID), "legIntPurposeIds")
+}
+
+// Returns false unless "id" exists in an array located at "data.key".
+func idExists(data []byte, id int, key string) bool {
+	hasID := false
+
+	jsonparser.ArrayEach(data, func(value []byte, dataType jsonparser.ValueType, offset int, err error) {
+		if err == nil && dataType == jsonparser.Number {
+			if intVal, err := strconv.ParseInt(string(value), 10, 0); err == nil {
+				if int(intVal) == id {
+					hasID = true
+				}
+			}
+		}
+	}, key)
+
+	return hasID
+}
+
+func lazyParseInt(data []byte, key string) (int, bool) {
+	if value, dataType, _, err := jsonparser.Get(data, key); err == nil && dataType == jsonparser.Number {
+		intVal, err := strconv.Atoi(string(value))
+		if err != nil {
+			return 0, false
+		}
+		return intVal, true
+	}
+	return 0, false
+}

vendorlist/lazy-parsing.go

@@ -0,0 +1,70 @@
+package vendorlist
+
+import (
+	"testing"
+)
+
+const testData = `
+{
+  "vendorListVersion": 5,
+  "vendors": [
+    {
+      "id": 32,
+      "purposeIds": [
+				1,
+				2
+      ],
+      "legIntPurposeIds": [
+        3
+      ],
+      "featureIds": [
+        2,
+        3
+      ]
+    }
+	]
+}
+`
+
+func TestLazyParsedVendorlist(t *testing.T) {
+	list := ParseLazily([]byte(testData))
+	assertIntsEqual(t, 5, int(list.Version()))
+	assertNil(t, list.Vendor(2), true)
+	assertNil(t, list.Vendor(32), false)
+}
+
+func TestLazyParsedVendor(t *testing.T) {
+	list := ParseLazily([]byte(testData))
+	v := list.Vendor(32)
+	assertBoolsEqual(t, true, v.Purpose(1))
+	assertBoolsEqual(t, true, v.Purpose(2))
+	assertBoolsEqual(t, false, v.Purpose(3))
+
+	assertBoolsEqual(t, false, v.LegitimateInterest(1))
+	assertBoolsEqual(t, false, v.LegitimateInterest(2))
+	assertBoolsEqual(t, true, v.LegitimateInterest(3))
+}
+
+func assertIntsEqual(t *testing.T, expected int, actual int) {
+	t.Helper()
+	if actual != expected {
+		t.Errorf("Ints were not equal. Expected %d, actual %d", expected, actual)
+	}
+}
+
+func assertBoolsEqual(t *testing.T, expected bool, actual bool) {
+	t.Helper()
+	if actual != expected {
+		t.Errorf("Bools were not equal. Expected %t, actual %t", expected, actual)
+	}
+}
+
+func assertNil(t *testing.T, value Vendor, expectNil bool) {
+	t.Helper()
+	if expectNil && value != nil {
+		t.Error("The vendor should be nil, but wasn't.")
+	}
+	if !expectNil && value == nil {
+		t.Errorf("The vendor should not be nil, but was.")
+	}
+}

vendorlist/lazy-parsing_test.go

@@ -0,0 +1,26 @@
+package vendorlist
+
+// VendorList is an interface used to fetch information about an IAB Global Vendor list.
+// For the latest version, see: https://vendorlist.consensu.org/vendorlist.json
+type VendorList interface {
+	// Version returns the version of the vendor list which this is.
+	Version() uint16
+
+	// Vendor returns info about the vendor with the given ID, or nil if that vendor isn't in this list.
+	//
+	// If callers need to query multiple Purpose or LegitimateInterest statuses from the same vendor,
+	// they should call this function once and then reuse the object it returns for future queries.
+	Vendor(vendorID uint16) Vendor
+}
+
+// Vendor describes which purposes a given vendor claims to use data for, in this vendor list.
+type Vendor interface {
+	// Purpose returns true if this vendor claims to use data for the given purpose, or false otherwise
+	Purpose(purposeID uint8) bool
+
+	// LegitimateInterest retursn true if this vendor claims a "Legitimate Interest" to
+	// use data for the given purpose.
+	//
+	// For an explanation of legitimate interest, see https://www.gdpreu.org/the-regulation/key-concepts/legitimate-interest/
+	LegitimateInterest(purposeID uint8) bool
+}