Unable to match Url

[dzonerzy]

Hi i'm trying to parse a custom grammar with the following code

package config

import (
	"fmt"
	"io/ioutil"
	"os"

	"github.com/alecthomas/participle/v2"
	"github.com/alecthomas/participle/v2/lexer"
	"github.com/alecthomas/participle/v2/lexer/stateful"
)

type Boolean bool

func (b *Boolean) Capture(values []string) error {
	if values[0] != "true" && values[0] != "false" {
		return fmt.Errorf("invalid boolean '%s' expecting '%s' or '%s'", values[0], "true", "false")
	}
	*b = values[0] == "true"
	return nil
}

type FilePath string

func (fp *FilePath) Str() string {
	return string(*fp)
}

func (fp *FilePath) Capture(values []string) (err error) {
	_, err = os.Stat(values[0])
	if err == nil {
		*fp = FilePath(values[0])
	}
	return err
}

type LogFile string

func (lf *LogFile) Str() string {
	return string(*lf)
}

func (lf *LogFile) Capture(values []string) (err error) {
	_, err = os.Stat(values[0])
	if err == nil {
		*lf = LogFile(values[0])
	} else {
		_, err = os.Create(values[0])
		if err == nil {
			*lf = LogFile(values[0])
		}
		os.Remove(values[0])
	}
	return err
}

type Configuration struct {
	Http  int
	Https int
	Hosts []Host
}

type ServerConfig struct {
	Properties ServerProperties `"server" "{" @@* "}"`
}

type ServerProperties struct {
	Http  int      `(("http" ":" @Ident) |`
	Https int      `("https" ":" @Ident) |`
	Hosts FilePath `("hosts" ":" @Ident))+`
}

type VirtualHosts struct {
	Hosts []Host `@@*`
}

type Host struct {
	HostName   string                `"vhost" (@Ident)? "{"`
	Properties VirtualHostProperties `@@* "}"`
}

type VirtualHostProperties struct {
	SSL          Boolean  `(("ssl" ":" @Ident) |`
	Certificate  FilePath `("cert" ":" @Ident) |`
	Key          FilePath `("key" ":" @Ident) |`
	ErrorLog     LogFile  `("errorlog" ":" @Ident) |`
	AutogenSSL   Boolean  `("autogenssl" ":" @Ident) |`
	ReverseProxy string   `("reverseproxy" ":" @Url) |`
	AccessLog    LogFile  `("accesslog" ":" @Ident))+ `
}

type ConfigParser struct {
	lex           lexer.Definition
	server_parser *participle.Parser
	hosts_parser  *participle.Parser
}

func (cp *ConfigParser) ParseServer(data []byte, v *ServerConfig) (err error) {
	err = cp.server_parser.ParseBytes("", data, v)
	return
}

func (cp *ConfigParser) ParseVirtualHosts(data []byte, v *VirtualHosts) (err error) {
	err = cp.hosts_parser.ParseBytes("", data, v)
	return
}

func (cp *ConfigParser) Parse(data []byte) (*Configuration, error) {
	var sconfig ServerConfig
	var vhosts VirtualHosts
	var err error = cp.Validate(data, &sconfig, &vhosts)
	if err != nil {
		return nil, err
	}
	return &Configuration{
		Http:  sconfig.Properties.Http,
		Https: sconfig.Properties.Https,
		Hosts: vhosts.Hosts,
	}, nil
}

func (cp *ConfigParser) Validate(data []byte, sconfig *ServerConfig, vhosts *VirtualHosts) error {
	if sconfig == nil {
		sconfig = &ServerConfig{}
	}
	if vhosts == nil {
		vhosts = &VirtualHosts{}
	}
	var err = cp.ParseServer(data, sconfig)
	if err != nil {
		return err
	}
	if sconfig.Properties.Https == 0 || sconfig.Properties.Http == 0 {
		return fmt.Errorf("missing mandatory field (http/https)")
	}
	if _, err = os.Stat(sconfig.Properties.Hosts.Str()); err != nil {
		return err
	}
	data, _ = ioutil.ReadFile(sconfig.Properties.Hosts.Str())
	err = cp.ParseVirtualHosts(data, vhosts)
	if err != nil {
		return err
	}
	if sconfig.Properties.Http == sconfig.Properties.Https {
		return fmt.Errorf("cannot have both HTTPS and HTTP on same port")
	}
	return nil
}

func NewConfigParser() *ConfigParser {
	var lexer = lexer.Must(stateful.NewSimple([]stateful.Rule{
		{Name: "Ident", Pattern: `[A-Za-z0-9/\\\.-]+`, Action: nil},
		{Name: "String", Pattern: `'[^']*'|"[^"]*"`, Action: nil},
		{Name: "Punct", Pattern: `^[\{\}\[\]:]`, Action: nil},
		{Name: "whitespace", Pattern: `\s+`, Action: nil},
		{Name: "comment", Pattern: `#\s+([\w [:punct:]]+)\n`, Action: nil},
		{Name: "Url", Pattern: `(?:https?:\/\/)?(?:[^@\/\n]+@)?(?:www\.)?([^:\/\n]+)`, Action: nil},
	}))
	return &ConfigParser{
		server_parser: participle.MustBuild(
			&ServerConfig{},
			participle.Lexer(lexer),
			participle.Unquote("String"),
		),
		hosts_parser: participle.MustBuild(
			&VirtualHosts{},
			participle.Lexer(lexer),
			participle.Unquote("String"),
		),
		lex: lexer,
	}
}

This is what i'm trying to parse

vhost 1.dzonerzy.net {
    ssl: false
    accesslog: logs/1.dzonerzy.net.access.log
    autogenssl: false
}

vhost 2.dzonerzy.net {
    ssl: true
    accesslog: logs/2.dzonerzy.net.access.log
    autogenssl: true
}

vhost 3.dzonerzy.net {
    accesslog: logs/3.dzonerzy.net.access.log
    reverseproxy: http://a.it
}

Without adding the Url rule everything works fine, here's the error:

2021/08/27 14:45:04 15:19: unexpected token "http" (expected <url>)

I suspect that the Punct rule at some point overlap with the Url rule due to ":" inside "http://"

[alecthomas]

Yes, that's likely it. Move Url to the top of the rules and it should work fine.

[dzonerzy]

Can't do that, or it will break the Server Config parser due to having a property called http: and https: and those will start to match @url while they are not url

[dzonerzy]

There's no way to force it match a specific token instead of let participle choose the one who best match?

[alecthomas]

Tokenisation is completely separate from parsing; parsing just consumes the matched tokens.

If URLs are first-class values, you could try to match the individual tokens in the URL structure. eg.

URL string `@((("http" | "https") ":" "/" "/")? .......`

Though this might get a bit complicated.