ViewVC Help
View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing
root/repos/FeepingCreaturism/FeepingCreaturism.cpp
(Generate patch)

Comparing FeepingCreaturism/FeepingCreaturism.cpp (file contents):
Revision 191 by Douglas Thrift, 2004-08-20T02:44:20-07:00 vs.
Revision 792 by douglas, 2006-06-01T23:55:43-07:00

# Line 4 | Line 4
4   //
5   // $Id$
6  
7 < #include "FeepingCreaturism.hpp"
7 > #include <cxx/standard.hh>
8  
9 < int main(int argc, char* argv[])
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 <        FeepingCreaturism creaturism;
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 one < two;
67 >
68 >        return one_ < two_;
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 <        return 0;
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   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines