verify_report.h

/*
    Copyright (C) 2022 Carl Hetherington <cth@carlh.net>
 
    This file is part of DCP-o-matic.
 
    DCP-o-matic 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 2 of the License, or
    (at your option) any later version.
 
    DCP-o-matic 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 DCP-o-matic.  If not, see <http://www.gnu.org/licenses/>.
 
*/
 
 
#include "compose.hpp"
#include "file.h"
#include "verify.h"
#include <boost/filesystem.hpp>
#include <vector>
 
 
namespace dcp {
 
 
class Formatter
{
public:
        Formatter(boost::filesystem::path file)
                : _file(file, "w")
        {}
 
        class Wrap
        {
        public:
                Wrap() = default;
 
                Wrap(Formatter* formatter, std::string const& close)
                        : _formatter(formatter)
                        , _close(close)
                {}
 
                Wrap(Formatter* formatter, std::string const& close, std::function<void ()> closer)
                        : _formatter(formatter)
                        , _close(close)
                        , _closer(closer)
                {}
 
                Wrap(Wrap&& other)
                {
                        std::swap(_formatter, other._formatter);
                        std::swap(_close, other._close);
                        std::swap(_closer, other._closer);
                }
 
                ~Wrap()
                {
                        if (_formatter) {
                                _formatter->file().puts(_close.c_str());
                        }
                        if (_closer) {
                                _closer();
                        }
                }
 
        private:
                Formatter* _formatter = nullptr;
                std::string _close;
                std::function<void ()> _closer = nullptr;
        };
 
        virtual Wrap document() { return {}; }
 
        virtual void heading(std::string const& text) = 0;
        virtual void subheading(std::string const& text) = 0;
        virtual Wrap body() { return {}; }
 
        virtual Wrap unordered_list() = 0;
        virtual void list_item(std::string const& text, boost::optional<std::string> type = {}) = 0;
 
        virtual std::function<std::string (std::string)> process_string() = 0;
        virtual std::function<std::string (std::string)> process_filename() = 0;
 
        dcp::File& file() {
                return _file;
        }
 
protected:
        dcp::File _file;
};
 
 
class TextFormatter : public Formatter
{
public:
        TextFormatter(boost::filesystem::path file)
                : Formatter(file)
        {}
 
        void heading(std::string const& text) override {
                print(text);
        }
 
        void subheading(std::string const& text) override {
                print("");
                print(text);
        }
 
        Wrap unordered_list() override {
                _indent++;
                return Wrap(this, "", [this]() { _indent--; });
        }
 
        void list_item(std::string const& text, boost::optional<std::string> type = {}) override {
                LIBDCP_UNUSED(type);
                for (int i = 0; i < _indent * 2; ++i) {
                        _file.puts(" ");
                }
                _file.puts("* ");
                print(text);
        }
 
        std::function<std::string (std::string)> process_string() override {
                return [](std::string s) {
                        return s;
                };
        }
 
        std::function<std::string (std::string)> process_filename() override {
                return [](std::string s) {
                        return s;
                };
        }
 
private:
        void print(std::string const& text) {
                _file.puts(text.c_str());
                _file.puts("\n");
        }
 
        int _indent = 0;
};
 
 
class HTMLFormatter : public Formatter
{
public:
        HTMLFormatter(boost::filesystem::path file)
                : Formatter(file)
        {}
 
        void heading(std::string const& text) override {
                tagged("h1", text);
        }
 
        void subheading(std::string const& text) override {
                tagged("h2", text);
        }
 
        Wrap document() override {
                auto html = wrapped("html");
                auto head = wrapped("head");
                auto style = wrapped("style");
                _file.puts("li {\n"
                           "  margin: 2px;\n"
                           "  padding: 2px 2px 2px 1em;\n"
                           "}\n"
                          );
                _file.puts("li.ok {\n"
                           "  background-color: #00ff00;\n"
                           "}\n"
                           "li.warning {\n"
                           "  background-color: #ffa500;\n"
                           "}\n"
                           "li.error {\n"
                           "  background-color: #ff0000;\n"
                           "}\n"
                           "li.bv21-error {\n"
                           "  background-color: #ff6666;\n"
                           "}\n"
                           "ul {\n"
                           "  list-style: none;\n"
                           "}\n"
                          );
                return html;
        }
 
        Wrap body() override {
                return wrapped("body");
        }
 
        Wrap unordered_list() override {
                return wrapped("ul");
        }
 
        void list_item(std::string const& text, boost::optional<std::string> type = {}) override {
                if (type) {
                        _file.puts(dcp::String::compose("<li class=\"%1\">%2", *type, text).c_str());
                } else {
                        _file.puts(dcp::String::compose("<li>%1", text).c_str());
                }
        }
 
        std::function<std::string (std::string)> process_string() override {
                return [](std::string s) {
                        boost::replace_all(s, "<", "&lt;");
                        boost::replace_all(s, ">", "&gt;");
                        return s;
                };
        }
 
        std::function<std::string (std::string)> process_filename() override {
                return [](std::string s) {
                        return String::compose("<code>%1</code>", s);
                };
        }
 
private:
        void tagged(std::string tag, std::string content) {
                _file.puts(String::compose("<%1>%2</%3>\n", tag, content, tag).c_str());
        };
 
        Wrap wrapped(std::string const& tag) {
                _file.puts(String::compose("<%1>", tag).c_str());
                return Wrap(this, String::compose("</%1>", tag));
        };
};
 
 
extern void verify_report(dcp::VerificationResult const& result, Formatter& formatter);
 
 
}