Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package chezmoi for openSUSE:Factory checked
in at 2023-04-26 17:26:21
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/chezmoi (Old)
and /work/SRC/openSUSE:Factory/.chezmoi.new.1533 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "chezmoi"
Wed Apr 26 17:26:21 2023 rev:21 rq:1082925 version:2.33.3
Changes:
--------
--- /work/SRC/openSUSE:Factory/chezmoi/chezmoi.changes 2023-04-21
20:17:20.114422243 +0200
+++ /work/SRC/openSUSE:Factory/.chezmoi.new.1533/chezmoi.changes
2023-04-26 17:26:23.253982441 +0200
@@ -1,0 +2,6 @@
+Wed Apr 26 08:41:08 UTC 2023 - Filippo Bonazzi <filippo.bona...@suse.com>
+
+- Update to version 2.33.3_
+ * fix: Correct capitalization of .chezmoi.config template variables
+
+-------------------------------------------------------------------
Old:
----
chezmoi-2.33.2.obscpio
New:
----
chezmoi-2.33.3.obscpio
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ chezmoi.spec ++++++
--- /var/tmp/diff_new_pack.jgLQEn/_old 2023-04-26 17:26:24.113987458 +0200
+++ /var/tmp/diff_new_pack.jgLQEn/_new 2023-04-26 17:26:24.117987482 +0200
@@ -17,7 +17,7 @@
Name: chezmoi
-Version: 2.33.2
+Version: 2.33.3
Release: 0
Summary: A multi-host manager for dotfiles
License: MIT
++++++ _service ++++++
--- /var/tmp/diff_new_pack.jgLQEn/_old 2023-04-26 17:26:24.149987668 +0200
+++ /var/tmp/diff_new_pack.jgLQEn/_new 2023-04-26 17:26:24.153987691 +0200
@@ -2,7 +2,7 @@
<service name="obs_scm" mode="manual">
<param name="scm">git</param>
<param name="url">https://github.com/twpayne/chezmoi.git</param>
- <param name="revision">v2.33.2</param>
+ <param name="revision">v2.33.3</param>
<param name="versionformat">@PARENT_TAG@</param>
<param name="versionrewrite-pattern">v(.*)</param>
</service>
++++++ chezmoi-2.33.2.obscpio -> chezmoi-2.33.3.obscpio ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/chezmoi-2.33.2/assets/chezmoi.io/docs/reference/commands/add.md
new/chezmoi-2.33.3/assets/chezmoi.io/docs/reference/commands/add.md
--- old/chezmoi-2.33.2/assets/chezmoi.io/docs/reference/commands/add.md
2023-04-21 15:42:44.000000000 +0200
+++ new/chezmoi-2.33.3/assets/chezmoi.io/docs/reference/commands/add.md
2023-04-21 21:43:06.000000000 +0200
@@ -4,22 +4,6 @@
state, then its source state is replaced with its current state in the
destination directory.
-## `--autotemplate` (deprecated)
-
-Automatically generate a template by replacing strings that match variable
-values from the `data` section of the config file with their respective config
-names as a template string. Longer substitutions occur before shorter ones.
-This implies the `--template` option.
-
-!!! warning
-
- `--autotemplate` uses a greedy algorithm which occasionally generates
- templates with unwanted variable substitutions. Carefully review any
- templates it generates.
-
- `--autotemplate` has been deprecated and will be removed in a future
- release of chezmoi.
-
## `--encrypt`
Encrypt files using the defined encryption method.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/chezmoi-2.33.2/pkg/chezmoi/autotemplate.go
new/chezmoi-2.33.3/pkg/chezmoi/autotemplate.go
--- old/chezmoi-2.33.2/pkg/chezmoi/autotemplate.go 2023-04-21
15:42:44.000000000 +0200
+++ new/chezmoi-2.33.3/pkg/chezmoi/autotemplate.go 1970-01-01
01:00:00.000000000 +0100
@@ -1,119 +0,0 @@
-package chezmoi
-
-import (
- "regexp"
- "sort"
- "strings"
-)
-
-// A templateVariable is a template variable. It is used instead of a
-// map[string]string so that we can control order.
-type templateVariable struct {
- name string
- value string
-}
-
-var templateMarkerRx = regexp.MustCompile(`\{{2,}|\}{2,}`)
-
-// autoTemplate converts contents into a template by escaping template markers
-// and replacing values in data with their keys. It returns the template and if
-// any replacements were made.
-func autoTemplate(contents []byte, data map[string]any) ([]byte, bool) {
- contentsStr := string(contents)
- replacements := false
-
- // Replace template markers.
- replacedTemplateMarkersStr :=
templateMarkerRx.ReplaceAllString(contentsStr, `{{ "$0" }}`)
- if replacedTemplateMarkersStr != contentsStr {
- contentsStr = replacedTemplateMarkersStr
- replacements = true
- }
-
- // Replace variables.
- //
- // This naive approach will generate incorrect templates if the variable
- // names match variable values. The algorithm here is probably O(N^2),
we
- // can do better.
- variables := extractVariables(data)
- sort.Slice(variables, func(i, j int) bool {
- valueI := variables[i].value
- valueJ := variables[j].value
- switch {
- case len(valueI) > len(valueJ): // First sort by value length.
- return true
- case len(valueI) == len(valueJ): // Second sort by value name.
- nameI := variables[i].name
- nameJ := variables[j].name
- return nameI < nameJ
- default:
- return false
- }
- })
- for _, variable := range variables {
- if variable.value == "" {
- continue
- }
-
- index := strings.Index(contentsStr, variable.value)
- for index != -1 && index != len(contentsStr) {
- if !inWord(contentsStr, index) && !inWord(contentsStr,
index+len(variable.value)) {
- // Replace variable.value which is on word
boundaries at both
- // ends.
- replacement := "{{ ." + variable.name + " }}"
- contentsStr = contentsStr[:index] + replacement
+ contentsStr[index+len(variable.value):]
- index += len(replacement)
- replacements = true
- } else {
- // Otherwise, keep looking. Consume at least
one byte so we make
- // progress.
- index++
- }
-
- // Look for the next occurrence of variable.value.
- j := strings.Index(contentsStr[index:], variable.value)
- if j == -1 {
- // No more occurrences found, so terminate the
loop.
- break
- }
- // Advance to the next occurrence.
- index += j
- }
- }
-
- return []byte(contentsStr), replacements
-}
-
-// extractVariables extracts all template variables from data.
-func extractVariables(data map[string]any) []templateVariable {
- return extractVariablesHelper(nil /* variables */, nil /* parent */,
data)
-}
-
-// extractVariablesHelper appends all template variables in data to variables
-// and returns variables. data is assumed to be rooted at parent.
-func extractVariablesHelper(
- variables []templateVariable, parent []string, data map[string]any,
-) []templateVariable {
- for name, value := range data {
- switch value := value.(type) {
- case string:
- variable := templateVariable{
- name: strings.Join(append(parent, name), "."),
- value: value,
- }
- variables = append(variables, variable)
- case map[string]any:
- variables = extractVariablesHelper(variables,
append(parent, name), value)
- }
- }
- return variables
-}
-
-// inWord returns true if splitting s at position i would split a word.
-func inWord(s string, i int) bool {
- return i > 0 && i < len(s) && isWord(s[i-1]) && isWord(s[i])
-}
-
-// isWord returns true if b is a word byte.
-func isWord(b byte) bool {
- return '0' <= b && b <= '9' || 'A' <= b && b <= 'Z' || 'a' <= b && b <=
'z'
-}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/chezmoi-2.33.2/pkg/chezmoi/autotemplate_test.go
new/chezmoi-2.33.3/pkg/chezmoi/autotemplate_test.go
--- old/chezmoi-2.33.2/pkg/chezmoi/autotemplate_test.go 2023-04-21
15:42:44.000000000 +0200
+++ new/chezmoi-2.33.3/pkg/chezmoi/autotemplate_test.go 1970-01-01
01:00:00.000000000 +0100
@@ -1,190 +0,0 @@
-package chezmoi
-
-import (
- "testing"
-
- "github.com/stretchr/testify/assert"
-)
-
-func TestAutoTemplate(t *testing.T) {
- for _, tc := range []struct {
- name string
- contentsStr string
- data map[string]any
- expected string
- expectedReplacements bool
- }{
- {
- name: "simple",
- contentsStr: "email = y...@example.com\n",
- data: map[string]any{
- "email": "y...@example.com",
- },
- expected: "email = {{ .email }}\n",
- expectedReplacements: true,
- },
- {
- name: "longest_first",
- contentsStr: "name = John Smith\nfirstName = John\n",
- data: map[string]any{
- "name": "John Smith",
- "firstName": "John",
- },
- expected: "" +
- "name = {{ .name }}\n" +
- "firstName = {{ .firstName }}\n",
- expectedReplacements: true,
- },
- {
- name: "alphabetical_first",
- contentsStr: "name = John Smith\n",
- data: map[string]any{
- "alpha": "John Smith",
- "beta": "John Smith",
- "gamma": "John Smith",
- },
- expected: "name = {{ .alpha }}\n",
- expectedReplacements: true,
- },
- {
- name: "nested_values",
- contentsStr: "email = y...@example.com\n",
- data: map[string]any{
- "personal": map[string]any{
- "email": "y...@example.com",
- },
- },
- expected: "email = {{ .personal.email }}\n",
- expectedReplacements: true,
- },
- {
- name: "only_replace_words",
- contentsStr: "darwinian evolution",
- data: map[string]any{
- "os": "darwin",
- },
- expected: "darwinian evolution", // not "{{ .os }}ian
evolution"
- },
- {
- name: "longest_match_first",
- contentsStr: "/home/user",
- data: map[string]any{
- "homeDir": "/home/user",
- },
- expected: "{{ .homeDir }}",
- expectedReplacements: true,
- },
- {
- name: "longest_match_first_prefix",
- contentsStr: "HOME=/home/user",
- data: map[string]any{
- "homeDir": "/home/user",
- },
- expected: "HOME={{ .homeDir }}",
- expectedReplacements: true,
- },
- {
- name: "longest_match_first_suffix",
- contentsStr: "/home/user/something",
- data: map[string]any{
- "homeDir": "/home/user",
- },
- expected: "{{ .homeDir }}/something",
- expectedReplacements: true,
- },
- {
- name: "longest_match_first_prefix_and_suffix",
- contentsStr: "HOME=/home/user/something",
- data: map[string]any{
- "homeDir": "/home/user",
- },
- expected: "HOME={{ .homeDir }}/something",
- expectedReplacements: true,
- },
- {
- name: "words_only",
- contentsStr: "aaa aa a aa aaa aa a aa aaa",
- data: map[string]any{
- "alpha": "a",
- },
- expected: "aaa aa {{ .alpha }} aa aaa aa {{
.alpha }} aa aaa",
- expectedReplacements: true,
- },
- {
- name: "words_only_2",
- contentsStr: "aaa aa a aa aaa aa a aa aaa",
- data: map[string]any{
- "alpha": "aa",
- },
- expected: "aaa {{ .alpha }} a {{ .alpha }}
aaa {{ .alpha }} a {{ .alpha }} aaa",
- expectedReplacements: true,
- },
- {
- name: "words_only_3",
- contentsStr: "aaa aa a aa aaa aa a aa aaa",
- data: map[string]any{
- "alpha": "aaa",
- },
- expected: "{{ .alpha }} aa a aa {{ .alpha
}} aa a aa {{ .alpha }}",
- expectedReplacements: true,
- },
- {
- name: "skip_empty",
- contentsStr: "a",
- data: map[string]any{
- "empty": "",
- },
- expected: "a",
- },
- {
- name: "markers",
- contentsStr: "{{}}",
- expected: `{{ "{{" }}{{ "}}" }}`,
- expectedReplacements: true,
- },
- } {
- t.Run(tc.name, func(t *testing.T) {
- actualTemplate, actualReplacements :=
autoTemplate([]byte(tc.contentsStr), tc.data)
- assert.Equal(t, tc.expected, string(actualTemplate))
- assert.Equal(t, tc.expectedReplacements,
actualReplacements)
- })
- }
-}
-
-func TestInWord(t *testing.T) {
- for _, tc := range []struct {
- s string
- i int
- expected bool
- }{
- {s: "", i: 0, expected: false},
- {s: "a", i: 0, expected: false},
- {s: "a", i: 1, expected: false},
- {s: "ab", i: 0, expected: false},
- {s: "ab", i: 1, expected: true},
- {s: "ab", i: 2, expected: false},
- {s: "abc", i: 0, expected: false},
- {s: "abc", i: 1, expected: true},
- {s: "abc", i: 2, expected: true},
- {s: "abc", i: 3, expected: false},
- {s: " abc ", i: 0, expected: false},
- {s: " abc ", i: 1, expected: false},
- {s: " abc ", i: 2, expected: true},
- {s: " abc ", i: 3, expected: true},
- {s: " abc ", i: 4, expected: false},
- {s: " abc ", i: 5, expected: false},
- {s: "/home/user", i: 0, expected: false},
- {s: "/home/user", i: 1, expected: false},
- {s: "/home/user", i: 2, expected: true},
- {s: "/home/user", i: 3, expected: true},
- {s: "/home/user", i: 4, expected: true},
- {s: "/home/user", i: 5, expected: false},
- {s: "/home/user", i: 6, expected: false},
- {s: "/home/user", i: 7, expected: true},
- {s: "/home/user", i: 8, expected: true},
- {s: "/home/user", i: 9, expected: true},
- {s: "/home/user", i: 10, expected: false},
- } {
- assert.Equal(t, tc.expected, inWord(tc.s, tc.i))
- }
-}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/chezmoi-2.33.2/pkg/chezmoi/sourcestate.go
new/chezmoi-2.33.3/pkg/chezmoi/sourcestate.go
--- old/chezmoi-2.33.2/pkg/chezmoi/sourcestate.go 2023-04-21
15:42:44.000000000 +0200
+++ new/chezmoi-2.33.3/pkg/chezmoi/sourcestate.go 2023-04-21
21:43:06.000000000 +0200
@@ -292,7 +292,6 @@
// AddOptions are options to SourceState.Add.
type AddOptions struct {
- AutoTemplate bool // Automatically create templates,
if possible.
Create bool // Add create_ entries instead of
normal entries.
Encrypt bool // Encrypt files.
EncryptedSuffix string // Suffix for encrypted files.
@@ -1876,13 +1875,6 @@
if err != nil {
return nil, err
}
- if options.AutoTemplate {
- var replacements bool
- contents, replacements = autoTemplate(contents,
s.TemplateData())
- if replacements {
- fileAttr.Template = true
- }
- }
if len(contents) == 0 {
fileAttr.Empty = true
}
@@ -1920,8 +1912,6 @@
contents := []byte(linkname)
template := false
switch {
- case options.AutoTemplate:
- contents, template = autoTemplate(contents, s.TemplateData())
case options.Template:
template = true
case !options.Template && options.TemplateSymlinks:
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/chezmoi-2.33.2/pkg/chezmoi/sourcestate_test.go
new/chezmoi-2.33.3/pkg/chezmoi/sourcestate_test.go
--- old/chezmoi-2.33.2/pkg/chezmoi/sourcestate_test.go 2023-04-21
15:42:44.000000000 +0200
+++ new/chezmoi-2.33.3/pkg/chezmoi/sourcestate_test.go 2023-04-21
21:43:06.000000000 +0200
@@ -429,23 +429,6 @@
},
},
{
- name: "template",
- destAbsPaths: []AbsPath{
- NewAbsPath("/home/user/.template"),
- },
- addOptions: AddOptions{
- AutoTemplate: true,
- Filter: NewEntryTypeFilter(EntryTypesAll,
EntryTypesNone),
- },
- tests: []any{
-
vfst.TestPath("/home/user/.local/share/chezmoi/dot_template.tmpl",
- vfst.TestModeIsRegular,
-
vfst.TestModePerm(0o666&^chezmoitest.Umask),
- vfst.TestContentsString("key = {{
.variable }}\n"),
- ),
- },
- },
- {
name: "dir_and_dir_file",
destAbsPaths: []AbsPath{
NewAbsPath("/home/user/.dir"),
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/chezmoi-2.33.2/pkg/cmd/addcmd.go
new/chezmoi-2.33.3/pkg/cmd/addcmd.go
--- old/chezmoi-2.33.2/pkg/cmd/addcmd.go 2023-04-21 15:42:44.000000000
+0200
+++ new/chezmoi-2.33.3/pkg/cmd/addcmd.go 2023-04-21 21:43:06.000000000
+0200
@@ -10,7 +10,6 @@
type addCmdConfig struct {
TemplateSymlinks bool `json:"templateSymlinks"
mapstructure:"templateSymlinks" yaml:"templateSymlinks"`
- autoTemplate bool
create bool
encrypt bool
exact bool
@@ -40,7 +39,6 @@
}
flags := addCmd.Flags()
- flags.BoolVarP(&c.Add.autoTemplate, "autotemplate", "a",
c.Add.autoTemplate, "Generate the template when adding files as templates")
//nolint:lll
flags.BoolVar(&c.Add.create, "create", c.Add.create, "Add files that
should exist, irrespective of their contents")
flags.BoolVar(&c.Add.encrypt, "encrypt", c.Add.encrypt, "Encrypt files")
flags.BoolVar(&c.Add.exact, "exact", c.Add.exact, "Add directories
exactly")
@@ -53,10 +51,6 @@
flags.BoolVarP(&c.Add.template, "template", "T", c.Add.template, "Add
files as templates")
flags.BoolVar(&c.Add.TemplateSymlinks, "template-symlinks",
c.Add.TemplateSymlinks, "Add symlinks with target in source or home dirs as
templates") //nolint:lll
- if err := flags.MarkDeprecated("autotemplate", "it will be removed in a
future release"); err != nil {
- panic(err)
- }
-
registerExcludeIncludeFlagCompletionFuncs(addCmd)
return addCmd
@@ -158,7 +152,6 @@
}
return sourceState.Add(c.sourceSystem, c.persistentState, c.destSystem,
destAbsPathInfos, &chezmoi.AddOptions{
- AutoTemplate: c.Add.autoTemplate,
Create: c.Add.create,
Encrypt: c.Add.encrypt,
EncryptedSuffix: c.encryption.EncryptedSuffix(),
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/chezmoi-2.33.2/pkg/cmd/config.go
new/chezmoi-2.33.3/pkg/cmd/config.go
--- old/chezmoi-2.33.2/pkg/cmd/config.go 2023-04-21 15:42:44.000000000
+0200
+++ new/chezmoi-2.33.3/pkg/cmd/config.go 2023-04-21 21:43:06.000000000
+0200
@@ -237,7 +237,7 @@
args []string
cacheDir chezmoi.AbsPath
command string
- config ConfigFile
+ config map[string]any
configFile chezmoi.AbsPath
executable chezmoi.AbsPath
fqdnHostname string
@@ -2084,7 +2084,7 @@
args: os.Args,
cacheDir: c.CacheDirAbsPath,
command: cmd.Name(),
- config: c.ConfigFile,
+ config: c.ConfigFile.toMap(),
configFile: c.configFileAbsPath,
executable: chezmoi.NewAbsPath(executable),
fqdnHostname: fqdnHostname,
@@ -2533,6 +2533,14 @@
}
}
+func (f *ConfigFile) toMap() map[string]any {
+ var result map[string]any
+ if err := mapstructure.Decode(f, &result); err != nil {
+ panic(err)
+ }
+ return result
+}
+
func parseCommand(command string, args []string) (string, []string, error) {
// If command is found, then return it.
if path, err := chezmoi.LookPath(command); err == nil {
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/chezmoi-2.33.2/pkg/cmd/testdata/scripts/addautotemplate.txtar
new/chezmoi-2.33.3/pkg/cmd/testdata/scripts/addautotemplate.txtar
--- old/chezmoi-2.33.2/pkg/cmd/testdata/scripts/addautotemplate.txtar
2023-04-21 15:42:44.000000000 +0200
+++ new/chezmoi-2.33.3/pkg/cmd/testdata/scripts/addautotemplate.txtar
1970-01-01 01:00:00.000000000 +0100
@@ -1,35 +0,0 @@
-# test that chezmoi add --autotemplate on a file with a replacement creates a
template in the source directory
-exec chezmoi add --autotemplate $HOME${/}.template
-stderr 'deprecated'
-cmp $CHEZMOISOURCEDIR/dot_template.tmpl golden/dot_template.tmpl
-
-# test that chezmoi add --autotemplate on a symlink with a replacement creates
a template in the source directory
-symlink $HOME/.symlink -> .target-value
-exec chezmoi add --autotemplate $HOME${/}.symlink
-cmp $CHEZMOISOURCEDIR/symlink_dot_symlink.tmpl golden/symlink_dot_symlink.tmpl
-
-# test that chezmoi add --autotemplate does not create a template if no
replacements occurred
-exec chezmoi add --autotemplate $HOME${/}.file
-cmp $CHEZMOISOURCEDIR/dot_file golden/dot_file
-
-# test that chezmoi add --autotemplate escapes brackets
-exec chezmoi add --autotemplate $HOME${/}.vimrc
-cmp $CHEZMOISOURCEDIR/dot_vimrc.tmpl golden/dot_vimrc.tmpl
-
--- golden/dot_file --
-# contents of .file
--- golden/dot_template.tmpl --
-key = {{ .variable }}
--- golden/dot_vimrc.tmpl --
-set foldmarker={{ "{{" }},{{ "}}" }}
--- golden/symlink_dot_symlink.tmpl --
-.target-{{ .variable }}
--- home/user/.config/chezmoi/chezmoi.toml --
-[data]
- variable = "value"
--- home/user/.file --
-# contents of .file
--- home/user/.template --
-key = value
--- home/user/.vimrc --
-set foldmarker={{,}}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/chezmoi-2.33.2/pkg/cmd/testdata/scripts/issue2942.txtar
new/chezmoi-2.33.3/pkg/cmd/testdata/scripts/issue2942.txtar
--- old/chezmoi-2.33.2/pkg/cmd/testdata/scripts/issue2942.txtar 1970-01-01
01:00:00.000000000 +0100
+++ new/chezmoi-2.33.3/pkg/cmd/testdata/scripts/issue2942.txtar 2023-04-21
21:43:06.000000000 +0200
@@ -0,0 +1,3 @@
+# test that .chezmoi.config variables are capitalized correctly
+exec chezmoi execute-template '{{ .chezmoi.config.keepassxc.command }}'
+stdout '^keepassxc-cli$'
++++++ chezmoi.obsinfo ++++++
--- /var/tmp/diff_new_pack.jgLQEn/_old 2023-04-26 17:26:24.601990306 +0200
+++ /var/tmp/diff_new_pack.jgLQEn/_new 2023-04-26 17:26:24.605990328 +0200
@@ -1,5 +1,5 @@
name: chezmoi
-version: 2.33.2
-mtime: 1682084564
-commit: ebc536f0dbf7c54ab8677b202532736be8d61c6c
+version: 2.33.3
+mtime: 1682106186
+commit: fe6010e8b2518ddabfcd5f58236763b4f2e90ff8
++++++ vendor.tar.gz ++++++
/work/SRC/openSUSE:Factory/chezmoi/vendor.tar.gz
/work/SRC/openSUSE:Factory/.chezmoi.new.1533/vendor.tar.gz differ: char 5, line
1
