ast.*EntityStatement.String - Code Metrics - Inspection of "feat: partial schema write feature" - Permify/permify - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#1153)

by Tolga

created 2024-03-24 14:05 UTC

ast.*EntityStatement.String A

↳ Parent: pkg/dsl/ast/statements.go

Complexity

Conditions

Size

Total Lines	36
Code Lines	22

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	22
nop	0
dl	0
loc	36
rs	9.352
c	0
b	0
f	0

package ast

import (
	"strings"

	"github.com/Permify/permify/pkg/dsl/token"
)

type (
	StatementType string
)

const (
	PERMISSION_STATEMENT     StatementType = "permission"
	RELATION_STATEMENT       StatementType = "relation"
	ATTRIBUTE_STATEMENT      StatementType = "attribute"
	ENTITY_STATEMENT         StatementType = "entity"
	RULE_STATEMENT           StatementType = "rule"
	EXPRESSION_STATEMENT     StatementType = "expression"
	RELATION_TYPE_STATEMENT  StatementType = "relation_type"
	ATTRIBUTE_TYPE_STATEMENT StatementType = "attribute_type"
)

// Statement defines an interface for a statement node.
type Statement interface {
	Node
	statementNode()
	GetName() string
	StatementType() StatementType
}

// EntityStatement represents a statement that refers to an entity.
type EntityStatement struct {
	Entity               token.Token // token.ENTITY
	Name                 token.Token // token.IDENT
	RelationStatements   []Statement // Statements that define relationships between entities
	AttributeStatements  []Statement // Statements that define attributes of the entity
	PermissionStatements []Statement // Statements that define permissions performed on the entity
}

// statementNode is a dummy method that satisfies the Statement interface.
func (ls *EntityStatement) statementNode() {}

// String returns a string representation of the EntityStatement.
func (ls *EntityStatement) String() string {
	var sb strings.Builder
	sb.WriteString("entity")
	sb.WriteString(" ")
	sb.WriteString(ls.Name.Literal)
	sb.WriteString(" {")
	sb.WriteString("\n")

	// Iterate over the relation statements and add them to the string builder.
	for _, rs := range ls.RelationStatements {
		sb.WriteString(rs.String())
		sb.WriteString("\n")
	}

	sb.WriteString("\n")

	// Iterate over the attribute statements and add them to the string builder.
	for _, as := range ls.AttributeStatements {
		sb.WriteString(as.String())
		sb.WriteString("\n")
	}

	sb.WriteString("\n")

	// Iterate over the permission statements and add them to the string builder.
	for _, ps := range ls.PermissionStatements {
		sb.WriteString(ps.String())
		sb.WriteString("\n")
	}

	sb.WriteString("}")
	sb.WriteString(" ")
	sb.WriteString("\n")

	// Return the final string.
	return sb.String()
}

func (ls *EntityStatement) GetName() string {
	return ls.Name.Literal
}

func (ls *EntityStatement) StatementType() StatementType {
	return ENTITY_STATEMENT
}

// AttributeStatement represents a statement that defines an attribute of an entity.
type AttributeStatement struct {
	Attribute     token.Token // token.ATTRIBUTE
	Name          token.Token // token.IDENT
	AttributeType AttributeTypeStatement
}

// statementNode is a dummy method that satisfies the Statement interface.
func (as *AttributeStatement) statementNode() {}

// String returns a string representation of the AttributeStatement.
func (as *AttributeStatement) String() string {
	var sb strings.Builder
	sb.WriteString("\t")
	sb.WriteString("attribute")
	sb.WriteString(" ")
	sb.WriteString(as.Name.Literal)
	sb.WriteString(" ")
	sb.WriteString(as.AttributeType.String())

	// Return the final string.
	return sb.String()
}

func (as *AttributeStatement) GetName() string {
	return as.Name.Literal
}

func (as *AttributeStatement) StatementType() StatementType {
	return ATTRIBUTE_STATEMENT
}

// RelationStatement represents a statement that defines a relationship between two entities.
type RelationStatement struct {
	Relation      token.Token             // token.RELATION
	Name          token.Token             // token.IDENT
	RelationTypes []RelationTypeStatement // Statements that define the types of the relationship
}

