Globalyzer 6.8 Release Notes

The 6.8.0 release provides the following new features:

• Support for SAML/SSO: The Globalyzer Server can now be configured with SAML/SSO, in addition to LDAP. This allows seamless integration with third party identity providers.
• Support for Command Center: Command Center is a new Lingoport product that communicates with the Globalyzer Server.

The 6.7.0 release includes many system upgrades and requires JDK 11:

• You can download from OpenLogic https://www.openlogic.com/openjdk-downloads
• Set JAVA_HOME to JDK 11
• Also: password encryption changed, so you will be prompted to log in the first time after installing

The 6.6.0 release provides the following new features:

• Go Rule Set: Globalyzer now provides a go rule set to scan go language code, and supports go string externalization to json resource files.
• Locale-Sensitive Method Priority Updates for JavaScript and CSharp Rule Sets: To streamline your internationalization work, we have updated the default priority settings for JavaScript and C# locale-sensitive methods, setting the methods that are most likely to be issues, to priority 1 or 2.

The 6.5.0 release provides the following new features:

• Python Rule Set: Globalyzer now provides a python3 rule set to scan python code, and supports python string externalization to either po or properties resource files.

The 6.4.1 release involves the Globalyzer Client only (not the Globalyzer Server). This release provides the following enhancements, along with minor bug fixes:

• Compressed Prediction Report: The prediction report for a scan can become quite large. The generated report is now a zip file, making it easier to check in to version control.
• Improved Scanning of jsx Files: Jsx files are a mixture of JavaScript and HTML. They are now scanned, by default, by both our JavaScript and HTML rule sets. Also, HTML scanning of these files has been greatly improved.
• Improved Scanning of TypeScript Files: The JavaScript rule set has been enhanced to scan ts files. Tsx files (a mixture of TypeScript and HTML), are also scanned by default by both JavaScript and HTML rule sets.

The 6.4.0 release provides the following new features:

• Method Statement Filters: These new filters are similar to Method Line Filters, except they apply to a programming language statement, as opposed to a line of code. If Globalyzer detects a Locale-Sensitive Method, and within the same statement finds a Method Statement Filter, that method will be excluded from the Locale-Sensitive Method Scan Results.
• Modified order of Embedded String Filtering and Retention Rules: Prior to this release, the Embedded String scan would first find all strings, then apply all Filtering rules, followed by all Retention rules. We have found that interleaving Filtering and Retention rules generates better results. We now apply specific filters and patterns before more general filters and patterns. For example, a string might be a parameter to a method that is in a line that is part of a statement. So, if you defined a String Method Pattern to retain an issue, but you have a String Statement Filter that filters the statement, the issue will ultimately be filtered since the more general, String Statement Filter, is applied last.

The 6.3.1 release involves the Globalyzer Client only (not the Globalyzer Server) and includes minor bug fixes.

The 6.3.0 release provides the following new features:

• Concatenation Detection for HTML Strings: HTML strings are sometimes a combination of text, externalized text, server-side code, and in the case of .vm files, variables. Globalyzer now detects these combinations and will set the priority to C. Globalyzer also provides a new rule retention for HTML rule sets only, called String Concatenation Patterns, to find concatenations that would normally be Filtered. For example, an HTML string which is a series of string externalizations would not be Active (since the string does not contain text to externalize). However the string should most likely be externalized as a whole, instead of concatenated parts. Use a String Concatenation Pattern to find these situations so they can be dealt with properly.
• Focus on Top Scan Result Issues: Globalyzer has taken a number of steps to help users focus on top issues.
  1. Defined Scan Views for Top, Most, and All Predicted Issues (select Scan->Refresh Default Scan Views to update existing projects)
  2. Provided shortcut keys to quickly switch among the three views. Ctrl+Shift+1 for Top, Ctrl+Shift+2 for Most, Ctrl+Shift+3 for All.
  3. Provided a new Lite attribute, report-priorities, to specify the priorities to include in the generated report.
• Password Encryption for Enterprise Servers: Companies with their own Globalyzer Server must provide some configuration information in the GzserverConfig.groovy file. This information includes some passwords: the database user password and, if the server is configured to use LDAP, an LDAP password. These passwords may now be encrypted via a new utility: globalyzer-encrypt-password.jar and the encrypted password may be specified in the GzserverConfig.groovy file.

