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 ext::Compare(one.GetData().Begin(), two.GetData().Begin(), one.GetData().GetSize() < two.GetData().GetSize() ? one.GetData().GetSize() : two.GetData().GetSize()) < 0;

        return ext::Compare(one_.GetData().Begin(), two_.GetData().Begin(), one_.GetData().GetSize() < two_.GetData().GetSize() ? one_.GetData().GetSize() : two_.GetData().GetSize()) < 0;
}

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:	796
Committed:	2006-06-04T15:23:25-07:00 (19 years ago) by douglas
File size:	4969 byte(s)
Log Message:	Fixy!
#	Content
1	// Feeping Creaturism
2	//
3	// Douglas Thrift
4	//
5	// $Id$
6
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	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
27	int Main(const app::Options &options)
28	{
29	try
30	{
31	FeepingCreaturism creaturism;
32
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 1;
40	}
41	}
42
43	FeepingCreaturism::FeepingCreaturism()
44	{
45	Initialize();
46	Parse();
47
48	cse::String path(Get(api::TheEnvironment, _B("PATH_INFO")));
49	api::Pcre::RegEx::Match match;
50
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	api::Cout << _B("Location: http://") << Get(api::TheEnvironment, "HTTP_HOST") << Get(api::TheEnvironment, "SCRIPT_NAME") << _B("/daily/\r\n\r\n");
59	}
60
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 ext::Compare(one.GetData().Begin(), two.GetData().Begin(), one.GetData().GetSize() < two.GetData().GetSize() ? one.GetData().GetSize() : two.GetData().GetSize()) < 0;
67
68	return ext::Compare(one_.GetData().Begin(), two_.GetData().Begin(), one_.GetData().GetSize() < two_.GetData().GetSize() ? one_.GetData().GetSize() : two_.GetData().GetSize()) < 0;
69	}
70
71	void FeepingCreaturism::Initialize()
72	{
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	_L<cse::String> args(1, path);
80
81	args.InsertLast(_B("-type"));
82	args.InsertLast(_B("f"));
83
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	void FeepingCreaturism::Parse()
94	{
95	_S<ios::Buffer> query(Get(api::TheEnvironment, _B("QUERY_STRING")));
96
97	if (Get(api::TheEnvironment, _B("REQUEST_METHOD")) == _B("POST"))
98	{
99	query.Clear();
100
101	ios::ReadToWriteFully(api::Cin, query, lexical_cast<size_t>(Get(api::TheEnvironment, _B("CONTENT_LENGTH"))));
102	}
103
104	if (query.IsEmpty())
105	return;
106
107	_forever
108	try
109	{
110	cse::String name(ios::ReadUntil(query, '='));
111
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	break;
123	}
124	}
125	catch (ext::EosException) { break; }
126	}
127
128	void FeepingCreaturism::Daily(const cse::String &date)
129	{
130	std::time_t when(std::time(NULL));
131	std::tm* day(std::localtime(&when));
132
133	day->tm_sec = 0;
134	day->tm_min = 0;
135	day->tm_hour = 0;
136
137	if (!date.IsEmpty())
138	::strptime(date.NullTerminate(), "%Y-%m-%d", day);
139
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(const cse::String &number)
148	{
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	_assert(random >= 0);
158	_assert(random % jargon_.GetSize() < jargon_.GetSize());
159
160	cse::String entry(jargon_.GetSize() ? jargon_[random % jargon_.GetSize()] : cse::EmptyString);
161
162	Select(entry);
163	}
164
165	void FeepingCreaturism::Select(const cse::String &selection, bool validate)
166	{
167	if (!validate \|\| jargon.Contains(selection))
168	{
169	api::Cout << _B("Content-Type: text/html; charset=UTF-8\r\n\r\n");
170
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	api::Cout << jargon;
174	}
175	else
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	}