Beispiel #1
0
        public void TestParsePo()
        {
            var po_parser = new PoParser();

            po_parser.Add("../../Catalog/en_US.pot");
            AssertUnits(new List <ILocalizationUnit> (po_parser.Parse()));
        }
Beispiel #2
0
        public static List <ILocalizationUnit> ParsePo(string po_file)
        {
            var po_parser = new PoParser();

            po_parser.Add(po_file);
            return(new List <ILocalizationUnit> (po_parser.Parse()));
        }
Beispiel #3
0
 public void SetUp()
 {
     foreach (var path in Directory.GetFiles("../../Catalog", "*.po"))
     {
         var parser = new PoParser();
         parser.Add(path);
         var lang = Path.GetFileNameWithoutExtension(path);
         catalogs.Add(lang, new ParserResourceCatalog(parser)
         {
             CurrentIsoLanguageCode = lang
         });
     }
 }
Beispiel #4
0
        private CultureDictionaryRecord[] ParseText(string resourceName)
        {
            var parser = new PoParser();

            var testAssembly = typeof(PoParserTests).GetTypeInfo().Assembly;

            using (var resource = testAssembly.GetManifestResourceStream("OrchardCore.Tests.Localization.PoFiles." + resourceName + ".po"))
            {
                using (var reader = new StreamReader(resource))
                {
                    return(parser.Parse(reader).ToArray());
                }
            }
        }
