Warn when missing semicolons

Author: NduatiK

lib/live_view_native/swiftui/rules_parser.ex

@@ -3,19 +3,22 @@ defmodule LiveViewNative.SwiftUI.RulesParser do
 
   alias LiveViewNative.SwiftUI.RulesParser.Modifiers
   alias LiveViewNative.SwiftUI.RulesParser.Parser
+  require Logger
 
   def parse(rules, opts \\ []) do
     file = Keyword.get(opts, :file) || ""
     module = Keyword.get(opts, :module) || ""
     line = Keyword.get(opts, :line) || 1
     variable_context = Keyword.get(opts, :variable_context, Elixir)
+    expect_semicolons? = Keyword.get(opts, :expect_semicolons?, false)
 
     context =
       opts
       |> Keyword.get(:context, %{})
       |> Map.put_new(:file, file)
       |> Map.put_new(:source_line, line)
       |> Map.put_new(:module, module)
+      |> Map.put_new(:expect_semicolons?, expect_semicolons?)
       |> Map.put_new(
         :annotations,
         Application.get_env(:live_view_native_stylesheet, :annotations, false)
@@ -35,10 +38,12 @@ defmodule LiveViewNative.SwiftUI.RulesParser do
       |> Parser.error_from_result()
 
     case result do
-      {:ok, [output], _unconsumed = "", _context, _current_line_and_offset, _} ->
+      {:ok, [output], warnings} ->
+        log_warnings(warnings, file)
         output
 
-      {:ok, output, _unconsumed = "", _context, _current_line_and_offset, _} ->
+      {:ok, output, warnings} ->
+        log_warnings(warnings, file)
         output
 
       {:error, message, _unconsumed, _context, {line, _}, _} ->
@@ -48,4 +53,10 @@ defmodule LiveViewNative.SwiftUI.RulesParser do
           line: line
     end
   end
+
+  def log_warnings(warnings, file) do
+    for {message, {line, _}, _offset} <- warnings do
+      IO.warn(message, line: line, file: file)
+    end
+  end
 end

lib/live_view_native/swiftui/rules_parser/modifiers.ex

@@ -283,6 +283,7 @@ defmodule LiveViewNative.SwiftUI.RulesParser.Modifiers do
     ignore_whitespace()
     |> concat(modifier_name())
     |> concat(modifier_brackets.(nested: false))
+    |> expect_semicolon_or_warn()
     |> post_traverse({PostProcessors, :to_function_call_ast, []}),
     export_combinator: true
   )

lib/live_view_native/swiftui/rules_parser/parser.ex

