Method parseStemPaths

runtime/parser/parser.go:693–774

parseStem parses a set of paths with the same stem (path without extension).

(ctx context.Context, paths []string)

// parseStem parses a set of paths with the same stem (path without extension).
func (p *Parser) parseStemPaths(ctx context.Context, paths []string) error {
	// Load YAML and SQL contents
	var yaml, yamlPath, sql, sqlPath string
	var found bool
	for _, path := range paths {
		// Load contents
		data, err := p.Repo.Get(ctx, path)
		if err != nil {
			if os.IsNotExist(err) {
				// This is a dirty parse where a file disappeared during parsing.
				// But due to the clear-and-rebuild behavior, we can safely continue parsing.
				continue
			}
			return err
		}

		// Check size
		if len(data) > maxFileSize {
			p.Errors = append(p.Errors, &runtimev1.ParseError{
				Message:  fmt.Sprintf("size %d bytes exceeds max size of %d bytes", len(data), maxFileSize),
				FilePath: path,
			})
			continue
		}

		// Assign to correct variable
		if strings.HasSuffix(path, ".sql") {
			sql = data
			sqlPath = path
			found = true
			continue
		}
		if strings.HasSuffix(path, ".yaml") || strings.HasSuffix(path, ".yml") {
			if yaml != "" {
				// Means there was both a .yaml and .yml file. We don't allow that!
				p.Errors = append(p.Errors, &runtimev1.ParseError{
					Message:  "skipping file because another YAML file has already been parsed for this path stem",
					FilePath: path,
				})
				continue
			}
			yaml = data
			yamlPath = path
			found = true
			continue
		}
		// The unhandled case should never happen, just being defensive
	}

	// There's a few cases above where we don't find YAML or SQL contents. It's fine to just skip the file in those cases.
	if !found {
		return nil
	}

	// Parse the SQL/YAML file pair to a Node, then parse the Node to p.Resources.
	node, err := p.parseStem(paths, yamlPath, yaml, sqlPath, sql)
	if err == nil {
		err = p.parseNode(ctx, node)