root/msg/text_plain.cc

/*  This file is part of Alue, the multiprotocol Internet discussion daemon

    Copyright © 2009, 2010 Antti-Juhani Kaijanaho

    Alue is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Alue is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Alue.  If not, see <http://www.gnu.org/licenses/>.

 */

#include "content_type.hh"
#include "entity_header.hh"
#include "text_plain.hh"

#include "../html/util.hh"
#include "../tlate/list_value.hh"
#include "../tlate/data_model.hh"
#include "../util.hh"

namespace
{
        msg::entity_header::ptr ct_hdr(msg::content_type ct)
        {
                std::string str =
                        std::string("Content-Type: ") +
                        ct.to_string() + "\r\n" +
                        "Content-Transfer-Encoding: 8bit\r\n" +
                        "\r\n";
                msg::entity_header::ptr rv(new msg::entity_header(str,
                                                                  false,
                                                                  ct.to_string()
                                                   )
                        );
                return rv;
        }
}

namespace msg
{
        text_plain::text_plain(entity_header::ptr hdr, std::string body)
                : entity(hdr)
        {
                init(body);
        }

        text_plain::text_plain(std::string body, content_type ct)
                : entity(ct_hdr(ct))
        {
                init(body);
        }

        text_plain::text_plain(entity::const_ptr e)
                : entity(*e)
        {
                init(e->get_body());
        }

        void text_plain::init(std::string text)
        {
                raw_body = text;
                content_type ct = get_content_type();
                if (ct.get_type() != msg::content_type::TEXT ||
                    ct.get_subtype() != "plain")
                {
                        para p(0);
                        p.push_back("[This entity is not plain text.]");
                        paras.push_back(p);
                        // FIXME
                        return;
                }

                if (util::to_lower(ct.get_param("format")) != "flowed")
                {
                        while (!text.empty())
                        {
                                size_t ps = text.find("\r\n\r\n");
                                std::string pars = text.substr(0, ps);
                                if (ps == std::string::npos)
                                        text.clear();
                                else
                                        text.erase(0, ps+4);
                                para p(0);
                                while (!pars.empty())
                                {
                                        size_t nl = pars.find("\r\n");
                                        std::string line = pars.substr(0, nl);
                                        if (nl == std::string::npos)
                                                pars.clear();
                                        else
                                                pars.erase(0, nl+2);
                                        p.push_back(line);
                                }
                                paras.push_back(p);
                        }
                        return;
                }

                const bool delsp = util::to_lower(ct.get_param("delsp"))
                        == "true";

                std::string cp;
                size_t cqd = 0;
                bool eop = false;
                while (!text.empty())
                {
                        size_t nl = text.find("\r\n");
                        std::string line = text.substr(0, nl);
                        if (nl == std::string::npos)
                                text.clear();
                        else
                                text.erase(0, nl+2);
                        size_t qd = line.find_first_not_of(">");
                        if (qd == std::string::npos) qd = line.length();
                        if (cqd == size_t(-1)) cqd = qd;
                        if (!line.empty() && line[0] == ' ')
                                line.erase(0,1);
                        if (qd > 0) line.erase(0, qd);
                        if (line == "-- " || cp == "-- " || qd != cqd || eop)
                        {
                                para p(cqd);
                                p.push_back(cp);
                                paras.push_back(p);
                                cp = "";
                                cqd = qd;
                        }
                        eop = line.empty() || line[line.length()-1] != ' ';
                        if (delsp && 
                            !line.empty() && line[line.length()-1] == ' ')
                                line.erase(line.length()-1);
                        cp += line;
                }
                if (!cp.empty())
                {
                        para p(cqd);
                        p.push_back(cp);
                        paras.push_back(p);
                }
        }

        boost::shared_ptr<tlate::value>
        text_plain::get_tlate_value(bool authn) const
        {
                tlate::list_value::ptr bodyv(new tlate::list_value);
                size_t qd = 0;
                for (size_t i = 0; i < num_paras(); i++)
                {
                        const msg::text_plain::para &par = get_para(i);
                        
                        while (qd < par.quote_depth())
                        {
                                tlate::data_model::ptr tag
                                        (new tlate::data_model);
                                tag->insert("start_quote");
                                bodyv->push_back(tag);
                                qd++;
                        }
                        
                        while (qd > par.quote_depth())
                        {
                                tlate::data_model::ptr tag
                                        (new tlate::data_model);
                                tag->insert("end_quote");
                                bodyv->push_back(tag);
                                qd--;
                        }

                        tlate::list_value::ptr parav(new tlate::list_value);
                        for (size_t j = 0; j < par.num_lines(); j++)
                        {
                                if (j > 0)
                                {
                                        tlate::data_model::ptr tag
                                                (new tlate::data_model);
                                        tag->insert("line_separator");
                                        parav->push_back(tag);
                                }
                                std::string line = par.get_line(j);
                                tlate::string_value::ptr linev
                                        (new tlate::string_value
                                         (html::quote(line, !authn)));
                                parav->push_back(linev);
                        }
                        bodyv->push_back(parav);
                }

                while (qd > 0)
                {
                        tlate::data_model::ptr tag(new tlate::data_model);
                        tag->insert("end_quote");
                        bodyv->push_back(tag);
                        qd--;
                }
                
                tlate::data_model::ptr rv(new tlate::data_model);
                rv->insert("text_plain", bodyv);
                return rv;
        }
}