chinwag 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4e33fde93c7612aeb9941b6b5544a48f9acc2afb
+  data.tar.gz: cd2a75d19bce767042c8e0c6401f29dfd30e7227
+SHA512:
+  metadata.gz: 73ff8f9e4db275f9ef69ea03ffe9cb35ef46db12621d1c7a8eca9a23a3a8cc7b63763fc3ebed916eb98c63220d366350d39c085d8ce8dff2e613cebd4a986da1
+  data.tar.gz: 2aa6284b8dcece586643bcd76922c72cbb0c7de76389444ec5198e25ad97a03622535ec3267d022d6aba9b82669abe445c0e03548ab756438de3d2cf214802ad

data/Rakefile

@@ -0,0 +1,35 @@
+require 'rake/extensiontask'
+require 'rubygems/package_task'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+Rake::ExtensionTask.new "chinwag" do |ext|
+  ext.lib_dir = "lib/chinwag"
+end
+
+s = Gem::Specification.new "chinwag", "0.1.0" do |s|
+  s.authors = ["Chris Calo"]
+  s.email = ["ccalo@vulcanca.com"]
+  s.summary = "A text-synthesis library, for use in layout testing (and more)."
+  s.description = "#{s.summary} It houses flexible methods for generation, and a dictionary class (CWDict) allowing adequate token files (or embedded defaults) to be used as the basis for output creation."
+  s.homepage = "https://github.com/vulcancreative/chinwag-ruby"
+  s.license = "MIT"
+
+  s.files         = Dir["Rakefile"]
+  s.files        += Dir["lib/**/*.rb"]
+  s.files        += Dir["ext/**/*.h"]
+  s.files        += Dir["ext/**/*.c"]
+  s.files        += Dir["ext/chinwag/extconf.rb"]
+
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.extensions    = Dir["ext/**/extconf.rb"]
+  s.require_paths = ["lib", "ext"]
+end
+
+Gem::PackageTask.new s do end
+
+task :spec => [:clean, :clobber, :compile]
+
+task :default => :spec
+task :test => :spec

data/ext/chinwag/chinwag.c