// statementNode is a dummy method that satisfies the Statement interface.
func (ls *RelationStatement) statementNode() {}

// String returns a string representation of the RelationStatement.
func (ls *RelationStatement) String() string {
	var sb strings.Builder
	sb.WriteString("\t")
	sb.WriteString("relation")
	sb.WriteString(" ")
	sb.WriteString(ls.Name.Literal)
	sb.WriteString(" ")

	// Iterate over the relation types and append them to the string builder.
	for _, rs := range ls.RelationTypes {
		sb.WriteString(rs.String())
		sb.WriteString(" ")
	}

	// Return the final string.
	return sb.String()
}

func (ls *RelationStatement) GetName() string {
	return ls.Name.Literal
}

func (ls *RelationStatement) StatementType() StatementType {
	return RELATION_STATEMENT
}

// AttributeTypeStatement represents a statement that defines the type of a relationship.
type AttributeTypeStatement struct {
	Type    token.Token // token.IDENT
	IsArray bool
}

// String returns a string representation of the RelationTypeStatement.
func (as *AttributeTypeStatement) String() string {
	var sb strings.Builder
	sb.WriteString(as.Type.Literal)
	if as.IsArray {
		sb.WriteString("[]")
	}
	return sb.String()
}

func (as *AttributeTypeStatement) GetName() string {
	return ""
}

func (as *AttributeTypeStatement) StatementType() StatementType {
	return ATTRIBUTE_TYPE_STATEMENT
}

func (as *AttributeTypeStatement) statementNode() {}

// RelationTypeStatement represents a statement that defines the type of relationship.
type RelationTypeStatement struct {
	Sign     token.Token // token.SIGN
	Type     token.Token // token.IDENT
	Relation token.Token // token.IDENT
}

// String returns a string representation of the RelationTypeStatement.
func (ls *RelationTypeStatement) String() string {
	var sb strings.Builder
	sb.WriteString("@")
	sb.WriteString(ls.Type.Literal)
	if ls.Relation.Literal != "" {
		sb.WriteString("#")
		sb.WriteString(ls.Relation.Literal)
	}
	return sb.String()
}

func (ls *RelationTypeStatement) GetName() string {
	return ""
}

func (ls *RelationTypeStatement) StatementType() StatementType {
	return RELATION_TYPE_STATEMENT
}

func (ls *RelationTypeStatement) statementNode() {}

// IsDirectEntityReference returns true if the RelationTypeStatement is a direct entity reference.
func IsDirectEntityReference(s RelationTypeStatement) bool {
	return s.Relation.Literal == ""
}

// PermissionStatement represents an permission statement, which consists of an permission name and an optional expression statement.
// It implements the Statement interface.
type PermissionStatement struct {
	Permission          token.Token // token.PERMISSION
	Name                token.Token // token.IDENT
	ExpressionStatement Statement
}

// statementNode is a marker method used to implement the Statement interface.
func (ls *PermissionStatement) statementNode() {}

// String returns a string representation of the permission statement.
func (ls *PermissionStatement) String() string {
	var sb strings.Builder
	sb.WriteString("\t")
	sb.WriteString("permission")
	sb.WriteString(" ")
	sb.WriteString(ls.Name.Literal)
	sb.WriteString(" = ")
	if ls.ExpressionStatement != nil {
		sb.WriteString(ls.ExpressionStatement.String())
	}
	return sb.String()
}

func (ls *PermissionStatement) GetName() string {
	return ls.Name.Literal
}

func (ls *PermissionStatement) StatementType() StatementType {
	return PERMISSION_STATEMENT
}

// ExpressionStatement struct represents an expression statement
type ExpressionStatement struct {
	Expression Expression
}

// statementNode function is needed to mark the struct as a Statement node
func (es *ExpressionStatement) statementNode() {}

// String function returns a string representation of the ExpressionStatement
func (es *ExpressionStatement) String() string {
	if es.Expression != nil {
		return es.Expression.String()
	}
	// If there is no expression, return an empty string
	return ""
}

