policy: remove superfluous interfaces

Those interfaces were only used inside the package, where private concrete work just as well.

capability/policy/match.go

@@ -25,52 +25,52 @@ func Match(policy Policy, node ipld.Node) bool {
 func matchStatement(statement Statement, node ipld.Node) bool {
 	switch statement.Kind() {
 	case KindEqual:
-		if s, ok := statement.(EqualityStatement); ok {
-			one, _, err := selector.Select(s.Selector(), node)
+		if s, ok := statement.(equality); ok {
+			one, _, err := selector.Select(s.selector, node)
 			if err != nil || one == nil {
 				return false
 			}
-			return datamodel.DeepEqual(s.Value(), one)
+			return datamodel.DeepEqual(s.value, one)
 		}
 	case KindGreaterThan:
-		if s, ok := statement.(InequalityStatement); ok {
-			one, _, err := selector.Select(s.Selector(), node)
+		if s, ok := statement.(equality); ok {
+			one, _, err := selector.Select(s.selector, node)
 			if err != nil || one == nil {
 				return false
 			}
-			return isOrdered(s.Value(), one, gt)
+			return isOrdered(s.value, one, gt)
 		}
 	case KindGreaterThanOrEqual:
-		if s, ok := statement.(InequalityStatement); ok {
-			one, _, err := selector.Select(s.Selector(), node)
+		if s, ok := statement.(equality); ok {
+			one, _, err := selector.Select(s.selector, node)
 			if err != nil || one == nil {
 				return false
 			}
-			return isOrdered(s.Value(), one, gte)
+			return isOrdered(s.value, one, gte)
 		}
 	case KindLessThan:
-		if s, ok := statement.(InequalityStatement); ok {
-			one, _, err := selector.Select(s.Selector(), node)
+		if s, ok := statement.(equality); ok {
+			one, _, err := selector.Select(s.selector, node)
 			if err != nil || one == nil {
 				return false
 			}
-			return isOrdered(s.Value(), one, lt)
+			return isOrdered(s.value, one, lt)
 		}
 	case KindLessThanOrEqual:
-		if s, ok := statement.(InequalityStatement); ok {
-			one, _, err := selector.Select(s.Selector(), node)
+		if s, ok := statement.(equality); ok {
+			one, _, err := selector.Select(s.selector, node)
 			if err != nil || one == nil {
 				return false
 			}
-			return isOrdered(s.Value(), one, lte)
+			return isOrdered(s.value, one, lte)
 		}
 	case KindNot:
-		if s, ok := statement.(NegationStatement); ok {
-			return !matchStatement(s.Value(), node)
+		if s, ok := statement.(negation); ok {
+			return !matchStatement(s.statement, node)
 		}
 	case KindAnd:
-		if s, ok := statement.(ConjunctionStatement); ok {
-			for _, cs := range s.Value() {
+		if s, ok := statement.(connective); ok {
+			for _, cs := range s.statements {
 				r := matchStatement(cs, node)
 				if !r {
 					return false
@@ -79,11 +79,11 @@ func matchStatement(statement Statement, node ipld.Node) bool {
 			return true
 		}
 	case KindOr:
-		if s, ok := statement.(DisjunctionStatement); ok {
-			if len(s.Value()) == 0 {
+		if s, ok := statement.(connective); ok {
+			if len(s.statements) == 0 {
 				return true
 			}
-			for _, cs := range s.Value() {
+			for _, cs := range s.statements {
 				r := matchStatement(cs, node)
 				if r {
 					return true
@@ -92,8 +92,8 @@ func matchStatement(statement Statement, node ipld.Node) bool {
 			return false
 		}
 	case KindLike:
-		if s, ok := statement.(WildcardStatement); ok {
-			one, _, err := selector.Select(s.Selector(), node)
+		if s, ok := statement.(wildcard); ok {
+			one, _, err := selector.Select(s.selector, node)
 			if err != nil || one == nil {
 				return false
 			}
@@ -101,16 +101,16 @@ func matchStatement(statement Statement, node ipld.Node) bool {
 			if err != nil {
 				return false
 			}
-			return s.Value().Match(v)
+			return s.glob.Match(v)
 		}
 	case KindAll:
-		if s, ok := statement.(QuantifierStatement); ok {
-			_, many, err := selector.Select(s.Selector(), node)
+		if s, ok := statement.(quantifier); ok {
+			_, many, err := selector.Select(s.selector, node)
 			if err != nil || many == nil {
 				return false
 			}
 			for _, n := range many {
-				ok := Match(s.Value(), n)
+				ok := Match(s.statements, n)
 				if !ok {
 					return false
 				}
@@ -118,13 +118,13 @@ func matchStatement(statement Statement, node ipld.Node) bool {
 			return true
 		}
 	case KindAny:
-		if s, ok := statement.(QuantifierStatement); ok {
-			_, many, err := selector.Select(s.Selector(), node)
+		if s, ok := statement.(quantifier); ok {
+			_, many, err := selector.Select(s.selector, node)
 			if err != nil || many == nil {
 				return false
 			}
 			for _, n := range many {
-				ok := Match(s.Value(), n)
+				ok := Match(s.statements, n)
 				if ok {
 					return true
 				}

capability/policy/policy.go

@@ -10,17 +10,17 @@ import (
 )
 
 const (
-	KindEqual              = "=="
-	KindGreaterThan        = ">"
-	KindGreaterThanOrEqual = ">="
-	KindLessThan           = "<"
-	KindLessThanOrEqual    = "<="
-	KindNot                = "not"
-	KindAnd                = "and"
-	KindOr                 = "or"
-	KindLike               = "like"
-	KindAll                = "all"
-	KindAny                = "any"
+	KindEqual              = "=="   // implemented by equality
+	KindGreaterThan        = ">"    // implemented by equality
+	KindGreaterThanOrEqual = ">="   // implemented by equality
+	KindLessThan           = "<"    // implemented by equality
+	KindLessThanOrEqual    = "<="   // implemented by equality
+	KindNot                = "not"  // implemented by negation
+	KindAnd                = "and"  // implemented by connective
+	KindOr                 = "or"   // implemented by connective
+	KindLike               = "like" // implemented by wildcard
+	KindAll                = "all"  // implemented by quantifier
+	KindAny                = "any"  // implemented by quantifier
 )
 
 type Policy []Statement
@@ -29,49 +29,6 @@ type Statement interface {
 	Kind() string
 }
 
-type EqualityStatement interface {
-	Statement
-	Selector() selector.Selector
-	Value() ipld.Node
-}
-
-type InequalityStatement interface {
-	Statement
-	Selector() selector.Selector
-	Value() ipld.Node
-}
-
-type WildcardStatement interface {
-	Statement
-	Selector() selector.Selector
-	Value() glob.Glob
-}
-
-type ConnectiveStatement interface {
-	Statement
-}
-
-type NegationStatement interface {
-	ConnectiveStatement
-	Value() Statement
-}
-
-type ConjunctionStatement interface {
-	ConnectiveStatement
-	Value() []Statement
-}
-
-type DisjunctionStatement interface {
-	ConnectiveStatement
-	Value() []Statement
-}
-
-type QuantifierStatement interface {
-	Statement
-	Selector() selector.Selector
-	Value() Policy
-}
-
 type equality struct {
 	kind     string
 	selector selector.Selector
@@ -82,31 +39,23 @@ func (e equality) Kind() string {
 	return e.kind
 }
 
-func (e equality) Value() ipld.Node {
-	return e.value
-}
-
-func (e equality) Selector() selector.Selector {
-	return e.selector
-}
-
-func Equal(selector selector.Selector, value ipld.Node) EqualityStatement {
+func Equal(selector selector.Selector, value ipld.Node) Statement {
 	return equality{KindEqual, selector, value}
 }
 
-func GreaterThan(selector selector.Selector, value ipld.Node) InequalityStatement {
+func GreaterThan(selector selector.Selector, value ipld.Node) Statement {
 	return equality{KindGreaterThan, selector, value}
 }
 
-func GreaterThanOrEqual(selector selector.Selector, value ipld.Node) InequalityStatement {
+func GreaterThanOrEqual(selector selector.Selector, value ipld.Node) Statement {
 	return equality{KindGreaterThanOrEqual, selector, value}
 }
 
-func LessThan(selector selector.Selector, value ipld.Node) InequalityStatement {
+func LessThan(selector selector.Selector, value ipld.Node) Statement {
 	return equality{KindLessThan, selector, value}
 }
 
-func LessThanOrEqual(selector selector.Selector, value ipld.Node) InequalityStatement {
+func LessThanOrEqual(selector selector.Selector, value ipld.Node) Statement {
 	return equality{KindLessThanOrEqual, selector, value}
 }
 
@@ -118,11 +67,7 @@ func (n negation) Kind() string {
 	return KindNot
 }
 
-func (n negation) Value() Statement {
-	return n.statement
-}
-
-func Not(stmt Statement) NegationStatement {
+func Not(stmt Statement) Statement {
 	return negation{stmt}
 }
 
@@ -135,15 +80,11 @@ func (c connective) Kind() string {
 	return c.kind
 }
 
-func (c connective) Value() []Statement {
-	return c.statements
-}
-
-func And(stmts ...Statement) ConjunctionStatement {
+func And(stmts ...Statement) Statement {
 	return connective{KindAnd, stmts}
 }
 
-func Or(stmts ...Statement) DisjunctionStatement {
+func Or(stmts ...Statement) Statement {
 	return connective{KindOr, stmts}
 }
 
@@ -157,15 +98,7 @@ func (n wildcard) Kind() string {
 	return KindLike
 }
 
-func (n wildcard) Selector() selector.Selector {
-	return n.selector
-}
-
-func (n wildcard) Value() glob.Glob {
-	return n.glob
-}
-
-func Like(selector selector.Selector, pattern string) (WildcardStatement, error) {
+func Like(selector selector.Selector, pattern string) (Statement, error) {
 	g, err := glob.Compile(pattern)
 	if err != nil {
 		return nil, err
@@ -183,18 +116,10 @@ func (n quantifier) Kind() string {
 	return n.kind
 }
 
-func (n quantifier) Selector() selector.Selector {
-	return n.selector
-}
-
-func (n quantifier) Value() Policy {
-	return n.statements
-}
-
-func All(selector selector.Selector, policy ...Statement) QuantifierStatement {
+func All(selector selector.Selector, policy ...Statement) Statement {
 	return quantifier{KindAll, selector, policy}
 }
 
-func Any(selector selector.Selector, policy ...Statement) QuantifierStatement {
+func Any(selector selector.Selector, policy ...Statement) Statement {
 	return quantifier{KindAny, selector, policy}
 }