passenger 3.0.21 → 3.9.1.beta

data/ext/common/Utils/StrIntUtils.cpp

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - http://www.modrails.com/
- *  Copyright (c) 2010 Phusion
+ *  Copyright (c) 2010, 2011, 2012 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -27,8 +27,9 @@
 #include <cstdlib>
 #include <cctype>
 #include <cmath>
-#include <Utils/utf8.h>
+#include <algorithm>
 #include <Exceptions.h>
+#include <Utils/utf8.h>
 #include <Utils/StrIntUtils.h>
 
 namespace Passenger {
@@ -79,6 +80,17 @@ split(const StaticString &str, char sep, vector<StaticString> &output) {
 	_split(str, sep, output);
 }
 
+string
+replaceString(const string &str, const string &toFind, const string &replaceWith) {
+	string::size_type pos = str.find(toFind);
+	if (pos == string::npos) {
+		return str;
+	} else {
+		string result(str);
+		return result.replace(pos, toFind.size(), replaceWith);
+	}
+}
+
 string
 toString(const vector<string> &vec) {
 	vector<StaticString> vec2;
@@ -320,6 +332,18 @@ atol(const string &s) {
 	return ::atol(s.c_str());
 }
 
+char *
+appendData(char *pos, const char *end, const char *data, size_t size) {
+	size_t maxToCopy = std::min<size_t>(end - pos, size);
+	memcpy(pos, data, maxToCopy);
+	return pos + size;
+}
+
+char *
+appendData(char *pos, const char *end, const StaticString &data) {
+	return appendData(pos, end, data.data(), data.size());
+}
+
 string
 cEscapeString(const StaticString &input) {
 	string result;

data/ext/common/Utils/StrIntUtils.h

@@ -1,6 +1,6 @@
 /*
  *  Phusion Passenger - http://www.modrails.com/
- *  Copyright (c) 2010 Phusion
+ *  Copyright (c) 2010, 2011, 2012 Phusion
  *
  *  "Phusion Passenger" is a trademark of Hongli Lai & Ninh Bui.
  *
@@ -28,12 +28,14 @@
 #include <string>
 #include <vector>
 #include <sstream>
-#include "StaticString.h"
+#include <cstddef>
+#include <StaticString.h>
 
 namespace Passenger {
 
 using namespace std;
 
+
 /**
  * Given a prefix string, a middle string and a postfix string, try to build a string
  * that looks like <tt>prefix + middle + postfix</tt>, with as many characters from
@@ -73,6 +75,12 @@ bool startsWith(const StaticString &str, const StaticString &substr);
 void split(const StaticString &str, char sep, vector<string> &output);
 void split(const StaticString &str, char sep, vector<StaticString> &output);
 
+/**
+ * Look for 'toFind' inside 'str', replace it with 'replaceWith' and return the result.
+ * Only the first occurence of 'toFind' is replaced.
+ */
+string replaceString(const string &str, const string &toFind, const string &replaceWith);
+
 /**
  * Convert anything to a string.
  */
@@ -216,6 +224,13 @@ roundUp(IntegerType number, IntegerType multiple) {
 	return (number + multiple - 1) / multiple * multiple;
 }
 
+/**
+ * Append the given data to the address at 'pos', but do not cross 'end'.
+ * Returns the end of the appended string.
+ */
+char *appendData(char *pos, const char *end, const char *data, size_t size);
+char *appendData(char *pos, const char *end, const StaticString &data);
+
 /**
  * Escape non-ASCII-printable characters in the given string with C-style escape sequences,
  * e.g. "foo\nbar\0" becomes "foo\\nbar\\0".
@@ -230,6 +245,7 @@ string cEscapeString(const StaticString &input);
  */
 string escapeHTML(const StaticString &input);
 
+
 } // namespace Passenger
 
 #endif /* _PASSENGER_STR_INT_UTILS_H_ */

data/ext/common/Utils/StringMap.h

@@ -50,27 +50,119 @@ class StringMap {
 private:
 	struct Entry {
 		string key;
-		T value;
+		pair<StaticString, T> thePair;
 	};
 	
 	typedef map<StaticString, Entry> InternalMap;
-	typedef typename InternalMap::iterator Iterator;
-	typedef typename InternalMap::const_iterator ConstIterator;
+	typedef typename InternalMap::iterator InternalIterator;
+	typedef typename InternalMap::const_iterator InternalConstIterator;
 	typedef typename InternalMap::value_type ValueType;
 	InternalMap store;
 	
 public:
+	class const_iterator {
+	private:
+		InternalConstIterator it;
+		
+	public:
+		const_iterator() { }
+		
+		const_iterator(const InternalConstIterator &_it)
+			: it(_it)
+			{ }
+		
+		const_iterator &operator=(const const_iterator &value) {
+			it = value.it;
+			return *this;
+		}
+		
+		const_iterator &operator++() {
+			it++;
+			return *this;
+		}
+		
+		const_iterator operator++(int) {
+			const_iterator copy(*this);
+			operator++();
+			return copy;
+		}
+		
+		bool operator==(const const_iterator &other) {
+			return it == other.it;
+		}
+		
+		bool operator!=(const const_iterator &other) {
+			return it != other.it;
+		}
+		
+		const pair<const StaticString, const T> &operator*() {
+			return (pair<const StaticString, const T> &) it->second.thePair;
+		}
+		
+		const pair<const StaticString, const T> *operator->() {
+			return &(**this);
+		}
+	};
+	
+	class iterator {
+	private:
+		InternalIterator it;
+		
+	public:
+		iterator() { }
+		
+		iterator(const InternalIterator &_it)
+			: it(_it)
+			{ }
+		
+		iterator &operator=(const iterator &value) {
+			it = value.it;
+			return *this;
+		}
+		
+		iterator &operator++() {
+			it++;
+			return *this;
+		}
+		
+		iterator operator++(int) {
+			iterator copy(*this);
+			operator++();
+			return copy;
+		}
+		
+		bool operator==(const iterator &other) {
+			return it == other.it;
+		}
+		
+		bool operator!=(const iterator &other) {
+			return it != other.it;
+		}
+		
+		pair<StaticString, T> &operator*() {
+			return it->second.thePair;
+		}
+		
+		pair<StaticString, T> *operator->() {
+			return &(**this);
+		}
+		
+		operator const_iterator() const {
+			return const_iterator(it);
+		}
+	};
+	
 	T get(const StaticString &key) const {
-		ConstIterator it = store.find(key);
+		InternalConstIterator it = store.find(key);
 		if (it == store.end()) {
 			return T();
 		} else {
-			return it->second.value;
+			return it->second.thePair.second;
 		}
 	}
 	
 	bool set(const StaticString &key, const T &value) {
-		pair<Iterator, bool> result = store.insert(make_pair(key, Entry()));
+		pair<InternalIterator, bool> result = store.insert(make_pair(key, Entry()));
 		if (result.second) {
 			// Key has been inserted. Copy it internally and point key
 			// to the copy.
@@ -78,13 +170,14 @@ public:
 			StaticString &originalKey = const_cast<StaticString &>(node.first);
 			Entry &entry = node.second;
 			entry.key = key;
-			entry.value = value;
+			entry.thePair.first = entry.key;
+			entry.thePair.second = value;
 			originalKey = entry.key;
 			return true;
 		} else {
 			// Key already exists. Update value.
 			Entry &entry = result.first->second;
-			entry.value = value;
+			entry.thePair.second = value;
 			return false;
 		}
 	}
@@ -92,6 +185,30 @@ public:
 	bool remove(const StaticString &key) {
 		return store.erase(key) > 0;
 	}
+	
+	unsigned int size() const {
+		return store.size();
+	}
+	
+	bool empty() const {
+		return store.empty();
+	}
+	
+	iterator begin() {
+		return iterator(store.begin());
+	}
+	
+	const_iterator begin() const {
+		return const_iterator(store.begin());
+	}
+	
+	iterator end() {
+		return iterator(store.end());
+	}
+	
+	const_iterator end() const {
+		return const_iterator(store.end());
+	}
 };
 
 

data/ext/common/Utils/Template.h

@@ -0,0 +1,212 @@
+#ifndef _PASSENGER_TEMPLATE_H_
+#define _PASSENGER_TEMPLATE_H_
+
+#include <string>
+#include <cstring>
+#include <cstdio>
+#include <StaticString.h>
+#include <Utils/StrIntUtils.h>
+#include <Utils/StringMap.h>
+
+namespace Passenger {
+
+using namespace std;
+
+
+/**
+ * Implements a simple HTML templating language.
+ */
+class Template {
+private:
+	typedef string::size_type size_type;
+
+	struct State {
+		string result;
+		const StringMap<StaticString> &substitutions;
+
+		State(const StaticString &content, const StringMap<StaticString> &_substitutions)
+			: result(content.data(), content.size()),
+			  substitutions(_substitutions)
+			{ }
+	};
+
+	struct Options {
+		bool raw;
+		string defaultValue;
+
+		Options() {
+			raw = false;
+		}
+	};
+
+	StaticString content;
+
+	static bool isNameCharacter(char ch) {
+		return (ch >= 'a' && ch <= 'z')
+			|| (ch >= 'A' && ch <= 'Z')
+			|| (ch >= '0' && ch <= '9')
+			|| ch == '_';
+	}
+
+	static StaticString readOptionName(const char **current) {
+		while (**current != '\0' && (**current == ',' || **current == ' ')) {
+			(*current)++;
+		}
+		const char *begin = *current;
+		while (**current != '\0' && isNameCharacter(**current)) {
+			(*current)++;
+		}
+		const char *end = *current;
+		return StaticString(begin, end - begin);
+	}
+
+	static StaticString readOptionValue(const char **current) {
+		while (**current != '\0' && **current == ' ') {
+			(*current)++;
+		}
+		if (**current == '=') {
+			(*current)++;
+			const char *begin = *current;
+			while (**current != '\0' && **current != ',') {
+				(*current)++;
+			}
+			const char *end = *current;
+			return StaticString(begin, end - begin);
+		} else {
+			return StaticString();
+		}
+	}
+
+	static Options parseOptions(const string &optionsString) {
+		Options options;
+
+		const char *current = optionsString.data();
+		while (*current != '\0') {
+			StaticString name = readOptionName(&current);
+			StaticString value = readOptionValue(&current);
+			if (name == "raw") {
+				options.raw = true;
+			} else if (name == "default") {
+				options.defaultValue = value;
+			} else {
+				fprintf(stderr, "Unknown template option '%s'\n", name.c_str());
+			}
+		}
+		return options;
+	}
+
+	static string &makeBreakable(string &html) {
+		string::size_type i = 0;
+		while (i < html.size()) {
+			char ch = html[i];
+			if (ch == '=' || ch == ',' || ch == ';' || ch == ':') {
+				html.insert(i + 1, "<wbr>");
+				i += sizeof("<wbr>");
+			} else if (ch == '&') {
+				// HTML escape character; skip to end.
+				do {
+					i++;
+				} while (i < html.size() && html[i] != ';');
+				if (i < html.size()) {
+					i++;
+				}
+			} else {
+				i++;
+			}
+		}
+		return html;
+	}
+
+	size_type processIf(State &state, size_type pos, size_type conditionEndPos, const string &name) {
+		const size_t prefixSize = sizeof("if ") - 1;
+		const size_t endIfSize  = sizeof("{{/if}}") - 1;
+		const string condition = name.substr(prefixSize, name.size() - prefixSize);
+		const string evalResult = state.substitutions.get(condition);
+
+		conditionEndPos += sizeof("}}") - 1;
+		size_type endIfPos = state.result.find("{{/if}}", conditionEndPos);
+		if (endIfPos == string::npos) {
+			return state.result.size();
+		}
+
+		if (!evalResult.empty() && evalResult != "false") {
+			const string subContent = state.result.substr(conditionEndPos, endIfPos - conditionEndPos);
+			State subState(subContent, state.substitutions);
+			apply(subState);
+			state.result.replace(pos, endIfPos + endIfSize - pos, subState.result);
+			return pos + subState.result.size();
+		} else {
+			state.result.erase(pos, endIfPos - pos + sizeof("{{/if}}") - 1);
+			return pos;
+		}
+	}
+
+	size_type processSubsitution(State &state, size_type pos, size_type endPos, string name) {
+		Options options;
+		size_type sep = name.find('|');
+		if (sep != string::npos) {
+			const string optionsString = name.substr(sep + 1);
+			name = name.substr(0, sep);
+			options = parseOptions(optionsString);
+		}
+
+		string value = state.substitutions.get(name);
+		if (value.empty()) {
+			value = options.defaultValue;
+		}
+		if (!options.raw) {
+			value = escapeHTML(value);
+			makeBreakable(value);
+		}
+
+		state.result.replace(pos, endPos - pos + (sizeof("}}") - 1), value);
+		return pos + value.size();
+	}
+
+	size_type processCommand(State &state, size_type pos) {
+		size_type endPos = state.result.find("}}", pos);
+		if (endPos == string::npos) {
+			return state.result.size();
+		}
+		
+		string name = state.result.substr(pos + 2, endPos - pos - 2);
+		if (startsWith(name, "if ")) {
+			return processIf(state, pos, endPos, name);
+		} else {
+			return processSubsitution(state, pos, endPos, name);
+		}
+	}
+
+	void apply(State &state) {
+		size_type searchStart = 0;
+
+		while (searchStart < state.result.size()) {
+			size_type pos = state.result.find("{{", searchStart);
+			if (pos == string::npos) {
+				searchStart = state.result.size();
+			} else {
+				searchStart = processCommand(state, pos);
+			}
+		}
+	}
+
+public:
+	Template(const StaticString &_content)
+		: content(_content)
+		{ }
+	
+	string apply(const StringMap<StaticString> &substitutions) {
+		State state(content, substitutions);
+		apply(state);
+		return state.result;
+	}
+
+	static string apply(const StaticString &content, const StringMap<StaticString> &substitutions) {
+		return Template(content).apply(substitutions);
+	}
+};
+
+
+} // namespace Passenger
+
+#endif /* _PASSENGER_TEMPLATE_H_ */