TidyDoc.hpp

Go to the documentation of this file.

/*
 *
 * ---
 *
 *  Copyright (C) 2020–2023 Anselm Schmidt (ans[ät]ohai.su)
 *
 *  This program 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 in addition to the terms of any
 *  licences already herein identified.
 *
 *  This program 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 this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * ---
 *
 * TidyDoc.hpp
 *
 * RAII wrapper for tidy-html5 documents.
 *
 *  Created on: Feb 7, 2019
 *      Author: ans
 */

#ifndef WRAPPER_TIDYDOC_HPP_
#define WRAPPER_TIDYDOC_HPP_

#include "TidyBuffer.hpp"

#include "../Helper/SilentInclude/tidy.h"
#include "../Helper/Strings.hpp"
#include "../Main/Exception.hpp"

#include <queue>    // std::queue
#include <string>   // std::string, std::to_string

namespace crawlservpp::Wrapper {

    /*
     * DECLARATION
     */


    class TidyDoc {
    public:

        TidyDoc();
        virtual ~TidyDoc();


        [[nodiscard]] std::string getOutput(std::queue<std::string>& warningsTo);


        void setOption(TidyOptionId option, bool value);
        void setOption(TidyOptionId option, int value);
        void setOption(TidyOptionId option, ulong value);
        void setOption(TidyOptionId option, const std::string& value);


        void parse(const std::string& in, std::queue<std::string>& warningsTo);
        void cleanAndRepair(std::queue<std::string>& warningsTo);



        MAIN_EXCEPTION_CLASS();


        TidyDoc(TidyDoc&) = delete;

        TidyDoc& operator=(TidyDoc&) = delete;

        TidyDoc(TidyDoc&&) = delete;

        TidyDoc& operator=(TidyDoc&&) = delete;


    private:
        bool created{false};
        
        ::TidyDoc doc;

        TidyBuffer errors;
        
        // static helper function
        [[nodiscard]] static bool isVersionBelow5_7_18();
    };

    /*
     * IMPLEMENTATION
     */

    /*
     * CONSTRUCTION AND DESTRUCTION
     */


    inline TidyDoc::TidyDoc() {
        // set language manually to avoid locale bug (https://github.com/crawlserv/crawlservpp/issues/164)
        if(TidyDoc::isVersionBelow5_7_18()) {
            tidySetLanguage(tidyGetLanguage());
        }
        
        // create document
        this->doc = tidyCreate();
        this->created = true;
        
        // set error buffer
        if(tidySetErrorBuffer(this->doc, this->errors.get()) != 0) {
            throw Exception("Could not set error buffer");
        }
    }

    inline TidyDoc::~TidyDoc() {
        if(this->created) {
            tidyRelease(this->doc);
        }
        
        this->created = false;
    }

    /*
     * GETTER
     */


    inline std::string TidyDoc::getOutput(std::queue<std::string>& warningsTo) {
        TidyBuffer buffer;

        switch(tidySaveBuffer(this->doc, buffer.get())) {
        case 0:
            // everything went fine
            break;

        case 1:
        case 2:
            // warnings or errors occured
            if(this->errors.valid()) {
                std::queue<std::string> warnings(
                        Helper::Strings::splitToQueue(
                                this->errors.getString(),
                                '\n',
                                true
                        )
                );

                while(!warnings.empty()) {
                    warningsTo.emplace(warnings.front());

                    warnings.pop();
                }

                this->errors.clear();
            }

            break;

        default:
            // fatal errors occured
            if(this->errors.valid() && !(this->errors.empty())) {
                throw Exception("Could not write to buffer: " + errors.getString());
            }

            throw Exception("Could not write to buffer");
        }

        if(buffer.valid() && !buffer.empty()) {
            return buffer.getString();
        }

        return std::string();
    }

    /*
     * SETTERS
     */


    inline void TidyDoc::setOption(TidyOptionId option, bool value) {
        if(tidyOptSetBool(this->doc, option, value ? yes : no) == 0) {
            throw Exception(
                    "Could not set tidy option #"
                    + std::to_string(option)
                    + " to boolean "
                    + (value ? "yes" : "no")
            );
        }
    }