The 6.2.1 release involves the Globalyzer Client only (not the Globalyzer Server) and includes minor bug fixes.

The 6.2 release provides the following new features:

• Import Lite Project Definition Files: The Workbench can now import Lite Project Definition files, reading from the file to create a project with scans in the Workbench. Also, if you are creating an Eclipse project and the base path of the project contains a lingoport/LiteProjectDefinition.xml file, you may choose to automatically import the file. In this way you can quickly point to a repo and create the Workbench project from the Lite file in the repo.
• Support for Android String Externalization: Globalyzer now supports a new resource type, named android, available for both Java and XML scans. Externalizing to the android resource file writes strings to the file: strings.xml.
• Rule Set Comparison from the Workbench: From the Workbench, you may now select two rule sets and generate a report comparing them. Previously, this feature was only available from our Command Line Interface. For example, you can create a default rule set and then extend it, adding/deleting/modifying rules. To see the differences, compare the base rule set with your modified rule set.
• String Statement Filters for most Rule Set Languages: Originally, String Statement Filters were only implemented for JavaScript. Now, they are available for all languages that support the notion of statements; for example: Java, C#, C++, etc. If Globalyzer detects a string literal within the statement of a String Statement Filter pattern, that string will be excluded from the Embedded String Scan Results. If multiple statements are on one line, it will only filter the strings found in the filtered statement, and leave other strings on the line detected. If a filtered statement spans multiple lines, it will filter the embedded strings across the multiple code lines.
• Improvements regarding Temporary Rules: In the Workbench, you can create temporary rules and scan with them without adding them to rule sets. You may now see these temporary rules across projects and choose to either delete or submit them. Select Project->Show/Submit Rule Set Filters/Detections menu item in the Workbench.

The 6.1.1 release involves the Globalyzer Client only (not the Globalyzer Server) and provides the following new features:

• Introducing Prediction Reports: Prediction Reports are used to save prediction markings, one report per scan. After marking the predictions for a scan, choose Machine Learning->Export Prediction Report to generate a scan's Prediction Report. These reports can then be shared with Globalyzer Lite, other Workbenches, and be reflected in the Dashboard. Globalyzer Lite will automatically apply the Prediction Report after scanning; other Workbenches can import the Prediction Report to update their Scan Results with the latest markings; and the Dashboard, which relies on Globalyzer Lite, will now display the same Scan Results and predictions shown in the Workbench. Remember that to speed up your i18n analysis, use Machine Learning->GO! It will use your T/F predictions to make additional predictions.
• Set Prediction column rather than ToDo, Invalid, and Ignore Status:
  We are deprecating the use of ToDo, Invalid, and Ignore status in favor of marking the prediction of an issue T/F/P.
  • Rather than changing the status of an issue to ToDo, set the prediction to T.
  • Rather than changing the status of an issue to Invalid, set the prediction to F.
  • Rather than changing the status of an issue to Ignore, set the prediction to P (for pending).
  After marking your predictions, choose Machine Learning->Export Prediction Report so that your new predictions will be reflected in the Dashboard and can be shared with other Workbenches.
• Dashboard False Positive Changes: In our 6.0 release, we added support for synchronizing false positive issues between the Dashboard and the Workbench using a DFP status. We are deprecating the DFP status in favor of a DFP prediction value. Now, Reload Dashboard False Positives will set the prediction value for all the False Positives on the Dashboard to DFP in the Workbench. Issues with a DFP prediction value can be ignored. Also, it is no longer necessary to Update to Dashboard as False Positive. Simply mark the prediction F and export the Prediction Report. Issues marked F will not be displayed on the Dashboard. To clear a DFP, go to the issue on the Dashboard and make it active again.
• New Scan Views: We added the following default Scan Views to easily view active issues with various prediction values:
  • All Scan Issues - All issues found by scanning, regardless of prediction value
  • All Predicted Active - All issues except those that you, GO!, or the Dashboard set to False (F, ML False, DFP). These issues are reflected in the Workbench Scan Summary and in the Dashboard.
  • All Working Active - All issues except those that you have explicitly set to F, or that the Dashboard set to DFP. Use GO! to speed up the evaluation process.
  • All Undecided - All issues without a set prediction value of T/F/P/DFP. These are the issues that you still need to evaluate.
  • Prediction T - All active issues with prediction marked T
  • Prediction F - All active issues with prediction marked F
  • Prediction P - All active issues with prediction marked P (pending)
  • Prediction DFP - All active issues with prediction marked DFP
