From 08d8326523cb01049bea38b49014cc1114933563 Mon Sep 17 00:00:00 2001 From: JPilson Date: Tue, 16 Apr 2024 20:33:05 +0200 Subject: [PATCH 1/9] feat: add key naming convention converter New methods have been added to convert keys to either camel or snake case depending on a boolean flag. These methods are used to format the text that is input into the Add Dialog in 'LocalizeItAction' class. This improves the versatility of key handling within the project. --- .../easyi18n/action/LocalizeItAction.java | 26 +++++++++++++++---- 1 file changed, 21 insertions(+), 5 deletions(-) diff --git a/src/main/java/de/marhali/easyi18n/action/LocalizeItAction.java b/src/main/java/de/marhali/easyi18n/action/LocalizeItAction.java index c7d6656..8e456f7 100644 --- a/src/main/java/de/marhali/easyi18n/action/LocalizeItAction.java +++ b/src/main/java/de/marhali/easyi18n/action/LocalizeItAction.java @@ -1,5 +1,6 @@ package de.marhali.easyi18n.action; +import com.google.common.base.CaseFormat; import com.intellij.openapi.actionSystem.AnAction; import com.intellij.openapi.actionSystem.AnActionEvent; import com.intellij.openapi.actionSystem.CommonDataKeys; @@ -47,7 +48,7 @@ class LocalizeItAction extends AnAction { throw new RuntimeException("Project is null!"); } - AddDialog dialog = new AddDialog(project, new KeyPath(text), text, (key) -> replaceSelectedText(project, editor, key)); + AddDialog dialog = new AddDialog(project, new KeyPath(convertKeyToNamingCase(text, true)), text, (key) -> replaceSelectedText(project, editor, key)); dialog.showAndHandle(); } @@ -55,8 +56,8 @@ class LocalizeItAction extends AnAction { * Replaces the selected text in the editor with a new text generated from the provided key. * * @param project the project where the editor belongs - * @param editor the editor where the text is selected - * @param key the key used to generate the replacement text + * @param editor the editor where the text is selected + * @param key the key used to generate the replacement text */ private void replaceSelectedText(Project project, @NotNull Editor editor, @NotNull String key) { int selectionStart = editor.getSelectionModel().getSelectionStart(); @@ -71,8 +72,8 @@ class LocalizeItAction extends AnAction { * Builds a replacement string based on the provided flavor template, key, and document util. * * @param flavorTemplate the flavor template string - * @param key the key used to generate the replacement text - * @param documentUtil the document util object used to determine the document type + * @param key the key used to generate the replacement text + * @param documentUtil the document util object used to determine the document type * @return the built replacement string */ private String buildReplacement(String flavorTemplate, String key, DocumentUtil documentUtil) { @@ -80,4 +81,19 @@ class LocalizeItAction extends AnAction { return flavorTemplate + "(\"" + key + "\")"; } + + private String convertKeyToNamingCase(String key, boolean camelCase) { + String newKey = key.toLowerCase(); + return camelCase ? convertKeyToCamelCase(newKey) : convertKeyToSnakeCase(newKey); + } + + private String convertKeyToCamelCase(String key) { + + + return CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, key); + } + + private String convertKeyToSnakeCase(String key) { + return CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_UNDERSCORE, key); + } } From 0c1710029ff84c8343750485aed351c78ce7c3f1 Mon Sep 17 00:00:00 2001 From: JPilson Date: Tue, 16 Apr 2024 20:33:57 +0200 Subject: [PATCH 2/9] feat: Add naming convention setting for presets Implemented a new setting, `getCaseFormat`, in the `ProjectSettings` interface, returning the naming convention used. Also extended corresponding implementations (`DefaultPreset`, `VueI18nPreset`, `ReactI18NextPreset`, `SettingsTestPreset`) to return `NamingConvention.CAMEL_CASE`. A new enum `NamingConvention` was created for this, with options `SNAKE_CASE` and `CAMEL_CASE`. --- .../easyi18n/settings/NamingConvention.java | 18 ++++++++++++++++++ .../easyi18n/settings/ProjectSettings.java | 2 ++ .../settings/presets/DefaultPreset.java | 6 ++++++ .../settings/presets/ReactI18NextPreset.java | 6 ++++++ .../settings/presets/VueI18nPreset.java | 6 ++++++ .../easyi18n/settings/SettingsTestPreset.java | 9 ++++++++- 6 files changed, 46 insertions(+), 1 deletion(-) create mode 100644 src/main/java/de/marhali/easyi18n/settings/NamingConvention.java diff --git a/src/main/java/de/marhali/easyi18n/settings/NamingConvention.java b/src/main/java/de/marhali/easyi18n/settings/NamingConvention.java new file mode 100644 index 0000000..9feaec5 --- /dev/null +++ b/src/main/java/de/marhali/easyi18n/settings/NamingConvention.java @@ -0,0 +1,18 @@ +package de.marhali.easyi18n.settings; + +import com.google.common.base.CaseFormat; + +public enum NamingConvention { + SNAKE_CASE("Snake"), + CAMEL_CASE("Camel"),; + private final String name; + + private NamingConvention(String name) { + this.name = name; + } + + @Override + public String toString() { + return super.name().toLowerCase(); + } +} diff --git a/src/main/java/de/marhali/easyi18n/settings/ProjectSettings.java b/src/main/java/de/marhali/easyi18n/settings/ProjectSettings.java index 019408a..fdf4e4b 100644 --- a/src/main/java/de/marhali/easyi18n/settings/ProjectSettings.java +++ b/src/main/java/de/marhali/easyi18n/settings/ProjectSettings.java @@ -1,5 +1,6 @@ package de.marhali.easyi18n.settings; +import com.google.common.base.CaseFormat; import de.marhali.easyi18n.io.parser.ParserStrategyType; import de.marhali.easyi18n.io.folder.FolderStrategyType; @@ -34,4 +35,5 @@ public interface ProjectSettings { // Experimental Configuration boolean isAlwaysFold(); String getFlavorTemplate(); + @NotNull NamingConvention getCaseFormat(); } diff --git a/src/main/java/de/marhali/easyi18n/settings/presets/DefaultPreset.java b/src/main/java/de/marhali/easyi18n/settings/presets/DefaultPreset.java index 383a5d3..c475019 100644 --- a/src/main/java/de/marhali/easyi18n/settings/presets/DefaultPreset.java +++ b/src/main/java/de/marhali/easyi18n/settings/presets/DefaultPreset.java @@ -2,6 +2,7 @@ package de.marhali.easyi18n.settings.presets; import de.marhali.easyi18n.io.parser.ParserStrategyType; import de.marhali.easyi18n.io.folder.FolderStrategyType; +import de.marhali.easyi18n.settings.NamingConvention; import de.marhali.easyi18n.settings.ProjectSettings; import org.jetbrains.annotations.NotNull; @@ -91,4 +92,9 @@ public class DefaultPreset implements ProjectSettings { public String getFlavorTemplate() { return "$i18n.t"; } + + @Override + public @NotNull NamingConvention getCaseFormat() { + return NamingConvention.CAMEL_CASE; + } } diff --git a/src/main/java/de/marhali/easyi18n/settings/presets/ReactI18NextPreset.java b/src/main/java/de/marhali/easyi18n/settings/presets/ReactI18NextPreset.java index 26c16b7..6d44310 100644 --- a/src/main/java/de/marhali/easyi18n/settings/presets/ReactI18NextPreset.java +++ b/src/main/java/de/marhali/easyi18n/settings/presets/ReactI18NextPreset.java @@ -1,7 +1,9 @@ package de.marhali.easyi18n.settings.presets; +import com.google.common.base.CaseFormat; import de.marhali.easyi18n.io.parser.ParserStrategyType; import de.marhali.easyi18n.io.folder.FolderStrategyType; +import de.marhali.easyi18n.settings.NamingConvention; import de.marhali.easyi18n.settings.ProjectSettings; import org.jetbrains.annotations.NotNull; @@ -91,4 +93,8 @@ public class ReactI18NextPreset implements ProjectSettings { public String getFlavorTemplate() { return "$i18n.t"; } + @Override + public @NotNull NamingConvention getCaseFormat() { + return NamingConvention.CAMEL_CASE; + } } diff --git a/src/main/java/de/marhali/easyi18n/settings/presets/VueI18nPreset.java b/src/main/java/de/marhali/easyi18n/settings/presets/VueI18nPreset.java index 491edf8..b720d75 100644 --- a/src/main/java/de/marhali/easyi18n/settings/presets/VueI18nPreset.java +++ b/src/main/java/de/marhali/easyi18n/settings/presets/VueI18nPreset.java @@ -2,6 +2,7 @@ package de.marhali.easyi18n.settings.presets; import de.marhali.easyi18n.io.parser.ParserStrategyType; import de.marhali.easyi18n.io.folder.FolderStrategyType; +import de.marhali.easyi18n.settings.NamingConvention; import de.marhali.easyi18n.settings.ProjectSettings; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -90,4 +91,9 @@ public class VueI18nPreset implements ProjectSettings { public String getFlavorTemplate() { return "$i18n.t"; } + + @Override + public @NotNull NamingConvention getCaseFormat() { + return NamingConvention.CAMEL_CASE; + } } diff --git a/src/test/java/de/marhali/easyi18n/settings/SettingsTestPreset.java b/src/test/java/de/marhali/easyi18n/settings/SettingsTestPreset.java index ab646ec..b76e185 100644 --- a/src/test/java/de/marhali/easyi18n/settings/SettingsTestPreset.java +++ b/src/test/java/de/marhali/easyi18n/settings/SettingsTestPreset.java @@ -1,5 +1,6 @@ package de.marhali.easyi18n.settings; +import com.google.common.base.CaseFormat; import de.marhali.easyi18n.io.folder.FolderStrategyType; import de.marhali.easyi18n.io.parser.ParserStrategyType; @@ -8,6 +9,7 @@ import org.jetbrains.annotations.Nullable; /** * Settings preset to test the functionality of the settings service. + * * @author marhali */ public class SettingsTestPreset implements ProjectSettings { @@ -88,6 +90,11 @@ public class SettingsTestPreset implements ProjectSettings { @Override public String getFlavorTemplate() { - return ""; + return "t"; + } + + @Override + public @NotNull NamingConvention getCaseFormat() { + return NamingConvention.CAMEL_CASE; } } From 667b7486148fa22f2147118f1335f902073383e2 Mon Sep 17 00:00:00 2001 From: JPilson Date: Tue, 16 Apr 2024 20:34:12 +0200 Subject: [PATCH 3/9] feat: Add key naming convention selection for extracted translations This update enables the user to specify a key naming convention (Camel Case or Snake Case) for extracted translations. This option is made available in the settings panel, and has been included in the project-specific configuration and state management for the project settings component. --- .../settings/ProjectSettingsComponent.java | 15 ++++ .../ProjectSettingsComponentState.java | 6 ++ .../settings/ProjectSettingsState.java | 70 ++++++++++++++----- src/main/resources/messages.properties | 4 ++ 4 files changed, 76 insertions(+), 19 deletions(-) diff --git a/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponent.java b/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponent.java index 2ed36e8..ef08742 100644 --- a/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponent.java +++ b/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponent.java @@ -1,5 +1,6 @@ package de.marhali.easyi18n.settings; +import com.google.common.base.CaseFormat; import com.intellij.ide.BrowserUtil; import com.intellij.openapi.fileChooser.FileChooserDescriptor; import com.intellij.openapi.project.Project; @@ -26,6 +27,7 @@ import java.util.ResourceBundle; /** * Configuration panel with all possible options for this plugin. + * * @author marhali */ public class ProjectSettingsComponent extends ProjectSettingsComponentState { @@ -64,7 +66,9 @@ public class ProjectSettingsComponent extends ProjectSettingsComponentState { .addVerticalGap(24) .addComponent(new TitledSeparator(bundle.getString("settings.experimental.title"))) .addComponent(constructAlwaysFoldField()) + .addVerticalGap(12) .addLabeledComponent(bundle.getString("settings.experimental.flavor-template"), constructFlavorTemplate(), 1, false) + .addLabeledComponent(bundle.getString("settings.experimental.key-naming-format.title"), constructKeyCaseFormater(), 1, false) .addComponentFillVertically(new JPanel(), 0) .getPanel(); } @@ -226,6 +230,17 @@ public class ProjectSettingsComponent extends ProjectSettingsComponentState { return flavorTemplate; } + private JComponent constructKeyCaseFormater() { + KeyCaseFormater = new ComboBox<>(bundle.getString("settings.experimental.key-naming-format.items").split(ArrayMapper.SPLITERATOR_REGEX)); + KeyCaseFormater.setToolTipText(bundle.getString("settings.experimental.key-naming-format.tooltip")); + KeyCaseFormater.setMinimumAndPreferredWidth(120); + KeyCaseFormater.addActionListener(e -> { + + }); + return KeyCaseFormater; + } + + private ItemListener handleParserChange() { return e -> { if (e.getStateChange() == ItemEvent.SELECTED) { diff --git a/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponentState.java b/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponentState.java index 0138a5c..a6eb5b8 100644 --- a/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponentState.java +++ b/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponentState.java @@ -1,5 +1,6 @@ package de.marhali.easyi18n.settings; +import com.google.common.base.CaseFormat; import com.intellij.openapi.ui.ComboBox; import com.intellij.openapi.ui.TextFieldWithBrowseButton; @@ -11,6 +12,7 @@ import javax.swing.*; /** * Mandatory for state management for the project settings component. + * * @author marhali */ public class ProjectSettingsComponentState { @@ -41,6 +43,7 @@ public class ProjectSettingsComponentState { protected JCheckBox alwaysFold; protected JTextField flavorTemplate; + protected ComboBox KeyCaseFormater; protected ProjectSettingsState getState() { // Every field needs to provide its state @@ -67,6 +70,8 @@ public class ProjectSettingsComponentState { state.setAlwaysFold(alwaysFold.isSelected()); state.setFlavorTemplate(flavorTemplate.getText()); + state.setCaseFormat(NamingConvention.valueOf(KeyCaseFormater.getSelectedItem().toString().replace("Case", "").trim())); + return state; } @@ -92,5 +97,6 @@ public class ProjectSettingsComponentState { alwaysFold.setSelected(state.isAlwaysFold()); flavorTemplate.setText(state.getFlavorTemplate()); + KeyCaseFormater.setSelectedItem(state.getCaseFormat().name()); } } diff --git a/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsState.java b/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsState.java index 4b9c064..38b033c 100644 --- a/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsState.java +++ b/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsState.java @@ -1,5 +1,6 @@ package de.marhali.easyi18n.settings; +import com.google.common.base.CaseFormat; import com.intellij.util.xmlb.annotations.Property; import de.marhali.easyi18n.io.parser.ParserStrategyType; @@ -13,32 +14,48 @@ import java.util.Objects; /** * Represents the project-specific configuration of this plugin. + * * @author marhali */ public class ProjectSettingsState implements ProjectSettings { // Resource Configuration - @Property private String localesDirectory; - @Property private FolderStrategyType folderStrategy; - @Property private ParserStrategyType parserStrategy; - @Property private String filePattern; + @Property + private String localesDirectory; + @Property + private FolderStrategyType folderStrategy; + @Property + private ParserStrategyType parserStrategy; + @Property + private String filePattern; - @Property private Boolean includeSubDirs; - @Property private boolean sorting; + @Property + private Boolean includeSubDirs; + @Property + private boolean sorting; // Editor configuration - @Property private String namespaceDelimiter; - @Property private String sectionDelimiter; - @Property private String contextDelimiter; - @Property private String pluralDelimiter; - @Property private String defaultNamespace; - @Property private String previewLocale; + @Property + private String namespaceDelimiter; + @Property + private String sectionDelimiter; + @Property + private String contextDelimiter; + @Property + private String pluralDelimiter; + @Property + private String defaultNamespace; + @Property + private String previewLocale; - @Property private Boolean nestedKeys; - @Property private Boolean assistance; + @Property + private Boolean nestedKeys; + @Property + private Boolean assistance; // Experimental configuration - @Property private Boolean alwaysFold; + @Property + private Boolean alwaysFold; /** * The `flavorTemplate` specifies the format used for replacing strings with their i18n (internationalization) counterparts. @@ -47,7 +64,10 @@ public class ProjectSettingsState implements ProjectSettings { * the specific framework or developers' preferences for handling i18n. The ability to dynamically change this template adds flexibility and customization * to cater to different i18n handling methods. */ - @Property private String flavorTemplate; + @Property + private String flavorTemplate; + @Property + private NamingConvention caseFormat; public ProjectSettingsState() { this(new DefaultPreset()); @@ -158,6 +178,11 @@ public class ProjectSettingsState implements ProjectSettings { return this.flavorTemplate; } + @Override + public @NotNull NamingConvention getCaseFormat() { + return this.caseFormat; + } + public void setLocalesDirectory(String localesDirectory) { this.localesDirectory = localesDirectory; } @@ -218,10 +243,15 @@ public class ProjectSettingsState implements ProjectSettings { this.alwaysFold = alwaysFold; } - public void setFlavorTemplate(String flavorTemplate){ + public void setFlavorTemplate(String flavorTemplate) { this.flavorTemplate = flavorTemplate; } + public void setCaseFormat(NamingConvention caseFormat) { + this.caseFormat = caseFormat; + } + + @Override public boolean equals(Object o) { if (this == o) return true; @@ -242,7 +272,8 @@ public class ProjectSettingsState implements ProjectSettings { && Objects.equals(nestedKeys, that.nestedKeys) && Objects.equals(assistance, that.assistance) && Objects.equals(alwaysFold, that.alwaysFold) - && Objects.equals(flavorTemplate,that.flavorTemplate); + && Objects.equals(flavorTemplate, that.flavorTemplate) + && Objects.equals(caseFormat, that.caseFormat); } @Override @@ -250,7 +281,7 @@ public class ProjectSettingsState implements ProjectSettings { return Objects.hash( localesDirectory, folderStrategy, parserStrategy, filePattern, includeSubDirs, sorting, namespaceDelimiter, sectionDelimiter, contextDelimiter, pluralDelimiter, - defaultNamespace, previewLocale, nestedKeys, assistance, alwaysFold,flavorTemplate + defaultNamespace, previewLocale, nestedKeys, assistance, alwaysFold, flavorTemplate, caseFormat ); } @@ -273,6 +304,7 @@ public class ProjectSettingsState implements ProjectSettings { ", assistance=" + assistance + ", alwaysFold=" + alwaysFold + ", flavorTemplate=" + flavorTemplate + + ", caseFormat=" + caseFormat.toString() + '}'; } } diff --git a/src/main/resources/messages.properties b/src/main/resources/messages.properties index 463b1bb..c5620d1 100644 --- a/src/main/resources/messages.properties +++ b/src/main/resources/messages.properties @@ -62,6 +62,10 @@ settings.experimental.always-fold.title=Always fold translation keys settings.experimental.always-fold.tooltip=Forces the editor to always display the value behind a translation key. The value cannot be unfolded when this function is active. settings.experimental.flavor-template =I18n flavor template settings.experimental.flavor-template-tooltip = Specify how to replace strings with i18n representation. +settings.experimental.key-naming-format.title=Key format of extracted translation +settings.experimental.key-naming-format.tooltip=Choose Naming Convention for the keys of extracted translation +settings.experimental.key-naming-format.items=Camel Case;Snake Case + error.io=An error occurred while processing translation files. \n\ Config: {0} => {1} ({2}) \n\ Path: {3} \n\ From b7b356308050c5166038d290c42401f6f3397156 Mon Sep 17 00:00:00 2001 From: JPilson Date: Thu, 18 Apr 2024 20:48:40 +0200 Subject: [PATCH 4/9] feat: Add case format to ProjectSettingsState and fromSelector method to NamingConvention This commit adds a new attribute, `caseFormat`, to the `ProjectSettingsState` class. It also introduces a static method `fromSelector` in the `NamingConvention` class to transform a string into a NamingConvention enum. The transformation in `ProjectSettingsComponentState` has been updated to use this new method. --- .../java/de/marhali/easyi18n/settings/NamingConvention.java | 4 ++++ .../easyi18n/settings/ProjectSettingsComponentState.java | 4 +++- .../de/marhali/easyi18n/settings/ProjectSettingsState.java | 1 + 3 files changed, 8 insertions(+), 1 deletion(-) diff --git a/src/main/java/de/marhali/easyi18n/settings/NamingConvention.java b/src/main/java/de/marhali/easyi18n/settings/NamingConvention.java index 9feaec5..5c21466 100644 --- a/src/main/java/de/marhali/easyi18n/settings/NamingConvention.java +++ b/src/main/java/de/marhali/easyi18n/settings/NamingConvention.java @@ -15,4 +15,8 @@ public enum NamingConvention { public String toString() { return super.name().toLowerCase(); } + static public NamingConvention fromSelector(String name) { + String formated = name.replace(" ","_"); + return valueOf(formated.toUpperCase()); + } } diff --git a/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponentState.java b/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponentState.java index a6eb5b8..e26bab4 100644 --- a/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponentState.java +++ b/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponentState.java @@ -9,6 +9,7 @@ import de.marhali.easyi18n.io.folder.FolderStrategyType; import de.marhali.easyi18n.settings.presets.Preset; import javax.swing.*; +import java.util.Objects; /** * Mandatory for state management for the project settings component. @@ -68,9 +69,10 @@ public class ProjectSettingsComponentState { state.setAssistance(assistance.isSelected()); state.setAlwaysFold(alwaysFold.isSelected()); + state.setFlavorTemplate(flavorTemplate.getText()); - state.setCaseFormat(NamingConvention.valueOf(KeyCaseFormater.getSelectedItem().toString().replace("Case", "").trim())); + state.setCaseFormat(NamingConvention.fromSelector(KeyCaseFormater.getSelectedItem().toString())); return state; } diff --git a/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsState.java b/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsState.java index 38b033c..93ad59b 100644 --- a/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsState.java +++ b/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsState.java @@ -95,6 +95,7 @@ public class ProjectSettingsState implements ProjectSettings { this.alwaysFold = defaults.isAlwaysFold(); this.flavorTemplate = defaults.getFlavorTemplate(); + this.caseFormat = defaults.getCaseFormat(); } @Override From f933ea91ebdf122cf962db44633c52f980e363b2 Mon Sep 17 00:00:00 2001 From: JPilson Date: Thu, 18 Apr 2024 21:03:15 +0200 Subject: [PATCH 5/9] feat: Add project-specific naming convention in LocalizeItAction Refactored convertKeyToNamingCase method to include project-specific naming conventions. Now, it adapts to the naming convention specified in the project settings. This change enhances flexibility by catering to individual project preferences. --- .../de/marhali/easyi18n/action/LocalizeItAction.java | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/main/java/de/marhali/easyi18n/action/LocalizeItAction.java b/src/main/java/de/marhali/easyi18n/action/LocalizeItAction.java index 8e456f7..1fe4fc9 100644 --- a/src/main/java/de/marhali/easyi18n/action/LocalizeItAction.java +++ b/src/main/java/de/marhali/easyi18n/action/LocalizeItAction.java @@ -11,6 +11,7 @@ import com.intellij.openapi.project.Project; import de.marhali.easyi18n.dialog.AddDialog; import de.marhali.easyi18n.model.KeyPath; +import de.marhali.easyi18n.settings.NamingConvention; import de.marhali.easyi18n.settings.ProjectSettingsService; import de.marhali.easyi18n.util.DocumentUtil; @@ -48,7 +49,7 @@ class LocalizeItAction extends AnAction { throw new RuntimeException("Project is null!"); } - AddDialog dialog = new AddDialog(project, new KeyPath(convertKeyToNamingCase(text, true)), text, (key) -> replaceSelectedText(project, editor, key)); + AddDialog dialog = new AddDialog(project, new KeyPath(convertKeyToNamingCase(text, project)), text, (key) -> replaceSelectedText(project, editor, key)); dialog.showAndHandle(); } @@ -82,9 +83,12 @@ class LocalizeItAction extends AnAction { return flavorTemplate + "(\"" + key + "\")"; } - private String convertKeyToNamingCase(String key, boolean camelCase) { + private String convertKeyToNamingCase(String key,Project project) { String newKey = key.toLowerCase(); - return camelCase ? convertKeyToCamelCase(newKey) : convertKeyToSnakeCase(newKey); + newKey = newKey.replaceAll("\\s+", "_"); + + NamingConvention namingConvention = ProjectSettingsService.get(project).getState().getCaseFormat(); + return (namingConvention == NamingConvention.CAMEL_CASE) ? convertKeyToCamelCase(newKey) : convertKeyToSnakeCase(newKey); } private String convertKeyToCamelCase(String key) { From 027016921faf5cb62858fe3e679e72bfd70ce33a Mon Sep 17 00:00:00 2001 From: JPilson Date: Sat, 20 Apr 2024 18:44:18 +0200 Subject: [PATCH 6/9] feat: update naming convention functionality Updated naming convention features by simplifying key case formatter construction and expanding the naming convention enum. Also performed a refactor to layout and formatting across various files for improved readability. Added new test cases to validate the update to naming convention. --- .../easyi18n/settings/NamingConvention.java | 24 ++++++++-- .../easyi18n/settings/ProjectSettings.java | 46 ++++++++++++++----- .../settings/ProjectSettingsComponent.java | 5 +- .../ProjectSettingsComponentState.java | 3 +- .../settings/ProjectSettingsState.java | 1 + .../easyi18n/KeyPathConverterTest.java | 6 +++ .../easyi18n/e2e/EndToEndTestCase.java | 8 ++-- .../easyi18n/mapper/PropertiesMapperTest.java | 7 +++ .../settings/ProjectSettingsServiceTest.java | 9 ++++ 9 files changed, 87 insertions(+), 22 deletions(-) diff --git a/src/main/java/de/marhali/easyi18n/settings/NamingConvention.java b/src/main/java/de/marhali/easyi18n/settings/NamingConvention.java index 5c21466..7fa9e16 100644 --- a/src/main/java/de/marhali/easyi18n/settings/NamingConvention.java +++ b/src/main/java/de/marhali/easyi18n/settings/NamingConvention.java @@ -2,21 +2,39 @@ package de.marhali.easyi18n.settings; import com.google.common.base.CaseFormat; +import java.util.Arrays; + public enum NamingConvention { - SNAKE_CASE("Snake"), - CAMEL_CASE("Camel"),; + SNAKE_CASE("Snake Case"), + + CAMEL_CASE("Camel Case"), + + CAMEL_CASE_UPPERCASE("Camel Case Uppercase"), + ; + private final String name; private NamingConvention(String name) { this.name = name; } + public String getName() { + return this.name; + } + @Override public String toString() { return super.name().toLowerCase(); } + static public NamingConvention fromSelector(String name) { - String formated = name.replace(" ","_"); + String formated = name.replace(" ", "_"); return valueOf(formated.toUpperCase()); } + + static public String[] getEnumNames() { + return Arrays.stream(NamingConvention.values()) + .map(NamingConvention::getName) + .toArray(String[]::new); + } } diff --git a/src/main/java/de/marhali/easyi18n/settings/ProjectSettings.java b/src/main/java/de/marhali/easyi18n/settings/ProjectSettings.java index fdf4e4b..626e672 100644 --- a/src/main/java/de/marhali/easyi18n/settings/ProjectSettings.java +++ b/src/main/java/de/marhali/easyi18n/settings/ProjectSettings.java @@ -9,31 +9,55 @@ import org.jetbrains.annotations.Nullable; /** * API to access the project-specific configuration for this plugin. + * * @author marhaliu */ public interface ProjectSettings { // Resource Configuration - @Nullable String getLocalesDirectory(); - @NotNull FolderStrategyType getFolderStrategy(); - @NotNull ParserStrategyType getParserStrategy(); - @NotNull String getFilePattern(); + @Nullable + String getLocalesDirectory(); + + @NotNull + FolderStrategyType getFolderStrategy(); + + @NotNull + ParserStrategyType getParserStrategy(); + + @NotNull + String getFilePattern(); boolean isIncludeSubDirs(); + boolean isSorting(); // Editor Configuration - @Nullable String getNamespaceDelimiter(); - @NotNull String getSectionDelimiter(); - @Nullable String getContextDelimiter(); - @Nullable String getPluralDelimiter(); - @Nullable String getDefaultNamespace(); - @NotNull String getPreviewLocale(); + @Nullable + String getNamespaceDelimiter(); + + @NotNull + String getSectionDelimiter(); + + @Nullable + String getContextDelimiter(); + + @Nullable + String getPluralDelimiter(); + + @Nullable + String getDefaultNamespace(); + + @NotNull + String getPreviewLocale(); boolean isNestedKeys(); + boolean isAssistance(); // Experimental Configuration boolean isAlwaysFold(); + String getFlavorTemplate(); - @NotNull NamingConvention getCaseFormat(); + + @NotNull + NamingConvention getCaseFormat(); } diff --git a/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponent.java b/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponent.java index ef08742..4041f83 100644 --- a/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponent.java +++ b/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponent.java @@ -231,12 +231,9 @@ public class ProjectSettingsComponent extends ProjectSettingsComponentState { } private JComponent constructKeyCaseFormater() { - KeyCaseFormater = new ComboBox<>(bundle.getString("settings.experimental.key-naming-format.items").split(ArrayMapper.SPLITERATOR_REGEX)); + KeyCaseFormater = new ComboBox<>(NamingConvention.getEnumNames()); KeyCaseFormater.setToolTipText(bundle.getString("settings.experimental.key-naming-format.tooltip")); KeyCaseFormater.setMinimumAndPreferredWidth(120); - KeyCaseFormater.addActionListener(e -> { - - }); return KeyCaseFormater; } diff --git a/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponentState.java b/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponentState.java index e26bab4..a98a947 100644 --- a/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponentState.java +++ b/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponentState.java @@ -99,6 +99,7 @@ public class ProjectSettingsComponentState { alwaysFold.setSelected(state.isAlwaysFold()); flavorTemplate.setText(state.getFlavorTemplate()); - KeyCaseFormater.setSelectedItem(state.getCaseFormat().name()); + KeyCaseFormater.setSelectedItem(state.getCaseFormat().getName()); } + } diff --git a/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsState.java b/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsState.java index 93ad59b..49cd0d1 100644 --- a/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsState.java +++ b/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsState.java @@ -66,6 +66,7 @@ public class ProjectSettingsState implements ProjectSettings { */ @Property private String flavorTemplate; + @Property private NamingConvention caseFormat; diff --git a/src/test/java/de/marhali/easyi18n/KeyPathConverterTest.java b/src/test/java/de/marhali/easyi18n/KeyPathConverterTest.java index b84d2cb..c023815 100644 --- a/src/test/java/de/marhali/easyi18n/KeyPathConverterTest.java +++ b/src/test/java/de/marhali/easyi18n/KeyPathConverterTest.java @@ -3,6 +3,7 @@ package de.marhali.easyi18n; import de.marhali.easyi18n.io.parser.ParserStrategyType; import de.marhali.easyi18n.io.folder.FolderStrategyType; import de.marhali.easyi18n.model.KeyPath; +import de.marhali.easyi18n.settings.NamingConvention; import de.marhali.easyi18n.settings.ProjectSettings; import de.marhali.easyi18n.util.KeyPathConverter; @@ -172,6 +173,11 @@ public class KeyPathConverterTest { public boolean isIncludeSubDirs() { return false; } + + @Override + public @NotNull NamingConvention getCaseFormat() { + return NamingConvention.CAMEL_CASE; + } }); } } diff --git a/src/test/java/de/marhali/easyi18n/e2e/EndToEndTestCase.java b/src/test/java/de/marhali/easyi18n/e2e/EndToEndTestCase.java index 7a58781..74ebca5 100644 --- a/src/test/java/de/marhali/easyi18n/e2e/EndToEndTestCase.java +++ b/src/test/java/de/marhali/easyi18n/e2e/EndToEndTestCase.java @@ -22,6 +22,7 @@ import java.util.Objects; /** * End-to-end test case. + * * @author marhali */ public abstract class EndToEndTestCase extends BasePlatformTestCase { @@ -57,7 +58,8 @@ public abstract class EndToEndTestCase extends BasePlatformTestCase { out.setLocalesDirectory(tempPath.toString()); ProjectSettingsService.get(getProject()).setState(out); - InstanceManager.get(getProject()).store().saveToPersistenceLayer(success -> {}); + InstanceManager.get(getProject()).store().saveToPersistenceLayer(success -> { + }); // Compare file structure and contents IOFileFilter fileFilter = TrueFileFilter.INSTANCE; @@ -73,7 +75,7 @@ public abstract class EndToEndTestCase extends BasePlatformTestCase { assertEquals(originalFiles.length, outputFiles.length); - for(int i = 0; i < originalFiles.length; i++) { + for (int i = 0; i < originalFiles.length; i++) { File originalFile = originalFiles[i]; File outputFile = outputFiles[i]; @@ -82,4 +84,4 @@ public abstract class EndToEndTestCase extends BasePlatformTestCase { FileUtils.readFileToString(outputFile, CHARSET)); } } -} +} \ No newline at end of file diff --git a/src/test/java/de/marhali/easyi18n/mapper/PropertiesMapperTest.java b/src/test/java/de/marhali/easyi18n/mapper/PropertiesMapperTest.java index 71bf2e1..f29b486 100644 --- a/src/test/java/de/marhali/easyi18n/mapper/PropertiesMapperTest.java +++ b/src/test/java/de/marhali/easyi18n/mapper/PropertiesMapperTest.java @@ -7,6 +7,7 @@ import de.marhali.easyi18n.io.parser.properties.PropertiesMapper; import de.marhali.easyi18n.io.parser.properties.SortableProperties; import de.marhali.easyi18n.model.TranslationData; import de.marhali.easyi18n.model.KeyPath; +import de.marhali.easyi18n.settings.NamingConvention; import de.marhali.easyi18n.settings.ProjectSettings; import de.marhali.easyi18n.util.KeyPathConverter; @@ -19,6 +20,7 @@ import java.util.*; /** * Unit tests for {@link PropertiesMapper}. + * * @author marhali */ public class PropertiesMapperTest extends AbstractMapperTest { @@ -245,6 +247,11 @@ public class PropertiesMapperTest extends AbstractMapperTest { public boolean isIncludeSubDirs() { return false; } + + @Override + public @NotNull NamingConvention getCaseFormat() { + return NamingConvention.CAMEL_CASE; + } }); } } \ No newline at end of file diff --git a/src/test/java/de/marhali/easyi18n/settings/ProjectSettingsServiceTest.java b/src/test/java/de/marhali/easyi18n/settings/ProjectSettingsServiceTest.java index 5ccc4f9..d82e06d 100644 --- a/src/test/java/de/marhali/easyi18n/settings/ProjectSettingsServiceTest.java +++ b/src/test/java/de/marhali/easyi18n/settings/ProjectSettingsServiceTest.java @@ -7,6 +7,7 @@ import de.marhali.easyi18n.settings.presets.DefaultPreset; /** * Tests for the project settings service itself. + * * @author marhali */ public class ProjectSettingsServiceTest extends BasePlatformTestCase { @@ -35,4 +36,12 @@ public class ProjectSettingsServiceTest extends BasePlatformTestCase { ProjectSettingsState after = XmlSerializerUtil.createCopy(previous); assertEquals("mySinglePropTest", after.getLocalesDirectory()); } + + public void testPersistenceFormatCase() { + ProjectSettingsState previous = new ProjectSettingsState(); + assertEquals(previous.getCaseFormat(), NamingConvention.CAMEL_CASE); + previous.setCaseFormat(NamingConvention.SNAKE_CASE); + ProjectSettingsState after = XmlSerializerUtil.createCopy(previous); + assertEquals(after.getCaseFormat(), NamingConvention.SNAKE_CASE); + } } From 4c737e25faa5a22adbc1d198f6002a1f0a730a38 Mon Sep 17 00:00:00 2001 From: JPilson Date: Sat, 20 Apr 2024 19:28:16 +0200 Subject: [PATCH 7/9] refactor: streamline key naming convention conversion Moved key naming convention conversion logic into NamingConvention enum. This simplifies the code in LocalizeItAction and makes the conversion function easily reusable. Also added support for uppercase snake and camel cases. --- .../easyi18n/action/LocalizeItAction.java | 17 ++--------- .../easyi18n/settings/NamingConvention.java | 30 ++++++++++++++++--- 2 files changed, 28 insertions(+), 19 deletions(-) diff --git a/src/main/java/de/marhali/easyi18n/action/LocalizeItAction.java b/src/main/java/de/marhali/easyi18n/action/LocalizeItAction.java index 1fe4fc9..e4b75ee 100644 --- a/src/main/java/de/marhali/easyi18n/action/LocalizeItAction.java +++ b/src/main/java/de/marhali/easyi18n/action/LocalizeItAction.java @@ -83,21 +83,8 @@ class LocalizeItAction extends AnAction { return flavorTemplate + "(\"" + key + "\")"; } - private String convertKeyToNamingCase(String key,Project project) { - String newKey = key.toLowerCase(); - newKey = newKey.replaceAll("\\s+", "_"); - - NamingConvention namingConvention = ProjectSettingsService.get(project).getState().getCaseFormat(); - return (namingConvention == NamingConvention.CAMEL_CASE) ? convertKeyToCamelCase(newKey) : convertKeyToSnakeCase(newKey); + private String convertKeyToNamingCase(String key, Project project) { + return NamingConvention.convertKeyToConvention(key, ProjectSettingsService.get(project).getState().getCaseFormat()); } - private String convertKeyToCamelCase(String key) { - - - return CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, key); - } - - private String convertKeyToSnakeCase(String key) { - return CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_UNDERSCORE, key); - } } diff --git a/src/main/java/de/marhali/easyi18n/settings/NamingConvention.java b/src/main/java/de/marhali/easyi18n/settings/NamingConvention.java index 7fa9e16..e9a94ad 100644 --- a/src/main/java/de/marhali/easyi18n/settings/NamingConvention.java +++ b/src/main/java/de/marhali/easyi18n/settings/NamingConvention.java @@ -5,12 +5,10 @@ import com.google.common.base.CaseFormat; import java.util.Arrays; public enum NamingConvention { - SNAKE_CASE("Snake Case"), - CAMEL_CASE("Camel Case"), - CAMEL_CASE_UPPERCASE("Camel Case Uppercase"), - ; + SNAKE_CASE("Snake Case"), + SNAKE_CASE_UPPERCASE("Snake Case Uppercase"); private final String name; @@ -37,4 +35,28 @@ public enum NamingConvention { .map(NamingConvention::getName) .toArray(String[]::new); } + + static public String convertKeyToConvention(String key, NamingConvention convention) { + String newKey = key.toLowerCase(); + newKey = newKey.replaceAll("\\s+", "_"); + return switch (convention) { + case SNAKE_CASE: + yield formatToSnakeCase(newKey, false); + case SNAKE_CASE_UPPERCASE: + yield formatToSnakeCase(newKey, true); + case CAMEL_CASE: + yield formatToCamelCase(newKey, false); + case CAMEL_CASE_UPPERCASE: + yield formatToCamelCase(newKey, true); + + }; + } + + static private String formatToCamelCase(String key, boolean capitalized) { + return CaseFormat.LOWER_UNDERSCORE.to(capitalized ? CaseFormat.UPPER_CAMEL : CaseFormat.LOWER_CAMEL, key); + } + + static private String formatToSnakeCase(String key, boolean capitalized) { + return CaseFormat.LOWER_UNDERSCORE.to(capitalized ? CaseFormat.UPPER_UNDERSCORE : CaseFormat.LOWER_UNDERSCORE, key); + } } From 340ab134e52eaf16577e65c28bbf585f95628ad4 Mon Sep 17 00:00:00 2001 From: JPilson Date: Sun, 21 Apr 2024 10:15:32 +0200 Subject: [PATCH 8/9] feat: Move NamingConvention to presets package Moved `NamingConvention` from the settings package to a new settings.presets package. This involved modifying various import statements across the application and updating methods that utilised this enum. Increased the `KeyCaseFormater` minimum and preferred width to 200 for better UI rendering. --- .../easyi18n/action/LocalizeItAction.java | 11 +++-- .../easyi18n/settings/ProjectSettings.java | 2 +- .../settings/ProjectSettingsComponent.java | 4 +- .../ProjectSettingsComponentState.java | 5 +-- .../settings/ProjectSettingsState.java | 2 +- .../settings/presets/DefaultPreset.java | 1 - .../{ => presets}/NamingConvention.java | 42 ++++++++++++++++--- .../settings/presets/ReactI18NextPreset.java | 2 - .../settings/presets/VueI18nPreset.java | 1 - src/main/resources/messages.properties | 1 - .../easyi18n/KeyPathConverterTest.java | 2 +- .../easyi18n/mapper/PropertiesMapperTest.java | 2 +- .../settings/ProjectSettingsServiceTest.java | 1 + .../easyi18n/settings/SettingsTestPreset.java | 2 +- 14 files changed, 54 insertions(+), 24 deletions(-) rename src/main/java/de/marhali/easyi18n/settings/{ => presets}/NamingConvention.java (54%) diff --git a/src/main/java/de/marhali/easyi18n/action/LocalizeItAction.java b/src/main/java/de/marhali/easyi18n/action/LocalizeItAction.java index e4b75ee..b55e7ef 100644 --- a/src/main/java/de/marhali/easyi18n/action/LocalizeItAction.java +++ b/src/main/java/de/marhali/easyi18n/action/LocalizeItAction.java @@ -1,6 +1,5 @@ package de.marhali.easyi18n.action; -import com.google.common.base.CaseFormat; import com.intellij.openapi.actionSystem.AnAction; import com.intellij.openapi.actionSystem.AnActionEvent; import com.intellij.openapi.actionSystem.CommonDataKeys; @@ -11,7 +10,7 @@ import com.intellij.openapi.project.Project; import de.marhali.easyi18n.dialog.AddDialog; import de.marhali.easyi18n.model.KeyPath; -import de.marhali.easyi18n.settings.NamingConvention; +import de.marhali.easyi18n.settings.presets.NamingConvention; import de.marhali.easyi18n.settings.ProjectSettingsService; import de.marhali.easyi18n.util.DocumentUtil; @@ -79,10 +78,16 @@ class LocalizeItAction extends AnAction { */ private String buildReplacement(String flavorTemplate, String key, DocumentUtil documentUtil) { if (documentUtil.isVue() || documentUtil.isJsOrTs()) return flavorTemplate + "('" + key + "')"; - return flavorTemplate + "(\"" + key + "\")"; } + /** + * Converts a given key to the specified naming convention. + * + * @param key the key to convert + * @param project the project where the key is being converted + * @return the converted key + */ private String convertKeyToNamingCase(String key, Project project) { return NamingConvention.convertKeyToConvention(key, ProjectSettingsService.get(project).getState().getCaseFormat()); } diff --git a/src/main/java/de/marhali/easyi18n/settings/ProjectSettings.java b/src/main/java/de/marhali/easyi18n/settings/ProjectSettings.java index 626e672..eee6c5b 100644 --- a/src/main/java/de/marhali/easyi18n/settings/ProjectSettings.java +++ b/src/main/java/de/marhali/easyi18n/settings/ProjectSettings.java @@ -1,9 +1,9 @@ package de.marhali.easyi18n.settings; -import com.google.common.base.CaseFormat; import de.marhali.easyi18n.io.parser.ParserStrategyType; import de.marhali.easyi18n.io.folder.FolderStrategyType; +import de.marhali.easyi18n.settings.presets.NamingConvention; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; diff --git a/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponent.java b/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponent.java index 4041f83..14b633a 100644 --- a/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponent.java +++ b/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponent.java @@ -1,6 +1,5 @@ package de.marhali.easyi18n.settings; -import com.google.common.base.CaseFormat; import com.intellij.ide.BrowserUtil; import com.intellij.openapi.fileChooser.FileChooserDescriptor; import com.intellij.openapi.project.Project; @@ -14,6 +13,7 @@ import com.intellij.util.ui.FormBuilder; import de.marhali.easyi18n.io.parser.ArrayMapper; import de.marhali.easyi18n.io.parser.ParserStrategyType; +import de.marhali.easyi18n.settings.presets.NamingConvention; import de.marhali.easyi18n.settings.presets.Preset; import javax.swing.*; @@ -233,7 +233,7 @@ public class ProjectSettingsComponent extends ProjectSettingsComponentState { private JComponent constructKeyCaseFormater() { KeyCaseFormater = new ComboBox<>(NamingConvention.getEnumNames()); KeyCaseFormater.setToolTipText(bundle.getString("settings.experimental.key-naming-format.tooltip")); - KeyCaseFormater.setMinimumAndPreferredWidth(120); + KeyCaseFormater.setMinimumAndPreferredWidth(200); return KeyCaseFormater; } diff --git a/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponentState.java b/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponentState.java index a98a947..c32be62 100644 --- a/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponentState.java +++ b/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsComponentState.java @@ -1,15 +1,14 @@ package de.marhali.easyi18n.settings; -import com.google.common.base.CaseFormat; import com.intellij.openapi.ui.ComboBox; import com.intellij.openapi.ui.TextFieldWithBrowseButton; import de.marhali.easyi18n.io.parser.ParserStrategyType; import de.marhali.easyi18n.io.folder.FolderStrategyType; +import de.marhali.easyi18n.settings.presets.NamingConvention; import de.marhali.easyi18n.settings.presets.Preset; import javax.swing.*; -import java.util.Objects; /** * Mandatory for state management for the project settings component. @@ -72,7 +71,7 @@ public class ProjectSettingsComponentState { state.setFlavorTemplate(flavorTemplate.getText()); - state.setCaseFormat(NamingConvention.fromSelector(KeyCaseFormater.getSelectedItem().toString())); + state.setCaseFormat(NamingConvention.fromString(KeyCaseFormater.getSelectedItem().toString())); return state; } diff --git a/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsState.java b/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsState.java index 49cd0d1..d9b159d 100644 --- a/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsState.java +++ b/src/main/java/de/marhali/easyi18n/settings/ProjectSettingsState.java @@ -1,12 +1,12 @@ package de.marhali.easyi18n.settings; -import com.google.common.base.CaseFormat; import com.intellij.util.xmlb.annotations.Property; import de.marhali.easyi18n.io.parser.ParserStrategyType; import de.marhali.easyi18n.io.folder.FolderStrategyType; import de.marhali.easyi18n.settings.presets.DefaultPreset; +import de.marhali.easyi18n.settings.presets.NamingConvention; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; diff --git a/src/main/java/de/marhali/easyi18n/settings/presets/DefaultPreset.java b/src/main/java/de/marhali/easyi18n/settings/presets/DefaultPreset.java index c475019..73f0da0 100644 --- a/src/main/java/de/marhali/easyi18n/settings/presets/DefaultPreset.java +++ b/src/main/java/de/marhali/easyi18n/settings/presets/DefaultPreset.java @@ -2,7 +2,6 @@ package de.marhali.easyi18n.settings.presets; import de.marhali.easyi18n.io.parser.ParserStrategyType; import de.marhali.easyi18n.io.folder.FolderStrategyType; -import de.marhali.easyi18n.settings.NamingConvention; import de.marhali.easyi18n.settings.ProjectSettings; import org.jetbrains.annotations.NotNull; diff --git a/src/main/java/de/marhali/easyi18n/settings/NamingConvention.java b/src/main/java/de/marhali/easyi18n/settings/presets/NamingConvention.java similarity index 54% rename from src/main/java/de/marhali/easyi18n/settings/NamingConvention.java rename to src/main/java/de/marhali/easyi18n/settings/presets/NamingConvention.java index e9a94ad..48db48a 100644 --- a/src/main/java/de/marhali/easyi18n/settings/NamingConvention.java +++ b/src/main/java/de/marhali/easyi18n/settings/presets/NamingConvention.java @@ -1,14 +1,18 @@ -package de.marhali.easyi18n.settings; +package de.marhali.easyi18n.settings.presets; import com.google.common.base.CaseFormat; import java.util.Arrays; +/** + * Enum representing different naming conventions. + * Provides utility methods to convert keys to the specified convention. + */ public enum NamingConvention { CAMEL_CASE("Camel Case"), - CAMEL_CASE_UPPERCASE("Camel Case Uppercase"), + CAMEL_CASE_UPPERCASE("Camel Case (Uppercase)"), SNAKE_CASE("Snake Case"), - SNAKE_CASE_UPPERCASE("Snake Case Uppercase"); + SNAKE_CASE_UPPERCASE("Snake Case (Uppercase)"); private final String name; @@ -16,6 +20,11 @@ public enum NamingConvention { this.name = name; } + /** + * Retrieves the name of the current instance of the class. + * + * @return the name of the current instance + */ public String getName() { return this.name; } @@ -25,17 +34,38 @@ public enum NamingConvention { return super.name().toLowerCase(); } - static public NamingConvention fromSelector(String name) { - String formated = name.replace(" ", "_"); - return valueOf(formated.toUpperCase()); + /** + * Converts a string representation of a naming convention to the corresponding NamingConvention enum value. + * + * @param name the string representation of the naming convention + * @return the corresponding NamingConvention enum value + */ + static public NamingConvention fromString(String name) { + for (NamingConvention value : NamingConvention.values()) { + if (value.getName().equals(name)) + return value; + } + return NamingConvention.CAMEL_CASE; } + /** + * Returns an array of strings representing the names of the enum values in the {@link NamingConvention} enum. + * + * @return an array of strings representing the enum names + */ static public String[] getEnumNames() { return Arrays.stream(NamingConvention.values()) .map(NamingConvention::getName) .toArray(String[]::new); } + /** + * Converts a given key to the specified naming convention. + * + * @param key the key to convert + * @param convention the naming convention to convert the key to + * @return the converted key + */ static public String convertKeyToConvention(String key, NamingConvention convention) { String newKey = key.toLowerCase(); newKey = newKey.replaceAll("\\s+", "_"); diff --git a/src/main/java/de/marhali/easyi18n/settings/presets/ReactI18NextPreset.java b/src/main/java/de/marhali/easyi18n/settings/presets/ReactI18NextPreset.java index 6d44310..5f2fff2 100644 --- a/src/main/java/de/marhali/easyi18n/settings/presets/ReactI18NextPreset.java +++ b/src/main/java/de/marhali/easyi18n/settings/presets/ReactI18NextPreset.java @@ -1,9 +1,7 @@ package de.marhali.easyi18n.settings.presets; -import com.google.common.base.CaseFormat; import de.marhali.easyi18n.io.parser.ParserStrategyType; import de.marhali.easyi18n.io.folder.FolderStrategyType; -import de.marhali.easyi18n.settings.NamingConvention; import de.marhali.easyi18n.settings.ProjectSettings; import org.jetbrains.annotations.NotNull; diff --git a/src/main/java/de/marhali/easyi18n/settings/presets/VueI18nPreset.java b/src/main/java/de/marhali/easyi18n/settings/presets/VueI18nPreset.java index b720d75..053ed51 100644 --- a/src/main/java/de/marhali/easyi18n/settings/presets/VueI18nPreset.java +++ b/src/main/java/de/marhali/easyi18n/settings/presets/VueI18nPreset.java @@ -2,7 +2,6 @@ package de.marhali.easyi18n.settings.presets; import de.marhali.easyi18n.io.parser.ParserStrategyType; import de.marhali.easyi18n.io.folder.FolderStrategyType; -import de.marhali.easyi18n.settings.NamingConvention; import de.marhali.easyi18n.settings.ProjectSettings; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; diff --git a/src/main/resources/messages.properties b/src/main/resources/messages.properties index c5620d1..2f8bbb5 100644 --- a/src/main/resources/messages.properties +++ b/src/main/resources/messages.properties @@ -64,7 +64,6 @@ settings.experimental.flavor-template =I18n flavor template settings.experimental.flavor-template-tooltip = Specify how to replace strings with i18n representation. settings.experimental.key-naming-format.title=Key format of extracted translation settings.experimental.key-naming-format.tooltip=Choose Naming Convention for the keys of extracted translation -settings.experimental.key-naming-format.items=Camel Case;Snake Case error.io=An error occurred while processing translation files. \n\ Config: {0} => {1} ({2}) \n\ diff --git a/src/test/java/de/marhali/easyi18n/KeyPathConverterTest.java b/src/test/java/de/marhali/easyi18n/KeyPathConverterTest.java index c023815..8f92bd9 100644 --- a/src/test/java/de/marhali/easyi18n/KeyPathConverterTest.java +++ b/src/test/java/de/marhali/easyi18n/KeyPathConverterTest.java @@ -3,7 +3,7 @@ package de.marhali.easyi18n; import de.marhali.easyi18n.io.parser.ParserStrategyType; import de.marhali.easyi18n.io.folder.FolderStrategyType; import de.marhali.easyi18n.model.KeyPath; -import de.marhali.easyi18n.settings.NamingConvention; +import de.marhali.easyi18n.settings.presets.NamingConvention; import de.marhali.easyi18n.settings.ProjectSettings; import de.marhali.easyi18n.util.KeyPathConverter; diff --git a/src/test/java/de/marhali/easyi18n/mapper/PropertiesMapperTest.java b/src/test/java/de/marhali/easyi18n/mapper/PropertiesMapperTest.java index f29b486..00cdd5c 100644 --- a/src/test/java/de/marhali/easyi18n/mapper/PropertiesMapperTest.java +++ b/src/test/java/de/marhali/easyi18n/mapper/PropertiesMapperTest.java @@ -7,7 +7,7 @@ import de.marhali.easyi18n.io.parser.properties.PropertiesMapper; import de.marhali.easyi18n.io.parser.properties.SortableProperties; import de.marhali.easyi18n.model.TranslationData; import de.marhali.easyi18n.model.KeyPath; -import de.marhali.easyi18n.settings.NamingConvention; +import de.marhali.easyi18n.settings.presets.NamingConvention; import de.marhali.easyi18n.settings.ProjectSettings; import de.marhali.easyi18n.util.KeyPathConverter; diff --git a/src/test/java/de/marhali/easyi18n/settings/ProjectSettingsServiceTest.java b/src/test/java/de/marhali/easyi18n/settings/ProjectSettingsServiceTest.java index d82e06d..cc8d850 100644 --- a/src/test/java/de/marhali/easyi18n/settings/ProjectSettingsServiceTest.java +++ b/src/test/java/de/marhali/easyi18n/settings/ProjectSettingsServiceTest.java @@ -4,6 +4,7 @@ import com.intellij.testFramework.fixtures.BasePlatformTestCase; import com.intellij.util.xmlb.XmlSerializerUtil; import de.marhali.easyi18n.settings.presets.DefaultPreset; +import de.marhali.easyi18n.settings.presets.NamingConvention; /** * Tests for the project settings service itself. diff --git a/src/test/java/de/marhali/easyi18n/settings/SettingsTestPreset.java b/src/test/java/de/marhali/easyi18n/settings/SettingsTestPreset.java index b76e185..8b03a75 100644 --- a/src/test/java/de/marhali/easyi18n/settings/SettingsTestPreset.java +++ b/src/test/java/de/marhali/easyi18n/settings/SettingsTestPreset.java @@ -1,9 +1,9 @@ package de.marhali.easyi18n.settings; -import com.google.common.base.CaseFormat; import de.marhali.easyi18n.io.folder.FolderStrategyType; import de.marhali.easyi18n.io.parser.ParserStrategyType; +import de.marhali.easyi18n.settings.presets.NamingConvention; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; From 45834046dde555e9ebd1f857086134b62406403a Mon Sep 17 00:00:00 2001 From: JPilson Date: Sun, 21 Apr 2024 11:09:20 +0200 Subject: [PATCH 9/9] feat: Replace Camel case uppercase with Pascal case The main modification is in `NamingConvention.java` replacing the enumeration `CAMEL_CASE_UPPERCASE` with `PASCAL_CASE`. This change can help to improve the readability of the code by reducing the verbosity of names and ensure convention consistency. Also, a new test file `NamingConventionTest.java` has been introduced to ensure correctness and stability of the code against these modifications. --- .../settings/presets/NamingConvention.java | 4 +-- .../settings/NamingConventionTest.java | 35 +++++++++++++++++++ 2 files changed, 37 insertions(+), 2 deletions(-) create mode 100644 src/test/java/de/marhali/easyi18n/settings/NamingConventionTest.java diff --git a/src/main/java/de/marhali/easyi18n/settings/presets/NamingConvention.java b/src/main/java/de/marhali/easyi18n/settings/presets/NamingConvention.java index 48db48a..71aa619 100644 --- a/src/main/java/de/marhali/easyi18n/settings/presets/NamingConvention.java +++ b/src/main/java/de/marhali/easyi18n/settings/presets/NamingConvention.java @@ -10,7 +10,7 @@ import java.util.Arrays; */ public enum NamingConvention { CAMEL_CASE("Camel Case"), - CAMEL_CASE_UPPERCASE("Camel Case (Uppercase)"), + PASCAL_CASE("Pascal Case"), SNAKE_CASE("Snake Case"), SNAKE_CASE_UPPERCASE("Snake Case (Uppercase)"); @@ -76,7 +76,7 @@ public enum NamingConvention { yield formatToSnakeCase(newKey, true); case CAMEL_CASE: yield formatToCamelCase(newKey, false); - case CAMEL_CASE_UPPERCASE: + case PASCAL_CASE: yield formatToCamelCase(newKey, true); }; diff --git a/src/test/java/de/marhali/easyi18n/settings/NamingConventionTest.java b/src/test/java/de/marhali/easyi18n/settings/NamingConventionTest.java new file mode 100644 index 0000000..72e0d3d --- /dev/null +++ b/src/test/java/de/marhali/easyi18n/settings/NamingConventionTest.java @@ -0,0 +1,35 @@ +package de.marhali.easyi18n.settings; + +import com.intellij.testFramework.fixtures.BasePlatformTestCase; +import de.marhali.easyi18n.settings.presets.NamingConvention; + +import java.io.IOException; + +public class NamingConventionTest extends BasePlatformTestCase { + @Override + protected void setUp() throws Exception { + super.setUp(); + } + + public void testConvertToNamingConvention() throws IOException { + assertEquals("helloWorld", NamingConvention.convertKeyToConvention("Hello World", NamingConvention.CAMEL_CASE)); + assertEquals("hello_world", NamingConvention.convertKeyToConvention("Hello World", NamingConvention.SNAKE_CASE)); + assertEquals("HelloWorld", NamingConvention.convertKeyToConvention("Hello World", NamingConvention.PASCAL_CASE)); + assertEquals("HELLO_WORLD", NamingConvention.convertKeyToConvention("Hello World", NamingConvention.SNAKE_CASE_UPPERCASE)); + } + + public void testGetEnumNames() throws Exception { + String[] expected = {"Camel Case", "Pascal Case", "Snake Case", "Snake Case (Uppercase)"}; + String[] actual = NamingConvention.getEnumNames(); + assertEquals(expected.length, actual.length); + } + + + public void testFromString() { + assertEquals(NamingConvention.CAMEL_CASE, NamingConvention.fromString("Camel Case")); + assertEquals(NamingConvention.PASCAL_CASE, NamingConvention.fromString("Pascal Case")); + assertEquals(NamingConvention.SNAKE_CASE, NamingConvention.fromString("Snake Case")); + assertEquals(NamingConvention.SNAKE_CASE_UPPERCASE, NamingConvention.fromString("Snake Case (Uppercase)")); + assertEquals(NamingConvention.CAMEL_CASE, NamingConvention.fromString("Invalid Input")); + } +}