Removed yamlcpp dependency from rawr-gen

rawr-gen now takes the input corpus as a command-line argument, so as to increase the ease-of-use. It also now shows a usage message if provided with a non-existent file or no argument.

3 files changed, 28 insertions, 15 deletions

@@ -4,7 +4,5 @@ ACLOCAL_AMFLAGS = ${ACLOCAL_FLAGS}
 bin_PROGRAMS = rawr-ebooks rawr-gen
 rawr_ebooks_SOURCES = ebooks.cpp kgramstats.cpp
 rawr_gen_SOURCES = gen.cpp kgramstats.cpp
-rawr_ebooks_CPPFLAGS = $(LIBTWITCURL_CFLAGS)
-AM_CPPFLAGS = $(YAML_CFLAGS)
-rawr_ebooks_LDADD = $(LIBTWITCURL_LIBS) $(YAML_LIBS)
-rawr_gen_LDADD = $(YAML_LIBS)
\ No newline at end of file
+rawr_ebooks_CPPFLAGS = $(LIBTWITCURL_CFLAGS) $(YAML_CFLAGS)
+rawr_ebooks_LDADD = $(LIBTWITCURL_LIBS) $(YAML_LIBS)
\ No newline at end of file
@@ -4,7 +4,7 @@
 
 rawr-ebooks is a very good example of taking things too far. One of the assignments in the algorithms course I took was to implement an algorithm in SML that would generate nonsense statistically similar to an input corpus (basically, a plain text file with words and sentences in it). Of course, the actual point of the assignment was more focused on finding an algorithm that would do this in certain required cost bounds, but after the assignment ended, I decided that the project was too fun to let go and, combined with the recent revelation that [@Horse_Ebooks](https://twitter.com/Horse_Ebooks) was actually not a bot as widely believed, decided to augment my algorithm with the ability to post to Twitter.
 
-rawr-ebooks actually consists of two programs: `rawr-ebooks`, which generates nonsense and posts it to a Twitter account every hour, and `rawr-gen`, which generates nonsense on command. `rawr-gen` is probably more useful for the casual, well, anybody.
+rawr-ebooks actually consists of two programs: `rawr-ebooks`, which generates nonsense and posts it to a Twitter account every hour, and `rawr-gen`, which generates nonsense on command. `rawr-gen` is probably more useful for the casual, well, anybody. It also, unlike `rawr-ebooks`, does not require that the user have any external libraries installed.
 
 Here is how one would go about compiling `rawr-gen`:
 
@@ -24,15 +24,14 @@ Here is how one would go about compiling `rawr-gen`:
 
    <pre>make rawr-gen</pre>
     
-5. Rename `config-example.yml` to `config.yml` and within it, replace `corpus.txt` with the path to your input
-6. Run `rawr-gen`
+5. Run `rawr-gen` with your corpus. For instance, if your corpus was called `corpus.txt`, you would run:
 
-   <pre>./rawr-gen</pre>
+   <pre>./rawr-gen corpus.txt</pre>
 
 ## Implementation details
 
 I ended up rewriting the algorithm in C++ as the SML implementation did not handle randomization very well and would have been very difficult to adjust to post to Twitter. The new version has many improvements that improve the quality of the generated output, and the input corpus that I use for @Rawr_Ebooks is growing every day. As of October 6th, 2013, it is about 200,000 words long.
 
-rawr-ebooks uses [yamlcpp](https://code.google.com/p/yaml-cpp/) to read configuration data from a file (mainly, where the input corpus is located, and the information used to connect to Twitter), and [twitcurl](https://code.google.com/p/twitcurl/) to post to Twitter.
+`rawr-ebooks` uses [yamlcpp](https://code.google.com/p/yaml-cpp/) to read configuration data from a file (mainly, where the input corpus is located, and the information used to connect to Twitter), and [twitcurl](https://code.google.com/p/twitcurl/) to post to Twitter. `rawr-gen` has no external dependencies, for ease of use, and accepts a corpus as a command-line argument.
 
 The program is roughly divided into two stages: a preprocessing stage and a generation stage. The preprocessing stage runs once at the beginning of the program's run and generates information to ease in the generation of output. This stage runs in O(t^2) time where t is the number of tokens in the input corpus. As you can probably tell, the preprocessing stage can take a fair bit of time to run sometimes. The generation stage actually generates the output and can occur multiple times per program run (in fact it should, otherwise you aren't making good use of the time spent during the preprocessing stage!). It runs in O(n log t) time, where t is the number of tokens in the input corpus, and n is the number of words to generate, which is usually between 5 and 50. As you can see, the generation stage runs far, far more quickly than the preprocessing stage.
\ No newline at end of file
@@ -7,18 +7,34 @@
 #include <cstdlib>
 #include <fstream>
 #include <iostream>
-#include <unistd.h>
-#include <yaml-cpp/yaml.h>
 
 using namespace::std;
 
 int main(int argc, char** args)
 {
         srand(time(NULL));
-        
-        YAML::Node config = YAML::LoadFile("config.yml");
-        
-        ifstream infile(config["corpus"].as<std::string>().c_str());
+    
+    if (argc == 1)
+    {
+        cout << "rawr-gen, version 1.0" << endl;
+        cout << "Usage: rawr-gen corpus-file" << endl;
+        cout << "  where 'corpus-file' is the path to your input" << endl;
+        
+        return 0;
+    }
+    
+        ifstream infile(args[1]);
+    if (!infile)
+    {
+        cout << "rawr-gen, version 1.0" << endl;
+        cout << "Usage: rawr-gen corpus-file" << endl;
+        cout << "  where 'corpus-file' is the path to your input" << endl;
+        cout << endl;
+        cout << "The file you specified does not exist." << endl;
+        
+        return 0;
+    }
+    
         string corpus;
         string line;
         while (getline(infile, line))