12750410851

Committed 13 Jan 2025 03:23PM UTC coverage: 68.077% (+0.5%) from 67.541%

Build # 12750410851

Build Type

Pull #820

github

Committed by

web-flow

Commit Message

Merge b7b0d1004 into 8e971e1a8

Pull Request Pull Request #820: #759: upgrade settings commandlet

Run Details

2689 of 4311 branches covered (62.38%)

Branch coverage included in aggregate %.

6946 of 9842 relevant lines covered (70.58%)

3.1 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

41.28

cli/src/main/java/com/devonfw/tools/ide/merge/PropertiesMerger.java

package com.devonfw.tools.ide.merge;

import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Properties;
import java.util.Set;

import com.devonfw.tools.ide.context.IdeContext;
import com.devonfw.tools.ide.environment.EnvironmentVariables;
import com.devonfw.tools.ide.environment.SortedProperties;

/**
 * Implementation of {@link FileMerger} for {@link Properties} files.
 */
public class PropertiesMerger extends FileMerger {

  /**
   * The constructor.
   *
   * @param context the {@link #context}.
   */
  public PropertiesMerger(IdeContext context) {

    super(context);
  }

  @Override
  protected void doMerge(Path setup, Path update, EnvironmentVariables resolver, Path workspace) {

    SortedProperties properties = new SortedProperties();
    boolean updateFileExists = Files.exists(update);
    Path template = setup;
    if (Files.exists(workspace)) {
      if (!updateFileExists) {
        this.context.trace("Nothing to do as update file does not exist: {}", update);
        return; // nothing to do ...
      }
      load(properties, workspace);
    } else if (Files.exists(setup)) {
      load(properties, setup);
    }
    if (updateFileExists) {
      load(properties, update);
      template = update;
    }
    resolve(properties, resolver, template.toString());
    save(properties, workspace);
    this.context.trace("Saved merged properties to: {}", workspace);
  }

  /**
   * @param file the {@link Path} to load.
   * @return the loaded {@link Properties}.
   */
  public Properties load(Path file) {

    Properties properties = new Properties();
    load(properties, file);
    return properties;
  }

  /**
   * @param file the {@link Path} to load.
   * @return the loaded {@link Properties}.
   */
  public Properties loadIfExists(Path file) {

    Properties properties = new Properties();
    if (file != null) {
      if (Files.exists(file)) {
        load(properties, file);
      } else {
        this.context.trace("Properties file does not exist: {}", file);
      }
    }
    return properties;
  }

  /**
   * @param properties the existing {@link Properties} instance.
   * @param file the properties {@link Path} to load.
   */
  public void load(Properties properties, Path file) {

    this.context.trace("Loading properties file: {}", file);
    try (Reader reader = Files.newBufferedReader(file)) {
      properties.load(reader);
    } catch (IOException e) {
      throw new IllegalStateException("Could not load properties from file: " + file, e);
    }
  }

  private void resolve(Properties properties, EnvironmentVariables variables, Object src) {

    Set<Object> keys = properties.keySet();
    for (Object key : keys) {
      String value = properties.getProperty(key.toString());
      properties.setProperty(key.toString(), variables.resolve(value, src, this.legacySupport));
    }
  }

  /**
   * @param properties the {@link Properties} to save.
   * @param file the {@link Path} to save to.
   */
  public void save(Properties properties, Path file) {

    this.context.trace("Saving properties file: {}", file);
    ensureParentDirectoryExists(file);
    try (Writer writer = Files.newBufferedWriter(file)) {
      properties.store(writer, null);
    } catch (IOException e) {
      throw new IllegalStateException("Could not write properties to file: " + file, e);
    }
  }

  @Override
  public void inverseMerge(Path workspace, EnvironmentVariables variables, boolean addNewProperties, Path update) {

    if (!Files.exists(workspace)) {
      this.context.trace("Workspace file does not exist: {}", workspace);
      return;
    }
    if (!Files.exists(update)) {
      this.context.trace("Update file does not exist: {}", update);
      return;
    }
    Object src = workspace.getFileName();
    Properties updateProperties = load(update);
    Properties workspaceProperties = load(workspace);
    SortedProperties mergedProperties = new SortedProperties();
    mergedProperties.putAll(updateProperties);
    boolean updated = false;
    for (Object key : workspaceProperties.keySet()) {
      Object workspaceValue = workspaceProperties.get(key);
      Object updateValue = updateProperties.get(key);
      if ((updateValue != null) || addNewProperties) {
        String updateValueResolved = null;
        if (updateValue != null) {
          updateValueResolved = variables.resolve(updateValue.toString(), src, this.legacySupport);
        }
        if (!workspaceValue.equals(updateValueResolved)) {
          String workspaceValueInverseResolved = variables.inverseResolve(workspaceValue.toString(), src);
          mergedProperties.put(key, workspaceValueInverseResolved);
          updated = true;
        }
      }
    }
    if (updated) {
      save(mergedProperties, update);
      this.context.debug("Saved changes from: {} to: {}", workspace.getFileName(), update);
    } else {
      this.context.trace("No changes for: {}", update);
    }
  }

  @Override
  protected boolean doUpgrade(Path workspaceFile) throws Exception {

    return doUpgradeTextContent(workspaceFile);
  }
}

