public void HonorsMaxDepth() { var g = new Glob(FileSystem); g.Options.MaxDepth = 1; g.Pattern = Path.GetFullPath(FixPath(TestDir + @"/**/file1")); AssertEqual(g.ExpandNames(), @"/file1", @"/dir2/file1", @"/dir3/file1"); g.Options.MaxDepth = 2; AssertEqual(g.ExpandNames(), @"/file1", @"/dir2/file1", @"/dir2/dir2/file1", @"/dir3/file1"); g.Options.MaxDepth = 0; AssertEqual(g.ExpandNames(), @"/file1"); }
public static Assembly Generate(string name, string pattern, Generator generatorPrototype = null) { if (Assemblies.ContainsKey(name)) { return(Assemblies[name]); } var files = Glob.ExpandNames(pattern); return(GenerateFiles(name, files, generatorPrototype)); }
public void CanLog() { var log = ""; var glob = new Glob(@"test", new TestFileSystem()) { IgnoreCase = true, ErrorLog = s => log += s }; var fs = glob.ExpandNames().ToList(); Assert.False(string.IsNullOrEmpty(log)); }
public void TestBpmn() { var assembly = Compiler.Generate("Bpmn", BpmnPattern); Assert.NotNull(assembly); var type = assembly.GetTypes().SingleOrDefault(t => t.Name == "TDefinitions"); Assert.NotNull(type); var serializer = new XmlSerializer(type); serializer.UnknownNode += new XmlNodeEventHandler(UnknownNodeHandler); serializer.UnknownAttribute += new XmlAttributeEventHandler(UnknownAttributeHandler); var unknownNodeError = false; var unknownAttrError = false; void UnknownNodeHandler(object sender, XmlNodeEventArgs e) { unknownNodeError = true; } void UnknownAttributeHandler(object sender, XmlAttributeEventArgs e) { unknownAttrError = true; } var currDir = Directory.GetCurrentDirectory(); var testDir = "bpmn_tests"; var fileExt = "bpmn"; var testFiles = Glob.ExpandNames(string.Format("{0}\\xml\\{1}\\*.{2}", currDir, testDir, fileExt)); foreach (var testFile in testFiles) { var xmlString = File.ReadAllText(testFile); var reader = XmlReader.Create(new StringReader(xmlString), new XmlReaderSettings { IgnoreWhitespace = true }); var isDeserializable = serializer.CanDeserialize(reader); Assert.True(isDeserializable); var deserializedObject = serializer.Deserialize(reader); Assert.False(unknownNodeError); Assert.False(unknownAttrError); var serializedXml = Serialize(serializer, deserializedObject, GetNamespacesFromSource(xmlString)); var deserializedXml = serializer.Deserialize(new StringReader(serializedXml)); AssertEx.Equal(deserializedObject, deserializedXml); } }
static void Main(string[] args) { bool show_help = false; bool watch = false; bool force = false; bool commit = false; var options = new OptionSet() { { "o|output=", "specify output Directory", v => output = v }, { "c|commit", "commit ocr-version", v => commit = true }, { "w|watch", "watch directory", v => watch = true }, { "f|force", "force generation of ocr file", v => force = true }, { "h|help", "orccore file1 [file2 ...file-n]", v => show_help = v != null } }; var pathes = options.Parse(args); if (show_help) { options.WriteOptionDescriptions(Console.Out); System.Environment.Exit(0); } if (watch) { Watcher watcher = new Watcher(pathes[0], output); watcher.Start(); Console.ReadLine(); watcher.Stop(); } else { foreach (var p in pathes) { var globber = new Glob(); var files = globber.ExpandNames(p); OcrService scanner = new OcrService(output); foreach (var f in files) { if (commit) { scanner.Commit(f); } else { scanner.Scan(f, force); } } } } }
private void DeserializeSampleXml(string pattern, Assembly assembly) { var files = Glob.ExpandNames(pattern); var set = new XmlSchemaSet(); var schemas = files.Select(f => XmlSchema.Read(XmlReader.Create(f), (s, e) => { Assert.True(false, e.Message); })); foreach (var s in schemas) { set.Add(s); } set.Compile(); var anyValidXml = false; foreach (var rootElement in set.GlobalElements.Values.Cast <XmlSchemaElement>().Where(e => !e.IsAbstract && !(e.ElementSchemaType is XmlSchemaSimpleType))) { var type = FindType(assembly, rootElement.QualifiedName); var serializer = new XmlSerializer(type); var generator = new XmlSampleGenerator(set, rootElement.QualifiedName); var sb = new StringBuilder(); using (var xw = XmlWriter.Create(sb, new XmlWriterSettings { Indent = true })) { // generate sample xml generator.WriteXml(xw); var xml = sb.ToString(); File.WriteAllText("xml.xml", xml); // validate serialized xml var settings = new XmlReaderSettings { ValidationType = ValidationType.Schema, Schemas = set }; var invalid = false; void validate(object s, ValidationEventArgs e) { if (HandleValidationError(xml, e)) { invalid = true; } } settings.ValidationEventHandler += validate; var reader = XmlReader.Create(new StringReader(xml), settings); while (reader.Read()) { ; } settings.ValidationEventHandler -= validate; // generated xml is not schema valid -> skip if (invalid) { continue; } anyValidXml = true; // deserialize from sample var sr = new StringReader(xml); var o = serializer.Deserialize(sr); // serialize back to xml var xml2 = Serialize(serializer, o); File.WriteAllText("xml2.xml", xml2); void validate2(object s, ValidationEventArgs e) { if (HandleValidationError(xml2, e)) { throw e.Exception; } }; settings.ValidationEventHandler += validate2; reader = XmlReader.Create(new StringReader(xml2), settings); while (reader.Read()) { ; } settings.ValidationEventHandler -= validate2; // deserialize again sr = new StringReader(xml2); var o2 = serializer.Deserialize(sr); AssertEx.Equal(o, o2); } } Assert.True(anyValidXml, "No valid generated XML for this test"); }
public void CanThrow() { var fs = new TestFileSystem { DirectoryInfo = new TestDirectoryInfoFactory { FromDirectoryNameFunc = n => throw new ArgumentException("", "1") } }; var g = new Glob(new GlobOptions { ThrowOnError = true }, fs) { Pattern = TestDir + @"\>" }; Assert.Throws <ArgumentException>("1", () => g.ExpandNames().ToList()); fs.Path = new TestPath(FileSystem) { GetDirectoryNameFunc = n => throw new ArgumentException("", "2") }; g = new Glob(fs) { Pattern = "*" }; Assert.Empty(g.ExpandNames()); g.Options.ThrowOnError = true; Assert.Throws <ArgumentException>("2", () => g.ExpandNames().ToList()); fs.Path = new TestPath(FileSystem) { GetDirectoryNameFunc = n => null }; fs.DirectoryInfo = new TestDirectoryInfoFactory { FromDirectoryNameFunc = n => throw new ArgumentException("", "3") }; g.Options.ThrowOnError = false; Assert.Empty(g.ExpandNames()); g.Options.ThrowOnError = true; Assert.Throws <ArgumentException>("3", () => g.ExpandNames().ToList()); fs.Path = new TestPath(FileSystem) { GetDirectoryNameFunc = n => "" }; fs.DirectoryInfo = new TestDirectoryInfoFactory { FromDirectoryNameFunc = n => null }; fs.Directory = new TestDirectory(FileSystem, null, "") { GetCurrentDirectoryFunc = () => throw new ArgumentException("", "4") }; g.Options.ThrowOnError = false; Assert.Empty(g.ExpandNames()); g.Options.ThrowOnError = true; Assert.Throws <ArgumentException>("4", () => g.ExpandNames().ToList()); fs.Directory = new TestDirectory(FileSystem, null, "") { GetCurrentDirectoryFunc = () => "5" }; var d = new TestDirectoryInfo(FileSystem, TestDir) { GetFileSystemInfosFunc = () => throw new ArgumentException("", "5") }; fs.DirectoryInfo = new TestDirectoryInfoFactory { FromDirectoryNameFunc = n => d }; g.Options.ThrowOnError = false; Assert.Empty(g.ExpandNames()); g.Options.ThrowOnError = true; Assert.Throws <ArgumentException>("5", () => g.ExpandNames().ToList()); }
public void CanMatchRelativePaths() { AssertEqual(Glob.ExpandNames(FixPath(@"..\..\dir3\file*"), ignoreCase: true, dirOnly: false, fileSystem: FileSystem), @"\dir3\file1"); AssertEqual(Glob.ExpandNames(FixPath(@".\..\..\.\.\dir3\file*"), ignoreCase: true, dirOnly: false, fileSystem: FileSystem), @"\dir3\file1"); }
static void Main(string[] args) { var showHelp = args.Length == 0; var namespaces = new List <string>(); var outputFolder = (string)null; var integerType = typeof(string); var namespacePrefix = ""; var verbose = false; var nullables = false; var pclCompatible = false; var enableDataBinding = false; var emitOrder = false; var entityFramework = false; var interfaces = true; var pascal = true; var collectionType = typeof(Collection <>); Type collectionImplementationType = null; var codeTypeReferenceOptions = default(CodeTypeReferenceOptions); string textValuePropertyName = "Value"; var generateDebuggerStepThroughAttribute = true; var disableComments = false; var doNotUseUnderscoreInPrivateMemberNames = false; var generateDescriptionAttribute = true; var enableUpaCheck = true; var options = new OptionSet { { "h|help", "show this message and exit", v => showHelp = v != null }, { "n|namespace=", @"map an XML namespace to a C# namespace Separate XML namespace and C# namespace by '='. One option must be given for each namespace to be mapped. A file name may be given by appending a pipe sign (|) followed by a file name (like schema.xsd) to the XML namespace. If no mapping is found for an XML namespace, a name is generated automatically (may fail).", v => namespaces.Add(v) }, { "o|output=", "the {FOLDER} to write the resulting .cs files to", v => outputFolder = v }, { "i|integer=", @"map xs:integer and derived types to {TYPE} instead of automatic approximation {TYPE} can be i[nt], l[ong], or d[ecimal].", v => { switch (v) { case "i": case "int": integerType = typeof(int); break; case "l": case "long": integerType = typeof(long); break; case "d": case "decimal": integerType = typeof(decimal); break; } } }, { "e|edb|enable-data-binding", "enable INotifyPropertyChanged data binding", v => enableDataBinding = v != null }, { "r|order", "emit order for all class members stored as XML element", v => emitOrder = v != null }, { "c|pcl", "PCL compatible output", v => pclCompatible = v != null }, { "p|prefix=", "the {PREFIX} to prepend to auto-generated namespace names", v => namespacePrefix = v }, { "v|verbose", "print generated file names on stdout", v => verbose = v != null }, { "0|nullable", "generate nullable adapter properties for optional elements/attributes w/o default values", v => nullables = v != null }, { "f|ef", "generate Entity Framework Code First compatible classes", v => entityFramework = v != null }, { "t|interface", "generate interfaces for groups and attribute groups (default is enabled)", v => interfaces = v != null }, { "a|pascal", "use Pascal case for class and property names (default is enabled)", v => pascal = v != null }, { "u|enableUpaCheck", "should XmlSchemaSet check for Unique Particle Attribution (UPA) (default is enabled)", v => enableUpaCheck = v != null }, { "ct|collectionType=", "collection type to use (default is " + typeof(Collection <>).FullName + ")", v => collectionType = v == null ? typeof(Collection <>) : Type.GetType(v, true) }, { "cit|collectionImplementationType=", "the default collection type implementation to use (default is null)", v => collectionImplementationType = v == null ? null : Type.GetType(v, true) }, { "ctro|codeTypeReferenceOptions=", "the default CodeTypeReferenceOptions Flags to use (default is unset; can be: {GlobalReference, GenericTypeParameter})", v => codeTypeReferenceOptions = v == null ? default(CodeTypeReferenceOptions) : (CodeTypeReferenceOptions)Enum.Parse(typeof(CodeTypeReferenceOptions), v, false) }, { "tvpn|textValuePropertyName=", "the name of the property that holds the text value of an element (default is Value)", v => textValuePropertyName = v }, { "dst|debuggerStepThrough", "generate DebuggerStepThroughAttribute (default is enabled)", v => generateDebuggerStepThroughAttribute = v != null }, { "dc|disableComments", "do not include comments from xsd", v => disableComments = v != null }, { "nu|noUnderscore", "do not generate underscore in private member name (default is false)", v => doNotUseUnderscoreInPrivateMemberNames = v != null }, { "da|description", "generate DescriptionAttribute (default is true)", v => generateDescriptionAttribute = v != null }, }; var files = options.Parse(args); if (showHelp) { ShowHelp(options); return; } files = files.SelectMany(f => Glob.ExpandNames(f)).Concat(files.Where(f => Uri.IsWellFormedUriString(f, UriKind.Absolute))).ToList(); var namespaceMap = namespaces.Select(n => ParseNamespace(n, namespacePrefix)).ToNamespaceProvider(key => { var xn = key.XmlSchemaNamespace; var name = string.Join(".", xn.Split('/').Where(p => p != "schema" && GeneratorConfiguration.IdentifierRegex.IsMatch(p)) .Select(n => n.ToTitleCase(NamingScheme.PascalCase))); if (!string.IsNullOrEmpty(namespacePrefix)) { name = namespacePrefix + (string.IsNullOrEmpty(name) ? "" : ("." + name)); } return(name); }); if (!string.IsNullOrEmpty(outputFolder)) { outputFolder = Path.GetFullPath(outputFolder); } var generator = new Generator { NamespaceProvider = namespaceMap, OutputFolder = outputFolder, GenerateNullables = nullables, EnableDataBinding = enableDataBinding, EmitOrder = emitOrder, IntegerDataType = integerType, EntityFramework = entityFramework, GenerateInterfaces = interfaces, NamingScheme = pascal ? NamingScheme.PascalCase : NamingScheme.Direct, CollectionType = collectionType, CollectionImplementationType = collectionImplementationType, CodeTypeReferenceOptions = codeTypeReferenceOptions, TextValuePropertyName = textValuePropertyName, GenerateDebuggerStepThroughAttribute = generateDebuggerStepThroughAttribute, DisableComments = disableComments, GenerateDescriptionAttribute = generateDescriptionAttribute, DoNotUseUnderscoreInPrivateMemberNames = doNotUseUnderscoreInPrivateMemberNames, EnableUpaCheck = enableUpaCheck }; if (pclCompatible) { generator.UseXElementForAny = true; generator.GenerateDesignerCategoryAttribute = false; generator.GenerateSerializableAttribute = false; generator.GenerateDebuggerStepThroughAttribute = false; generator.DataAnnotationMode = DataAnnotationMode.None; generator.GenerateDescriptionAttribute = false; } if (verbose) { generator.Log = s => System.Console.Out.WriteLine(s); } generator.Generate(files); }
static void Main(string[] args) { string outputFolder = Path.Join(Environment.CurrentDirectory, "out"); var resolve = new List <string>(); var exclusions = new List <string>(); var options = new OptionSet { { "o|output=", "Output folder", o => outputFolder = o }, { "v", "Increase verbosity", v => { if (v != null) { Logger.Verbosity++; } } }, { "r|resolve=", "Additional resolve folders", r => resolve.Add(r) }, { "e|exclude=", "Excluded files", e => exclusions.Add(e) } }; List <string> extras; try { extras = options.Parse(args); } catch (OptionException ex) { Logger.Error(ex); return; } if (!Directory.Exists(outputFolder)) { try { Directory.CreateDirectory(outputFolder); } catch (IOException ex) { Logger.Error(ex); return; } } if (!Path.IsPathRooted(outputFolder)) { outputFolder = Path.Combine(Environment.CurrentDirectory, outputFolder); } Logger.Trace($"Writing files to '{outputFolder}'", 1); var excludedFiles = new HashSet <string>(); foreach (string exclusion in exclusions) { foreach (string file in Glob.ExpandNames(exclusion)) { excludedFiles.Add(file); } } foreach (string extra in extras) { foreach (string fileName in Glob.ExpandNames(extra)) { if (excludedFiles.Contains(fileName)) { Logger.Trace($"Excluding file '{fileName}'", 2); continue; } try { List <string> paths = new List <string>(resolve); paths.Add(Path.GetDirectoryName(fileName)); GenerateStrippedAssembly(fileName, outputFolder, paths); } catch (Exception ex) { Logger.Error(ex); } } } }
public static int Main(string[] args) { #if DNX451 || NET451 System.Threading.Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture; #else CultureInfo.CurrentCulture = CultureInfo.InvariantCulture; #endif var options = new Options { OutputFile = default(string), OutputFormat = ".pot", InputFormat = default(string), Keywords = new List <Keyword>(), InputPatterns = new List <string>() }; for (var i = 0; i < args.Length; i++) { var arg = args[i]; if (arg.StartsWith("-")) { if (arg == "-o" || arg == "--output") { options.OutputFile = args[++i]; continue; } if (arg == "-f" || arg == "--format") { options.OutputFormat = args[++i]; continue; } if (arg == "-k" || arg == "--keyword") { options.Keywords.Add(Keyword.Parse(args[++i])); continue; } if (arg == "-l" || arg == "--language") { options.InputFormat = args[++i]; continue; } PrintUsage("Unrecognized argument '{0}'", arg); return(-1); } options.InputPatterns.Add(arg); } if (options.InputPatterns.Count <= 0) { PrintUsage(); return(-1); } if (options.InputFormat != null && !extractors.ContainsKey(options.InputFormat)) { PrintUsage("Language '{0}' not found", options.InputFormat); return(-1); } var generatorFactory = default(IGeneratorFactory); if (string.IsNullOrEmpty(options.OutputFormat) || !generators.TryGetValue(options.OutputFormat, out generatorFactory)) { PrintUsage("Generator '{0}' not found", options.OutputFormat); return(-1); } var files = options.InputPatterns .SelectMany(f => Glob.ExpandNames(f)) .ToArray(); var missingFiles = files.Where(f => !File.Exists(f)).ToArray(); if (missingFiles.Length > 0) { PrintUsage("Files {0} not found", string.Join(", ", missingFiles.Select(f => $"'${f}'"))); return(-1); } if (options.InputFormat == null) { var unknownFiles = files.Where(f => !extractors.ContainsKey(Path.GetExtension(f))).ToArray(); if (unknownFiles.Length > 0) { PrintUsage("Unknown format for files: {0}", string.Join(", ", unknownFiles.Select(f => $"'${f}'"))); return(-1); } } var matches = new List <KeywordMatch>(); foreach (var file in files) { using (var stream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.Read)) using (var reader = new StreamReader(stream)) { var extension = options.InputFormat ?? Path.GetExtension(file); var extractor = extractors[extension]; var effectiveKeywords = options.Keywords.Count > 0 ? options.Keywords : extractor.DefaultKeywords; var calls = extractor.GetInvocations(reader, fileName: file); foreach (var call in calls) { var match = effectiveKeywords.Select(k => k.Match(call)) .Where(m => m != null) .FirstOrDefault(); if (match == null) { continue; } matches.Add(match); } } } var groups = matches.GroupBy(m => m, m => m, (k, g) => new KeywordMatchGroup(k.Singular, k.Plural, k.Context, g.Where(i => i.Source != null).Select(i => i.Source.Value)) ); var hasOutputFile = !string.IsNullOrEmpty(options.OutputFile) && options.OutputFile != "-"; using (var outputStream = hasOutputFile ? new FileStream(options.OutputFile, FileMode.Create, FileAccess.Write, FileShare.None) : Console.OpenStandardOutput()) using (var generator = generatorFactory.Create(outputStream, new UTF8Encoding(false, true))) { generator.WriteHeader(); foreach (var group in groups) { generator.WriteEntry(group); } generator.WriteFooter(); generator.Flush(); } return(0); }