protected override int Execute() { var baseResult = base.Execute(); if (baseResult != 0) { return(baseResult); } var metadata = new GenymanMetadata(); var version = GetVersion(); Log.Information($"Executing new command for {metadata.PackageId} - Version {version}"); var sw = Stopwatch.StartNew(); var configuration = new GenymanConfiguration <TConfiguration> { Genyman = metadata, Configuration = new TTemplate(), }; var output = ""; var extension = "json"; if (JsonOption.HasValue()) { output = configuration.ToJsonString(); extension = "json"; } else //Later support more formats! { // DEFAULT is json output = configuration.ToJsonString(); extension = "json"; } var fileName = !string.IsNullOrEmpty(FileNameOption.Value()) ? FileNameOption.ParsedValue : $"gm-{metadata.Identifier.ToLower()}"; fileName = $"{fileName}.{extension}"; var fullFileName = Path.Combine(Environment.CurrentDirectory, fileName); if (File.Exists(fileName) && !Overwrite.HasValue()) { Log.Error($"File {fullFileName} already exists. Specify --overwrite if you want to overwrite files"); return(-1); } File.WriteAllText(fullFileName, output); Log.Information($"Configuration file {fileName} was written"); Log.Information($"Finished ({sw.ElapsedMilliseconds}ms)"); return(0); }
/// <summary> /// JsonObject constructor by a given key-value pair of items. /// </summary> /// <param name="keys">Key or keys</param> /// <param name="values">Value or values</param> /// <param name="nesting">Apply nesting behaviour if key input is a single string concatenated by dots, representing the desired nested structure</param> /// <param name="jsonOption">Options to modify a JsonObject</param> internal JsonObject(List <string> keys, List <object> values, bool nesting, JsonOption jsonOption) { if (nesting) { List <KeyValuePair <string, object> > pair = keys.Zip(values, (k, v) => new KeyValuePair <string, object>(k, v)).ToList(); pair.ForEach(p => AddRecursive(this, p.Key, p.Value, jsonOption)); } else { List <KeyValuePair <string, object> > pair = keys.Zip(values, (k, v) => new KeyValuePair <string, object>(k, v)).ToList(); pair.ForEach(p => AddInternal(this, p.Key, p.Value, jsonOption)); } }
public static JsonObject ByKeysAndValues([ArbitraryDimensionArrayImport] List <string> keys, [KeepReference][ArbitraryDimensionArrayImport] List <object> values, [DefaultArgument("true")] bool nesting, [DefaultArgument("JsonOption.None")] JsonOption jsonOption) { if (keys == null) { throw new ArgumentNullException("keys"); } if (values == null) { throw new ArgumentNullException("values"); } if (keys.Count != values.Count) { string error = String.Format("Keys and values need to be of same size.\nKeys: {0}\nValues: {1}", keys.Count, values.Count); throw new ArgumentException(error); } if (values.Contains(null)) { throw new ArgumentNullException("values", "Values' input contains one or more null elements."); } return(new JsonObject(keys, values, nesting, jsonOption)); }
public static JsonObject Merge(JsonObject jsonObject, List <JsonObject> others, [DefaultArgument("JsonOption.None")] JsonOption jsonOption) { Dictionary <string, object> dict = new Dictionary <string, object>(); List <string> keys = new List <string>(); List <object> values = new List <object>(); foreach (KeyValuePair <string, object> x in jsonObject.dict.ToList()) { keys.Add(x.Key); values.Add(x.Value); } foreach (var other in others) { foreach (KeyValuePair <string, object> y in other.dict.ToList()) { keys.Add(y.Key); values.Add(y.Value); } } return(new JsonObject(keys, values, true, jsonOption)); }
public static JsonObject Add(JsonObject jsonObject, List <string> key, List <object> value, bool nesting, JsonOption jsonOption) { if (key == null) { throw new ArgumentNullException("key"); } if (value == null) { throw new ArgumentNullException("value"); } List <string> keys = jsonObject.Keys.Concat(key).ToList(); List <object> values = jsonObject.Values.Concat(value).ToList(); return(new JsonObject(keys, values, nesting, jsonOption)); }
/// <summary> /// Method to add values recursively to a JsonObject. /// </summary> /// <param name="json"></param> /// <param name="key"></param> /// <param name="value"></param> /// <param name="jsonOption"></param> /// <returns></returns> internal static JsonObject AddRecursive(JsonObject json, string key, object value, JsonOption jsonOption) { //If key doens't contain a dot, recursiveness is not applied. if (!key.Contains(".")) { json = AddInternal(json, key, value, jsonOption); } else { string[] keys = key.Split('.'); string k = keys.First(); string restOfKeys = String.Join(".", keys.Skip(1).ToArray()); bool containsKey = json.dict.ContainsKey(k); //If contains key, the associated value will be a JsonObject. if (containsKey) { JsonObject newJson = json.dict[k] as JsonObject; JsonObject jsonRecursive = AddRecursive(newJson, restOfKeys, value, jsonOption); json.dict[k] = jsonRecursive; } else { JsonObject newJson = new JsonObject(); JsonObject jsonRecursive = AddRecursive(newJson, restOfKeys, value, jsonOption); json = AddInternal(json, k, jsonRecursive, jsonOption); } } return(json); }
internal static JsonObject AddInternal(JsonObject json, string key, object value, JsonOption jsonOption) { if (json.dict.ContainsKey(key)) { switch (jsonOption) { case JsonOption.Update: json.dict[key] = value; break; case JsonOption.Combine: if (json.dict[key] is IList <object> && json.dict[key].GetType().IsGenericType) { List <object> listValue = json.dict[key] as List <object>; listValue.Add(value); json.dict[key] = listValue; } else { json.dict[key] = new List <object>() { json.dict[key], value }; } break; default: json.dict.Add(key, value); break; } } else { json.dict.Add(key, value); } return(json); }
public JsonParser AddOption(JsonOption option) { this.options.Add(option); return(this); }