170 tests pass and counting

Author: Arjan Scherpenisse

lib/speech_markdown/grammar.ex

@@ -62,7 +62,8 @@ defmodule SpeechMarkdown.Grammar do
 
   identifier =
     reduce(
-      repeat(ascii_char('_abcdefghijklmnopqrstuvwxyz1234567890')),
+      ascii_char('_abcdefghijklmnopqrstuvwxyz1234567890')
+      |> concat(repeat(ascii_char('_abcdefghijklmnopqrstuvwxyz1234567890'))),
       :to_string
     )
 
@@ -101,12 +102,16 @@ defmodule SpeechMarkdown.Grammar do
     |> ignore(string("]"))
     |> unwrap_and_tag(:audio)
 
+  defp empty_block(_x) do
+    :empty_block
+  end
+
   parenthesized =
     ignore(string("("))
-    #    |> reduce(repeat(utf8_char([{:not, ?)}])), :to_string)
-    |> concat(parsec(:document))
+    |> reduce(repeat(utf8_char([{:not, ?)}])), :to_string)
+    #    |> concat(parsec(:document))
     |> ignore(string(")"))
-    |> parsec(:block)
+    |> choice([parsec(:block), string("[]") |> reduce(:empty_block)])
     |> reduce(:nested_block)
 
   ipa =
@@ -134,7 +139,7 @@ defmodule SpeechMarkdown.Grammar do
   )
 
   def nested_block([a, b]) do
-    {:nested_block, a, b}
+    {:nested_block, [{:text, a}], b}
   end
 
   def kv_block(x) do
@@ -154,8 +159,9 @@ defmodule SpeechMarkdown.Grammar do
   non_ctrl_instr =
     utf8_char((@ws ++ [?), ?], ?[, ?(, 35, ?!]) |> Enum.map(&{:not, &1}))
 
+  # [{:not, ?[}, {:not, ?)}])
   plaintext =
-    utf8_char([{:not, ?[}, {:not, ?)}])
+    utf8_char([])
     |> reduce(:to_string)
     |> unwrap_and_tag(:text)
 
@@ -168,6 +174,7 @@ defmodule SpeechMarkdown.Grammar do
     |> repeat(utf8_char([{:not, char}]))
     |> reduce(:to_string)
     |> ignore(string(abbrev))
+    |> lookahead(choice([ws, eos()]))
     |> reduce({:short_emphasis, [emphasis]})
   end
 