• Sharing GO! Results: In the Workbench, you automatically generate Machine Learning and Prediction Report files for a scan by selecting Machine Learning->GO! These predictions can then be shared with other Workbenches and reflected in the Dashboard. If you would like to apply existing Machine Learning files to your Scan Results, you can select Machine Learning->Import Machine Learning. Run GO! whenever you add or modify T/F/P predictions, so that GO! can make more predictions that are then saved in the Machine Learning and Prediction Report files.
• Globalyzer Command Line Client and Machine Learning: When running a scan via the Globalyzer Command Line Client (CLI), you can now apply existing Machine Learning files via a new --machine-learning flag. New code will then be predicted. Note, you still must generate the Machine Learning files for a scan via the Workbench's Machine Learning->GO!
• Scan Reports and Prediction Value: By default, all reports generated from the Workbench, CLI, and Lite will contain only Predicted Active results. This means that results with a prediction value of F, ML False, or DFP will not be reported. XML reports generated from Lite are the exception, and contain results for all prediction values. In the Workbench, you can now configure detailed reports to contain desired prediction values.

The 6.1 release provides the following new features:

• Introducing Machine Learning: Machine Learning is a powerful new feature that helps users more quickly identify the real issues in their source code. After scanning with Rule Sets in the Workbench, the user marks some active issues as TRUE or FALSE and then invokes Machine Learning to make predictions on the remaining active issues. It may predict ML True (a real issue), ML False (a false issue), or ML NULL (not enough information to make a prediction). This is an iterative process; the user can make corrections by marking more predictions as TRUE or FALSE and re-invoking Machine Learning, until the prediction results are satisfactory. At this point, the issues predicted as TRUE, ML True, or ML NULL are the ones to address.
• Company Dictionary: This feature allows users to add words to their Globalyzer Company's dictionary when scanning. A Company Dictionary is maintained on the Globalyzer Server. Users can upload, download, and view their dictionary contents. To add words to the dictionary, download the dictionary from the Server, modify the dictionary file on your local machine, and upload to the Server. Note that there is one Company Dictionary per company, so all users within the company will see the same dictionary contents. To use the Company Dictionary, download the dictionary from the server and place in your Lingoport directory. When scanning, Globalyzer will include the words from your downloaded dictionary file along with those in the Lingoport Dictionary.
• Import Rule Set Enhancement: You can now export all your rule sets to a single Rule Set Repository file. And then, when importing from this file, you can select just a subset of the Rule Sets to import.
• Updated Rule Terminology: We changed some of our Globalyzer Rule names to be clearer and more consistent:
  • String Literal Filters are now String Content Filters
  • String Retention Patterns are now String Content Patterns
  • String Operand Filters are now String Variable Filters
  • String Operand Patterns are now String Variable Patterns
• Globalyzer Server requires Tomcat 8.5.x: The 6.1 release of the Globalyzer Server has been upgraded to use Grails 3, which requires Tomcat 8.5.x (for our Enterprise users).

The 6.0 release provides the following new features:

• Support for Local Rule Sets using Lite: This feature allows scanning to occur without accessing the Globalyzer Server. Rule sets are stored in local files, rather than retrieved from the Server. Use of this feature requires a Globalyzer License to be downloaded from the Server and stored on your local machine. Also note that this feature is only available for Globalyzer Lite. The Workbench, for example, still requires a connection to the Globalyzer Server.
• Dashboard False Positive: A new status has been implemented for Globalyzer, called Dashboard False Positive, or DFP. This status allows the false positives manually ignored in the Workbench (via status changes) to be reflected on the Dashboard. When an issue is set to DFP, the Dashboard is updated and the issue is ignored. The Workbench can also update its list of DFP issues from the Dashboard, allowing the Workbench to ignore false positives found and set by other developers.
• Security Enhancements: Several security enhancements have been implemented for the Globalyzer Server. Our password encryption algorithm has been upgraded to use bcrypt, forgot password now performs a password reset rather than retrieval, and we now guard against clickjacking and directory/path traversal attacks. Our version of Tomcat has been upgraded to enable some of these security features.
• Report Enhancements: Previously, generating reports from the Workbench only included issues with Active or ToDo status. Now you can choose the statuses of interest; for example, generating a report of Filtered issues.

