Creating a Wordle with TDD in Javascript

We maintain training this wonderful Kata and studying. You’ll be able to observe the steps!

TL;DR: Javascript can be superior for TDD

Throughout January 2022 Wordle rush, I wrote an article describing how to create a Wordle with TDD using PHP.

How to Develop a Wordle Game using TDD in 25 Minutes

A couple of months after, I transcribed the UI model of a Wordle created with Codex Artificial Intelligence.

Step by Step Wordle Creation With Codex AI

I’ll mix each worlds to program as a Centaur.

I can even examine the method and output from totally different language variations.

That is the Javascript model.

---

As standard, we are going to give attention to the sport enterprise logic, realizing we will construct the consumer interface with natural language commands.

On this article, I’ll use a repl.it with Jest.

Javascript has many Unit testing frameworks.

You need to use no matter you want.

Let’s start…

Following the identical rules as the previous article, we are going to begin by defining a Wordle Phrase.

The smallest data quantity in Wordle is a phrase.

We will argue that letter is smaller, however all wanted letter protocol is already outlined (we may be incorrect).

A phrase shouldn’t be a char(5).

A phrase shouldn’t be an array.

A phrase shouldn’t be a string.

This can be a frequent mistake and a bijection violation.

A phrase and a string have totally different duties, although they could intersect.

Mixing (unintentional) implementation particulars with (essential) conduct is a widespread mistake.

So we have to outline what’s a phrase.

A phrase in Wordle is a legitimate 5-letter phrase.

Let’s begin with our joyful path:

take a look at("test01ValidWordLettersAreValid", async perform() 
  const phrase = new Phrase('legitimate');
  count on(['v', 'a', 'l', 'i', 'd']).toStrictEqual(phrase.letters());
);

We assert that prompting for letters in ‘legitimate’ returns an array of the letters.

That is the end result:

Message: letters from phrase should be 'legitimate'
Stack Hint:
ReferenceError: Phrase shouldn't be outlined
    at Object.<nameless> (/house/runner/Wordle-TDD/_test_runnertest_suite.js:6:18)
    at Promise.then.accomplished (/house/runner/Wordle-TDD/node_modules/jest-circus/construct/utils.js:333:28)    

That is wonderful since we’ve not outlined what a phrase is.

Discover

• This can be a TDD Sample.
• We identify the objects following their conduct even earlier than they exist.
• Phrase class shouldn’t be outlined but.
• Our Phrase’s first trivial duty is to reply its letters.
• This isn’t a getter. Each wordle phrase should reply its letters.
• We do not care about letter sorting. That might be a untimely optimization and gold plating state of affairs.
• We begin with a easy instance. No duplicated.
• We do not mess with phrase validation but (the phrase may be XXXXX).
• We will begin with a less complicated take a look at validating the phrase is created. This might violate the take a look at construction that all the time requires an assertion.
• The anticipated worth ought to all the time be the primary within the assertion.

We have to create a Phrase with the letters() perform.

class Phrase 
  letters() 
    return ['v', 'a', 'l', 'i', 'd'];
    

Discover

• We do not want constructors (but).
• We hardcode letters perform since that is the best attainable answer thus far.
• Pretend it until we make it.

We run all of the exams (simply 1) and we’re OK.

✅  test01ValidWordLettersAreValid

  All exams have handed 1/1  

---

Let’s write one other take a look at:

take a look at("test02FewWordLettersShouldRaiseException", async perform() 
  count on(() =>  
    new Phrase('vali');                 
               ).toThrow(Error);
);

The take a look at fails as anticipated…

❌  test02FewWordLettersShouldRaiseException
Stack Hint:
Error: count on(obtained).toThrow(anticipated)

Anticipated constructor: Error

Acquired perform didn't throw
    at Object.toThrow (/house/runner/Wordle-TDD/_test_runnertest_suite.js:10:23)

✅  test01ValidWordLettersAreValid

  1/2 handed, see errors above  