func (es *ExpressionStatement) GetName() string {
	return ""
}

func (es *ExpressionStatement) StatementType() StatementType {
	return EXPRESSION_STATEMENT
}

// RuleStatement represents a rule statement, which consists of a rule name, a list of parameters and a body.
type RuleStatement struct {
	Rule       token.Token // token.RULE
	Name       token.Token // token.IDENT
	Arguments  map[token.Token]AttributeTypeStatement
	Expression string
}

// statementNode is a marker method used to implement the Statement interface.
func (rs *RuleStatement) statementNode() {}

// String returns a string representation of the permission statement.
func (rs *RuleStatement) String() string {
	var sb strings.Builder
	sb.WriteString("rule")
	sb.WriteString(" ")
	sb.WriteString(rs.Name.Literal)
	sb.WriteString("(")

	var literals []string
	for param, typ := range rs.Arguments {
		var pb strings.Builder
		pb.WriteString(param.Literal)
		pb.WriteString(" ")
		pb.WriteString(typ.Type.Literal)
		if typ.IsArray {
			pb.WriteString("[]")
		}
		literals = append(literals, pb.String())
	}

	sb.WriteString(strings.Join(literals, ", "))

	sb.WriteString(")")
	sb.WriteString(" ")
	sb.WriteString("{")

	sb.WriteString("\n")
	sb.WriteString("\t")
	sb.WriteString(rs.Expression)
	sb.WriteString("\n")

	sb.WriteString("}")
	return sb.String()
}

func (rs *RuleStatement) GetName() string {
	return rs.Name.Literal
}

func (rs *RuleStatement) StatementType() StatementType {
	return RULE_STATEMENT
}


