displayText = function() {
// DEBUGGING console.log("displayText");
if (unusedWords[0].length > 0) {
//random index of unusedWords
let index = getRandomInt(0, unusedWords[0].length);
//word to replace chosen from list of unused words
let wordToReplace = unusedWords[0][index];
//generate gibberish based off word to replace
let gibberish = generateGibberish(wordToReplace);
//Dictionary[wordToReplace] = gibberish;
//adding user input & gibberish to Dictionary object:
if (textInput !== "") {
let text = textInput;
Dictionary.set(wordToReplace, {
gibberishWord: gibberish,
userSynonym: text
});
}
//For removing highlighting, if I manage to add it in becomeGibberish:
// mutableTxt[0] = mutableTxt[0].replace("<mark>", "");
// mutableTxt[0] = mutableTxt[0].replace("</mark>", "");
mutable txt = becomeGibberish(
// The following does not treat things like "<" as tokens: --why does tokenize make "<" into tokens but not split?
// ANSWER tokenize is designed and written to do this specially:
// to tokenize means to divide a string up in to its atomic meaningful units (as defined by the routine)
// split just works on strings and just does what it says it will
// This splits txt on a space or a line-ending (\n) using a regex pattern between //
txt.split(/[ \n]/),
// RiTa.tokenize(mutableTxt[0]),
wordToReplace,
gibberish
// putting a dot and this method at the end of becomeGibberish replaces line-endings with <br>
)//.replaceAll("\n", "<br>"); //word to gibberish
unusedWords[0].splice(index, 1); //removed the replaced word from the list of unused words
display2.innerText = "‘" + gibberish + "’ means:";
} else {
display2.innerText = "Done.";
//pause a couple second
//button appears on screen with "Write a poem?" on it
//-->pressing the button causes the current display to fade out and me replaced by the new poem appearring word by shifting word on screen
}
//}
}
mutable txt = testpoem.innerHTML
txt.split(/[ \n]/)
// document.addEventListener('keydown', displayText);
/* document.addEventListener('keydown', e => {
console.log(`${e.key} pressed`); // for DEBUGGING ONLY
e.stopPropagation();
if (e.key == "Enter") {
e.key = "";
displayText();
}
})*/
/*update = function(lPoem) {
let words = RiTa.tokenize(mutableTxt[0]); // split into words
// loop a random number of times: 1 - numberOfPossibleReplacements
//loop from random spot
let r = Math.floor(Math.random() * words.length);
//for (let i = r; i < words.length + r; i++) {
//let idx = i % words.length;
let idx = r % words.length;
words[idx] = randomWord(lPoem[idx], words[idx]);
//}
return RiTa.untokenize(words);
// mutable txt = RiTa.untokenize(words); // actually even with await Promises ... this does not work
// mutableTxt[0] = RiTa.untokenize(words); // this would also work
}*/
/*viewof buttonWithValue = Button("Reset", {
reduce: functionRunOnClick
})*/
/*functionRunOnClick = function() {
mutableTxt[0] = unmutableTxt [0];
unusedWords[0] = [generateUnusedWords(unmutableTxt[0])];
display1.reload();
display2.reload();
}*/
/*functionRunOnClick = function() {
mutableTxt[0] = unmutableTxt[0];
unusedWords[0] = [generateUnusedWords(unmutableTxt[0])];
display1.innerHTML = mutableTxt[0].replace(/-g/g, " \n");
display2.innerText = 'Press Enter:';
}*/
md`How highlighting works:`
md`${'<mark>"hello"</mark>'}`
html`<mark>"hello"</mark>`
md`<mark>hello</mark>`
x = "cat."
y = x.includes(".")
x.replace(".", "")
//choosing random word in poem to turn into Gibberish
function becomeGibberish(poem, wordToReplace, gibberish) {
//words = string of poem
for (let ii = 0; ii < poem.length; ii++) {
// bug was ABOVE: ii <= poem.length is wrong:
// array indexes are 0 thru .length-1 but .length *is* the number of elements:
// last index+1 doesn't exist, i.e. is "undefined"
//loop through all elements of words(mutableTxt)
// THIS IS THE FIX for not dealing with word at the end of lines
// (difference fix as compared to the words at beginning problem)
// This still doesn't deal with puntuation [,.?! etc.]
// but you can figure out how to do that ;)
let br = false;
let gibWord = gibberish;
let word = poem[ii];
// looking for "<br>"
let brIndex = word.indexOf("<br>");
if (brIndex != -1) {
word = poem[ii].substr(0, brIndex);
br = true;
}
//remove punctuation
if (word.includes(".")){
gibWord += ".";
word = word.replace(".", "");
}
if (word.includes(",")){
gibWord += ",";
word = word.replace(",", "");
}
if (word.toLowerCase() == wordToReplace) {
//if the element contains the random unused word
if (/[A-Z]/.test(poem[ii][0])) {
word = "<mark>" + RiTa.capitalize(gibWord) + "</mark>"; // keep capitals
} else {
word = "<mark>" + gibWord + "</mark>"; //["<mark>", gibberish, "</mark>"]; //replace the element with gibberish //md`<mark> gibberish </mark>` //supposed to highlight but won't work
}
poem[ii] = word;
if (br) poem[ii] += "<br>";
}
// let newPoem = RiTa.untokenize(poem);
}
return poem.join(" ");
}
md`Test: ${becomeGibberish("very short poem".split(" "), "short", testShort)}`
testShort = generateGibberish("short")
RiTa.tokenize("very short poem")[0].toLowerCase()
//Creating new Gibberish Words based of number of syllabels in input word
function generateGibberish(oWord){
let syllables = RiTa.syllables(oWord);
let syllablesArray = syllables.split('/');
var numSyllables = syllablesArray.length;
var gibberish = "";
var notOneVowel = (oWord.length > 1 && numSyllables == 1);
//stuff about contractions
/*if has Prefix
if ending of prefix = vowel --> start root word with consonant
else --> start root word with vowel
if has suffix
if beginning of suffix = vowel --> end root word with consonant
else --> end root word with vowel
*/
let rand = Math.random();
//What word starts with
if (rand <0.3){
var startVowel = true;
} else {
var startVowel = false;
}
for (let j = 0; j < numSyllables; j++){ //loop for number of syllables
//Syllable starts w/ Vowels
if (startVowel == true) {
gibberish += createVowel(notOneVowel);
}
else {
gibberish += createConsonant();
}
if(consonants.indexOf(gibberish.slice(-1)) > 0){
startVowel = true;
}
else{
startVowel = false;
}
}
//if gibberish == real word --> create new gibberish word
return gibberish;
}
//Create a single syllable starting with a vowel:
function createVowel(notOneVowel){
let newVowel = vowels[getRandomInt(0, vowels.length)]; //random starting vowel
let numLetters = getRandomInt(1, 3); //generate random number for either 1 or 2 letter syllable
if (notOneVowel === true){
numLetters = 2;//if one syllable word with more than 1 letter
} //don't allow gibberish to be 1 vowel
if (numLetters > 1){ //if syllable has more than 1 letter
newVowel += consonants[getRandomInt(0, consonants.length)]; //add a random consonant
}
return newVowel;
}
//Create a single syllable starting with a consonant
function createConsonant(){
let newConsonant = consonants[getRandomInt(0, consonants.length)] + vowels[getRandomInt(0, vowels.length)]; //random starting consonant and random addition vowel
let numLetters = getRandomInt(2, 4); // random length 2-3
if(numLetters > 2){ //if syllable 3 letters
newConsonant += consonants[getRandomInt(0, consonants.length)]; //add consonant
}
return newConsonant;
}
function findSuffix(word){
//find suffix from array of prefixes
//group word with other words
//remove syllables from oWord
}
function findPrefix(word){
//find prefix from array of prefixes
//group word with other words
//remove syllables from oWord
}
//This is broken I need to refine the coding later
function findRootWords(poem){
let roots = [];
for(let ii = 0; ii < poem.length; ii++){ //for every word in the poem
let rootWord = poem[ii];
let thisPrefix = [];
let thisSuffix = [];
//is there a prefix? --> remove it
for (let jj = 0; jj < prefixes.length; jj++){
if(rootWord.startsWith(prefixes[jj])){
thisPrefix.push(prefixes[jj]);
rootWord = rootWord.replace(prefixes[jj],"");
}
}
//is there a suffix --> remove it
for (let jj = 0; jj < suffixes.length; jj++){
if(rootWord.endsWith(suffixes[jj])){
thisSuffix.push(suffixes[jj]);
rootWord = rootWord.replace(suffixes[jj],"");
}
}
//add to broken down word into a list of objects of root words, prefixes, and suffixes --> when generating gibberish can keep track of letter start and end requirements
roots.push({root: rootWord, prefix: thisPrefix, suffix: thisSuffix});
}
return roots;
}
/*From paragraph that evolves:
if (next.includes(word) || word.includes(next)) {
continue; // skip substrings
}*/
function createPrefixes(prefixList){
let newPrefixList = [];
for(let ii = 0; ii < prefixList.length; ii++){
newPrefixList[ii] = generateGibberish(prefixList[ii]);
}
return newPrefixList;
}
function createSuffixes(suffixList){
let newSuffixList = [];
for(let ii = 0; ii < suffixList.length; ii++){
suffixList[ii] = generateGibberish(suffixList[ii]);
}
return newSuffixList;
}
//Generate an array of all words in an Array[0], with all repeated words removed
function generateUnusedWords(poem){
let words = poem.toLowerCase();
words = RiTa.tokenize(words);
//remove punctuation and -g(line break symbol)
let i = 0;
while(i < words.length){
if (words[i] == "." || words[i] == "," || words[i] == "-g"){
words.splice(i, 1);
}
else {
++i;
}
}
return [...new Set(words)];
}
//in future need to alter to account for prefixes and suffixes
/*From paragraph that evolves:
if (next.includes(word) || word.includes(next)) {
continue; // skip substrings
}*/
function generateWordArrays(thePoem){
let fullPoem = [];
let words1 = RiTa.untokenize(thePoem);
let words2 = translatePoem("originalWord", "gibberishWord", thePoem);
let words3 = translatePoem("gibberishWord", "userSynonym", thePoem);
for(let ii = 0; ii < words1.length; ii++){
fullPoem[ii] = Array(words1[ii], words2[ii], words3[ii]);
}
return fullPoem; //output = array of lists of strings
}
function translatePoem(fromWhat, toWhat, thePoem) {
RiTa.tokenize(thePoem[0]);
let newPoem = thePoem;
for (let i=0; i < thePoem.length; i++){
for (let j=0; j < Dictionary.length; j++){
if (Dictionary[j].fromWhat === thePoem[i]){
newPoem[j] = Dictionary[j].toWhat;
}
}
}
return newPoem; //output array of strings
}
function randomWord(wordArray, currentWord) {
// only works with flat arrays of words
let safetyCounter = 0,
word;
do {
word = wordArray[getRandomInt(wordArray.length)];
} while (
currentWord != undefined &&
word == currentWord &&
safetyCounter++ < 100
);
return word;
}
function gibPoem(oPoem){
let nPoem = oPoem;
for(let ii = 0; ii < oPoem.length; ii++){
if(oPoem[ii] == "-g"){
nPoem[ii] = "-g";
}
else{
nPoem[ii] = generateGibberish(oPoem[ii]);
}
}
return nPoem;
}
Dictionary = new Map();
rootWords = [findRootWords(unmutableUnusedWords[0])];
testing2 = findRootWords(["undone", "done", "ouch"]);
testing = generateUnusedWords(unmutableTxt[0])
display2 = md`Click ‘Gibberfy’`
prefixes = ["un", "pre", "in"/*this one may be tough*/, "con"]; //need to add more
suffixes = ["ing", "ish", "less", "ee", "ence", "ful" ]; // also need to add more
gibberishPrefixes = [createPrefixes(prefixes)]
gibberishSuffixes = [createSuffixes(suffixes)];
h = "texting"
function fun(){
let h = "testing";
let e = suffixes[0];
return h.replace(e, "");
}
fun();
function p(){
return suffixes[0];
}
p();
import { Button, Text } from "@observablehq/inputs"
Purpose-built for displays of data
Observable is your go-to platform for exploring data and creating expressive data visualizations. Use reactive JavaScript notebooks for prototyping and a collaborative canvas for visual data exploration and dashboard creation.