Discover

• The primary take a look at handed
• The second take a look at is predicted to throw an exception. Which it did not.
• We simply declare a generic exception will probably be raised.
• We simply elevate a generic Error.
• Creating particular exceptions is a code smell that pollutes namespaces. (until we catch it, however this isn’t taking place proper now).

We have to change our implementation to make test02 go (and likewise test01).

class Phrase 
  constructor(phrase) 
    if (phrase.size < 5)
      throw new Error('Too few letters. Ought to be 5');
  
  letters() 
      return ['v', 'a', 'l', 'i', 'd'];
    

And the exams go.

✅  test02FewWordLettersShouldRaiseException

✅  test01ValidWordLettersAreValid

  All exams have handed 2/2  

Discover

• We’re not utilizing the constructor argument to arrange the precise letters (but).
• We simply test for a couple of letters. Not for too many since we do not have but a masking take a look at.
• TDD requires full protection. Including one other test with no take a look at is a method violation.

Let’s test for too many.

take a look at("test03TooManyWordLettersShouldRaiseException", async perform() 
  count on(() =>  
    new Phrase('toolong');                 
               ).toThrow(Error);

);

We run them:

❌  test03TooManyWordLettersShouldRaiseException
Stack Hint:
Error: count on(obtained).toThrow(anticipated)

Anticipated constructor: Error

Acquired perform didn't throw
    at Object.toThrow (/house/runner/Wordle-TDD/_test_runnertest_suite.js:10:23)

✅  test02FewWordLettersShouldRaiseException

✅  test01ValidWordLettersAreValid

  2/3 handed, see errors above  

We add the validation:

class Phrase 
  constructor(letters) 
    if (letters.size < 5)
      throw new Error('Too few letters. Ought to be 5');
    if (letters.size > 5)
      throw new Error('Too many letters. Ought to be 5');
  
  letters() 
      return ['v', 'a', 'l', 'i', 'd'];
    

And all exams handed.

All exams have handed 3/3  

---

We will now make an (elective) refactor and alter the perform to claim a spread as a substitute of two boundaries.
We resolve to depart it this manner since it’s extra declarative.

We will additionally add a take a look at for zero phrases following the Zombie methodology.

Let’s do it.

take a look at("test04EmptyLettersShouldRaiseException", async perform() 
  count on(() =>  
    new Phrase('');                 
               ).toThrow(Error);

);

✅  test04EmptyLettersShouldRaiseException

✅  test03TooManyWordLettersShouldRaiseException

✅  test02FewWordLettersShouldRaiseException

✅  test01ValidWordLettersAreValid

It’s no shock the take a look at passes since we have already got a take a look at masking this state of affairs.

As this take a look at provides no worth, we must always take away it.

---

Let’s test now what are legitimate letters:

take a look at("test05InvalidLettersShouldRaiseException", async perform() 
   count on(() =>  
    new Phrase('vali*');                 
               ).toThrow(Error);

);

… and the take a look at is damaged since no assertion is raised.

❌  test05InvalidLettersShouldRaiseException
Stack Hint:
Error: count on(obtained).toThrow(anticipated)

Anticipated constructor: Error

Acquired perform didn't throw

We have to appropriate the code…

class Phrase 
  constructor(phrase) 
    if (phrase.size < 5)
      throw new Error('Too few letters. Ought to be 5');
    if (phrase.size > 5)
      throw new Error('Too many letters. Ought to be 5');
    if (phrase.indexOf('*') > -1) 
      throw new Error('Phrase has invalid letters');
  

And all exams go since we’re clearly hardcoding.

All exams have handed 5/5  

Discover

• We hardcode the asterisc to be the one invalid character (so far as we all know).
• We will place the checking code earlier than or after the earlier validations.
  — Till we’ve got an invalid case (with invalid characters and invalid size) we can’t assume the anticipated conduct.

Let’s add extra invalid letters and proper the code.