@@ -35,8 +35,8 @@ defmodule LiveViewNative.SwiftUI.RulesParser.Parser do
       choices ++
         if generate_error? do
           [
-            error_parser
-            |> put_error(
+            put_error(
+              error_parser,
               "Expected one of the following:\n" <>
                 label_from_named_choices(named_choices) <> "\n",
               show_incorrect_text?: show_incorrect_text?
@@ -49,16 +49,19 @@ defmodule LiveViewNative.SwiftUI.RulesParser.Parser do
   end
 
   def expect(combinator \\ empty(), combinator_2, opts) do
-    error_parser = Keyword.get(opts, :error_parser, non_whitespace())
-    error_message = Keyword.get(opts, :error_message)
-    generate_error? = Keyword.get(opts, :generate_error?, true)
+    opts =
+      opts
+      |> Keyword.update(:error_parser, non_whitespace(), &(&1 || empty()))
+      |> Keyword.update(:error_message, "", & &1)
+      |> Keyword.update(:generate_error?, true, & &1)
+      |> Keyword.update(:warning, false, & &1)
 
     combinator
     |> concat(
-      if generate_error? do
+      if opts[:generate_error?] do
         choice([
           combinator_2,
-          put_error(error_parser, error_message, opts)
+          put_error(opts[:error_parser], opts[:error_message], opts)
         ])
       else
         combinator_2
@@ -150,8 +153,13 @@ defmodule LiveViewNative.SwiftUI.RulesParser.Parser do
         {message, position, byte_offset} = Error.context_to_error_message(context)
         {:error, message, rest, context, position, byte_offset}
 
-      result ->
-        result
+      {:ok, output, _unconsumed = "", %{context: %Context{} = context}, _, _} ->
+        warnings =
+          Enum.map(context.warnings, fn warning ->
+            Error.context_to_error_message(context, warning)
+          end)
+
+        {:ok, output, warnings}
     end
   end
 end

lib/live_view_native/swiftui/rules_parser/parser/context.ex

@@ -8,6 +8,7 @@ defmodule LiveViewNative.SwiftUI.RulesParser.Parser.Context do
     source: "",
     source_lines: [],
     errors: [],
+    warnings: [],
     highlight_error: true,
     # Where in the code does the input start?
     # Useful for localizing errors when parsing sigil text
@@ -45,14 +46,14 @@ defmodule LiveViewNative.SwiftUI.RulesParser.Parser.Context do
     if is_frozen?(context) and not error.forced? do
       context
     else
-      path = [:context, Access.key(:errors)]
+      path =
+        if error.is_warning? do
+          [:context, Access.key(:warnings)]
+        else
+          [:context, Access.key(:errors)]
+        end
 
-      {_, context} =
-        get_and_update_in(context, path, fn
-          existing_errors -> {[error | existing_errors], [error | existing_errors]}
-        end)
-
-      context
+      update_in(context, path, &[error | &1])
     end
   end
 

lib/live_view_native/swiftui/rules_parser/parser/error.ex

@@ -9,70 +9,64 @@ defmodule LiveViewNative.SwiftUI.RulesParser.Parser.Error do
     :line,
     :byte_offset,
     :error_message,
-    forced?: false
+    forced?: false,
+    is_warning?: false
   ])
 
   def put_error(
         rest,
         args,
         context,
-        _,
-        _,
-        error_message,
-        opts \\ []
-      )
-
-  def put_error(
-        rest,
-        [] = arg,
-        context,
-        {line, _offset},
-        byte_offset,
-        error_message,
-        opts
-      ) do
-    # IO.inspect({[], rest, error_message}, label: "error[0]")
-
-    context =
-      Context.put_new_error(context, rest, %__MODULE__{
-        incorrect_text: "",
-        line: line,
-        byte_offset: byte_offset,
-        error_message: error_message,
-        show_incorrect_text?: Keyword.get(opts, :show_incorrect_text?, false),
-        forced?: Keyword.get(opts, :force_error?, false)
-      })
-
-    {rest, arg, context}
-  end
-
-  def put_error(
-        rest,
-        [matched_text | _] = args,
-        context,
         {line, _offset},
         byte_offset,
         error_message,
-        opts
+        opts \\ []
       ) do
-    # IO.inspect({matched_text, rest, error_message}, label: "error[0]")
+    # IO.inspect({args, rest, error_message}, label: "error[0]")
+
+    error = %__MODULE__{
+      incorrect_text: List.first(args, ""),
+      line: line,
+      byte_offset: byte_offset,
+      error_message: error_message,
+      show_incorrect_text?: Keyword.get(opts, :show_incorrect_text?, false),
+      forced?: Keyword.get(opts, :force_error?, false),
+      is_warning?: false
+    }
 
     context =
-      Context.put_new_error(context, rest, %__MODULE__{
-        incorrect_text: matched_text,
-        line: line,
-        byte_offset: byte_offset,
-        error_message: error_message,
-        show_incorrect_text?: Keyword.get(opts, :show_incorrect_text?, false),
-        forced?: Keyword.get(opts, :force_error?, false)
-      })
+      case opts[:warning] do
+        true ->
+          # Always treat error as warning
+          Context.put_new_error(context, rest, %{error | is_warning?: true})
+
+        false ->
+          # Never treat error as warning
+          Context.put_new_error(context, rest, error)
+
+        nil ->
+          # Never treat error as warning
+          Context.put_new_error(context, rest, error)
+
+        warning ->
+          # The error is an optional warning
+          # Only log the warning if value in `context[<key>]` is true
+          if get_in(context, [Access.key(warning)]) == true do
+            Context.put_new_error(context, rest, %{error | is_warning?: true})
+          else
+            context
+          end
+      end
 
     {rest, args, context}
   end
 
   def context_to_error_message(context) do
     [%__MODULE__{} = error | _] = Enum.reverse(context.errors)
+    context_to_error_message(context, error)
+  end
 
+  def context_to_error_message(context, %__MODULE__{} = error) do
     error_message = error.error_message
     line = error.line
     incorrect_text = error.incorrect_text
@@ -144,8 +138,15 @@ defmodule LiveViewNative.SwiftUI.RulesParser.Parser.Error do
         ""
       end
 
+    header =
+      if error.is_warning? do
+        ""
+      else
+        "Unsupported input:"
+      end
+
     message = """
-    Unsupported input:
+    #{header}
     #{line_spacer} |
     #{lines}
     #{line_spacer} |

lib/live_view_native/swiftui/rules_parser/tokens.ex

@@ -113,6 +113,19 @@ defmodule LiveViewNative.SwiftUI.RulesParser.Tokens do
     combinator |> ignore(optional(whitespace(min: 1)))
   end
 
+  def expect_semicolon_or_warn(combinator) do
+    combinator
+    |> concat(
+      ignore(string(";"))
+      |> expect(
+        warning: :expect_semicolons?,
+        error_message: "Expected a ‘;’",
+        error_parser: empty(),
+        show_incorrect_text?: false
+      )
+    )
+  end
+
   # @tuple_children [
   #   parsec(:nested_attribute),
   #   atom(),

test/live_view_native/swiftui/rules_parser_test.exs

@@ -1,12 +1,14 @@
 defmodule LiveViewNative.SwiftUI.RulesParserTest do
   use ExUnit.Case
+  import ExUnit.CaptureIO
   alias LiveViewNative.SwiftUI.RulesParser
 
   def parse(input, opts \\ []) do
     RulesParser.parse(input,
       file: Keyword.get(opts, :file),
       module: Keyword.get(opts, :module),
       line: Keyword.get(opts, :line),
+      expect_semicolons?: Keyword.get(opts, :expect_semicolons?, false),
       context: %{
         annotations: Keyword.get(opts, :annotations, false)
       }
@@ -382,6 +384,7 @@ defmodule LiveViewNative.SwiftUI.RulesParserTest do
 
       input = ~s{rotationEffect(gesture_state(:rotate, .rotation, defaultValue: .zero))}
       output = {:rotationEffect, [], [{:__gesture_state__, [], [:rotate, {:., [], [nil, :rotation]}, [defaultValue: {:., [], [nil, :zero]}]]}]}
+      assert parse(input) == output
     end
   end
 
@@ -454,6 +457,80 @@ defmodule LiveViewNative.SwiftUI.RulesParserTest do
       assert String.trim(error.description) == error_prefix
     end
 
+    test "warn when missing semicolons" do
+      input = "blue() red()"
+
+      logs =
+        capture_io(:stderr, fn ->
+          assert parse(input, expect_semicolons?: true)
+        end)
+
+      assert logs =~
+               """
+               warning:#{" "}
+                 |
+               1 | blue()‎ red()
+                 |       ^
+                 |
+
+               Expected a ‘;’
+               """
+
+      assert logs =~
+               """
+               warning:#{" "}
+                 |
+               1 | blue() red()‎
+                 |             ^
+                 |
+
+               Expected a ‘;’
+               """
+
+      input = """
+      blue()
+      red()
+      green()
+      """
+
+      logs =
+        capture_io(:stderr, fn ->
+          assert parse(input, expect_semicolons?: true)
+        end)
+
+      assert logs =~
+               """
+               warning:#{" "}
+                 |
+               1 | blue()‎
+                 |       ^
+                 |
+
+               Expected a ‘;’
+               """
+      assert logs =~
+               """
+               warning:#{" "}
+                 |
+               2 | red()‎
+                 |      ^
+                 |
+
+               Expected a ‘;’
+               """
+
+      assert logs =~
+               """
+               warning:#{" "}
+                 |
+               3 | green()‎
+                 |        ^
+                 |
+
+               Expected a ‘;’
+               """
+    end
+
     test "invalid modifier name" do
       input = "1(.red)"