Beispiel #5
0
        public void ParseIntoDictionaryStringWithSlashesTest()
        {
            string msgid  = @"The type of parameter \""${0}\"" is not supported";
            string msgstr = @"Il tipo del parametro \""${0}\"" non è supportato";

            string parsedMsgid  = @"The type of parameter ""${0}"" is not supported";
            string parsedMsgstr = @"Il tipo del parametro ""${0}"" non è supportato";

            PoParser   target = new PoParser();
            TextReader reader = new StringReader(String.Format(@"
            msgid ""{0}""
            msgstr ""{1}""
            ", msgid, msgstr));

            var actual = target.ParseIntoDictionary(reader);

            Assert.AreEqual(1, actual.Count, "Parsed dictionary entries count do not match");
            Assert.AreEqual(parsedMsgid, actual.Keys.ToArray()[0], "Key does not match");
            Assert.AreEqual(parsedMsgstr, actual.Values.ToArray()[0], "Value does not match");
        }
Beispiel #6
0
        private void toolStripMenuItemOpenPoFile_Click(object sender, EventArgs e)
        {
            try
            {
                // Пользователь выбирает файл, с помощью файлового диалога OS.
                var ofd      = new InputFile();
                var filePath = ofd.GetFilePath(".po");
                if (String.IsNullOrWhiteSpace(filePath))
                {
                    return;
                }

                // Парсим выбранный пользователем файл. После завершения слушаем событие - CompleteEvent.
                var poParser = new PoParser(filePath);
                poParser.ParseCompletedEvent += PoFileParseCompleted;
                poParser.Parse();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString());
            }
        }
Beispiel #7
0
        public void SetUp()
        {
            foreach (var path in Directory.GetFiles("../../Catalog", "*.po"))
            {
                var parser = new PoParser();
                parser.Add(path);
                var lang = Path.GetFileNameWithoutExtension(path);
                catalogs.Add(new Tuple <string, ResourceCatalog> (lang, new ParserResourceCatalog(parser)
                {
                    CurrentIsoLanguageCode = lang
                }));
            }

            (new GeneratorTests()).TestMoGenerator();
            foreach (var path in Directory.GetFiles("../../Catalog", "*.mo"))
            {
                var lang    = Path.GetFileNameWithoutExtension(path);
                var catalog = new MoCatalog(File.Open(path, FileMode.Open))
                {
                    CurrentIsoLanguageCode = lang
                };
                catalogs.Add(new Tuple <string, ResourceCatalog> (lang, catalog));
            }
        }
Beispiel #8
0
        static void Main(string[] args)
        {
            var getopt = new Getopt(Assembly.GetExecutingAssembly().GetName().Name, args, "i:o:")
            {
                Opterr = false
            };

            string input  = null;
            string output = null;

            int option;

            while (-1 != (option = getopt.getopt()))
            {
                switch (option)
                {
                case 'i': input = getopt.Optarg; break;

                case 'o': output = getopt.Optarg; break;

                default: PrintUsage(); return;
                }
            }

            if (input == null || output == null)
            {
                PrintUsage();
                return;
            }

            try
            {
                if (!File.Exists(input))
                {
                    Console.WriteLine("File {0} not found", input);
                    return;
                }

                Dictionary <string, string> entries;
                var parser = new PoParser();
                using (var reader = new StreamReader(input))
                {
                    entries = parser.ParseIntoDictionary(reader);
                }

                using (var writer = new ResourceWriter(output))
                {
                    foreach (var kv in entries)
                    {
                        try { writer.AddResource(kv.Key, kv.Value); }
                        catch (Exception e) { Console.WriteLine("Error adding item {0}: {1}", kv.Key, e.Message); }
                    }
                    writer.Generate();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error during execution: {0}", ex.Message);
                return;
            }
        }
Beispiel #9
0
        public static int Main(string[] args)
        {
            var    input_paths                = new List <string> ();
            string output_path                = "-";
            string generator_name             = String.Empty;
            string source_root_path           = null;
            string reduce_master_path         = null;
            string reduce_retain_path         = null;
            string android_input_strings_xml  = null;
            string android_output_strings_xml = null;
            string analyer_config_path        = null;
            LocalizationMetadata metadata     = null;
            bool generate_pot           = false;
            bool exclude_po_header      = false;
            bool analyze                = false;
            bool analyzer_warn_as_error = false;
            bool log          = false;
            bool verbose      = false;
            bool retain_order = false;
            bool show_help    = false;
            bool count_words  = false;
            int  word_count   = 0;

            Generator generator = null;

            var options = new OptionSet {
                { "i|input=", "Input directory, search pattern, or file to parse (non-recursive)", v => input_paths.Add(v) },
                { "o|output=", "Output file for extracted string resources", v => output_path = v },
                { "r|source-root=", "Root directory of source code", v => source_root_path = v },
                { "g|generator=", String.Format("Generator to use ({0})",
                                                String.Join("|", Generator.GeneratorNames)), v => generator_name = v },
                { "retain-order", "Retain the original input string order when generating. " +
                  "Default behavior is to sort strings for better diff support.", v => retain_order = v != null },
                { "a|analyze", "Run the string analyzer after generation", v => analyze = v != null },
                { "analyzer-config=", "Path to a configuration file for the analyzer; use with --analyze", v => analyer_config_path = v },
                { "analyzer-warnaserror", "Treat analyzer warnings as errors", v => analyzer_warn_as_error = v != null },
                { "reduce-master=", "Reduce a master localized PO file, " +
                  "keeping only strings defined by another unlocalized PO[T] file", v => reduce_master_path = v },
                { "reduce-retain=", "An unlocalized PO[T] file used to " +
                  "determine which strings from reduce-master should be retained", v => reduce_retain_path = v },
                { "android-input-strings-xml=", "Input file of unlocalized Android Strings.xml " +
                  "for preserving hand-maintained string resources", v => android_input_strings_xml = v },
                { "android-output-strings-xml=", "Output file of localized Android Strings.xml " +
                  "for preserving hand-maintained string resources", v => android_output_strings_xml = v },
                { "pot", v => generate_pot = v != null },
                { "exclude-po-header", v => exclude_po_header = v != null },
                { "l|log", "Display logging", v => log = v != null },
                { "m|meta=", "Add localization metadata (key=value)", v => {
                      var parts = v.Split(new [] { '=' }, 2);
                      if (parts != null && parts.Length == 2)
                      {
                          if (metadata == null)
                          {
                              metadata = new LocalizationMetadata();
                          }

                          metadata.Add(parts[0].Trim(), parts[1].Trim());
                      }
                  } },
                { "wc", "Count words to translate, output goes in the po header and in the console (with -v)", v => count_words = v != null },
                { "v|verbose", "Verbose logging", v => verbose = v != null },
                { "h|help", "Show this help message and exit", v => show_help = v != null }
            };

            try {
                options.Parse(args);

                if (show_help)
                {
                    Console.WriteLine("Usage: vernacular [OPTIONS]+");
                    Console.WriteLine();
                    Console.WriteLine("Options:");
                    options.WriteOptionDescriptions(Console.Out);
                    return(1);
                }

                if (source_root_path != null)
                {
                    if (!Directory.Exists(source_root_path))
                    {
                        throw new OptionException("invalid source-root", "source-root");
                    }

                    source_root_path = new DirectoryInfo(source_root_path).FullName;
                }

                generator = Generator.GetGeneratorForName(generator_name.ToLower());
                if (generator == null)
                {
                    throw new OptionException("invalid generator", "generator");
                }

                generator.RetainStringOrder = retain_order;

                if (generator is PoGenerator)
                {
                    ((PoGenerator)generator).PotMode = generate_pot;
                    ((PoGenerator)generator).ExcludeHeaderMetadata = exclude_po_header;
                }

                if (reduce_master_path != null && reduce_retain_path == null)
                {
                    throw new OptionException("reduce-retain must be specified if reduce-master is", "reduce-retain");
                }
                else if (reduce_master_path == null && reduce_retain_path != null)
                {
                    throw new OptionException("reduce-master must be specified if reduce-retain is", "reduce-master");
                }
                else if (reduce_master_path != null && reduce_retain_path != null)
                {
                    var reduce_master = new PoParser {
                        SourceRootPath = source_root_path
                    };
                    var reduce_retain = new PoParser {
                        SourceRootPath = source_root_path
                    };

                    reduce_master.Add(reduce_master_path);
                    reduce_retain.Add(reduce_retain_path);

                    generator.Reduce(reduce_master, reduce_retain);

                    generator.Generate(output_path);

                    return(0);
                }
            } catch (OptionException e) {
                Console.WriteLine("vernacular: {0}", e.Message);
                Console.WriteLine("Try `vernacular --help` for more information.");
                return(1);
            }

            var parser = new AggregateParser {
                SourceRootPath = source_root_path
            };

            if (verbose)
            {
                parser.LogLevel = 2;
            }
            else if (log)
            {
                parser.LogLevel = 1;
            }

            StringAnalyzer analyzer = null;

            if (analyze)
            {
                try {
                    analyzer = new StringAnalyzer(analyer_config_path, analyzer_warn_as_error);
                } catch {
                    return(1);
                }
            }

            foreach (var input_path in input_paths)
            {
                if (File.Exists(input_path))
                {
                    parser.Add(input_path);
                    continue;
                }

                var search_pattern = "*";
                var dir            = input_path;

                if (!Directory.Exists(dir))
                {
                    search_pattern = Path.GetFileName(dir);
                    dir            = Path.GetDirectoryName(dir);
                    if (!Directory.Exists(dir))
                    {
                        continue;
                    }
                }

                foreach (var path in Directory.EnumerateFiles(dir, search_pattern, SearchOption.TopDirectoryOnly))
                {
                    parser.Add(path);
                }
            }

            if (metadata != null)
            {
                generator.Add(metadata);
            }

            foreach (var localization_unit in parser.Parse())
            {
                var localized_string = localization_unit as LocalizedString;
                if (count_words && localized_string != null)
                {
                    var separators = new char[] { '.', '?', '!', ' ', ';', ':', ',' };
                    if (localized_string.UntranslatedSingularValue != null)
                    {
                        word_count +=
                            localized_string.UntranslatedSingularValue.Split(separators, StringSplitOptions.RemoveEmptyEntries).
                            Count();
                    }
                    if (localized_string.UntranslatedPluralValue != null)
                    {
                        word_count +=
                            localized_string.UntranslatedPluralValue.Split(separators, StringSplitOptions.RemoveEmptyEntries).Count();
                    }
                }
                generator.Add(localization_unit);

                if (analyzer != null)
                {
                    analyzer.Add(localized_string);
                }
            }

            if (analyzer != null)
            {
                var error_count = analyzer.Analyze();
                if (error_count > 0)
                {
                    Console.WriteLine("The analyzer reported {0} errors. Generation skipped.", error_count);
                    return(1);
                }
            }

            if (count_words)
            {
                var word_count_metadata = new LocalizationMetadata();
                word_count_metadata.Add("Word-Count", word_count.ToString(CultureInfo.InvariantCulture));
                generator.Add(word_count_metadata);
            }

            generator.Generate(output_path);

            if (generator is AndroidGenerator && android_input_strings_xml != null && android_output_strings_xml != null)
            {
                ((AndroidGenerator)generator).LocalizeManualStringsXml(android_input_strings_xml, android_output_strings_xml);
            }

            if (verbose && count_words)
            {
                Console.WriteLine("Total of words in untranslated messages: {0} words.", word_count);
            }

            return(0);
        }
Beispiel #10
0
        public static void Main(string [] args)
        {
            var    input_paths                = new List <string> ();
            string output_path                = "-";
            string generator_name             = String.Empty;
            string source_root_path           = null;
            string reduce_master_path         = null;
            string reduce_retain_path         = null;
            string android_input_strings_xml  = null;
            string android_output_strings_xml = null;
            bool   analyze   = false;
            bool   log       = false;
            bool   verbose   = false;
            bool   show_help = false;

            Generator generator = null;

            var options = new OptionSet {
                { "i|input=", "Input directory, search pattern, or file to parse (non-recursive)", v => input_paths.Add(v) },
                { "o|output=", "Output file for extracted string resources", v => output_path = v },
                { "r|source-root=", "Root directory of source code", v => source_root_path = v },
                { "g|generator=", String.Format("Generator to use ({0})",
                                                String.Join("|", Generator.GeneratorNames)), v => generator_name = v },
                { "a|analyze", "Run the string analyzer after generation", v => analyze = v != null },
                { "reduce-master=", "Reduce a master localized PO file, " +
                  "keeping only strings defined by another unlocalized PO[T] file", v => reduce_master_path = v },
                { "reduce-retain=", "An unlocalized PO[T] file used to " +
                  "determine which strings from reduce-master should be retained", v => reduce_retain_path = v },
                { "android-input-strings-xml=", "Input file of unlocalized Android Strings.xml " +
                  "for preserving hand-maintained string resources", v => android_input_strings_xml = v },
                { "android-output-strings-xml=", "Output file of localized Android Strings.xml " +
                  "for preserving hand-maintained string resources", v => android_output_strings_xml = v },
                { "l|log", "Display logging", v => log = v != null },
                { "v|verbose", "Verbose logging", v => verbose = v != null },
                { "h|help", "Show this help message and exit", v => show_help = v != null }
            };

            try {
                options.Parse(args);

                if (show_help)
                {
                    Console.WriteLine("Usage: vernacular [OPTIONS]+");
                    Console.WriteLine();
                    Console.WriteLine("Options:");
                    options.WriteOptionDescriptions(Console.Out);
                    return;
                }

                if (source_root_path != null)
                {
                    if (!Directory.Exists(source_root_path))
                    {
                        throw new OptionException("invalid source-root", "source-root");
                    }

                    source_root_path = new DirectoryInfo(source_root_path).FullName;
                }

                generator = Generator.GetGeneratorForName(generator_name.ToLower());
                if (generator == null)
                {
                    throw new OptionException("invalid generator", "generator");
                }

                if (reduce_master_path != null && reduce_retain_path == null)
                {
                    throw new OptionException("reduce-retain must be specified if reduce-master is", "reduce-retain");
                }
                else if (reduce_master_path == null && reduce_retain_path != null)
                {
                    throw new OptionException("reduce-master must be specified if reduce-retain is", "reduce-master");
                }
                else if (reduce_master_path != null && reduce_retain_path != null)
                {
                    var reduce_master = new PoParser {
                        SourceRootPath = source_root_path
                    };
                    var reduce_retain = new PoParser {
                        SourceRootPath = source_root_path
                    };

                    reduce_master.Add(reduce_master_path);
                    reduce_retain.Add(reduce_retain_path);

                    generator.Reduce(reduce_master, reduce_retain);

                    generator.Generate(output_path);

                    return;
                }
            } catch (OptionException e) {
                Console.WriteLine("vernacular: {0}", e.Message);
                Console.WriteLine("Try `vernacular --help` for more information.");
                return;
            }

            var parser = new AggregateParser {
                SourceRootPath = source_root_path
            };

            if (verbose)
            {
                parser.LogLevel = 2;
            }
            else if (log)
            {
                parser.LogLevel = 1;
            }

            StringAnalyzer analyzer = null;

            if (analyze)
            {
                analyzer = new StringAnalyzer();
            }

            foreach (var input_path in input_paths)
            {
                if (File.Exists(input_path))
                {
                    parser.Add(input_path);
                    continue;
                }

                var search_pattern = "*";
                var dir            = input_path;

                if (!Directory.Exists(dir))
                {
                    search_pattern = Path.GetFileName(dir);
                    dir            = Path.GetDirectoryName(dir);
                    if (!Directory.Exists(dir))
                    {
                        continue;
                    }
                }

                foreach (var path in Directory.EnumerateFiles(dir, search_pattern, SearchOption.TopDirectoryOnly))
                {
                    parser.Add(path);
                }
            }

            foreach (var localized_string in parser.Parse())
            {
                generator.Add(localized_string);

                if (analyzer != null)
                {
                    analyzer.Add(localized_string);
                }
            }

            if (analyzer != null)
            {
                analyzer.Analyze();
            }

            generator.Generate(output_path);

            if (generator is AndroidGenerator && android_input_strings_xml != null && android_output_strings_xml != null)
            {
                ((AndroidGenerator)generator).LocalizeManualStringsXml(android_input_strings_xml, android_output_strings_xml);
            }
        }