Release v0.4.3

Author: KaruroChori

RELEASE.md

@@ -1,10 +1,14 @@
 ## v0.4.3
 
+Very minor release, just so that downstream code can take advantage of several fixes and new features.  
+Also, this release restores the WASM/WASI build which broke due to `from_chars` compatibility across toolchains.
+
 ### New features
 
-- Natural ordering for strings is now supported
+- Natural ordering for strings is now supported in `order-by` by all commands (as the new default)
+- `order-by` directives can be typed, like `asc:float` or `asc:f` will parse entries as float and sort them accordingly.
 
 ### Breaking
 
-- `s:enable` has been reworked as an overload of `s:when`.
-- Default string comparisons are now following natural ordering.
+- `s:enable.*` has been reworked as an overload of `s:when`. Use it as `s:when.*`.
+- Default string comparisons are now following natural ordering, which might break things.

TODO.md

@@ -2,12 +2,17 @@
 
 ## `v0.4.3`
 
-- [ ] Rework the mechanisms used in `order-by` and fill missing comparisons in the RPN
-  - [ ] Extend `order-by` to support explicit types for comparison (extremely optional)
-  - [x] Support for string natural order (111 > 22).
+- [x] Basic support for natural ordering (in commands only, not vm for now)
+- [x] Extend `order-by` to support explicit types for comparison (extremely optional)
+- [x] Fixing the WASM build
 
 ## `v0.4.5`
 
+- [ ] Stringview version of `strnatcmp` to optimize the dot comparisons
+- [ ] Rework the mechanisms used in `order-by` and fill missing comparisons in the RPN
+
+## `v0.4.7`
+
 - [ ] Properly show ctx information while logging
 - [ ] In the UI for the demo, add a loader as the first boot is quite slow
 - [ ] Fill in the docs at least of the public interface

docs/ordering.md

@@ -3,7 +3,7 @@ Ordering criteria are used in two situations:
 - in the `order-by` attributes of cycles for each type but `for-range`
 - as basic boolean binary operator in the RPN virtual machine
 
-The two implementations are not unified, so feature parity is desired but not intrinsic.
+The two implementations are not unified, so feature parity is desirable but not intrinsic.
 
 ## Order types
 
@@ -13,7 +13,7 @@ Whatever ordinal is assigned to the entries, sorting is just based on an ascendi
 
 ### `RANDOM`
 
-Data of any type is first hashed, and `ASC` is applied to those hashes.
+Data of any type is first hashed, and `asc` is applied to those hashes.
 For integers, floats and booleans this just involves their immediate data.  
 For strings the characters buffer is used as the hash source. If the dot notation is needed, each token separated by `.` will be hashed and compared on its own.
 Nodes should not be directly compared. Doing so is not illegal, just nonsensical.
@@ -22,24 +22,28 @@ Nodes should not be directly compared. Doing so is not illegal, just nonsensical
 
 ### Nodes
 
+Via suffix `:n` or `:node`.  
 Nodes should not be directly compared.  
 Doing so is not illegal, just nonsensical and UB.  
 A more precise semantic for this case might be introduced later on.
 
-### Attributes
+### ~~Attributes~~
 
-By default, they are cast to string before evaluation.
+They are always cast to string before evaluation. So they will not be compared as XML nodes.
 
 ### Integers
 
+Via suffix `:i`, `:int` or `:integer`.  
 Comparison as expected from any basic math class.
 
 ### Floats
 
+Via suffix `:f`, `:float``.  
 Comparison as expected from any basic math class.
 
 ### Booleans
 
+Via suffix `:b`, `:bool` or `:boolean`.  
 `true` is smaller than `false`.
 
 ### Strings
@@ -48,14 +52,17 @@ Strings are by far the most complex to handle as multiple criteria are possible.
 
 #### Encoding ordering
 
+Via suffix `:s`, `:str` or `:string`.
 Based on the binary representation of UTF-8 encoding.
 
 #### Natural ordering
 
+Via suffix `:ns`, `:natstr` or `:natural-string`.
 `hello10` bigger than `hello2`.
 
 #### Lexicographic ordering
 
+Via suffix `:ls`, `:lexistr` or `:lexi-string`.
 For symbols in the Latin alphabet this is more or less equivalent to the encoding ordering.  
 However, different languages have totally different customary approaches, and are not often based on alphabets.  
 Basically any criteria rooted in linguistic arguments goes in here.

docs/releases/v0.4.3.md

@@ -0,0 +1,14 @@
+## v0.4.3
+
+Very minor release, just so that downstream code can take advantage of several fixes and new features.  
+Also, this release restores the WASM/WASI build which broke due to `from_chars` compatibility across toolchains.
+
+### New features
+
+- Natural ordering for strings is now supported in `order-by` by all commands (as the new default)
+- `order-by` directives can be typed, like `asc:float` or `asc:f` will parse entries as float and sort them accordingly.
+
+### Breaking
+
+- `s:enable.*` has been reworked as an overload of `s:when`. Use it as `s:when.*`.
+- Default string comparisons are now following natural ordering, which might break things.

include/utils.hpp

@@ -9,13 +9,14 @@
 namespace vs{
 namespace templ{
 
-template <typename T, typename... Args> struct concatenator;
-
-template <typename... Args0, typename... Args1>
-struct concatenator<std::variant<Args0...>, Args1...> {
-    using type = std::variant<Args0..., Args1...>;
-};
-
+/**
+ * @brief Get a value from a variant, or if not valid returns a default value.
+ * 
+ * @tparam T 
+ * @param ref 
+ * @param defval 
+ * @return const T& 
+ */
 template<typename T>
 const T& get_or(const auto& ref, const T& defval) noexcept{
     if(std::holds_alternative<T>(ref))return std::get<T>(ref);

meson.build

@@ -1,7 +1,7 @@
 project(
   'vs-templ',
   ['cpp'],
-  version: '0.4.2',
+  version: '0.4.3',
   meson_version: '>= 1.1',
   default_options: ['cpp_std=c++20'],
 )

scripts/codegen.sh

@@ -1,3 +1,3 @@
 #!/bin/bash
-
+# Not used for now.
 gperf ./schemas/vm.gperf --output-file ./src/vm.autogen.cpp

src/vs-templ.cpp

@@ -220,15 +220,31 @@ std::optional<symbol> preprocessor::resolve_expr(const std::string_view& _str, c
 
 preprocessor::order_t preprocessor::order_from_string(std::string_view str){
     //TODO: extend to specify type. Syntax: `type:method`
+    int offset = 0;
     order_t tmp;
-    if(str[0]=='.'){tmp.modifiers.dot=true;}
-    if((std::string_view(str.begin()+tmp.modifiers.dot, str.end()) == std::string_view("asc"))){tmp.method=order_t::method_t::ASC;}
-    else if((std::string_view(str.begin()+tmp.modifiers.dot, str.end()) == std::string_view("desc"))){tmp.method=order_t::method_t::DESC;}
-    else if((std::string_view(str.begin()+tmp.modifiers.dot, str.end()) == std::string_view("random"))){tmp.method=order_t::method_t::RANDOM;}
+    if(str.starts_with(".")){tmp.modifiers.dot=true;offset++;}
+    std::string_view pstr = std::string_view(str.begin()+offset, str.end());
+    if((pstr.starts_with("asc"))){tmp.method=order_t::method_t::ASC;offset+=std::string_view("asc").length();}
+    else if(pstr.starts_with("desc")){tmp.method=order_t::method_t::DESC;offset+=std::string_view("desc").length();}
+    else if(pstr.starts_with("random")){tmp.method=order_t::method_t::RANDOM;offset+=std::string_view("random").length();}
     else{
-        log(log_t::WARNING,std::format("`{}` is not a valid criterion for comparison",str));
+        log(log_t::WARNING,std::format("`{}` is not a valid criterion for comparison",pstr));
     }
 
+    pstr = std::string_view(str.begin()+offset, str.end());
+
+    //Technically this would allow things like `.arc:hello:i` but to be honest I am not concerned with that
+    if(pstr==":i" || pstr==":int" || pstr==":integer")tmp.type=order_t::type_t::INTEGER;
+    else if(pstr==":f" || pstr==":float")tmp.type=order_t::type_t::FLOAT;
+    else if(pstr==":b" || pstr==":bool"|| pstr==":boolean")tmp.type=order_t::type_t::BOOLEAN;
+    else if(pstr==":s" || pstr==":str"|| pstr==":string")tmp.type=order_t::type_t::STRING;
+    else if(pstr==":ns" || pstr==":natstr" || pstr==":natural-string")tmp.type=order_t::type_t::NATURAL_STRING;
+    else if(pstr==":ls" || pstr==":lexistr" || pstr==":lexi-string")tmp.type=order_t::type_t::LEXI_STRING;
+    else if(pstr==":n" || pstr==":node")tmp.type=order_t::type_t::NODE;
+    else if(pstr.length()>0){
+        log(log_t::WARNING,std::format("`{}` is not a valid type for comparison",pstr));
+    }
+    
     return tmp;
 }