    inline void TidyDoc::setOption(TidyOptionId option, int value) {
        if(tidyOptSetInt(this->doc, option, value) == 0) {
            throw Exception(
                    "Could not set tidy option #"
                    + std::to_string(option)
                    + " to integer "
                    + std::to_string(value)
            );
        }
    }


    inline void TidyDoc::setOption(TidyOptionId option, ulong value) {
        if(tidyOptSetInt(this->doc, option, value) == 0) {
            throw Exception(
                    "Could not set tidy option #"
                    + std::to_string(option)
                    + " to unsigned integer "
                    + std::to_string(value)
            );
        }
    }


    inline void TidyDoc::setOption(TidyOptionId option, const std::string& value) {
        if(tidyOptSetValue(this->doc, option, value.c_str()) == 0) {
            throw Exception(
                    "Could not set tidy option #"
                    + std::to_string(option)
                    + " to string \""
                    + value
                    + "\""
            );
        }
    }

    /*
     * PARSING AND CLEANUP
     */


    inline void TidyDoc::parse(const std::string& in, std::queue<std::string>& warningsTo) {
        switch(tidyParseString(this->doc, in.c_str())) {
        case 0:
            // everything went fine
            break;

        case 1:
        case 2:
            // warnings or errors occured
            if(this->errors.valid()) {
                std::queue<std::string> warnings(
                        Helper::Strings::splitToQueue(
                                this->errors.getString(),
                                '\n',
                                true
                        )
                );

                while(!warnings.empty()) {
                    warningsTo.emplace(warnings.front());

                    warnings.pop();
                }

                this->errors.clear();
            }

            break;

        default:
            // errors occured
            if(this->errors.valid() && !(this->errors.empty())) {
                throw Exception("Could not parse HTML: " + errors.getString());
            }

            throw Exception("Could not parse HTML");
        }
    }


    inline void TidyDoc::cleanAndRepair(std::queue<std::string>& warningsTo) {
        switch(tidyCleanAndRepair(this->doc)) {
        case 0:
            // everything went fine
            break;

        case 1:
        case 2:
            // warnings or errors occured
            if(this->errors.valid()) {
                std::queue<std::string> warnings(
                        Helper::Strings::splitToQueue(
                                this->errors.getString(),
                                '\n',
                                true
                        )
                );

                while(!warnings.empty()) {
                    warningsTo.emplace(warnings.front());

                    warnings.pop();
                }

                this->errors.clear();
            }

            break;

        default:
            // fatal errors occured
            if(this->errors.valid() && !(this->errors.empty())) {
                throw Exception("Could not clean and repair HTML: " + errors.getString());
            }

            throw Exception("Could not clean and repair HTML");
        }
    }
    
    // static helper function checking whether the library version is below 5.7.18
    inline bool TidyDoc::isVersionBelow5_7_18() {
        constexpr auto firstDotPosition{1};
        constexpr auto secondDotPosition{3};
        constexpr auto length{6};
        
        const std::string version(tidyLibraryVersion());
        
        if(version.substr(0, firstDotPosition) > "5") {
            return false; // version 6.0 or higher
        }
        
        if(version.size() > firstDotPosition && version[firstDotPosition] != '.') {
            return false; // version 10.0 or higher
        }
        
        if(version.substr(0, secondDotPosition) > "5.7") {
            return false; // version 5.8 or higher
        }
        
        if(version.substr(0, firstDotPosition) < "5") {
            return true; // version 4.x or lower
        }
        
        if(version.size() > secondDotPosition && version[secondDotPosition] != '.') {
            return false; // version 5.10 or higher
        }
        
        if(version >= "5.7.18" && version.size() >= length) {
            return false; // version 5.7.18 or higher
        }
        
        if(version.substr(0, secondDotPosition) < "5.7") {
            return true; // version 5.6 or lower
        }
        
        if(version.size() > length) {
            return false; // version 5.7.100 or higher
        }
        
        return true; // version 5.7.17 or lower
    }

} /* namespace crawlservpp::Wrapper */

#endif /* WRAPPER_TIDYDOC_HPP_ */