repos/FeepingCreaturism/FeepingCreaturism.cpp

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

#include "Environment.hpp"
#include "Matcher.hpp"
#include "Jargon.hpp"

extern "C"
{
#include <sys/types.h>
#include <sys/stat.h>
#include <fts.h>
}

int main(int argc, char* argv[])
{
        FeepingCreaturism::program = argv[0];

        FeepingCreaturism creaturism;

        return 0;
}

FeepingCreaturism::FeepingCreaturism()
{
        initialize();
        parse();

        ext::String path(env.get("PATH_INFO"));
        Matcher matcher;

        if (path == "/daily/") daily(); else if (path == "/random/")
        {
                random();
        }
        else if (path == matcher("^/(" + this->matcher + ")$"))
        {
                select(matcher[1], true);
        }
        else
        {
                api::Cout << "Location: http://" << env.get("HTTP_HOST")
                        << env.get("SCRIPT_NAME") << "/daily/\r\n\r\n";
        }
}

ext::String FeepingCreaturism::program;

bool FeepingCreaturism::CaseLess::operator()(const std::string& one,
        const std::string& two)
{
        std::string one_(one), two_(two);

        // XXX: should be std::tolower except g++34 doesn't believe it
        std::transform(one.begin(), one.end(), one_.begin(), ::tolower);
        std::transform(two.begin(), two.end(), two_.begin(), ::tolower);

        return one_ < two_;
}

void FeepingCreaturism::initialize()
{
        ext::Handle<xml::Document> document(xml::Parse("jargon.xml"));
        ext::Handle<xml::Node> node(*document/"feepingcreaturism");

        this->path = *node/"jargon";
        this->matcher = *node/"matcher";

        char* path[] = { new char[this->path.size()] };

        std::strcpy(path[0], this->path.c_str());

        ::FTS* traversal(::fts_open(path, FTS_LOGICAL, NULL));
        Matcher matcher("^" + this->path + "/(" + this->matcher + ")$");

        if (traversal == NULL)
        {
                api::Cerr << program << ": Horrible Failure!\n";

                std::exit(1);
        }

        for (::FTSENT* entity(::fts_read(traversal)); entity != NULL;
                entity = ::fts_read(traversal))
        {
                if (entity->fts_info == FTS_F && entity->fts_path == matcher)
                {
                        jargon.insert(matcher[1]);
                }
        }

        ::fts_close(traversal);

        delete [] path[0];
}

void FeepingCreaturism::parse()
{
        std::stringstream query(env.get("QUERY_STRING"));

        if (env.get("REQUEST_METHOD") == "POST")
        {
                std::streamsize length(lexical_cast<std::streamsize>(env.get("CONTENT_"
                        "TYPE")));
                char* content(new char[length]);

                api::Cin.Read(content, length);
                query.write(content, length);

                delete [] content;
        }

        if (query.str().empty()) return;

        do
        {
                std::string name, value;

                std::getline(query, name, '=');
                std::getline(query, value, '&');

                cgi.insert(_P(name, value));
        }
        while (query.good());
}

void FeepingCreaturism::daily()
{
        std::time_t when(std::time(NULL));
        std::tm* now(std::localtime(&when));

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

        std::time_t difference(mktime(now) / 86400);
        std::vector<ext::String> jargon(this->jargon.begin(), this->jargon.end());
        ext::String entry(jargon.size() ? jargon[difference % jargon.size()] : "");

        select(entry);
}