1	package com.devonfw.tools.ide.merge;
2
3	import java.io.IOException;
4	import java.io.Reader;
5	import java.io.Writer;
6	import java.nio.file.Files;
7	import java.nio.file.Path;
8	import java.util.Properties;
9	import java.util.Set;
10
11	import com.devonfw.tools.ide.context.IdeContext;
12	import com.devonfw.tools.ide.environment.EnvironmentVariables;
13	import com.devonfw.tools.ide.environment.SortedProperties;
14
15	/**
16	* Implementation of {@link FileMerger} for {@link Properties} files.
17	*/
18	public class PropertiesMerger extends FileMerger {
19
20	/**
21	* The constructor.
22	*
23	* @param context the {@link #context}.
24	*/
25	public PropertiesMerger(IdeContext context) {
26
27	super(context);	3✔
28	}	1✔
29
30	@Override
31	protected void doMerge(Path setup, Path update, EnvironmentVariables resolver, Path workspace) {
32
33	SortedProperties properties = new SortedProperties();	4✔
34	boolean updateFileExists = Files.exists(update);	5✔
35	Path template = setup;	2✔
36	if (Files.exists(workspace)) {	5✔
37	if (!updateFileExists) {	2!
38	this.context.trace("Nothing to do as update file does not exist: {}", update);	×
39	return; // nothing to do ...	×
40	}
41	load(properties, workspace);	5✔
42	} else if (Files.exists(setup)) {	5✔
43	load(properties, setup);	4✔
44	}
45	if (updateFileExists) {	2!
46	load(properties, update);	4✔
47	template = update;	2✔
48	}
49	resolve(properties, resolver, template.toString());	6✔
50	save(properties, workspace);	4✔
51	this.context.trace("Saved merged properties to: {}", workspace);	10✔
52	}	1✔
53
54	/**
55	* @param file the {@link Path} to load.
56	* @return the loaded {@link Properties}.
57	*/
58	public Properties load(Path file) {
59
60	Properties properties = new Properties();	4✔
61	load(properties, file);	4✔
62	return properties;	2✔
63	}
64
65	/**
66	* @param file the {@link Path} to load.
67	* @return the loaded {@link Properties}.
68	*/
69	public Properties loadIfExists(Path file) {
70
71	Properties properties = new Properties();	×
72	if (file != null) {	×
73	if (Files.exists(file)) {	×
74	load(properties, file);	×
75	} else {
76	this.context.trace("Properties file does not exist: {}", file);	×
77	}
78	}
79	return properties;	×
80	}
81
82	/**
83	* @param properties the existing {@link Properties} instance.
84	* @param file the properties {@link Path} to load.
85	*/
86	public void load(Properties properties, Path file) {
87
88	this.context.trace("Loading properties file: {}", file);	10✔
89	try (Reader reader = Files.newBufferedReader(file)) {	3✔
90	properties.load(reader);	3✔
91	} catch (IOException e) {	×
92	throw new IllegalStateException("Could not load properties from file: " + file, e);	×
93	}	1✔
94	}	1✔
95
96	private void resolve(Properties properties, EnvironmentVariables variables, Object src) {
97
98	Set<Object> keys = properties.keySet();	3✔
99	for (Object key : keys) {	9✔
100	String value = properties.getProperty(key.toString());	5✔
101	properties.setProperty(key.toString(), variables.resolve(value, src, this.legacySupport));	11✔
102	}	1✔
103	}	1✔
104
105	/**
106	* @param properties the {@link Properties} to save.
107	* @param file the {@link Path} to save to.
108	*/
109	public void save(Properties properties, Path file) {
110
111	this.context.trace("Saving properties file: {}", file);	10✔
112	ensureParentDirectoryExists(file);	2✔
113	try (Writer writer = Files.newBufferedWriter(file)) {	5✔
114	properties.store(writer, null);	4✔
115	} catch (IOException e) {	×
116	throw new IllegalStateException("Could not write properties to file: " + file, e);	×
117	}	1✔
118	}	1✔
119
120	@Override
121	public void inverseMerge(Path workspace, EnvironmentVariables variables, boolean addNewProperties, Path update) {
122
123	if (!Files.exists(workspace)) {	×
124	this.context.trace("Workspace file does not exist: {}", workspace);	×
125	return;	×
126	}
127	if (!Files.exists(update)) {	×
128	this.context.trace("Update file does not exist: {}", update);	×
129	return;	×
130	}
131	Object src = workspace.getFileName();	×
132	Properties updateProperties = load(update);	×
133	Properties workspaceProperties = load(workspace);	×
134	SortedProperties mergedProperties = new SortedProperties();	×
135	mergedProperties.putAll(updateProperties);	×
136	boolean updated = false;	×
137	for (Object key : workspaceProperties.keySet()) {	×
138	Object workspaceValue = workspaceProperties.get(key);	×
139	Object updateValue = updateProperties.get(key);	×
140	if ((updateValue != null) \|\| addNewProperties) {	×
141	String updateValueResolved = null;	×
142	if (updateValue != null) {	×
143	updateValueResolved = variables.resolve(updateValue.toString(), src, this.legacySupport);	×
144	}
145	if (!workspaceValue.equals(updateValueResolved)) {	×
146	String workspaceValueInverseResolved = variables.inverseResolve(workspaceValue.toString(), src);	×
147	mergedProperties.put(key, workspaceValueInverseResolved);	×
148	updated = true;	×
149	}
150	}
151	}	×
152	if (updated) {	×
153	save(mergedProperties, update);	×
154	this.context.debug("Saved changes from: {} to: {}", workspace.getFileName(), update);	×
155	} else {
156	this.context.trace("No changes for: {}", update);	×
157	}
158	}	×
159
160	@Override
161	protected boolean doUpgrade(Path workspaceFile) throws Exception {
162
163	return doUpgradeTextContent(workspaceFile);	×
164	}
165	}

devonfw / IDEasy / 12750410851

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous