E9

- Working towards arg date/duration eval.

src/A3.cpp

@@ -830,6 +830,7 @@ const A3 A3::tokenize (const A3& input) const
     n.skipWS ();
   }
 
+  output.dump ("A3::tokenize");
   return output;
 }
 
@@ -863,6 +864,7 @@ const A3 A3::infix (const A3& input) const
     previous = *arg;
   }
 
+  modified.dump ("A3::infix");
   return modified;
 }
 
@@ -1036,6 +1038,7 @@ const A3 A3::expand (const A3& input) const
     previous = arg;
   }
 
+  expanded.dump ("A3::expand");
   return expanded;
 }
 
@@ -1109,6 +1112,7 @@ const A3 A3::sequence (const A3& input) const
       sequenced.push_back (*arg);
   }
 
+  sequenced.dump ("A3::sequence");
   return sequenced;
 }
 
@@ -1207,6 +1211,7 @@ const A3 A3::postfix (const A3& input) const
     op_stack.pop_back ();
   }
 
+  converted.dump ("A3::postfix");
   return converted;
 }
 

src/DOM.cpp

@@ -30,8 +30,6 @@
 #include <sstream>
 #include <Context.h>
 #include <Nibbler.h>
-#include <Date.h>
-#include <Duration.h>
 #include <text.h>
 #include <i18n.h>
 #include <DOM.h>

src/Duration.cpp

@@ -57,7 +57,6 @@ static const char* durations[] =
   "minutes",
   "mins",
   "min",
-
   "mnths",
   "monthly",
   "months",
@@ -66,7 +65,6 @@ static const char* durations[] =
   "mo",
   "mths",
   "m",
-
   "quarterly",
   "quarters",
   "qrtrs",

src/E9.cpp

@@ -27,12 +27,24 @@
 
 #include <iostream> // TODO Remove.
 #include <Context.h>
+#include <Date.h>
+#include <Duration.h>
 #include <text.h>
 #include <A3.h>
 #include <E9.h>
 
 extern Context context;
 
+std::ostream& operator<< (std::ostream& out, const Term& term)
+{
+  out << term._raw   << "/"
+      << term._value << "/"
+      << term._type  << "/"
+      << term._category;
+
+  return out;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Perform all the necessary steps prior to an eval call.
 E9::E9 (const A3& args)
@@ -79,6 +91,7 @@ void E9::eval (const Task& task, std::vector <Term>& value_stack)
 {
   // Case sensitivity is configurable.
   bool case_sensitive = context.config.getBoolean ("search.case.sensitive");
+  std::string dateformat = context.config.get ("dateformat");
 
   std::vector <Term>::iterator arg;
   for (arg = _terms.begin (); arg != _terms.end (); ++arg)
@@ -167,6 +180,15 @@ void E9::eval (const Task& task, std::vector <Term>& value_stack)
     // Operand.
     else
     {
+      // Expand the value if possible.
+      if (arg->_category == "dom")
+        arg->_value = context.dom.get (arg->_raw, task);
+      else if (arg->_category == "date")
+        arg->_value = Date (arg->_raw, dateformat).toEpochString ();
+      else if (arg->_category == "duration")
+        arg->_value = (std::string)Duration (arg->_raw);
+
+      //std::cout << "# E9::eval operand " << *arg << "\n";
       value_stack.push_back (*arg);
     }
   }
@@ -206,12 +228,9 @@ bool E9::eval_match (Term& left, Term& right, bool case_sensitive)
 void E9::operator_not (Term& result, Term& right)
 {
   // TODO This is not right.
-  result = Term (right._raw, coerce (right, "bool")._value, "bool");
+  result = Term (right._raw, coerce (right, "bool")._value, "bool", right._category);
 
-  std::cout << "# not " << right._raw << "/" << right._value << "/" << right._category
-            << " --> "
-            << result._raw << "/" << result._value << "/" << result._category
-            << "\n";
+//  std::cout << "# not " << right << " --> " << result << "\n";
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -228,14 +247,7 @@ void E9::operator_and (Term& result, Term& left, Term& right)
     result._category = "bool";
   }
 
-/*
-  std::cout << "# " << left._raw << "/" << left._value << "/" << left._category
-            << " and "
-            << right._raw << "/" << right._value << "/" << right._category
-            << " --> "
-            << result._raw << "/" << result._value << "/" << result._category
-            << "\n";
-*/
+//  std::cout << "# " << left << " and " << right << " --> " << result << "\n";
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -252,14 +264,7 @@ void E9::operator_or (Term& result, Term& left, Term& right)
     result._category = "bool";
   }
 