void FeepingCreaturism::random()
{
        ::srandomdev();

        std::vector<ext::String> jargon(this->jargon.begin(), this->jargon.end());
        ext::String entry(jargon.size() ? jargon[::random() % jargon.size()] : "");

        select(entry);
}

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

                _M::iterator include(cgi.find("include"));

                if (include != cgi.end())
                {
                        Jargon jargon(path + "/" + selection,
                                lexical_cast<bool>(include->second));

                        api::Cout << jargon;
                }
                else
                {
                        Jargon jargon(path + "/" + selection);

                        api::Cout << jargon;
                }
        }
        else
        {
                api::Cout << "Status: 404\r\n"
                        << "Content-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 "
                        << env.get("PATH_INFO") << " was not found on this server.</p>\n"
                        << "<hr />\n" << env.get("SERVER_SIGNATURE") << "</body></html>\n";
        }
}
Revision:	206
Committed:	2004-09-01T03:36:00-07:00 (20 years, 9 months ago) by Douglas Thrift
File size:	4010 byte(s)
Log Message:	Removed menes evil sort, replaced with CaseLess std sort.
#	User	Rev	Content
1	Douglas Thrift	191	// Feeping Creaturism
2			//
3			// Douglas Thrift
4			//
5			// $Id$
6
7	Douglas Thrift	194	#include "Environment.hpp"
8			#include "Matcher.hpp"
9	Douglas Thrift	196	#include "Jargon.hpp"
10	Douglas Thrift	191
11	Douglas Thrift	194	extern "C"
12			{
13			#include <sys/types.h>
14			#include <sys/stat.h>
15			#include <fts.h>
16			}
17
18	Douglas Thrift	191	int main(int argc, char* argv[])
19			{
20	Douglas Thrift	201	FeepingCreaturism::program = argv[0];
21
22	Douglas Thrift	191	FeepingCreaturism creaturism;
23
24			return 0;
25			}
26	Douglas Thrift	194
27			FeepingCreaturism::FeepingCreaturism()
28			{
29			initialize();
30	Douglas Thrift	203	parse();
31	Douglas Thrift	194
32	Douglas Thrift	203	ext::String path(env.get("PATH_INFO"));
33	Douglas Thrift	194	Matcher matcher;
34
35	Douglas Thrift	198	if (path == "/daily/") daily(); else if (path == "/random/")
36	Douglas Thrift	194	{
37			random();
38			}
39			else if (path == matcher("^/(" + this->matcher + ")$"))
40			{
41			select(matcher[1], true);
42			}
43	Douglas Thrift	198	else
44			{
45	Douglas Thrift	203	api::Cout << "Location: http://" << env.get("HTTP_HOST")
46	Douglas Thrift	202	<< env.get("SCRIPT_NAME") << "/daily/\r\n\r\n";
47	Douglas Thrift	198	}
48	Douglas Thrift	194	}
49
50	Douglas Thrift	203	ext::String FeepingCreaturism::program;
51	Douglas Thrift	201
52	Douglas Thrift	206	bool FeepingCreaturism::CaseLess::operator()(const std::string& one,
53			const std::string& two)
54			{
55			std::string one_(one), two_(two);
56
57			// XXX: should be std::tolower except g++34 doesn't believe it
58			std::transform(one.begin(), one.end(), one_.begin(), ::tolower);
59			std::transform(two.begin(), two.end(), two_.begin(), ::tolower);
60
61			return one_ < two_;
62			}
63
64	Douglas Thrift	194	void FeepingCreaturism::initialize()
65			{
66	Douglas Thrift	201	ext::Handle<xml::Document> document(xml::Parse("jargon.xml"));
67			ext::Handle<xml::Node> node(*document/"feepingcreaturism");
68	Douglas Thrift	194
69	Douglas Thrift	201	this->path = *node/"jargon";
70			this->matcher = *node/"matcher";
71	Douglas Thrift	194
72			char* path[] = { new char[this->path.size()] };
73
74			std::strcpy(path[0], this->path.c_str());
75
76			::FTS* traversal(::fts_open(path, FTS_LOGICAL, NULL));
77	Douglas Thrift	203	Matcher matcher("^" + this->path + "/(" + this->matcher + ")$");
78	Douglas Thrift	194
79	Douglas Thrift	196	if (traversal == NULL)
80			{
81	Douglas Thrift	203	api::Cerr << program << ": Horrible Failure!\n";
82	Douglas Thrift	196
83			std::exit(1);
84			}
85
86	Douglas Thrift	194	for (::FTSENT* entity(::fts_read(traversal)); entity != NULL;
87			entity = ::fts_read(traversal))
88			{
89			if (entity->fts_info == FTS_F && entity->fts_path == matcher)
90			{
91			jargon.insert(matcher[1]);
92			}
93			}
94
95			::fts_close(traversal);
96
97			delete [] path[0];
98			}
99
100	Douglas Thrift	203	void FeepingCreaturism::parse()
101			{
102			std::stringstream query(env.get("QUERY_STRING"));
103
104			if (env.get("REQUEST_METHOD") == "POST")
105			{
106			std::streamsize length(lexical_cast<std::streamsize>(env.get("CONTENT_"
107			"TYPE")));
108			char* content(new char[length]);
109
110			api::Cin.Read(content, length);
111			query.write(content, length);
112
113			delete [] content;
114			}
115
116			if (query.str().empty()) return;
117
118			do
119			{
120			std::string name, value;
121
122			std::getline(query, name, '=');
123			std::getline(query, value, '&');
124
125			cgi.insert(_P(name, value));
126			}
127			while (query.good());
128			}
129
130	Douglas Thrift	194	void FeepingCreaturism::daily()
131			{
132			std::time_t when(std::time(NULL));
133			std::tm* now(std::localtime(&when));
134
135			now->tm_sec = 0;
136			now->tm_min = 0;
137			now->tm_hour = 0;
138
139			std::time_t difference(mktime(now) / 86400);
140	Douglas Thrift	203	std::vector<ext::String> jargon(this->jargon.begin(), this->jargon.end());
141			ext::String entry(jargon.size() ? jargon[difference % jargon.size()] : "");
142	Douglas Thrift	194
143			select(entry);
144			}
145
146			void FeepingCreaturism::random()
147			{
148			::srandomdev();
149
150	Douglas Thrift	203	std::vector<ext::String> jargon(this->jargon.begin(), this->jargon.end());
151			ext::String entry(jargon.size() ? jargon[::random() % jargon.size()] : "");
152	Douglas Thrift	194
153			select(entry);
154			}
155
156	Douglas Thrift	203	void FeepingCreaturism::select(const ext::String& selection, bool validate)
157	Douglas Thrift	194	{
158			if (!validate \|\| jargon.find(selection) != jargon.end())
159			{
160	Douglas Thrift	203	api::Cout << "Content-Type: text/html; charset=UTF-8\r\n\r\n";
161	Douglas Thrift	196
162	Douglas Thrift	203	_M::iterator include(cgi.find("include"));
163	Douglas Thrift	196
164	Douglas Thrift	203	if (include != cgi.end())
165			{
166			Jargon jargon(path + "/" + selection,
167			lexical_cast<bool>(include->second));
168
169			api::Cout << jargon;
170			}
171			else
172			{
173			Jargon jargon(path + "/" + selection);
174
175			api::Cout << jargon;
176			}
177	Douglas Thrift	194	}
178	Douglas Thrift	195	else
179			{
180	Douglas Thrift	203	api::Cout << "Status: 404\r\n"
181			<< "Content-Type: text/html; charset=ISO-8859-1\r\n\r\n"
182			<< "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n"
183	Douglas Thrift	195	<< "<html><head>\n<title>404 Not Found</title>\n</head><body>\n"
184			<< "<h1>Not Found</h1>\n<p>The requested URL "
185			<< env.get("PATH_INFO") << " was not found on this server.</p>\n"
186			<< "<hr />\n" << env.get("SERVER_SIGNATURE") << "</body></html>\n";
187			}
188	Douglas Thrift	194	}