diff --git a/.cfformat.json b/.cfformat.json index ff8178c..0233515 100644 --- a/.cfformat.json +++ b/.cfformat.json @@ -17,19 +17,19 @@ "function_call.multiline.leading_comma.padding": true, "function_call.casing.builtin": "cfdocs", "function_call.casing.userdefined": "camel", - "function_call.multiline.element_count": 3, + "function_call.multiline.element_count": 2, "function_call.multiline.leading_comma": false, "function_call.multiline.min_length": 40, "function_declaration.padding": true, "function_declaration.empty_padding": false, "function_declaration.multiline.leading_comma": false, "function_declaration.multiline.leading_comma.padding": true, - "function_declaration.multiline.element_count": 3, + "function_declaration.multiline.element_count": 2, "function_declaration.multiline.min_length": 40, "function_declaration.group_to_block_spacing": "compact", "function_anonymous.empty_padding": false, "function_anonymous.group_to_block_spacing": "compact", - "function_anonymous.multiline.element_count": 3, + "function_anonymous.multiline.element_count": 2, "function_anonymous.multiline.leading_comma": false, "function_anonymous.multiline.leading_comma.padding": true, "function_anonymous.multiline.min_length": 40, @@ -44,6 +44,7 @@ "max_columns": 120, "metadata.multiline.element_count": 3, "metadata.multiline.min_length": 40, + "method_call.chain.multiline" : 3, "newline":"\n", "property.multiline.element_count": 3, "property.multiline.min_length": 40, diff --git a/.cflintrc b/.cflintrc index 396a0b3..0453a37 100644 --- a/.cflintrc +++ b/.cflintrc @@ -1,61 +1,157 @@ { - "rule": [], - "includes": [ - { "code": "AVOID_USING_CFINCLUDE_TAG" }, - { "code": "AVOID_USING_CFABORT_TAG" }, - { "code": "AVOID_USING_CFEXECUTE_TAG" }, - { "code": "AVOID_USING_DEBUG_ATTR" }, - { "code": "AVOID_USING_ABORT" }, - { "code": "AVOID_USING_ISDATE" }, - { "code": "AVOID_USING_ISDEBUGMODE" }, - { "code": "AVOID_USING_CFINSERT_TAG" }, - { "code": "AVOID_USING_CFUPDATE_TAG" }, - { "code": "ARG_VAR_CONFLICT" }, - { "code": "ARG_HINT_MISSING" }, - { "code": "ARG_HINT_MISSING_SCRIPT" }, - { "code" : "ARGUMENT_INVALID_NAME" }, - { "code" : "ARGUMENT_ALLCAPS_NAME" }, - { "code" : "ARGUMENT_TOO_WORDY" }, - { "code" : "ARGUMENT_IS_TEMPORARY" }, - { "code": "CFQUERYPARAM_REQ" }, - { "code": "COMPARE_INSTEAD_OF_ASSIGN" }, - { "code": "COMPONENT_HINT_MISSING" }, - { "code" : "COMPONENT_INVALID_NAME" }, - { "code" : "COMPONENT_ALLCAPS_NAME" }, - { "code" : "COMPONENT_TOO_SHORT" }, - { "code" : "COMPONENT_TOO_LONG" }, - { "code" : "COMPONENT_TOO_WORDY" }, - { "code" : "COMPONENT_IS_TEMPORARY" }, - { "code" : "COMPONENT_HAS_PREFIX_OR_POSTFIX" }, - { "code": "COMPLEX_BOOLEAN_CHECK" }, - { "code": "EXCESSIVE_FUNCTION_LENGTH" }, - { "code": "EXCESSIVE_COMPONENT_LENGTH" }, - { "code": "EXCESSIVE_ARGUMENTS" }, - { "code": "EXCESSIVE_FUNCTIONS" }, - { "code": "EXPLICIT_BOOLEAN_CHECK" }, - { "code": "FUNCTION_TOO_COMPLEX" }, - { "code": "FUNCTION_HINT_MISSING" }, - { "code": "FILE_SHOULD_START_WITH_LOWERCASE" }, - { "code": "LOCAL_LITERAL_VALUE_USED_TOO_OFTEN" }, - { "code": "GLOBAL_LITERAL_VALUE_USED_TOO_OFTEN" }, - { "code": "MISSING_VAR" }, - { "code" : "METHOD_INVALID_NAME" }, - { "code" : "METHOD_ALLCAPS_NAME" }, - { "code" : "METHOD_IS_TEMPORARY" }, - { "code": "NESTED_CFOUTPUT" }, - { "code": "NEVER_USE_QUERY_IN_CFM" }, - { "code": "OUTPUT_ATTR" }, - { "code" : "QUERYPARAM_REQ" }, - { "code": "UNUSED_LOCAL_VARIABLE" }, - { "code": "UNUSED_METHOD_ARGUMENT" }, - { "code": "SQL_SELECT_STAR" }, - { "code": "SCOPE_ALLCAPS_NAME" }, - { "code": "VAR_ALLCAPS_NAME" }, - { "code": "VAR_INVALID_NAME" }, - { "code": "VAR_TOO_WORDY" } - ], - "inheritParent": false, - "parameters": { - "TooManyFunctionsChecker.maximum" : 20 - } + "rule": [], + "includes": [ + { + "code": "AVOID_USING_CFINCLUDE_TAG" + }, + { + "code": "AVOID_USING_CFABORT_TAG" + }, + { + "code": "AVOID_USING_CFEXECUTE_TAG" + }, + { + "code": "AVOID_USING_DEBUG_ATTR" + }, + { + "code": "AVOID_USING_ABORT" + }, + { + "code": "AVOID_USING_ISDATE" + }, + { + "code": "AVOID_USING_ISDEBUGMODE" + }, + { + "code": "AVOID_USING_CFINSERT_TAG" + }, + { + "code": "AVOID_USING_CFUPDATE_TAG" + }, + { + "code": "ARG_VAR_CONFLICT" + }, + { + "code": "ARG_HINT_MISSING" + }, + { + "code": "ARG_HINT_MISSING_SCRIPT" + }, + { + "code": "ARGUMENT_INVALID_NAME" + }, + { + "code": "ARGUMENT_ALLCAPS_NAME" + }, + { + "code": "ARGUMENT_TOO_WORDY" + }, + { + "code": "ARGUMENT_IS_TEMPORARY" + }, + { + "code": "CFQUERYPARAM_REQ" + }, + { + "code": "COMPARE_INSTEAD_OF_ASSIGN" + }, + { + "code": "COMPONENT_HINT_MISSING" + }, + { + "code": "COMPONENT_INVALID_NAME" + }, + { + "code": "COMPONENT_ALLCAPS_NAME" + }, + { + "code": "COMPONENT_TOO_SHORT" + }, + { + "code": "COMPONENT_TOO_LONG" + }, + { + "code": "COMPONENT_TOO_WORDY" + }, + { + "code": "COMPONENT_IS_TEMPORARY" + }, + { + "code": "COMPONENT_HAS_PREFIX_OR_POSTFIX" + }, + { + "code": "COMPLEX_BOOLEAN_CHECK" + }, + { + "code": "EXCESSIVE_ARGUMENTS" + }, + { + "code": "EXCESSIVE_FUNCTIONS" + }, + { + "code": "EXPLICIT_BOOLEAN_CHECK" + }, + { + "code": "FUNCTION_HINT_MISSING" + }, + { + "code": "FILE_SHOULD_START_WITH_LOWERCASE" + }, + { + "code": "LOCAL_LITERAL_VALUE_USED_TOO_OFTEN" + }, + { + "code": "GLOBAL_LITERAL_VALUE_USED_TOO_OFTEN" + }, + { + "code": "MISSING_VAR" + }, + { + "code": "METHOD_INVALID_NAME" + }, + { + "code": "METHOD_ALLCAPS_NAME" + }, + { + "code": "METHOD_IS_TEMPORARY" + }, + { + "code": "NESTED_CFOUTPUT" + }, + { + "code": "NEVER_USE_QUERY_IN_CFM" + }, + { + "code": "OUTPUT_ATTR" + }, + { + "code": "QUERYPARAM_REQ" + }, + { + "code": "UNUSED_LOCAL_VARIABLE" + }, + { + "code": "UNUSED_METHOD_ARGUMENT" + }, + { + "code": "SQL_SELECT_STAR" + }, + { + "code": "SCOPE_ALLCAPS_NAME" + }, + { + "code": "VAR_ALLCAPS_NAME" + }, + { + "code": "VAR_INVALID_NAME" + }, + { + "code": "VAR_TOO_WORDY" + } + ], + "inheritParent": false, + "parameters": { + "TooManyFunctionsChecker.maximum": 50 + }, + "excludes": [] } \ No newline at end of file diff --git a/.markdownlint.json b/.markdownlint.json new file mode 100644 index 0000000..31705fa --- /dev/null +++ b/.markdownlint.json @@ -0,0 +1,14 @@ +{ + "line-length": false, + "single-h1": false, + "no-hard-tabs" : false, + "fenced-code-language" : false, + "no-bare-urls" : false, + "first-line-h1": false, + "no-multiple-blanks": { + "maximum": 2 + }, + "no-duplicate-header" : { + "siblings_only" : true + } +} \ No newline at end of file diff --git a/box.json b/box.json index bc837cf..19c1953 100644 --- a/box.json +++ b/box.json @@ -1,6 +1,6 @@ { "name":"MockDataCFC", - "version":"3.3.1", + "version":"3.4.0", "location":"https://downloads.ortussolutions.com/ortussolutions/coldbox-modules/MockDataCFC/@build.version@/MockDataCFC-@build.version@.zip", "author":"Ortus Solutions", "homepage":"https://github.com/Ortus-Solutions/MockDataCFC", @@ -29,6 +29,9 @@ "*/.md" ], "scripts":{ - "toMaster":"recipe build/toMaster.boxr" + "release":"recipe build/release.boxr", + "format":"cfformat run handlers,models,test-harness/tests/,ModuleConfig.cfc --overwrite", + "format:watch":"cfformat watch handlers,models,test-harness/tests/,ModuleConfig.cfc ./.cfformat.json", + "format:check":"cfformat check handlers,models,test-harness/tests/,ModuleConfig.cfc" } } \ No newline at end of file diff --git a/build/Build.cfc b/build/Build.cfc index 732b127..cf74dff 100644 --- a/build/Build.cfc +++ b/build/Build.cfc @@ -56,7 +56,7 @@ component{ buildID=createUUID(), branch="development" ){ - // Create project mapping + // Create project mapping fileSystemUtil.createMapping( arguments.projectName, variables.cwd ); // Run the tests @@ -70,7 +70,10 @@ component{ docs( argumentCollection=arguments ); // checksums - buildChecksums(); + buildChecksums(); + + // Build latest changelog + latestChangelog(); // Finalize Message print.line() @@ -78,7 +81,7 @@ component{ .toConsole(); } - /** + /** * Run the test suites */ function runTests(){ @@ -195,7 +198,28 @@ component{ overwrite=true, recurse=true ); - } + } + + /** + * Build the latest changelog file: changelog-latest.md + */ + function latestChangelog(){ + print.blueLine( "Building latest changelog..." ).toConsole(); + + if( !fileExists( variables.cwd & "changelog.md" ) ){ + return error( "Cannot continue building, changelog.md file doesn't exist!" ); + } + + fileWrite( + variables.cwd & "changelog-latest.md", + fileRead( variables.cwd & 'changelog.md' ).split( '----' )[2].trim() & chr( 13 ) & chr( 10 ) + ); + + print + .greenLine( "Latest changelog file created at `changelog-latest.md`" ) + .line() + .line( fileRead( variables.cwd & "changelog-latest.md" ) ); + } /********************************************* PRIVATE HELPERS *********************************************/ diff --git a/build/toMaster.boxr b/build/release.boxr similarity index 69% rename from build/toMaster.boxr rename to build/release.boxr index ec73706..e216f22 100755 --- a/build/toMaster.boxr +++ b/build/release.boxr @@ -1,19 +1,25 @@ # This recipe signifies a new release of the module by doing merges and bumps accordingly -# Check out master +# Check out master and update it locally !git checkout -f master -# Merge development into it +!git pull origin master + +# Merge development into it for release !git merge --no-ff development -# Tag the master repo with the version in box.json + +# Tag the master repo with the version from box.json !git tag v`box package show version` -# Push all branches + +# Push all branches back out to github !git push origin --all + # Push all tags !git push origin --tags + # Check development again !git checkout -f development + # Bump to prepare for a new release, do minor, change if needed and don't tag bump --minor --!tagVersion -# Send it out !git commit -a -m "version bump" !git push origin development \ No newline at end of file diff --git a/changelog.md b/changelog.md index a8f60cf..02dbd33 100644 --- a/changelog.md +++ b/changelog.md @@ -1,10 +1,48 @@ # Changelog -## 3.3.1 +All notable changes to this project will be documented in this file. -* `bug` : param the default method when executing via URL instead of setting it. +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). -## 3.3.0 +---- + +## [3.4.0] => 2020-JUN-03 + +### Added + +* `string` type re-architected to produce more randomness and more permutations according to our new generation pattern: `string[-(secure|alpha|numeric):max]` #6 +* More formatting rules +* Changelog standards +* Auto publishing to github (artifacts and changelogs) +* Types are now case-insensitive when called: `num,oneof,lorem,baconlorem,sentence,words` #5 +* `generateFakeData()` is now public +* All generators can now be called individually by function name +* `lorem,baconlorem,words,sentence` you can now produce random sizes with them via `min:max` notation +* Optimized generation by using arrays instead of strings +* Included libraries for nouns and adjectives + +### Changed + +* Access variables according to scopes instead of lookup +* Internal data generation names to avoid method conflicts + +### Fixed + +* Access variables according to scopes +* `$returnType` is not documented #8 + +---- + +## [3.3.1] => 2020-APR-16 + +### Fixed + +* param the default method when executing via URL instead of setting it. + +---- + +## [3.3.0] => 2020-JAN-28 ### New Features @@ -25,7 +63,9 @@ * Added new domains for more random generation * Removed spacing from words -## 3.2.0 +---- + +## [3.2.0] => 2020-JAN-08 ### New Features @@ -39,12 +79,16 @@ * TestBox 3 upgrade * More direct scoping of the arguments scope -## 3.1.0 +---- + +## [3.1.0] => 2019-MAY-19 * CommandBox ability to execute * Template updates to standards -## 3.0.0 +---- + +## [3.0.0] => 2018-SEP-4 * **Compatibility** : `num` arguments have been dropped and you must use `$num` as the identifier for how many items you like * Introduction of nested mocking. You can now declare nested mocks as structs and the mock data will nest accordingly: @@ -72,11 +116,15 @@ This will produce top level mock data with 2 books per record. * Updated readmes and syntax updates for modern engines * Upgraded to new ColdBox module Harness -## 2.4.0 +---- + +## [2.4.0] * Added auto-incrementing ID's FOR REAL this time -## 2.3.0 +---- + +## [2.3.0] * Added auto-incrementing ID's * Update on build control @@ -86,17 +134,23 @@ This will produce top level mock data with 2 books per record. * Bug on `isDefault()` always returning true. * Added tests and automation -## 2.2.0 +---- + +## [2.2.0] * Made it a module as well for ColdBox apps. -## 2.0.0 +---- + +## [2.0.0] * Added support for words, sentences, uuid, bacon lorem, date and datetime * Added CommandBox Support * Added Documentation * Added ability to execute as a CFC instead of only via web service -## 1.0.0 +---- + +## [1.0.0] Original by Ray Camden diff --git a/handlers/Main.cfc b/handlers/Main.cfc index 51c73d7..5830a56 100644 --- a/handlers/Main.cfc +++ b/handlers/Main.cfc @@ -13,12 +13,18 @@ component extends="coldbox.system.EventHandler" { // mock the incoming RC without reserved words var results = mockData.mock( argumentCollection = rc.filter( function( item ){ - return !listFindNoCase( "event,namespaceRouting,namespace", item ); + return !listFindNoCase( + "event,namespaceRouting,namespace", + item + ); } ) ); // CORS - cfheader( name="Access-Control-Allow-Origin", value="*" ); + cfheader( + name ="Access-Control-Allow-Origin", + value="*" + ); // Rendering event.renderData( type = "json", data = results ); diff --git a/models/MockData.cfc b/models/MockData.cfc index 53af615..3952dea 100644 --- a/models/MockData.cfc +++ b/models/MockData.cfc @@ -4,11 +4,21 @@ */ component { - // Param default URL method if running cfc directly + /** + * Direct method for URL mocking service + */ param name="url.method" default="mock"; + /** + * -------------------------------------------------------------------------- + * Static Data Used For Generation + * -------------------------------------------------------------------------- + */ + + variables.cwd = getDirectoryFromPath( getCurrentTemplatePath() ); + // Defaults used for data, may move to a file later - variables.fNames = [ + variables._firstNames = [ "Alexia", "Alice", "Amy", @@ -53,7 +63,7 @@ component { "Veronica" ]; - variables.lNames = [ + variables._lastNames = [ "Anderson", "Bearenstein", "Boudreaux", @@ -86,7 +96,7 @@ component { "Zelda" ]; - variables.webDomains = [ + variables._webDomains = [ "adobe.com", "aol.com", "apple.com", @@ -115,23 +125,21 @@ component { "test.com" ]; - variables.lorem = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."; + variables._loremData = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."; - variables.sentences = [ + variables._words = deserializeJSON( fileRead( variables.cwd & "nouns.json" ) ); + + variables._adjectives = deserializeJSON( fileRead( variables.cwd & "adjectives.json" ) ); + + variables._baconloremData = arrayToList( [ "Bacon ipsum dolor amet bacon biltong brisket sirloin kielbasa", "hock beef landjaeger boudin alcatra", "sausage beef beef ribs pancetta pork chop doner short ribs", "brisket alcatra shankle pork chop, turducken picanha", "Venison doner leberkas turkey ball tip tongue" - ]; - - variables.words = listToArray( - "Aeroplane,Air,Aircraft,Airforce,Airport,Album,Alphabet,Apple,Arm,Army,Baby,Baby,Backpack,Balloon,Banana,Bank,Barbecue,Bathroom,Bathtub,Bed,Bed,Bee,Bible,Bible,Bird,Bomb,Book,Boss,Bottle,Bowl,Box,Boy,Brain,Bridge,Butterfly,Button,Cappuccino,Car,Car-race,Carpet,Carrot,Cave,Chair,Chess,Chief,Child,Chisel,Chocolates,Church,Church,Circle,Circus,Circus,Clock,Clown,Coffee,Coffee-shop,Comet,CompactDisc,Compass,Computer,Crystal,Cup,Cycle,DataBase,Desk,Diamond,Dress,Drill,Drink,Drum,Dung,Ears,Earth,Egg,Electricity,Elephant,Eraser,Explosive,Eyes,Family,Fan,Feather,Festival,Film,Finger,Fire,Floodlight,Flower,Foot,Fork,Freeway,Fruit,Fungus,Game,Garden,Gas,Gate,Gemstone,Girl,Gloves,God,Grapes,Guitar,Hammer,Hat,Hieroglyph,Highway,Horoscope,Horse,Hose,Ice,Ice-cream,Insect,Jetfighter,Junk,Kaleidoscope,Kitchen,Knife,Leather,Leg,Library,Liquid,Magnet,Man,Map,Maze,Meat,Meteor,Microscope,Milk,Milkshake,Mist,Money,Monster,Mosquito,Mouth,Nail,Navy,Necklace,Needle,Onion,PaintBrush,Pants,Parachute,Passport,Pebble,Pendulum,Pepper,Perfume,Pillow,Plane,Planet,Pocket,Post-office,Potato,Printer,Prison,Pyramid,Radar,Rainbow,Record,Restaurant,Rifle,Ring,Robot,Rock,Rocket,Roof,Room,Rope,Saddle,Salt,Sandpaper,Sandwich,Satellite,School,Ship,Shoes,Shop,Shower,Signature,Skeleton,Slave,Snail,Software,Solid,SpaceShuttle,Spectrum,Sphere,Spice,Spiral,Spoon,Sports-car,Spotlight,Square,Staircase,Star,Stomach,Sun,Sunglasses,Surveyor,Swimming,Sword,Table,Tapestry,Teeth,Telescope,Television,Tennis,Thermometer,Tiger,Toilet,Tongue,Torch,Torpedo,Train,Treadmill,Triangle,Tunnel,Typewriter,Umbrella,Vacuum,Vampire,Videotape,Vulture,Water,Weapon,Web,Wheelchair,Window,Woman,Worm,X-ray" - ); - - variables.baconlorem = arrayToList( variables.sentences ); + ] ); - variables.defaults = [ + variables._defaultTypes = [ "age", "all_age", "baconlorem", @@ -150,7 +158,7 @@ component { "words" ]; - variables.extensions = [ + variables._extensions = [ ".cfm", ".css", ".doc", @@ -168,7 +176,7 @@ component { ".xlsx" ]; - variables.imageExtensions = [ + variables._imageExtensions = [ ".svg", ".gif", ".jpg", @@ -182,6 +190,8 @@ component { /** * This function is the remote entry point for our service or data calls * The incoming arguments are evaluated for mocking data services. + * + * @return Array, struct, or single mocked data */ remote function mock() returnformat="json"{ // cfheader( name="Content-Type", value="text/html" ); @@ -239,31 +249,29 @@ component { // If in Service mode, then add headers if ( cgi.script_name contains "MockData.cfc" ) { - cfheader( name="Content-Type", value="application/json" ); + cfheader( + name ="Content-Type", + value="application/json" + ); // CORS for web service calls - cfheader( name="Access-Control-Allow-Origin", value="*" ); + cfheader( + name ="Access-Control-Allow-Origin", + value="*" + ); } return result; } - /***************************** PRIVATE ****************************************/ - - /** - * Check if an incoming type exists in our default types - * @target The target to check - */ - private boolean function isDefault( required target ){ - return defaults.findNoCase( target ) > 0; - } - /** * Generate the fake data according to incoming type * - * @type The valid incoming fake data type - * @index The index location of the fake iteration + * @type The valid incoming fake data type, see docs for valid types + * @index The index location of the fake iteration if any + * + * @return The fake data */ - private function generateFakeData( required type, required index ){ + function generateFakeData( required type, index = 1 ){ // Supplier closure or lambda if ( isClosure( arguments.type ) || isCustomFunction( arguments.type ) ) { return arguments.type( arguments.index ); @@ -272,22 +280,22 @@ component { return arguments.index; } if ( arguments.type == "ipaddress" ) { - return generateIpAddress(); + return ipAddress(); } - if ( arguments.type.find( "string" ) == 1 ) { - return generateString( arguments.type ); + if ( arguments.type.findNoCase( "string" ) == 1 ) { + return string( arguments.type ); } if ( arguments.type == "uuid" ) { return createUUID(); } if ( arguments.type == "name" ) { - return generateFirstName() & " " & generateLastName(); + return firstName() & " " & lastName(); } if ( arguments.type == "fname" ) { - return generateFirstName(); + return firstName(); } if ( arguments.type == "lname" ) { - return generateLastName(); + return lastName(); } if ( arguments.type == "age" ) { return randRange( 18, 75 ); @@ -296,288 +304,286 @@ component { return randRange( 1, 100 ); } if ( arguments.type == "email" ) { - return generateEmail(); + return email(); } if ( arguments.type == "imageurl" ) { - return generateImageUrl(); + return imageUrl(); } if ( arguments.type == "imageurl_http" ) { - return generateImageUrl( httpOnly = true ); + return imageUrl( httpOnly = true ); } if ( arguments.type == "imageurl_https" ) { - return generateImageUrl( httpsOnly = true ); + return imageUrl( httpsOnly = true ); } if ( arguments.type == "url" ) { - return generateUrl(); + return uri(); } if ( arguments.type == "url_http" ) { - return generateUrl( httpOnly = true ); + return uri( httpOnly = true ); } if ( arguments.type == "url_https" ) { - return generateUrl( httpsOnly = true ); + return uri( httpsOnly = true ); } if ( arguments.type == "website" ) { - return generateWebsite(); + return websiteUrl(); } if ( arguments.type == "website_http" ) { - return generateWebsite( httpOnly = true ); + return websiteUrl( httpOnly = true ); } if ( arguments.type == "website_https" ) { - return generateWebsite( httpsOnly = true ); + return websiteUrl( httpsOnly = true ); } if ( arguments.type == "ssn" ) { - return generateSSN(); + return ssn(); } if ( arguments.type == "tel" ) { - return generateTelephone(); + return telephone(); } if ( arguments.type == "date" ) { - return generateDateRange(); + return dateRange(); } if ( arguments.type == "datetime" ) { - return generateDateRange( showTime = true ); - } - if ( arguments.type.find( "num" ) == 1 ) { - return generateNumber( arguments.type ); - } - if ( arguments.type.find( "oneof" ) == 1 ) { - return generateOneOf( arguments.type ); - } - if ( arguments.type.find( "lorem" ) == 1 ) { - return generateLorem( arguments.type ); - } - if ( arguments.type.find( "baconlorem" ) == 1 ) { - return generateLorem( arguments.type ); - } - if ( arguments.type.find( "sentence" ) == 1 ) { - return generateSentences( arguments.type ); - } - if ( arguments.type.find( "words" ) == 1 ) { - return generateWords( arguments.type ); + return dateRange( showTime = true ); + } + if ( arguments.type.findNoCase( "num" ) == 1 ) { + return num( + arguments.type.find( ":" ) ? arguments.type.REreplaceNoCase( "num\:?", "" ) : javacast( "null", "" ) + ); + } + if ( arguments.type.findNoCase( "oneof" ) == 1 ) { + return oneOf( + arguments.type.find( ":" ) ? arguments.type.REreplaceNoCase( "oneOf\:?", "" ) : javacast( "null", "" ) + ); + } + if ( arguments.type.findNoCase( "lorem" ) == 1 ) { + return lorem( + arguments.type.find( ":" ) ? arguments.type.REreplaceNoCase( "lorem\:?", "" ) : javacast( "null", "" ) + ); + } + if ( arguments.type.findNoCase( "baconlorem" ) == 1 ) { + return baconLorem( + arguments.type.find( ":" ) ? arguments.type.REreplaceNoCase( "baconlorem\:?", "" ) : javacast( + "null", + "" + ) + ); + } + if ( arguments.type.findNoCase( "sentence" ) == 1 ) { + return sentence( + arguments.type.find( ":" ) ? arguments.type.REreplaceNoCase( "sentence\:?", "" ) : javacast( + "null", + "" + ) + ); + } + if ( arguments.type.findNoCase( "words" ) == 1 ) { + return words( + arguments.type.find( ":" ) ? arguments.type.REreplaceNoCase( "words\:?", "" ) : javacast( "null", "" ) + ); } return "No Type ['#arguments.type#'] Found"; } - /** - * Generate a new mocked item - * @fieldModels A struct of name and type of the model to generate - * @index The numerical index of the item being generated - */ - private struct function generateNewItem( required array fieldModels, required index ){ - var result = {}; - arguments.fieldModels.each( function( field ){ - // Verify the field struct has a name, else generate it - if ( !field.keyExists( "name" ) ) { - field.name = "field" & i; - } - - // if we are a default, that is our type, otherwise string - if ( - isSimpleValue( field.type ) - && - !field.type.len() - && - isDefault( field.name ) - ) { - field.type = field.name; - } - - // Determine the type of field model - if ( isStruct( field.type ) ) { - // Bind the return type as a struct - field.type.$returnType = "struct"; - // The field model defines a single object relationship - result[ field.name ] = mock( argumentCollection = field.type ); - } else if ( isArray( field.type ) ) { - // The field model defines a one to many relationship - result[ field.name ] = mock( argumentCollection = field.type[ 1 ] ); - } else { - // Generate the fake data - result[ field.name ] = generateFakeData( field.type, index ); - } - } ); - - return result; - } + /********************************* GENERATORS ********************************/ /** - * Get the parts count from the incoming target type which can be - * - type:max - * - type:min:max + * Generate random strings according to the passed string type + * + * The type can be of the following permutations pattern: string[-(secure|alpha|numeric):max] + * + * string - Generate 10 alphanumeric characters + * string:max - Generate {max} count of alphanumeric characters + * string-numeric - Generate numeric characters + * string-alpha - Generate alpha characters + * string-secure - Generate alpha+numeric+secure characters + * + * @type This can be string, or string:size */ - private function getPartCounts( required target ){ - // Calculate counts - var parts = target.listToArray( ":" ); - - if ( parts.len() == 2 ) { - return parts[ 2 ]; + function string( required type ){ + // Generation data + var alpha = listToArray( + "A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z" + ); + var numeric = listToArray( "0,1,2,3,4,5,6,7,8,9" ); + var secure = listToArray( "!,@,$,%,&,*,-,_,=,+,?,~" ); + + // The return type to use: alphanumeric (default), alpha, numeric, secure + if ( arguments.type.findNoCase( "string-alphanumeric" ) ) { + var returnType = "alphanumeric"; + } else if ( arguments.type.findNoCase( "string-numeric" ) ) { + var returnType = "numeric"; + } else if ( arguments.type.findNoCase( "string-alpha" ) ) { + var returnType = "alpha"; + } else if ( arguments.type.findNoCase( "string-secure" ) ) { + var returnType = "secure"; } else { - return randRange( parts[ 2 ], parts[ 3 ] ); + var returnType = "alphanumeric"; } - } - - /********************************* GENERATORS ********************************/ - /** - * Generate a SHA-512 hash with no - dashes - */ - private function generateHash(){ - return replace( - hash( now(), "SHA-512" ), - "-", - "", - "all" - ); - } + // Check incoming type, if default of `string` default to 10 chars + if ( !arguments.type.find( ":" ) ) { + arguments.type &= ":10"; + } - /** - * Generate random strings - * - * @type This can be strings, or strings:lettersMax - */ - private function generateString( required type ){ - // Default is 10 characters - if ( type == "string" ) { - return left( generateHash(), 10 ); - } - - // Else choose length via : parts - if ( type.find( ":" ) > 1 ) { - // Calculate counts - var result = ""; - var count = getToken( type, 2, ":" ); - // Calculate Blocks - var blocks = ceiling( count / 128 ); - - // Generate strings - for ( var i = 0; i < blocks; i++ ) { - result &= generateHash(); + // Prepare Data List + switch ( returnType ) { + case "alpha": { + var dataList = alpha; + break; + } + case "numeric": { + var dataList = numeric; + break; + } + case "secure": { + var dataList = alpha.append( numeric.append( secure, true ), true ); + break; } + default: { + var dataList = alpha.append( numeric, true ); + } + } - return left( result, count ); + // Iterate and create string + var result = ""; + var count = getToken( arguments.type, 2, ":" ); + for ( var i = 1; i <= count; i++ ) { + result &= dataList[ randRange( 1, dataList.len() ) ]; } + + return result; } /** * Generate random words * - * @type This can be words, or words:count + * @size The number of words to generate or can be a min:max range to produce random number of words */ - private function generateWords( required type ){ - if ( type == "words" ) { - return words[ randRange( 1, arrayLen( words ) ) ]; - } - if ( type.find( ":" ) > 1 ) { - var parts = type.listToArray( ":" ); - var result = ""; - var count = ""; - if ( parts.len() == 2 ) { - count = parts[ 2 ]; + function words( size = 1 ){ + // Do we have a random size request? + if ( arguments.size.find( ":" ) ) { + arguments.size = randRange( + getToken( arguments.size, 1, ":" ), + getToken( arguments.size, 2, ":" ) + ); + } + // Generate it + var result = []; + for ( var i = 1; i <= arguments.size; i++ ) { + if ( i mod 2 > 0 ) { + result.append( variables._words[ randRange( 1, variables._words.len() ) ] ); } else { - count = randRange( parts[ 2 ], parts[ 3 ] ); - } - for ( var i = 0; i < count; i++ ) { - result &= words[ randRange( 1, arrayLen( words ) ) ] & " "; + result.append( variables._adjectives[ randRange( 1, variables._adjectives.len() ) ] ); } - return result; } + return result.toList( " " ); } /** * Generate sentences + * + * @size The number of sentences to produce, default is 1, or pass in a min:max to produce random sentences */ - private function generateSentences( required type ){ - if ( arguments.type == "sentence" ) { - return sentences[ randRange( 1, arrayLen( sentences ) ) ]; - } - if ( arguments.type.find( ":" ) > 1 ) { - var parts = arguments.type.listToArray( ":" ); - var result = ""; - var count = ""; - if ( parts.len() == 2 ) { - count = parts[ 2 ]; - } else { - count = randRange( parts[ 2 ], parts[ 3 ] ); - } - for ( var i = 0; i < count; i++ ) { - result &= sentences[ randRange( 1, arrayLen( sentences ) ) ] & "\n\n"; - } - return result; - } + function sentence( size = 1 ){ + // Do we have a random size request? + if ( arguments.size.find( ":" ) ) { + arguments.size = randRange( + getToken( arguments.size, 1, ":" ), + getToken( arguments.size, 2, ":" ) + ); + } + // Generate it + var result = []; + for ( var i = 1; i <= arguments.size; i++ ) { + result.append( words( 15 ) & chr( 13 ) & chr( 10 ) ); + } + return result.toList(); } /** * Generate Lorem - * @type The target type + * + * @size The number of sentences of lorem to produce, default is 1, or pass in a min:max to produce random sentences */ - private function generateLorem( required type ){ - if ( arguments.type == "lorem" ) { - return lorem; - } - if ( arguments.type == "baconlorem" ) { - return baconlorem; - } - - // Restricting by convention - if ( type.find( ":" ) > 1 ) { - var parts = type.listToArray( ":" ); - var result = ""; - var count = ""; - var targetLorem = ( arguments.type == "lorem" ? variables.lorem : variables.baconlorem ); + function lorem( size = 1 ){ + // Do we have a random size request? + if ( arguments.size.find( ":" ) ) { + arguments.size = randRange( + getToken( arguments.size, 1, ":" ), + getToken( arguments.size, 2, ":" ) + ); + } + // Generate it + var result = []; + for ( var i = 1; i <= arguments.size; i++ ) { + result.append( variables._loremData ); + } + return result.toList(); + } - if ( parts.len() == 2 ) { - count = parts[ 2 ]; - } else { - count = randRange( parts[ 2 ], parts[ 3 ] ); - } - for ( var i = 0; i < count; i++ ) { - result &= targetLorem & "\n\n"; - } - return result; - } + /** + * Generate bacon lorem text + * + * @size The number of sentences of lorem to produce, default is 1, or pass in a min:max to produce random sentences + */ + function baconLorem( size = 1 ){ + // Do we have a random size request? + if ( arguments.size.find( ":" ) ) { + arguments.size = randRange( + getToken( arguments.size, 1, ":" ), + getToken( arguments.size, 2, ":" ) + ); + } + // Generate it + var result = []; + for ( var i = 1; i <= arguments.size; i++ ) { + result.append( variables._baconloremData ); + } + return result.toList(); } /** - * generate one of functions + * Generate one of the data supplied randomly + * + * @data This can be a single value or a list of values val1:val2:valz */ - private function generateOneOf( required type ){ + function oneOf( required data ){ // Support oneof:male:female, ie, pick a random one - var items = arguments.type.listToArray( ":" ); - items.deleteAt( 1 ); + var items = arguments.data.listToArray( ":" ); return items[ randRange( 1, items.len() ) ]; } /** - * Generate a random number + * Generate a random number, if no count is passed we use a ceiling of 10 + * + * @count The count of numbers to generate. This can be a whole number or the `min:max` format */ - private function generateNumber( required type ){ - // Support num, num:10, num:1:10 - if ( arguments.type == "num" ) { - return randRange( 1, 10 ); - } - if ( arguments.type.find( ":" ) > 1 ) { - var parts = arguments.type.listToArray( ":" ); - if ( parts.len() == 2 ) { - return randRange( 1, parts[ 2 ] ); - } - return randRange( parts[ 2 ], parts[ 3 ] ); - } + function num( count = 10 ){ + // Basic generation + if ( !arguments.count.find( ":" ) ) { + return randRange( 1, arguments.count ); + } + // Min/Max generation + return randRange( + getToken( arguments.count, 1, ":" ), + getToken( arguments.count, 2, ":" ) + ); } /** * Generate telephone */ - private function generateTelephone(){ + function telephone(){ return "(" & randRange( 1, 9 ) & randRange( 1, 9 ) & randRange( 1, 9 ) & ") " & randRange( 1, 9 ) & randRange( 1, 9 ) & randRange( 1, 9 ) & "-" & randRange( 1, 9 ) & randRange( 1, 9 ) & randRange( 1, 9 ) & randRange( 1, 9 ); } /** - * Generate SSN + * Generate a social security number */ - private function generateSSN(){ + function ssn(){ return randRange( 1, 9 ) & randRange( 1, 9 ) & randRange( 1, 9 ) & "-" & randRange( 1, 9 ) & randRange( 1, 9 ) & "-" & randRange( 1, 9 ) & randRange( 1, 9 ) & randRange( 1, 9 ) & randRange( 1, 9 ); @@ -586,11 +592,11 @@ component { /** * Generate an email */ - private function generateEmail(){ - var fname = generateFirstName().toLowerCase(); - var lname = generateLastName().toLowerCase(); + function email(){ + var fname = firstName().toLowerCase(); + var lname = lastName().toLowerCase(); var emailPrefix = fname.charAt( 1 ) & lname; - return emailPrefix & "@" & variables.webDomains[ randRange( 1, variables.webDomains.len() ) ]; + return emailPrefix & "@" & variables._webDomains[ randRange( 1, variables._webDomains.len() ) ]; } /** @@ -599,44 +605,44 @@ component { * @httpOnly Only do http sites, mutex with httpsOnly * @httpsOnly Only do https sites, mutex with httpOnly */ - private function generateImageUrl( boolean httpOnly, boolean httpsOnly ){ + function imageUrl( boolean httpOnly, boolean httpsOnly ){ arguments.imageExtensions = true; - return generateUrl( argumentCollection = arguments ); + return uri( argumentCollection = arguments ); } /** - * Generate a random URL including a random protocol + * Generate a random URI including a random protocol * * @httpOnly Only do http sites, mutex with httpsOnly * @httpsOnly Only do https sites, mutex with httpOnly */ - private function generateUrl( + function uri( boolean httpOnly, boolean httpsOnly, boolean imageExtensions = false ){ - var randomPaths = generateWords( "words:1:#randRange( 1, 5 )#" ) + var randomPaths = words( "1:#randRange( 1, 5 )#" ) .listToArray( " " ) .toList( "/" ) .lcase(); var randomHash = ""; if ( ( randRange( 1, 10 ) % 2 ) ) { - randomHash = "###generateWords( "words" )#"; + randomHash = "###words()#"; } var randomFile = ""; if ( ( randRange( 1, 10 ) % 2 ) ) { - randomFile = generateWords( "words" ); + randomFile = words(); } if ( arguments.imageExtensions ) { - randomFile &= variables.imageExtensions[ randRange( 1, variables.imageExtensions.len() ) ]; + randomFile &= variables._imageExtensions[ randRange( 1, variables._imageExtensions.len() ) ]; } else { - randomFile &= variables.extensions[ randRange( 1, variables.extensions.len() ) ]; + randomFile &= variables._extensions[ randRange( 1, variables._extensions.len() ) ]; } - return generateWebsite( argumentCollection = arguments ) & "/" & randomPaths & randomFile & randomHash; + return websiteUrl( argumentCollection = arguments ) & "/" & randomPaths & randomFile & randomHash; } /** @@ -645,7 +651,7 @@ component { * @httpOnly Only do http sites, mutex with httpsOnly * @httpsOnly Only do https sites, mutex with httpOnly */ - private function generateWebsite( boolean httpOnly, boolean httpsOnly ){ + function websiteUrl( boolean httpOnly, boolean httpsOnly ){ var prefix = "http"; if ( !isNull( arguments.httpsOnly ) ) { prefix = "https"; @@ -659,29 +665,29 @@ component { webPart = "www."; } - return "#prefix#://" & webpart & variables.webDomains[ randRange( 1, variables.webDomains.len() ) ]; + return "#prefix#://" & webpart & variables._webDomains[ randRange( 1, variables._webDomains.len() ) ]; } /** * Generate an ip address */ - private function generateIpAddress(){ + function ipAddress(){ return "#randRange( 0, 255 )#.#randRange( 0, 255 )#.#randRange( 0, 255 )#.#randRange( 0, 255 )#"; } /** * Generate a first name */ - private function generateFirstName(){ - return fNames[ randRange( 1, fNames.len() ) ]; + function firstName(){ + return variables._firstNames[ randRange( 1, variables._firstNames.len() ) ]; } /** * Generate a last name * @return {[type]} [description] */ - private function generateLastName(){ - return lNames[ randRange( 1, lNames.len() ) ]; + function lastName(){ + return variables._lastNames[ randRange( 1, variables._lastNames.len() ) ]; } /** @@ -692,7 +698,7 @@ component { * @dateFormat The date formatting to use * @timeFormat The time formmating to use */ - private function generateDateRange( + function dateRange( date from = "#createDateTime( "2010", "01", "01", "0", "0", "0" )#", date to = "#now()#", showTime = false, @@ -715,4 +721,64 @@ component { } } + /***************************** PRIVATE ****************************************/ + + /** + * Check if an incoming type exists in our default types + * + * @target The target string to check + */ + private boolean function isDefaultType( required target ){ + return variables._defaultTypes.findNoCase( arguments.target ) > 0; + } + + /** + * Generate a new mocked item, called by the mock() method when receiving arguments + * and parsing them into field models + * + * @fieldModels An array of field model structs: { name : "fieldName", type : "mocking type" } + * @index The numerical index of the item being generated + * + * @return The generated faked item + */ + private struct function generateNewItem( + required array fieldModels, + index = 1 + ){ + var result = {}; + arguments.fieldModels.each( function( field ){ + // Verify the field struct has a name, else generate it + if ( !field.keyExists( "name" ) ) { + field.name = "field" & i; + } + + // if we are a default, that is our type, otherwise string + if ( + isSimpleValue( field.type ) + && + !field.type.len() + && + isDefaultType( field.name ) + ) { + field.type = field.name; + } + + // Determine the type of field model + if ( isStruct( field.type ) ) { + // Bind the return type as a struct + field.type.$returnType = "struct"; + // The field model defines a single object relationship + result[ field.name ] = mock( argumentCollection = field.type ); + } else if ( isArray( field.type ) ) { + // The field model defines a one to many relationship + result[ field.name ] = mock( argumentCollection = field.type[ 1 ] ); + } else { + // Generate the fake data + result[ field.name ] = generateFakeData( field.type, index ); + } + } ); + + return result; + } + } diff --git a/models/adjectives.json b/models/adjectives.json new file mode 100644 index 0000000..a662cd3 --- /dev/null +++ b/models/adjectives.json @@ -0,0 +1,5177 @@ +["abased", + "abject", + "able", + "abloom", + "ablush", + "abreast", + "abridged", + "abroach", + "abroad", + "abrupt", + "abscessed", + "absolved", + "absorbed", + "abstruse", + "absurd", + "abused", + "abuzz", + "accrete", + "accrued", + "accurst", + "acerb", + "aching", + "acock", + "acold", + "acorned", + "acred", + "acrid", + "acting", + "added", + "addle", + "addorsed", + "adept", + "adjunct", + "admired", + "adnate", + "adored", + "adrift", + "adroit", + "adscript", + "adult", + "adunc", + "adust", + "advised", + "aery", + "afeard", + "afeared", + "affine", + "affined", + "afire", + "aflame", + "afloat", + "afoot", + "afoul", + "afraid", + "after", + "aftmost", + "agape", + "agaze", + "aged", + "ageing", + "ageless", + "agelong", + "aggrieved", + "aghast", + "agile", + "aging", + "agleam", + "agley", + "aglow", + "agnate", + "ago", + "agog", + "agone", + "agreed", + "aground", + "ahead", + "ahorse", + "ahull", + "aidful", + "aidless", + "ailing", + "aimless", + "ain", + "air", + "airborne", + "airless", + "airsick", + "airtight", + "ajar", + "akin", + "alar", + "alate", + "alert", + "algal", + "algid", + "algoid", + "alien", + "alight", + "alike", + "alined", + "alive", + "alleged", + "allowed", + "alloyed", + "alone", + "aloof", + "alright", + "altered", + "altern", + "alvine", + "amazed", + "amber", + "amiss", + "amok", + "amort", + "ample", + "amuck", + "amused", + "android", + "angled", + "anguine", + "anguished", + "anile", + "announced", + "ansate", + "anti", + "antic", + "antique", + "antlered", + "antlike", + "antrorse", + "anxious", + "apart", + "apeak", + "apish", + "appalled", + "applied", + "appressed", + "arcane", + "arching", + "argent", + "arid", + "armchair", + "armless", + "armored", + "aroid", + "aroused", + "arranged", + "arrant", + "arrased", + "arrhythmic", + "artful", + "artless", + "arty", + "ashake", + "ashamed", + "ashen", + "ashy", + "askance", + "askant", + "askew", + "asking", + "aslant", + "asleep", + "aslope", + "asphalt", + "asprawl", + "asquint", + "assumed", + "assured", + "astir", + "astral", + "astute", + "aswarm", + "athirst", + "atilt", + "atrip", + "attached", + "attack", + "attent", + "attired", + "attrite", + "attuned", + "audile", + "aurous", + "austere", + "averse", + "avid", + "avowed", + "awake", + "aware", + "awash", + "away", + "aweless", + "awesome", + "awestruck", + "awful", + "awheel", + "awing", + "awkward", + "awnless", + "awry", + "axile", + "azure", + "babbling", + "baccate", + "backboned", + "backhand", + "backless", + "backmost", + "backstage", + "backstair", + "backstairs", + "backswept", + "backward", + "backwoods", + "baddish", + "baffling", + "baggy", + "bairnly", + "balanced", + "balding", + "baldish", + "baleful", + "balky", + "bally", + "balmy", + "banal", + "bandaged", + "banded", + "baneful", + "bangled", + "bankrupt", + "banner", + "bannered", + "baptist", + "bar", + "barbate", + "bardic", + "bardy", + "bareback", + "barebacked", + "barefaced", + "barefoot", + "barer", + "barest", + "baric", + "barish", + "barkless", + "barky", + "barmy", + "baroque", + "barrelled", + "baseless", + "baser", + "basest", + "bashful", + "basic", + "bassy", + "bastioned", + "bated", + "battered", + "battled", + "batty", + "bausond", + "bawdy", + "beaded", + "beady", + "beaky", + "beaming", + "beamish", + "beamless", + "beamy", + "beardless", + "bearish", + "bearlike", + "beastlike", + "beastly", + "beaten", + "beating", + "beauish", + "becalmed", + "bedded", + "bedfast", + "bedight", + "bedimmed", + "bedrid", + "beechen", + "beefy", + "beery", + "beetle", + "befogged", + "begrimed", + "beguiled", + "behind", + "bellied", + "belted", + "bemazed", + "bemused", + "bended", + "bending", + "bendwise", + "bendy", + "benign", + "benthic", + "benzal", + "bereft", + "berried", + "berserk", + "besieged", + "bespoke", + "besprent", + "bestead", + "bestial", + "betrothed", + "beveled", + "biased", + "bifid", + "biform", + "bigger", + "biggest", + "biggish", + "bijou", + "bilgy", + "bilious", + "billion", + "billionth", + "bilobed", + "binate", + "biped", + "birchen", + "birdlike", + "birken", + "bistred", + "bitchy", + "bitless", + "bitten", + "bitty", + "bivalve", + "bizarre", + "blackish", + "blameful", + "blameless", + "blaring", + "blasted", + "blasting", + "blatant", + "bleary", + "blended", + "blending", + "blindfold", + "blinding", + "blinking", + "blissful", + "blissless", + "blithesome", + "bloated", + "blockish", + "blocky", + "blooded", + "bloodied", + "bloodshot", + "bloodstained", + "blooming", + "bloomless", + "bloomy", + "blotchy", + "blotto", + "blotty", + "blowhard", + "blowsy", + "blowy", + "blowzy", + "blubber", + "bluer", + "bluest", + "bluish", + "blurry", + "blushful", + "blushless", + "boarish", + "boastful", + "boastless", + "bobtail", + "bodger", + "bodied", + "boding", + "boggy", + "bogus", + "bomb", + "bombproof", + "boneless", + "bonism", + "bonkers", + "bony", + "bonzer", + "bookish", + "bookless", + "boorish", + "booted", + "bootleg", + "bootless", + "boozy", + "bordered", + "boring", + "bosker", + "bosky", + "bosom", + "bosomed", + "bossy", + "botchy", + "bouffant", + "boughten", + "bouilli", + "bouncy", + "bounded", + "bounden", + "boundless", + "bousy", + "bovid", + "bovine", + "bowing", + "boxlike", + "boyish", + "bracing", + "brackish", + "bractless", + "braggart", + "bragging", + "braided", + "brainless", + "brainsick", + "brainy", + "brakeless", + "brambly", + "branching", + "branchless", + "branchlike", + "branny", + "brashy", + "brassy", + "brattish", + "bratty", + "braver", + "bravest", + "braving", + "brawny", + "brazen", + "breaking", + "breakneck", + "breasted", + "breathless", + "breathy", + "breechless", + "breeding", + "breezeless", + "breezy", + "brickle", + "bricky", + "bridgeless", + "briefless", + "brilliant", + "brimful", + "brimless", + "brimming", + "brinded", + "brindle", + "brindled", + "brinish", + "briny", + "bristly", + "brittle", + "broadband", + "broadcast", + "broadish", + "broadloom", + "broadside", + "broch", + "broguish", + "bronzy", + "broody", + "broomy", + "browless", + "brownish", + "browny", + "bruising", + "brumal", + "brumous", + "brunet", + "brunette", + "brushless", + "brushy", + "brutal", + "brute", + "brutelike", + "brutish", + "bubbly", + "buccal", + "buckish", + "buckram", + "buckshee", + "buckskin", + "bucktooth", + "bucktoothed", + "budless", + "buggy", + "bughouse", + "buirdly", + "bulbar", + "bulbous", + "bulgy", + "bulky", + "bullate", + "bullied", + "bullish", + "bumbling", + "bumptious", + "bumpy", + "bunchy", + "bunted", + "buoyant", + "burdened", + "burghal", + "buried", + "burlesque", + "burly", + "burry", + "bursal", + "bursting", + "bushy", + "busied", + "buskined", + "bustled", + "busty", + "buttocked", + "buxom", + "bygone", + "byssal", + "caboched", + "caboshed", + "caddish", + "cadenced", + "cadent", + "cadgy", + "cagey", + "cagy", + "caitiff", + "calcic", + "calfless", + "caller", + "callous", + "callow", + "calmy", + "campy", + "cancelled", + "cancrine", + "cancroid", + "candent", + "candied", + "canine", + "cankered", + "canny", + "canty", + "cany", + "capeskin", + "caprine", + "captious", + "captive", + "cardboard", + "carefree", + "careful", + "careless", + "careworn", + "caring", + "carking", + "carlish", + "carmine", + "carnose", + "carpal", + "carping", + "carsick", + "carven", + "casebook", + "casteless", + "castled", + "catching", + "catchweight", + "catchy", + "cattish", + "catty", + "caudate", + "cauline", + "causal", + "causeless", + "cautious", + "cayenned", + "ceaseless", + "cecal", + "cedarn", + "ceilinged", + "censured", + "centered", + "centred", + "centric", + "centrist", + "centum", + "cercal", + "cerise", + "cerous", + "certain", + "cervid", + "cervine", + "cestoid", + "chaffless", + "chaffy", + "chainless", + "chairborne", + "chaliced", + "chalky", + "chambered", + "chanceful", + "chanceless", + "chancy", + "changeful", + "changeless", + "changing", + "chapeless", + "chargeful", + "chargeless", + "charming", + "charmless", + "charry", + "chartered", + "chartless", + "chary", + "chasmal", + "chasmic", + "chasmy", + "chasseur", + "chaster", + "chastest", + "chastised", + "chatty", + "checkered", + "checky", + "cheeky", + "cheerful", + "cheerless", + "cheerly", + "cheery", + "cheesy", + "chelate", + "chemic", + "chequy", + "cherty", + "chestnut", + "chesty", + "chevroned", + "chewy", + "chichi", + "chiefless", + "chiefly", + "chiffon", + "childing", + "childish", + "childless", + "childlike", + "childly", + "chill", + "chilly", + "chin", + "chintzy", + "chipper", + "chippy", + "chirpy", + "chiseled", + "chiselled", + "chlorous", + "chocker", + "choicer", + "chokey", + "choking", + "choky", + "chondral", + "choosey", + "choosy", + "chopping", + "choppy", + "choral", + "chordal", + "chordate", + "choric", + "chrismal", + "chronic", + "chthonic", + "chubby", + "chuffy", + "chummy", + "chunky", + "churchless", + "churchly", + "churchward", + "churchy", + "churlish", + "churning", + "chymous", + "cichlid", + "cirrate", + "cirrose", + "cirsoid", + "cissoid", + "cissy", + "cisted", + "cistic", + "citrous", + "citrus", + "clamant", + "clammy", + "clankless", + "clannish", + "clasping", + "classless", + "classy", + "clastic", + "clathrate", + "clausal", + "claustral", + "clavate", + "clawless", + "clayey", + "clayish", + "cleanly", + "cleansing", + "clerkish", + "clerkly", + "cliffy", + "clingy", + "clinquant", + "clipping", + "cliquey", + "cliquish", + "cliquy", + "clitic", + "clockwise", + "cloddish", + "cloddy", + "clogging", + "cloggy", + "cloistered", + "cloistral", + "clonic", + "closer", + "closest", + "clotty", + "clouded", + "cloudless", + "cloudy", + "clovered", + "clownish", + "cloying", + "clubby", + "clucky", + "clueless", + "clumpy", + "clumsy", + "clustered", + "coaly", + "coarser", + "coarsest", + "coastal", + "coastward", + "coastwise", + "coated", + "coatless", + "coccal", + "coccoid", + "cockney", + "cocksure", + "cocky", + "coffered", + "cogent", + "cognate", + "coky", + "coldish", + "collapsed", + "collect", + "colloid", + "colly", + "coltish", + "columned", + "comal", + "comate", + "combined", + "combless", + "combust", + "comely", + "comfy", + "coming", + "commie", + "commo", + "comose", + "compact", + "compelled", + "compleat", + "complete", + "compo", + "composed", + "concave", + "conceived", + "concerned", + "conchal", + "conchate", + "concise", + "condemned", + "condign", + "conferred", + "confined", + "confirmed", + "confused", + "conjoined", + "conjoint", + "conjunct", + "connate", + "conoid", + "conscious", + "constrained", + "consumed", + "contained", + "contrate", + "contrite", + "contrived", + "controlled", + "contused", + "convex", + "convict", + "convinced", + "cooing", + "cooking", + "coolish", + "copied", + "coppiced", + "corbelled", + "cordate", + "corded", + "cordial", + "cordless", + "coreless", + "corking", + "corky", + "cormous", + "cornered", + "cornute", + "corny", + "correct", + "corrupt", + "corvine", + "cosher", + "costal", + "costate", + "costive", + "costly", + "costumed", + "cottaged", + "couchant", + "counter", + "countless", + "courant", + "couthie", + "couthy", + "coxal", + "coyish", + "cozy", + "crabbed", + "crabby", + "crablike", + "crabwise", + "crackbrained", + "crackers", + "cracking", + "crackjaw", + "crackle", + "crackling", + "crackly", + "crackpot", + "craftless", + "crafty", + "cragged", + "craggy", + "cranky", + "crannied", + "crashing", + "craven", + "crawling", + "crawly", + "creaky", + "creamlaid", + "creamy", + "creasy", + "credent", + "creedal", + "creepy", + "crenate", + "crescive", + "cressy", + "crestless", + "cricoid", + "crimeless", + "crimpy", + "crimson", + "crinal", + "cringing", + "crinite", + "crinkly", + "crinoid", + "crinose", + "crippling", + "crispate", + "crispy", + "crisscross", + "cristate", + "croaky", + "crookback", + "crooked", + "crosiered", + "crossbred", + "crosstown", + "crosswise", + "croupous", + "croupy", + "crowded", + "crowing", + "crowning", + "crownless", + "crucial", + "cruder", + "crudest", + "cruel", + "crumbly", + "crumby", + "crummy", + "crumpled", + "crunchy", + "crural", + "crushing", + "crustal", + "crusted", + "crustless", + "crusty", + "crying", + "cryptal", + "cryptic", + "ctenoid", + "cubbish", + "cubist", + "cuboid", + "cultic", + "cultish", + "cultrate", + "cumbrous", + "cunning", + "cupric", + "cuprous", + "curbless", + "curdy", + "cureless", + "curly", + "currish", + "cursed", + "cursing", + "cursive", + "curtate", + "curving", + "curvy", + "cushy", + "cuspate", + "cussed", + "custom", + "cutcha", + "cuter", + "cutest", + "cyan", + "cycloid", + "cyclone", + "cymoid", + "cymose", + "cystoid", + "cytoid", + "czarist", + "daedal", + "daffy", + "daimen", + "dainty", + "daisied", + "dam", + "damaged", + "damfool", + "damning", + "dampish", + "dancing", + "dangling", + "dapper", + "dapple", + "dappled", + "daring", + "darkish", + "darkling", + "darksome", + "dashing", + "dastard", + "dated", + "dateless", + "dauby", + "dauntless", + "daylong", + "daytime", + "deathful", + "deathless", + "deathlike", + "deathly", + "deathy", + "debased", + "debauched", + "deceased", + "decent", + "declared", + "decreed", + "decurved", + "dedal", + "deedless", + "defaced", + "defiled", + "defined", + "deflexed", + "deformed", + "defunct", + "deictic", + "deism", + "deject", + "deltoid", + "demure", + "dendroid", + "denser", + "densest", + "dentate", + "dentoid", + "deposed", + "depraved", + "depressed", + "deprived", + "deranged", + "dermal", + "dermic", + "dermoid", + "dernier", + "descant", + "described", + "desert", + "deserved", + "designed", + "desired", + "desmoid", + "despised", + "destined", + "detached", + "detailed", + "deuced", + "deviled", + "devoid", + "devout", + "dewlapped", + "dewy", + "dextral", + "dextrorse", + "dextrous", + "diarch", + "dicey", + "dickey", + "dicky", + "diet", + "diffuse", + "diffused", + "dighted", + "diglot", + "dilute", + "dimmest", + "dimming", + "dimply", + "dingbats", + "dingy", + "dinkies", + "dinky", + "diplex", + "diploid", + "dippy", + "direful", + "direr", + "direst", + "dirty", + "discalced", + "disclosed", + "discoid", + "discreet", + "discrete", + "diseased", + "disgraced", + "disguised", + "dishy", + "disjoined", + "disjoint", + "disjunct", + "disliked", + "dispensed", + "disperse", + "dispersed", + "displayed", + "displeased", + "disposed", + "dissolved", + "distal", + "distent", + "distilled", + "distinct", + "distrait", + "distraught", + "distressed", + "disturbed", + "distyle", + "disused", + "divers", + "diverse", + "divorced", + "dizzied", + "dizzy", + "docile", + "dockside", + "doddered", + "dodgy", + "dogged", + "dogging", + "doggish", + "doggone", + "doggoned", + "doggy", + "doglike", + "doited", + "doleful", + "dolesome", + "dollish", + "doltish", + "donnard", + "donnered", + "donnish", + "donsie", + "dopey", + "dopy", + "dormant", + "dormie", + "dormy", + "dorty", + "dotal", + "doting", + "dotted", + "doty", + "doubling", + "doubtful", + "doubting", + "doubtless", + "doughy", + "dovelike", + "dovetailed", + "dovish", + "dowdy", + "dowie", + "downbeat", + "downhill", + "downrange", + "downright", + "downstage", + "downstair", + "downstairs", + "downstate", + "downstream", + "downwind", + "dozen", + "dozenth", + "dozing", + "dozy", + "draffy", + "drafty", + "dragging", + "draggy", + "draining", + "drastic", + "dratted", + "draughty", + "dreadful", + "dreamful", + "dreamless", + "dreamlike", + "dreamy", + "dreary", + "dreggy", + "dressy", + "drier", + "driest", + "driftless", + "drifty", + "drippy", + "driven", + "drizzly", + "droning", + "dronish", + "droopy", + "dropping", + "dropsied", + "drossy", + "droughty", + "drouthy", + "drowsing", + "drowsy", + "drudging", + "drumly", + "drunken", + "dryer", + "ducal", + "duckbill", + "duckie", + "ducky", + "ductile", + "duddy", + "dudish", + "dulcet", + "dullish", + "dumbstruck", + "dumpish", + "dun", + "dungy", + "dural", + "duskish", + "dusky", + "dustless", + "dustproof", + "dwarfish", + "dyeline", + "dying", + "earnest", + "earthborn", + "earthbound", + "earthen", + "earthly", + "earthquaked", + "earthward", + "earthy", + "easeful", + "eastbound", + "eastmost", + "eastward", + "eaten", + "eating", + "ebon", + "eccrine", + "ecru", + "edgeless", + "edging", + "edgy", + "eely", + "eerie", + "eery", + "effete", + "effluent", + "effuse", + "egal", + "eighteen", + "eighteenth", + "eightfold", + "eighty", + "elapsed", + "elder", + "eldest", + "eldritch", + "elect", + "elfin", + "elfish", + "elite", + "elmy", + "elvish", + "embowed", + "emersed", + "emptied", + "enarched", + "enate", + "encased", + "enceinte", + "endarch", + "endless", + "endmost", + "endorsed", + "endways", + "enforced", + "engorged", + "engrailed", + "engrained", + "engraved", + "enhanced", + "enjambed", + "enlarged", + "enorm", + "enough", + "enow", + "enraged", + "enrapt", + "enrolled", + "enslaved", + "enthralled", + "entire", + "entranced", + "enured", + "enwrapped", + "equine", + "equipped", + "erased", + "erect", + "ermined", + "erose", + "errant", + "errhine", + "erring", + "ersatz", + "erstwhile", + "escaped", + "essive", + "estranged", + "estrous", + "eterne", + "ethic", + "ethmoid", + "ethnic", + "eustyle", + "evens", + "evoked", + "exact", + "exarch", + "exchanged", + "excused", + "exempt", + "exhaled", + "expert", + "expired", + "exposed", + "exsert", + "extant", + "extinct", + "extrorse", + "eyeless", + "fabled", + "faceless", + "facete", + "factious", + "faddish", + "faddy", + "faded", + "fadeless", + "fading", + "faecal", + "failing", + "faintish", + "fairish", + "faithful", + "faithless", + "falcate", + "falser", + "falsest", + "fameless", + "famished", + "famous", + "fancied", + "fanfold", + "fangled", + "fangless", + "farand", + "farci", + "farfetched", + "farming", + "farouche", + "farrow", + "farther", + "farthest", + "fatal", + "fated", + "fateful", + "fatigue", + "fatigued", + "fatless", + "fatter", + "fattest", + "fattish", + "faucal", + "faucial", + "faultless", + "faulty", + "faunal", + "favored", + "favoured", + "fearful", + "fearless", + "fearsome", + "feastful", + "feathered", + "featured", + "febrile", + "fecal", + "feckless", + "fecund", + "federalist", + "feeble", + "feeblish", + "feeling", + "feisty", + "feline", + "felon", + "felsic", + "fenny", + "feodal", + "feral", + "ferine", + "ferny", + "fervent", + "fervid", + "fesswise", + "festal", + "festive", + "fetching", + "fetial", + "fetid", + "feudal", + "fewer", + "fibered", + "fibroid", + "fibrous", + "fickle", + "fictile", + "fictive", + "fiddling", + "fiddly", + "fiendish", + "fiercer", + "fiercest", + "fifteen", + "fifteenth", + "fifty", + "filar", + "filial", + "filose", + "filthy", + "filtrable", + "financed", + "fineable", + "finer", + "finest", + "fingered", + "finished", + "finite", + "finless", + "finny", + "fireproof", + "firry", + "fishy", + "fissile", + "fistic", + "fitchy", + "fitful", + "fitted", + "fitter", + "fitting", + "fivefold", + "fizzy", + "flabby", + "flaccid", + "flagging", + "flaggy", + "flagrant", + "flameproof", + "flaming", + "flamy", + "flappy", + "flaring", + "flashy", + "flatling", + "flattest", + "flattish", + "flaunty", + "flawless", + "flawy", + "flaxen", + "fleckless", + "fledgeling", + "fledgling", + "fledgy", + "fleeceless", + "fleecy", + "fleeing", + "fleeting", + "fleshless", + "fleshly", + "fleshy", + "flexile", + "flightless", + "flighty", + "flimsy", + "flinty", + "flippant", + "flipping", + "flitting", + "floaty", + "floccose", + "floccus", + "flooded", + "floodlit", + "floppy", + "florid", + "flory", + "flossy", + "floury", + "flowered", + "flowing", + "fluent", + "fluffy", + "flukey", + "fluky", + "flurried", + "fluted", + "fluty", + "flyweight", + "foamless", + "foamy", + "focused", + "focussed", + "foetal", + "foetid", + "fogbound", + "foggy", + "fogless", + "folded", + "folkish", + "folklore", + "folksy", + "fontal", + "foodless", + "foolish", + "foolproof", + "footed", + "footless", + "footling", + "footsore", + "footworn", + "foppish", + "forceful", + "forceless", + "forehand", + "foremost", + "forenamed", + "foresaid", + "foreseen", + "forespent", + "foretold", + "forfeit", + "forky", + "former", + "formless", + "fornent", + "forspent", + "forte", + "forthright", + "fortis", + "forworn", + "foughten", + "fourfold", + "fourscore", + "foursquare", + "fourteenth", + "foxy", + "fozy", + "fractious", + "fractured", + "fragile", + "fragrant", + "frantic", + "fratchy", + "fraudful", + "frazzled", + "freakish", + "freaky", + "freckly", + "freebie", + "freeborn", + "freeing", + "freer", + "freest", + "frenzied", + "frequent", + "freshman", + "fretful", + "fretted", + "fretty", + "fribble", + "friended", + "friendless", + "frightened", + "frightful", + "frilly", + "fringeless", + "frisky", + "frizzly", + "frizzy", + "frockless", + "frolic", + "fronded", + "frontal", + "frontier", + "frontless", + "frosted", + "frostless", + "frostlike", + "frosty", + "frothy", + "froward", + "frowsty", + "frowsy", + "frowzy", + "frozen", + "fructed", + "frugal", + "fruited", + "fruitful", + "fruitless", + "fruity", + "frumpish", + "frumpy", + "frustrate", + "fubsy", + "fucoid", + "fugal", + "fulfilled", + "fulgent", + "fulgid", + "fulsome", + "fulvous", + "fumy", + "funded", + "funest", + "fungal", + "fungoid", + "fungous", + "funky", + "furcate", + "furry", + "furthest", + "furtive", + "furzy", + "fuscous", + "fusil", + "fusile", + "fussy", + "fustian", + "fusty", + "futile", + "fuzzy", + "gabbroid", + "gabled", + "gadoid", + "gadrooned", + "gaga", + "gainful", + "gainless", + "gainly", + "gaited", + "galliard", + "galling", + "gallooned", + "galore", + "gamer", + "gamesome", + "gamest", + "gamey", + "gamic", + "gammy", + "gamy", + "gangling", + "gangly", + "ganoid", + "gaping", + "gardant", + "garish", + "garni", + "gassy", + "gated", + "gateless", + "gaudy", + "gaumless", + "gauzy", + "gawky", + "gawsy", + "gearless", + "geegaw", + "gelded", + "gelid", + "gemel", + "gemmate", + "gemmy", + "genal", + "genial", + "genic", + "genteel", + "genty", + "georgic", + "germane", + "gestic", + "gewgaw", + "ghastful", + "ghastly", + "ghostly", + "ghoulish", + "gibbose", + "gibbous", + "giddied", + "giddy", + "gifted", + "giggly", + "gilded", + "gimcrack", + "gimlet", + "gimpy", + "girlish", + "girly", + "giving", + "glabrate", + "glabrous", + "glacial", + "gladsome", + "glaikit", + "glairy", + "glandered", + "glaring", + "glary", + "glasslike", + "glassy", + "gleeful", + "gleesome", + "gleety", + "glenoid", + "glial", + "glibber", + "glibbest", + "globate", + "globoid", + "globose", + "gloomful", + "glooming", + "gloomy", + "glossies", + "glossy", + "glottic", + "glowing", + "gluey", + "glummer", + "glummest", + "glumpy", + "glutted", + "glyphic", + "glyptic", + "gnarly", + "gnathic", + "gneissic", + "gneissoid", + "gnomic", + "gnomish", + "goalless", + "goateed", + "goatish", + "godless", + "godlike", + "godly", + "goitrous", + "goodish", + "goodly", + "gooey", + "goofy", + "goosey", + "goosy", + "gorgeous", + "gormless", + "gorsy", + "gory", + "gouty", + "gowaned", + "goyish", + "graceful", + "graceless", + "gracile", + "gracious", + "gradely", + "grainy", + "grapey", + "grapy", + "grasping", + "graspless", + "grassy", + "grateful", + "grating", + "gratis", + "grave", + "gravel", + "graveless", + "gravest", + "gravid", + "grayish", + "greening", + "greenish", + "greensick", + "greyish", + "griefless", + "grieving", + "grimmer", + "grimmest", + "grimy", + "gripping", + "gripple", + "grippy", + "grisly", + "gristly", + "gritty", + "grizzled", + "groggy", + "groovy", + "groping", + "grotesque", + "grotty", + "grouchy", + "groundless", + "grouty", + "grubby", + "grudging", + "gruesome", + "gruffish", + "grumbly", + "grummer", + "grummest", + "grumose", + "grumous", + "grumpy", + "gruntled", + "guardant", + "guarded", + "guardless", + "guideless", + "guiding", + "guileful", + "guileless", + "guiltless", + "guilty", + "gular", + "gulfy", + "gummous", + "gummy", + "gumptious", + "gunless", + "gushy", + "gusty", + "gutless", + "gutsy", + "gutta", + "guttate", + "gyral", + "gyrate", + "gyrose", + "habile", + "hackly", + "hackneyed", + "hadal", + "haemal", + "haemic", + "haggish", + "hairless", + "hairlike", + "halest", + "halftone", + "hallowed", + "haloid", + "halting", + "hamate", + "hammered", + "hammy", + "handed", + "handled", + "handless", + "handmade", + "handsome", + "handworked", + "handwrought", + "handy", + "hangdog", + "hapless", + "haploid", + "haptic", + "harassed", + "hardback", + "hardened", + "hardwood", + "harlot", + "harmful", + "harmless", + "harnessed", + "harried", + "hastate", + "hasty", + "hatching", + "hated", + "hateful", + "hatless", + "hatted", + "haughty", + "haunted", + "haunting", + "hawkish", + "hawklike", + "haywire", + "hazy", + "headed", + "headfirst", + "headless", + "headlong", + "headmost", + "headstrong", + "heady", + "healing", + "healthful", + "healthy", + "heaping", + "heapy", + "hearted", + "heartfelt", + "hearties", + "heartless", + "heartsome", + "hearty", + "heated", + "heathen", + "heathy", + "heating", + "heavies", + "heaving", + "hectic", + "hedgy", + "heedful", + "heedless", + "heelless", + "hefty", + "heinous", + "heirless", + "helmless", + "helpful", + "helpless", + "hemal", + "hempen", + "hempy", + "hennaed", + "herbaged", + "herbal", + "herbless", + "herby", + "here", + "hidden", + "highbrow", + "highest", + "hilding", + "hilly", + "hinder", + "hindmost", + "hindward", + "hipper", + "hippest", + "hippy", + "hircine", + "hirsute", + "hispid", + "hissing", + "histie", + "histoid", + "hitchy", + "hither", + "hiveless", + "hivelike", + "hobnail", + "hobnailed", + "hoggish", + "hoiden", + "holey", + "hollow", + "holmic", + "holstered", + "homebound", + "homeless", + "homelike", + "homely", + "homesick", + "homespun", + "homeward", + "homey", + "homy", + "honest", + "honeyed", + "honied", + "hoodless", + "hoofless", + "hooly", + "hopeful", + "hopeless", + "hopping", + "horal", + "hornish", + "hornless", + "hornlike", + "horny", + "horrent", + "horrid", + "horsey", + "horsy", + "hotfoot", + "hotshot", + "hotter", + "hottest", + "hotting", + "hottish", + "hourlong", + "hourly", + "housebound", + "houseless", + "hoven", + "howling", + "hoyden", + "hueless", + "huffish", + "huffy", + "huger", + "hugest", + "hulking", + "hulky", + "humbler", + "humdrum", + "humic", + "humid", + "hummel", + "humpbacked", + "humpy", + "hunchback", + "hunchbacked", + "hundredth", + "hungry", + "hunky", + "hunted", + "hurling", + "hurried", + "hurtful", + "hurtless", + "hurtling", + "husky", + "hydric", + "hydro", + "hydroid", + "hydrous", + "hymnal", + "hyoid", + "hyphal", + "hypnoid", + "icky", + "ictic", + "idem", + "idled", + "idlest", + "idling", + "iffy", + "ignored", + "imbued", + "immane", + "immense", + "immersed", + "immune", + "impel", + "impelled", + "impish", + "implied", + "imposed", + "improved", + "impure", + "inane", + "inapt", + "inboard", + "inborn", + "inbound", + "inbred", + "inbreed", + "inby", + "incased", + "incensed", + "incised", + "incog", + "increased", + "incrust", + "incult", + "incurved", + "incuse", + "indign", + "indoor", + "indrawn", + "inept", + "infect", + "infelt", + "infirm", + "inflamed", + "inflexed", + "inform", + "informed", + "ingrain", + "ingrained", + "ingrate", + "ingrown", + "inhaled", + "inhumed", + "injured", + "inky", + "inlaid", + "inmost", + "innate", + "inphase", + "inrush", + "insane", + "inscribed", + "inshore", + "insides", + "inspired", + "instinct", + "insured", + "intact", + "intense", + "intent", + "intern", + "interred", + "intime", + "intoed", + "intoned", + "intown", + "introrse", + "inured", + "involved", + "inward", + "inwrought", + "irate", + "ireful", + "irksome", + "itching", + "itchy", + "ivied", + "jaded", + "jadish", + "jagged", + "jaggy", + "jammy", + "jangly", + "jannock", + "japan", + "jarring", + "jasp", + "jaundiced", + "jazzy", + "jealous", + "jejune", + "jellied", + "jerky", + "jessant", + "jestful", + "jesting", + "jet", + "jetting", + "jetty", + "jeweled", + "jewelled", + "jiggered", + "jiggish", + "jiggly", + "jingly", + "jobless", + "jocose", + "jocund", + "jointed", + "jointless", + "jointured", + "joking", + "jolty", + "jouncing", + "jowly", + "joyful", + "joyless", + "joyous", + "jubate", + "jugal", + "jugate", + "juiceless", + "juicy", + "jumbled", + "jumpy", + "jungly", + "jural", + "jurant", + "jussive", + "jutting", + "kacha", + "kaput", + "karmic", + "karstic", + "kayoed", + "kerchiefed", + "keyless", + "khaki", + "kidnapped", + "killing", + "kilted", + "kindless", + "kindly", + "kindred", + "kingless", + "kinglike", + "kingly", + "kinky", + "kinless", + "kirtled", + "kittle", + "klephtic", + "klutzy", + "knaggy", + "knavish", + "kneeling", + "knickered", + "knifeless", + "knightless", + "knightly", + "knitted", + "knobby", + "knotless", + "knotted", + "knotty", + "knowing", + "knuckly", + "knurly", + "kookie", + "kooky", + "kosher", + "kutcha", + "labelled", + "labile", + "labored", + "laboured", + "labrid", + "labroid", + "lacking", + "lacy", + "laddish", + "laden", + "laggard", + "laic", + "lairy", + "laky", + "lambdoid", + "lambent", + "lamblike", + "lamer", + "lamest", + "laming", + "lanate", + "landed", + "landless", + "landscaped", + "landward", + "languid", + "lanky", + "lanose", + "lapelled", + "lapstrake", + "larboard", + "larger", + "largest", + "largish", + "larine", + "larkish", + "larky", + "larval", + "lashing", + "lasting", + "lated", + "lateen", + "later", + "latest", + "lathlike", + "lathy", + "latish", + "latter", + "latticed", + "laurelled", + "lavish", + "lawful", + "lawless", + "lawny", + "leachy", + "leaden", + "leadless", + "leady", + "leafless", + "leafy", + "leaky", + "leaning", + "leaping", + "learned", + "leary", + "leathern", + "ledgy", + "leery", + "leftward", + "legged", + "leggy", + "legit", + "legless", + "leisure", + "leisured", + "lengthways", + "lengthwise", + "lengthy", + "lenis", + "lenten", + "lentic", + "lento", + "lentoid", + "leprose", + "leprous", + "lettered", + "licenced", + "licensed", + "licit", + "lidded", + "lidless", + "liege", + "lifeful", + "lifeless", + "lifelike", + "lifelong", + "lighted", + "lightfast", + "lightful", + "lightish", + "lightless", + "lightsome", + "lightweight", + "lignite", + "likely", + "lilied", + "limbate", + "limbless", + "limey", + "limpid", + "limy", + "liney", + "lingual", + "linty", + "liny", + "lipless", + "lipoid", + "lippy", + "lissom", + "lissome", + "listless", + "lither", + "lithesome", + "lithest", + "lithic", + "litho", + "lithoid", + "litten", + "littler", + "littlest", + "livelong", + "lively", + "livid", + "loaded", + "loamy", + "loathful", + "loathly", + "loathsome", + "lobar", + "lobate", + "lobose", + "lofty", + "logy", + "lonesome", + "longer", + "longhand", + "longing", + "longish", + "longsome", + "longwall", + "longwise", + "looking", + "loonies", + "loopy", + "looser", + "loosest", + "lordless", + "lordly", + "losel", + "losing", + "lossy", + "lotic", + "loudish", + "lounging", + "louring", + "loury", + "lousy", + "loutish", + "louvered", + "louvred", + "loveless", + "lovelorn", + "lovely", + "lovesick", + "lovesome", + "lowly", + "loyal", + "lozenged", + "lubric", + "lucent", + "lucid", + "luckless", + "lukewarm", + "lumpen", + "lumpish", + "lunate", + "lupine", + "lurdan", + "lurid", + "luscious", + "lushy", + "lustful", + "lustral", + "lustred", + "lustrous", + "lusty", + "lying", + "lymphoid", + "lyrate", + "lyric", + "macled", + "madcap", + "maddest", + "madding", + "maigre", + "mainstream", + "maintained", + "makeless", + "makeshift", + "malar", + "male", + "malign", + "malty", + "mammoth", + "man", + "maneless", + "manful", + "mangey", + "mangy", + "manic", + "manky", + "manlike", + "mannered", + "mannish", + "mansard", + "mantic", + "many", + "marching", + "mardy", + "marish", + "maroon", + "married", + "marshy", + "masking", + "massive", + "massy", + "mastless", + "mastoid", + "matchless", + "mated", + "matey", + "matin", + "matted", + "mature", + "maudlin", + "maungy", + "mawkish", + "maxi", + "mazy", + "meager", + "meagre", + "meaning", + "measled", + "measly", + "measured", + "meaty", + "medley", + "melic", + "mellow", + "mensal", + "menseful", + "menseless", + "mere", + "merest", + "merging", + "mesarch", + "meshed", + "mesic", + "messier", + "messy", + "metalled", + "mettled", + "mickle", + "middling", + "midget", + "midi", + "midmost", + "midship", + "midships", + "miffy", + "mighty", + "migrant", + "milkless", + "million", + "millionth", + "millrun", + "mimic", + "mincing", + "minded", + "mindful", + "mindless", + "mingy", + "mini", + "minim", + "minion", + "minute", + "mirky", + "mirthful", + "mirthless", + "miry", + "mis", + "misformed", + "mislaid", + "misproud", + "missive", + "misty", + "mistyped", + "misused", + "mitered", + "mizzen", + "mnemic", + "moanful", + "mobbish", + "model", + "modeled", + "modest", + "modish", + "molal", + "molar", + "moldy", + "molten", + "monarch", + "moneyed", + "monger", + "mongrel", + "monied", + "monism", + "monkish", + "mono", + "monstrous", + "montane", + "monthly", + "mony", + "moody", + "moonish", + "moonless", + "moonlit", + "moonstruck", + "moony", + "moory", + "mopey", + "mopy", + "mordant", + "moreish", + "morish", + "morose", + "mossy", + "motey", + "mothy", + "motile", + "motored", + "mottled", + "mounted", + "mournful", + "mousey", + "mousy", + "mouthless", + "mouthy", + "moveless", + "mowburnt", + "mucid", + "mucking", + "muckle", + "mucky", + "mucoid", + "muddy", + "muggy", + "muley", + "mulish", + "mulley", + "mumchance", + "mundane", + "mural", + "murine", + "murky", + "murrey", + "muscid", + "muscly", + "museful", + "mushy", + "musing", + "musky", + "mussy", + "mustached", + "musty", + "mutant", + "muted", + "muzzy", + "mythic", + "nacred", + "nagging", + "naggy", + "naiant", + "naif", + "nailless", + "naissant", + "naive", + "nameless", + "naming", + "napless", + "napping", + "nappy", + "nary", + "nascent", + "nasty", + "natant", + "natty", + "naughty", + "nauseous", + "needful", + "needless", + "needy", + "negroid", + "neighbor", + "neighbour", + "nephric", + "nerval", + "nervate", + "nerveless", + "nervine", + "nervy", + "nescient", + "nested", + "nestlike", + "netted", + "nettly", + "neural", + "neuron", + "neuter", + "newborn", + "newish", + "newsless", + "newsy", + "nicer", + "nicest", + "nifty", + "niggard", + "niggling", + "nightless", + "nightlong", + "nightly", + "nimble", + "nimbused", + "ninefold", + "nineteen", + "ninety", + "nipping", + "nippy", + "nitid", + "nitty", + "nival", + "nobby", + "nocent", + "nodal", + "nodding", + "nodose", + "nodous", + "noiseless", + "noisette", + "noisome", + "noisy", + "nonplused", + "nonplussed", + "nonstick", + "northmost", + "northward", + "nosey", + "notal", + "notchy", + "noted", + "noteless", + "noticed", + "notour", + "novel", + "novice", + "noxious", + "nubbly", + "nubile", + "nudist", + "numbing", + "nuptial", + "nutant", + "nutlike", + "nutmegged", + "nutty", + "nymphal", + "oafish", + "oaken", + "oarless", + "oaten", + "obese", + "oblate", + "obliged", + "oblique", + "oblong", + "obscene", + "obscure", + "observed", + "obtect", + "obtuse", + "obverse", + "occult", + "ocher", + "ochre", + "ocker", + "oddball", + "offbeat", + "offhand", + "offish", + "offscreen", + "offshore", + "offside", + "often", + "oily", + "okay", + "olden", + "older", + "oldest", + "olid", + "only", + "onshore", + "onside", + "onstage", + "onward", + "oozing", + "oozy", + "ornate", + "orphan", + "ortho", + "oscine", + "osiered", + "osmic", + "osmous", + "otic", + "outback", + "outboard", + "outbound", + "outbred", + "outcast", + "outcaste", + "outdone", + "outdoor", + "outland", + "outlaw", + "outlined", + "outmost", + "outraged", + "outright", + "outsize", + "outsized", + "outspread", + "outworn", + "ovate", + "over", + "overt", + "ovine", + "ovoid", + "owing", + "owlish", + "owllike", + "packaged", + "padded", + "pagan", + "painful", + "painless", + "paler", + "palest", + "paling", + "palish", + "pallid", + "pally", + "palmar", + "palmate", + "palmy", + "palpate", + "palsied", + "paltry", + "paly", + "pan", + "paneled", + "panniered", + "panzer", + "papist", + "pappose", + "pappy", + "par", + "pardine", + "parklike", + "parky", + "parlous", + "parol", + "parotid", + "parted", + "partite", + "pass", + "passant", + "passless", + "pasteboard", + "pasted", + "pastel", + "pasties", + "pasty", + "patchy", + "patent", + "pathic", + "pathless", + "patient", + "paunchy", + "pausal", + "pauseful", + "pauseless", + "pavid", + "pawky", + "payoff", + "peaceful", + "peaceless", + "peachy", + "peaked", + "peaky", + "pearlized", + "peaty", + "pebbly", + "peccant", + "peckish", + "pedal", + "pedate", + "peddling", + "peeling", + "peerless", + "peevish", + "peewee", + "peltate", + "pelting", + "pencilled", + "pendant", + "pendent", + "pending", + "penile", + "pennate", + "pennied", + "pennoned", + "pensile", + "pensive", + "peppy", + "perceived", + "percent", + "percoid", + "perished", + "perjured", + "perky", + "perplexed", + "perverse", + "pesky", + "petalled", + "petite", + "petrous", + "pettish", + "pewter", + "phaseless", + "phasic", + "phasmid", + "phatic", + "phlegmy", + "phocine", + "phonal", + "phoney", + "phonic", + "phony", + "photic", + "phrenic", + "phthisic", + "phylloid", + "physic", + "piano", + "picked", + "pickled", + "picky", + "pictured", + "piddling", + "piebald", + "piecemeal", + "piercing", + "piggie", + "piggish", + "pillaged", + "pillared", + "pilose", + "pimpled", + "pimply", + "pinchbeck", + "piney", + "pinguid", + "pinkish", + "pinnate", + "pinpoint", + "piny", + "pious", + "pipeless", + "pipelike", + "piping", + "pipy", + "piquant", + "piscine", + "pitchy", + "pithy", + "pitted", + "placeless", + "placid", + "placoid", + "plagal", + "plaguey", + "plaguy", + "plaided", + "plaintive", + "plangent", + "plantar", + "plantless", + "plashy", + "plastered", + "plastics", + "plated", + "platy", + "plausive", + "playful", + "pleading", + "pleasing", + "plebby", + "pleural", + "pliant", + "plical", + "plicate", + "plodding", + "plosive", + "plotful", + "plotless", + "plucky", + "plumaged", + "plumate", + "plumbic", + "plumbless", + "plumbous", + "plummy", + "plumose", + "plumy", + "plusher", + "plushest", + "poachy", + "pockmarked", + "pocky", + "podgy", + "poignant", + "pointing", + "pointless", + "pokey", + "pokies", + "poky", + "polished", + "polite", + "pollened", + "poltroon", + "pompous", + "ponceau", + "pongid", + "poorly", + "poppied", + "porcine", + "porky", + "porous", + "porrect", + "portly", + "possessed", + "postern", + "postiche", + "postponed", + "potent", + "potted", + "potty", + "powered", + "practic", + "practiced", + "practised", + "praising", + "prayerful", + "prayerless", + "preachy", + "preborn", + "precast", + "precise", + "prefab", + "preggers", + "pregnant", + "premed", + "premier", + "premiere", + "premorse", + "prepared", + "prepense", + "preschool", + "prescribed", + "prescript", + "present", + "preserved", + "preset", + "pressing", + "pressor", + "presto", + "presumed", + "pretend", + "pretty", + "prewar", + "priceless", + "pricey", + "pricy", + "prideful", + "prideless", + "priestly", + "priggish", + "primal", + "primate", + "primsie", + "princely", + "printed", + "printless", + "prissy", + "pristine", + "privies", + "probing", + "produced", + "profane", + "profaned", + "professed", + "profound", + "profuse", + "prolate", + "prolix", + "pronounced", + "proposed", + "proscribed", + "prostate", + "prostrate", + "prostyle", + "prosy", + "proven", + "provoked", + "prowessed", + "proxy", + "prudent", + "prudish", + "prunted", + "prying", + "pseudo", + "psycho", + "pubic", + "pucka", + "puddly", + "pudgy", + "puffy", + "puggish", + "puggy", + "puisne", + "pukka", + "puling", + "pulpy", + "pulsing", + "punchy", + "punctate", + "punctured", + "pungent", + "punkah", + "puny", + "pupal", + "purblind", + "purer", + "purest", + "purging", + "purplish", + "purpure", + "pursued", + "pursy", + "pushing", + "pushy", + "pussy", + "putrid", + "pygmoid", + "pyknic", + "pyoid", + "quadrate", + "quadric", + "quaggy", + "quaky", + "qualmish", + "quantal", + "quartan", + "quartered", + "quartic", + "quartile", + "queasy", + "queenless", + "queenly", + "quenchless", + "quibbling", + "quickset", + "quiet", + "quilted", + "quinate", + "quinoid", + "quinsied", + "quintan", + "quintic", + "quippish", + "quirky", + "quondam", + "rabic", + "rabid", + "racemed", + "racing", + "racist", + "racy", + "raddled", + "raffish", + "raging", + "rainier", + "rainless", + "rainproof", + "raising", + "rakehell", + "rakish", + "ralline", + "ramal", + "rambling", + "rammish", + "ramose", + "rampant", + "ramstam", + "rancid", + "randie", + "randy", + "rangy", + "ranking", + "raploch", + "rarer", + "rarest", + "raring", + "rascal", + "rasping", + "raspy", + "ratite", + "ratlike", + "rattish", + "rattling", + "rattly", + "ratty", + "raucous", + "raunchy", + "ravaged", + "raving", + "rawboned", + "rawish", + "rayless", + "rearmost", + "rearward", + "reasoned", + "rebel", + "reborn", + "rebuked", + "reckless", + "recluse", + "record", + "rectal", + "recurved", + "redder", + "reddest", + "reddish", + "reedy", + "reeky", + "refer", + "refined", + "regal", + "regent", + "regnal", + "regnant", + "released", + "relieved", + "remiss", + "remnant", + "removed", + "rending", + "renowned", + "rental", + "repand", + "repent", + "replete", + "reproved", + "reptant", + "reptile", + "required", + "rescued", + "resigned", + "resolved", + "restful", + "resting", + "restive", + "restless", + "restored", + "retail", + "retained", + "retired", + "retral", + "retrorse", + "retuse", + "revealed", + "revered", + "reviled", + "revived", + "revolved", + "rheumy", + "rhinal", + "rhodic", + "rhomboid", + "rhotic", + "rhythmic", + "riant", + "ribald", + "ribless", + "riblike", + "ridden", + "rident", + "ridgy", + "riftless", + "righteous", + "rightful", + "rightish", + "rightist", + "rightward", + "rigid", + "riming", + "rimless", + "rimose", + "rimy", + "rindless", + "rindy", + "ringent", + "ringless", + "ripping", + "ripply", + "risen", + "risky", + "riteless", + "ritzy", + "rival", + "riven", + "roadless", + "roasting", + "robust", + "rodded", + "rodless", + "rodlike", + "roguish", + "roily", + "rollneck", + "rompish", + "roofless", + "rooky", + "roomy", + "rooted", + "rootless", + "rootlike", + "ropy", + "roseless", + "roselike", + "rostral", + "rosy", + "rotate", + "rotted", + "rotting", + "rotund", + "roughcast", + "roughish", + "rounded", + "rounding", + "roundish", + "roupy", + "rousing", + "routed", + "routine", + "rowdy", + "rubbly", + "rubied", + "rubric", + "rudish", + "rueful", + "ruffled", + "rufous", + "rugged", + "rugose", + "ruling", + "rumbly", + "rummy", + "rumpless", + "runic", + "runny", + "runtish", + "runty", + "rushing", + "rushy", + "russet", + "rustic", + "rustred", + "rusty", + "ruthful", + "ruthless", + "rutted", + "ruttish", + "rutty", + "saclike", + "sacral", + "sadist", + "sagging", + "said", + "sainted", + "saintly", + "saline", + "sallow", + "saltant", + "salted", + "saltier", + "saltish", + "saltless", + "salty", + "salving", + "sandalled", + "sanded", + "sandy", + "saner", + "sanest", + "sanguine", + "sapid", + "sapless", + "sappy", + "sarcoid", + "sarcous", + "sarky", + "sassy", + "sated", + "satem", + "saucy", + "saut", + "saving", + "savvy", + "scabby", + "scabrous", + "scaldic", + "scalelike", + "scalene", + "scalpless", + "scampish", + "scandent", + "scanty", + "scaphoid", + "scarcer", + "scarcest", + "scarless", + "scary", + "scatheless", + "scathing", + "scatty", + "scentless", + "sceptral", + "scheming", + "schistose", + "schizo", + "schizoid", + "schmaltzy", + "schmalzy", + "scientific", + "scincoid", + "scirrhoid", + "scirrhous", + "scissile", + "scleroid", + "sclerosed", + "sclerous", + "scombrid", + "scombroid", + "scopate", + "scornful", + "scraggly", + "scraggy", + "scrambled", + "scrannel", + "scrappy", + "scratchless", + "scratchy", + "scrawly", + "scrawny", + "screaky", + "screeching", + "screwy", + "scribal", + "scrimpy", + "scroddled", + "scroggy", + "scrotal", + "scrubbed", + "scrubby", + "scruffy", + "scrumptious", + "sculptured", + "scummy", + "scungy", + "scurrile", + "scurry", + "scurvy", + "scutate", + "seaboard", + "seaborne", + "seamless", + "seamy", + "searching", + "seasick", + "seatless", + "seaward", + "second", + "sectile", + "secund", + "secure", + "sedate", + "sedgy", + "seduced", + "seedless", + "seedy", + "seeing", + "seeking", + "seely", + "seeming", + "seemly", + "seismal", + "seismic", + "sejant", + "select", + "selfish", + "selfless", + "selfsame", + "semi", + "senile", + "sensate", + "senseless", + "septal", + "septate", + "sequent", + "sequined", + "seral", + "serene", + "serfish", + "serflike", + "serrate", + "serried", + "serviced", + "servo", + "setose", + "severe", + "sexism", + "sexist", + "sexless", + "sextan", + "sexy", + "shabby", + "shaded", + "shadeless", + "shadowed", + "shady", + "shaftless", + "shaken", + "shaky", + "shallow", + "shalwar", + "shamefaced", + "shameful", + "shameless", + "shapeless", + "shapely", + "shaping", + "shaven", + "shawlless", + "sheathy", + "sheepish", + "shellproof", + "shelly", + "shickered", + "shieldless", + "shieldlike", + "shier", + "shiest", + "shiftless", + "shifty", + "shingly", + "shining", + "shiny", + "shipboard", + "shipless", + "shipshape", + "shirtless", + "shirty", + "shocking", + "shoddy", + "shoeless", + "shopworn", + "shoreless", + "shoreward", + "shortcut", + "shortish", + "shorty", + "shotten", + "showy", + "shredded", + "shredless", + "shrewish", + "shrieval", + "shrinelike", + "shrouding", + "shroudless", + "shrubby", + "shrunken", + "shyer", + "shyest", + "sicker", + "sicklied", + "sickly", + "sideling", + "sidelong", + "sideward", + "sideways", + "sighful", + "sighted", + "sightless", + "sightly", + "sigmate", + "silenced", + "silken", + "silty", + "silvan", + "silvern", + "simplex", + "sincere", + "sinful", + "singing", + "singsong", + "sinless", + "sinning", + "sissy", + "sister", + "sixfold", + "sixteen", + "sixty", + "sizy", + "skaldic", + "sketchy", + "skewbald", + "skidproof", + "skilful", + "skillful", + "skimpy", + "skinking", + "skinless", + "skinny", + "skirtless", + "skittish", + "skyward", + "slaggy", + "slakeless", + "slangy", + "slantwise", + "slapstick", + "slashing", + "slaty", + "slavish", + "sleazy", + "sleekit", + "sleeky", + "sleepless", + "sleepwalk", + "sleepy", + "sleety", + "sleeveless", + "slender", + "slickered", + "slier", + "sliest", + "slighting", + "slimline", + "slimmer", + "slimmest", + "slimming", + "slimsy", + "slimy", + "slinky", + "slippy", + "slipshod", + "sloping", + "sloshy", + "slothful", + "slouchy", + "sloughy", + "sludgy", + "sluggard", + "sluggish", + "sluicing", + "slumbrous", + "slummy", + "slushy", + "sluttish", + "smacking", + "smallish", + "smarmy", + "smartish", + "smarty", + "smashing", + "smeary", + "smectic", + "smelly", + "smileless", + "smiling", + "smitten", + "smokeproof", + "smoking", + "smothered", + "smugger", + "smuggest", + "smutty", + "snafu", + "snaggy", + "snakelike", + "snaky", + "snappish", + "snappy", + "snarly", + "snatchy", + "snazzy", + "sneaking", + "sneaky", + "snider", + "snidest", + "sniffy", + "snippy", + "snobbish", + "snoopy", + "snooty", + "snoozy", + "snoring", + "snotty", + "snouted", + "snowless", + "snowlike", + "snubby", + "snuffly", + "snuffy", + "snugger", + "snuggest", + "snugging", + "soapless", + "soapy", + "soaring", + "sober", + "socko", + "sodden", + "softish", + "softwood", + "soggy", + "sola", + "solemn", + "soli", + "sollar", + "solus", + "solute", + "solvent", + "somber", + "sombre", + "sombrous", + "sometime", + "sonant", + "songful", + "songless", + "sonless", + "sonsie", + "sonsy", + "soothfast", + "soothing", + "sopping", + "soppy", + "sordid", + "sorer", + "sorest", + "sorry", + "sotted", + "sottish", + "soulful", + "soulless", + "soundless", + "soundproof", + "soupy", + "sourish", + "southmost", + "southpaw", + "southward", + "sovran", + "sozzled", + "spaceless", + "spacial", + "spacious", + "spadelike", + "spangly", + "spanking", + "sparid", + "sparing", + "sparkless", + "sparkling", + "sparoid", + "sparry", + "sparser", + "sparsest", + "spastic", + "spathic", + "spathose", + "spatial", + "spavined", + "specious", + "speckled", + "speckless", + "speechless", + "speedful", + "speeding", + "speedless", + "speedy", + "spellbound", + "spendthrift", + "spermic", + "spermous", + "sphagnous", + "sphenic", + "spheral", + "sphereless", + "spherelike", + "spheric", + "sphery", + "sphygmic", + "sphygmoid", + "spicate", + "spicy", + "spiffing", + "spiffy", + "spiky", + "spindling", + "spindly", + "spineless", + "spinose", + "spinous", + "spiral", + "spirant", + "spireless", + "spiroid", + "spiry", + "spiteful", + "splanchnic", + "splashy", + "spleenful", + "spleenish", + "spleeny", + "splendent", + "splendid", + "splendrous", + "splenic", + "splitting", + "splurgy", + "spoken", + "spokewise", + "spongy", + "spooky", + "spoony", + "sportful", + "sportive", + "sportless", + "sporty", + "spotless", + "spotty", + "spousal", + "spouseless", + "spouted", + "spoutless", + "spriggy", + "sprightful", + "sprightly", + "springing", + "springless", + "springlike", + "springtime", + "springy", + "sprucer", + "sprucest", + "sprucing", + "spryer", + "spryest", + "spunky", + "spurless", + "squabby", + "squalid", + "squally", + "squamate", + "squamous", + "squarish", + "squarrose", + "squashy", + "squeaky", + "squeamish", + "squiffy", + "squiggly", + "squirmy", + "squirting", + "squishy", + "stabbing", + "stabile", + "stagey", + "stagnant", + "stagy", + "stalkless", + "stalky", + "stalwart", + "stalworth", + "stannous", + "staple", + "starboard", + "starchy", + "staring", + "starless", + "starlight", + "starlike", + "starring", + "starry", + "starveling", + "starving", + "statant", + "stated", + "stateless", + "stateside", + "statewide", + "statist", + "stative", + "statued", + "steadfast", + "stealthy", + "steamtight", + "steamy", + "stedfast", + "steepled", + "stelar", + "stellar", + "stellate", + "stemless", + "stenosed", + "stepwise", + "steric", + "sterile", + "sternal", + "sternmost", + "sthenic", + "stickit", + "stiffish", + "stifling", + "stilly", + "stilted", + "stingless", + "stingy", + "stinko", + "stintless", + "stirless", + "stirring", + "stockinged", + "stockish", + "stockless", + "stocky", + "stodgy", + "stolen", + "stolid", + "stoneground", + "stoneless", + "stoneware", + "stonkered", + "stopless", + "stopping", + "store", + "storeyed", + "storied", + "stormbound", + "stormless", + "stormproof", + "stotious", + "stoutish", + "straining", + "strangest", + "strapless", + "strapping", + "stratous", + "strawless", + "strawlike", + "streaky", + "streaming", + "streamless", + "streamlined", + "streamy", + "stressful", + "stretchy", + "striate", + "stricken", + "strident", + "strifeful", + "strifeless", + "strigose", + "stringent", + "stringless", + "stringy", + "stripeless", + "stripy", + "strobic", + "strongish", + "strophic", + "stroppy", + "structured", + "strutting", + "strychnic", + "stubbled", + "stubbly", + "stubborn", + "stubby", + "studied", + "stuffy", + "stumbling", + "stumpy", + "stunning", + "stupid", + "sturdied", + "sturdy", + "stutter", + "stylar", + "styleless", + "stylised", + "stylish", + "stylized", + "styloid", + "subdued", + "subfusc", + "subgrade", + "sublimed", + "submerged", + "submersed", + "submiss", + "subscribed", + "subscript", + "subtile", + "subtle", + "succinct", + "suchlike", + "suffused", + "sugared", + "suited", + "sulcate", + "sulfa", + "sulkies", + "sulky", + "sullen", + "sullied", + "sultry", + "sunbaked", + "sunbeamed", + "sunburnt", + "sunfast", + "sunken", + "sunless", + "sunlike", + "sunlit", + "sunproof", + "sunrise", + "sunset", + "sunward", + "super", + "superb", + "supine", + "supple", + "supposed", + "sural", + "surbased", + "surer", + "surest", + "surfy", + "surgeless", + "surging", + "surgy", + "surly", + "surpliced", + "surplus", + "surprised", + "suspect", + "svelter", + "sveltest", + "swainish", + "swampy", + "swanky", + "swaraj", + "swarthy", + "sweated", + "sweaty", + "sweeping", + "sweetmeal", + "swelling", + "sweptwing", + "swindled", + "swingeing", + "swinish", + "swirly", + "swishy", + "swordless", + "swordlike", + "sylphic", + "sylphid", + "sylphish", + "sylphy", + "sylvan", + "systemless", + "taboo", + "tabu", + "tacit", + "tacky", + "tactful", + "tactile", + "tactless", + "tailing", + "tailless", + "taillike", + "tailored", + "taintless", + "taken", + "taking", + "talcose", + "talking", + "talky", + "taloned", + "tameless", + "tamer", + "tamest", + "taming", + "tandem", + "tangential", + "tangier", + "tangled", + "tangy", + "tannic", + "tapeless", + "tapelike", + "tardy", + "tarmac", + "tarnal", + "tarot", + "tarry", + "tarsal", + "tartish", + "tasseled", + "tasselled", + "tasteful", + "tasteless", + "tasty", + "tattered", + "tatty", + "taurine", + "tawdry", + "tawie", + "tearful", + "tearing", + "tearless", + "teary", + "teasing", + "techy", + "teeming", + "teenage", + "teensy", + "teeny", + "telic", + "telling", + "telltale", + "tempered", + "templed", + "tempting", + "tender", + "tenfold", + "tenor", + "tenseless", + "tenser", + "tensest", + "tensing", + "tensive", + "tented", + "tentie", + "tentless", + "tenty", + "tepid", + "terbic", + "terete", + "tergal", + "termless", + "ternate", + "terrene", + "tertial", + "tertian", + "testate", + "testy", + "tetchy", + "textbook", + "textile", + "textless", + "textured", + "thallic", + "thalloid", + "thallous", + "thankful", + "thankless", + "thatchless", + "thecal", + "thecate", + "theism", + "theist", + "themeless", + "thenar", + "thermic", + "theroid", + "thetic", + "thickset", + "thievish", + "thinking", + "thinnish", + "thirdstream", + "thirstless", + "thirsty", + "thirteen", + "thistly", + "thornless", + "thorny", + "thoughtful", + "thoughtless", + "thousandth", + "thowless", + "thrashing", + "threadbare", + "threadlike", + "thready", + "threatful", + "threefold", + "threescore", + "thriftless", + "thrifty", + "thrilling", + "throaty", + "throbbing", + "throbless", + "throneless", + "throwback", + "thudding", + "thuggish", + "thumbless", + "thumblike", + "thumping", + "thymic", + "thymy", + "thyrsoid", + "ticklish", + "tiddly", + "tideless", + "tidied", + "tightknit", + "timbered", + "timeless", + "timely", + "timeous", + "timid", + "tingly", + "tinhorn", + "tinkling", + "tinkly", + "tinny", + "tinsel", + "tintless", + "tiny", + "tippy", + "tiptoe", + "tiptop", + "tireless", + "tiresome", + "titled", + "toeless", + "toey", + "togaed", + "togate", + "toilful", + "toilsome", + "tombless", + "tonal", + "toneless", + "tongueless", + "tonguelike", + "tonish", + "tonnish", + "tony", + "toothless", + "toothlike", + "toothsome", + "toothy", + "topfull", + "topless", + "topmost", + "torose", + "torpid", + "torquate", + "torrent", + "tortile", + "tortious", + "tortured", + "tother", + "touching", + "touchy", + "toughish", + "touring", + "tourist", + "toward", + "towered", + "townish", + "townless", + "towy", + "toxic", + "toyless", + "toylike", + "traceless", + "trackless", + "tractile", + "tractrix", + "trainless", + "tranquil", + "transcribed", + "transient", + "transposed", + "traplike", + "trappy", + "trashy", + "traveled", + "travelled", + "traverse", + "treacly", + "treasured", + "treen", + "trembling", + "trembly", + "trenchant", + "trendy", + "tressured", + "tressy", + "tribal", + "tribeless", + "trichoid", + "trickish", + "trickless", + "tricksome", + "tricksy", + "tricky", + "tricorn", + "trident", + "trifid", + "trifling", + "triform", + "trillion", + "trillionth", + "trilobed", + "trinal", + "triploid", + "trippant", + "tripping", + "tristful", + "triter", + "tritest", + "triune", + "trivalve", + "trochal", + "trochoid", + "trodden", + "trophic", + "trophied", + "tropic", + "troppo", + "trothless", + "troublous", + "truant", + "truceless", + "truer", + "truffled", + "truncate", + "trunnioned", + "trustful", + "trusting", + "trustless", + "trusty", + "truthful", + "truthless", + "tryptic", + "tsarism", + "tsarist", + "tubal", + "tubate", + "tubby", + "tubeless", + "tumbling", + "tumid", + "tuneful", + "tuneless", + "turbaned", + "turbid", + "turdine", + "turfy", + "turgent", + "turgid", + "tuskless", + "tussal", + "tussive", + "tutti", + "twaddly", + "tweedy", + "twelvefold", + "twenty", + "twiggy", + "twinkling", + "twinning", + "twofold", + "typal", + "typhous", + "typic", + "ugsome", + "ullaged", + "umber", + "umbral", + "umbrose", + "umpteen", + "umpteenth", + "unaimed", + "unaired", + "unapt", + "unarmed", + "unasked", + "unawed", + "unbacked", + "unbagged", + "unbaked", + "unbarbed", + "unbarred", + "unbathed", + "unbegged", + "unbent", + "unbid", + "unblamed", + "unbleached", + "unblenched", + "unblent", + "unblessed", + "unblocked", + "unblown", + "unboned", + "unborn", + "unborne", + "unbought", + "unbound", + "unbowed", + "unbraced", + "unbranched", + "unbreached", + "unbreathed", + "unbred", + "unbreeched", + "unbridged", + "unbroke", + "unbruised", + "unbrushed", + "unburned", + "unburnt", + "uncaged", + "uncalled", + "uncapped", + "uncashed", + "uncaught", + "uncaused", + "unchained", + "unchanged", + "uncharge", + "uncharged", + "uncharmed", + "unchaste", + "unchecked", + "uncheered", + "unchewed", + "unclad", + "unclaimed", + "unclassed", + "unclean", + "uncleaned", + "uncleansed", + "unclear", + "uncleared", + "unclimbed", + "unclipped", + "unclogged", + "unclutched", + "uncocked", + "uncoined", + "uncombed", + "uncooked", + "uncouth", + "uncropped", + "uncross", + "uncrowned", + "unculled", + "uncurbed", + "uncured", + "uncursed", + "uncurved", + "uncut", + "undamped", + "undeaf", + "undealt", + "undecked", + "undimmed", + "undipped", + "undocked", + "undone", + "undrained", + "undraped", + "undrawn", + "undreamed", + "undreamt", + "undress", + "undressed", + "undried", + "undrilled", + "undrowned", + "undrunk", + "undubbed", + "undue", + "undug", + "undulled", + "undyed", + "unfair", + "unfanned", + "unfeared", + "unfed", + "unfelled", + "unfelt", + "unfenced", + "unfiled", + "unfilled", + "unfilmed", + "unfine", + "unfired", + "unfirm", + "unfished", + "unfit", + "unflawed", + "unfledged", + "unflushed", + "unfooled", + "unforced", + "unforged", + "unformed", + "unfought", + "unfound", + "unframed", + "unfraught", + "unfree", + "unfunded", + "unfurred", + "ungalled", + "ungauged", + "ungeared", + "ungilt", + "ungirthed", + "unglad", + "unglazed", + "unglossed", + "ungloved", + "ungored", + "ungorged", + "ungowned", + "ungraced", + "ungrassed", + "ungrazed", + "ungroomed", + "unground", + "ungrown", + "ungrudged", + "ungual", + "unguessed", + "unguled", + "ungummed", + "ungyved", + "unhacked", + "unhailed", + "unhanged", + "unharmed", + "unhatched", + "unhealed", + "unheard", + "unhelped", + "unhewn", + "unhinged", + "unhired", + "unhooped", + "unhorsed", + "unhung", + "unhurt", + "unhusked", + "unique", + "unjust", + "unkempt", + "unkenned", + "unkept", + "unkind", + "unkinged", + "unkissed", + "unknelled", + "unlaid", + "unlearned", + "unlearnt", + "unleased", + "unled", + "unlet", + "unlike", + "unlimed", + "unlined", + "unlit", + "unlooked", + "unlopped", + "unlost", + "unloved", + "unmade", + "unmailed", + "unmaimed", + "unmanned", + "unmarked", + "unmarred", + "unmasked", + "unmatched", + "unmeant", + "unmeet", + "unmet", + "unmilked", + "unmilled", + "unmissed", + "unmixed", + "unmoaned", + "unmourned", + "unmoved", + "unmown", + "unnamed", + "unoiled", + "unowned", + "unpaced", + "unpaged", + "unpaid", + "unpained", + "unpaired", + "unpared", + "unpaved", + "unpeeled", + "unpent", + "unperched", + "unpicked", + "unpierced", + "unplaced", + "unplagued", + "unplanked", + "unplayed", + "unpleased", + "unpledged", + "unploughed", + "unplucked", + "unplumb", + "unplumbed", + "unplumed", + "unpoised", + "unpolled", + "unposed", + "unpraised", + "unpreached", + "unpressed", + "unpriced", + "unprimed", + "unprized", + "unpropped", + "unproved", + "unpruned", + "unpurged", + "unquelled", + "unquenched", + "unraised", + "unraked", + "unreached", + "unread", + "unreaped", + "unreined", + "unrent", + "unrhymed", + "unribbed", + "unrigged", + "unrimed", + "unripe", + "unroped", + "unrouged", + "unroused", + "unrubbed", + "unrude", + "unruled", + "unsafe", + "unsaid", + "unsailed", + "unsapped", + "unsashed", + "unsaved", + "unscaled", + "unscanned", + "unscarred", + "unscathed", + "unschooled", + "unscorched", + "unscoured", + "unscratched", + "unscreened", + "unsealed", + "unsearched", + "unseen", + "unseized", + "unsensed", + "unsent", + "unset", + "unshamed", + "unshaped", + "unshared", + "unshaved", + "unsheathed", + "unshed", + "unshipped", + "unshocked", + "unshod", + "unshoed", + "unshorn", + "unshown", + "unshrived", + "unshunned", + "unshut", + "unsight", + "unsigned", + "unsized", + "unskilled", + "unskimmed", + "unskinned", + "unslain", + "unsliced", + "unsluiced", + "unslung", + "unsmirched", + "unsmooth", + "unsmoothed", + "unsnuffed", + "unsoaped", + "unsoft", + "unsoiled", + "unsold", + "unsolved", + "unsought", + "unsound", + "unsown", + "unspared", + "unsparred", + "unspelled", + "unspent", + "unspied", + "unspilled", + "unspilt", + "unspoiled", + "unspoilt", + "unsprung", + "unspun", + "unsquared", + "unstack", + "unstacked", + "unstaid", + "unstained", + "unstamped", + "unstarched", + "unstilled", + "unstirred", + "unstitched", + "unstocked", + "unstopped", + "unstrained", + "unstreamed", + "unstressed", + "unstringed", + "unstriped", + "unstripped", + "unstrung", + "unstuck", + "unstuffed", + "unsucked", + "unsung", + "unsure", + "unswayed", + "unswept", + "unsworn", + "untailed", + "untame", + "untamed", + "untanned", + "untapped", + "untarred", + "untaught", + "unteamed", + "unthanked", + "unthawed", + "unthought", + "untied", + "untiled", + "untilled", + "untinged", + "untinned", + "untired", + "untold", + "untombed", + "untoned", + "untorn", + "untouched", + "untraced", + "untracked", + "untrained", + "untrenched", + "untressed", + "untried", + "untrimmed", + "untrod", + "untrue", + "unturfed", + "unturned", + "unurged", + "unused", + "unversed", + "unvexed", + "unviewed", + "unvoiced", + "unwaked", + "unwarmed", + "unwarned", + "unwarped", + "unwashed", + "unwatched", + "unweaned", + "unwebbed", + "unwed", + "unweened", + "unweighed", + "unwell", + "unwept", + "unwet", + "unwhipped", + "unwilled", + "unwinged", + "unwiped", + "unwired", + "unwise", + "unwished", + "unwitched", + "unwon", + "unwooed", + "unworked", + "unworn", + "unwound", + "unwrapped", + "unwrought", + "unwrung", + "upbeat", + "upbound", + "upcast", + "upgrade", + "uphill", + "upmost", + "uppish", + "upraised", + "upset", + "upstage", + "upstaged", + "upstair", + "upstairs", + "upstart", + "upstate", + "upstream", + "uptight", + "uptown", + "upturned", + "upward", + "upwind", + "urbane", + "urdy", + "urgent", + "urnfield", + "useful", + "useless", + "utile", + "utmost", + "vadose", + "vagal", + "vagrant", + "vagrom", + "vaguer", + "vaguest", + "valanced", + "valgus", + "valiant", + "valid", + "valval", + "valvar", + "valvate", + "vambraced", + "vaneless", + "vanward", + "vapid", + "varied", + "varus", + "vassal", + "vasty", + "vatic", + "vaulted", + "vaulting", + "vaunted", + "vaunting", + "vaunty", + "veilless", + "veiny", + "velar", + "velate", + "vellum", + "venal", + "vengeful", + "venose", + "venous", + "ventose", + "verbless", + "verbose", + "verdant", + "verism", + "verist", + "vespine", + "vestral", + "vibrant", + "viceless", + "viewless", + "viewy", + "villose", + "villous", + "vinous", + "viral", + "virgate", + "virile", + "visaged", + "viscid", + "viscose", + "viscous", + "vitric", + "vivid", + "vivo", + "vixen", + "voetstoots", + "vogie", + "voiceful", + "voiceless", + "voided", + "volant", + "volar", + "volumed", + "volvate", + "vorant", + "voteless", + "votive", + "vulpine", + "vying", + "wacky", + "wageless", + "waggish", + "waggly", + "wailful", + "wailing", + "waisted", + "wakeful", + "wakeless", + "wakerife", + "waking", + "walnut", + "wambly", + "wandle", + "waney", + "waning", + "wanner", + "wannest", + "wanning", + "wannish", + "wanting", + "wanton", + "warded", + "warlike", + "warming", + "warmish", + "warning", + "warring", + "wartless", + "wartlike", + "warty", + "wary", + "washy", + "waspish", + "waspy", + "wasted", + "wasteful", + "watchful", + "waveless", + "wavelike", + "waving", + "wavy", + "waxen", + "waxing", + "waxy", + "wayless", + "wayward", + "wayworn", + "weakly", + "weaponed", + "wearied", + "wearing", + "wearish", + "weary", + "weathered", + "webby", + "wedded", + "wedgy", + "weedy", + "weekday", + "weekly", + "weeny", + "weepy", + "weer", + "weest", + "weighted", + "weighty", + "welcome", + "weldless", + "westbound", + "western", + "wetter", + "wettish", + "whacking", + "whacky", + "whapping", + "whate'er", + "wheaten", + "wheezing", + "wheezy", + "wheyey", + "whilom", + "whining", + "whinny", + "whiny", + "whiplike", + "whirring", + "whiskered", + "whitish", + "whittling", + "whity", + "wholesale", + "wholesome", + "whopping", + "whoreson", + "whorish", + "wicked", + "wicker", + "wider", + "widespread", + "widest", + "widish", + "wieldy", + "wifeless", + "wifely", + "wiggly", + "wigless", + "wiglike", + "wilful", + "willful", + "willing", + "willyard", + "wily", + "wimpy", + "windburned", + "winded", + "windproof", + "windswept", + "windy", + "wingless", + "winglike", + "wintry", + "winy", + "wiretap", + "wiring", + "wiry", + "wiser", + "wisest", + "wising", + "wispy", + "wistful", + "witchy", + "withdrawn", + "withy", + "witless", + "witted", + "witting", + "witty", + "wizard", + "wizen", + "wizened", + "woaded", + "wobbling", + "woeful", + "woesome", + "wolfish", + "wonky", + "wonted", + "wooded", + "woodless", + "woodsy", + "woodwind", + "woolen", + "woollen", + "woozier", + "woozy", + "wordless", + "wordy", + "workless", + "worldly", + "worldwide", + "wormy", + "worried", + "worser", + "worshipped", + "worthless", + "worthwhile", + "worthy", + "wounded", + "woundless", + "woven", + "wrapround", + "wrathful", + "wrathless", + "wreathless", + "wreckful", + "wretched", + "wrier", + "wriest", + "wriggly", + "wrinkly", + "writhen", + "writhing", + "written", + "wrongful", + "xanthous", + "xerarch", + "xeric", + "xiphoid", + "xylic", + "xyloid", + "yarer", + "yarest", + "yawning", + "yclept", + "yearling", + "yearlong", + "yearly", + "yearning", + "yeastlike", + "yeasty", + "yester", + "yestern", + "yielding", + "yogic", + "yolky", + "yonder", + "younger", + "youthful", + "yttric", + "yuletide", + "zany", + "zealous", + "zebrine", + "zeroth", + "zestful", + "zesty", + "zigzag", + "zillion", + "zincky", + "zincoid", + "zincous", + "zincy", + "zingy", + "zinky", + "zippy", + "zonate", + "zoning" +] \ No newline at end of file diff --git a/models/nouns.json b/models/nouns.json new file mode 100644 index 0000000..ed9375c --- /dev/null +++ b/models/nouns.json @@ -0,0 +1,2265 @@ +["aardvark", + "abyssinian", + "accelerator", + "accordion", + "account", + "accountant", + "acknowledgment", + "acoustic", + "acrylic", + "act", + "action", + "activity", + "actor", + "actress", + "adapter", + "addition", + "address", + "adjustment", + "adult", + "advantage", + "advertisement", + "aftermath", + "afternoon", + "aftershave", + "afterthought", + "age", + "agenda", + "agreement", + "air", + "airbus", + "airmail", + "airplane", + "airport", + "airship", + "alarm", + "albatross", + "alcohol", + "algebra", + "algeria", + "alibi", + "alley", + "alligator", + "alloy", + "almanac", + "alphabet", + "alto", + "aluminium", + "aluminum", + "ambulance", + "america", + "amount", + "amusement", + "anatomy", + "anethesiologist", + "anger", + "angle", + "angora", + "animal", + "anime", + "ankle", + "answer", + "ant", + "anteater", + "antelope", + "anthony", + "anthropology", + "apartment", + "apology", + "apparatus", + "apparel", + "appeal", + "appendix", + "apple", + "appliance", + "approval", + "april", + "aquarius", + "arch", + "archaeology", + "archeology", + "archer", + "architecture", + "area", + "argentina", + "argument", + "aries", + "arithmetic", + "arm", + "armadillo", + "armchair", + "army", + "arrow", + "art", + "ash", + "ashtray", + "asia", + "asparagus", + "asphalt", + "asterisk", + "astronomy", + "athlete", + "ATM", + "atom", + "attack", + "attempt", + "attention", + "attic", + "attraction", + "august", + "aunt", + "australia", + "australian", + "author", + "authority", + "authorization", + "avenue", + "baboon", + "baby", + "back", + "backbone", + "bacon", + "badge", + "badger", + "bag", + "bagel", + "bagpipe", + "bail", + "bait", + "baker", + "bakery", + "balance", + "balinese", + "ball", + "balloon", + "bamboo", + "banana", + "band", + "bandana", + "bangle", + "banjo", + "bank", + "bankbook", + "banker", + "bar", + "barbara", + "barber", + "barge", + "baritone", + "barometer", + "base", + "baseball", + "basement", + "basin", + "basket", + "basketball", + "bass", + "bassoon", + "bat", + "bath", + "bathroom", + "bathtub", + "battery", + "battle", + "bay", + "beach", + "bead", + "beam", + "bean", + "bear", + "beard", + "beast", + "beat", + "beautician", + "beauty", + "beaver", + "bed", + "bedroom", + "bee", + "beech", + "beef", + "beer", + "beet", + "beetle", + "beggar", + "beginner", + "begonia", + "behavior", + "belgian", + "belief", + "bell", + "belt", + "bench", + "bengal", + "beret", + "berry", + "bestseller", + "betty", + "bibliography", + "bicycle", + "bike", + "bill", + "billboard", + "biology", + "biplane", + "birch", + "bird", + "birth", + "birthday", + "bit", + "bite", + "black", + "bladder", + "blade", + "blanket", + "blinker", + "blizzard", + "block", + "blouse", + "blow", + "blowgun", + "blue", + "board", + "boat", + "bobcat", + "body", + "bolt", + "bomb", + "bomber", + "bone", + "bongo", + "bonsai", + "book", + "bookcase", + "booklet", + "boot", + "border", + "botany", + "bottle", + "bottom", + "boundary", + "bow", + "bowl", + "box", + "boy", + "bra", + "brace", + "bracket", + "brain", + "brake", + "branch", + "brand", + "brandy", + "brass", + "brazil", + "bread", + "break", + "breakfast", + "breath", + "brian", + "brick", + "bridge", + "british", + "broccoli", + "brochure", + "broker", + "bronze", + "brother", + "brother-in-law", + "brow", + "brown", + "brush", + "bubble", + "bucket", + "budget", + "buffer", + "buffet", + "bugle", + "building", + "bulb", + "bull", + "bulldozer", + "bumper", + "bun", + "burglar", + "burma", + "burn", + "burst", + "bus", + "bush", + "business", + "butane", + "butcher", + "butter", + "button", + "buzzard", + "cabbage", + "cabinet", + "cable", + "cactus", + "cafe", + "cake", + "calculator", + "calculus", + "calendar", + "calf", + "call", + "camel", + "camera", + "camp", + "can", + "cancer", + "candle", + "cannon", + "canoe", + "canvas", + "cap", + "capital", + "cappelletti", + "capricorn", + "captain", + "caption", + "car", + "caravan", + "carbon", + "card", + "cardboard", + "cardigan", + "care", + "carnation", + "carol", + "carp", + "carpenter", + "carriage", + "carrot", + "cart", + "cartoon", + "case", + "cast", + "castanet", + "cat", + "catamaran", + "caterpillar", + "cathedral", + "catsup", + "cattle", + "cauliflower", + "cause", + "caution", + "cave", + "c-clamp", + "cd", + "ceiling", + "celery", + "celeste", + "cell", + "cellar", + "cello", + "celsius", + "cement", + "cemetery", + "cent", + "centimeter", + "century", + "ceramic", + "cereal", + "certification", + "chain", + "chair", + "chalk", + "chance", + "change", + "channel", + "character", + "chard", + "charles", + "chauffeur", + "check", + "cheek", + "cheese", + "cheetah", + "chef", + "chemistry", + "cheque", + "cherry", + "chess", + "chest", + "chick", + "chicken", + "chicory", + "chief", + "child", + "children", + "chill", + "chime", + "chimpanzee", + "chin", + "china", + "chinese", + "chive", + "chocolate", + "chord", + "christmas", + "christopher", + "chronometer", + "church", + "cicada", + "cinema", + "circle", + "circulation", + "cirrus", + "citizenship", + "city", + "clam", + "clarinet", + "class", + "claus", + "clave", + "clef", + "clerk", + "click", + "client", + "climb", + "clipper", + "cloakroom", + "clock", + "close", + "closet", + "cloth", + "cloud", + "clover", + "club", + "clutch", + "coach", + "coal", + "coast", + "coat", + "cobweb", + "cockroach", + "cocktail", + "cocoa", + "cod", + "coffee", + "coil", + "coin", + "coke", + "cold", + "collar", + "college", + "collision", + "colombia", + "colon", + "colony", + "color", + "colt", + "column", + "columnist", + "comb", + "comfort", + "comic", + "comma", + "command", + "commission", + "committee", + "community", + "company", + "comparison", + "competition", + "competitor", + "composer", + "composition", + "computer", + "condition", + "condor", + "cone", + "confirmation", + "conga", + "congo", + "conifer", + "connection", + "consonant", + "continent", + "control", + "cook", + "copper", + "copy", + "copyright", + "cord", + "cork", + "cormorant", + "corn", + "cornet", + "correspondent", + "cost", + "cotton", + "couch", + "cougar", + "cough", + "country", + "course", + "court", + "cousin", + "cover", + "cow", + "cowbell", + "crab", + "crack", + "cracker", + "craftsman", + "crate", + "crawdad", + "crayfish", + "crayon", + "cream", + "creator", + "creature", + "credit", + "creditor", + "creek", + "crib", + "cricket", + "crime", + "criminal", + "crocodile", + "crocus", + "croissant", + "crook", + "crop", + "cross", + "crow", + "crowd", + "crown", + "crush", + "cry", + "cub", + "cuban", + "cucumber", + "cultivator", + "cup", + "cupboard", + "cupcake", + "curler", + "currency", + "current", + "curtain", + "curve", + "cushion", + "custard", + "customer", + "cut", + "cuticle", + "cycle", + "cyclone", + "cylinder", + "cymbal", + "dad", + "daffodil", + "dahlia", + "daisy", + "damage", + "dance", + "dancer", + "danger", + "daniel", + "dash", + "dashboard", + "database", + "date", + "daughter", + "david", + "day", + "dead", + "deadline", + "deal", + "death", + "deborah", + "debt", + "debtor", + "decade", + "december", + "decimal", + "decision", + "decrease", + "dedication", + "deer", + "defense", + "deficit", + "degree", + "delete", + "delivery", + "den", + "denim", + "dentist", + "deodorant", + "department", + "deposit", + "description", + "desert", + "design", + "desire", + "desk", + "dessert", + "destruction", + "detail", + "detective", + "development", + "dew", + "diamond", + "diaphragm", + "dibble", + "dictionary", + "dietician", + "difference", + "digestion", + "digger", + "digital", + "dill", + "dime", + "dimple", + "dinghy", + "dinner", + "dinosaur", + "diploma", + "dipstick", + "direction", + "dirt", + "disadvantage", + "discovery", + "discussion", + "disease", + "disgust", + "dish", + "distance", + "distribution", + "distributor", + "division", + "dock", + "doctor", + "dog", + "dogsled", + "doll", + "dollar", + "dolphin", + "domain", + "donald", + "donkey", + "donna", + "door", + "double", + "doubt", + "downtown", + "dragon", + "dragonfly", + "drain", + "drake", + "drama", + "draw", + "drawbridge", + "drawer", + "dream", + "dredger", + "dress", + "dresser", + "drill", + "drink", + "drive", + "driver", + "drizzle", + "drop", + "drug", + "drum", + "dryer", + "duck", + "duckling", + "dugout", + "dungeon", + "dust", + "eagle", + "ear", + "earth", + "earthquake", + "ease", + "edge", + "edger", + "editor", + "editorial", + "education", + "edward", + "eel", + "effect", + "egg", + "eggnog", + "eggplant", + "egypt", + "eight", + "elbow", + "element", + "elephant", + "elizabeth", + "ellipse", + "emery", + "employee", + "employer", + "encyclopedia", + "end", + "enemy", + "energy", + "engine", + "engineer", + "english", + "enquiry", + "entrance", + "environment", + "epoch", + "epoxy", + "equinox", + "equipment", + "era", + "error", + "estimate", + "ethernet", + "ethiopia", + "euphonium", + "europe", + "evening", + "event", + "examination", + "example", + "exchange", + "exclamation", + "exhaust", + "ex-husband", + "existence", + "expansion", + "experience", + "expert", + "explanation", + "ex-wife", + "eye", + "eyebrow", + "eyelash", + "eyeliner", + "face", + "fact", + "factory", + "fahrenheit", + "fall", + "family", + "fan", + "fang", + "farm", + "farmer", + "fat", + "father", + "father-in-law", + "faucet", + "fear", + "feast", + "feather", + "feature", + "february", + "fedelini", + "feedback", + "feeling", + "feet", + "felony", + "female", + "fender", + "ferry", + "ferryboat", + "fertilizer", + "fiber", + "fiberglass", + "fibre", + "fiction", + "field", + "fifth", + "fight", + "fighter", + "file", + "find", + "fine", + "finger", + "fir", + "fire", + "fireman", + "fireplace", + "firewall", + "fish", + "fisherman", + "flag", + "flame", + "flare", + "flat", + "flavor", + "flax", + "flesh", + "flight", + "flock", + "flood", + "floor", + "flower", + "flugelhorn", + "flute", + "fly", + "foam", + "fog", + "fold", + "font", + "food", + "foot", + "football", + "footnote", + "force", + "forecast", + "forehead", + "forest", + "forgery", + "fork", + "form", + "format", + "fortnight", + "foundation", + "fountain", + "fowl", + "fox", + "foxglove", + "fragrance", + "frame", + "france", + "freckle", + "freeze", + "freezer", + "freighter", + "french", + "freon", + "friction", + "Friday", + "fridge", + "friend", + "frog", + "front", + "frost", + "frown", + "fruit", + "fuel", + "fur", + "furniture", + "galley", + "gallon", + "game", + "gander", + "garage", + "garden", + "garlic", + "gas", + "gasoline", + "gate", + "gateway", + "gauge", + "gazelle", + "gear", + "gearshift", + "geese", + "gemini", + "gender", + "geography", + "geology", + "geometry", + "george", + "geranium", + "german", + "germany", + "ghana", + "ghost", + "giant", + "giraffe", + "girdle", + "girl", + "gladiolus", + "glass", + "glider", + "glockenspiel", + "glove", + "glue", + "goal", + "goat", + "gold", + "goldfish", + "golf", + "gondola", + "gong", + "good-bye", + "goose", + "gore-tex", + "gorilla", + "gosling", + "government", + "governor", + "grade", + "grain", + "gram", + "granddaughter", + "grandfather", + "grandmother", + "grandson", + "grape", + "graphic", + "grass", + "grasshopper", + "gray", + "grease", + "great-grandfather", + "great-grandmother", + "greece", + "greek", + "green", + "grenade", + "grey", + "grill", + "grip", + "ground", + "group", + "grouse", + "growth", + "guarantee", + "guatemalan", + "guide", + "guilty", + "guitar", + "gum", + "gun", + "gym", + "gymnast", + "hacksaw", + "hail", + "hair", + "haircut", + "half-brother", + "half-sister", + "halibut", + "hall", + "hallway", + "hamburger", + "hammer", + "hamster", + "hand", + "handball", + "handicap", + "handle", + "handsaw", + "harbor", + "hardboard", + "hardcover", + "hardhat", + "hardware", + "harmonica", + "harmony", + "harp", + "hat", + "hate", + "hawk", + "head", + "headlight", + "headline", + "health", + "hearing", + "heart", + "heat", + "heaven", + "hedge", + "height", + "helen", + "helicopter", + "helium", + "hell", + "helmet", + "help", + "hemp", + "hen", + "heron", + "herring", + "hexagon", + "hill", + "himalayan", + "hip", + "hippopotamus", + "history", + "hockey", + "hoe", + "hole", + "holiday", + "home", + "honey", + "hood", + "hook", + "hope", + "horn", + "horse", + "hose", + "hospital", + "hot", + "hour", + "hourglass", + "house", + "hovercraft", + "hub", + "hubcap", + "humidity", + "humor", + "hurricane", + "hyacinth", + "hydrant", + "hydrofoil", + "hydrogen", + "hyena", + "hygienic", + "ice", + "icebreaker", + "icicle", + "icon", + "idea", + "ikebana", + "illegal", + "imprisonment", + "improvement", + "impulse", + "inch", + "income", + "increase", + "index", + "india", + "indonesia", + "industry", + "ink", + "innocent", + "input", + "insect", + "instruction", + "instrument", + "insulation", + "insurance", + "interactive", + "interest", + "internet", + "interviewer", + "intestine", + "invention", + "inventory", + "invoice", + "iran", + "iraq", + "iris", + "iron", + "island", + "israel", + "italian", + "italy", + "jacket", + "jaguar", + "jail", + "jam", + "james", + "january", + "japan", + "japanese", + "jar", + "jasmine", + "jason", + "jaw", + "jeep", + "jelly", + "jellyfish", + "jennifer", + "jet", + "jewel", + "join", + "joke", + "joseph", + "journey", + "judge", + "judo", + "juice", + "july", + "jumbo", + "jump", + "jumper", + "june", + "jury", + "justice", + "jute", + "kale", + "kamikaze", + "kangaroo", + "karate", + "karen", + "kayak", + "kendo", + "kenneth", + "kenya", + "ketchup", + "kettle", + "kettledrum", + "kevin", + "key", + "keyboard", + "kick", + "kidney", + "kilogram", + "kilometer", + "kimberly", + "kiss", + "kitchen", + "kite", + "kitten", + "kitty", + "knee", + "knife", + "knight", + "knot", + "knowledge", + "kohlrabi", + "korean", + "laborer", + "lace", + "ladybug", + "lake", + "lamb", + "lamp", + "lan", + "land", + "landmine", + "language", + "larch", + "lasagna", + "latency", + "latex", + "lathe", + "laugh", + "laundry", + "laura", + "law", + "lawyer", + "layer", + "lead", + "leaf", + "leather", + "leek", + "leg", + "legal", + "lemonade", + "lentil", + "leo", + "leopard", + "letter", + "lettuce", + "level", + "libra", + "library", + "license", + "lier", + "lift", + "light", + "lightning", + "lilac", + "lily", + "limit", + "linda", + "line", + "linen", + "link", + "lion", + "lip", + "lipstick", + "liquid", + "liquor", + "lisa", + "list", + "literature", + "litter", + "liver", + "lizard", + "llama", + "loaf", + "loan", + "lobster", + "lock", + "locket", + "locust", + "look", + "loss", + "lotion", + "love", + "low", + "lumber", + "lunch", + "lunchroom", + "lung", + "lunge", + "lute", + "luttuce", + "lycra", + "lynx", + "lyocell", + "lyre", + "lyric", + "macaroni", + "machine", + "macrame", + "magazine", + "magic", + "magician", + "maid", + "mail", + "mailbox", + "mailman", + "makeup", + "malaysia", + "male", + "mall", + "mallet", + "man", + "manager", + "mandolin", + "manicure", + "manx", + "map", + "maple", + "maraca", + "marble", + "march", + "margaret", + "margin", + "maria", + "marimba", + "mark", + "market", + "mary", + "mascara", + "mask", + "mass", + "match", + "math", + "mattock", + "may", + "mayonnaise", + "meal", + "measure", + "meat", + "mechanic", + "medicine", + "meeting", + "melody", + "memory", + "men", + "menu", + "mercury", + "message", + "metal", + "meteorology", + "meter", + "methane", + "mexican", + "mexico", + "mice", + "michael", + "michelle", + "microwave", + "middle", + "mile", + "milk", + "milkshake", + "millennium", + "millimeter", + "millisecond", + "mimosa", + "mind", + "mine", + "minibus", + "mini-skirt", + "minister", + "mint", + "minute", + "mirror", + "missile", + "mist", + "mistake", + "mitten", + "moat", + "modem", + "mole", + "mom", + "Monday", + "money", + "monkey", + "month", + "moon", + "morning", + "morocco", + "mosque", + "mosquito", + "mother", + "mother-in-law", + "motion", + "motorboat", + "motorcycle", + "mountain", + "mouse", + "moustache", + "mouth", + "move", + "multi-hop", + "multimedia", + "muscle", + "museum", + "music", + "musician", + "mustard", + "myanmar", + "nail", + "name", + "nancy", + "napkin", + "narcissus", + "nation", + "neck", + "need", + "needle", + "neon", + "nepal", + "nephew", + "nerve", + "nest", + "net", + "network", + "newsprint", + "newsstand", + "nic", + "nickel", + "niece", + "nigeria", + "night", + "nitrogen", + "node", + "noise", + "noodle", + "norwegian", + "nose", + "note", + "notebook", + "notify", + "novel", + "november", + "number", + "numeric", + "nurse", + "nut", + "nylon", + "oak", + "oatmeal", + "objective", + "oboe", + "observation", + "occupation", + "ocean", + "ocelot", + "octagon", + "octave", + "october", + "octopus", + "odometer", + "offence", + "offer", + "office", + "oil", + "okra", + "olive", + "onion", + "open", + "opera", + "operation", + "ophthalmologist", + "opinion", + "option", + "orange", + "orchestra", + "orchid", + "order", + "organ", + "organisation", + "organization", + "ornament", + "ostrich", + "otter", + "ounce", + "output", + "outrigger", + "oval", + "oven", + "overcoat", + "owl", + "owner", + "ox", + "oxygen", + "oyster", + "package", + "packet", + "page", + "pail", + "pain", + "paint", + "pair", + "pajama", + "pakistan", + "palm", + "pamphlet", + "pan", + "pancake", + "pancreas", + "panda", + "pansy", + "panther", + "pantry", + "panty", + "pantyhose", + "paper", + "paperback", + "parade", + "parallelogram", + "parcel", + "parent", + "parenthesis", + "park", + "parrot", + "parsnip", + "part", + "particle", + "partner", + "partridge", + "party", + "passbook", + "passenger", + "passive", + "pasta", + "paste", + "pastor", + "pastry", + "patch", + "path", + "patient", + "patio", + "patricia", + "paul", + "payment", + "pea", + "peace", + "peak", + "peanut", + "pear", + "pedestrian", + "pediatrician", + "peen", + "peer-to-peer", + "pelican", + "pen", + "penalty", + "pencil", + "pendulum", + "pentagon", + "peony", + "pepper", + "perch", + "perfume", + "period", + "periodical", + "peripheral", + "permission", + "persian", + "person", + "peru", + "pest", + "pet", + "pharmacist", + "pheasant", + "philosophy", + "phone", + "physician", + "piano", + "piccolo", + "pickle", + "picture", + "pie", + "pig", + "pigeon", + "pike", + "pillow", + "pilot", + "pimple", + "pin", + "pine", + "ping", + "pink", + "pint", + "pipe", + "pisces", + "pizza", + "place", + "plain", + "plane", + "planet", + "plant", + "plantation", + "plaster", + "plasterboard", + "plastic", + "plate", + "platinum", + "play", + "playground", + "playroom", + "pleasure", + "plier", + "plot", + "plough", + "plow", + "plywood", + "pocket", + "poet", + "point", + "poison", + "poland", + "police", + "policeman", + "polish", + "politician", + "pollution", + "polo", + "polyester", + "pond", + "popcorn", + "poppy", + "population", + "porch", + "porcupine", + "port", + "porter", + "position", + "possibility", + "postage", + "postbox", + "pot", + "potato", + "poultry", + "pound", + "powder", + "power", + "precipitation", + "preface", + "pressure", + "price", + "priest", + "print", + "printer", + "prison", + "probation", + "process", + "produce", + "product", + "production", + "professor", + "profit", + "promotion", + "propane", + "property", + "prose", + "prosecution", + "protest", + "protocol", + "pruner", + "psychiatrist", + "psychology", + "ptarmigan", + "puffin", + "pull", + "puma", + "pump", + "pumpkin", + "punch", + "punishment", + "puppy", + "purchase", + "purple", + "purpose", + "push", + "pvc", + "pyjama", + "pyramid", + "quail", + "quality", + "quart", + "quarter", + "quartz", + "queen", + "question", + "quicksand", + "quiet", + "quill", + "quilt", + "quince", + "quit", + "quiver", + "quotation", + "rabbi", + "rabbit", + "radar", + "radiator", + "radio", + "radish", + "raft", + "rail", + "railway", + "rain", + "rainbow", + "raincoat", + "rainstorm", + "rake", + "ramie", + "random", + "range", + "rat", + "rate", + "raven", + "ravioli", + "ray", + "rayon", + "reaction", + "reading", + "reason", + "receipt", + "recess", + "record", + "recorder", + "rectangle", + "red", + "reduction", + "refrigerator", + "refund", + "regret", + "reindeer", + "relation", + "relative", + "religion", + "relish", + "reminder", + "repair", + "replace", + "report", + "representative", + "request", + "resolution", + "respect", + "responsibility", + "rest", + "restaurant", + "result", + "retailer", + "revolve", + "revolver", + "reward", + "rhinoceros", + "rhythm", + "rice", + "richard", + "riddle", + "rifle", + "ring", + "rise", + "risk", + "river", + "riverbed", + "road", + "roadway", + "roast", + "robert", + "robin", + "rock", + "rocket", + "rod", + "roll", + "romania", + "romanian", + "ronald", + "roof", + "room", + "rooster", + "root", + "rose", + "rotate", + "route", + "router", + "rowboat", + "rub", + "rubber", + "rugby", + "rule", + "run", + "russia", + "russian", + "rutabaga", + "ruth", + "sack", + "sagittarius", + "sail", + "sailboat", + "sailor", + "salad", + "salary", + "sale", + "salesman", + "salmon", + "salt", + "sampan", + "samurai", + "sand", + "sandra", + "sandwich", + "Santa", + "sardine", + "satin", + "Saturday", + "sauce", + "sausage", + "save", + "saw", + "saxophone", + "scale", + "scallion", + "scanner", + "scarecrow", + "scarf", + "scene", + "scent", + "schedule", + "school", + "science", + "scissor", + "scooter", + "scorpio", + "scorpion", + "scraper", + "screen", + "screw", + "screwdriver", + "sea", + "seagull", + "seal", + "seaplane", + "search", + "seashore", + "season", + "seat", + "second", + "secretary", + "secure", + "security", + "seed", + "seeder", + "segment", + "select", + "selection", + "self", + "semicircle", + "semicolon", + "sense", + "sentence", + "september", + "servant", + "server", + "session", + "sex", + "shade", + "shadow", + "shake", + "shallot", + "shame", + "shampoo", + "shape", + "share", + "shark", + "sharon", + "shear", + "sheep", + "sheet", + "shelf", + "shell", + "shield", + "shingle", + "ship", + "shirt", + "shock", + "shoe", + "shoemaker", + "shop", + "shoulder", + "shovel", + "show", + "shrimp", + "shrine", + "siamese", + "siberian", + "side", + "sideboard", + "sidecar", + "sidewalk", + "sign", + "signature", + "silica", + "silk", + "silver", + "sing", + "singer", + "single", + "sink", + "sister", + "sister-in-law", + "size", + "skate", + "ski", + "skill", + "skin", + "skirt", + "sky", + "slash", + "slave", + "sled", + "sleep", + "sleet", + "slice", + "slime", + "slip", + "slipper", + "slope", + "smash", + "smell", + "smile", + "smoke", + "snail", + "snake", + "sneeze", + "snow", + "snowboard", + "snowflake", + "snowman", + "snowplow", + "snowstorm", + "soap", + "soccer", + "society", + "sociology", + "sock", + "soda", + "sofa", + "softball", + "softdrink", + "software", + "soil", + "soldier", + "son", + "song", + "soprano", + "sort", + "sound", + "soup", + "sousaphone", + "soy", + "soybean", + "space", + "spade", + "spaghetti", + "spain", + "spandex", + "spark", + "sparrow", + "spear", + "specialist", + "speedboat", + "sphere", + "sphynx", + "spider", + "spike", + "spinach", + "spleen", + "sponge", + "spoon", + "spot", + "spring", + "sprout", + "spruce", + "spy", + "square", + "squash", + "squid", + "squirrel", + "stage", + "staircase", + "stamp", + "star", + "start", + "starter", + "state", + "statement", + "station", + "statistic", + "steam", + "steel", + "stem", + "step", + "step-aunt", + "step-brother", + "stepdaughter", + "step-daughter", + "step-father", + "step-grandfather", + "step-grandmother", + "stepmother", + "step-mother", + "step-sister", + "stepson", + "step-son", + "step-uncle", + "steven", + "stew", + "stick", + "stinger", + "stitch", + "stock", + "stocking", + "stomach", + "stone", + "stool", + "stop", + "stopsign", + "stopwatch", + "store", + "storm", + "story", + "stove", + "stranger", + "straw", + "stream", + "street", + "streetcar", + "stretch", + "string", + "structure", + "study", + "sturgeon", + "submarine", + "substance", + "subway", + "success", + "sudan", + "suede", + "sugar", + "suggestion", + "suit", + "summer", + "sun", + "Sunday", + "sundial", + "sunflower", + "sunshine", + "supermarket", + "supply", + "support", + "surfboard", + "surgeon", + "surname", + "surprise", + "susan", + "sushi", + "swallow", + "swamp", + "swan", + "sweater", + "sweatshirt", + "sweatshop", + "swedish", + "swim", + "swing", + "swiss", + "switch", + "sword", + "swordfish", + "sycamore", + "syrup", + "system", + "table", + "tablecloth", + "tabletop", + "tachometer", + "tadpole", + "tail", + "tailor", + "taiwan", + "talk", + "tank", + "tanker", + "tanzania", + "target", + "taste", + "taurus", + "tax", + "taxi", + "taxicab", + "tea", + "teacher", + "team", + "technician", + "teeth", + "television", + "teller", + "temper", + "temperature", + "temple", + "tempo", + "tendency", + "tennis", + "tenor", + "tent", + "territory", + "test", + "text", + "textbook", + "texture", + "thailand", + "theater", + "theory", + "thermometer", + "thing", + "thistle", + "thought", + "thread", + "thrill", + "throat", + "throne", + "thumb", + "thunder", + "thunderstorm", + "Thursday", + "ticket", + "tie", + "tiger", + "tile", + "timbale", + "time", + "timer", + "timpani", + "tin", + "tip", + "tire", + "titanium", + "title", + "toad", + "toast", + "toe", + "toenail", + "toilet", + "tomato", + "tom-tom", + "ton", + "tongue", + "tooth", + "toothbrush", + "toothpaste", + "top", + "tornado", + "tortellini", + "tortoise", + "touch", + "tower", + "town", + "toy", + "tractor", + "trade", + "traffic", + "trail", + "train", + "tramp", + "transaction", + "transmission", + "transport", + "trapezoid", + "tray", + "treatment", + "tree", + "trial", + "triangle", + "trick", + "trigonometry", + "trip", + "trombone", + "trouble", + "trouser", + "trout", + "trowel", + "truck", + "trumpet", + "trunk", + "t-shirt", + "tsunami", + "tub", + "tuba", + "Tuesday", + "tugboat", + "tulip", + "tuna", + "tune", + "turkey", + "turn", + "turnip", + "turnover", + "turret", + "turtle", + "tv", + "twig", + "twilight", + "twine", + "twist", + "typhoon", + "tyvek", + "uganda", + "umbrella", + "uncle", + "undercloth", + "underpant", + "undershirt", + "underwear", + "unit", + "use", + "utensil", + "vacation", + "vacuum", + "valley", + "value", + "van", + "vase", + "vault", + "vegetable", + "vegetarian", + "veil", + "vein", + "velvet", + "verdict", + "vermicelli", + "verse", + "vessel", + "vest", + "veterinarian", + "vibraphone", + "Vietnam", + "view", + "vinyl", + "viola", + "violet", + "violin", + "virgo", + "viscose", + "vise", + "vision", + "visitor", + "voice", + "volcano", + "volleyball", + "voyage", + "vulture", + "waiter", + "waitress", + "walk", + "wall", + "wallaby", + "wallet", + "walrus", + "war", + "wash", + "washer", + "wasp", + "waste", + "watch", + "watchmaker", + "water", + "waterfall", + "wave", + "wax", + "way", + "wealth", + "weapon", + "weasel", + "weather", + "wedge", + "Wednesday", + "weed", + "weeder", + "week", + "weight", + "whale", + "wheel", + "whip", + "whiskey", + "whistle", + "white", + "wholesaler", + "whorl", + "wilderness", + "william", + "willow", + "wind", + "windchime", + "window", + "windscreen", + "windshield", + "wine", + "wing", + "winter", + "wire", + "wish", + "witch", + "withdrawal", + "witness", + "wolf", + "woman", + "women", + "wood", + "wool", + "woolen", + "word", + "work", + "workshop", + "worm", + "wound", + "wrecker", + "wren", + "wrench", + "wrinkle", + "wrist", + "writer", + "xylophone", + "yacht", + "yak", + "yam", + "yard", + "yarn", + "year", + "yellow", + "yew", + "yogurt", + "yoke", + "yugoslavian", + "zebra", + "zephyr", + "zinc", + "zipper", + "zone", + "zoo", + "zoology" +] \ No newline at end of file diff --git a/readme.md b/readme.md index 8595e11..eb2cfbf 100755 --- a/readme.md +++ b/readme.md @@ -49,7 +49,7 @@ By default it will produce a glorious array of 10 objects of nothing! Since we d > **Note:** MockData uses CORS so if you're running a virtual domain then you will still be able to hit the service.(As long as you have a decent browser.) -### Number of objects +### Number of objects (`$num`) The number of objects to be returned by the service is determined by the `$num` argument, which defaults to `10` items: @@ -88,6 +88,37 @@ var data = getInstance( "MockData@MockDataCFC" ) ); ``` +### Available return types (`$returntype`) + +By default the service/method call will return X amount of records in the form of an array. However, if you would like to just return an object literal representation you can do so via the `$returnType` argument. + +Available return types: + +* `array` - Default, returns an array of objects +* `struct` - Returns an object literal struct + +```js +// Method Call +var data = getInstance( "MockData@MockDataCFC" ) + .mock( + $returnType = "struct", + name = "name", + age = "age", + id = "uuid", + email = "email" + ); +// Service call +http://127.0.0.1:60299/MockDataCFC?$returnType=struct&name=name&age=age&id=uuid&email=email + +// The output will be something like this +{ + "id": "91659091-A489-4706-BAC64FA8E1665509", + "name": "Danny Tobias", + "age": 33, + "email": "idegeneres@microsoft.com" +} +``` + ### Available Mocking Types The available types MockDataCFC supports are: @@ -113,6 +144,9 @@ The available types MockDataCFC supports are: * `sentence`: Generates a sentences. If used as `sentence:N`, returns N sentences. If used as `sentence:X:Y`, returns a random number of sentences beetween X and Y. * `ssn`: Generates a random Social Security number. * `string`: Generates a random string of length 10 by default. You can increase the length by passing it `string:length`. +* `string-alpha` : Generates a random alpha string of length 10 by default. You can increase the length by passing it `string-alpha:length`. +* `string-numeric` : Generates a random numeric string of length 10 by default. You can increase the length by passing it `string-numeric:length`. +* `string-secure` : Generates a random secure (alpha+numeric+symbols) string of length 10 by default. You can increase the length by passing it `string-secure:length`. * `tel`: Generates a random (American) telephone number. * `uuid`: Generates a random UUID * `url` : Generates a random URL with a random protocol @@ -123,6 +157,28 @@ The available types MockDataCFC supports are: * `website_https` : Generates a random website, `https` only protocol * `words`: Generates a single word. If used as `word:N`, returns N words. If used as `words:X:Y`, returns a random number of words beetween X and Y. +### Calling Types By Function Name + +Please check out the apidocs at : https://apidocs.ortussolutions.com/#/coldbox-modules/MockDataCFC/ for the latest methods, but you can also use the mocking methods instead of going via the `mock()` method. + +* `baconLorem()` +* `dateRange()` +* `email()` +* `firstName()` +* `imageUrl()` +* `ipAddress()` +* `lastName()` +* `lorem()` +* `num()` +* `oneOf()` +* `sentence()` +* `ssn()` +* `string()` +* `telephone()` +* `uri()` +* `websiteUrl()` +* `words()` + ### Supplier Type (Custom Data) You can also create your own content by using a supplier closure/lambda as your type. This is a function that will create the content and return it for you. diff --git a/test-harness/box.json b/test-harness/box.json index 87e0631..f660017 100644 --- a/test-harness/box.json +++ b/test-harness/box.json @@ -8,7 +8,7 @@ "coldbox":"^5.0.0" }, "devDependencies":{ - "testbox":"^3.0.0" + "testbox":"^4.0.0" }, "installPaths":{ "coldbox":"coldbox/", diff --git a/test-harness/tests/Application.cfc b/test-harness/tests/Application.cfc index 10d2b3f..047bb66 100644 --- a/test-harness/tests/Application.cfc +++ b/test-harness/tests/Application.cfc @@ -7,25 +7,25 @@ www.ortussolutions.com component{ // APPLICATION CFC PROPERTIES - this.name = "ColdBoxTestingSuite" & hash(getCurrentTemplatePath()); - this.sessionManagement = true; - this.sessionTimeout = createTimeSpan( 0, 0, 15, 0 ); + this.name = "ColdBoxTestingSuite" & hash(getCurrentTemplatePath()); + this.sessionManagement = true; + this.sessionTimeout = createTimeSpan( 0, 0, 15, 0 ); this.applicationTimeout = createTimeSpan( 0, 0, 15, 0 ); - this.setClientCookies = true; + this.setClientCookies = true; // Create testing mapping this.mappings[ "/tests" ] = getDirectoryFromPath( getCurrentTemplatePath() ); // The application root - rootPath = REReplaceNoCase( this.mappings[ "/tests" ], "tests(\\|/)", "" ); + rootPath = REReplaceNoCase( this.mappings[ "/tests" ], "tests(\\|/)", "" ); this.mappings[ "/root" ] = rootPath; // UPDATE THE NAME OF THE MODULE IN TESTING BELOW request.MODULE_NAME = "MockDataCFC"; // The module root path - moduleRootPath = REReplaceNoCase( this.mappings[ "/root" ], "#request.module_name#(\\|/)test-harness(\\|/)", "" ); - this.mappings[ "/moduleroot" ] = moduleRootPath; + moduleRootPath = REReplaceNoCase( this.mappings[ "/root" ], "#request.module_name#(\\|/)test-harness(\\|/)", "" ); + this.mappings[ "/moduleroot" ] = moduleRootPath; this.mappings[ "/#request.MODULE_NAME#" ] = moduleRootPath & "#request.MODULE_NAME#"; } \ No newline at end of file diff --git a/test-harness/tests/specs/MockDataTest.cfc b/test-harness/tests/specs/MockDataTest.cfc index 08fa473..50282b9 100644 --- a/test-harness/tests/specs/MockDataTest.cfc +++ b/test-harness/tests/specs/MockDataTest.cfc @@ -1,6 +1,6 @@ -component extends="coldbox.system.testing.BaseTestCase" appMapping="root"{ +component extends="coldbox.system.testing.BaseTestCase" appMapping="root" { -/*********************************** LIFE CYCLE Methods ***********************************/ + /*********************************** LIFE CYCLE Methods ***********************************/ function beforeAll(){ super.beforeAll(); @@ -11,165 +11,180 @@ component extends="coldbox.system.testing.BaseTestCase" appMapping="root"{ super.afterAll(); } -/*********************************** BDD SUITES ***********************************/ + /*********************************** BDD SUITES ***********************************/ function run(){ describe( "MockData CFC", function(){ - - - beforeEach(function( currentSpec ){ + beforeEach( function( currentSpec ){ variables.mockdataCFC = getInstance( "MockData@MockDataCFC" ); - }); + } ); it( "can be created", function(){ - expect( mockDataCFC ).toBeComponent(); - }); + expect( mockDataCFC ).toBeComponent(); + } ); it( "can generate with defaults", function(){ var r = mockDataCFC.mock(); - expect( r.len() ).toBe( 10 ); - }); + expect( r.len() ).toBe( 10 ); + } ); it( "can generate autoincrementing IDs", function(){ - var r = mockDataCFC.mock( id="autoincrement" ); - expect( r[ 1 ].id ).toBe( 1 ); - expect( r[ 10 ].id ).toBe( 10 ); - }); + var r = mockDataCFC.mock( id = "autoincrement" ); + expect( r[ 1 ].id ).toBe( 1 ); + expect( r[ 10 ].id ).toBe( 10 ); + } ); it( "can generate uuids", function(){ - var r = mockDataCFC.mock( id="uuid" ); - expect( r[ 1 ].id ).toBeUUID(); - }); + var r = mockDataCFC.mock( id = "uuid" ); + expect( r[ 1 ].id ).toBeUUID(); + } ); it( "can generate names", function(){ - var r = mockDataCFC.mock( name="name" ); - expect( r[ 1 ].name ).toInclude( " " ); - }); + var r = mockDataCFC.mock( name = "name" ); + expect( r[ 1 ].name ).toInclude( " " ); + } ); it( "can generate ages", function(){ - var r = mockDataCFC.mock( age="age" ); - expect( r[ 1 ].age ).toBeGTE( 18 ) - .toBeLTE( 75 ); - }); + var r = mockDataCFC.mock( age = "age" ); + expect( r[ 1 ].age ).toBeGTE( 18 ).toBeLTE( 75 ); + } ); it( "can generate all ages", function(){ - var r = mockDataCFC.mock( age="all_age" ); - expect( r[ 1 ].age ).toBeGTE( 1 ) - .toBeLTE( 100 ); - }); + var r = mockDataCFC.mock( age = "all_age" ); + expect( r[ 1 ].age ).toBeGTE( 1 ).toBeLTE( 100 ); + } ); it( "can generate emails", function(){ - var r = mockDataCFC.mock( email="email" ); - expect( r[ 1 ].email ).toBeEmail(); - }); + var r = mockDataCFC.mock( email = "email" ); + expect( r[ 1 ].email ).toBeEmail(); + } ); it( "can generate ssn", function(){ - var r = mockDataCFC.mock( ssn="ssn" ); - expect( r[ 1 ].ssn ).toBeSSN(); - }); + var r = mockDataCFC.mock( ssn = "ssn" ); + expect( r[ 1 ].ssn ).toBeSSN(); + } ); it( "can generate telephones", function(){ - var r = mockDataCFC.mock( phone="tel" ); - expect( r[ 1 ].phone ).notToBeEmpty(); - }); + var r = mockDataCFC.mock( phone = "tel" ); + expect( r[ 1 ].phone ).notToBeEmpty(); + } ); it( "can generate dates", function(){ - var r = mockDataCFC.mock( createdOn="date" ); - expect( r[ 1 ].createdOn ).toBeDate(); - }); + var r = mockDataCFC.mock( createdOn = "date" ); + expect( r[ 1 ].createdOn ).toBeDate(); + } ); it( "can generate date times", function(){ - var r = mockDataCFC.mock( createdOn="datetime" ); - expect( r[ 1 ].createdOn ).toBeDate(); - }); + var r = mockDataCFC.mock( createdOn = "datetime" ); + expect( r[ 1 ].createdOn ).toBeDate(); + } ); it( "can generate numbers", function(){ - var r = mockDataCFC.mock( value="num" ); - expect( r[ 1 ].value ).toBeNumeric() - .toBeLTE( 10 ); - }); + var r = mockDataCFC.mock( value = "num" ); + expect( r[ 1 ].value ).toBeNumeric().toBeLTE( 10 ); + } ); it( "can generate numbers with randomness", function(){ - var r = mockDataCFC.mock( value="num:5" ); - expect( r[ 1 ].value ).toBeNumeric() - .toBeLTE( 5 ); + var r = mockDataCFC.mock( value = "num:5" ); + expect( r[ 1 ].value ).toBeNumeric().toBeLTE( 5 ); - var r = mockDataCFC.mock( value="num:5:6" ); - expect( r[ 1 ].value ).toBeNumeric() + var r = mockDataCFC.mock( value = "num:5:6" ); + expect( r[ 1 ].value ) + .toBeNumeric() .toBeLTE( 6 ) - .toBeGTE( 5); - }); + .toBeGTE( 5 ); + } ); it( "can generate one ofs", function(){ - var r = mockDataCFC.mock( gender="oneof:male:female" ); - expect( r[ 1 ].gender ).toMatch( "(male|female)" ); - }); + var r = mockDataCFC.mock( gender = "oneof:male:female" ); + expect( r[ 1 ].gender ).toMatch( "(male|female)" ); + } ); it( "can generate lorem", function(){ - var r = mockDataCFC.mock( notes="lorem" ); - expect( r[ 1 ].notes ).toinclude( "lorem" ); - }); + var r = mockDataCFC.mock( notes = "lorem" ); + expect( r[ 1 ].notes ).toinclude( "lorem" ); + } ); it( "can generate bacon lorem", function(){ - var r = mockDataCFC.mock( notes="baconlorem" ); - expect( r[ 1 ].notes ).toinclude( "bacon" ); - }); + var r = mockDataCFC.mock( notes = "baconlorem" ); + expect( r[ 1 ].notes ).toinclude( "bacon" ); + } ); it( "can generate sentences", function(){ - var r = mockDataCFC.mock( notes="sentence" ); - expect( r[ 1 ].notes ).notToBeEmpty(); - }); + var r = mockDataCFC.mock( notes = "sentence" ); + expect( r[ 1 ].notes ).notToBeEmpty(); + } ); it( "can generate words", function(){ - var r = mockDataCFC.mock( notes="words" ); - expect( r[ 1 ].notes ).notToBeEmpty(); - }); + var r = mockDataCFC.mock( notes = "words" ); + expect( r[ 1 ].notes ).notToBeEmpty(); + } ); it( "can generate custom data", function(){ - var r = mockDataCFC.mock( test = function( index ){ return "hello"; } ); - expect( r[ 1 ].test ).toBe( "hello" ); - }); + var r = mockDataCFC.mock( + test = function( index ){ + return "hello"; + } + ); + expect( r[ 1 ].test ).toBe( "hello" ); + } ); it( "can generate a website", function(){ var r = mockDataCFC.mock( homepage = "website" ); - expect( r[ 1 ].homepage ).toBeUrl(); - }); + expect( r[ 1 ].homepage ).toBeUrl(); + } ); it( "can generate https only websites", function(){ var r = mockDataCFC.mock( homepage = "website_https" ); r.each( function( item ){ expect( item.homepage ).toInclude( "https" ); } ); - }); + } ); it( "can generate http only websites", function(){ var r = mockDataCFC.mock( homepage = "website_http" ); r.each( function( item ){ expect( item.homepage ).toInclude( "http:" ); } ); - }); + } ); it( "can generate a url", function(){ var r = mockDataCFC.mock( homepage = "url" ); debug( r ); - expect( r[ 1 ].homepage ).toBeUrl(); - }); + expect( r[ 1 ].homepage ).toBeUrl(); + } ); it( "can generate an image url", function(){ var r = mockDataCFC.mock( homepage = "imageurl" ); debug( r ); - expect( r[ 1 ].homepage ).toBeUrl(); - }); + expect( r[ 1 ].homepage ).toBeUrl(); + } ); it( "can generate a string", function(){ var r = mockDataCFC.mock( test = "string" ); debug( r ); - expect( r[ 1 ].test ).toHaveLength( 10 ); - }); + expect( r[ 1 ].test ).toHaveLength( 10 ); + } ); + + it( "can generate an alpha string", function(){ + var r = mockDataCFC.mock( test = "string-alpha" ); + debug( r ); + expect( r[ 1 ].test ).toHaveLength( 10 ); + } ); + it( "can generate a secure string", function(){ + var r = mockDataCFC.mock( test = "string-secure" ); + debug( r ); + expect( r[ 1 ].test ).toHaveLength( 10 ); + } ); + it( "can generate a numeric string", function(){ + var r = mockDataCFC.mock( test = "string-numeric" ); + debug( r ); + expect( r[ 1 ].test ).toHaveLength( 10 ); + } ); it( "can generate a big string", function(){ var r = mockDataCFC.mock( test = "string:200" ); debug( r ); - expect( r[ 1 ].test ).toHaveLength( 200 ); - }); + expect( r[ 1 ].test ).toHaveLength( 200 ); + } ); it( "can generate an ip address", function(){ var r = mockDataCFC.mock( test = "ipaddress" ); @@ -178,12 +193,20 @@ component extends="coldbox.system.testing.BaseTestCase" appMapping="root"{ reFindNoCase( "^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$", r[ 1 ].test - ) + ) ).toBeTrue(); - }); - - }); - + } ); + + it( "can generate a struct $returnType", function(){ + var r = mockDataCFC.mock( + $returnType = "struct", + test = "string:200", + name = "name" + ); + debug( r ); + expect( r ).toBeStruct().toHaveKey( "test,name" ); + } ); + } ); } -} \ No newline at end of file +}