take a look at("test06PointShouldRaiseException", async perform() 
   count on(() =>  
    new Phrase('val.d');                 
               ).toThrow(Error);

);

// Resolution

 constructor(phrase) 
    if (phrase.indexOf('*') > -1) 
      throw new Error('Phrase has invalid letters');
    if (phrase.indexOf('.') > -1) 
      throw new Error('Phrase has invalid letters');

Discover

• We did not write a extra generic perform (but) since we can’t appropriate exams and refactor on the similar time (the approach forbids us).

All of the exams are okay.

We will refactor.

We substitute the final two sentences.

class Phrase {
  constructor(phrase) 
    if (phrase.size < 5)
      throw new Error('Too few letters. Ought to be 5');
    if (phrase.size > 5)
      throw new Error('Too many letters. Ought to be 5');
    // Refactor  
    if (!phrase.match(/^[a-z]+$/i)) 
      throw new Error('phrase has invalid letters');
    //   

Discover

• We will refactor provided that we do not change the exams on the similar time.
• The assertion checks just for uppercase letters. Since we’re coping with these examples thus far.
• We defer design choices as a lot as attainable.
• We outlined an everyday expression primarily based on English Letters. We’re fairly certain it will not settle for Spanish (ñ), German(ë), and many others.

As a checkpoint, we’ve got solely 5 letter phrases any more.

Lets assert on letters() perform.

We left it exhausting coded.

TDD Opens many paths.

We have to maintain monitor of all of them till we open new ones.

We have to examine phrases.

take a look at("test07TwoWordsAreNotTheSame", async perform() 
    const firstWord = new Phrase('legitimate');
    const secondWord = new Phrase('joyful');
    count on(firstWord).not.toStrictEqual(secondWord);
);

take a look at("test08TwoWordsAreTheSame", async perform() 
    const firstWord = new Phrase('legitimate');
    const secondWord = new Phrase('legitimate');
    count on(firstWord).toStrictEqual(secondWord);
);

And the take a look at fails.

Let’s use the parameter we’re sending to them.

class Phrase 
  constructor(phrase)  
    // ...
    this._word = phrase;
  
  letters() 
      return ['v', 'a', 'l', 'i', 'd'];
    

✅  test08TwoWordsAreTheSame

✅  test07TwoWordsAreNotTheSame

✅  test06PointShouldRaiseException

✅  test05InvalidLettersShouldRaiseException

✅  test04EmptyLettersShouldRaiseException

✅  test03TooManyWordLettersShouldRaiseException

✅  test02FewWordLettersShouldRaiseException

✅  test01ValidWordLettersAreValid

  All exams have handed 8/8  

Discover

• We retailer the letters and that is sufficient for object comparability (it would depend upon the language).
• letters() perform continues to be hardcoded

---

We add a distinct phrase for letters comparability.

Keep in mind letters() perform was hardcoded till now.

take a look at("test09LettersForGrassWord", async perform() 
  const grassWord = new Phrase('grass'); 
  count on(['g','r','a','s','s']).toStrictEqual(grassWord.letters());
);

And the take a look at fails as anticipated.

❌  test09LettersForGrassWord
Stack Hint:
Error: count on(obtained).toStrictEqual(anticipated) // deep equality

- Anticipated  - 4
+ Acquired  + 4

