As reported in https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=830727 magiconair/properties fails test on x86_64 as follows:

  === RUN   Test
  2016/07/10 22:26:08 circular reference
  exit status 1
  FAIL  github.com/magiconair/properties    0.004s

according to https://docs.oracle.com/cd/E23095_01/Platform.93/ATGProgGuide/html/s0204propertiesfileformat01.html The backslash character must be escaped as a double backslash

Fails:

% go version go version go1.18beta2 linux/amd64

As per:

https://go.dev/doc/devel/release#policy

Supported versions are today 1.16 and 1.17, so we can drop this brittle check.

Note: This is an improvement over #49 for circular reference error message.

Context

When there are properties with circular references, the error message thrown contains one of the key in the cycle. This can be a bit annoying to fix, since it does not give a trace. Given this library supports loading properties from multiple sources, grep etc can fail.

Input:

foo = depends on ${bar}

bar = which depends on ${baz}

baz = ${foo} completes a cyclic reference

The error message thrown when properties.MustLoadFile is called with the above file:

circular reference in "foo = ${foo}"

This pull request is an attempt to make it look better, my take:

circular reference in:
foo=depends on ${bar}
bar=which depends on ${baz}
baz=${foo} completes a cyclic reference

This is not perfect, it still does not highlight the exact source of these properties, but I felt that the overhead of carrying that context to properties.expand may be a bit too much, since the method is currently stateless.

Thanks for the library!

Hi I ran into this issue from eBay fabio, i want to set property 'registry.consul.register.tags'. i.e. "key1=val1" as one of the tag, but it has this kind of error: [FATAL] 1.1.5. circular reference

is that a way to escape equal symbol. thanks

I'm not sure if I'm missing something, but it seems you can only set properties to strings. I know you can read other types, but what if I was to SetInt()?

When reading comments \ are loaded correctly, but when writing they are then replaced by \\. This leads to wrong comments when writing and reading multiple times.

I assume that it is not necessary to encode the comments.

This enables properties like this:

a = b
c = ${a} ${a}

Previously, this would incorrectly throw a circular reference error. Now instead this will correctly evaluate the above as "c = b b".

As part of our configuration service, we need to store configurations as is in key-value records without substituing the ${..} expressions. Application that retrieve properties from this service will do the expansions.

My suggestion is to provide another Load function that takes the extra boolean parameter expandExpressions

This pull request addresses a use case for reading and updating properties files that have:

• commented out sample values for key/value entries that need to be preserved. eg:

# Uncomment the following to override the default value
# serverHostname = host.com

• sectional comments with whitespace formatting. eg:

# 
# Section 1 
#

# comment1
key = value

Changes:

• Add a preserveFormatting bool option to the loader to allow scanning and retaining whitespace as part of comments.
• Add a preserveFormatting bool option when writing comments to pass through the whitespace formatting to the output.
• Add a virtual key/value for the end of the input to allow trailing comments to be retained and emitted.
• Update lexer to not discard whitespace if preserveFormatting is set.
• Comments are now structs containing 2 elements: the original prefixes from the input, and the comment value itself.

Notes:

• I chose not to add a preserveFormatting option to each of the Load* methods. I felt doing this would explode the number of combinations of potential parameters.
  • Instead, the preserveFormatting option for loading is only available through the GetLoader method followed by explicitly setting the loader options before invoking the underlying Load methods.

It's pretty easy to leave a single tab on a line after editing a large properties file. I think the parser should simply ignore such a line instead of failing.

This pull request allows adding some private fields on properties structs without having problems, only marking this field as skipped with a specific tag as the test example below.:

	type S struct {
		p     string `properties:"-"`
		X     string `properties:"-"`
		Undef string `properties:",default=some value"`
	}

This change will avoid an error cannot set p using the struct above.

I'm doing the following test:

// Set a key to "a=b" and value "c"
p := properties.NewProperties()
p.Set("a=b", "c")
buf := new(bytes.Buffer)
p.Write(buf, properties.UTF8)
println(buf.String())

I'd espect the serialized version to be:

a\=b = c

Since the \ should be used to escape the first equal sign, but the program prints:

a=b = c

Which seems wrong. If saved in a file and read again, the key becomes "a" (while, when reading from the correct file, the key is correctly interpreted as "a=b").

In case the properties file has a logical division of the configurations, I'd like to decode to several dedicated structs.

For example: Given the following config.properties file

app.port=3000
db.host=127.0.0.1
db.port=8000
db.username=username123
db.password=password123
pglistener.min_reconn=10 * time.Second
pglistener.max_reconn=1 * time.Minute
...
...

I'd like to decode to the following structs:

type Config struct {
	AppPort string `properties:"app.port,default=3000"`
}

type DBConfig struct {
	Host          string  `properties:"db.host,default=127.0.0.1"`
	Port           int       `properties:"db.port,default=5432"`
	Username string `properties:"db.username"`
	Password  string `properties:"db.password"`
}


type PGListener struct {
	MinReconnectInterval time.Duration `properties:"pglistener.min_reconn"`
	MaxReconnectInterval time.Duration `properties:"pglistener.max_reconn"`
}

Given a properties file consisting of:

Test = foo,bar,baz

A config struct of

type Config struct {
    Test []string `properties:"Test"`
}

And the following decoding

    var cfg Config
    if err := p.Decode(&cfg); err != nil {
        log.Fatal(err)
    }
    fmt.Printf("got test values: %s\n", cfg.Test[1])
```

My program crashes as cfg.Test is of length 1.

Hello, would be possible to add support to decode into map[string]interface{}. I need to decode a properties file into a generic interface{} but below code is returning an error. Is there a reason to only allow it to be a struct?

	if t.Kind() != reflect.Ptr || v.Elem().Type().Kind() != reflect.Struct {
		return fmt.Errorf("not a pointer to struct: %s", t)
	}