diff options
Diffstat (limited to 'RGens/src/main')
11 files changed, 1788 insertions, 25 deletions
diff --git a/RGens/src/main/java/bjc/RGens/parser/RBGrammarReader.java b/RGens/src/main/java/bjc/RGens/parser/RBGrammarReader.java index 48e21b1..bf3a40c 100644 --- a/RGens/src/main/java/bjc/RGens/parser/RBGrammarReader.java +++ b/RGens/src/main/java/bjc/RGens/parser/RBGrammarReader.java @@ -158,7 +158,7 @@ public class RBGrammarReader { actualName.deleteCharAt(actualName.length() - 1); actualName.append("]"); - retList = gram.generateGenericValues(actualName.toString(), (s) -> s, " "); + retList = gramm.generateGenericValues(actualName.toString(), (s) -> s, " "); } else { // @FIXME notify the user they did something wrong retList.add(strang); @@ -168,11 +168,7 @@ public class RBGrammarReader { return retList; }; - Runnable specialReset = () -> { - vars.clear(); - }; - - gram.configureSpecial(specialPredicate, specialAction, specialReset); + gram.configureSpecial(specialPredicate, specialAction); return gram; } catch (IOException ioex) { diff --git a/RGens/src/main/java/bjc/RGens/parser/ReaderState.java b/RGens/src/main/java/bjc/RGens/parser/ReaderState.java index 8e846cf..14d7ff8 100644 --- a/RGens/src/main/java/bjc/RGens/parser/ReaderState.java +++ b/RGens/src/main/java/bjc/RGens/parser/ReaderState.java @@ -150,6 +150,8 @@ public class ReaderState { */ public void startNewRule(String ruleName) { currentGrammar.addRule(ruleName); + + currentRule = ruleName; } /** diff --git a/RGens/src/main/java/bjc/RGens/parser/sample-grammars/24hr-rpg.gram b/RGens/src/main/java/bjc/RGens/parser/sample-grammars/24hr-rpg.gram index 7c4eadf..344d9a8 100755 --- a/RGens/src/main/java/bjc/RGens/parser/sample-grammars/24hr-rpg.gram +++ b/RGens/src/main/java/bjc/RGens/parser/sample-grammars/24hr-rpg.gram @@ -1,6 +1,6 @@ -[rpg] [rpg-part] , [rpg-part] and <rpg-part> - [rpg-part] and <rpg-part> - [rpg-part] the <rpg-part> +[rpg] [rpg-part] , [rpg-part] and [rpg-part] + [rpg-part] and [rpg-part] + [rpg-part] the [rpg-part] pragma initial-rule [rpg] @@ -201,5 +201,4 @@ pragma initial-rule [rpg] skies madness economy - the 60s - + the 60s diff --git a/RGens/src/main/java/bjc/RGens/parser/sample-grammars/anime.gram b/RGens/src/main/java/bjc/RGens/parser/sample-grammars/anime.gram index 1a695c8..0cc21d8 100755 --- a/RGens/src/main/java/bjc/RGens/parser/sample-grammars/anime.gram +++ b/RGens/src/main/java/bjc/RGens/parser/sample-grammars/anime.gram @@ -1,19 +1,20 @@ -[initial-name] [two-name] - [three-name] +[anime-name] [anime-two-name] + [anime-three-name] -pragma initial-rule [name] +pragma initial-rule [anime-name] +pragma export-rule [anime-name] -[two-name] [first-name] [third-name] - [second-name] [third-name] +[anime-two-name] [anime-first-name] [anime-third-name] + [anime-second-name] [anime-third-name] -[name] [first-name] [first-name] - [first-name] [second-name] - [second-name] [first-name] - [second-name] [second-name] +[anime-three-name] [anime-first-name] [anime-first-name] + [anime-first-name] [anime-second-name] + [anime-second-name] [anime-first-name] + [anime-second-name] [anime-second-name] -pragma suffix-with [name] [third-name] +pragma suffix-with [anime-name] [anime-third-name] -[first-name] Vampire +[anime-first-name] Vampire Cat Death Mermaid @@ -40,7 +41,7 @@ pragma suffix-with [name] [third-name] Lucid Space -[second-name] Princess +[anime-second-name] Princess Planet Blade Bride @@ -68,7 +69,7 @@ pragma suffix-with [name] [third-name] Blackout Phantom -[third-name] Forever +[anime-third-name] Forever Detectives Memories Outlaw diff --git a/RGens/src/main/java/bjc/RGens/parser/sample-grammars/college.gram b/RGens/src/main/java/bjc/RGens/parser/sample-grammars/college.gram new file mode 100644 index 0000000..f1bee8e --- /dev/null +++ b/RGens/src/main/java/bjc/RGens/parser/sample-grammars/college.gram @@ -0,0 +1,515 @@ +[college-announcement] next [course-time] , [university] will offer ' [college-course] ' + the [university] class ' [college-course] ' has been cancelled due to lack of interest + starting next year, incoming freshmen at [university] will be required to take ' [college-course] ' + ' [college-course] ' will no longer be offered at [university] due to lack of interest + ' [college-course] ' is the most popular [course-level] class at [university] + due to overwhelming popularity, an additional section of ' [college-course] ' will be offered at [university] next semester + not one single student signed up for [university] 's ' [college-course ' last semester + a [poll] of students at [university] revealed ' [college-course] ' is the [popular] popular [class-type] offered + +pragma initial-rule [college-announcement] + +[course-time] fall + year + semester + +[course-level] graduate + undergraduate + freshmen + liberal arts + +[poll] poll + survey + +[popular] least + most + +[class-type] class + course + +pragma range-rule [past-years] 1800 1970 + +[college-course] [course-adj] [course-noun] [course-suffix] + [course-adj] [course-noun] : [course-ending] + [course-adj] [course-noun] and [course-adj] [course-noun] [course-suffix] + [course-noun] and [course-noun] [course-suffix] + [course-group1] [course-group2] [course-life] [course-suffix] + [course-group2] [course-noun] [course-life] [course-suffix] + [course-group1] [course-group2] [course-life] since [past-years] + [course-group2] [course-life] : [course-ending] + contemporary [course-group2] [course-life] and [course-life] + contemporary [course-group2] [course-life] : [course-ending] + transforming the [course-group1] [course-group2] experience + [course-prefix] [course-group1] [course-group2] [course-life] + [course-prefix] [course-group2] [course-life] [course-suffix] + [course-prefix] [course-adj] [course-noun] [course-suffix] + [course-prefix] the [course-group1] [course-group2] [course-movement] [course-suffix] + [course-adj] [course-life] : [course-ending] + [course-adj] [course-noun] in modern [course-medium] + [course-noun] [course-suffix] : [course-ending] + [course-prefix] [course-noun] and [course-noun] [course-suffix] + the [course-adj] dimension of [course-group1] [course-group2] [course-medium] + [course-prefix] [course-topic] in [course-group2] [course-medium] : [course-ending] + [course-topic] and [course-topic] [course-suffix] + [course-group2] [course-medium] interpretation: [course-ending] + [course-group2] [course-medium] as a [course-adj] genre + [course-prefix] [course-group1] [course-group2] [course-medium] + [course-life] of [course-group2] [course-noun] : [course-ending] + [course-prefix] [course-popculture] : [course-ending] + [course-popculture] [course-suffix] : [course-ending] + [course-prefix] [course-adj] [course-noun] and [theory] + [course-prefix] [course-action] : [course-ending] + [course-action] [course-suffix] : [course-ending] + [course-prefix] [course-nounprefix] [course-ancient] [course-medium] : [course-ending] + ethnicity [course-suffix] : the [course-group1] [course-group2] [condition] + masterpieces of [course-group1] [course-group2] [course-medium] + [course-buzzword2] , [course-buzzword2] and [course-buzzword2] [course-suffix] : [course-ending] + [course-buzzword2] , [course-buzzword2] and [course-buzzword2] in [course-group2] [course-medium] : [course-ending] + [course-prefix] [course-event] : [course-ending] + [course-event] as [course-explored] in [course-group1] [course-group2] [course-medium] + [university-subject] as [course-explored] in [course-group1] [course-group2] [course-medium] + [course-impactof] : [course-ending] + [course-static] + [course-static] + +[condition] condition + experience + +[course-static] [course-env1] : [course-prefix] [course-env2] + [course-prefix] [course-env3] : policy [course-suffix] + the meaning of life as [course-explored] in [course-group1] [course-group2] [course-medium] + the [course-impact] of [course-group2] [thinker-type] on [course-contemporary] [university-subject] : [course-ending] + the [rise] of [course-group2] [thinker-type] in [course-contemporary] [university-subject] : [course-ending] + [course-ancient] [course-medium] as the [roots] of [course-contemporary] [university-subject]] + [course-buzzword2] , [course-buzzword2] and [course-buzzword2] as [course-explored] in [course-contemporary] [films] : [course-ending] + the history of [course-group2] [course-life] : [course-ending] + the [archetype] of the [quest] in [course-group1] [course-group2] [course-medium] + [cross-cultural] [studies] [course-group2] [course-life] + +[course-event] the african diaspora + the harlem renaissance + the civil rights movement + the italian renaissance + westward expansion + manifest destiny + women's suffrage + world war I + world war II + the war of 1812 + the american revolution + the french revolution + the russian revolution + the american civil war + the franco-prussian war + the jfk assasination + +[thinker-type] researchers + thinkers + scientists + +[rise] rise + emergence + success + empowerment + +[roots] roots + foundations + +[films] film + fiction + television + cinema + theater + +[archetype] archetype + symbolism + +[quest] quest paradigm + journey + awakening + rite of passage + +[cross-cultural] cross-cultural + multi-ethnic + +[studies] studies in + perspectives on +[course-env1] saving the world + the end of the word + the sky is falling + here come the mass extinctions + +[course-env2] modern enviromentalism + enviromental biology + enviromental activism + +[course-env3] the greenhouse effect + planetwide climatic change + global warning + +[course-action] basketweaving + aquatic ballet + synchronized swimming + professional sports + the [course-adj] pottery experience + home economics + cardplaying + [sportship] + the culinary [experience] + +[sportship] sportspersonship + sportsmanship + +[experience] arts + experience + +[course-noun] diversity + globalism + equality + feminism + sexuality + self-actualization + political correctness + enviromentalism + marxism + socialsm + communism + darwinism + activism + queer theory + [course-nounprefix] romanticism + [course-nounprefix] dadaism + [course-nounprefix] cubism + [course-nounprefix] realism + paganism + homosexuality + sexuality + evolution + poverty + fundamentalism + intellectualism + multiculturalism + +[course-nounprefix] post- + pre- + early + classical + +[course-adj] progressive + liberal + liberal + aesthetic + postmodern + feminist + radical + populist + humanist + reformist + liberated + +[course-prefix] ad-hoc investigation of + ad-hoc investigation of + the potential of + foundations of + literature of + the history of + principles of + exploration of + philosophy of + psychology of + meta-physics of + dynamic exploration of + symbolism of + topics in + advanced topics in + selected topics in + special topics in + survey of + the universe of + the meaning of + theories of + perspectives in + topics in + special studies in + introduction to + research capstone in + quantitative methods in + colloquium in + senior seminar in + critical perspectives in + brief survey of + concepts in + the highlights of + +[course-suffix] in the postmodern era + in the postmodern world + in the modern adge + in modern society + in modern america + in today's society + in the american landscape + in the united states + in the 21st century + in recent times + in the real world + in the [college-adj] world + +[course-ending] ideas in conflict + ideas in transition + critical issues facing the [course-contemporary] [course-person] + a process approach + [course-buzzword] , [course-buzzword] and [course-buzzword] + a [course-metaphor] of [course-noun] [course-suffix] + a [course-metaphor] of [course-ancient] [course-suffix] + a [course-metaphor] [course-explored] in american [course-medium] + a [course-metaphor] [course-explored] in [course-contemporary] [course-medium] + what is to be learned from it? + an interdisciplinary [study] + from [last-name] to [last-name] + [theory] at work + policy [course-suffix] + different points of view + [course-buzzword] and [course-buzzword] + the big picture + a paradigm shift + [modern] [theories] + myth and reality + the untold story + [journey] [discovery] + +[modern] modern + contemporary + +[theories] ideas + theories + +[journey] a journey of + a quest for + an odyssey of + +[discovery] discovery + exploration + thought + self-actualization + +[study] study + approach + +[course-group1] gay and lesbian + homosexual + bisexual + transgender + inner city + rural + suburban + urban + southern + western + eastern + liberated + upper class + middle class + [course-adj] + +[course-group2] african-american + hispanic + european + latino + native american + pacific islander + australian + latvian + elbonian + italian + african + american + asian + chinese + japanese + french + german + russian + middle eastern + scandinavian + mexican + female + female + female + neo-pagan + atheist + polytheistic + minority + multi-ethnic + +[course-ancient] roman + etruscan + greek + byzantine + mayan + incan + aztec + viking + bablyonian + egyptian + sumerian + hittite + renaissance + chinese + native american + +[course-life] life + literature + music + art + issues + perspectives + lifestyles + thought + ethics + values + landscapes + culture + society + images + ideas + endeavors + expression + affairs + morals + retrospectives + symbols + religion + traditions + civilization + +[course-metaphor] metaphor + study + presentation + collage + figure + symbol + +[course-explored] explored + expressed + analyzed + interpreted + seen + +[course-person] individual + american + person + citizen + student + well-rounded person + woman + minority + liberal + +[course-buzzword] understanding + understanding + analysis + synthesis + synergy + practice + the human condition + development + cross-cultural awareness + cross-cultural perspectives + evaluation + interpretation + abstraction + decision-making + perspectives + context + paradigms + critical thinking + relationships + discovery + empowerment + +[course-buzzword2] race + class + status + gender + age + sex + work + family + community + culture + politics + struggle + conflict + +[course-movement] movement + revolution + evolution + transformation + metamorphosis + campaign + +[course-medium] art + paintings + literature + folklore + mythology + poetry + sculptures + music + architecture + dance + drama + +[course-topic] sex + death + suicide + trauma + drama + life + mythology + crime + love + hate + anger + passion + infidelity + horror + +[course-popculture] 'star wars' + 'star trek' + cyberpunk literature + harlequin romances + 'the simpsons' + 'the x-files' + daytime soap operas + radio talk shows + shakespeare's [comedy] + 'the scarlet letter; + 'seinfeld' + classic american literature + classic [course-ancient] [literature] + political cartoons + pornography + 'the jerry springer show' + +[comedy] comedies + tragedies + +[literature] literature + art + +[course-contemporary] contemporary + modern + 21st century + 20th century + +[course-impactof] the [course-impact] of [course-ancient] [course-medium] on [course-group1] [course-group2] [course-medium] [course-suffix] + the [course-impact] of [course-ancient] [course-medium] on [course-contemporary] [university-subject] + the [course-impact] of [course-ancient] [course-medium] on [course-contemporary] [course-adj] [course-noun] + the [course-impact] of [course-group1] [course-group2] [course-medium] on [course-contemporary] [course-adj] [course-noun] + the [course-impact] of [course-group1] [course-group2] [course-medim] on [university-subject] + +[course-impact] impact + effect + consequences + influence diff --git a/RGens/src/main/java/bjc/RGens/parser/sample-grammars/dungeon-enviroment.gram b/RGens/src/main/java/bjc/RGens/parser/sample-grammars/dungeon-enviroment.gram index 6ac9858..f521125 100755 --- a/RGens/src/main/java/bjc/RGens/parser/sample-grammars/dungeon-enviroment.gram +++ b/RGens/src/main/java/bjc/RGens/parser/sample-grammars/dungeon-enviroment.gram @@ -137,4 +137,4 @@ pragma initial-rule [enviroment] an interrogatin room with a table and chair an empty classroom a room whose ceiling is a giant human - aa room that is constantly swaying + a room that is constantly swaying diff --git a/RGens/src/main/java/bjc/RGens/parser/sample-grammars/insults.gram b/RGens/src/main/java/bjc/RGens/parser/sample-grammars/insults.gram new file mode 100644 index 0000000..1b3881b --- /dev/null +++ b/RGens/src/main/java/bjc/RGens/parser/sample-grammars/insults.gram @@ -0,0 +1,156 @@ +[insult] Thou [insult-1] [insult2] [insult3]! + +pragma initial-rule [insult] + +[insult-1] artless + bawdy + beslubbering + bootless + churlish + cockered + clouted + craven + currish + dankish + dissembling + droning + errant + fawning + fobbing + froward + frothy + gleeking + goatish + gorbellied + impertinent + infectious + jarring + loggerheaded + lumpish + mammering + mangled + mewling + paunchy + pribbling + puking + puny + qualling + rank + reeky + roguish + ruttish + saucy + spleeny + spongy + surly + tottering + unmuzzled + vain + venomed + villainous + warped + wayward + weedy + yeasty + +[insult-2] base-court + bat-fowling + beef-witted + beetle-headed + boil-brained + clapper-clawed + clay-brained + common-kissing + crook-pated + dismal-dreaming + dizzy-eyed + doghearted + dread-bolted + earth-vexing + elf-skinned + fat-kidneyed + fen-sucked + flap-mouthed + fly-bitten + folly-fallen + fool-born + full-gorged + guts-griping + half-faced + hasty-witted + hedge-born + hell-hated + idle-headed + ill-breeding + ill-nurtured + knotty-pated + milk-livered + motley-minded + onion-eyed + plume-plucked + pottle-deep + pox-marked + reeling-ripe + rough-hewn + rude-growing + rump-fed + shard-borne + sheep-biting + spur-galled + swag-bellied + tardy-gaited + tickle-brained + toad-spotted + unchin-snouted + weather-bitten + +[insults-3] apple-john + baggage + barnacle + bladder + boar-pig + bugbear + bum-bailey + canker-blossom + clack-dish + clotpole + coxcomb + codpiece + death-token + dewberry + flap-dragon + flax-wench + flirt-gill + foot-licker + fustilarian + giglet + gudgeon + haggard + harpy + hedge-pig + horn-beast + hugger-mugger + joithead + lewdster + lout + maggot-pie + malt-worm + mammet + measle + minnow + miscreant + moldwarp + mumble-news + nut-hook + pigeon-egg + pignut + puttock + pumpion + ratsbane + scut + skainsmate + strumpet + varlet + vassal + whey-face + wagtail diff --git a/RGens/src/main/java/bjc/RGens/parser/sample-grammars/mission.gram b/RGens/src/main/java/bjc/RGens/parser/sample-grammars/mission.gram new file mode 100644 index 0000000..9dce28a --- /dev/null +++ b/RGens/src/main/java/bjc/RGens/parser/sample-grammars/mission.gram @@ -0,0 +1,461 @@ +[mission-statement] [opening] [work-phrase] [verb-part] [noun-part] + [opening] [work-phrase2] [verb-part2] [noun-part] + [opening] [verb-part] [noun-part] + [opening] [work-phrase] [verb-part] [noun-part] and [verb-part] [noun-part] + [opening] [work-phrase2] [verb-part2] [noun-part] and [verb-part2] [noun-part] + [opening] [verb-part] [noun-part] and [noun-part] + [opening] [work-phrase] [verb-part] [noun-part] [connector] [goal] + [opening] [work-phrase2] [verb-part2] [noun-part] [connector] [goal] + [opening] [verb-part] [noun-part] [connector] [goal] + [opening] [work-phrase] [verb-part] [noun-part] [connector] [goal] and [goal] + [opening] [work-phrase2] [verb-part2] [noun-part] [connector] [goal] and [goal] + [opening] [verb-part] [noun-part] [connector] [goal] and [goal] + [opening] [work-phrase] [verb-part] [noun-part] and [verb-part] [noun-part] [connector] [goal] + [opening] [work-phrase2] [verb-part2] [noun-part] and [verb-part2] [noun-part] [connector] [goal] + [opening] [verb-part] [noun-part] and [noun-part] [connector] [goal] + [opening] [verb-part] [noun-part], [noun-part] and [noun-part] [connector] [goal] + [opening] [work-phrase] [verb-part] [noun-part] [connector] [verb-part] [noun-part] [connector] [goal] + [opening] [work-phrase2] [verb-part2] [noun-part] [connector] [verb-part] [noun-part] [connector] [goal] + [opening] [verb-part] [noun-part] [connector] [verb-part] [noun-part] [connector] [goal] + +pragma initial-rule [mission-statement] + +[verb-part] [verb-how] [verb] + [verb] + +[verb-part2] [verb-how] [verb-gerund] + [verb-gerund] + +[noun-part] our [adjective] [noun] + our [noun] + our [noun-prefix] [noun] + [adjective] [noun-prefix] [noun] + [adjective] [noun] + [noun] + +[opening] it's our [duty] to + it is our [duty] to + it is our [mission] to + it's our [mission] to + our [mission] is to + our [duty] is + we are committed to + we have committed to + we + we resolve to + +[duty] duty + responsibility + obligation + +[mission] mission + task + goal + job + business + function + +[verb] aggregate + deliver + deploy + embrace + empower + enable + engage + engineer + enhance + envision + extend + facilitate + generate + harness + implement + innovate + integrate + leverage + maximize + optimize + reinvent + revolutionize + simplify + spearhead + strategize + streamline + syndicate + synergize + synthesize + transform + unleash + utilize + visualize + +[verb-gerund] aggregating + delivering + deploying + embracing + empowering + enabling + engaging + engineering + enhancing + envisioning + extending + facilitating + generating + harnessing + implementing + innovating + integrating + leveraging + maximizing + optimizing + reinventing + revolutionizing + simplifying + spearheading + strategizing + streamlining + syndicating + synergizing + synthesizing + transforming + unleashing + utilizing + visualizing + +[verb-how] dramatically + practically + conveniently + efficiently + productively + rapidly + enthusiastically + completely + competently + assertively + quickly + intelligently + endlessly + tirelessly + effectively + skillfully + proficiently + professionally + swiftly + energetically + vigorously + zealously + briskly + speedily + shrewdly + cleverly + sharply + astutely + successfully + expertly + +[work-phrase] strive to + work to + endeavor to + continue to + execute a strategic plan to + +[work-phrase2] strive towards + work towards + endeavor towards + continue towards + make progress towards + make strides towards + take steps towards + achieve progress in + engage in + execute a strategic plan involving + +[noun] action items + architectures + assets + bandwidth + channels + communities + content + deliverables + eyeballs + face time + functionalities + infomediaries + infrastructures + initiatives + interfaces + key players + leadership skills + markets + metrics + middleware + mindshare + perspectives + networks + niches + paradigms + partnerships + platforms + portals + relationship corridors + relationships + synergies + schemas + skill sets + solutions + strategic alliances + supply-chains + synergies + technologies + total quality management + version control + vision + catalysts for [noun] + +[noun-prefix] sub- + meta- + mega- + e- + E- + cyber- + Net- + +[adjective] best-of-breed + bilateral + bleeding-edge + client-centered + cross-platform + cross-media + customer-centric + cutting-edge + distributed + dot-com + dynamic + effective + efficient + effort-intensive + enterprise + evolutionary + extensible + forward-thinking + frictionless + future-proof + global + granular + hyperlinked + idiot-proof + innovative + integrated + interactive + intuitive + killer + leading-edge + legacy + massively-parallel + mission-critical + multilevel + next-generation + object-oriented + open-source + proactive + progressive + real-time + revolutionary + robust + scalable + seamless + strategic + synergistic + transparent + turn-key + two-tier + ubiquitous + user-centric + value-added + vertical + viral + virtual + visionary + wireless + world-class + +[connector] so that we may + in order to + as part of our master plan to + as part of a larger strategy to + to + to + in order that we may + to allow us to + to enable us to + to permit us to + so that hopefully we may + as part of our five-year plan to + as part of our business plan to + as a component of our plan to + as the first step in our scheme to + +[goal] [make] a lot of [money] + produce [profit] for our [shareholders] + produce more [profit] for our [shareholders] + [increase] [profit] for our [shareholders] + better serve our customers + better serve our [shareholders] + better serve the [world] + [increase] our [bottom-line] + get out of debt + prevent bankruptcy + stay competitive for [todays] [world] + remain profitable in [todays] [world] + [set-us-apart] [competition] + [defeat] [competition] + [increase] customer satisfaction + create a [better] [product] + market a [lesser] [product] + produce a [better] [product] that kicks [competition] 's [butt] + market a [lesser] [product] that [make] s us a lot of [money] + exceed customer [demands] + meet the [demands] of our valued customers + meet the [demands] of the [world] + successfully market an overhyped [lesser] [product] + take over the [world] + dominate the [world] + waste a lot of time in meetings + make our founder enough [money] to exceed the net worth of the world's richest man + +[demands] demands + expectations + wants + needs + requirements + +[product] product + product line + line of products + line of services + brand + +[better] better + superior + finer + more affordable + quality + higher quality + popular + robust + +[lesser] lesser + highly inferior + subpar + worse + more expensive + weak + lower quality + poor + +[make] make + earn + produce + create + yield + +[defeat] defeat + counter + challenge + beat + strike back at + conquer + crush + shellac + rout + vanquish + reign victorious over + overwhelm + beat the snot out of + +[competition] the competition + our competitors + the rest of the industry + our evil competitors + the market + the industry + our enemies + +[set-us-apart] set us apart from + pull ahead from + distance us from + take us ahead of + +[todays] today's + tomorrow's + the future + +[shareholders] shareholders + employees + executive officers + head honchos + workers + serfs + investors + venture capitalists + sponsors + +[increase] increase + shore up + inflate + enlarge + enrich + add to + augment + advance + expand + burgeon + grow + multiply + make greater + +[profit] profit + dividends + cash + money + revenue + income + earnings + proceeds + rewards + benefits + +[money] money + cash + currency + moola + greenbacks + dough + bread + scratch + bucks + simoleons + +[world] world + industry + globe + universe + nation + country + market + economy + +[butt] butt + ass + rear end + posterior + behind + +[bottom-line] bottom line + stock price + net worth + earnings + revenue + sales diff --git a/RGens/src/main/java/bjc/RGens/server/GrammarServer.java b/RGens/src/main/java/bjc/RGens/server/GrammarServer.java new file mode 100644 index 0000000..3efe6a3 --- /dev/null +++ b/RGens/src/main/java/bjc/RGens/server/GrammarServer.java @@ -0,0 +1,188 @@ +package bjc.RGens.server; + +import bjc.utils.funcdata.FunctionalMap; +import bjc.utils.funcdata.IMap; +import bjc.utils.funcdata.IList; +import bjc.utils.funcutils.ListUtils; +import bjc.utils.gen.WeightedGrammar; + +import java.io.File; +import java.io.IOException; +import java.io.FileInputStream; + +import java.util.Scanner; +import java.util.function.Supplier; + +public class GrammarServer { + private Scanner scn; + + public final IMap<String, WeightedGrammar<String>> loadedGrammars; + + public final IMap<String, WeightedGrammar<String>> exportedRules; + + public GrammarServer(Scanner scn) { + this.scn = scn; + + this.loadedGrammars = new FunctionalMap<>(); + this.exportedRules = new FunctionalMap<>(); + + ServerGrammarReader.setExportedRules(exportedRules); + } + + public static void main(String[] args) { + System.out.println("GrammarServer 1.0"); + + Scanner scn = new Scanner(System.in); + + GrammarServer serv = new GrammarServer(scn); + + System.out.print("Enter a command (m for help): "); + + char comm = scn.nextLine().charAt(0); + + while(comm != 'e') { + switch(comm) { + case 'm': + System.out.println("GrammarServer Commands:"); + System.out.println("\tm: Print command help"); + System.out.println("\te: Exit GrammarServer"); + System.out.println("\tl: Load grammar from file"); + System.out.println("\ts: Show loaded grammars"); + System.out.println("\tg: Generate text"); + break; + case 'g': + serv.generateText(); + break; + case 's': + // @TODO expand to general show stuff method + System.out.printf("Currently loaded grammars (%d total):\n", + serv.loadedGrammars.getSize()); + + serv.loadedGrammars.forEachKey(key -> { + System.out.println("\t" + key); + }); + + break; + case 'l': + serv.loadGrammar(); + break; + default: + System.out.println("? Unrecognized Command"); + } + + System.out.print("Enter a command (m for help): "); + + comm = scn.nextLine().charAt(0); + } + + System.out.println("GrammarServer exiting"); + } + + private void generateText() { + System.out.println("Entering Generate Mode"); + + System.out.print("(Generate Mode) Enter a command (m for help): "); + + char comm = scn.nextLine().charAt(0); + + while(comm != 'e') { + switch(comm) { + case 'm': + System.out.println("GrammarServer Generate Mode Commands: "); + System.out.println("\tm: Show command help"); + System.out.println("\tx: Generate from exported rules"); + System.out.println("\te: Exit Generate Mode"); + break; + case 'x': + System.out.print("Enter the name of the rule to generate" + + " (l to list, enter to cancel): "); + + String ruleName = scn.nextLine().trim(); + + while(true) { + if(ruleName.equals("")) break; + + if(ruleName.equals("l")) { + System.out.println("Current exported rules: "); + exportedRules.forEachKey(key -> { + System.out.println("\t" + key); + }); + } else if (exportedRules.containsKey(ruleName)) { + String ruleResult = ListUtils.collapseTokens( + exportedRules.get(ruleName) + .generateListValues(ruleName, " ")); + + System.out.println("Generated Result: "); + System.out.println(ruleResult.replaceAll("\\s+", " ")); + + System.out.println("Generate again from this rule? (yes/no)"); + + String resp = scn.nextLine().trim(); + + if(resp.equalsIgnoreCase("yes")) { + continue; + } + } else { + System.out.println("? Unrecognized external rule"); + } + + System.out.print("Enter the name of the rule to generate" + + " (l to list, enter to cancel): "); + + ruleName = scn.nextLine().trim(); + } + break; + default: + System.out.println("? Unrecognized command"); + } + + System.out.print("(Generate Mode) Enter a command (m for help): "); + + comm = scn.nextLine().charAt(0); + } + + System.out.println("Exiting Generate Mode"); + } + + private void loadGrammar() { + System.out.print("Enter path to load grammar from: "); + + String grammarPath = scn.nextLine().trim(); + + File grammarFile = new File(grammarPath); + + String grammarName = grammarFile.getName().trim(); + + grammarName = grammarName.substring(0, grammarName.lastIndexOf(".")); + + System.out.printf("Enter grammar name or press enter for" + + " the default (%s): ", grammarName); + + String inputName = scn.nextLine(); + + if(!inputName.equals("")) { + grammarName = inputName; + } + + System.out.printf("Loading grammar (named %s) from path %s\n", + grammarName, grammarPath); + + try (FileInputStream inputStream = new FileInputStream(grammarPath)) { + WeightedGrammar<String> newGram = + ServerGrammarReader.fromStream(inputStream).merge((gram, exports) -> { + for(String export : exports.toIterable()) { + exportedRules.put(export, gram); + } + + return gram; + }); + + loadedGrammars.put(grammarName, newGram); + } catch (IOException ioex) { + System.out.printf("? Error reading grammar from file" + + " (reason: %s)", ioex.getMessage()); + } + + return; + } +} diff --git a/RGens/src/main/java/bjc/RGens/server/ReaderState.java b/RGens/src/main/java/bjc/RGens/server/ReaderState.java new file mode 100644 index 0000000..9285f7b --- /dev/null +++ b/RGens/src/main/java/bjc/RGens/server/ReaderState.java @@ -0,0 +1,184 @@ +package bjc.RGens.server; + +import java.io.IOException; +import java.nio.file.Path; +import java.util.Stack; +import java.util.function.Supplier; + +import bjc.utils.funcdata.FunctionalList; +import bjc.utils.funcdata.IList; +import bjc.utils.gen.WeightedGrammar; + +/** + * Represents the internal state of reader + * + * @author ben + * + */ +public class ReaderState { + private WeightedGrammar<String> currentGrammar; + private String currentRule; + private boolean isUniform; + + private IList<String> exports; + + /** + * Create a new reader state + */ + public ReaderState() { + currentGrammar = new WeightedGrammar<>(); + + // Grammars start out uniform + isUniform = true; + + exports = new FunctionalList<>(); + } + + public void addExport(String export) { + exports.add(export); + } + + public IList<String> getExports() { + return exports; + } + + /** + * Get the rule names for the current grammar + * + * @return The rule names for the current grammar + */ + public IList<String> getRuleNames() { + return currentGrammar.getRuleNames(); + } + + /** + * Check if this reader is currently in uniform mode + * + * @return Whether this grammar is in uniform mode + */ + public boolean isUniform() { + return isUniform; + } + + /** + * Set the current grammar to be the specified one + * + * @param newWorkingGrammar + * The new grammar to use + */ + public void setCurrentGrammar(WeightedGrammar<String> newWorkingGrammar) { + currentGrammar = newWorkingGrammar; + } + + /** + * Set the rule currently being worked on + * + * @param ruleName + * The rule currently being worked on + */ + public void setCurrentRule(String ruleName) { + currentRule = ruleName; + } + + /** + * Set the initial rule of this grammar + * + * @param ruleName + * The initial rule of this grammar + */ + public void setInitialRule(String ruleName) { + currentGrammar.setInitialRule(ruleName); + } + + /** + * Toggle this uniformity setting for this grammar + */ + public void toggleUniformity() { + isUniform = !isUniform; + } + + /** + * Add a case to the current grammar + * + * @param ruleProbability + * The probability for this case to occur + * @param ruleParts + * The parts that make up this case + */ + public void addCase(int ruleProbability, IList<String> ruleParts) { + currentGrammar.addCase(currentRule, ruleProbability, ruleParts); + } + + /** + * Add a special rule to the grammar + * + * @param ruleName The name of the special rule + * @param cse The special case for the rule + */ + public void addSpecialRule(String ruleName, Supplier<IList<String>> cse) { + currentGrammar.addSpecialRule(ruleName, cse); + } + + /** + * Start editing a new rule in the current grammar + * + * @param ruleName + * The name of the new rule to edit + */ + public void startNewRule(String ruleName) { + currentGrammar.addRule(ruleName); + + currentRule = ruleName; + } + + /** + * Convert this package of state into a weighted grammar + * + * @return The grammar represented by this state + */ + public WeightedGrammar<String> getGrammar() { + return currentGrammar; + } + + /** + * Prefix a token onto all of the cases for the specified rule + * + * @param ruleName + * The rule to do prefixing on + * @param prefixToken + * The token to prefix onto each case + * @param additionalProbability + * The probability modification of the prefixed cases + */ + public void prefixRule(String ruleName, String prefixToken, + int additionalProbability) { + currentGrammar.prefixRule(ruleName, prefixToken, + additionalProbability); + } + + /** + * Delete a rule from the current grammar + * + * @param ruleName + * The name of the rule to delete + */ + public void deleteRule(String ruleName) { + currentGrammar.deleteRule(ruleName); + } + + /** + * Suffix a token onto all of the cases for the specified rule + * + * @param ruleName + * The rule to do suffixing on + * @param suffixToken + * The token to suffix onto each case + * @param additionalProbability + * The probability modification of the suffixed cases + */ + public void suffixRule(String ruleName, String suffixToken, + int additionalProbability) { + currentGrammar.suffixRule(ruleName, suffixToken, + additionalProbability); + } +} diff --git a/RGens/src/main/java/bjc/RGens/server/ServerGrammarReader.java b/RGens/src/main/java/bjc/RGens/server/ServerGrammarReader.java new file mode 100644 index 0000000..e59a225 --- /dev/null +++ b/RGens/src/main/java/bjc/RGens/server/ServerGrammarReader.java @@ -0,0 +1,261 @@ +package bjc.RGens.server; + +import com.mifmif.common.regex.Generex; + +import java.io.InputStream; +import java.util.Random; +import java.util.function.BiFunction; +import java.util.function.Predicate; +import java.util.function.Supplier; + +import bjc.utils.data.IPair; +import bjc.utils.data.Pair; +import bjc.utils.funcdata.FunctionalStringTokenizer; +import bjc.utils.funcdata.FunctionalList; +import bjc.utils.funcdata.FunctionalMap; +import bjc.utils.funcdata.IList; +import bjc.utils.funcdata.IMap; +import bjc.utils.funcutils.ListUtils; +import bjc.utils.gen.WeightedGrammar; +import bjc.utils.parserutils.RuleBasedConfigReader; + +/** + * Read a grammar from a stream + * + * @author ben + * + */ +public class ServerGrammarReader { + private static RuleBasedConfigReader<ReaderState> reader; + + private static Random numgen = new Random(); + + private static IMap<String, WeightedGrammar<String>> exportedRules; + + public static void setExportedRules(IMap<String, WeightedGrammar<String>> rules) { + exportedRules = rules; + } + + static { + setupReader(); + + initPragmas(); + } + + private static void debugGrammar(ReaderState state) { + System.out.println("Printing rule names: "); + + for (String currentRule : state.getRuleNames().toIterable()) { + System.out.println("\t" + currentRule); + } + + System.out.println(); + } + + private static void doCase(FunctionalStringTokenizer tokenizer, ReaderState state) { + int ruleProbability = readOptionalProbability(tokenizer, state); + + state.addCase(ruleProbability, tokenizer.toList()); + } + + /** + * Read a grammar from a stream + * + * @param inputStream + * The stream to load the grammar from + * + * @return A grammar read from the stream + * + */ + public static IPair<WeightedGrammar<String>, IList<String>> + fromStream(InputStream inputStream) { + ReaderState initialState = new ReaderState(); + + WeightedGrammar<String> gram = reader.fromStream(inputStream, initialState).getGrammar(); + + IMap<String, IList<String>> vars = new FunctionalMap<>(); + + Predicate<String> specialPredicate = (strang) -> { + if(strang.matches("\\{\\S+\\}") || strang.matches("\\[\\S+\\}")) { + return true; + } + + return false; + }; + + BiFunction<String, WeightedGrammar<String>, IList<String>> + specialAction = (strang, gramm) -> { + IList<String> retList = new FunctionalList<>(); + + if(strang.matches("\\{\\S+\\}")) { + if(strang.matches("\\{\\S+:=\\S+\\}")) { + String[] varParts = strang.split(":="); + + String varName = varParts[0].substring(1); + String ruleName = varParts[1].substring(0, varParts[1].length()); + + IList<String> varValue = gramm.generateGenericValues( + ruleName, (s) -> s, " "); + + vars.put(varName, varValue); + } else if(strang.matches("\\{\\S+=\\S+\\}")) { + String[] varParts = strang.split("="); + + String varName = varParts[0].substring(1); + String varValue = varParts[1].substring(0, varParts[1].length()); + + vars.put(varName, new FunctionalList<>(varValue)); + } else { + // @FIXME notify the user they did something wrong + retList.add(strang); + } + } else { + if(strang.matches("\\[\\$\\S+\\]")) { + String varName = strang.substring(2, strang.length()); + + retList = vars.get(varName); + } else if(strang.matches("\\[\\$\\S+\\-\\S+\\]")) { + String[] varParts = strang.substring(1, strang.length()).split("-"); + + StringBuilder actualName = new StringBuilder("["); + + for(String varPart : varParts) { + if(varPart.startsWith("$")) { + IList<String> varName = vars.get(varPart.substring(1)); + + if(varName.getSize() != 1) { + // @FIXME notify the user they did something wrong + } + + actualName.append(varName.first() + "-"); + } else { + actualName.append(varPart + "-"); + } + } + + // Trim trailing - + actualName.deleteCharAt(actualName.length() - 1); + actualName.append("]"); + + retList = gramm.generateGenericValues(actualName.toString(), (s) -> s, " "); + } else if (exportedRules.containsKey(strang)) { + return exportedRules.get(strang) + .generateGenericValues(strang, (s) -> s, " "); + } else { + // @FIXME notify the user they did something wrong + retList.add(strang); + } + } + + return retList; + }; + + gram.configureSpecial(specialPredicate, specialAction); + + return new Pair<>(gram, initialState.getExports()); + } + + private static void initialRule(FunctionalStringTokenizer tokenizer, ReaderState state) { + String initialRuleName = tokenizer.nextToken(); + + state.setInitialRule(initialRuleName); + } + + private static void initPragmas() { + reader.addPragma("debug", (tokenizer, state) -> { + debugGrammar(state); + }); + + reader.addPragma("uniform", (tokenizer, state) -> { + state.toggleUniformity(); + }); + + reader.addPragma("initial-rule", ServerGrammarReader::initialRule); + + reader.addPragma("remove-rule", ServerGrammarReader::removeRule); + + reader.addPragma("prefix-with", ServerGrammarReader::prefixRule); + reader.addPragma("suffix-with", ServerGrammarReader::suffixRule); + + reader.addPragma("regex-rule", (tokenizer, state) -> { + String ruleName = tokenizer.nextToken(); + + IList<String> regx = tokenizer.toList(); + Generex regex = new Generex(ListUtils.collapseTokens(regx)); + + state.addSpecialRule(ruleName, () -> { + return new FunctionalList<>(regex.random().split(" ")); + }); + }); + + reader.addPragma("range-rule", (tokenizer, state) -> { + String ruleName = tokenizer.nextToken(); + + int start = Integer.parseInt(tokenizer.nextToken()); + int end = Integer.parseInt(tokenizer.nextToken()); + + state.addSpecialRule(ruleName, () -> { + return new FunctionalList<>(Integer.toString( + numgen.nextInt((end - start) + 1) + start)); + }); + }); + + reader.addPragma("export-rule", (tokenizer, state) -> { + String ruleName = tokenizer.nextToken(); + + state.addExport(ruleName); + }); + } + + private static void prefixRule(FunctionalStringTokenizer tokenizer, ReaderState state) { + String ruleName = tokenizer.nextToken(); + String prefixToken = tokenizer.nextToken(); + + int additionalProbability = readOptionalProbability(tokenizer, state); + + state.prefixRule(ruleName, prefixToken, additionalProbability); + } + + private static int readOptionalProbability(FunctionalStringTokenizer tokenizer, ReaderState state) { + if (state.isUniform()) { + return 0; + } + + return Integer.parseInt(tokenizer.nextToken()); + } + + private static void removeRule(FunctionalStringTokenizer tokenizer, ReaderState state) { + String ruleName = tokenizer.nextToken(); + + state.deleteRule(ruleName); + } + + private static void setupReader() { + reader = new RuleBasedConfigReader<>(null, null, null); + + reader.setStartRule((tokenizer, stateTokenPair) -> { + stateTokenPair.doWith((initToken, state) -> { + state.startNewRule(initToken); + + doCase(tokenizer, state); + }); + }); + + reader.setContinueRule((tokenizer, state) -> { + doCase(tokenizer, state); + }); + + reader.setEndRule((tokenizer) -> { + tokenizer.setCurrentRule(null); + }); + } + + private static void suffixRule(FunctionalStringTokenizer tokenizer, ReaderState state) { + String ruleName = tokenizer.nextToken(); + String suffixToken = tokenizer.nextToken(); + + int additionalProbability = readOptionalProbability(tokenizer, state); + + state.suffixRule(ruleName, suffixToken, additionalProbability); + } +} |