  Array [
-   "v",
+   "g",
+   "r",
    "a",
-   "l",
-   "i",
-   "d",
+   "s",
+   "s",
  ]
    at Object.toStrictEqual (/house/runner/Wordle-TDD/_test_runnertest_suite.js:9:37)

Discover

• It is vitally vital to test for equality/inequality as a substitute of assertTrue() since many IDEs open a comparability software primarily based on the objects.
• That is one more reason to make use of IDEs and by no means textual content editors.

Let’s change the letters() perform since we have been faking it.

class Phrase 
  letters() 
      return this._word.break up("");
    

---

We want to verify comparisons should not case-sensitive.

take a look at("test10ComparisonIsCaseInsensitve", async perform() 
    const firstWord = new Phrase('legitimate');
    const secondWord = new Phrase('VALID');
    count on(firstWord).toStrictEqual(secondWord); 
);

Check fails.

We have to take a call.

We resolve all our domains will probably be lowercase.

We won’t permit uppercase letters regardless of the UI having caps.

We cannot do magic conversions.

We alter the take a look at to catch invalid uppercase letters and repair them.

take a look at("test10NoUppercaseAreAllowed", async perform() 
   count on(() =>  
    new Phrase('vAliD');                 
               ).toThrow(Error);
);

class Phrase {
  constructor(phrase) 
    // We take away the /i modifier on the common expression  
    if (!phrase.match(/^[a-z]+$/)) 
      throw new Error('phrase has invalid letters');   
  

Our phrases are in a bijection with English Wordle phrases. or not?

Let’s attempt a non-English phrase.

take a look at("test11XXXXIsnotAValidWord", async perform() 
  count on(() =>  
    new Phrase('XXXXX');                 
               ).toThrow(Error);
);

This take a look at fails.

We’re not catching invalid English 5-letter phrases.

Discover

• We have to decide. In line with our bijection, there’s an exterior dictionary asserting legitimate phrases.
• We will validate with the dictionary upon phrase creation. However we wish the dictionary to retailer legitimate wordle phrases. No strings.
• It’s an egg-chicken downside.
• We resolve to cope with invalid phrases within the dictionary and never the Wordle phrase.
• We take away the take a look at.
• We’ll discover a higher means in a couple of moments.

---

Let’s create the sport.

We begin speaking a few sport that doesn’t exist.

take a look at("test11EmptyGameHasNoWinner", async perform() 
  const sport = new Sport()
  count on(false).toStrictEqual(sport.hasWon());
);

Check fails.

We have to create the category and the perform.

class Sport 
  hasWon() 
      return false;
    

---

We implement phrases tried.

And the best answer.

Hardcoding as all the time.

take a look at("test12EmptyGameWordsAttempted", async perform() 
  const sport = new Sport()
  count on([]).toStrictEqual(sport.wordsAttempted());
);

class Sport 
  wordsAttempted() 
    return [];
  

✅  test12EmptyGameWordsAttempted
...
  All exams have handed 12/12  

take a look at("test13TryOneWordAndRecordIt", async perform() 
  var sport = new Sport();
  sport.addAttempt(new Phrase('loser'));
  count on([new Word('loser')]).toStrictEqual(sport.wordsAttempted());   
);

class Sport 
  constructor() 
    this._attempts = [];
  
  hasWon() 
      return false;
  
  wordsAttempted() 
    return this._attempts;
  
  addAttempt(phrase) 
    this._attempts.push(phrase);    
  

Discover

• We retailer the makes an attempt regionally and add the try and likewise change wordsAttempted() actual implementation.

---

We will implement hasLost() if it misses 6 makes an attempt.

With the best implementation as standard.

take a look at("test14TryOneWordAndDontLooseYet", async perform() 
  const sport = new Sport();
  sport.addAttempt(new Phrase('loser'));
  count on(false).toStrictEqual(sport.hasLost());   
);

class Sport  
  hasLost() 
      return false;
  

Discover

• We’re studying the foundations as our mannequin grows.

As all the time. We cease faking it and resolve to make it.

take a look at("test15TryFiveWordsLoses", async perform() 
  const sport = new Sport([new Word('loser'), new Word('music')], new Phrase('music'));
  sport.addAttempt(new Phrase('loser'));
  sport.addAttempt(new Phrase('loser'));
  sport.addAttempt(new Phrase('loser'));
  sport.addAttempt(new Phrase('loser'));
  sport.addAttempt(new Phrase('loser'));
  count on(false).toStrictEqual(sport.hasLost());  
  // final try
  sport.addAttempt(new Phrase('loser'));
  count on(true).toStrictEqual(sport.hasLost());  
);

class Sport 
  hasLost() 
    return this._attempts.size > 5;
  

Now we have many of the mechanics.

Let’s add legitimate phrases dictionary and play invalid.

take a look at("test16TryToPlayInvalid", async perform() 
  const sport = new Sport([]);  
  count on(() =>  
    sport.addAttempt(new Phrase('xxxxx'));            
               ).toThrow(Error);
);

The take a look at fails as anticipated.

We repair it.

class Sport 
  constructor(validWords) 
    this._attempts = [];
    this._validWords = validWords;
     