@@ -0,0 +1,246 @@
+#include "chinwag.h"
+
+char* chinwag(cw_t type, unsigned long min, unsigned long max, dict_t dict)
+{
+  char* result = NULL;
+
+  if(min == 0 || max == 0)
+  {
+    char e[]="ERROR : chinwag requires max and min to be greater than 0; "
+    "got min : %d, max : %d\n";
+    fprintf(stderr, e, min, max);
+    exit(EXIT_FAILURE);
+  }
+
+  if(max < min)
+  {
+    char e[]="ERROR : chinwag requires max greater than, or equal to, min; "
+    "got min : %d, max : %d\n";
+    fprintf(stderr, e, min, max);
+    exit(EXIT_FAILURE);
+  }
+
+  if(type >= 4)
+  {
+    char e[]="ERROR : chinwag requires a valid output type\n";
+    fprintf(stderr, e, min, max);
+    exit(EXIT_FAILURE);
+  }
+
+  if(type == CW_LETTERS) result = ltr_rng(min, max, dict);
+  else if(type == CW_WORDS) result = wrd_rng(min, max, dict);
+  else if(type == CW_SENTENCES) result = snt_rng(min, max, dict);
+  else if(type == CW_PARAGRAPHS) result = pgf_rng(min, max, dict);
+
+  return result;
+}
+
+char* ltr_rng(unsigned long min, unsigned long max, dict_t dict)
+{
+  dict_t temp = open_dict();
+  I32 amount = motherr(min,max), total = 0; U32 len = 0;
+  char* s = (char*)malloc(SMALL_BUFFER); char* sample = NULL; 
+  char* result = NULL; char* vowels = "aeiou";
+
+  while(amount > 0)
+  {
+    if(amount == 2)
+    {
+      // SSWS : modifies destination, can't modify source, new string
+      sample = sample_substring_with_size(vowels, 1);
+      s = strcpy(s, sample); free(sample);
+      len = 1; total += len;
+      s[len] = '\0';
+    }
+    else
+    {
+      s = strcpy(s, sample_dict(dict));
+      len = strlen(s); total += len; s[len] = '\0';
+      if(len > amount || include(s, " ") || include(s, "-")) continue;
+    }
+
+    amount -= len;
+
+    // postfixed alteration (append vowel chain/remove trailing character)
+    if(amount + 1 == 0)
+    {
+      // SWS : modifies destination, can't modify source, new string
+      sample = substring_with_size(s, 0, len - 2);
+      s = strcpy(s, sample); free(sample);
+      len -= 1; total -= 1; s[len] = '\0';
+
+      amount += 1;
+    }
+    else if(amount - 1 == 0)
+    {
+      // SSWS : modifies destination, can't modify source, new string
+      sample = sample_substring_with_size(vowels, 1);
+      s = add_suffix(s, sample); free(sample);
+      len += 1; total += 1; s[len] = '\0';
+
+      amount -= 1;
+    }
+    else if(amount - 2 == 0)
+    {
+      // SSWS : modifies destination, can't modify source, new string
+      sample = sample_substring_with_size(vowels, 2);
+      s = add_suffix(s, sample); free(sample);
+      len += 2; total += 2; s[len] = '\0';
+
+      amount -= 2;
+    }
+
+    temp = place_word_in_dict(temp, s);
+    if(amount > 0 && amount != 1) --amount;
+  }
+
+  // post-process dict (pass utility::capitalize function as parameter)
+  temp = prune_dict(temp, false);
+  temp = map_dict(temp, capitalize);
+  result = join_dict(temp, " ");
+
+  close_dict(temp);
+  free(s); s = NULL;
+
+  return result;
+}
+
+char* wrd_rng(unsigned long min, unsigned long max, dict_t dict)
+{
+  dict_t temp = open_dict();
+  U32 amount = motherr(min, max), total = total_dict(dict);
+  char* sample = NULL; char* result = NULL;
+  bool invalid = true;
+
+  // add words to dict
+  for(U32 i = 0; i != amount; ++i)
+  {
+    while(invalid)
+    {
+      sample = sample_dict(dict);
+
+      // valid if no space, hyphen, or duplicate (latter depends on size)
+      if(exclude(sample, " ") && exclude(sample, "-"))
+      {
+        if(amount > total) invalid = false;
+        else if(dict_exclude(temp, sample)) invalid = false;
+      }
+    }
+    
+    temp = place_word_in_dict(temp, sample);
+    invalid = true;
+  }
+
+  // post-process dict (pass utility::capitalize function as parameter)
+  temp = map_dict(temp, capitalize);
+  result = join_dict(temp, " ");
+
+  close_dict(temp);
+
+  return result;
+}
+
+char* snt_rng(unsigned long min, unsigned long max, dict_t dict)
+{
+  dict_t master = open_dict(), temp; drow_t selected;
+  U32 word_amount = 0, last = 0, amount = motherr(min, max), now = 0, 
+  len = 0, t_minus = 0; U8 comma = 0; I32 punct = 0;
+  U32* no_dice = (U32*)malloc(sizeof(U32) * SMALL_BUFFER);
+  char* sample = NULL; char* result = NULL; char* s = NULL;
+  bool invalid = true;
+
+  for(U32 i = 0; i != amount; ++i)
+  {
+    temp = open_dict();
+    word_amount = motherr(SENTENCE_MIN_WORD_LENGTH, 
+    SENTENCE_MAX_WORD_LENGTH);
+
+    if(word_amount >= 2) comma = (U8)motherr(0, 1);
+
+    // if comma, determine commma position after first word)
+    if(word_amount >= 2 && comma == 1) comma = motherr(1, word_amount - 1);
+
+    // determine sentence rhythm
+    for(U32 j = 0; j != word_amount; ++j)
+    {
+      if(j == 0) now = motherr(5, 10);
+      else if(j == word_amount - 1) now = motherr(3, 8);
+      else if(t_minus > 0) { now = motherr(1, 10); --t_minus; }
+      else if(last <= 10) now = motherr(1, dict.count - 1);
+      else if(last > 10 || last <= 2) { now = motherr(6, 10); t_minus = 3; }
+
+      selected = dict.drows[now];
+      sample = sample_drow(selected);
+
+      while(dict_include(temp, sample) && strlen(sample) != now)
+      { sample = sample_dict(dict); }
+
+      // add comma (if applicable)
+      if(comma && j == comma - 1)
+      {
+        // get local copy of sample for modification
+        len = strlen(sample);
+        s = (char*)malloc(strlen(sample) + 1);
+
+        strcpy(s, sample);
+        s[len] = '\0';
+
+        s = add_suffix(s, ",");
+        temp = place_word_in_dict(temp, s);
+
+        free(s);
+      }
+      else temp = place_word_in_dict(temp, sample);
+
+      invalid = true;
+      last = now;
+    }
+
+    // join temporary dict into a sentence; capitalize first word
+    s = join_dict(temp, " ");
+    s = capitalize(s);
+
+    // determine punctuation; 1 - period, 2 - question, 3 - exclamation
+    // based on a ratio of 64-21-15, sampled from Shakespeare's Hamlet
+    punct = (I32)motherr(0, 99);
+
+    if(punct >= 0 && punct <= 63) s = add_suffix(s, ".");
+    else if(punct >= 64 && punct <= 84) s = add_suffix(s, "?");
+    else if(punct >= 85 && punct <= 99) s = add_suffix(s, "!");
+
+    // add sentence to master dict and cleanup
+    master = place_word_in_dict(master, s);
+
+    close_dict(temp);
+    free(s);
+  }
+
+  result = join_dict(master, " ");
+  close_dict(master);
+  free(no_dice);
+
+  return result;
+}
+
+char* pgf_rng(unsigned long min, unsigned long max, dict_t dict)
+{
+  char* result = NULL; char* sentences = NULL;
+  U32 amount = motherr(min, max), sentence_amount = 0;
+  dict_t master = open_dict();
+
+  for(U32 i = 0; i != amount; ++i)
+  {
+    sentence_amount = motherr(PARAGRAPH_MIN_SENTENCE_LENGTH, 
+    PARAGRAPH_MAX_SENTENCE_LENGTH);
+
+    sentences = snt(sentence_amount, dict);
+    master = place_word_in_dict(master, sentences);
+
+    free(sentences);
+  }
+
+  result = join_dict(master, "\n\n");
+  close_dict(master);
+
+  return result;
+}