-/*
-  std::cout << "# " << left._raw << "/" << left._value << "/" << left._category
-            << " or "
-            << right._raw << "/" << right._value << "/" << right._category
-            << " --> "
-            << result._raw << "/" << result._value << "/" << result._category
-            << "\n";
-*/
+//  std::cout << "# " << left << " or " << right << " --> " << result << "\n";
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -279,14 +284,7 @@ void E9::operator_xor (Term& result, Term& left, Term& right)
     result._category = "bool";
   }
 
-/*
-  std::cout << "# " << left._raw << "/" << left._value << "/" << left._category
-            << " xor "
-            << right._raw << "/" << right._value << "/" << right._category
-            << " --> "
-            << result._raw << "/" << result._value << "/" << result._category
-            << "\n";
-*/
+//  std::cout << "# " << left << " xor " << right << " --> " << result << "\n";
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -309,14 +307,7 @@ void E9::operator_lt (Term& result, Term& left, Term& right)
 
   result._category = "bool";
 
-/*
-  std::cout << "# " << left._raw << "/" << left._value << "/" << left._category
-            << " < "
-            << right._raw << "/" << right._value << "/" << right._category
-            << " --> "
-            << result._raw << "/" << result._value << "/" << result._category
-            << "\n";
-*/
+//  std::cout << "# " << left << " < " << right << " --> " << result << "\n";
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -340,14 +331,7 @@ void E9::operator_lte (Term& result, Term& left, Term& right)
 
   result._category = "bool";
 
-/*
-  std::cout << "# " << left._raw << "/" << left._value << "/" << left._category
-            << " <= "
-            << right._raw << "/" << right._value << "/" << right._category
-            << " --> "
-            << result._raw << "/" << result._value << "/" << result._category
-            << "\n";
-*/
+//  std::cout << "# " << left << " <= " << right << " --> " << result << "\n";
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -371,14 +355,7 @@ void E9::operator_gte (Term& result, Term& left, Term& right)
 
   result._category = "bool";
 
-/*
-  std::cout << "# " << left._raw << "/" << left._value << "/" << left._category
-            << " >= "
-            << right._raw << "/" << right._value << "/" << right._category
-            << " --> "
-            << result._raw << "/" << result._value << "/" << result._category
-            << "\n";
-*/
+//  std::cout << "# " << left << " >= " << right << " --> " << result << "\n";
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -401,14 +378,7 @@ void E9::operator_gt (Term& result, Term& left, Term& right)
 
   result._category = "bool";
 
-/*
-  std::cout << "# " << left._raw << "/" << left._value << "/" << left._category
-            << " > "
-            << right._raw << "/" << right._value << "/" << right._category
-            << " --> "
-            << result._raw << "/" << result._value << "/" << result._category
-            << "\n";
-*/
+//  std::cout << "# " << left << " > " << right << " --> " << result << "\n";
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -424,14 +394,7 @@ void E9::operator_inequal (
   else
     result._raw = result._value = "false";
 
-/*
-  std::cout << "# " << left._raw << "/" << left._value << "/" << left._category
-            << " != "
-            << right._raw << "/" << right._value << "/" << right._category
-            << " --> "
-            << result._raw << "/" << result._value << "/" << result._category
-            << "\n";
-*/
+//  std::cout << "# " << left << " != " << right << " --> " << result << "\n";
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -478,14 +441,7 @@ void E9::operator_equal (
     }
   }
 
