ViewVC Help

View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing

root/repos/FeepingCreaturism/FeepingCreaturism.cpp

Comparing FeepingCreaturism/FeepingCreaturism.cpp (file contents):
Revision 201 by Douglas Thrift, 2004-08-30T19:24:40-07:00 vs.
Revision 792 by douglas, 2006-06-01T23:55:43-07:00

#	Line 4 | Line 4
4		//
5		// $Id$
6
7	<	#include "Environment.hpp"
8	<	#include "Matcher.hpp"
7	>	#include <cxx/standard.hh>
8	>
9	>	#include <api/environment.hpp>
10	>	#include <api/exename.hpp>
11	>	#include <api/pcre/regex.hpp>
12	>	#include <api/random.hpp>
13	>	#include <app/simple.hpp>
14	>	#include <cse/traits.hpp>
15	>
16	>	#include <ctime>
17	>
18		#include "Jargon.hpp"
19
20	<	extern "C"
20	>	template <typename Environment>
21	>	cse::String Get(const Environment &environment, const cse::String &name)
22		{
23	<	#include <sys/types.h>
24	<	#include <sys/stat.h>
15	<	#include <fts.h>
23	>	try { return environment.Get(name); }
24	>	catch (ext::NotFoundException) { return cse::EmptyString; }
25		}
26
27	<	int main(int argc, char* argv[])
27	>	int Main(const app::Options &options)
28		{
29	<	FeepingCreaturism::program = argv[0];
29	>	try
30	>	{
31	>	FeepingCreaturism creaturism;
32
33	<	FeepingCreaturism creaturism;
33	>	return 0;
34	>	}
35	>	catch (const ext::Exception &exception)
36	>	{
37	>	api::Cout << _B("Content-Type: text/plain\r\n\r\n") << exception << ios::NewLine;
38
39	<	return 0;
39	>	return 1;
40	>	}
41		}
42
43		FeepingCreaturism::FeepingCreaturism()
44		{
45	<	initialize();
45	>	Initialize();
46	>	Parse();
47
48	<	std::string path(env.get("PATH_INFO"));
49	<	Matcher matcher;
48	>	cse::String path(Get(api::TheEnvironment, _B("PATH_INFO")));
49	>	api::Pcre::RegEx::Match match;
50
51	<	if (path == "/daily/") daily(); else if (path == "/random/")
52	<	{
53	<	random();
54	<	}
55	<	else if (path == matcher("^/(" + this->matcher + ")$"))
56	<	{
40	<	select(matcher[1], true);
41	<	}
51	>	if (match = api::Pcre::RegEx(_B("^/daily/(\\d{4}-\\d{2}-\\d{2})?$"))(path))
52	>	Daily(match[1]);
53	>	else if (match = api::Pcre::RegEx(_B("^/random/(\\d+)?$"))(path))
54	>	Random(match[1]);
55	>	else if (match = api::Pcre::RegEx(_S<ios::String>() << _B("^/(") << matcher << _B(")$"))(path))
56	>	Select(match[1], true);
57		else
58	<	{
44	<	cout << "Status: 301\r\n";
45	<	}
58	>	api::Cout << _B("Location: http://") << Get(api::TheEnvironment, "HTTP_HOST") << Get(api::TheEnvironment, "SCRIPT_NAME") << _B("/daily/\r\n\r\n");
59		}
60
61	<	std::string FeepingCreaturism::program;
61	>	bool FeepingCreaturism::CaseLess::Execute(const cse::String &one, const cse::String &two)
62	>	{
63	>	cse::String one_(cse::ToLower(one)), two_(cse::ToLower(two));
64	>
65	>	if (one_ == two_)
66	>	return one < two;
67
68	<	void FeepingCreaturism::initialize()
68	>	return one_ < two_;
69	>	}
70	>
71	>	void FeepingCreaturism::Initialize()
72		{
73	<	ext::Handle<xml::Document> document(xml::Parse("jargon.xml"));
74	<	ext::Handle<xml::Node> node(*document/"feepingcreaturism");
73	>	_R<xml::Document> document(xml::Parse(_B("jargon.xml")));
74	>	_R<xml::Node> node(*document/_B("feepingcreaturism"));
75	>
76	>	path = *node/_B("jargon");
77	>	matcher = *node/_B("matcher");
78
79	<	this->path = *node/"jargon";
56	<	this->matcher = *node/"matcher";
79	>	_L<cse::String> args(1, path);
80
81	<	char* path[] = { new char[this->path.size()] };
81	>	args.InsertLast(_B("-type"));
82	>	args.InsertLast(_B("f"));
83
84	<	std::strcpy(path[0], this->path.c_str());
84	>	_S<api::Process> find(_B("/usr/bin/find"), args);
85	>	api::Pcre::RegEx matcher_(_S<ios::String>() << _B("^") << path << _B("/(") << matcher << _B(")$"));
86	>	ext::Buffer path;
87	>
88	>	while (ios::ReadLine(*find.GetReader(), path))
89	>	if (api::Pcre::RegEx::Match match = matcher_(path))
90	>	jargon.Insert(match[1]);
91	>	}
92
93	<	::FTS* traversal(::fts_open(path, FTS_LOGICAL, NULL));
94	<	Matcher matcher('^' + this->path + "/(" + this->matcher + ")$");
93	>	void FeepingCreaturism::Parse()
94	>	{
95	>	_S<ios::Buffer> query(Get(api::TheEnvironment, _B("QUERY_STRING")));
96
97	<	if (traversal == NULL)
97	>	if (Get(api::TheEnvironment, _B("REQUEST_METHOD")) == _B("POST"))
98		{
99	<	cerr << program << ": Horrible Failure!\n";
99	>	query.Clear();
100
101	<	std::exit(1);
101	>	ios::ReadToWriteFully(api::Cin, query, lexical_cast<size_t>(Get(api::TheEnvironment, _B("CONTENT_LENGTH"))));
102		}
103
104	<	for (::FTSENT* entity(::fts_read(traversal)); entity != NULL;
105	<	entity = ::fts_read(traversal))
106	<	{
107	<	if (entity->fts_info == FTS_F && entity->fts_path == matcher)
104	>	if (query.IsEmpty())
105	>	return;
106	>
107	>	_forever
108	>	try
109		{
110	<	jargon.insert(matcher[1]);
78	<	}
79	<	}
110	>	cse::String name(ios::ReadUntil(query, '='));
111
112	<	::fts_close(traversal);
112	>	try
113	>	{
114	>	cse::String value(ios::ReadUntil(query, '&'));
115	>
116	>	cgi[name].InsertLast(value);
117	>	}
118	>	catch (ext::EosException)
119	>	{
120	>	cgi[name].InsertLast();
121
122	<	delete [] path[0];
122	>	break;
123	>	}
124	>	}
125	>	catch (ext::EosException) { break; }
126		}
127
128	<	void FeepingCreaturism::daily()
128	>	void FeepingCreaturism::Daily(const cse::String &date)
129		{
130		std::time_t when(std::time(NULL));
131	<	std::tm* now(std::localtime(&when));
131	>	std::tm* day(std::localtime(&when));
132
133	<	now->tm_sec = 0;
134	<	now->tm_min = 0;
135	<	now->tm_hour = 0;
133	>	day->tm_sec = 0;
134	>	day->tm_min = 0;
135	>	day->tm_hour = 0;
136
137	<	std::time_t difference(mktime(now) / 86400);
138	<	std::vector<std::string> jargon(this->jargon.begin(), this->jargon.end());
97	<	std::string entry(jargon.size() ? jargon[difference % jargon.size()] : "");
137	>	if (!date.IsEmpty())
138	>	::strptime(date.NullTerminate(), "%Y-%m-%d", day);
139
140	<	select(entry);
140	>	std::time_t difference(mktime(day) / 86400);
141	>	_L<cse::String> jargon_(jargon.Begin(), jargon.End());
142	>	cse::String entry(jargon_.GetSize() ? jargon_[difference % jargon_.GetSize()] : cse::EmptyString);
143	>
144	>	Select(entry);
145		}
146
147	<	void FeepingCreaturism::random()
147	>	void FeepingCreaturism::Random(const cse::String &number)
148		{
149	<	::srandomdev();
149	>	_L<cse::String> jargon_(jargon.Begin(), jargon.End());
150	>	size_t random;
151	>
152	>	if (number.IsEmpty())
153	>	api::WeakRandom.Read(reinterpret_cast<byte_t *>(&random), sizeof (size_t));
154	>	else
155	>	random = lexical_cast<size_t>(number);
156
157	<	std::vector<std::string> jargon(this->jargon.begin(), this->jargon.end());
158	<	std::string entry(jargon.size() ? jargon[::random() % jargon.size()] : "");
157	>	_assert(random >= 0);
158	>	_assert(random % jargon_.GetSize() < jargon_.GetSize());
159
160	<	select(entry);
160	>	cse::String entry(jargon_.GetSize() ? jargon_[random % jargon_.GetSize()] : cse::EmptyString);
161	>
162	>	Select(entry);
163		}
164
165	<	void FeepingCreaturism::select(const std::string& selection, bool validate)
165	>	void FeepingCreaturism::Select(const cse::String &selection, bool validate)
166		{
167	<	if (!validate || jargon.find(selection) != jargon.end())
167	>	if (!validate || jargon.Contains(selection))
168		{
169	<	cout << "Content-Type: text/html; charset=UTF-8\r\n\r\n";
169	>	api::Cout << _B("Content-Type: text/html; charset=UTF-8\r\n\r\n");
170
171	<	Jargon jargon(path + '/' + selection);
171	>	Jargon jargon(path, selection, cgi.Contains(_B("include")) && lexical_cast<bool>(cgi[_B("include")].First()), cgi.Contains(_B("relative")) ? cgi[_B("relative")].First() : cse::EmptyString);
172
173	<	cout << jargon;
173	>	api::Cout << jargon;
174		}
175		else
176	<	{
124	<	cout << "Status: 404\r\nContent-Type: text/html; charset=ISO-8859-1\r\n"
125	<	<< "\r\n<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n"
126	<	<< "<html><head>\n<title>404 Not Found</title>\n</head><body>\n"
127	<	<< "<h1>Not Found</h1>\n<p>The requested URL "
128	<	<< env.get("PATH_INFO") << " was not found on this server.</p>\n"
129	<	<< "<hr />\n" << env.get("SERVER_SIGNATURE") << "</body></html>\n";
130	<	}
176	>	api::Cout << _B("Status: 404\r\nContent-Type: text/html; charset=ISO-8859-1\r\n\r\n<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n<html><head>\n<title>404 Not Found</title>\n</head><body>\n<h1>Not Found</h1>\n<p>The requested URL ") << Get(api::TheEnvironment, _B("PATH_INFO")) << _B(" was not found on this server.</p>\n<hr />\n") << Get(api::TheEnvironment, _B("SERVER_SIGNATURE")) << _B("</body></html>\n");
177		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines