#870 Nuget push

azist · Jul 21, 2023 · 04fac45 · 04fac45
1 parent c89092f
commit 04fac45
Show file tree

Hide file tree

Showing 6 changed files with 127 additions and 10 deletions.
diff --git a/elm/build/build-packages.cmd b/elm/build/build-packages.cmd
@@ -1,7 +1,7 @@
 @echo on
 
-set VER=3.6.0.3
-set HEADLINE=Decipher null check
+set VER=3.6.0.5
+set HEADLINE=Base64 leading spaces
 call build-all Release %VER%
 
 if errorlevel 1 goto BUILD_ERROR

diff --git a/src/Azos/Conf/MacroRunner.cs b/src/Azos/Conf/MacroRunner.cs
@@ -151,16 +151,28 @@ public virtual string Macro_decipher(IConfigSectionNode node, string inputValue,
       }
 
       var algorithmName = macroParams.ValOf("algo", "alg", "a", "algorithm");//this may be blank
-      var toString = macroParams.Of("string", "str", "text", "txt").ValueAsBool(false);//true to decode into string vs base:64 byte array
+      var required      = macroParams.Of("req", "require", "required").ValueAsBool(true);
+      var allowFailure  = macroParams.Of("allow-failure").ValueAsBool(false);
+      var toString      = macroParams.Of("string", "str", "text", "txt").ValueAsBool(false);//true to decode into string vs base:64 byte array
 
-      var result = Security.TheSafe.DecipherConfigValue(inputValue, toString, algorithmName);
+      if (inputValue.IsNotNullOrWhiteSpace())
+      {
+        var result = Security.TheSafe.DecipherConfigValue(inputValue, toString, algorithmName);
+
+        if (result == null && !allowFailure)
+        {
+          throw new ConfigException(StringConsts.CONFIG_MACRO_DECIPHER_FAILURE_ERROR.Args(inputValue.TakeFirstChars(8), inputValue.Length, node.RootPath));
+        }
+
+        return result;
+      }
 
-      if (result == null && !macroParams.Of("allow-failure").ValueAsBool(false))
+      if (required)
       {
-        throw new ConfigException(StringConsts.CONFIG_MACRO_DECIPHER_FAILURE_ERROR.Args(node.RootPath));
+        throw new ConfigException(StringConsts.CONFIG_MACRO_DECIPHER_RQUIRED_ERROR.Args(node.RootPath));
       }
 
-      return result;
+      return null;
     }
   }
 

