OnX generic function and some tests

helpers.go

@@ -55,6 +55,73 @@ func OnLink(it LinkOrIRI, fn WithLinkFn) error {
 	return fn(ob)
 }
 
+func On[T Objects](it Item, fn func(*T) error) error {
+	/*
+		switch i := it.(type) {
+		case *Object:
+			return fn(i)
+		case Object:
+			return fn(&i)
+		case *Place:
+			return fn(i)
+		case Place:
+			return fn(&i)
+		case *Profile:
+			return fn(i)
+		case Profile:
+			return fn(&i)
+		case *Relationship:
+			return fn(i)
+		case Relationship:
+			return fn(&i)
+		case *Tombstone:
+			return fn(i)
+		case Tombstone:
+			return fn(&i)
+		case *Actor:
+			return fn(i)
+		case Actor:
+			return fn(&i)
+		case *Activity:
+			return fn(i)
+		case Activity:
+			return fn(&i)
+		case *IntransitiveActivity:
+			return fn(i)
+		case IntransitiveActivity:
+			return fn(&i)
+		case *Question:
+			return fn(i)
+		case Question:
+			return fn(&i)
+		case *Collection:
+			return fn(i)
+		case Collection:
+			return fn(&i)
+		case *CollectionPage:
+			return fn(i)
+		case CollectionPage:
+			return fn(&i)
+		case *OrderedCollection:
+			return fn(i)
+		case OrderedCollection:
+			return fn(&i)
+		case *OrderedCollectionPage:
+			return fn(i)
+		case OrderedCollectionPage:
+			return fn(&i)
+		default:
+			typ := reflect.TypeOf(new(Object))
+			if reflect.TypeOf(it).ConvertibleTo(typ) {
+				if i, ok := reflect.ValueOf(it).Convert(typ).Interface().(*Object); ok {
+					return fn(i)
+				}
+			}
+		}
+	*/
+	return fmt.Errorf("invalid type %T for generic function", it)
+}
+
 // OnObject calls function fn on it Item if it can be asserted to type *Object
 //
 // This function should be safe to be called for all types with a structure compatible

helpers_test.go

@@ -268,3 +268,49 @@ func TestOnCollectionPage(t *testing.T) {
 func TestOnOrderedCollectionPage(t *testing.T) {
 	t.Skipf("TODO")
 }
+
+type args[T Objects] struct {
+	it T
+	fn func (fn canErrorFunc, expected T) func(*T) error
+}
+
+type testPair[T Objects] struct {
+	name     string
+	args     args[T]
+	expected T
+	wantErr  bool
+}
+
+func assert[T Objects](fn canErrorFunc, expected T) func(*T) error {
+	return func(p *T) error {
+		if !assertDeepEquals(fn, *p, expected) {
+			return fmt.Errorf("not equal")
+		}
+		return nil
+	}
+}
+
+func TestOn(t *testing.T) {
+	testQuestion := Object{ID: "https://example.com"}
+	var tests []testPair[Object] = []testPair[Object]{
+		{
+			name:     "single",
+			args:     args[Object]{testQuestion, assert[Object]},
+			expected: testQuestion,
+			wantErr:  true,
+		},
+	}
+	for _, tt := range tests {
+		var logFn canErrorFunc
+		if tt.wantErr {
+			logFn = t.Logf
+		} else {
+			logFn = t.Errorf
+		}
+		t.Run(tt.name, func(t *testing.T) {
+			if err := On(tt.args.it, tt.args.fn(logFn, tt.expected)); (err != nil) != tt.wantErr {
+				t.Errorf("On[%T]() error = %v, wantErr %v", tt.args.it, err, tt.wantErr)
+			}
+		})
+	}
+}