The 5.4 release provides the following new features:

• Support for 4-byte UTF-8 Characters: Updates the MySQL database used by the Globalyzer Server (and the Globalyzer Workbench if installed to use MySQL) to accept 4-byte characters, such as 𡇙. Previously, database only supported up to 3-byte UTF-8 characters. Note that your MySQL version must be 5.5.3 or later and MySQL variable settings must be updated to utf8mb4. Instructions are available in Server upgrade documentation as well as Client download and installation directions.
• Introducing json as a resource file type for JavaScript: JavaScript embedded strings can now be externalized to json files.

The 5.3 release includes the following features.

Note: As of 5.3, all Globalyzer Clients are compiled with Java 8; to run a client, you must have Java 8 (or later) installed on your machine.

• Introducing the Swift Rule Set: We added a new Rule Set to support the Swift programming language. It contains rules for Embedded Strings, Locale-Sensitive Methods, Static File References, and General Patterns.
• Enhanced Perl Rule Set: In release 5.2, we added support for Perl Locale-Sensitive Methods, but no content. In this release, we provide Locale-Sensitive Methods and their corresponding help, in addition to new rules in other categories.
• Introducing the Globalyzer MVN Plugin: MVN projects can be scanned using our Globalyzer MVN plugin. The Globalyzer MVN plugin scans your MVN project and generates scan reports to a directory specified in the pom.xml file. We ask our MVN customers to install the MVN plugin in a private MVN repository for your company. Once installed, all developers can then access the plugin to scan their code.

The 5.2.1 minor release provides new client jar files (versioned 5.2.1) to download (in addition to the previously released 5.2.0 jar files). The 5.2.1 jar files have been compiled with Java 8 and sit on top of Eclipse 4.x. If you have Java 8 on your machine, we encourage you to use these latest jar files.

The 5.2 release includes the following features.

• Introducing Rule Categories: Rules now have a new Category attribute that allows rules across the rule set to be grouped. Rules can then be quickly enabled/disabled according to category from the Edit Rule Set page.
• Enhanced JavaScript Rule Set includes jQuery, AngularJS, ReactJS, and NodeJS specific rules: These new rules use the Category attribute to identify the JavaScript library associated with the rule. From the Edit Rule Set page, enable or disable rules for the JavaScript Library Categories to more effectively scan your code. New detection and filter rules have been added to scan code that uses
  • jQuery
  • AngularJS
  • ReactJS
  • and NodeJS libraries.
• New Filter Type for JavaScript Rule Sets - String Statement Filters: If Globalyzer detects a string literal within the statement of a String Statement Filter pattern, that string will be excluded from the Embedded String Scan Results. If multiple statements are on one line, it will only filter the strings found in the filtered statement, and leave other strings on the line detected. If a filtered statement spans multiple lines, it will filter the embedded strings across the multiple code lines.
• Support for HTML Tag Libraries: Globalyzer now supports skipping Tag Library tags during its HTML Embedded String scan, resulting in cleaner scan results. The Tag Library tags are configured in the Ignored HTML Tags rules.
• Locale-Sensitive Method Support for the Perl Rule Set: You can now configure Locale-Sensitive Methods for Perl Rule Sets.
• Support for Mason Files: Globalyzer can now scan Mason Files, which are files containing JavaScript, HTML, and Perl.

The following lists new features in the 5.1 release.

• Finer control configuring Locale-Sensitive Methods for Java: There are two new fields when configuring Locale-Sensitive Methods for Java, Class or Variable Type and Parameter Type(s) to Filter. If the Class or Variable Type is specified, then only method calls for this class will be detected. If Parameter Type(s) to Filter is specified, then if one of the arguments is of the specified type, the Locale-Sensitive Method will not be detected. For example, you can now configure toLowerCase to be detected only when called via the java.lang.String class only if a java.util.Locale parameter has not been provided.
• Globalyzer Lite and API Enhancements: Globalyzer Lite and the API now support setting session and scan options, similar to what is already available in the Globalyzer Workbench. These new options include: the location of the data dictionary, whether or not to filter results against the dictionary, the scan timeout duration, source file encoding, result types to scan, and comment text.
• Globalyzer Lite Login Feature: You can now set default login information for Globalyzer Lite by creating a .globalyzerrc file. When processing Project Definition Files, Lite will grab the username/password information from the .globalyzerrc file if it is not provided in the Project Definition File itself.

