cmd.runGenerateAst - Code Metrics - Inspection of "refactor(cmd/permify): streamline command registra..." - Permify/permify - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#2607)

by Tolga

created 2025-11-14 13:42 UTC

cmd.runGenerateAst C

↳ Parent: pkg/cmd/ast.go

Complexity

Conditions

Size

Total Lines	51
Code Lines	28

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	9
eloc	28
nop	0
dl	0
loc	51
rs	6.6666
c	0
b	0
f	0

How to fix Long Method

package cmd

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/url"

	"github.com/spf13/cobra"
	"github.com/spf13/viper"
	"google.golang.org/protobuf/encoding/protojson"

	"github.com/Permify/permify/internal/schema"
	"github.com/Permify/permify/pkg/cmd/flags"
	"github.com/Permify/permify/pkg/development/file"
)

// NewGenerateASTCommand creates a new cobra.Command to generate the Abstract Syntax Tree (AST) from a given file.
// The command expects exactly one argument, which is the URL or path to the file.
// It also allows for flags registration for further validation (like coverage flags).
func NewGenerateAstCommand() *cobra.Command {
	command := &cobra.Command{
		Use:   "ast <file>",
		Short: "Generates the AST from a specified file and prints it as JSON.",
		RunE:  runGenerateAst(),
		Args:  cobra.ExactArgs(1),
	}

	f := command.Flags()
	f.Bool("pretty", false, "If set to true, produces a human-readable output of the AST.")

	command.PreRun = func(cmd *cobra.Command, args []string) {
		flags.RegisterAstFlags(f)
	}

	return command
}

// runGenerateAST creates a closure that generates the AST and returns its JSON representation.
// Depending on the "pretty" flag, the output can be either pretty-printed or raw.
func runGenerateAst() func(cmd *cobra.Command, args []string) error {
	return func(cmd *cobra.Command, args []string) error {
		// Fetch the value of the "pretty" flag.
		pretty := viper.GetBool("pretty")

		// Parse the provided URL.
		u, err := url.Parse(args[0])
		if err != nil {
			return err
		}

		// Initialize a decoder for the provided URL.
		decoder, err := file.NewDecoderFromURL(u)
		if err != nil {
			return err
		}

		// Initialize an empty shape to store the decoded schema.
		s := &file.Shape{}

		// Decode the content from the URL into the shape.
		err = decoder.Decode(s)
		if err != nil {
			return err
		}

		// Convert the string definitions in the shape to a structured schema.
		def, err := schema.NewSchemaFromStringDefinitions(true, s.Schema)
		if err != nil {
			return err
		}

		// Serialize the schema definition into JSON.
		jsonData, err := protojson.Marshal(def)
		if err != nil {
			return err
		}

		// Print the JSON, either prettified or raw based on the "pretty" flag.
		if pretty {
			var prettyJSON bytes.Buffer
			err = json.Indent(&prettyJSON, jsonData, "", "  ")
			if err != nil {
				return err
			}
			fmt.Println(prettyJSON.String())
		} else {
			fmt.Println(string(jsonData))
		}

		return nil
	}
}


1			package cmd
2
3			import (
4			"bytes"
5			"encoding/json"
6			"fmt"
7			"net/url"
8
9			"github.com/spf13/cobra"
10			"github.com/spf13/viper"
11			"google.golang.org/protobuf/encoding/protojson"
12
13			"github.com/Permify/permify/internal/schema"
14			"github.com/Permify/permify/pkg/cmd/flags"
15			"github.com/Permify/permify/pkg/development/file"
16			)
17
18			// NewGenerateASTCommand creates a new cobra.Command to generate the Abstract Syntax Tree (AST) from a given file.
19			// The command expects exactly one argument, which is the URL or path to the file.
20			// It also allows for flags registration for further validation (like coverage flags).
21			func NewGenerateAstCommand() *cobra.Command {
22			command := &cobra.Command{
23			Use: "ast <file>",
24			Short: "Generates the AST from a specified file and prints it as JSON.",
25			RunE: runGenerateAst(),
26			Args: cobra.ExactArgs(1),
27			}
28
29			f := command.Flags()
30			f.Bool("pretty", false, "If set to true, produces a human-readable output of the AST.")
31
32			command.PreRun = func(cmd *cobra.Command, args []string) {
33			flags.RegisterAstFlags(f)
34			}
35
36			return command
37			}
38
39			// runGenerateAST creates a closure that generates the AST and returns its JSON representation.
40			// Depending on the "pretty" flag, the output can be either pretty-printed or raw.
41			func runGenerateAst() func(cmd *cobra.Command, args []string) error {
42			return func(cmd *cobra.Command, args []string) error {
43			// Fetch the value of the "pretty" flag.
44			pretty := viper.GetBool("pretty")
45
46			// Parse the provided URL.
47			u, err := url.Parse(args[0])
48			if err != nil {
49			return err
50			}
51
52			// Initialize a decoder for the provided URL.
53			decoder, err := file.NewDecoderFromURL(u)
54			if err != nil {
55			return err
56			}
57
58			// Initialize an empty shape to store the decoded schema.
59			s := &file.Shape{}
60
61			// Decode the content from the URL into the shape.
62			err = decoder.Decode(s)
63			if err != nil {
64			return err
65			}
66
67			// Convert the string definitions in the shape to a structured schema.
68			def, err := schema.NewSchemaFromStringDefinitions(true, s.Schema)
69			if err != nil {
70			return err
71			}
72
73			// Serialize the schema definition into JSON.
74			jsonData, err := protojson.Marshal(def)
75			if err != nil {
76			return err
77			}
78
79			// Print the JSON, either prettified or raw based on the "pretty" flag.
80			if pretty {
81			var prettyJSON bytes.Buffer
82			err = json.Indent(&prettyJSON, jsonData, "", " ")
83			if err != nil {
84			return err
85			}
86			fmt.Println(prettyJSON.String())
87			} else {
88			fmt.Println(string(jsonData))
89			}
90
91			return nil
92			}
93			}
94

Permify / permify

Pull Request — master (#2607)

cmd.runGenerateAst C

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like