mstch/src/template_type.cpp

#include "template_type.hpp"

using namespace mstch;

template_type::template_type(const std::string& str) {
  tokenize(str);
  strip_whitespace();
}

void template_type::tokenize(const std::string& t) {
  std::string delim_start{"{{"};
  std::string delim_end{"}}"};
  std::string::const_iterator tok_end, tok_start = t.begin();
  parse_state pstate = parse_state::start;
  unsigned int del_pos = 0;
  for (std::string::const_iterator it = t.begin(); it != t.end(); ++it) {
    if (pstate == parse_state::start) {
      if (*it == delim_start[0]) {
        pstate = parse_state::in_del_start;
        tok_end = it;
        del_pos = 1;
      } else if (*it == '\n') {
        tokens.push_back({{tok_start, it + 1}});
        tok_start = it + 1;
      }
    } else if (pstate == parse_state::in_del_start) {
      if (*it == delim_start[del_pos] && ++del_pos == delim_start.size())
        pstate = parse_state::in_del;
      else
        pstate = parse_state::start;
    } else if (pstate == parse_state::in_del) {
      if (*it == '{')
        pstate = parse_state::in_esccontent;
      else if (*it == delim_end[0] && (del_pos = 1))
        pstate = parse_state::in_del_end;
      else
        pstate = parse_state::in_content;
    } else if (pstate == parse_state::in_esccontent && *it == '}') {
      pstate = parse_state::in_content;
    } else if (pstate == parse_state::in_content && *it == delim_end[0]) {
      pstate = parse_state::in_del_end;
      del_pos = 1;
    } else if (pstate == parse_state::in_del_end) {
      if (*it == delim_end[del_pos] && ++del_pos == delim_end.size()) {
        pstate = parse_state::start;
        tokens.push_back({{tok_start, tok_end}});
        tokens.push_back(
            {{tok_end, it + 1},
             delim_start.size(),
             delim_end.size()});
        tok_start = it + 1;
      } else {
        pstate = parse_state::start;
      }
    }
  }
  tokens.push_back({{tok_start, t.end()}});
}

void template_type::strip_whitespace() {
  auto line_begin = tokens.begin();
  bool has_tag = false, non_space = false;
  for (auto it = tokens.begin(); it != tokens.end(); ++it) {
    auto type = (*it).token_type();
    if (type != token::type::text && type != token::type::variable &&
        type != token::type::unescaped_variable)
      has_tag = true;
    else if (!(*it).ws_only())
      non_space = true;
    if ((*it).eol()) {
      if (has_tag && !non_space) {
        auto line_it = line_begin;
        for (; !(*line_it).eol(); ++line_it)
          if ((*line_it).ws_only())
            line_it = tokens.erase(line_it);
        if ((*line_it).ws_only())
          line_it = tokens.erase(line_it);
        it = line_it - 1;
      }
      non_space = has_tag = false;
      line_begin = it + 1;
    }
  }
}