The following lists new features in the 5.0 release.

• String Concatenation Detection: Globalyzer now flags string literals that are part of string concatenations, helping you to easily identify and refactor the concatenation before externalizing strings to resource files. As Globalyzer scans your source code, it sets a detected string's Scan Results priority to the new string concatenation priority 'C' when at least one of the following conditions are true:
  • string literal starts or ends with white space
  • string literal is preceded or followed by (language specific) concatenation characters
  • string literal is a parameter to a Locale-Sensitive Method configured to have priority 0 (the string concatenation priority)
• Finer control when configuring String Method Filters and String Method Patterns for Java: When configuring String Method Filters and String Method Patterns for your Java Rule Set, you can now optionally include Class or Variable Type(s) to give you finer control over issues being filtered/detected. For example, rather than filtering all strings passed to the method, setName, you can associate a Class name so filtering will only take place when the embedded string is passed to the setName method of the specified Class.
• Globalyzer Lite Project Definition File Generation from Workbench: Save time setting up Globalyzer Lite by generating your Globalyzer Lite Project Definition File from the Workbench. Create your Workbench Project and then select File->Export->Globalyzer->Export Project Definition (Lite).

The following lists new features in the 4.8.3 release.

• Improved Globalyzer Lite Integration Support: Globalyzer Lite lets developers check i18n compliance before committing to a source repository.
  • IDE Internationalization Support: Globalyzer Lite now supports finding and correcting internationalization issues entirely within an IDE. Our documentation covers integration within Visual Studio, IntelliJ IDEA, and Eclipse. Integration with numerous other IDEs is also possible.
  • Build Integration: Added new command line options. The project location, scan items, and report directory can now be easily specified at runtime.
  (You will need a special license to access Globalyzer Lite. Please contact sales@lingoport.com.)
• Enhanced Configuration Options for Enterprise Servers: Enterprise Servers can now configure information and links that display on the Login screen, as well as messages that display for LDAP-configured servers. In addition, a default team name may be configured; if specified, newly created users will automatically be assigned to the default team.

The following lists new features in the 4.8 release.

• Introducing Globalyzer Lite: Globalyzer Lite is a lightweight version of the Globalyzer Client.
  • It is smaller and faster to install than the Globalyzer Workbench and CLI.
  • It requires no external database.
  • A Project Definition XML file allows for the creation of temporary projects and scans, execution of those scans, and generation of corresponding reports. This can be particularly useful in a Continuous Integration model.
  • Multiple projects can be processed simultaneously on the same machine.
  • Note: This feature requires special licensing. Please contact sales@lingoport.com.
• Globalyzer Server Runs on Java 8: The 4.8 release upgrades the Globalyzer server to run on Java 1.8 (for our Enterprise users). Note that Tomcat 7 is now required for deploying the 4.8 Globalyzer Server.

The following lists new features in the 4.7 release.

Note: As of the 4.6 Release, Globalyzer requires Java 1.7. Please make sure that JDK 1.7 is installed on your machine before attempting to install the Globalyzer Client.

• The Globalyzer API: The Globalyzer API allows you to create Globalyzer projects and scans, execute scans, and generate reports from a java program. This enables projects to be created "on the fly." For example, during code check-in, the check-in process could trigger the execution of a java program that calls the API to scan the source code, enabling timely feedback on its internationalization status. See the Globalyzer API reference page for more information on how to use this new feature.
• LDAP for Enterprise Servers: The Globalyzer Server can be configured to use your company's LDAP system. All Globalyzer user access and information is then managed by LDAP.
  Note: This feature requires special licensing. Please contact sales@lingoport.com.
• Improved Rule Sets: Updated Globalyzer default rule sets, with specific attention on JavaScript and Objective-C.

The following lists new features in the 4.6 release.

• Introducing String Operand Filters/Patterns: This feature (available for all languages except HTML) allows you to filter/retain string literals that are compared with, or assigned to, variables. For languages such as XML, you can use this to filter out string attributes.
• Filter Strings used as Array Indices for C#, PHP, and JavaScript: C#, PHP, and JavaScript support Associative Arrays, where strings can be used to index arrays. String literals used in this manner are not user-facing and should be filtered. This filtering is now performed automatically; there is no Rule Set configuration work required. Note that this has only been implemented for C#, PHP, and JavaScript.
• Managers can Assign Ownership of Rule Sets: Prior to this feature, only Rule Set owners could assign their Rule Sets to another user within the company. Now, managers can assign Rule Sets of team members to other users within the company.
• Email False Positive Scan Results to Lingoport: Feedback from Globalyzer users regarding false positive Scan Results has been invaluable. To help facilitate this feedback, the Workbench now allows the user to select entries in Scan Results and email them to Lingoport via a menu selection. This information will help us further refine our default Rule Sets.
• Improved JavaScript Rule Set: New filters have been added to the JavaScript Rule Set and help for JavaScript Locale-Sensitive Methods has been enhanced.
• Secure HTTP: Globalyzer now supports the additional security of HTTPS for all data that passes between the Client and the globalyzer.com Server.
• New version command for the Command Line Client: The Globalyzer Command Line Client now supports --version and -ver to provide version information for both the Client and the Server.
• String Method Filters/Patterns now filter/retain Strings within Nested Methods: If string literals are passed to a nested method, they will be filtered if the outer method is a String Method Filter, and retained if the outer method is a String Method Pattern.
• Reason Field in Scan Results more Descriptive for Embedded Strings: In addition to displaying the pattern of the rule (that either filtered or retained the Embedded String), the Reason field now includes "Literal", "Line", "Method", or "Operand", to indicate the type of the rule.
• Reorganization of Reference Section Help: The Reference Section Help has been organized into Command Line, Server, and Workbench Reference sections.

Should you encounter problems or have questions, please email support@lingoport.com.

The following lists new features in the Globalyzer 4.5 release.

• Rule Set Inheritance: Rule Sets now support inheritance! A Rule Set can be created to extend an existing Rule Set. The new Rule Set inherits all the rules of the parent Rule Set and can add new rules and/or override inherited rules. This allows companies to centrally manage core Rule Sets and project teams can then inherit the modifications.
• Comparing Rule Sets: Available from the Command Line Interface, Rule Sets defined on the server can now be compared, generating an HTML report with the differences.
• Support for Android: The Java Rule Set has been enhanced to support android applications. New String Method Filters, String Literal Filters, and String Line Filters have been added to weed out false positive Embedded Strings.
• Time Stamps in Console Output and in Show Log: Time Stamps have been added to the Console output as well as the Show Log HTML page.
• Updated RESX Resource File: The generated RESX Resource File has been updated from version 1.3 to 2.0.

Our 4.3.1 release made a few important tuning and performance improvements in the areas of MySQL Client database support, scanning, and the File Inspector.

The following lists new features in the Globalyzer 4.3 release.

• Shared Globalyzer Projects: Globalyzer project and scan configuration (without scan results) can now be shared. Instead of explicitly importing and exporting projects, Globalyzer manages these tasks automatically, enabling team members to work on the same project seamlessly. See the Shared Projects reference page for more information on how to use this new feature.
• Import/Merge: When importing a Globalyzer project that already exists in your workspace, you now have the option to either Overwrite or Merge. Overwrite deletes your existing project before importing the new one; merge combines the imported project with your existing one.
• Globalyzer Data Directory Location: During Client Installation, you are now prompted for the location of the Data Directory, where Globalyzer stores application data and log files as well as the optional HSQLDB database. The default is [userhome]/.globalyzer, but this can be set to another location.
• Additional Help on Headless Globalyzer Install: Login to the Globalyzer Server and click on the Globalyzer Client download link. The Client Installation download page includes instructions on how to install the Globalyzer Client via a script as opposed to a GUI. You'll want to use this when installing Globalyzer to build machines where Globalyzer scanning can be part of the nightly build.
• Suggested Rule Sets for Unsupported Languages: The Create Rule Set reference page provides Rule Set suggestions for currently unsupported languages.
• File Inspector Report Line Counts: Line counts have been added to File Inspector Reports.

