Fix live_patch handling

.github/workflows/elixir.yml

@@ -14,7 +14,7 @@ env:
 jobs:
   build:
     name: Build and test
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v3
     - name: Set up Elixir

CHANGELOG.md

@@ -33,6 +33,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 - Views will now update properly when the server changes the value of a form field (#1483)
+- Fixed float parsing for stylesheet rules
 
 ## [0.3.1] 2024-10-02
 

Sources/LiveViewNative/Coordinators/LiveNavigationEntry.swift

@@ -11,15 +11,20 @@ import SwiftUI
 public struct LiveNavigationEntry<R: RootRegistry>: Hashable {
     public let url: URL
     public let coordinator: LiveViewCoordinator<R>
+
+    let mode: LiveRedirect.Mode
+
     let navigationTransition: Any?
     let pendingView: (any View)?
 
     public static func == (lhs: Self, rhs: Self) -> Bool {
         lhs.url == rhs.url && lhs.coordinator === rhs.coordinator
+        && lhs.mode == rhs.mode
     }
 
     public func hash(into hasher: inout Hasher) {
         hasher.combine(url)
         hasher.combine(ObjectIdentifier(coordinator))
+        hasher.combine(mode)
     }
 }

Sources/LiveViewNative/Coordinators/LiveSessionCoordinator.swift

@@ -100,7 +100,7 @@ public class LiveSessionCoordinator<R: RootRegistry>: ObservableObject {
             try? LiveViewNativeCore.storeSessionCookie("\(cookie.name)=\(cookie.value)", self.url.absoluteString)
         }
 
-        self.navigationPath = [.init(url: url, coordinator: .init(session: self, url: self.url), navigationTransition: nil, pendingView: nil)]
+        self.navigationPath = [.init(url: url, coordinator: .init(session: self, url: self.url), mode: .replaceTop, navigationTransition: nil, pendingView: nil)]
 
         self.mergedEventSubjects = self.navigationPath.first!.coordinator.eventSubject.compactMap({ [weak self] value in
             self.map({ ($0.navigationPath.first!.coordinator, value) })
@@ -112,37 +112,76 @@ public class LiveSessionCoordinator<R: RootRegistry>: ObservableObject {
         $navigationPath.scan(([LiveNavigationEntry<R>](), [LiveNavigationEntry<R>]()), { ($0.1, $1) }).sink { [weak self] prev, next in
             guard let self else { return }
             Task {
-                try await prev.last?.coordinator.disconnect()
                 if prev.count > next.count {
-                    let targetEntry = self.liveSocket!.getEntries()[next.count - 1]
-                    next.last?.coordinator.join(
-                        try await self.liveSocket!.traverseTo(targetEntry.id,
-                                                              .some([
-                                                                  "_format": .str(string: LiveSessionParameters.platform),
-                                                                  "_interface": .object(object: LiveSessionParameters.platformParams)
-                                                              ]),
-                                                              nil)
-                    )
+                    // backward navigation
+
+                    // if the coordinator is connected, the mode was a `patch`, and the new entry has the same coordinator
+                    // send a `live_patch` event and keep the same coordinator.
+                    if case .patch = prev.last!.mode,
+                       case .connected = prev.last?.coordinator.state,
+                       next.last?.coordinator === prev.last?.coordinator
+                    {
+                        _ = try await prev.last?.coordinator.doPushEvent(
+                            "live_patch",
+                            payload: .jsonPayload(json: .object(object: [
+                                "url": .str(string: next.last!.url.absoluteString)
+                            ]))
+                        )
+                        next.last!.coordinator.url = next.last!.url
+                        next.last!.coordinator.objectWillChange.send()
+                        if next.count <= 1 { // if we navigated back to the root page, trigger an update on the session too
+                            self.objectWillChange.send()
+                        }
+                        return
+                    } else {
+                        try await prev.last?.coordinator.disconnect()
+                        let targetEntry = self.liveSocket!.getEntries()[next.count - 1]
+                        next.last?.coordinator.join(
+                            try await self.liveSocket!.traverseTo(
+                                targetEntry.id,
+                                .some([
+                                    "_format": .str(string: LiveSessionParameters.platform),
+                                    "_interface": .object(object: LiveSessionParameters.platformParams)
+                                ]),
+                                nil
+                            )
+                        )
+                    }
                 } else if next.count > prev.count && prev.count > 0 {
                     // forward navigation (from `redirect` or `<NavigationLink>`)
-                    next.last?.coordinator.join(
-                        try await self.liveSocket!.navigate(next.last!.url.absoluteString,
-                                                            .some([
-                                                                "_format": .str(string: LiveSessionParameters.platform),
-                                                                "_interface": .object(object: LiveSessionParameters.platformParams)
-                                                            ]),
-                                                            NavOptions(action: .push))
-                    )
-                } else if next.count == prev.count {
-                    guard let liveChannel =
-                            try await self.liveSocket?.navigate(next.last!.url.absoluteString,
+                    switch next.last!.mode {
+                    case .patch:
+                        next.last?.coordinator.url = next.last!.url
+                        return
+                    case .replaceTop:
+                        try await prev.last?.coordinator.disconnect()
+                        next.last?.coordinator.join(
+                            try await self.liveSocket!.navigate(next.last!.url.absoluteString,
                                                                 .some([
                                                                     "_format": .str(string: LiveSessionParameters.platform),
                                                                     "_interface": .object(object: LiveSessionParameters.platformParams)
-                                                                    ]),
-                                                                   NavOptions(action: .replace))
-                    else { return }
-                    next.last?.coordinator.join(liveChannel)
+                                                                ]),
+                                                                NavOptions(action: .push))
+                        )
+                    }
+                } else if next.count == prev.count {
+                    switch next.last!.mode {
+                    case .patch:
+                        next.last?.coordinator.url = next.last!.url
+                        return
+                    case .replaceTop:
+                        try await prev.last?.coordinator.disconnect()
+                        guard let liveChannel = try await self.liveSocket?.navigate(
+                            next.last!.url.absoluteString,
+                            .some([
+                                "_format": .str(string: LiveSessionParameters.platform),
+                                "_interface": .object(object: LiveSessionParameters.platformParams)
+                            ]),
+                            NavOptions(action: .replace)
+                        )
+                        else { return }
+                        next.last?.coordinator.join(liveChannel)
+                    }
                 }
             }
         }.store(in: &cancellables)
@@ -318,7 +357,7 @@ public class LiveSessionCoordinator<R: RootRegistry>: ObservableObject {
                 if case .user(user: "assets_change") = event.event {
                     Task { @MainActor in
                         await self.disconnect()
-                        self.navigationPath = [.init(url: self.url, coordinator: .init(session: self, url: self.url), navigationTransition: nil, pendingView: nil)]
+                        self.navigationPath = [.init(url: self.url, coordinator: .init(session: self, url: self.url), mode: .replaceTop, navigationTransition: nil, pendingView: nil)]
                         await self.connect()
                         self.lastReloadTime = Date()
                     }
@@ -374,7 +413,7 @@ public class LiveSessionCoordinator<R: RootRegistry>: ObservableObject {
         await self.disconnect()
         if let url {
             self.url = url
-            self.navigationPath = [.init(url: self.url, coordinator: self.navigationPath.first!.coordinator, navigationTransition: nil, pendingView: nil)]
+            self.navigationPath = [.init(url: self.url, coordinator: self.navigationPath.first!.coordinator, mode: .replaceTop, navigationTransition: nil, pendingView: nil)]
         }
         await self.connect(httpMethod: httpMethod, httpBody: httpBody, additionalHeaders: headers)
 //        do {
@@ -440,7 +479,7 @@ public class LiveSessionCoordinator<R: RootRegistry>: ObservableObject {
         switch redirect.mode {
         case .replaceTop:
             let coordinator = LiveViewCoordinator(session: self, url: redirect.to)
-            let entry = LiveNavigationEntry(url: redirect.to, coordinator: coordinator, navigationTransition: navigationTransition, pendingView: pendingView)
+            let entry = LiveNavigationEntry(url: redirect.to, coordinator: coordinator, mode: redirect.mode, navigationTransition: navigationTransition, pendingView: pendingView)
             switch redirect.kind {
             case .push:
                 navigationPath.append(entry)
@@ -458,7 +497,7 @@ public class LiveSessionCoordinator<R: RootRegistry>: ObservableObject {
             // patch is like `replaceTop`, but it does not disconnect.
             let coordinator = navigationPath.last!.coordinator
             coordinator.url = redirect.to
-            let entry = LiveNavigationEntry(url: redirect.to, coordinator: coordinator, navigationTransition: navigationTransition, pendingView: pendingView)
+            let entry = LiveNavigationEntry(url: redirect.to, coordinator: coordinator, mode: redirect.mode, navigationTransition: navigationTransition, pendingView: pendingView)
             switch redirect.kind {
             case .push:
                 navigationPath.append(entry)

Sources/LiveViewNative/Live/LiveView.swift

@@ -288,7 +288,7 @@ struct PhxMain<R: RootRegistry>: View {
     @EnvironmentObject private var session: LiveSessionCoordinator<R>
 
     var body: some View {
-        NavStackEntryView(.init(url: context.coordinator.url, coordinator: context.coordinator, navigationTransition: nil, pendingView: nil))
+        NavStackEntryView(.init(url: context.coordinator.url, coordinator: context.coordinator, mode: .replaceTop, navigationTransition: nil, pendingView: nil))
     }
 }
 

Sources/LiveViewNative/Views/Layout Containers/Presentation Containers/NavigationLink.swift

@@ -123,6 +123,7 @@ struct NavigationLink<Root: RootRegistry>: View {
                         value: LiveNavigationEntry(
                             url: url,
                             coordinator: LiveViewCoordinator(session: $liveElement.context.coordinator.session, url: url),
+                            mode: .replaceTop,
                             navigationTransition: nil, // FIXME: navigationTransition
                             pendingView: pendingView
                         )

lib/live_view_native/swiftui/rules_parser/tokens.ex

@@ -21,32 +21,30 @@ defmodule LiveViewNative.SwiftUI.RulesParser.Tokens do
 
   def nil_(), do: replace(string("nil"), nil)
 
-  def minus(), do: string("-")
-
-  def underscored_integer() do
-    integer(min: 1)
+  def digits() do
+    ascii_char([?0..?9])
     |> repeat(
       choice([
         ascii_char([?0..?9]),
-        ignore(string("_"))
-        |> ascii_char([?0..?9])
+        ignore(string("_")) |> ascii_char([?0..?9])
       ])
-      |> reduce({List, :to_string, []})
     )
-    |> reduce({Enum, :join, [""]})
+    |> reduce({List, :to_string, []})
+  end
+
+  def minus(), do: string("-")
+
+  def frac() do
+    concat(string("."), digits())
   end
 
   def integer() do
     optional(minus())
-    |> concat(underscored_integer())
+    |> concat(digits())
     |> reduce({Enum, :join, [""]})
     |> map({String, :to_integer, []})
   end
 
-  def frac() do
-    concat(string("."), underscored_integer())
-  end
-
   def float() do
     integer()
     |> concat(frac())

test/live_view_native/swiftui/rules_parser_test.exs

@@ -117,8 +117,8 @@ defmodule LiveViewNative.SwiftUI.RulesParserTest do
 
       assert parse(input) == output
 
-      input = "background(Color.blue.opacity(0.2).blendMode(.multiply).mix(with: .orange).opacity(0.7))"
-      output = {:background, [], [{:., [], [{:., [], [{:., [], [{:., [], [{:., [], [:Color, :blue]}, {:opacity, [], [0.2]}]}, {:blendMode, [], [{:., [], [nil, :multiply]}]}]}, {:mix, [], [{:with, {:., [], [nil, :orange]}}]}]}, {:opacity, [], [0.7]}]}]}
+      input = "background(Color.blue.opacity(0.02).blendMode(.multiply).mix(with: .orange).opacity(0.7))"
+      output = {:background, [], [{:., [], [{:., [], [{:., [], [{:., [], [{:., [], [:Color, :blue]}, {:opacity, [], [0.02]}]}, {:blendMode, [], [{:., [], [nil, :multiply]}]}]}, {:mix, [], [{:with, {:., [], [nil, :orange]}}]}]}, {:opacity, [], [0.7]}]}]}
 
       assert parse(input) == output
     end