diff --git a/src/Azos/Data/StringValueConversion.cs b/src/Azos/Data/StringValueConversion.cs
@@ -40,9 +40,13 @@ public static byte[] AsByteArray(this string val, byte[] dflt = null)
       if (val == null) return dflt;
       try
       {
-        if (val.Length > BASE64_VALUE_PREFIX.Length && val.StartsWith(BASE64_VALUE_PREFIX, StringComparison.OrdinalIgnoreCase))
+        if (val.Length > BASE64_VALUE_PREFIX.Length)
         {
-          return val.Substring(BASE64_VALUE_PREFIX.Length).FromWebSafeBase64();
+          var pp = val.GetPrefixedPart(BASE64_VALUE_PREFIX, StringComparison.OrdinalIgnoreCase);
+          if (pp.part.IsNotNullOrWhiteSpace())
+          {
+            return pp.part.FromWebSafeBase64();
+          }
         }
 
         var result = new List<byte>();

diff --git a/src/Azos/StrUtils.cs b/src/Azos/StrUtils.cs
@@ -554,6 +554,40 @@ public static KeyValuePair<string, string> SplitKVP(this string src, char delimi
       return new KeyValuePair<string, string>(src, string.Empty);
     }
 
+    /// <summary>
+    /// Returns an index of a starting segment (a prefix) in a string, bypassing all of
+    /// the following white characters (space, tab, return, LF) before the prefix.
+    /// Returns -1 if the string does not have a prefix or is null or whitespace
+    /// </summary>
+    public static int IndexOfPrefix(this string str, string pfx, StringComparison comp = StringComparison.Ordinal)
+    {
+      if (str.IsNullOrWhiteSpace()) return -1;
+      if (pfx.IsNullOrWhiteSpace()) return -1;
+
+      for(var i=0; i < str.Length; i++)
+      {
+        var c = str[i];
+        if (c is ' ' or '\t' or '\r' or '\n') continue;
+        if (str.IndexOf(pfx, i, comp) == i) return i;
+        return -1;
+      }
+
+      return -1;
+    }
+
+    /// <summary>
+    /// Tries to find a prefix bypassing whitespace characters in the beginning, then returns a prefixed remaining part
+    /// along with prefix index start. Returns (-1, null) if not found <seealso cref="IndexOfPrefix(string, string, StringComparison)"/>
+    /// </summary>
+    public static (int idxPfx, string part) GetPrefixedPart(this string str, string pfx, StringComparison comp = StringComparison.Ordinal)
+    {
+      var idx = str.IndexOfPrefix(pfx, comp);
+      if (idx < 0) return (-1, null);
+      var part = str.Substring(idx + pfx.Length);
+      return (idx, part);
+    }
+
+
     /// <summary>
     /// Provides string to byte[] conversion using a rented buffer.
     /// You must release the common buffer back by calling TextBytes.Dispose().

diff --git a/src/Azos/StringConsts_eng.cs b/src/Azos/StringConsts_eng.cs
@@ -339,7 +339,8 @@ Revise app container allocation logic which is usually at the app entry point.
     public const string CONFIG_NO_PROVIDER_LOAD_FORMAT_ERROR =
         "No configuration provider can open content supplied in this format: ";
 
-    public const string CONFIG_MACRO_DECIPHER_FAILURE_ERROR = "Could not `::decipher` the value around `{0}`. Check safe keys";
+    public const string CONFIG_MACRO_DECIPHER_FAILURE_ERROR = "Could not `::decipher` the value `{0}...`[{1}] around `{2}`. Check safe keys";
+    public const string CONFIG_MACRO_DECIPHER_RQUIRED_ERROR = "Missing required value for `::decipher` around `{0}`";
 
     public const string CONFIG_VARS_EVAL_ERROR =
         "Configuration variable '{0}' evaluation error: {1}";

diff --git a/src/testing/Azos.Tests.Nub/StrUtilsTests.cs b/src/testing/Azos.Tests.Nub/StrUtilsTests.cs
@@ -293,5 +293,71 @@ public void SplitKVP_8()
     [Run] public void TakeLastSegment_4() => Aver.AreEqual("here", "snake.zhaba/here".TakeLastSegment('/'));
     [Run] public void TakeLastSegment_5() => Aver.AreEqual("zhaba/here", "snake.zhaba/here".TakeLastSegment('.'));
 
+
+    [Run]
+    public void IndexOfPrefix_0()
+    {
+      string v = null;
+      string p = null;
+      Aver.AreEqual(-1, v.IndexOfPrefix(p));
+
+      p = "a";
+      Aver.AreEqual(-1, v.IndexOfPrefix(p));
+
+      v = "abc";
+      p = null;
+      Aver.AreEqual(-1, v.IndexOfPrefix(p));
+
+      v = "   ";
+      p = null;
+      Aver.AreEqual(-1, v.IndexOfPrefix(p));
+
+      v = null;
+      p = "  ";
+      Aver.AreEqual(-1, v.IndexOfPrefix(p));
+    }
+
+    [Run]
+    public void IndexOfPrefix_1()
+    {
+      Aver.AreEqual(-1, "   base64:fada".IndexOfPrefix("base65"));
+      Aver.AreEqual(-1, "   base64:fada".IndexOfPrefix("base64="));
+      Aver.AreEqual(0,  "base64:fada".IndexOfPrefix("base64"));
+      Aver.AreEqual(0,  "base64:fada".IndexOfPrefix("base64:"));
+      Aver.AreEqual(0,  "base64:fada".IndexOfPrefix("base64:fada"));
+      Aver.AreEqual(-1, "base64:fada".IndexOfPrefix("base64:fadaBa"));
+
+      Aver.AreEqual(3, "   base64:fada".IndexOfPrefix("base64:"));
+      Aver.AreEqual(11, " \t \r\r   \n  base64:fada".IndexOfPrefix("base64:"));
+      Aver.AreEqual(11, " \t \r\r   \n  base64:fada".IndexOfPrefix("base64"));
+    }
+
+    [Run]
+    public void GetPrefixedPart_1()
+    {
+      Aver.AreEqual(-1, "   base64:fada".GetPrefixedPart("base65").idxPfx);
+      Aver.AreEqual(-1, "   base64:fada".GetPrefixedPart("base64=").idxPfx);
+
+      Aver.AreEqual(0, "base64:fada".GetPrefixedPart("base64").idxPfx);
+      Aver.AreEqual(":fada", "base64:fada".GetPrefixedPart("base64").part);
+
+      Aver.AreEqual(0,  "base64:fada".GetPrefixedPart("base64:").idxPfx);
+      Aver.AreEqual("fada", "base64:fada".GetPrefixedPart("base64:").part);
+
+      Aver.AreEqual(0,  "base64:fada".GetPrefixedPart("base64:fada").idxPfx);
+      Aver.AreEqual("", "base64:fada".GetPrefixedPart("base64:fada").part);
+
+      Aver.AreEqual(-1, "base64:fada".GetPrefixedPart("base64:fadaBa").idxPfx);
+
+      Aver.AreEqual(3,  "   base64:fada".GetPrefixedPart("base64:").idxPfx);
+      Aver.AreEqual("fada", "   base64:fada".GetPrefixedPart("base64:").part);
+
+      Aver.AreEqual(11,     " \t \r\r   \n  base64:fada".GetPrefixedPart("base64:").idxPfx);
+      Aver.AreEqual("fada", " \t \r\r   \n  base64:fada".GetPrefixedPart("base64:").part);
+
+      Aver.AreEqual(11,      " \t \r\r   \n  base64:fada".GetPrefixedPart("base64").idxPfx);
+      Aver.AreEqual(":fada", " \t \r\r   \n  base64:fada".GetPrefixedPart("base64").part);
+    }
+
   }
 }