1			package ast
2
3			import (
4			"strings"
5
6			"github.com/Permify/permify/pkg/dsl/token"
7			)
8
9			type (
10			StatementType string
11			)
12
13			const (
14			PERMISSION_STATEMENT StatementType = "permission"
15			RELATION_STATEMENT StatementType = "relation"
16			ATTRIBUTE_STATEMENT StatementType = "attribute"
17			ENTITY_STATEMENT StatementType = "entity"
18			RULE_STATEMENT StatementType = "rule"
19			EXPRESSION_STATEMENT StatementType = "expression"
20			RELATION_TYPE_STATEMENT StatementType = "relation_type"
21			ATTRIBUTE_TYPE_STATEMENT StatementType = "attribute_type"
22			)
23
24			// Statement defines an interface for a statement node.
25			type Statement interface {
26			Node
27			statementNode()
28			GetName() string
29			StatementType() StatementType
30			}
31
32			// EntityStatement represents a statement that refers to an entity.
33			type EntityStatement struct {
34			Entity token.Token // token.ENTITY
35			Name token.Token // token.IDENT
36			RelationStatements []Statement // Statements that define relationships between entities
37			AttributeStatements []Statement // Statements that define attributes of the entity
38			PermissionStatements []Statement // Statements that define permissions performed on the entity
39			}
40
41			// statementNode is a dummy method that satisfies the Statement interface.
42			func (ls *EntityStatement) statementNode() {}
43
44			// String returns a string representation of the EntityStatement.
45			func (ls *EntityStatement) String() string {
46			var sb strings.Builder
47			sb.WriteString("entity")
48			sb.WriteString(" ")
49			sb.WriteString(ls.Name.Literal)
50			sb.WriteString(" {")
51			sb.WriteString("\n")
52
53			// Iterate over the relation statements and add them to the string builder.
54			for _, rs := range ls.RelationStatements {
55			sb.WriteString(rs.String())
56			sb.WriteString("\n")
57			}
58
59			sb.WriteString("\n")
60
61			// Iterate over the attribute statements and add them to the string builder.
62			for _, as := range ls.AttributeStatements {
63			sb.WriteString(as.String())
64			sb.WriteString("\n")
65			}
66
67			sb.WriteString("\n")
68
69			// Iterate over the permission statements and add them to the string builder.
70			for _, ps := range ls.PermissionStatements {
71			sb.WriteString(ps.String())
72			sb.WriteString("\n")
73			}
74
75			sb.WriteString("}")
76			sb.WriteString(" ")
77			sb.WriteString("\n")
78
79			// Return the final string.
80			return sb.String()
81			}
82
83			func (ls *EntityStatement) GetName() string {
84			return ls.Name.Literal
85			}
86
87			func (ls *EntityStatement) StatementType() StatementType {
88			return ENTITY_STATEMENT
89			}
90
91			// AttributeStatement represents a statement that defines an attribute of an entity.
92			type AttributeStatement struct {
93			Attribute token.Token // token.ATTRIBUTE
94			Name token.Token // token.IDENT
95			AttributeType AttributeTypeStatement
96			}
97
98			// statementNode is a dummy method that satisfies the Statement interface.
99			func (as *AttributeStatement) statementNode() {}
100
101			// String returns a string representation of the AttributeStatement.
102			func (as *AttributeStatement) String() string {
103			var sb strings.Builder
104			sb.WriteString("\t")
105			sb.WriteString("attribute")
106			sb.WriteString(" ")
107			sb.WriteString(as.Name.Literal)
108			sb.WriteString(" ")
109			sb.WriteString(as.AttributeType.String())
110
111			// Return the final string.
112			return sb.String()
113			}
114
115			func (as *AttributeStatement) GetName() string {
116			return as.Name.Literal
117			}
118
119			func (as *AttributeStatement) StatementType() StatementType {
120			return ATTRIBUTE_STATEMENT
121			}
122
123			// RelationStatement represents a statement that defines a relationship between two entities.
124			type RelationStatement struct {
125			Relation token.Token // token.RELATION
126			Name token.Token // token.IDENT
127			RelationTypes []RelationTypeStatement // Statements that define the types of the relationship
128			}
129
130			// statementNode is a dummy method that satisfies the Statement interface.
131			func (ls *RelationStatement) statementNode() {}
132
133			// String returns a string representation of the RelationStatement.
134			func (ls *RelationStatement) String() string {
135			var sb strings.Builder
136			sb.WriteString("\t")
137			sb.WriteString("relation")
138			sb.WriteString(" ")
139			sb.WriteString(ls.Name.Literal)
140			sb.WriteString(" ")
141
142			// Iterate over the relation types and append them to the string builder.
143			for _, rs := range ls.RelationTypes {
144			sb.WriteString(rs.String())
145			sb.WriteString(" ")
146			}
147
148			// Return the final string.
149			return sb.String()
150			}
151
152			func (ls *RelationStatement) GetName() string {
153			return ls.Name.Literal
154			}
155
156			func (ls *RelationStatement) StatementType() StatementType {
157			return RELATION_STATEMENT
158			}
159
160			// AttributeTypeStatement represents a statement that defines the type of a relationship.
161			type AttributeTypeStatement struct {
162			Type token.Token // token.IDENT
163			IsArray bool
164			}
165
166			// String returns a string representation of the RelationTypeStatement.
167			func (as *AttributeTypeStatement) String() string {
168			var sb strings.Builder
169			sb.WriteString(as.Type.Literal)
170			if as.IsArray {
171			sb.WriteString("[]")
172			}
173			return sb.String()
174			}
175
176			func (as *AttributeTypeStatement) GetName() string {
177			return ""
178			}
179
180			func (as *AttributeTypeStatement) StatementType() StatementType {
181			return ATTRIBUTE_TYPE_STATEMENT
182			}
183
184			func (as *AttributeTypeStatement) statementNode() {}
185
186			// RelationTypeStatement represents a statement that defines the type of relationship.
187			type RelationTypeStatement struct {
188			Sign token.Token // token.SIGN
189			Type token.Token // token.IDENT
190			Relation token.Token // token.IDENT
191			}
192
193			// String returns a string representation of the RelationTypeStatement.
194			func (ls *RelationTypeStatement) String() string {
195			var sb strings.Builder
196			sb.WriteString("@")
197			sb.WriteString(ls.Type.Literal)
198			if ls.Relation.Literal != "" {
199			sb.WriteString("#")
200			sb.WriteString(ls.Relation.Literal)
201			}
202			return sb.String()
203			}
204
205			func (ls *RelationTypeStatement) GetName() string {
206			return ""
207			}
208
209			func (ls *RelationTypeStatement) StatementType() StatementType {
210			return RELATION_TYPE_STATEMENT
211			}
212
213			func (ls *RelationTypeStatement) statementNode() {}
214
215			// IsDirectEntityReference returns true if the RelationTypeStatement is a direct entity reference.
216			func IsDirectEntityReference(s RelationTypeStatement) bool {
217			return s.Relation.Literal == ""
218			}
219
220			// PermissionStatement represents an permission statement, which consists of an permission name and an optional expression statement.
221			// It implements the Statement interface.
222			type PermissionStatement struct {
223			Permission token.Token // token.PERMISSION
224			Name token.Token // token.IDENT
225			ExpressionStatement Statement
226			}
227
228			// statementNode is a marker method used to implement the Statement interface.
229			func (ls *PermissionStatement) statementNode() {}
230
231			// String returns a string representation of the permission statement.
232			func (ls *PermissionStatement) String() string {
233			var sb strings.Builder
234			sb.WriteString("\t")
235			sb.WriteString("permission")
236			sb.WriteString(" ")
237			sb.WriteString(ls.Name.Literal)
238			sb.WriteString(" = ")
239			if ls.ExpressionStatement != nil {
240			sb.WriteString(ls.ExpressionStatement.String())
241			}
242			return sb.String()
243			}
244
245			func (ls *PermissionStatement) GetName() string {
246			return ls.Name.Literal
247			}
248
249			func (ls *PermissionStatement) StatementType() StatementType {
250			return PERMISSION_STATEMENT
251			}
252
253			// ExpressionStatement struct represents an expression statement
254			type ExpressionStatement struct {
255			Expression Expression
256			}
257
258			// statementNode function is needed to mark the struct as a Statement node
259			func (es *ExpressionStatement) statementNode() {}
260
261			// String function returns a string representation of the ExpressionStatement
262			func (es *ExpressionStatement) String() string {
263			if es.Expression != nil {
264			return es.Expression.String()
265			}
266			// If there is no expression, return an empty string
267			return ""
268			}
269
270			func (es *ExpressionStatement) GetName() string {
271			return ""
272			}
273
274			func (es *ExpressionStatement) StatementType() StatementType {
275			return EXPRESSION_STATEMENT
276			}
277
278			// RuleStatement represents a rule statement, which consists of a rule name, a list of parameters and a body.
279			type RuleStatement struct {
280			Rule token.Token // token.RULE
281			Name token.Token // token.IDENT
282			Arguments map[token.Token]AttributeTypeStatement
283			Expression string
284			}
285
286			// statementNode is a marker method used to implement the Statement interface.
287			func (rs *RuleStatement) statementNode() {}
288
289			// String returns a string representation of the permission statement.
290			func (rs *RuleStatement) String() string {
291			var sb strings.Builder
292			sb.WriteString("rule")
293			sb.WriteString(" ")
294			sb.WriteString(rs.Name.Literal)
295			sb.WriteString("(")
296
297			var literals []string
298			for param, typ := range rs.Arguments {
299			var pb strings.Builder
300			pb.WriteString(param.Literal)
301			pb.WriteString(" ")
302			pb.WriteString(typ.Type.Literal)
303			if typ.IsArray {
304			pb.WriteString("[]")
305			}
306			literals = append(literals, pb.String())
307			}
308
309			sb.WriteString(strings.Join(literals, ", "))
310
311			sb.WriteString(")")
312			sb.WriteString(" ")
313			sb.WriteString("{")
314
315			sb.WriteString("\n")
316			sb.WriteString("\t")
317			sb.WriteString(rs.Expression)
318			sb.WriteString("\n")
319
320			sb.WriteString("}")
321			return sb.String()
322			}
323
324			func (rs *RuleStatement) GetName() string {
325			return rs.Name.Literal
326			}
327
328			func (rs *RuleStatement) StatementType() StatementType {
329			return RULE_STATEMENT
330			}
331

Permify / permify

Pull Request — master (#1153)

ast.*EntityStatement.String A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like