repos/FeepingCreaturism/FeepingCreaturism.cpp

// Feeping Creaturism
//
// Douglas Thrift
//
// $Id$

#include <cxx/standard.hh>

#include <api/environment.hpp>
#include <api/exename.hpp>
#include <api/pcre/regex.hpp>
#include <api/random.hpp>
#include <app/simple.hpp>
#include <cse/traits.hpp>

#include <ctime>

#include "Jargon.hpp"

template <typename Environment>
cse::String Get(const Environment &environment, const cse::String &name)
{
        try { return environment.Get(name); }
        catch (ext::NotFoundException) { return cse::EmptyString; }
}

int Main(const app::Options &options)
{
        try
        {
                FeepingCreaturism creaturism;

                return 0;
        }
        catch (const ext::Exception &exception)
        {
                api::Cout << _B("Content-Type: text/plain\r\n\r\n") << exception << ios::NewLine;

                return 1;
        }
}

FeepingCreaturism::FeepingCreaturism()
{
        Initialize();
        Parse();

        cse::String path(Get(api::TheEnvironment, _B("PATH_INFO")));
        api::Pcre::RegEx::Match match;

        if (match = api::Pcre::RegEx(_B("^/daily/(\\d{4}-\\d{2}-\\d{2})?$"))(path))
                Daily(match[1]);
        else if (match = api::Pcre::RegEx(_B("^/random/(\\d+)?$"))(path))
                Random(match[1]);
        else if (match = api::Pcre::RegEx(_S<ios::String>() << _B("^/(") << matcher << _B(")$"))(path))
                Select(match[1], true);
        else
                api::Cout << _B("Location: http://") << Get(api::TheEnvironment, "HTTP_HOST") << Get(api::TheEnvironment, "SCRIPT_NAME") << _B("/daily/\r\n\r\n");
}

bool FeepingCreaturism::CaseLess::Execute(const cse::String &one, const cse::String &two)
{
        cse::String one_(cse::ToLower(one)), two_(cse::ToLower(two));

        if (one_ == two_)
                return one < two;

        return one_ < two_;
}

void FeepingCreaturism::Initialize()
{
        _R<xml::Document> document(xml::Parse(_B("jargon.xml")));
        _R<xml::Node> node(*document/_B("feepingcreaturism"));

        path = *node/_B("jargon");
        matcher = *node/_B("matcher");

        _L<cse::String> args(1, path);

        args.InsertLast(_B("-type"));
        args.InsertLast(_B("f"));

        _S<api::Process> find(_B("/usr/bin/find"), args);
        api::Pcre::RegEx matcher_(_S<ios::String>() << _B("^") << path << _B("/(") << matcher << _B(")$"));
        ext::Buffer path;

        while (ios::ReadLine(*find.GetReader(), path))
                if (api::Pcre::RegEx::Match match = matcher_(path))
                        jargon.Insert(match[1]);
}

void FeepingCreaturism::Parse()
{
        _S<ios::Buffer> query(Get(api::TheEnvironment, _B("QUERY_STRING")));

        if (Get(api::TheEnvironment, _B("REQUEST_METHOD")) == _B("POST"))
        {
                query.Clear();

                ios::ReadToWriteFully(api::Cin, query, lexical_cast<size_t>(Get(api::TheEnvironment, _B("CONTENT_LENGTH"))));
        }

        if (query.IsEmpty())
                return;

        _forever
                try
                {
                        cse::String name(ios::ReadUntil(query, '='));

                        try
                        {
                                cse::String value(ios::ReadUntil(query, '&'));

                                cgi[name].InsertLast(value);
                        }
                        catch (ext::EosException)
                        {
                                cgi[name].InsertLast();

                                break;
                        }
                }
                catch (ext::EosException) { break; }
}