-/*
-  std::cout << "# " << left._raw << "/" << left._value << "/" << left._category
-            << " = "
-            << right._raw << "/" << right._value << "/" << right._category
-            << " --> "
-            << result._raw << "/" << result._value << "/" << result._category
-            << "\n";
-*/
+//  std::cout << "# " << left << " = " << right << " --> " << result << "\n";
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -502,14 +458,7 @@ void E9::operator_match (
   else
     result._raw = result._value = "false";
 
-/*
-  std::cout << "# " << left._raw << "/" << left._value << "/" << left._category
-            << " ~ "
-            << right._raw << "/" << right._value << "/" << right._category
-            << " --> "
-            << result._raw << "/" << result._value << "/" << result._category
-            << "\n";
-*/
+//  std::cout << "# " << left << " ~ " << right << " --> " << result << "\n";
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -536,62 +485,31 @@ void E9::operator_nomatch (
   else
     result._raw = result._value = "false";
 
-/*
-  std::cout << "# " << left._raw << "/" << left._value << "/" << left._category
-            << " !~ "
-            << right._raw << "/" << right._value << "/" << right._category
-            << " --> "
-            << result._raw << "/" << result._value << "/" << result._category
-            << "\n";
-*/
+//  std::cout << "# " << left << " !~ " << right << " --> " << result << "\n";
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 void E9::operator_multiply (Term& result, Term& left, Term& right)
 {
-
-  std::cout << "# " << left._raw << "/" << left._value << "/" << left._category
-            << " * "
-            << right._raw << "/" << right._value << "/" << right._category
-            << " --> "
-            << result._raw << "/" << result._value << "/" << result._category
-            << "\n";
+  std::cout << "# " << left << " * " << right << " --> " << result << "\n";
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 void E9::operator_divide (Term& result, Term& left, Term& right)
 {
-
-  std::cout << "# " << left._raw << "/" << left._value << "/" << left._category
-            << " / "
-            << right._raw << "/" << right._value << "/" << right._category
-            << " --> "
-            << result._raw << "/" << result._value << "/" << result._category
-            << "\n";
+  std::cout << "# " << left << " / " << right << " --> " << result << "\n";
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 void E9::operator_add (Term& result, Term& left, Term& right)
 {
-
-  std::cout << "# " << left._raw << "/" << left._value << "/" << left._category
-            << " + "
-            << right._raw << "/" << right._value << "/" << right._category
-            << " --> "
-            << result._raw << "/" << result._value << "/" << result._category
-            << "\n";
+  std::cout << "# " << left << " + " << right << " --> " << result << "\n";
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 void E9::operator_subtract (Term& result, Term& left, Term& right)
 {
-
-  std::cout << "# " << left._raw << "/" << left._value << "/" << left._category
-            << " - "
-            << right._raw << "/" << right._value << "/" << right._category
-            << " --> "
-            << result._raw << "/" << result._value << "/" << result._category
-            << "\n";
+  std::cout << "# " << left << " - " << right << " --> " << result << "\n";
 }
 
 ////////////////////////////////////////////////////////////////////////////////

src/E9.h

@@ -39,6 +39,7 @@ public:
   Term ()
   : _raw ("")
   , _value ("")
+  , _type ("")
   , _category ("")
   {
   }
@@ -46,6 +47,7 @@ public:
   Term (const Arg& arg)
   : _raw (arg._raw)
   , _value (arg._raw)
+  , _type ("string")
   , _category (arg._category)
   {
   }
@@ -53,9 +55,11 @@ public:
   Term (
     const std::string& raw,
     const std::string& value,
+    const std::string& type,
     const std::string& category)
   : _raw (raw)
   , _value (value)
+  , _type (type)
   , _category (category)
   {
   }
@@ -64,6 +68,7 @@ public:
   {
     _raw      = other._raw;
     _value    = other._value;
+    _type     = other._type;
     _category = other._category;
   }
 
@@ -73,6 +78,7 @@ public:
     {
       _raw      = other._raw;
       _value    = other._value;
+      _type     = other._type;
       _category = other._category;
     }
 
@@ -83,12 +89,14 @@ public:
   {
     return _raw      == other._raw   &&
            _value    == other._value &&
+           _type     == other._type  &&
            _category == other._category;
   }
 
 public:
   std::string _raw;      // Raw input token, never modified
   std::string _value;    // Evaluated raw token, sometimes identical
+  std::string _type;     // Inferred type
   std::string _category; // Categorized argument
 };
 

src/TDB2.cpp

@@ -25,7 +25,6 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#include <iostream> // TODO Remove.
 #include <Context.h>
 #include <text.h>
 #include <TDB2.h>
@@ -281,6 +280,11 @@ void TF2::load_lines ()
 
   split (_lines, _contents, '\n');
   _loaded_lines = true;
+
+/*
+  if (_lines.back () == "")
+    _lines.pop_back ();
+*/
 }
 
 ////////////////////////////////////////////////////////////////////////////////

src/commands/Command.cpp

@@ -409,13 +409,19 @@ void Command::modify_task (
       A3::extract_attr (arg->_raw, name, value);
       if (A3::is_attribute (name, name))  // Canonicalize
       {
+        std::cout << "# Command::modify_task name='" << name << "' value='" << value << "'\n";
+
         // All values must be eval'd first.
         A3 fragment;
-        fragment.push_back (Arg (value, "attr"));
+        fragment.capture (value);
+        fragment = fragment.tokenize (fragment);
         E9 e (fragment);
         std::string result = e.evalExpression (task);
         context.debug (std::string ("Eval '") + value + "' --> '" + result + "'");
 
+fragment.dump ("pre modify_task attr");
+std::cout << "# modify_task result='" << result << "'\n";
+
         // Dependencies must be resolved to UUIDs.
         if (name == "depends")
         {

test/duration.t.cpp

@@ -48,7 +48,7 @@ int convertDuration (const std::string& input)
 
 int main (int argc, char** argv)
 {
-  UnitTest t (628);
+  UnitTest t (629);
 
   Duration d;
 
@@ -570,6 +570,7 @@ int main (int argc, char** argv)
   t.ok (d.valid ("0w"),         "valid duration 0w");
   t.ok (d.valid ("1 wks"),      "valid duration 1 wks");
   t.ok (d.valid ("1 wk"),       "valid duration 1 wk");
+  t.ok (d.valid ("1wk"),        "valid duration 1wk");
   t.ok (d.valid ("1w"),         "valid duration 1w");
   t.ok (d.valid ("10 wks"),     "valid duration 10 wks");
   t.ok (d.valid ("10 wk"),      "valid duration 10 wk");

test/text.t.cpp

@@ -35,7 +35,7 @@ Context context;
 ////////////////////////////////////////////////////////////////////////////////
 int main (int argc, char** argv)
 {
-  UnitTest t (258);
+  UnitTest t (262);
 
   // void wrapText (std::vector <std::string>& lines, const std::string& text, const int width)
   std::string text = "This is a test of the line wrapping code.";
@@ -155,6 +155,13 @@ int main (int argc, char** argv)
   t.is (items[2], "bc",            "split '-a-bc-def' '--' -> [2] 'bc'");
   t.is (items[3], "def",           "split '-a-bc-def' '--' -> [3] 'def'");
 
+  unsplit = "one\ntwo\nthree";
+  split (items, unsplit, "\n");
+  t.is (items.size (), (size_t) 3, "split 'one\\ntwo\\nthree' -> 'one', 'two', 'three'");
+  t.is (items[0], "one",           "split 'one\\ntwo\\nthree' -> [0] 'one'");
+  t.is (items[1], "two",           "split 'one\\ntwo\\nthree' -> [1] 'two'");
+  t.is (items[2], "three",         "split 'one\\ntwo\\nthree' -> [2] 'three'");
+
   // void splitq (std::vector<std::string>&, const std::string&, const char);
   unsplit = "one 'two' '' 'three four' \"five six seven\" eight'nine ten'";
   splitq (items, unsplit, ' ');