data/ext/chinwag/chinwag.h

@@ -0,0 +1,71 @@
+//
+//  chinwag.h
+//  Chinwag
+//
+//  Created by Chris Calo on 8/05/14.
+//  Copyright (c) 2014 Vulcan Creative, LLC. All rights reserved.
+//
+
+#ifndef __CHINWAG_AUGXMJP4_H
+#define __CHINWAG_AUGXMJP4_H
+
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <signal.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <sys/time.h>
+
+// output types
+enum {
+  CW_LETTERS      =   0,
+  CW_WORDS        =   1,
+  CW_SENTENCES    =   2,
+  CW_PARAGRAPHS   =   3,
+};
+typedef unsigned long cw_t;
+
+// internal dictionary row
+typedef struct dictionary_type {
+  bool sorted;
+  unsigned long count;
+  unsigned long largest;
+  unsigned long largest_pos;
+  char** words;
+} drow_t;
+
+// dictionary (row container)
+typedef struct dictionary_container_type {
+  bool sorted;
+  unsigned long count;
+  drow_t* drows;
+  char* name;
+} dict_t;
+
+#include "seuss.h"
+#include "latin.h"
+
+#include "ingredient.h"
+#include "generator.h"
+#include "tokenize.h"
+#include "utility.h"
+#include "config.h"
+#include "dict.h"
+
+char* chinwag(cw_t type, unsigned long min, unsigned long max, dict_t dict);
+
+#define ltr(amt, dict) ltr_rng(amt, amt, dict)
+#define wrd(amt, dict) wrd_rng(amt, amt, dict)
+#define snt(amt, dict) snt_rng(amt, amt, dict)
+#define pgf(amt, dict) pgf_rng(amt, amt, dict)
+
+char* ltr_rng(unsigned long min, unsigned long max, dict_t dict);
+char* wrd_rng(unsigned long min, unsigned long max, dict_t dict);
+char* snt_rng(unsigned long min, unsigned long max, dict_t dict);
+char* pgf_rng(unsigned long min, unsigned long max, dict_t dict);
+
+#endif

