properties.go

Documentation: github.com/magiconair/properties

     1  // Copyright 2013-2022 Frank Schroeder. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package properties
     6  
     7  // BUG(frank): Set() does not check for invalid unicode literals since this is currently handled by the lexer.
     8  // BUG(frank): Write() does not allow to configure the newline character. Therefore, on Windows LF is used.
     9  
    10  import (
    11  	"bytes"
    12  	"fmt"
    13  	"io"
    14  	"log"
    15  	"os"
    16  	"regexp"
    17  	"sort"
    18  	"strconv"
    19  	"strings"
    20  	"time"
    21  	"unicode/utf8"
    22  )
    23  
    24  const maxExpansionDepth = 64
    25  
    26  // ErrorHandlerFunc defines the type of function which handles failures
    27  // of the MustXXX() functions. An error handler function must exit
    28  // the application after handling the error.
    29  type ErrorHandlerFunc func(error)
    30  
    31  // ErrorHandler is the function which handles failures of the MustXXX()
    32  // functions. The default is LogFatalHandler.
    33  var ErrorHandler ErrorHandlerFunc = LogFatalHandler
    34  
    35  // LogHandlerFunc defines the function prototype for logging errors.
    36  type LogHandlerFunc func(fmt string, args ...interface{})
    37  
    38  // LogPrintf defines a log handler which uses log.Printf.
    39  var LogPrintf LogHandlerFunc = log.Printf
    40  
    41  // LogFatalHandler handles the error by logging a fatal error and exiting.
    42  func LogFatalHandler(err error) {
    43  	log.Fatal(err)
    44  }
    45  
    46  // PanicHandler handles the error by panicking.
    47  func PanicHandler(err error) {
    48  	panic(err)
    49  }
    50  
    51  // -----------------------------------------------------------------------------
    52  
    53  // A Properties contains the key/value pairs from the properties input.
    54  // All values are stored in unexpanded form and are expanded at runtime
    55  type Properties struct {
    56  	// Pre-/Postfix for property expansion.
    57  	Prefix  string
    58  	Postfix string
    59  
    60  	// DisableExpansion controls the expansion of properties on Get()
    61  	// and the check for circular references on Set(). When set to
    62  	// true Properties behaves like a simple key/value store and does
    63  	// not check for circular references on Get() or on Set().
    64  	DisableExpansion bool
    65  
    66  	// Stores the key/value pairs
    67  	m map[string]string
    68  
    69  	// Stores the comments per key.
    70  	c map[string][]string
    71  
    72  	// Stores the keys in order of appearance.
    73  	k []string
    74  
    75  	// WriteSeparator specifies the separator of key and value while writing the properties.
    76  	WriteSeparator string
    77  }
    78  
    79  // NewProperties creates a new Properties struct with the default
    80  // configuration for "${key}" expressions.
    81  func NewProperties() *Properties {
    82  	return &Properties{
    83  		Prefix:  "${",
    84  		Postfix: "}",
    85  		m:       map[string]string{},
    86  		c:       map[string][]string{},
    87  		k:       []string{},
    88  	}
    89  }
    90  
    91  // Load reads a buffer into the given Properties struct.
    92  func (p *Properties) Load(buf []byte, enc Encoding) error {
    93  	l := &Loader{Encoding: enc, DisableExpansion: p.DisableExpansion}
    94  	newProperties, err := l.LoadBytes(buf)
    95  	if err != nil {
    96  		return err
    97  	}
    98  	p.Merge(newProperties)
    99  	return nil
   100  }
   101  
   102  // Get returns the expanded value for the given key if exists.
   103  // Otherwise, ok is false.
   104  func (p *Properties) Get(key string) (value string, ok bool) {
   105  	v, ok := p.m[key]
   106  	if p.DisableExpansion {
   107  		return v, ok
   108  	}
   109  	if !ok {
   110  		return "", false
   111  	}
   112  
   113  	expanded, err := p.expand(key, v)
   114  
   115  	// we guarantee that the expanded value is free of
   116  	// circular references and malformed expressions
   117  	// so we panic if we still get an error here.
   118  	if err != nil {
   119  		ErrorHandler(err)
   120  	}
   121  
   122  	return expanded, true
   123  }
   124  
   125  // MustGet returns the expanded value for the given key if exists.
   126  // Otherwise, it panics.
   127  func (p *Properties) MustGet(key string) string {
   128  	if v, ok := p.Get(key); ok {
   129  		return v
   130  	}
   131  	ErrorHandler(invalidKeyError(key))
   132  	panic("ErrorHandler should exit")
   133  }
   134  
   135  // ----------------------------------------------------------------------------
   136  
   137  // ClearComments removes the comments for all keys.
   138  func (p *Properties) ClearComments() {
   139  	p.c = map[string][]string{}
   140  }
   141  
   142  // ----------------------------------------------------------------------------
   143  
   144  // GetComment returns the last comment before the given key or an empty string.
   145  func (p *Properties) GetComment(key string) string {
   146  	comments, ok := p.c[key]
   147  	if !ok || len(comments) == 0 {
   148  		return ""
   149  	}
   150  	return comments[len(comments)-1]
   151  }
   152  
   153  // ----------------------------------------------------------------------------
   154  
   155  // GetComments returns all comments that appeared before the given key or nil.
   156  func (p *Properties) GetComments(key string) []string {
   157  	if comments, ok := p.c[key]; ok {
   158  		return comments
   159  	}
   160  	return nil
   161  }
   162  
   163  // ----------------------------------------------------------------------------
   164  
   165  // SetComment sets the comment for the key.
   166  func (p *Properties) SetComment(key, comment string) {
   167  	p.c[key] = []string{comment}
   168  }
   169  
   170  // ----------------------------------------------------------------------------
   171  
   172  // SetComments sets the comments for the key. If the comments are nil then
   173  // all comments for this key are deleted.
   174  func (p *Properties) SetComments(key string, comments []string) {
   175  	if comments == nil {
   176  		delete(p.c, key)
   177  		return
   178  	}
   179  	p.c[key] = comments
   180  }
   181  
   182  // ----------------------------------------------------------------------------
   183  
   184  // GetBool checks if the expanded value is one of '1', 'yes',
   185  // 'true' or 'on' if the key exists. The comparison is case-insensitive.
   186  // If the key does not exist the default value is returned.
   187  func (p *Properties) GetBool(key string, def bool) bool {
   188  	v, err := p.getBool(key)
   189  	if err != nil {
   190  		return def
   191  	}
   192  	return v
   193  }
   194  
   195  // MustGetBool checks if the expanded value is one of '1', 'yes',
   196  // 'true' or 'on' if the key exists. The comparison is case-insensitive.
   197  // If the key does not exist the function panics.
   198  func (p *Properties) MustGetBool(key string) bool {
   199  	v, err := p.getBool(key)
   200  	if err != nil {
   201  		ErrorHandler(err)
   202  	}
   203  	return v
   204  }
   205  
   206  func (p *Properties) getBool(key string) (value bool, err error) {
   207  	if v, ok := p.Get(key); ok {
   208  		return boolVal(v), nil
   209  	}
   210  	return false, invalidKeyError(key)
   211  }
   212  
   213  func boolVal(v string) bool {
   214  	v = strings.ToLower(v)
   215  	return v == "1" || v == "true" || v == "yes" || v == "on"
   216  }
   217  
   218  // ----------------------------------------------------------------------------
   219  
   220  // GetDuration parses the expanded value as an time.Duration (in ns) if the
   221  // key exists. If key does not exist or the value cannot be parsed the default
   222  // value is returned. In almost all cases you want to use GetParsedDuration().
   223  func (p *Properties) GetDuration(key string, def time.Duration) time.Duration {
   224  	v, err := p.getInt64(key)
   225  	if err != nil {
   226  		return def
   227  	}
   228  	return time.Duration(v)
   229  }
   230  
   231  // MustGetDuration parses the expanded value as an time.Duration (in ns) if
   232  // the key exists. If key does not exist or the value cannot be parsed the
   233  // function panics. In almost all cases you want to use MustGetParsedDuration().
   234  func (p *Properties) MustGetDuration(key string) time.Duration {
   235  	v, err := p.getInt64(key)
   236  	if err != nil {
   237  		ErrorHandler(err)
   238  	}
   239  	return time.Duration(v)
   240  }
   241  
   242  // ----------------------------------------------------------------------------
   243  
   244  // GetParsedDuration parses the expanded value with time.ParseDuration() if the key exists.
   245  // If key does not exist or the value cannot be parsed the default
   246  // value is returned.
   247  func (p *Properties) GetParsedDuration(key string, def time.Duration) time.Duration {
   248  	s, ok := p.Get(key)
   249  	if !ok {
   250  		return def
   251  	}
   252  	v, err := time.ParseDuration(s)
   253  	if err != nil {
   254  		return def
   255  	}
   256  	return v
   257  }
   258  
   259  // MustGetParsedDuration parses the expanded value with time.ParseDuration() if the key exists.
   260  // If key does not exist or the value cannot be parsed the function panics.
   261  func (p *Properties) MustGetParsedDuration(key string) time.Duration {
   262  	s, ok := p.Get(key)
   263  	if !ok {
   264  		ErrorHandler(invalidKeyError(key))
   265  	}
   266  	v, err := time.ParseDuration(s)
   267  	if err != nil {
   268  		ErrorHandler(err)
   269  	}
   270  	return v
   271  }
   272  
   273  // ----------------------------------------------------------------------------
   274  
   275  // GetFloat64 parses the expanded value as a float64 if the key exists.
   276  // If key does not exist or the value cannot be parsed the default
   277  // value is returned.
   278  func (p *Properties) GetFloat64(key string, def float64) float64 {
   279  	v, err := p.getFloat64(key)
   280  	if err != nil {
   281  		return def
   282  	}
   283  	return v
   284  }
   285  
   286  // MustGetFloat64 parses the expanded value as a float64 if the key exists.
   287  // If key does not exist or the value cannot be parsed the function panics.
   288  func (p *Properties) MustGetFloat64(key string) float64 {
   289  	v, err := p.getFloat64(key)
   290  	if err != nil {
   291  		ErrorHandler(err)
   292  	}
   293  	return v
   294  }
   295  
   296  func (p *Properties) getFloat64(key string) (value float64, err error) {
   297  	if v, ok := p.Get(key); ok {
   298  		value, err = strconv.ParseFloat(v, 64)
   299  		if err != nil {
   300  			return 0, err
   301  		}
   302  		return value, nil
   303  	}
   304  	return 0, invalidKeyError(key)
   305  }
   306  
   307  // ----------------------------------------------------------------------------
   308  
   309  // GetInt parses the expanded value as an int if the key exists.
   310  // If key does not exist or the value cannot be parsed the default
   311  // value is returned. If the value does not fit into an int the
   312  // function panics with an out of range error.
   313  func (p *Properties) GetInt(key string, def int) int {
   314  	v, err := p.getInt64(key)
   315  	if err != nil {
   316  		return def
   317  	}
   318  	return intRangeCheck(key, v)
   319  }
   320  
   321  // MustGetInt parses the expanded value as an int if the key exists.
   322  // If key does not exist or the value cannot be parsed the function panics.
   323  // If the value does not fit into an int the function panics with
   324  // an out of range error.
   325  func (p *Properties) MustGetInt(key string) int {
   326  	v, err := p.getInt64(key)
   327  	if err != nil {
   328  		ErrorHandler(err)
   329  	}
   330  	return intRangeCheck(key, v)
   331  }
   332  
   333  // ----------------------------------------------------------------------------
   334  
   335  // GetInt64 parses the expanded value as an int64 if the key exists.
   336  // If key does not exist or the value cannot be parsed the default
   337  // value is returned.
   338  func (p *Properties) GetInt64(key string, def int64) int64 {
   339  	v, err := p.getInt64(key)
   340  	if err != nil {
   341  		return def
   342  	}
   343  	return v
   344  }
   345  
   346  // MustGetInt64 parses the expanded value as an int if the key exists.
   347  // If key does not exist or the value cannot be parsed the function panics.
   348  func (p *Properties) MustGetInt64(key string) int64 {
   349  	v, err := p.getInt64(key)
   350  	if err != nil {
   351  		ErrorHandler(err)
   352  	}
   353  	return v
   354  }
   355  
   356  func (p *Properties) getInt64(key string) (value int64, err error) {
   357  	if v, ok := p.Get(key); ok {
   358  		value, err = strconv.ParseInt(v, 10, 64)
   359  		if err != nil {
   360  			return 0, err
   361  		}
   362  		return value, nil
   363  	}
   364  	return 0, invalidKeyError(key)
   365  }
   366  
   367  // ----------------------------------------------------------------------------
   368  
   369  // GetUint parses the expanded value as an uint if the key exists.
   370  // If key does not exist or the value cannot be parsed the default
   371  // value is returned. If the value does not fit into an int the
   372  // function panics with an out of range error.
   373  func (p *Properties) GetUint(key string, def uint) uint {
   374  	v, err := p.getUint64(key)
   375  	if err != nil {
   376  		return def
   377  	}
   378  	return uintRangeCheck(key, v)
   379  }
   380  
   381  // MustGetUint parses the expanded value as an int if the key exists.
   382  // If key does not exist or the value cannot be parsed the function panics.
   383  // If the value does not fit into an int the function panics with
   384  // an out of range error.
   385  func (p *Properties) MustGetUint(key string) uint {
   386  	v, err := p.getUint64(key)
   387  	if err != nil {
   388  		ErrorHandler(err)
   389  	}
   390  	return uintRangeCheck(key, v)
   391  }
   392  
   393  // ----------------------------------------------------------------------------
   394  
   395  // GetUint64 parses the expanded value as an uint64 if the key exists.
   396  // If key does not exist or the value cannot be parsed the default
   397  // value is returned.
   398  func (p *Properties) GetUint64(key string, def uint64) uint64 {
   399  	v, err := p.getUint64(key)
   400  	if err != nil {
   401  		return def
   402  	}
   403  	return v
   404  }
   405  
   406  // MustGetUint64 parses the expanded value as an int if the key exists.
   407  // If key does not exist or the value cannot be parsed the function panics.
   408  func (p *Properties) MustGetUint64(key string) uint64 {
   409  	v, err := p.getUint64(key)
   410  	if err != nil {
   411  		ErrorHandler(err)
   412  	}
   413  	return v
   414  }
   415  
   416  func (p *Properties) getUint64(key string) (value uint64, err error) {
   417  	if v, ok := p.Get(key); ok {
   418  		value, err = strconv.ParseUint(v, 10, 64)
   419  		if err != nil {
   420  			return 0, err
   421  		}
   422  		return value, nil
   423  	}
   424  	return 0, invalidKeyError(key)
   425  }
   426  
   427  // ----------------------------------------------------------------------------
   428  
   429  // GetString returns the expanded value for the given key if exists or
   430  // the default value otherwise.
   431  func (p *Properties) GetString(key, def string) string {
   432  	if v, ok := p.Get(key); ok {
   433  		return v
   434  	}
   435  	return def
   436  }
   437  
   438  // MustGetString returns the expanded value for the given key if exists or
   439  // panics otherwise.
   440  func (p *Properties) MustGetString(key string) string {
   441  	if v, ok := p.Get(key); ok {
   442  		return v
   443  	}
   444  	ErrorHandler(invalidKeyError(key))
   445  	panic("ErrorHandler should exit")
   446  }
   447  
   448  // ----------------------------------------------------------------------------
   449  
   450  // Filter returns a new properties object which contains all properties
   451  // for which the key matches the pattern.
   452  func (p *Properties) Filter(pattern string) (*Properties, error) {
   453  	re, err := regexp.Compile(pattern)
   454  	if err != nil {
   455  		return nil, err
   456  	}
   457  
   458  	return p.FilterRegexp(re), nil
   459  }
   460  
   461  // FilterRegexp returns a new properties object which contains all properties
   462  // for which the key matches the regular expression.
   463  func (p *Properties) FilterRegexp(re *regexp.Regexp) *Properties {
   464  	pp := NewProperties()
   465  	for _, k := range p.k {
   466  		if re.MatchString(k) {
   467  			// TODO(fs): we are ignoring the error which flags a circular reference.
   468  			// TODO(fs): since we are just copying a subset of keys this cannot happen (fingers crossed)
   469  			pp.Set(k, p.m[k])
   470  		}
   471  	}
   472  	return pp
   473  }
   474  
   475  // FilterPrefix returns a new properties object with a subset of all keys
   476  // with the given prefix.
   477  func (p *Properties) FilterPrefix(prefix string) *Properties {
   478  	pp := NewProperties()
   479  	for _, k := range p.k {
   480  		if strings.HasPrefix(k, prefix) {
   481  			// TODO(fs): we are ignoring the error which flags a circular reference.
   482  			// TODO(fs): since we are just copying a subset of keys this cannot happen (fingers crossed)
   483  			pp.Set(k, p.m[k])
   484  		}
   485  	}
   486  	return pp
   487  }
   488  
   489  // FilterStripPrefix returns a new properties object with a subset of all keys
   490  // with the given prefix and the prefix removed from the keys.
   491  func (p *Properties) FilterStripPrefix(prefix string) *Properties {
   492  	pp := NewProperties()
   493  	n := len(prefix)
   494  	for _, k := range p.k {
   495  		if len(k) > len(prefix) && strings.HasPrefix(k, prefix) {
   496  			// TODO(fs): we are ignoring the error which flags a circular reference.
   497  			// TODO(fs): since we are modifying keys I am not entirely sure whether we can create a circular reference
   498  			// TODO(fs): this function should probably return an error but the signature is fixed
   499  			pp.Set(k[n:], p.m[k])
   500  		}
   501  	}
   502  	return pp
   503  }
   504  
   505  // Len returns the number of keys.
   506  func (p *Properties) Len() int {
   507  	return len(p.m)
   508  }
   509  
   510  // Keys returns all keys in the same order as in the input.
   511  func (p *Properties) Keys() []string {
   512  	keys := make([]string, len(p.k))
   513  	copy(keys, p.k)
   514  	return keys
   515  }
   516  
   517  // Set sets the property key to the corresponding value.
   518  // If a value for key existed before then ok is true and prev
   519  // contains the previous value. If the value contains a
   520  // circular reference or a malformed expression then
   521  // an error is returned.
   522  // An empty key is silently ignored.
   523  func (p *Properties) Set(key, value string) (prev string, ok bool, err error) {
   524  	if key == "" {
   525  		return "", false, nil
   526  	}
   527  
   528  	// if expansion is disabled we allow circular references
   529  	if p.DisableExpansion {
   530  		prev, ok = p.Get(key)
   531  		p.m[key] = value
   532  		if !ok {
   533  			p.k = append(p.k, key)
   534  		}
   535  		return prev, ok, nil
   536  	}
   537  
   538  	// to check for a circular reference we temporarily need
   539  	// to set the new value. If there is an error then revert
   540  	// to the previous state. Only if all tests are successful
   541  	// then we add the key to the p.k list.
   542  	prev, ok = p.Get(key)
   543  	p.m[key] = value
   544  
   545  	// now check for a circular reference
   546  	_, err = p.expand(key, value)
   547  	if err != nil {
   548  
   549  		// revert to the previous state
   550  		if ok {
   551  			p.m[key] = prev
   552  		} else {
   553  			delete(p.m, key)
   554  		}
   555  
   556  		return "", false, err
   557  	}
   558  
   559  	if !ok {
   560  		p.k = append(p.k, key)
   561  	}
   562  
   563  	return prev, ok, nil
   564  }
   565  
   566  // SetValue sets property key to the default string value
   567  // as defined by fmt.Sprintf("%v").
   568  func (p *Properties) SetValue(key string, value interface{}) error {
   569  	_, _, err := p.Set(key, fmt.Sprintf("%v", value))
   570  	return err
   571  }
   572  
   573  // MustSet sets the property key to the corresponding value.
   574  // If a value for key existed before then ok is true and prev
   575  // contains the previous value. An empty key is silently ignored.
   576  func (p *Properties) MustSet(key, value string) (prev string, ok bool) {
   577  	prev, ok, err := p.Set(key, value)
   578  	if err != nil {
   579  		ErrorHandler(err)
   580  	}
   581  	return prev, ok
   582  }
   583  
   584  // String returns a string of all expanded 'key = value' pairs.
   585  func (p *Properties) String() string {
   586  	var s string
   587  	for _, key := range p.k {
   588  		value, _ := p.Get(key)
   589  		s = fmt.Sprintf("%s%s = %s\n", s, key, value)
   590  	}
   591  	return s
   592  }
   593  
   594  // Sort sorts the properties keys in alphabetical order.
   595  // This is helpfully before writing the properties.
   596  func (p *Properties) Sort() {
   597  	sort.Strings(p.k)
   598  }
   599  
   600  // Write writes all unexpanded 'key = value' pairs to the given writer.
   601  // Write returns the number of bytes written and any write error encountered.
   602  func (p *Properties) Write(w io.Writer, enc Encoding) (n int, err error) {
   603  	return p.WriteComment(w, "", enc)
   604  }
   605  
   606  // WriteComment writes all unexpanced 'key = value' pairs to the given writer.
   607  // If prefix is not empty then comments are written with a blank line and the
   608  // given prefix. The prefix should be either "# " or "! " to be compatible with
   609  // the properties file format. Otherwise, the properties parser will not be
   610  // able to read the file back in. It returns the number of bytes written and
   611  // any write error encountered.
   612  func (p *Properties) WriteComment(w io.Writer, prefix string, enc Encoding) (n int, err error) {
   613  	var x int
   614  
   615  	for _, key := range p.k {
   616  		value := p.m[key]
   617  
   618  		if prefix != "" {
   619  			if comments, ok := p.c[key]; ok {
   620  				// don't print comments if they are all empty
   621  				allEmpty := true
   622  				for _, c := range comments {
   623  					if c != "" {
   624  						allEmpty = false
   625  						break
   626  					}
   627  				}
   628  
   629  				if !allEmpty {
   630  					// add a blank line between entries but not at the top
   631  					if len(comments) > 0 && n > 0 {
   632  						x, err = fmt.Fprintln(w)
   633  						if err != nil {
   634  							return
   635  						}
   636  						n += x
   637  					}
   638  
   639  					for _, c := range comments {
   640  						x, err = fmt.Fprintf(w, "%s%s\n", prefix, c)
   641  						if err != nil {
   642  							return
   643  						}
   644  						n += x
   645  					}
   646  				}
   647  			}
   648  		}
   649  		sep := " = "
   650  		if p.WriteSeparator != "" {
   651  			sep = p.WriteSeparator
   652  		}
   653  		x, err = fmt.Fprintf(w, "%s%s%s\n", encode(key, " :", enc), sep, encode(value, "", enc))
   654  		if err != nil {
   655  			return
   656  		}
   657  		n += x
   658  	}
   659  	return
   660  }
   661  
   662  // Map returns a copy of the properties as a map.
   663  func (p *Properties) Map() map[string]string {
   664  	m := make(map[string]string)
   665  	for k, v := range p.m {
   666  		m[k] = v
   667  	}
   668  	return m
   669  }
   670  
   671  // FilterFunc returns a copy of the properties which includes the values which passed all filters.
   672  func (p *Properties) FilterFunc(filters ...func(k, v string) bool) *Properties {
   673  	pp := NewProperties()
   674  outer:
   675  	for k, v := range p.m {
   676  		for _, f := range filters {
   677  			if !f(k, v) {
   678  				continue outer
   679  			}
   680  			pp.Set(k, v)
   681  		}
   682  	}
   683  	return pp
   684  }
   685  
   686  // ----------------------------------------------------------------------------
   687  
   688  // Delete removes the key and its comments.
   689  func (p *Properties) Delete(key string) {
   690  	delete(p.m, key)
   691  	delete(p.c, key)
   692  	newKeys := []string{}
   693  	for _, k := range p.k {
   694  		if k != key {
   695  			newKeys = append(newKeys, k)
   696  		}
   697  	}
   698  	p.k = newKeys
   699  }
   700  
   701  // Merge merges properties, comments and keys from other *Properties into p
   702  func (p *Properties) Merge(other *Properties) {
   703  	for _, k := range other.k {
   704  		if _, ok := p.m[k]; !ok {
   705  			p.k = append(p.k, k)
   706  		}
   707  	}
   708  	for k, v := range other.m {
   709  		p.m[k] = v
   710  	}
   711  	for k, v := range other.c {
   712  		p.c[k] = v
   713  	}
   714  }
   715  
   716  // ----------------------------------------------------------------------------
   717  
   718  // check expands all values and returns an error if a circular reference or
   719  // a malformed expression was found.
   720  func (p *Properties) check() error {
   721  	for key, value := range p.m {
   722  		if _, err := p.expand(key, value); err != nil {
   723  			return err
   724  		}
   725  	}
   726  	return nil
   727  }
   728  
   729  func (p *Properties) expand(key, input string) (string, error) {
   730  	// no pre/postfix -> nothing to expand
   731  	if p.Prefix == "" && p.Postfix == "" {
   732  		return input, nil
   733  	}
   734  
   735  	return expand(input, []string{key}, p.Prefix, p.Postfix, p.m)
   736  }
   737  
   738  // expand recursively expands expressions of '(prefix)key(postfix)' to their corresponding values.
   739  // The function keeps track of the keys that were already expanded and stops if it
   740  // detects a circular reference or a malformed expression of the form '(prefix)key'.
   741  func expand(s string, keys []string, prefix, postfix string, values map[string]string) (string, error) {
   742  	if len(keys) > maxExpansionDepth {
   743  		return "", fmt.Errorf("expansion too deep")
   744  	}
   745  
   746  	for {
   747  		start := strings.Index(s, prefix)
   748  		if start == -1 {
   749  			return s, nil
   750  		}
   751  
   752  		keyStart := start + len(prefix)
   753  		keyLen := strings.Index(s[keyStart:], postfix)
   754  		if keyLen == -1 {
   755  			return "", fmt.Errorf("malformed expression")
   756  		}
   757  
   758  		end := keyStart + keyLen + len(postfix) - 1
   759  		key := s[keyStart : keyStart+keyLen]
   760  
   761  		// fmt.Printf("s:%q pp:%q start:%d end:%d keyStart:%d keyLen:%d key:%q\n", s, prefix + "..." + postfix, start, end, keyStart, keyLen, key)
   762  
   763  		for _, k := range keys {
   764  			if key == k {
   765  				var b bytes.Buffer
   766  				b.WriteString("circular reference in:\n")
   767  				for _, k1 := range keys {
   768  					fmt.Fprintf(&b, "%s=%s\n", k1, values[k1])
   769  				}
   770  				return "", fmt.Errorf(b.String())
   771  			}
   772  		}
   773  
   774  		val, ok := values[key]
   775  		if !ok {
   776  			val = os.Getenv(key)
   777  		}
   778  		new_val, err := expand(val, append(keys, key), prefix, postfix, values)
   779  		if err != nil {
   780  			return "", err
   781  		}
   782  		s = s[:start] + new_val + s[end+1:]
   783  	}
   784  }
   785  
   786  // encode encodes a UTF-8 string to ISO-8859-1 and escapes some characters.
   787  func encode(s string, special string, enc Encoding) string {
   788  	switch enc {
   789  	case UTF8:
   790  		return encodeUtf8(s, special)
   791  	case ISO_8859_1:
   792  		return encodeIso(s, special)
   793  	default:
   794  		panic(fmt.Sprintf("unsupported encoding %v", enc))
   795  	}
   796  }
   797  
   798  func encodeUtf8(s string, special string) string {
   799  	v := ""
   800  	for pos := 0; pos < len(s); {
   801  		r, w := utf8.DecodeRuneInString(s[pos:])
   802  		pos += w
   803  		v += escape(r, special)
   804  	}
   805  	return v
   806  }
   807  
   808  func encodeIso(s string, special string) string {
   809  	var r rune
   810  	var w int
   811  	var v string
   812  	for pos := 0; pos < len(s); {
   813  		switch r, w = utf8.DecodeRuneInString(s[pos:]); {
   814  		case r < 1<<8: // single byte rune -> escape special chars only
   815  			v += escape(r, special)
   816  		case r < 1<<16: // two byte rune -> unicode literal
   817  			v += fmt.Sprintf("\\u%04x", r)
   818  		default: // more than two bytes per rune -> can't encode
   819  			v += "?"
   820  		}
   821  		pos += w
   822  	}
   823  	return v
   824  }
   825  
   826  func escape(r rune, special string) string {
   827  	switch r {
   828  	case '\f':
   829  		return "\\f"
   830  	case '\n':
   831  		return "\\n"
   832  	case '\r':
   833  		return "\\r"
   834  	case '\t':
   835  		return "\\t"
   836  	case '\\':
   837  		return "\\\\"
   838  	default:
   839  		if strings.ContainsRune(special, r) {
   840  			return "\\" + string(r)
   841  		}
   842  		return string(r)
   843  	}
   844  }
   845  
   846  func invalidKeyError(key string) error {
   847  	return fmt.Errorf("unknown property: %s", key)
   848  }
   849
View as plain text