src/grim.cc

Commits

b966b2a517365074e5c381dbdea05b3221dc0198 e840f1eeb0ae26af69e1ae146ea9938e28e9f1af e4e05418a640eaed08cd1ec7cd8644eb1dbcca50 4e01ba8ad2c3361fa4be3d896288020948b58b5e aae562ac1350480e4889aabb35899f776c5b59e9 6c3ae0e31eb0893f20e3872117f92cc6b9a942af 350e7d88bb2feb9db00c6e032cc6623f215b7adf 95e6c70d23e99ffcf70e5bbe12503496e5d8f232 e188783659b9bc3b9993a647e93ed110e7f41db6 5e4c38ff3c212cdd9881427ef3f8c2706539a190 e50ea9e1356a74af18fdd171337ef9dc931e1f4e 8f2e83556d12aaebe8e8597ea6923804b0eb7a43 1627c585128af263181053ab2cf1a4cdcd14ee21 def3513f75b325464ad88a33c741c4ca80572b77 a21501590980a905fa9b902897d700a42a08b7f0 56074a6bfe4498d092f3a227297c8c20e2bb962c d9cf1485b7ae0614130494f0e73237921323b9a1 80f04b134ae32ad8a9d526007b33dd02f6600f05 23d6c65f9368d3c622a55a3068a6b2f1efa0c8d4 09c195df02536b6a796bd648fce9669397b96109 f2b5c8202fbc904e2ed78260e3fdbd55164799d2 4bfba076120f389994fc46a98e8b7a2622314400 e36ac5417e10ee9b9f94f340e1ccf28afc5705ea d00dc89a86dd7e2fcfd4618bc3a1c8cfba9e3c3d d9eef16adaf292f3748db5fb5aa98463de10d712 18ff2ec1bfc1cf9fcd17c1acb05c3b41f8f0ed83 9e7fd2980d723437ea621b78d395fa72ca3f4922

Diff

