What is the regexp for the space between two letters of a same word in Ruby

The code executes well but I am missing a spec: the space between letters of the same word must be replaced by an empty space in morse. For example: hi in morse would be .... .. (4 dots, space, 2 dots)....the code is not recognizing the way I am representing this separation in my master hash --> "" => " "

Any thoughts on what am I missing?. Thanks

My code is as follows:

MASTER = { "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" => "--..",
           "," => " ",
           ""  => " ",
           "'" => " " }

def encode(text)
  # TODO: write a method which returns the morse sentence for the given text
  # NOTE: you may want to extract a `encode_word` method
  encode_word = ""
  text.chars.each { |element| encode_word << element.gsub(/(\w|\W)/, MASTER) }
  encode_word
end

Split the text by space (or perhaps any whitespace) into words, translate each character in those words using your morse code substitution table and then join everything back together (join chars with a space, words with a pipe). Something like

def encode(text)
  text.split(" ").map do |word|
    word.each_char.map do |char|
      MASTER[char]
    end.join(" ")
  end.join("|")
end

Note

• this will start to fail as soon as you have input that is not contained in your morse table. E.g. a an é will cause an error.
• Since upper/lowercase is the same in morse, you can drop half the table and make sure you lookup with the correct case. E.g. drop lower case and do lookup like this MASTER[char.upcase]

Code

First let us get the hash equivalent from the hash using word.chars.map { |letter| MASTER[letter] } and then we use this regular expression /(?<=\w) (?=\w)/ to replace the empty space.

def encode(text)
  text.gsub(/\w+/) do |word|
    word.chars.map { |letter| MASTER[letter] }.join("").gsub(/(?<=\w) (?=\w)/, "")
  end
end

Example input

text = "hello world"
p encode(text)

Output

"......-...-..--- .-----.-..-..-.."

Let master be the hash given in the question.

Suppose

text = "Little Miss Muffet"

We can modify text as follows.

text.gsub(/.(?=(.))?/) do |c|
  MASTER[c] + ((c != ' ' && $1 && $1 != ' ') ? ' ' : '')
end
  #=> ".-.. .. - - .-.. .|-- .. ... ...|-- ..- ..-. ..-. . -"

See String#gsub.

The regular expression has the following elements.

.       # match any character (other than a line terminator)
(?=     # begin a positive lookahead
  (.)   # match any character and save it to capture group 1
)?      # end the positive lookahead and make it optional

If the first character matched is followed by another character the positive lookahead will be executed and the following character will be saved to capture group 1 and held by the global variable $1.

The forward lookahead will not be executed if the first character matched is the last character in the string. In this case $1 #=> nil.

The expression

c != ' ' && $1 && $1 != ' '

reads, "The character matched ('c') is neither a space nor is the last character of the string ($1) and the following character is not a space ($1 != ' ')".

Note that this approach manipulates the string directly, rather than breaking it into words, converting each word to array of letters, manipulate those arrays and then converting the result back to a string.