text: Removed local join/split implementation

src/Config.cpp

@@ -40,7 +40,7 @@
 #include <Timer.h>
 #include <JSON.h>
 #include <Lexer.h>
-#include <text.h>
+#include <shared.h>
 #include <format.h>
 #include <util.h>
 #include <i18n.h>
@@ -437,8 +437,7 @@ void Config::parse (const std::string& input, int nest /* = 1 */)
     return;
 
   // Split the input into lines.
-  std::vector <std::string> lines;
-  split (lines, input, "\n");
+  auto lines = split (input, '\n');
 
   // Parse each line.
   for (auto& line : lines)

src/Msg.cpp

@@ -27,7 +27,7 @@
 #include <cmake.h>
 #include <Msg.h>
 #include <Lexer.h>
-#include <text.h>
+#include <shared.h>
 
 ////////////////////////////////////////////////////////////////////////////////
 void Msg::set (const std::string& name, const std::string& value)
@@ -89,9 +89,7 @@ bool Msg::parse (const std::string& input)
     throw std::string ("ERROR: Malformed message");
 
   // Parse header.
-  std::vector <std::string> lines;
-  split (lines, input.substr (0, separator), '\n');
-  for (auto& i : lines)
+  for (auto& i : split (input.substr (0, separator), '\n'))
   {
     auto delimiter = i.find (':');
     if (delimiter == std::string::npos)

src/commands/CmdCustom.cpp

@@ -37,6 +37,7 @@
 #include <ViewTask.h>
 #include <i18n.h>
 #include <format.h>
+#include <shared.h>
 #include <text.h>
 #include <main.h>
 
@@ -72,18 +73,15 @@ int CmdCustom::execute (std::string& output)
   std::string reportSort    = context.config.get ("report." + _keyword + ".sort");
   std::string reportFilter  = context.config.get ("report." + _keyword + ".filter");
 
-  std::vector <std::string> columns;
-  split (columns, reportColumns, ',');
+  auto columns = split (reportColumns, ',');
   validateReportColumns (columns);
 
-  std::vector <std::string> labels;
-  split (labels, reportLabels, ',');
+  auto labels = split (reportLabels, ',');
 
   if (columns.size () != labels.size () && labels.size () != 0)
     throw format (STRING_CMD_CUSTOM_MISMATCH, _keyword);
 
-  std::vector <std::string> sortOrder;
-  split (sortOrder, reportSort, ',');
+  auto sortOrder = split (reportSort, ',');
   if (sortOrder.size () != 0 &&
       sortOrder[0] != "none")
     validateSortColumns (sortOrder);

src/commands/CmdExec.cpp

@@ -29,7 +29,7 @@
 #include <stdlib.h>
 #include <Context.h>
 #include <i18n.h>
-#include <text.h>
+#include <shared.h>
 
 extern Context context;
 
@@ -52,9 +52,7 @@ CmdExec::CmdExec ()
 ////////////////////////////////////////////////////////////////////////////////
 int CmdExec::execute (std::string&)
 {
-  std::string command_line;
-  join (command_line, " ", context.cli2.getWords ());
-  return system (command_line.c_str ());
+  return system (join (" ", context.cli2.getWords ()).c_str ());
 }
 
 ////////////////////////////////////////////////////////////////////////////////

src/commands/CmdImport.cpp

@@ -32,6 +32,7 @@
 #include <Context.h>
 #include <Filter.h>
 #include <format.h>
+#include <shared.h>
 #include <text.h>
 #include <util.h>
 #include <i18n.h>
@@ -147,10 +148,7 @@ int CmdImport::import (const std::string& input)
   //   { ... }
   catch (std::string& e)
   {
-    std::vector <std::string> lines;
-    split (lines, input, '\n');
-
-    for (auto& line : lines)
+    for (auto& line : split (input, '\n'))
     {
       if (line.length ())
       {

src/commands/CmdInfo.cpp

@@ -299,8 +299,7 @@ int CmdInfo::execute (std::string& output)
     task.getTags (tags);
     if (tags.size ())
     {
-      std::string allTags;
-      join (allTags, " ", tags);
+      auto allTags = join (" ", tags);
 
       row = view.addRow ();
       view.set (row, 0, STRING_COLUMN_LABEL_TAGS);

src/commands/CmdUDAs.cpp

@@ -33,6 +33,7 @@
 #include <Filter.h>
 #include <main.h>
 #include <format.h>
+#include <shared.h>
 #include <text.h>
 #include <util.h>
 #include <i18n.h>
@@ -215,8 +216,7 @@ int CmdCompletionUDAs::execute (std::string& output)
   if (udas.size ())
   {
     std::sort (udas.begin (), udas.end ());
-    join (output, "\n", udas);
-    output += '\n';
+    output = join ("\n", udas) + '\n';
   }
 
   return 0;

src/dependency.cpp

@@ -31,7 +31,7 @@
 #include <stack>
 #include <Context.h>
 #include <format.h>
-#include <util.h>
+#include <shared.h>
 #include <i18n.h>
 #include <main.h>
 

src/rules.cpp

@@ -67,8 +67,7 @@ void initializeColorRules ()
     // Load the rule.precedence.color list, split it, then autocomplete against
     // the 'rules' vector loaded above.
     std::vector <std::string> results;
-    std::vector <std::string> precedence;
-    split (precedence, context.config.get ("rule.precedence.color"), ',');
+    auto precedence = split (context.config.get ("rule.precedence.color"), ',');
 
     for (const auto& p : precedence)
     {

src/text.cpp

@@ -36,6 +36,7 @@
 #include <Lexer.h>
 #include <math.h>
 #include <util.h>
+#include <shared.h>
 #include <text.h>
 #include <utf8.h>
 #include <i18n.h>
@@ -45,246 +46,6 @@ extern Context context;
 static const char* newline = "\n";
 static const char* noline  = "";
 
-///////////////////////////////////////////////////////////////////////////////
-void wrapText (
-  std::vector <std::string>& lines,
-  const std::string& text,
-  const int width,
-  bool hyphenate)
-{
-  std::string line;
-  unsigned int offset = 0;
-  while (extractLine (line, text, width, hyphenate, offset))
-    lines.push_back (line);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void split (
-  std::set<std::string>& results,
-  const std::string& input,
-  const char delimiter)
-{
-  results.clear ();
-  std::string::size_type start = 0;
-  std::string::size_type i;
-  while ((i = input.find (delimiter, start)) != std::string::npos)
-  {
-    results.insert (input.substr (start, i - start));
-    start = i + 1;
-  }
-
-  if (input.length ())
-    results.insert (input.substr (start));
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void split (
-  std::vector<std::string>& results,
-  const std::string& input,
-  const char delimiter)
-{
-  results.clear ();
-  std::string::size_type start = 0;
-  std::string::size_type i;
-  while ((i = input.find (delimiter, start)) != std::string::npos)
-  {
-    results.push_back (input.substr (start, i - start));
-    start = i + 1;
-  }
-
-  if (input.length ())
-    results.push_back (input.substr (start));
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void split (
-  std::vector<std::string>& results,
-  const std::string& input,
-  const std::string& delimiter)
-{
-  results.clear ();
-  std::string::size_type length = delimiter.length ();
-
-  std::string::size_type start = 0;
-  std::string::size_type i;
-  while ((i = input.find (delimiter, start)) != std::string::npos)
-  {
-    results.push_back (input.substr (start, i - start));
-    start = i + length;
-  }
-
-  if (input.length ())
-    results.push_back (input.substr (start));
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void join (
-  std::string& result,
-  const std::string& separator,
-  const std::vector<std::string>& items)
-{
-  std::stringstream s;
-  unsigned int size = items.size ();
-  for (unsigned int i = 0; i < size; ++i)
-  {
-    s << items[i];
-    if (i < size - 1)
-      s << separator;
-  }
-
-  result = s.str ();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-void join (
-  std::string& result,
-  const std::string& separator,
-  const std::vector<int>& items)
-{
-  std::stringstream s;
-  unsigned int size = items.size ();
-  for (unsigned int i = 0; i < size; ++i)
-  {
-    s << items[i];
-    if (i < size - 1)
-      s << separator;
-  }
-
-  result = s.str ();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Remove enclosing balanced quotes.  Assumes trimmed text.
-std::string unquoteText (const std::string& input)
-{
-  std::string output = input;
-
-  if (output.length () > 1)
-  {
-    char quote = output[0];
-    if ((quote == '\'' || quote == '"') &&
-        output[output.length () - 1] == quote)
-      return output.substr (1, output.length () - 2);
-  }
-
-  return output;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-int longestLine (const std::string& input)
-{
-  int longest = 0;
-  int length = 0;
-  std::string::size_type i = 0;
-  int character;
-
-  while ((character = utf8_next_char (input, i)))
-  {
-    if (character == '\n')
-    {
-      if (length > longest)
-        longest = length;
-
-      length = 0;
-    }
-    else
-      length += mk_wcwidth (character);
-  }
-
-  if (length > longest)
-    longest = length;
-
-  return longest;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Break UTF8 text into chunks no more than width characters.
-bool extractLine (
-  std::string& line,
-  const std::string& text,
-  int width,
-  bool hyphenate,
-  unsigned int& offset)
-{
-  // Terminate processing.
-  if (offset >= text.length ())
-    return false;
-
-  int line_length                     {0};
-  int character                       {0};
-  std::string::size_type lastWordEnd  {std::string::npos};
-  bool something                      {false};
-  std::string::size_type cursor       {offset};
-  std::string::size_type prior_cursor {offset};
-  while ((character = utf8_next_char (text, cursor)))
-  {
-    // Premature EOL.
-    if (character == '\n')
-    {
-      line = text.substr (offset, prior_cursor - offset);
-      offset = cursor;
-      return true;
-    }
-
-    if (! Lexer::isWhitespace (character))
-    {
-      something = true;
-      if (! text[cursor] || Lexer::isWhitespace (text[cursor]))
-        lastWordEnd = prior_cursor;
-    }
-
-    line_length += mk_wcwidth (character);
-
-    if (line_length >= width)
-    {
-      // Backtrack to previous word end.
-      if (lastWordEnd != std::string::npos)
-      {
-        // Eat one WS after lastWordEnd.
-        std::string::size_type lastBreak = lastWordEnd;
-        utf8_next_char (text, lastBreak);
-
-        // Position offset at following char.
-        std::string::size_type nextStart = lastBreak;
-        utf8_next_char (text, nextStart);
-
-        line = text.substr (offset, lastBreak - offset);
-        offset = nextStart;
-        return true;
-      }
-
-      // No backtrack, possible hyphenation.
-      else if (hyphenate)
-      {
-        line = text.substr (offset, prior_cursor - offset) + '-';
-        offset = prior_cursor;
-        return true;
-      }
-
-      // No hyphenation, just truncation.
-      else
-      {
-        line = text.substr (offset, cursor - offset);
-        offset = cursor;
-        return true;
-      }
-    }
-
-    // Hindsight.
-    prior_cursor = cursor;
-  }
-
-  // Residual text.
-  if (something)
-  {
-    line = text.substr (offset, cursor - offset);
-     offset = cursor;
-    return true;
-  }
-
-  return false;
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 const char* optionalBlankLine ()
 {

src/text.h

@@ -33,15 +33,6 @@
 #include <vector>
 
 // text.cpp, Non-UTF-8 aware.
-void wrapText (std::vector <std::string>&, const std::string&, const int, bool);
-std::string unquoteText (const std::string&);
-int longestLine (const std::string&);
-bool extractLine (std::string&, const std::string&, int, bool, unsigned int&);
-void split (std::set<std::string>&, const std::string&, const char);
-void split (std::vector<std::string>&, const std::string&, const char);
-void split (std::vector<std::string>&, const std::string&, const std::string&);
-void join (std::string&, const std::string&, const std::vector<std::string>&);
-void join (std::string&, const std::string&, const std::vector<int>&);
 const char* optionalBlankLine ();
 bool nontrivial (const std::string&);
 int strippedLength (const std::string&);