void FeepingCreaturism::Daily(const cse::String &date)
{
        std::time_t when(std::time(NULL));
        std::tm* day(std::localtime(&when));

        day->tm_sec = 0;
        day->tm_min = 0;
        day->tm_hour = 0;

        if (!date.IsEmpty())
                ::strptime(date.NullTerminate(), "%Y-%m-%d", day);

        std::time_t difference(mktime(day) / 86400);
        _L<cse::String> jargon_(jargon.Begin(), jargon.End());
        cse::String entry(jargon_.GetSize() ? jargon_[difference % jargon_.GetSize()] : cse::EmptyString);

        Select(entry);
}

void FeepingCreaturism::Random(const cse::String &number)
{
        _L<cse::String> jargon_(jargon.Begin(), jargon.End());
        size_t random;
        
        if (number.IsEmpty())
                api::WeakRandom.Read(reinterpret_cast<byte_t *>(&random), sizeof (size_t));
        else
                random = lexical_cast<size_t>(number);

        _assert(random >= 0);
        _assert(random % jargon_.GetSize() < jargon_.GetSize());

        cse::String entry(jargon_.GetSize() ? jargon_[random % jargon_.GetSize()] : cse::EmptyString);

        Select(entry);
}

void FeepingCreaturism::Select(const cse::String &selection, bool validate)
{
        if (!validate || jargon.Contains(selection))
        {
                api::Cout << _B("Content-Type: text/html; charset=UTF-8\r\n\r\n");

                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);

                api::Cout << jargon;
        }
        else
                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");
}
Revision:	792
Committed:	2006-06-01T23:55:43-07:00 (19 years ago) by douglas
File size:	4653 byte(s)
Log Message:	Woo!
#	User	Rev	Content
1	Douglas Thrift	191	// Feeping Creaturism
2			//
3			// Douglas Thrift
4			//
5			// $Id$
6
7	douglas	792	#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	Douglas Thrift	196	#include "Jargon.hpp"
19	Douglas Thrift	191
20	douglas	792	template <typename Environment>
21			cse::String Get(const Environment &environment, const cse::String &name)
22			{
23			try { return environment.Get(name); }
24			catch (ext::NotFoundException) { return cse::EmptyString; }
25			}
26	Douglas Thrift	261
27	douglas	792	int Main(const app::Options &options)
28	Douglas Thrift	191	{
29	douglas	792	try
30			{
31			FeepingCreaturism creaturism;
32	Douglas Thrift	201
33	douglas	792	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	Douglas Thrift	191
39	douglas	792	return 1;
40			}
41	Douglas Thrift	251	}
42	Douglas Thrift	194
43			FeepingCreaturism::FeepingCreaturism()
44			{
45	douglas	792	Initialize();
46			Parse();
47	Douglas Thrift	194
48	douglas	792	cse::String path(Get(api::TheEnvironment, _B("PATH_INFO")));
49			api::Pcre::RegEx::Match match;
50	Douglas Thrift	194
51	douglas	792	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	Douglas Thrift	198	else
58	douglas	792	api::Cout << _B("Location: http://") << Get(api::TheEnvironment, "HTTP_HOST") << Get(api::TheEnvironment, "SCRIPT_NAME") << _B("/daily/\r\n\r\n");
59	Douglas Thrift	194	}
60
61	douglas	792	bool FeepingCreaturism::CaseLess::Execute(const cse::String &one, const cse::String &two)
62	Douglas Thrift	206	{
63	douglas	792	cse::String one_(cse::ToLower(one)), two_(cse::ToLower(two));
64	Douglas Thrift	206
65	douglas	792	if (one_ == two_)
66			return one < two;
67	Douglas Thrift	206
68			return one_ < two_;
69			}
70
71	douglas	792	void FeepingCreaturism::Initialize()
72	Douglas Thrift	194	{
73	douglas	792	_R<xml::Document> document(xml::Parse(_B("jargon.xml")));
74			_R<xml::Node> node(*document/_B("feepingcreaturism"));
75	Douglas Thrift	194
76	douglas	792	path = *node/_B("jargon");
77			matcher = *node/_B("matcher");
78	Douglas Thrift	194
79	douglas	792	_L<cse::String> args(1, path);
80	Douglas Thrift	194
81	douglas	792	args.InsertLast(_B("-type"));
82			args.InsertLast(_B("f"));
83	Douglas Thrift	194
84	douglas	792	_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	Douglas Thrift	194
88	douglas	792	while (ios::ReadLine(*find.GetReader(), path))
89			if (api::Pcre::RegEx::Match match = matcher_(path))
90			jargon.Insert(match[1]);
91	Douglas Thrift	194	}
92
93	douglas	792	void FeepingCreaturism::Parse()
94	Douglas Thrift	203	{
95	douglas	792	_S<ios::Buffer> query(Get(api::TheEnvironment, _B("QUERY_STRING")));
96	Douglas Thrift	203
97	douglas	792	if (Get(api::TheEnvironment, _B("REQUEST_METHOD")) == _B("POST"))
98	Douglas Thrift	203	{
99	douglas	792	query.Clear();
100	Douglas Thrift	203
101	douglas	792	ios::ReadToWriteFully(api::Cin, query, lexical_cast<size_t>(Get(api::TheEnvironment, _B("CONTENT_LENGTH"))));
102	Douglas Thrift	203	}
103
104	douglas	792	if (query.IsEmpty())
105			return;
106	Douglas Thrift	203
107	douglas	792	_forever
108			try
109			{
110			cse::String name(ios::ReadUntil(query, '='));
111	Douglas Thrift	203
112	douglas	792	try
113			{
114			cse::String value(ios::ReadUntil(query, '&'));
115	Douglas Thrift	203
116	douglas	792	cgi[name].InsertLast(value);
117			}
118			catch (ext::EosException)
119			{
120			cgi[name].InsertLast();
121
122			break;
123			}
124			}
125			catch (ext::EosException) { break; }
126	Douglas Thrift	203	}
127
128	douglas	792	void FeepingCreaturism::Daily(const cse::String &date)
129	Douglas Thrift	194	{
130			std::time_t when(std::time(NULL));
131	Douglas Thrift	211	std::tm* day(std::localtime(&when));
132	Douglas Thrift	194
133	Douglas Thrift	211	day->tm_sec = 0;
134			day->tm_min = 0;
135			day->tm_hour = 0;
136	Douglas Thrift	194
137	douglas	792	if (!date.IsEmpty())
138			::strptime(date.NullTerminate(), "%Y-%m-%d", day);
139	Douglas Thrift	211
140			std::time_t difference(mktime(day) / 86400);
141	douglas	792	_L<cse::String> jargon_(jargon.Begin(), jargon.End());
142			cse::String entry(jargon_.GetSize() ? jargon_[difference % jargon_.GetSize()] : cse::EmptyString);
143	Douglas Thrift	194
144	douglas	792	Select(entry);
145	Douglas Thrift	194	}
146
147	douglas	792	void FeepingCreaturism::Random(const cse::String &number)
148	Douglas Thrift	194	{
149	douglas	792	_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	Douglas Thrift	194
157	douglas	792	_assert(random >= 0);
158			_assert(random % jargon_.GetSize() < jargon_.GetSize());
159	Douglas Thrift	194
160	douglas	792	cse::String entry(jargon_.GetSize() ? jargon_[random % jargon_.GetSize()] : cse::EmptyString);
161	Douglas Thrift	211
162	douglas	792	Select(entry);
163	Douglas Thrift	194	}
164
165	douglas	792	void FeepingCreaturism::Select(const cse::String &selection, bool validate)
166	Douglas Thrift	194	{
167	douglas	792	if (!validate \|\| jargon.Contains(selection))
168	Douglas Thrift	194	{
169	douglas	792	api::Cout << _B("Content-Type: text/html; charset=UTF-8\r\n\r\n");
170	Douglas Thrift	196
171	douglas	792	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	Douglas Thrift	196
173	Douglas Thrift	225	api::Cout << jargon;
174	Douglas Thrift	194	}
175	Douglas Thrift	195	else
176	douglas	792	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	Douglas Thrift	194	}