  addAttempt(phrase) 
    if (!this._validWords.some(validWord => validWord.sameAs(phrase))) 
      throw new Error(phrase.letters() + " shouldn't be a sound phrase");
    
    this._attempts.push(phrase);    
  


// repair earlier exams
// change 

const sport = new Sport([]);

// to 

const sport = new Sport([new Word('loser')]);

Additionally add: 
Class Phrase 
 sameAs(phrase) 
    return phrase.phrase() == this.phrase();
  

and the take a look at is fastened, however…

  test16TryToPlayInvalid

❌  test15TryFiveWordsLoses
Stack Hint:
TypeError: Can not learn properties of undefined (studying 'contains')

❌  test14TryOneWordAndDontLooseYet
Stack Hint:
TypeError: Can not learn properties of undefined (studying 'contains') 

❌  test13TryOneWordAndRecordIt
Stack Hint:
TypeError: Can not learn properties of undefined (studying 'contains')

✅  test12EmptyGameWordsAttempted

✅  test10EmptyGameHasNoWinner

  12/15 handed, see errors above  

Discover

• test13, test14, and test15 had been beforehand working.
• Now, they’re damaged since we added a brand new enterprise rule.
• We have to go the dictionary when creating the sport.
• We repair the three of them by including an array with the phrases we are going to use.
• It’s a good signal our setup will get complicated to maintain creating legitimate situations.

Now, we play to win.

We add the take a look at and wish to alter hasWon() accordingly.

take a look at("test17GuessesWord", async perform() 
  const phrases = [new Word('happy')];
  const correctWord = new Phrase('joyful');
  const sport = new Sport(phrases, correctWord);  
  count on(sport.hasWon()).toStrictEqual(false);
  sport.addAttempt(new Phrase('joyful'));
  count on(sport.hasWon()).toStrictEqual(true);
);

// we have to retailer the right phrase
class Sport {
  constructor(validWords, correctWord) 
    this._attempts = [];
    this._validWords = validWords;
    this._correctWord = correctWord;
  
  hasWon() 
    return this._attempts.some(try => try.sameAs(this._correctWord)); 

Discover

• We use no flags to test if somebody has gained. We will instantly test it.
• We do not care if it has gained in a earlier try.
• We make an addParameter refactor with this new aspect to earlier sport definitions.

---

We added the Appropriate Phrase.

We have to assert this phrase is within the dictionary.

take a look at("test18CorrectWordNotInDictionary", async perform() 
  const phrases = [new Word('happy')];
  const correctWord = new Phrase('heros');  
   count on(() =>  
     new Sport(phrases, correctWord);                 
               ).toThrow(Error);
);

class Sport {
  constructor(validWords, correctWord) 
    if (!validWords.some(validWord => validWord.sameAs(correctWord)))
      throw new Error("Appropriate phrase " + phrase.phrase() + " shouldn't be a sound phrase");  
  

Discover

• We would have liked to alter all earlier video games since we would have liked to go the winner sport earlier than the beginning
• This can be a good aspect impact because it favors full and immutable objects.

---

✅  test18CorrectWordNotInDictionary
...

✅  test01ValidWordLettersAreValid