data/ext/chinwag/config.c

@@ -0,0 +1,28 @@
+#include "config.h"
+
+const unsigned MAJOR_VERSION = 1;
+const unsigned MINOR_VERSION = 1;
+const unsigned PATCH_VERSION = 4;
+
+const char* const DATE_YEAR = "2014";
+const char* const DATE_MONTH = "12";
+const char* const DATE_DAY = "02";
+const char* const REVISION = "743";
+
+const unsigned SMALL_BUFFER = 1024;
+const unsigned LARGE_BUFFER = 5120;
+
+const unsigned MIN_DICT_SIZE = 300;
+
+const char* const DELIMITERS = "\r\n,;:\034";
+
+const unsigned CW_DEFAULT = 1; // == WORDS
+
+const unsigned DEFAULT_MIN_OUTPUT_LENGTH = 1;
+const unsigned DEFAULT_MAX_OUTPUT_LENGTH = 5;
+
+const unsigned SENTENCE_MIN_WORD_LENGTH = 2;
+const unsigned SENTENCE_MAX_WORD_LENGTH = 25;
+
+const unsigned PARAGRAPH_MIN_SENTENCE_LENGTH = 4;
+const unsigned PARAGRAPH_MAX_SENTENCE_LENGTH = 6;

data/ext/chinwag/config.h

@@ -0,0 +1,42 @@
+#ifndef __CONFIG_6TCIIEDT_H
+#define __CONFIG_6TCIIEDT_H
+
+#include "chinwag.h"
+
+// data used for versioning information
+extern const unsigned MAJOR_VERSION;
+extern const unsigned MINOR_VERSION;
+extern const unsigned PATCH_VERSION;
+
+// data used for compilation information
+extern const char* const DATE_YEAR;
+extern const char* const DATE_MONTH;
+extern const char* const DATE_DAY;
+extern const char* const REVISION;
+
+// minimum and maximum fixed buffer sizes
+extern const unsigned SMALL_BUFFER;
+extern const unsigned LARGE_BUFFER;
+
+// minimum size allowed for dictionary tokens (more == better randomization)
+extern const unsigned MIN_DICT_SIZE;
+
+// individual characters used to deliminate dictionary tokens
+extern const char* const DELIMITERS;
+
+// default output type
+extern const unsigned CW_DEFAULT;
+
+// pre-defined default output caps (both must be unsigned integers)
+extern const unsigned DEFAULT_MIN_OUTPUT_LENGTH;
+extern const unsigned DEFAULT_MAX_OUTPUT_LENGTH;
+
+// pre-defined caps for determining randomized sentence lengths
+extern const unsigned SENTENCE_MIN_WORD_LENGTH;
+extern const unsigned SENTENCE_MAX_WORD_LENGTH;
+
+// pre-defined caps for determining randomized paragraph lengths
+extern const unsigned PARAGRAPH_MIN_SENTENCE_LENGTH;
+extern const unsigned PARAGRAPH_MAX_SENTENCE_LENGTH;
+
+#endif