The following lists new features in the Globalyzer 4.2 release.

• Objective-C Rule Set: We've added this important rule set to help you internationalize your iOS and other Objective-C applications. In addition to scanning for i18n issues in Objective-C source code, Globalyzer supports string externalization to Objective-C's preferred text resource file type: strings
• Ability to Assign Rule Sets to Others: Though team members can share rule sets, only the rule set owner can made modifications. This feature facilitates passing rule set ownership to another. Just edit the rule set and select a new owner in the Owner dropdown.
• Launch Client without First Creating a Rule Set on the Server: This feature supports the natural process of using Globalyzer: first create a Project, then run File Inspector, then create Rule Sets and Scans.
• Create Rule Sets from the Client: To facilitate rule set creation, Globalyzer now supports the ability to create new rule sets directly from the Client. You may still want do some customization on the Server, but it's now even easier to create that first set of rule sets as you're running the Client, creating your Globalyzer Project and looking at the results of your File Inspection report to determine which rule sets you'll need for scanning your source code.
• Additional default Scan Views: In addition to All Active, there are now default Scan Views for Priority 1, Priority 2, Priority 1 and 2, Ignore, Invalid, ToDo, Filtered, All, and All but Active and Filtered.
• Notification of Newer Globalyzer Versions on Client Startup: On Client startup, a popup displays if there is a newer version of the Client available or if there is a Client/Server version mismatch; the popup includes a link to the latest Client download.
• Demo Results displayed based on Priority: When a demo user executes scans, up to 100 active results are reported. This feature focuses on reporting mostly higher priority issues. It reports 50 Priority 1 issues, 30 Priority 2 issues, 20 Priority 3 issues, 5 Priority 4 issues, and 5 Priority 5 issues.

The following lists new features in the Globalyzer 4.1.1 release.

• Additional options when pseudo-localizing your resource files:
  • Pseudo-localize all your base resource files at one time by using the new Localize All button.
  • Use the new Start and End fields to specify characters to be displayed before and after each string. This helps you quickly identify layout issues where the full string is not fitting. For example [String]
  • You can also specify that each character of the string itself be replaced by an accented character for easier differentiation from English strings. For example Šţŕîñg
• Support for Delphi RC resource file type: The Delphi language requires its own version of the RC resource file type. Upon string externalization, a .pas file is created and updated, along with the .h and .rc files.
• .NET Tutorial: To accompany our Java tutorial, the .NET tutorial takes your through the basic steps involved in internationalizing a simple .NET Web application.

The following lists new features in the Globalyzer 4.1 release.

• Refine your Rule Set from within the Client: The Globalyzer Client now allows you to create both filter and detection rules, rescan your code to see their effects, and update the Rule Set on the server when you are satisfied with the results. This Scan Result driven approach to fine-tuning your Rule Set should help you significantly streamline your scanning and filtering process.
• Prioritize your internationalization work: Globalyzer now prioritizes its locale-sensitive method, general pattern, and static file reference detections (in addition to embedded string detections implemented in version 3.5), helping you focus on the most likely issues first. These priority settings can be customized. You'll see the priority breakdown both on screen and in the many reports that are provided for you to track and manage your progress.
• Retain and prioritize strings passed to specified methods: Rule Sets now include a new detection, called String Method Patterns. This feature allows you to specifically identify methods that are passed strings that would be displayed to the end user. For example, in javascript we have added confirm, in C# Show, and in java JLabel. By identifying these types of methods and configuring them in your Rule Set, you can set the priority for these string detections and ensure that they are addressed during your internationalization process.
• Disable Scan Feature: Scans can now be disabled. Disabled scans can be configured but are not scanned (automatically or manually) and the scan results are not available/displayed. This feature is useful for limiting the amount of rescanning that occurs when configuring scans. The user can focus on one scan, disabling the others.
• All resource types now support group mode: In group mode, externalized strings are grouped by file in the resource file.
• All resource types now support comments: Comments can be added to resource files and will be preserved during subsequent string externalizations.

For more information, please visit www.lingoport.com.

© 2022 by Lingoport Inc. All rights reserved