  All exams have handed 17/17  

What occurs if we win within the ultimate try?

Zombies ask us all the time to test for (B)boundaries the place bugs disguise.

take a look at("test19TryFiveWordsWins", async perform() 
  const sport = new Sport([new Word('loser'),new Word('heros')],new Phrase('heros'));
  sport.addAttempt(new Phrase('loser'));
  sport.addAttempt(new Phrase('loser'));
  sport.addAttempt(new Phrase('loser'));
  sport.addAttempt(new Phrase('loser'));
  sport.addAttempt(new Phrase('loser'));
  count on(false).toStrictEqual(sport.hasLost());  
  count on(false).toStrictEqual(sport.hasWon());  
  // final try
  sport.addAttempt(new Phrase('heros'));
  count on(false).toStrictEqual(sport.hasLost());  
  count on(true).toStrictEqual(sport.hasWon());  
);

// And the correction

hasLost() 
    return !this.hasWon() && this._attempts.size > 5;
  

---

Now we have all of the mechanics.

Let’s add the letter’s positions.

We will do it in Phrase class.

take a look at("test20LettersDoNotMatch", async perform() 
  const firstWord = new Phrase('bushes');
  const secondWord = new Phrase('legitimate');
  count on([]).toStrictEqual(firstWord.matchesPositionWith(secondWord));
);

As standard, we get an undefined perform error:

❌  test20LettersDoNotMatch
Stack Hint:
TypeError: firstWord.matchesPositionWith shouldn't be a perform

Let’s faux it as standard.

class Phrase 
  matchesPositionWith(correctWord) 
    return [];    
  

Discover

• Names are all the time crucial.
• We will identify the parameter anotherWord.
• We choose correctWord.
• We’re conscious we are going to quickly want a sophisticated algorithm and roles needs to be clear and contextual.

---

Let’s match

take a look at("test21MatchesFirstLetter", async perform() 
  const guessWord = new Phrase('bushes');
  const correctWord = new Phrase('desk');
  count on([1]).toStrictEqual(guessWord.matchesPositionWith(correctWord));
);

Fails.

We have to outline it higher

This can be a ok algorithm.

Ugly and crucial

We’ll refactor it later, for certain.

matchesPositionWith(correctWord) 
   var positions = [];
   for (var currentPosition = 0; 
      currentPosition < this.letters().size; 
      currentPosition++) 
       if (this.letters()[currentPosition] == correctWord.letters()[currentPosition]) 
             positions.push(currentPosition + 1); 
             //People begin relying on 1
       
   
   return positions;

And all of the exams go.

Discover

• The matching property shouldn’t be symmetric

---

Now we’d like the ultimate steps.

Matching in incorrect positions.

and all the time the best answer…

take a look at("test23MatchesIncorrectPositions", async perform() 
  const guessWord = new Phrase('bushes');
  const correctWord = new Phrase('drama');
  count on([2]).toStrictEqual(guessWord.matchesPositionWith(correctWord));
  count on([]).toStrictEqual(guessWord.matchesIncorrectPositionWith(correctWord));
);

// The best answer

class Phrase 
  matchesIncorrectPositionWith(correctWord) 
     return [];
  

Discover

• By including these protected, zero instances we miss many standard bugs.

A extra spicy take a look at case.

take a look at("test24MatchesIncorrectPositionsWithMatch", async perform() 
  const guessWord = new Phrase('alarm');
  const correctWord = new Phrase('drama');
  count on([3]).toStrictEqual(guessWord.matchesPositionWith(correctWord));
  count on([1, 4, 5]).toStrictEqual(guessWord.matchesIncorrectPositionWith(correctWord));
  // A*ARM vs *RAMA
  count on([3]).toStrictEqual(correctWord.matchesPositionWith(guessWord));
  count on([2, 4, 5]).toStrictEqual(correctWord.matchesIncorrectPositionWith(guessWord));
);

Let’s go for the implementation