diff --git a/src/grim.cc b/src/grim.cc
index 1bf4374..2bf0c39 100755
--- a/src/grim.cc
+++ b/src/grim.cc
@@ -343 +342,0 @@ struct Style {
-// //!TODO: have parseSelectorParts return string_views
@@ -381 +380 @@ std::vector<std::vector<std::string>> parseSelectorParts(std::string_view select
-		if (nesting == 0 ) {
+		if (nesting == 0 && !current.empty()) {
@@ -400,22 +399,3 @@ std::vector<std::vector<std::string>> parseSelectorParts(std::string_view select
-				if (s == '>' || s == '+' || s == '~' || s == ' ') {
-					if (std::isspace(current.front()) || std::isspace(current.back())) {
-						trimSpace(current);
-					}		
-					if (!current.empty()) {
-						if (current[0] == ':' && current.back() != ')') {
-							current[0] = '[';
-							current.push_back(']');
-						}
-
-						buffer.push_back(std::move(current));
-						buffer.push_back("");
-						buffer.back() += s;
-
-					} else
-					if (s != ' ') {
-						buffer.push_back("");
-						buffer.back() += s;
-					}
-					current.clear();
-				} else if (s != '\0') {
-					current.push_back(s);
+			if (s == '>' || s == '+' || s == '~' || s == ' ') {
+				if (std::isspace(current.front()) || std::isspace(current.back())) {
+					trimSpace(current);
@@ -422,0 +403,13 @@ std::vector<std::vector<std::string>> parseSelectorParts(std::string_view select
+				
+				if (current[0] == ':' && current.back() != ')') {
+					current[0] = '[';
+					current.push_back(']');
+				}
+				
+				buffer.push_back(std::move(current));
+				buffer.push_back("");
+				buffer.back() += s;
+				current.erase();
+			} else if (s != '\0') {
+				current.push_back(s);
+			}
@@ -428,3 +420,0 @@ std::vector<std::vector<std::string>> parseSelectorParts(std::string_view select
-			if (std::isspace(current.front()) || std::isspace(current.back())) {
-				trimSpace(current);
-			};
@@ -431,0 +422,3 @@ std::vector<std::vector<std::string>> parseSelectorParts(std::string_view select
+				if (std::isspace(current.front()) || std::isspace(current.back())) {
+					trimSpace(current);
+				};
@@ -441 +434 @@ std::vector<std::vector<std::string>> parseSelectorParts(std::string_view select
-			current.clear();
+			current.erase();

#include "grim.h"
#include <iostream>
#include <sstream>
#include <algorithm>
#include <stdexcept>
#include <cctype>
#include <string_view>

// Constructor

void Node::ClassList::createIndex() {
	int index = 0;
	// Add a space to the back to help trigger the adding of the 
	// last item
	std::string classes = self->Attributes["class"]+" ";
	// Update the stored length
	len = classes.length();
	indexes.clear();

bool waitForFirstChar = true;

for (size_t i = 0; i < len; i++) {
		if (waitForFirstChar && classes[i] != ' ') {
			index = i;
			waitForFirstChar = false;
		} else if (!waitForFirstChar) {
			if (classes[i] == ' ') {
				indexes.push_back({index, i-index});
				waitForFirstChar = true;
			}
		}
	}
}

bool Node::ClassList::checkIndex() {
	std::string classes = self->Attributes["class"];
	if (classes.length() != len) {
		return false;
	} else {
		// Skip the first one because there is a space
		// also we don't care if the values are the same
		// just that the array indexing is the same. If the 
		// value is the same size and position it doesn't matter
		for (size_t i = 1; i < indexes.size(); i++) {
			// See if the index position is a space
			// if not return false
			if (classes[indexes[i-1].first] != ' ') {
				return false;
			}
		}
		return true;
	}
}

size_t Node::ClassList::length() {
	if (!checkIndex()) {
		createIndex();
	}
	return indexes.size();
}

std::string Node::ClassList::item(size_t key) {
	if (!checkIndex()) {
		createIndex();
	}
	if (key < indexes.size()) {
		std::pair<int, int> pair = indexes[key];
		return self->Attributes["class"].substr(pair.first, pair.second);
	} else {
		return "";
	}
}

void Node::ClassList::add(std::string value) {
	if (!checkIndex()) {
		createIndex();
	}

if (self->Attributes["class"].length() == 0) {
		self->Attributes["class"] += value;
	} else {
		self->Attributes["class"] += " "+value;
	}
	// len because the index of the added space will be the length of 
	// the prevous string
	int vl = value.length();
	indexes.push_back({len, vl});
	len += vl+1;
}

void Node::ClassList::remove(std::string value) {
	if (!checkIndex()) {
		createIndex();
	}

int newLen = value.length();
	size_t cLen = indexes.size();
	std::string classes = self->Attributes["class"];

for (size_t i = 0; i < cLen; i++) {
		std::pair<int, int> pair = indexes[i];
		if (newLen == pair.second) {
			if (classes.substr(pair.first, pair.second) == value) {
				// Splice out the value to be removed 
				// !ISSUE: This will keep the surounding spaces and cause the size to grow when 
				// + classes are added and removed
				self->Attributes["class"] = classes.substr(0, pair.first)+classes.substr(pair.first+pair.second);
			}
		}
	}	
}

bool Node::ClassList::contains(std::string value) {
	if (!checkIndex()) {
		createIndex();
	}

int newLen = value.length();
	size_t cLen = indexes.size();
	std::string classes = self->Attributes["class"];	
	bool found = false;

for (size_t i = 0; i < cLen; i++) {
		std::pair<int, int> pair = indexes[i];
		if (newLen == pair.second) {
			if (classes.substr(pair.first, pair.second) == value) {
				// Same logic as remove but turns found true then breaks
				found = true;
				break;
			}
		}
	}
	return found;
}

void Node::ClassList::toggle(std::string value) {
	if (contains(value)) {
		remove(value);
	} else {
		add(value);
	}
}

std::string Node::ClassList::value() const {
	return self->Attributes["class"];
}

std::string Node::getTagName() const { return TagName; }
void Node::setTagName(const std::string& name) { TagName = name; }

const std::unordered_map<std::string, std::string>& Node::getAttributes() const {
    return Attributes;
}

// Implement the getter/setter methods declared using the macro
#define IMPLEMENT_ATTRIBUTE_ACCESSORS(_Type, _FuncNameSuffix, _AttrKeyString) \
    _Type Node::get##_FuncNameSuffix() const { \
        return getAttribute<_Type>(_AttrKeyString); \
    } \
    void Node::set##_FuncNameSuffix(_Type value) { \
        setAttribute(_AttrKeyString, value); \
    }

IMPLEMENT_ATTRIBUTE_ACCESSORS(std::string, Id, "id")
IMPLEMENT_ATTRIBUTE_ACCESSORS(std::string, InnerText, "innerText")
IMPLEMENT_ATTRIBUTE_ACCESSORS(bool, ContentEditable, "contenteditable")
IMPLEMENT_ATTRIBUTE_ACCESSORS(std::string, Href, "href")
IMPLEMENT_ATTRIBUTE_ACCESSORS(std::string, Src, "src")
IMPLEMENT_ATTRIBUTE_ACCESSORS(std::string, Title, "title")
IMPLEMENT_ATTRIBUTE_ACCESSORS(std::string, Value, "value")
IMPLEMENT_ATTRIBUTE_ACCESSORS(int, TabIndex, "tabindex")
IMPLEMENT_ATTRIBUTE_ACCESSORS(bool, Disabled, "disabled")
IMPLEMENT_ATTRIBUTE_ACCESSORS(bool, Required, "required")
IMPLEMENT_ATTRIBUTE_ACCESSORS(bool, Checked, "checked")

Node* Node::createElement(std::string name) {
    std::unique_ptr<Node> newNode = std::make_unique<Node>();
    newNode->setTagName(name);
    newNode->parent = this;
    children.push_back(std::move(newNode));
    return children.back().get();
}

template<typename T>
void Node::setAttribute(const std::string& name, const T& value) {
    if constexpr (std::is_same_v<T, bool>) {
        if (value) {
            Attributes[name] = "";
        } else {
            Attributes.erase(name);
        }
    } else if constexpr (std::is_arithmetic_v<T>) {
        Attributes[name] = std::to_string(value);
    } else {
        static_assert(std::is_convertible_v<T, std::string>,
            "setAttribute: Type cannot be converted to std::string automatically.");
        Attributes[name] = static_cast<std::string>(value);
    }
}

void Node::setAttribute(const std::string& name, const std::string& value) {
    Attributes[name] = value;
}

template<typename T>
T Node::getAttribute(const std::string& name) const {
    auto it = Attributes.find(name);
    if (it != Attributes.end()) {
        const std::string& s = it->second;

if constexpr (std::is_same_v<T, int>) {
            try {
                return std::stoi(s);
            } catch (const std::invalid_argument& e) {
                return 0;
            } catch (const std::out_of_range& e) {
                return 0;
            }
        } else if constexpr (std::is_same_v<T, bool>) {
            std::string lower_s = s;
            std::transform(lower_s.begin(), lower_s.end(), lower_s.begin(),
                [](unsigned char c){ return std::tolower(c); });
            return (!lower_s.empty() && lower_s != "false");
        } else if constexpr (std::is_same_v<T, double>) {
            try {
                return std::stod(s);
            } catch (const std::invalid_argument& e) {
                return 0.0;
            } catch (const std::out_of_range& e) {
                return 0.0;
            }
        } else {
            static_assert(std::is_convertible_v<std::string, T>,
                "getAttribute: Type conversion from std::string not implemented for this type.");
            return static_cast<T>(s);
        }
    }
    return T();
}

std::string Node::getAttribute(const std::string& name) const {
    auto it = Attributes.find(name);
    if (it != Attributes.end()) {
        return it->second;
    }
    return "";
}

std::vector<std::string> Node::getAttributeKeys() {
	std::vector<std::string> keys;

for(auto p : Attributes) {
		keys.push_back(p.first);
	}
	return keys;
}

std::string Node::print(int indent) {
	std::string out = "";
    for (int i = 0; i < indent; ++i) {
        out += "  ";
    }

out += "<" + getTagName();
    for (const auto& attr_pair : getAttributes()) {
        if (attr_pair.first == "innerText" || attr_pair.first == "tagName") {
            continue;
        }
        out += " " + attr_pair.first;
        if (!attr_pair.second.empty()) {
            out += "=\"" + attr_pair.second + "\"";
        }
    }
    out += ">";

if (!getAttribute("innerText").empty()) {
        out += "\n" + getAttribute("innerText");
    }

out += "\n";

for (const auto& child : children) {
        out += child->print(indent + 1)+"\n";
    }

for (int i = 0; i < indent; ++i) {
        out += "  ";
    }
    out += "</" + getTagName() + ">\n";

return out;
}

void trimSpace(std::string& str) {
    if (str.empty()) {
        return;
    }

// Find first non-space
    size_t first_non_space = 0;
    while (first_non_space < str.length() && std::isspace(str[first_non_space])) {
        first_non_space++;
    }

// If all spaces or empty
    if (first_non_space == str.length()) {
        str.clear(); // Set to empty string
        return;
    }

// Find last non-space
    size_t last_non_space = str.length() - 1;
    while (last_non_space >= first_non_space && std::isspace(str[last_non_space])) {
        last_non_space--;
    }

// Erase trailing spaces
    if (last_non_space < str.length() - 1) {
        str.erase(last_non_space + 1);
    }

// Erase leading spaces
    if (first_non_space > 0) {
        str.erase(0, first_non_space);
    }
}

struct Style {
	std::unordered_map<std::string, std::string> properties;
	std::vector<std::vector<std::string>> selector;
	// Index of when it was added (for cascading)
	size_t index;
};

// parseSelectorParts deconstructs a selector into its indiviual parts
// so they can be store and used in things like finding styles for basemap
// and comparing a node to a selector in testSelector. This is a higher level function
// that should be ran once perselector and the results saved somewhere
// selector: any CSS selector
// //!TODO: have parseSelectorParts return string_views
std::vector<std::vector<std::string>> parseSelectorParts(std::string_view selector) {
	// need to account for selectors with parenthesis like: h1:(+ input:required)
	// need to convert all single quotes to double quotes
	// need to account for commas, will return
	// need to colapse all spaces to a single space
	// need to trim spaces

std::vector<std::vector<std::string>> parts;
	std::vector<std::string> buffer;
	std::string current;

size_t nesting = 0;

size_t sl = selector.length();
	current.reserve(sl);

for (size_t e = 0; e < sl; e++) {
		char s = selector[e];
		 
		if (s == '\'') {
			// convert single quotes to double quotes
			s = '\"';
		}

if (s == ' ' && nesting == 0) {
			if (e > 0 && e < sl-1) {
				bool prevMatch = selector[e-1] == '>' || selector[e-1] == '+' || selector[e-1] == '~';
				bool nextMatch = selector[e+1] == '>' || selector[e+1] == '+' || selector[e+1] == '~';

if (prevMatch && !nextMatch) {
					s = '\0';
				} else if (!prevMatch && nextMatch) {
					s = '\0';
				}
			}
		}

if (nesting == 0 ) {
			if (s == ':' || s == '[' || s == ',' || s == '#' || s == '.') {
				// We convert any : selectors (like :checked) to [checked]
				// because we store every thing as attributes on the Node
				// when test selector is ran it will convert all its attributes 
				// to [checked] or [href="url"]
				// so we can easily compare the two
				if (std::isspace(current.front()) || std::isspace(current.back())) {
					trimSpace(current);
				}
				if (!current.empty()) {
					if (current[0] == ':' && current.back() != ')') {
						current[0] = '[';
						current.push_back(']');
					}
					buffer.push_back(std::move(current));
				}
				current = s;
			} else 
				if (s == '>' || s == '+' || s == '~' || s == ' ') {
					if (std::isspace(current.front()) || std::isspace(current.back())) {
						trimSpace(current);
					}		
					if (!current.empty()) {
						if (current[0] == ':' && current.back() != ')') {
							current[0] = '[';
							current.push_back(']');
						}

buffer.push_back(std::move(current));
						buffer.push_back("");
						buffer.back() += s;

} else
					if (s != ' ') {
						buffer.push_back("");
						buffer.back() += s;
					}
					current.clear();
				} else if (s != '\0') {
					current.push_back(s);
				}
		} else if (s != '\0') {
			current.push_back(s);
		}

if ((s == ',' && nesting == 0) || e == sl-1) {
			if (std::isspace(current.front()) || std::isspace(current.back())) {
				trimSpace(current);
			};
			if (!current.empty() && current != ",") {
				if (current[0] == ':' && current.back() != ')') {
					current[0] = '[';
					current.push_back(']');

}
				buffer.push_back(std::move(current));
			}
			parts.push_back(std::move(buffer));
			buffer.clear();
			current.clear();
		}
		if (s == '(' || s == '[' || s == '{') {
			nesting++;
		} else if (s == ')' || s == ']' || s == '}') {
			nesting--;
		}

}

return parts;
}

class StyleHandler {
	private:
		// basemap: Maps baseparts to a index of the styles vector pointing to a Style object
		// because processing a CSS selector isn't trivial we want to make a short list of 
		// the styles that can possibly be a match so we aren't spending a lot of compute 
		// on a selector that applies to the wrong element. Todo this we take the right most part
		// of a selector (that is the part that targets the current element) and we do a few checks
		// like is the tagname the same, does it have that class, and do the id's match. If so that 
		// is a candidate and we run the full selector on it. That includes checking parents,children, 
		// or what ever else the selector needs to match.
		std::unordered_map<std::string, std::vector<size_t>> basemap;
		std::vector<Style> styles;

std::vector<std::string> parseNodeParts(Node* node) {
			std::vector<std::string> parts;

parts.push_back(node->getTagName());
			parts.push_back("#"+node->getId());

// classes and attributes
			auto keys = node->getAttributeKeys();

for (auto k : keys) {
				if (k != "tagName" || k != "id" || k != "innerText" || k != "class") {
					std::string v;
					std::string av = node->getAttribute(k);
					if (av != "") {
							v = "=\""+av+"\"";

}
					parts.push_back('['+k+v+']');
				}
			}

auto classLen = node->classList.length();

for (size_t i = 0; i < classLen; i++) {
				parts.push_back("."+node->classList.item(i));
			}

return parts;
		}

public:
		void add(std::string selector, std::unordered_map<std::string, std::string> properties) {
			// Type is 2d vector of selector parts
			auto parts = parseSelectorParts(selector);
			size_t index = styles.size();
			Style style = {properties,parts,index};

styles.push_back(std::move(style));
// !ISSUE: Re do the basemap mapping in the add function
// + will need to go through each 1d then once in start from right and go left until >+~" " or eol 
/*			for (auto p : parts) {
				if (basemap.find(p) != basemap.end()) {
					basemap[p].push_back(index);
				} else {
					std::vector<size_t> bm = {index};
					basemap[p] = bm;
				}
			}
*/
		}
		
		std::unordered_map<std::string, std::string> getStyles(Node* node) {
			std::vector<std::string> parts = parseNodeParts(node);

std::vector<size_t> canidates;

for (auto p : parts) {
				if (auto sty = basemap.find(p); sty != basemap.end()) {
					for (auto s : sty->second) {
						bool found = false;
						// This makes sure we aren't adding the same styles to the candidates list
						for (auto c : canidates) {
							if (c == s) {
								found = true;
								break;
							}
						}
						if (!found) {
							canidates.push_back(s);
						}
					}
				}
			}

// Now we have the list of candidates next we will refined our selection
			// we need to pull the selectors from each candidate then run testSelector on it
		}
};

bool testSelector(Node* node, std::vector<std::vector<std::string>> selector) {
	// By the time we get here, we know the right most selector some what matches
	// so now if it is a compound selector we should see if the parent('s) some what match

// !TODO: Add support for *
	if (selector.size() > 1) {
		// If a selector is made up of several different selectors
		// ie {{"h1"}, {"h2"}, {"h3"}}
		// run each selector and return on a match
		for (auto s : selector) {
			bool match = testSelector(node, {s});
			if (match) {
				return true;
			}
		}
		return false;
	}

std::vector<std::string> trimmed;
	std::vector<std::string> parts;
	std::string symbol;
	bool symbolFound = false;

for (int i = selector[0].size()-1; i >= 0; i--) {
		std::string part = selector[0][i];
		if (symbolFound) {
			trimmed.insert(trimmed.begin(), part);
		} else {
			if (part != ">" || part != " " || part != "+" || part != "~") {
				parts.insert(parts.begin(), part);
			} else {
				symbol = part;
			}
		}
	}

// Given our selector is: {{"div", ">", "h1"}}
	// we should now have
	// trimmed = {"div"}
	// parts = {"h1"}
	// symbol = ">"

// matched is true here because the node matching logic
	// returns if matched is false
	bool matched = true;

std::vector<std::string> nodeClasses;
	size_t classLen = node->classList.length();
	for (size_t i = 0; i < classLen; i++) {
		nodeClasses.push_back("."+node->classList.item(i));
	}

std::unordered_map<std::string, std::string> attributes = node->getAttributes();
	std::vector<std::string> attrs;

for (auto a : attributes) {
		if (a.second != "") {
			attrs.push_back("["+a.first+"=\""+a.second+"\"]");
		} else {

attrs.push_back("["+a.first+"]");
		}
	}

// Find the index of the child relative to it's parent
	const auto& children = node->parent->children;
	size_t childIndex = 0;
	if (children.size() > 1) {
		for (size_t i = 0; i < children.size(); i++) {
			Node* child_ptr = children[i].get();

if (child_ptr == node) {
				childIndex = i;	
			}
		}
	}

size_t i = 0;
	for (auto p : parts) {
		if (i == 0 && p[0] != '#' && p[0] != '.' &&  p[0] != '[') {
			matched = node->getTagName() == p;
		} else if (p[0] == '#') {
			matched = "#"+node->getId() == p;
		} else if (p[0] == '.') {
			bool found = false;
			for (auto c : nodeClasses) {
				if (p == c) {
					found = true;
					break;
				}
			}
			matched = found;
		} else if (p[0] == '[') {
			// This covers all attributes and non relative pseudo-classes
			// as parseSelectorParts converts any attribute
			// without a ending ) to [name]: 
			// See tests/css_selector.cc for examples
			bool found = false;
			for (auto a : attrs) {
				if (p == a) {
					found = true;
					break;
				}
			}
			matched = found;
		} // !TODO: Need a case for : , this will run the :has... logic
		else if (p[0] == ":") {
			// This handles the relative pseudo classes
			for :last-child and nth-child and the others we should get the position
				     of the node at the top. Then apply in attributes
			// These will run through, parsing the inner part and recalling testSelector
			// with it
			if (p.starts_with(":has(")) {
				
			} else if (p.starts_with(":last-child")) {
			} else if (p.starts_with(":first-child")) {
				
			} else if (p.starts_with(":where(")) {
				// where
			} else if (p.starts_with(":is(")) {

} else if (p.starts_with(":not(")) {
			} else if (p.starts_with(":nth-child(")) {
			} else if (p.starts_with("::before")) {
			} else if (p.starts_with("::after")) {}
				
		}

if (!matched) {
			// Return out of the function
			return false;
		}
		i++;
	}

// if the node did not match it would have returned false so if there isn't 
	// a symbol then we return true

if (symbol == "") {
		return true;
	}

// The rest of the logic assumes the other selectors do not match until proven otherwise
	matched = false;

if (node->parent != nullptr) {
		return false;
	}
	
	if (symbol == ">") {
		// child cominator
		// We are just testing the parent node here
		matched = testSelector(node->parent, {trimmed});
	} else if (symbol == "+") {
		// next sibling combinator
		if (children.size() > 1) {
			// If there isn't a prevous sibling then it cannot match
			if (childIndex == 0) {
				return false;
			} else {
				// In this selector we just need to get the direct sibling and test it
				matched = testSelector(children[i-1].get(), {trimmed});
			}
		}
	} else if (symbol == "~") {
		// Subsequent-sibling combinator
		const auto& children = node->parent->children;
		if (children.size() > 1) {
			for (size_t i = 0; i < children.size(); i++) {
				Node* child_ptr = children[i].get();

if (child_ptr == node) {
					break;
				} else {
					// We have to test every selector before the current element,
					// if any match then it matches
					matched = testSelector(children[i].get(), {trimmed});
					if (matched) {
						break;
					}
				}
			}
		}
	} else if (symbol == " ") {
		// For the descendant combinator we have to check every parent until we match or nullptr out
		Node* current = node->parent;
		while (current != nullptr) {
			if (testSelector(current, {trimmed})) {
				matched = true;
				break;
			}
			current = current->parent;
		}
	}

return matched;
}