@@ -185,9 +192,9 @@ defmodule SpeechMarkdown.Grammar do
   defparsec(
     :document,
     choice([
+      parenthesized,
       section,
       audio,
-      parenthesized,
       parsec(:block),
       parsec(:any_emphasis),
       plaintext

lib/speech_markdown/transpiler.ex

@@ -35,6 +35,11 @@ defmodule SpeechMarkdown.Transpiler do
      |> opt_strip_declaration(xml_declaration)}
   end
 
+  ### EMPTY BLOCK
+  defp convert({:nested_block, nodes, :empty_block}, variant) do
+    Enum.map(nodes, &convert(&1, variant))
+  end
+
   ### BREAK
 
   defp convert({:kv_block, [{"break", break}]}, _variant) do
@@ -60,7 +65,18 @@ defmodule SpeechMarkdown.Transpiler do
 
   ### SECTIONS
 
-  defp convert({:section, block, nodes}, :alexa) do
+  defp convert({:section, [{_, _} | _] = attrs, nodes}, :alexa) do
+    {alexa_attrs, attrs} =
+      Enum.split_with(attrs, &(elem(&1, 0) in ~w(excited disappointed)))
+
+    nodes
+    |> Enum.map(&convert(&1, :alexa))
+    |> wrap_with_voice_and_or_lang(attrs)
+    |> Alexa.emotion(alexa_attrs)
+    |> unwrap_single_node()
+  end
+
+  defp convert({:section, block, nodes}, :alexa) when is_binary(block) do
     nodes
     |> Enum.map(&convert(&1, :alexa))
     |> Alexa.emotion(block)
@@ -102,6 +118,74 @@ defmodule SpeechMarkdown.Transpiler do
     Enum.map(nodes, &convert(&1, variant))
   end
 
+  ### WHISPER
+  defp convert({:nested_block, nodes, {:block, "whisper"}}, :alexa) do
+    nodes = Enum.map(nodes, &convert(&1, :alexa))
+    {:"amazon:effect", [name: 'whispered'], nodes}
+  end
+
+  defp convert({:nested_block, nodes, {:block, "whisper"}}, variant) do
+    nodes = Enum.map(nodes, &convert(&1, variant))
+    {:prosody, [volume: 'x-soft', rate: 'slow'], nodes}
+  end
+
+  ### PROSODY
+
+  defp convert(
+         {:nested_block, nodes, {:kv_block, [{"volume", volume}]}},
+         variant
+       ) do
+    {:prosody, [volume: volume], Enum.map(nodes, &convert(&1, variant))}
+  end
+
+  defp convert(
+         {:nested_block, nodes, {:kv_block, [{"pitch", pitch}]}},
+         variant
+       ) do
+    {:prosody, [pitch: pitch], Enum.map(nodes, &convert(&1, variant))}
+  end
+
+  defp convert(
+         {:nested_block, nodes, {:kv_block, [{"rate", rate}]}},
+         variant
+       ) do
+    {:prosody, [rate: rate], Enum.map(nodes, &convert(&1, variant))}
+  end
+
+  ### LANG
+
+  defp convert({:nested_block, nodes, {:kv_block, [{"lang", _}]}}, :google) do
+    Enum.map(nodes, &convert(&1, :google))
+  end
+
+  defp convert({:nested_block, nodes, {:kv_block, [{"lang", lang}]}}, variant) do
+    {:lang, ["xml:lang": ch(lang)], Enum.map(nodes, &convert(&1, variant))}
+  end
+
+  ### SUB
+
+  defp convert({:nested_block, nodes, {:kv_block, [{"sub", sub}]}}, variant) do
+    {:sub, [alias: ch(sub)], Enum.map(nodes, &convert(&1, variant))}
+  end
+
+  ### VOICE
+
+  defp convert({:nested_block, nodes, {:kv_block, [{"voice", voice}]}}, :alexa) do
+    nodes = Enum.map(nodes, &convert(&1, :alexa))
+
+    case Validator.alexa_voice(voice) do
+      nil ->
+        nodes
+
+      voice ->
+        {:voice, [name: ch(voice)], nodes}
+    end
+  end
+
+  defp convert({:nested_block, nodes, {:kv_block, [{"voice", _}]}}, variant) do
+    Enum.map(nodes, &convert(&1, variant))
+  end
+
   ### SAY-AS
   defp convert(
          {:nested_block, nodes, {:kv_block, [{"emphasis", level}]}},
@@ -111,23 +195,33 @@ defmodule SpeechMarkdown.Transpiler do
   end
 
   defp convert(
-         {:nested_block, nodes, {:kv_block, [{"date", format}]}},
+         {:nested_block, nodes, {:kv_block, [{dt, format}]}},
          variant
-       ) do
-    {:"say-as", ["interpret-as": 'date', format: ch(format)],
+       )
+       when dt in ~w(date time) do
+    {:"say-as", ["interpret-as": ch(dt), format: ch(format)],
      Enum.map(nodes, &convert(&1, variant))}
   end
 
-  @interpret_as ~w(characters number address chars)
+  defp convert({:nested_block, nodes, {:block, say}}, :google)
+       when say in ~w(interjection) do
+    Enum.map(nodes, &convert(&1, :google))
+  end
+
+  @interpret_as ~w(characters number address chars expletive fraction interjection ordinal unit)
   defp convert({:nested_block, nodes, {:block, say}}, variant)
        when say in @interpret_as do
     {:"say-as", ["interpret-as": say], Enum.map(nodes, &convert(&1, variant))}
   end
 
+  ### AUDIO
+
   defp convert({:audio, src}, _variant) do
     {:audio, [src: ch(src)], []}
   end
 
+  ### TEXT
+
   defp convert({:text, text}, _variant) do
     ch(text)
   end
@@ -157,4 +251,40 @@ defmodule SpeechMarkdown.Transpiler do
   end
 
   defdelegate ch(s), to: String, as: :to_charlist
+
+  defp wrap_with_voice_and_or_lang(nodes, attrs) do
+    ~w(lang voice)
+    |> Enum.reduce(nodes, fn
+      "lang", children ->
+        case kw(attrs, "lang") do
+          nil ->
+            children
+
+          lang ->
+            [{:lang, ["xml:lang": ch(lang)], children}]
+        end
+
+      "voice", children ->
+        case kw(attrs, "voice") do
+          nil ->
+            children
+
+          "device" ->
+            children
+
+          voice ->
+            [{:voice, [name: ch(voice)], children}]
+        end
+    end)
+  end
+
+  defp unwrap_single_node([{_, _, _} = n]), do: n
+  defp unwrap_single_node(n), do: n
+
+  defp kw(list, prop) do
+    case :proplists.get_value(prop, list) do
+      :undefined -> nil
+      value -> value
+    end
+  end
 end

lib/speech_markdown/transpiler/alexa.ex

@@ -10,6 +10,10 @@ defmodule SpeechMarkdown.Transpiler.Alexa do
     {:"amazon:domain", [name: 'music'], inner}
   end
 
+  def emotion(inner, "newscaster") do
+    {:"amazon:domain", [name: 'news'], inner}
+  end
+
   def emotion(inner, block) do
     case section_to_xml_attrs(block) do
       {:ok, attrs} ->

lib/speech_markdown/validator.ex

@@ -1,6 +1,6 @@
 defmodule SpeechMarkdown.Validator do
-  @blocks ~w(address cardinal number characters expletive bleep fraction interjection ordinal phone telephone unit whisper emphasis excited disappointed)
-  @attributes ~w(break date emphasis lang voice pitch ipa sub disappointed excited)
+  @blocks ~w(address cardinal number characters expletive fraction interjection ordinal phone telephone unit whisper emphasis excited disappointed)
+  @attributes ~w(break date time emphasis lang voice pitch ipa sub disappointed excited)
 
   @enum_attrs [
     rate: ~w(x-slow slow medium fast x-fast),
@@ -118,6 +118,10 @@ defmodule SpeechMarkdown.Validator do
     end
   end
 
+  defp validate_kvs([{"vol", value} | rest], acc) do
+    validate_kvs([{"volume", value} | rest], acc)
+  end
+
   defp validate_kvs([{"break", break} | rest], acc) do
     with :ok <- valid_delay(break) do
       validate_kvs(rest, [{"break", break} | acc])
@@ -143,11 +147,27 @@ defmodule SpeechMarkdown.Validator do
     end
   end
 
+  defp convert_nested({:block, "emphasis"}) do
+    {:ok, {:kv_block, [{"emphasis", "moderate"}]}}
+  end
+
+  defp convert_nested({:block, "pitch"}) do
+    {:ok, {:kv_block, [{"pitch", "medium"}]}}
+  end
+
+  defp convert_nested({:block, "rate"}) do
+    {:ok, {:kv_block, [{"rate", "medium"}]}}
+  end
+
+  defp convert_nested({:block, v}) when v in ~w(vol volume) do
+    {:ok, {:kv_block, [{"volume", "medium"}]}}
+  end
+
   defp convert_nested({:block, block}) when block in @blocks do
     {:ok, {:block, block}}
   end
 
-  @translate_blocks %{"chars" => "characters"}
+  @translate_blocks %{"chars" => "characters", "bleep" => "expletive"}
   @translate_block_header Map.keys(@translate_blocks)
 
   defp convert_nested({:block, block}) when block in @translate_block_header do
@@ -166,6 +186,10 @@ defmodule SpeechMarkdown.Validator do
     {:ok, {:kv_block, [{"sub", sub}]}}
   end
 
+  defp convert_nested(:empty_block) do
+    {:ok, :empty_block}
+  end
+
   defp convert_nested({:kv_block, kvs}) do
     with {:ok, kvs1} <- validate_kvs(kvs) do
       {:ok, {:kv_block, kvs1}}
@@ -174,4 +198,39 @@ defmodule SpeechMarkdown.Validator do
 
   def break_attr(type) when type in @delay_enum, do: :strength
   def break_attr(_type), do: :time
+
+  @alexa_voices %{
+                  "Ivy" => "en-US",
+                  "Joanna" => "en-US",
+                  "Joey" => "en-US",
+                  "Justin" => "en-US",
+                  "Kendra" => "en-US",
+                  "Kimberly" => "en-US",
+                  "Matthew" => "en-US",
+                  "Salli" => "en-US",
+                  "Nicole" => "en-AU",
+                  "Russell" => "en-AU",
+                  "Amy" => "en-GB",
+                  "Brian" => "en-GB",
+                  "Emma" => "en-GB",
+                  "Aditi" => "en-IN",
+                  "Raveena" => "en-IN",
+                  "Hans" => "de-DE",
+                  "Marlene" => "de-DE",
+                  "Vicki" => "de-DE",
+                  "Conchita" => "es-ES",
+                  "Enrique" => "es-ES",
+                  "Carla" => "it-IT",
+                  "Giorgio" => "it-IT",
+                  "Mizuki" => "ja-JP",
+                  "Takumi" => "ja-JP",
+                  "Celine" => "fr-FR",
+                  "Lea" => "fr-FR",
+                  "Mathieu" => "fr-FR"
+                }
+                |> Map.keys()
+
+  def alexa_voice(voice) do
+    Enum.find(@alexa_voices, &(String.downcase(&1) == String.downcase(voice)))
+  end
 end

test/speech_markdown/grammar_test.exs

@@ -45,6 +45,8 @@ defmodule SpeechMarkdown.Grammar.Test do
     assert parse(
              "hello [bla] there [x:\"bar\"] and (foo [300ms] (d)[x] apentuin)[foo:\"bar\";lang:\"nl\"] that is it\n\n#[foo]\nxxx"
            )
+
+    #           |> IO.inspect(label: "x")
   end
 
   test "emphasis" do
@@ -73,4 +75,18 @@ defmodule SpeechMarkdown.Grammar.Test do
                {:kv_block, [{"emphasis", "reduced"}]}}
             ]} = parse("++strong++ +med+ ~moderate~ -reduced-")
   end
+
+  test "special chars" do
+    text = """
+    This is text with (parens) but this and other special characters: []()*~@#\\_!+- are ignored
+    """
+
+    assert [text: _] = parse!(text)
+
+    text = """
+    This is text with ~parens! but this and other special characters: *~@#\\_!+- are ignored
+    """
+
+    assert [text: _] = parse!(text)
+  end
 end