 class Phrase 
  matchesIncorrectPositionWith(correctWord) 
      var positions = [];
      for (var currentPosition = 0; currentPosition < 5; currentPosition++) 
        if (correctWord.letters().contains(this.letters()[currentPosition])) 
          positions.push(currentPosition + 1);
        
      
      return positions.filter(perform(place) 
        return !this.matchesPositionWith(correctWord).contains(place);
     .bind(this));
    
  
}

That is it.

Now we have applied a really small mannequin with all significant guidelines.

All exams have handed 21/21  

take a look at("test20220911", async perform() 
  const correctWord = new Phrase('tibia');
    // Sorry for the spoiler
  const phrases = [
    // all the words I've tried
    new Word('paper'), 
    new Word('tools'),
    new Word('music'),
    new Word('think'), 
    new Word('twins'),
    new Word('tight'),
    // plus the winning word
    correctWord
  ];
  
  const sport = new Sport(phrases, correctWord);  
  count on(sport.hasWon()).toStrictEqual(false);
  count on(sport.hasLost()).toStrictEqual(false);
  // P(A)PER vs TIBIA
  sport.addAttempt(new Phrase('paper'));
  count on([]).toStrictEqual((new Phrase('paper')).matchesPositionWith(correctWord));
  count on([2]).toStrictEqual((new Phrase('paper')).matchesIncorrectPositionWith(correctWord));
  // [T]OOLS vs TIBIA
  count on([1]).toStrictEqual((new Phrase('instruments')).matchesPositionWith(correctWord));
  count on([]).toStrictEqual((new Phrase('instruments')).matchesIncorrectPositionWith(correctWord));  
  sport.addAttempt(new Phrase('instruments'));
  // MUS[I]C vs TIBIA
  count on([4]).toStrictEqual((new Phrase('music')).matchesPositionWith(correctWord));
  count on([]).toStrictEqual((new Phrase('music')).matchesIncorrectPositionWith(correctWord));
  sport.addAttempt(new Phrase('music'));
  // [T]H(I)NK vs TIBIA
  count on([1]).toStrictEqual((new Phrase('suppose')).matchesPositionWith(correctWord));
  count on([3]).toStrictEqual((new Phrase('suppose')).matchesIncorrectPositionWith(correctWord));
  sport.addAttempt(new Phrase('suppose'));
  // [T]W(I)NS vs TIBIA
  count on([1]).toStrictEqual((new Phrase('twins')).matchesPositionWith(correctWord));
  count on([3]).toStrictEqual((new Phrase('twins')).matchesIncorrectPositionWith(correctWord));  
  sport.addAttempt(new Phrase('twins'));  
  count on(sport.hasWon()).toStrictEqual(false);
  count on(sport.hasLost()).toStrictEqual(false);
  // [T][I]GHT vs TIBIA
  count on([1, 2]).toStrictEqual((new Phrase('tight')).matchesPositionWith(correctWord));
  count on([]).toStrictEqual((new Phrase('tight')).matchesIncorrectPositionWith(correctWord));  
  
  sport.addAttempt(new Phrase('tight'));
  count on(sport.hasWon()).toStrictEqual(false);
  count on(sport.hasLost()).toStrictEqual(true);
);

---

(You can find extra each day examples within the repo)

I used to be very proud of my working wordle.

Then I examine its complex rules

Studying new guidelines shouldn’t be an issue when we’ve got TDD.

Let’s cowl the examples from the article

take a look at("test25VeryComplexWrongPositions", async perform() 

  const guessWord = new Phrase('geese');
  const correctWord = new Phrase('these');
  count on([4, 5]).toStrictEqual(guessWord.matchesPositionWith(correctWord));
  count on(['s','e']).toStrictEqual(guessWord.lettersAtCorrectPosition(correctWord));
  count on([]).toStrictEqual(guessWord.lettersAtWrongtPosition(correctWord));
  count on([]).toStrictEqual(guessWord.matchesIncorrectPositionWith(correctWord));
  // GEE[S][E] vs THOSE

  const anotherGuessWord = new Phrase('added');
  const anotherCorrectWord = new Phrase('dread');
  count on([5]).toStrictEqual(anotherGuessWord.matchesPositionWith(anotherCorrectWord));
  count on(['d']).toStrictEqual(anotherGuessWord.lettersAtCorrectPosition(anotherCorrectWord));
  count on(['a', 'd', 'e']).toStrictEqual(anotherGuessWord.lettersAtWrongtPosition(anotherCorrectWord));
  count on([1, 2, 4]).toStrictEqual(anotherGuessWord.matchesIncorrectPositionWith(anotherCorrectWord));
  // (A)(D)D(E)[D] vs DREAD
  
  const yetAnotherGuessWord = new Phrase('mamma');
  const yetAnotherCorrectWord = new Phrase('maxim');
  count on([1, 2]).toStrictEqual(yetAnotherGuessWord.matchesPositionWith(yetAnotherCorrectWord));
  count on(['m', 'a']).toStrictEqual(yetAnotherGuessWord.lettersInCorrectPosition(yetAnotherCorrectWord));
  count on(['m']).toStrictEqual(yetAnotherGuessWord.lettersAtWrongtPosition(yetAnotherCorrectWord));
  count on([3]).toStrictEqual(yetAnotherGuessWord.matchesIncorrectPositionWith(yetAnotherCorrectWord));
  // [M][A](M)MA vs MAXIM
);

Let’s steal the algorithm from the article.

matchesIncorrectPositionWith(correctWord)      
    const correctPositions = this.matchesPositionWith(correctWord);
    var incorrectPositions = [];
    var correctWordLetters = correctWord.letters();
    var ownWordLetters = this.letters();
    for (var currentPosition = 0; currentPosition < 5; currentPosition++) 
      if (correctPositions.contains(currentPosition + 1)) 
        // We will use these wildcards since they're no legitimate letters
        correctWordLetters.splice(currentPosition, 1, '*');
        ownWordLetters.splice(currentPosition, 1, '+');
      
        
    for (var currentPosition = 0; currentPosition < 5; currentPosition++) 
      const positionInCorrectWord = correctWordLetters.indexOf(ownWordLetters[currentPosition]);
      if (positionInCorrectWord != -1)         
        correctWordLetters.splice(positionInCorrectWord, 1, '*');
        ownWordLetters.splice(currentPosition, 1, '+');
        incorrectPositions.push(currentPosition + 1); 
      
        
    return incorrectPositions;
  

We have to add one other perform (which will probably be helpful for keyboard colours).

lettersAtCorrectPosition(correctWord) 
    return this.matchesPositionWith(correctWord).map(place => this.letters()[position -1 ]);

  
lettersAtWrongtPosition(correctWord) 
    return this.matchesIncorrectPositionWith(correctWord).map(place => this.letters()[position -1]);

Discover

• The algorithm adjustments a replica of the right phrase by inserting ‘*’ when the right place matches
• It additionally hides the visited letters by altering to a particular (an invalid ‘+’).

DREAD vs ADDED
DREA* vs ADDE+
DRE** vs +DDE+
*RE** vs ++DE+
*R*** vs ++D++

This answer is totally different and extra full than the previous one.

The wordle guidelines haven’t modified.

In line with David Farley, we have to be specialists at studying.

And we study by training katas like this one.

We find yourself with 2 compact courses the place we outlined our enterprise mannequin.

This small mannequin has an actual 1:1 bijection within the MAPPER to the true world.

It is able to evolve.

This sport is a metaphor for actual software program engineering.

Hope you discover it attention-grabbing and observe the kata with me.

You’ll be able to mess around with the working repl.it.

• Mix this answer with the AI-Generated
• Use an actual dictionary
• Change the language and alphabet
• Change the foundations to a distinct wordle

---

Additionally Printed Here