From 20efcebab08e2e1a3f968a06b0a738010a99063a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Michael=20Mur=C3=A9?= Date: Mon, 2 Sep 2024 02:24:13 +0200 Subject: [PATCH] policy: remove superfluous interfaces Those interfaces were only used inside the package, where private concrete work just as well. --- capability/policy/match.go | 62 +++++++++---------- capability/policy/policy.go | 119 +++++++----------------------------- 2 files changed, 53 insertions(+), 128 deletions(-) diff --git a/capability/policy/match.go b/capability/policy/match.go index 46f525e..3f9b1a9 100644 --- a/capability/policy/match.go +++ b/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 } diff --git a/capability/policy/policy.go b/capability/policy/policy.go index 33e1a02..7f435c9 100644 --- a/capability/policy/policy.go +++ b/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} }