Daily works

core/uim/core/containers/arrays/array_.d

@@ -245,6 +245,22 @@ bool has(T)(in T[] source, in T[] values) {
   return hasAllValues(source, values);
 }
 
+bool hasAll(T)(in T[] source, in T[] values...) {
+  return hasAllValues(source, values.dup);
+}
+
+bool hasAll(T)(in T[] source, in T[] values) {
+  return hasAllValues(source, values);
+}
+
+bool hasAny(T)(in T[] source, in T[] values...) {
+  return hasAnyValues(source, values.dup);
+}
+
+bool hasAny(T)(in T[] source, in T[] values) {
+  return hasAnyValues(source, values);
+}
+
 // #region hasAllValues & hasValue
 bool hasAllValues(T)(in T[] source, in T[] values...) {
   return hasAllValues(source, values.dup);

core/uim/core/containers/maps/keys/map.d

@@ -128,10 +128,12 @@ V[K] renameKeys(K, V)(V[K] entries, K[K] mapping) {
   return results;
 }
 
+// Returns a new map with the specified key(s) renamed
 V[K] renameKey(K, V)(V[K] entries, K[] originalPath, K[] newPath) {
   return entries.renameKey(originalPath.join("."), newPath.join("."));
 }
 
+// Returns a new map with the specified key(s) renamed
 V[K] renameKey(K, V)(V[K] entries, K originalKey, K newKey) {
   V[K] results = entries.dup;
   if (!results.hasKey(originalKey)) {

core/uim/core/containers/maps/keys/string_.d

@@ -35,10 +35,10 @@ V[K] addPrefixKey(K, V)(V[K] items, K key, K prefix) if (is(K == string)) {
 }
 
 unittest {
-  assert(["a": "1", "b": "2"].addPrefixKey("b", "x").hasKey("xb"));
+/*   assert(["a": "1", "b": "2"].addPrefixKey("b", "x").hasKey("xb"));
   assert(!["a": "1", "b": "2"].addPrefixKey("a", "x").hasKey("a"));
   assert(["a": "1", "b": "2"].addPrefixKey("b", "x")["xb"] == "2");
-  assert(["a": "1", "b": "2"].addPrefixKey("b", "x")["a"] == "1");
+  assert(["a": "1", "b": "2"].addPrefixKey("b", "x")["a"] == "1"); */
 
 /*   assert(["a": "1"].addPrefixKey("x")["xa"] == "1");
   assert(["a": "1", "b": "2"].addPrefixKey("x").hasKey("xb")); */

core/uim/core/containers/maps/map.d

@@ -5,8 +5,8 @@
 *****************************************************************************************************************/
 module uim.core.containers.maps.map;
 
-@safe:
 import uim.core;
+@safe:
 
 enum SORTED = true;
 enum NOTSORTED = false;

core/uim/core/containers/maps/string_.d

@@ -37,22 +37,20 @@ STRINGAA filterByValues(string[string] entries, string[] someValues) {
 }
 
 unittest {
-  assert(["a": "1", "b": "2"].filterByValues("1") == ["a": "1"]);
+  /*   assert(["a": "1", "b": "2"].filterByValues("1") == ["a": "1"]);
   assert(["a": "1", "b": "2"].filterByValues("0").empty);
   // TODO    assert(["a": "1", "b": "2", "c": "3"].filterByValues("1", "2") == ["a": "1"]);
-  assert(["a": "1", "b": "2", "c": "3"].filterByValues("0").empty);
+  assert(["a": "1", "b": "2", "c": "3"].filterByValues("0").empty); */
 }
 // #endregion filter
 
 string toString(string[string] aa) {
   return "%s".format(aa);
 }
 
-
-  unittest {
-    /// Add Tests
-  }
-
+unittest {
+  /// Add Tests
+}
 
 string aa2String(string[string] atts, string sep = "=") {
   string[] strings;
@@ -76,8 +74,6 @@ unittest {
   /// TODO Add Tests
 }
 
-
-
 // #region update
 STRINGAA update(string[string] items, string key, bool value) {
   return items.update(key, to!string(value));
@@ -133,5 +129,3 @@ unittest {
   assert(merge(testmap, "a", "A")["a"] == "A");
 }
 // #endregion merge
-
-

core/uim/core/convert/package.d

@@ -0,0 +1,11 @@
+module uim.core.convert;
+
+import uim.core;
+@safe:
+
+STRINGAA toStringMap(Json[string] map) {
+  STRINGAA stringMap;
+  map.byKeyValue
+    .each!(kv => stringMap[kv.key] = kv.value.to!string);
+  return stringMap;
+}

core/uim/core/datatypes/boolean.d

@@ -28,18 +28,16 @@ bool toggle(bool value) {
   return !value;
 }
 
-bool toggle(ref bool value) {
-  value = !value;
-  return value;
-}
-
 unittest {
   assert(toggle(true) == false, "Error in toggle(bool)");
   assert(toggle(toggle(true)) == true, "Error in toggle(bool)");
 
   bool value = true;
   assert(value.toggle == false);
-  assert(value == false);
+  /* assert(value == false);
+
+  value = true;
+  assert(value.toggle.toggle == true); */
 }
 
 /// Translates boolean to defined values
@@ -50,6 +48,9 @@ pure T translate(T)(bool value, T ifTrue, T ifFalse) {
 unittest {
   assert(translate(true, "YES", "NO") == "YES", "Error in translate(bool, T, T)");
   assert(translate(false, "YES", "NO") == "NO", "Error in translate(bool, T, T)");
+
+  assert(translate(true, 1, 2) == 1, "Error in translate(bool, T, T)");
+  assert(translate(false, 1, 2) == 2, "Error in translate(bool, T, T)");
 }
 
 /// Translates boolean to defined values

core/uim/core/datatypes/json.d

@@ -22,12 +22,31 @@ unittest {
   assert(Null!Json.isNull);
 }
 
-// #region Properties
+// #region keys
+// Get keys from json object
 string[] keys(Json anObject) {
   return !anObject.isNull
     ? anObject.byKeyValue.map!(kv => kv.key).array : null;
 }
-// #endregion Properties
+unittest {
+  auto json = parseJsonString(`{"a": "b", "c": {"d": 1}, "e": ["f", {"g": "h"}]}`);
+  assert(json.keys.hasAll("a", "c", "e"));
+  assert(!json.keys.hasAll("a", "c", "x"));
+}
+// #endregion keys
+
+// #region values
+// Get values from json object
+Json[] values(Json anObject) {
+  return !anObject.isNull
+    ? anObject.byKeyValue.map!(kv => kv.value).array : null;
+}
+unittest {
+  auto json = parseJsonString(`{"a": "b", "c": {"d": 1}, "e": ["f", {"g": "h"}]}`);
+/*   assert(json.values.hasAll("a", "c", "e"));
+  assert(!json.values.hasAll("a", "c", "x")); */
+}
+// #endregion values
 
 // #region Check json value
 bool isMap(Json json) {
@@ -109,10 +128,14 @@ unittest {
   assert(!parseJsonString(`1.1`).isInteger);
 }
 
+// #region isNull
+// Check if json value is null
 bool isNull(Json value) {
   return (value.type == Json.Type.null_);
 }
 
+mixin(CheckJsonIs!("Null"));
+
 bool isNull(Json value, string[] path) {
   if (uim.core.containers.arrays.array_.isEmpty(path)) {
     return true;
@@ -128,23 +151,71 @@ bool isNull(Json value, string[] path) {
 }
 
 bool isNull(Json value, string key) {
-  return value.isObject && value.hasKey(key);
+  return value.isObject && value.hasKey(key) 
+    ? value[key].isNull
+    : true;
 }
 
 unittest {
-  /* assert(Json(null).isNull);
+  assert(Json(null).isNull);
   assert(!Json.emptyObject.isNull);
-  assert(!Json.emptyArray.isNull); */
+  assert(!Json.emptyArray.isNull);
+
+  auto json = parseJsonString(`{"a": "b", "c": {"d": 1}, "e": ["f", {"g": "h"}]}`);
+  assert(json.isNull("x"));
+  assert(!json.isNull("a"));
+
+  assert(json.isNull(["x"]));
+  assert(!json.isNull(["a"]));
+  assert(json.isNull(["c", "x"]));
+  assert(!json.isNull(["c", "d"]));
+  assert(json.isNull(["c", "d", "x"]));
+
+  assert(json.allNull(["x", "y"]));
+  assert(!json.allNull(["a", "y"]));
+  assert(json.anyNull(["x", "y"]));
+  assert(!json.anyNull(["a", "c"]));
 }
+// #endregion isNull
 
+// #region isString
 bool isString(Json value) {
   return (value.type == Json.Type.string);
 }
 
+mixin(CheckJsonIs!("String"));
+
+bool isString(Json value, string[] path) {
+  if (value.isNull(path)) {
+    return false;
+  }
+
+  auto firstKey = path[0];
+  if (value.isString(firstKey)) {
+    return true;
+  }
+
+  return path.length > 1
+    ? isString(value[firstKey], path.removeFirst) : false;
+}
+
+bool isString(Json value, string key) {
+  return value.isObject && value.hasKey(key) 
+    ? value[key].isString
+    : true;
+}
+
 unittest {
   assert(parseJsonString(`"a"`).isString);
   assert(!parseJsonString(`1.1`).isString);
+
+  auto json = parseJsonString(`{"a": "b", "c": {"d": 1}, "e": ["f", {"g": 1.1}], "i": {"j": "x"}}`);
+  assert(json.isString("a"));
+  assert(!json.isString("c"));
+  assert(json.isString(["i", "j"]));
+  assert(!json.isString(["e", "g"]));
 }
+// #endregion isString
 
 bool isUndefined(Json value) {
   return (value.type == Json.Type.undefined);
@@ -173,7 +244,8 @@ bool isIntegral(Json value) {
   return value.isLong;
 }
 
-/// Checks if every key is in json object
+// #region hasKey
+// Check if json has key
 bool hasAllKeys(Json json, string[] keys, bool deepSearch = false) {
   return keys
     .filter!(k => hasKey(json, k, deepSearch))
@@ -239,6 +311,7 @@ unittest {
   assert(json.hasKey("a"));
   assert(json.hasKey("d", true));
 }
+// #endregion hasKey
 
 bool hasAllValues(Json json, Json[] values, bool deepSearch = false) {
   foreach (value; values)

core/uim/core/mixins/json.d

@@ -0,0 +1,21 @@
+module uim.core.mixins.json;
+
+template CheckJsonIs(string jsonType) {
+  const char[] CheckJsonIs = `
+bool all`~jsonType~`(Json value, string[] keys...) {
+  return value.all`~jsonType~`(keys.dup);
+}
+
+bool all`~jsonType~`(Json value, string[] keys) {
+  return keys.all!(key => value.is`~jsonType~`(key));
+}
+
+bool any`~jsonType~`(Json value, string[] keys...) {
+  return value.any`~jsonType~`(keys.dup);
+}
+
+bool any`~jsonType~`(Json value, string[] keys) {
+  return keys.any!(key => value.is`~jsonType~`(key));
+}
+`;
+}

core/uim/core/mixins/package.d

@@ -7,6 +7,7 @@ module uim.core.mixins;
 
 public {
   import uim.core.mixins.function_;
+  import uim.core.mixins.json;
   import uim.core.mixins.phobos;
   import uim.core.mixins.properties;
 }

core/uim/core/package.d

@@ -12,6 +12,7 @@ public import vibe.d;
 public {
   import uim.core.classes;
   import uim.core.containers;
+  import uim.core.convert;
   import uim.core.datatypes;
   import uim.core.dlang;
   import uim.core.enumerations;