motion-turbo-ios 0.1

data/lib/turbo/visitable_view/refresh_control.rb

@@ -0,0 +1,61 @@
+module Turbo
+  class VisitableView < UIView
+    module RefreshControl
+      def refreshControl
+        @refreshControl ||= begin
+          refreshControl = UIRefreshControl.alloc.init
+          refreshControl.addTarget(self, action: "refresh:", forControlEvents: UIControlEventValueChanged)
+          refreshControl
+        end
+      end
+
+      def allowsPullToRefresh
+        return @allowsPullToRefresh if defined?(@allowsPullToRefresh)
+        @allowsPullToRefresh = true
+      end
+
+      def allowsPullToRefresh=(allowsPullToRefresh)
+        @allowsPullToRefresh = allowsPullToRefresh
+        if allowsPullToRefresh
+          installRefreshControl
+        else
+          removeRefreshControl
+        end
+      end
+
+      def isRefreshing
+        refreshControl.refreshing?
+      end
+
+      def refresh(sender)
+        visitable.visitableViewDidRequestRefresh if visitable
+      end
+
+      private
+
+      def installRefreshControl
+        scrollView = webView.scrollView if webView
+        return unless scrollView && allowsPullToRefresh
+        # TODO
+        #if !targetEnvironment(macCatalyst)
+        scrollView.addSubview(refreshControl)
+
+        # Infer refresh control's default height from its frame, if given.
+        # Otherwise fallback to 60 (the default height).
+        refreshControlHeight = CGRectGetHeight(refreshControl.frame) > 0 ? CGRectGetHeight(refreshControl.frame) : 60
+        NSLayoutConstraint.activateConstraints([
+            refreshControl.centerXAnchor.constraintEqualToAnchor(centerXAnchor),
+            refreshControl.topAnchor.constraintEqualToAnchor(safeAreaLayoutGuide.topAnchor),
+            refreshControl.heightAnchor.constraintEqualToConstant(refreshControlHeight)
+        ])
+        #endif
+      end
+
+      def removeRefreshControl
+        refreshControl.endRefreshing
+        #refreshControl.removeFromSuperview
+        webView.scrollView.refreshControl = nil
+      end
+    end
+  end
+end

data/lib/turbo/visitable_view/screenshots.rb

@@ -0,0 +1,56 @@
+module Turbo
+  class VisitableView < UIView
+    module Screenshots
+      def screenshotContainerView
+        @screenshotContainerView ||= begin
+          view = UIView.alloc.initWithFrame(CGRectZero)
+          view.translatesAutoresizingMaskIntoConstraints = false
+          view.backgroundColor = backgroundColor
+          view
+        end
+      end
+
+      attr_reader :screenshotView
+
+      def isShowingScreenshot
+        screenshotContainerView.superview != nil
+      end
+
+      def updateScreenshot
+        return unless webView
+        return if isShowingScreenshot
+        screenshot = webView.snapshotViewAfterScreenUpdates(false)
+        return unless screenshot
+
+        screenshotView.removeFromSuperview if screenshotView
+        screenshot.translatesAutoresizingMaskIntoConstraints = false
+        screenshotContainerView.addSubview(screenshot)
+
+        NSLayoutConstraint.activateConstraints([
+          screenshot.centerXAnchor.constraintEqualToAnchor(screenshotContainerView.centerXAnchor),
+          screenshot.topAnchor.constraintEqualToAnchor(screenshotContainerView.topAnchor),
+          screenshot.widthAnchor.constraintEqualToConstant(screenshot.bounds.size.width),
+          screenshot.heightAnchor.constraintEqualToConstant(screenshot.bounds.size.height)
+        ])
+        @screenshotView = screenshot
+      end
+
+      def showScreenshot
+        if !isShowingScreenshot && !isRefreshing
+          addSubview(screenshotContainerView)
+          addFillConstraintsForSubview(screenshotContainerView)
+          showOrHideWebView
+        end
+      end
+
+      def hideScreenshot
+        screenshotContainerView.removeFromSuperview
+        showOrHideWebView
+      end
+
+      def clearScreenshot
+        screenshotView.removeFromSuperview if screenshotView
+      end
+    end
+  end
+end

data/lib/turbo/visitable_view/scroll_view.rb

@@ -0,0 +1,21 @@
+module Turbo
+  class VisitableView < UIView
+    module ScrollView
+      private
+
+      def hiddenScrollView
+        @hiddenScrollView ||= begin
+          scrollView = UIScrollView.alloc.initWithFrame(CGRectZero)
+          scrollView.translatesAutoresizingMaskIntoConstraints = false
+          scrollView.scrollsToTop = false
+          scrollView
+        end
+      end
+
+      def installHiddenScrollView
+        insertSubview(hiddenScrollView, atIndex: 0)
+        addFillConstraintsForSubview(hiddenScrollView)
+      end
+    end
+  end
+end

data/lib/turbo/visitable_view/web_view.rb

@@ -0,0 +1,28 @@
+module Turbo
+  class VisitableView < UIView
+    module WebView
+      attr_reader :webView, :visitable
+
+      def activateWebView(webView, forVisitable: visitable)
+        @webView = webView
+        @visitable = visitable
+        #addSubview(webView)
+        insertSubview(webView, atIndex: 0)
+        addFillConstraintsForSubview(webView)
+        installRefreshControl
+        showOrHideWebView
+      end
+
+      def deactivateWebView
+        removeRefreshControl
+        webView.removeFromSuperview if webView
+        @webView = nil
+        @visitable = nil
+      end
+
+      def showOrHideWebView
+        webView.hidden = isShowingScreenshot if webView
+      end
+    end
+  end
+end

data/lib/turbo/web_view/script_message.rb

@@ -0,0 +1,77 @@
+module Turbo
+  class ScriptMessage
+    NAMES = {
+      page_loaded: "pageLoaded",
+      page_load_failed: "pageLoadFailed",
+      error_raised: "errorRaised",
+      visit_proposed: "visitProposed",
+      visit_started: "visitStarted",
+      visit_request_started: "visitRequestStarted",
+      visit_request_completed: "visitRequestCompleted",
+      visit_request_failed: "visitRequestFailed",
+      visit_request_finished: "visitRequestFinished",
+      visit_rendered: "visitRendered",
+      visit_completed: "visitCompleted",
+      form_submission_started: "formSubmissionStarted",
+      form_submission_finished: "formSubmissionFinished",
+      page_invalidated: "pageInvalidated",
+      log: "log"
+    }
+
+    def self.parse(message)
+      body = message.body
+      return unless body
+
+      rawName = body["name"]
+      return unless rawName
+
+      name = NAMES.key(rawName)
+      return unless name
+
+      data = body["data"]
+      return unless data
+
+      return new(name, data)
+    end
+
+    attr_reader :name, :data
+
+    def initialize(name, data)
+      @name = name
+      @data = data
+    end
+
+    def identifier
+      identifier = data["identifier"]
+      identifier if identifier.is_a?(String)
+    end
+
+    # Milliseconds since unix epoch as provided by JavaScript Date.now()
+    def timestamp
+      #data["timestamp"] as? TimeInterval ?? 0
+      timestamp = data["timestamp"]
+      timestamp.to_i || 0
+    end
+
+    def date
+      NSDate.alloc.initWithTimeIntervalSince1970(timestamp / 1000.0)
+    end
+
+    def restorationIdentifier
+      restorationIdentifier = data["restorationIdentifier"]
+      restorationIdentifier if restorationIdentifier.is_a?(String)
+    end
+
+    def location
+      NSURL.alloc.initWithString(data["location"]) if data["location"]
+    end
+
+    def options
+      if options = data["options"]
+        VisitOptions.alloc.initFromHash(options)
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/turbo/web_view/script_message_handler.rb

@@ -0,0 +1,16 @@
+module Turbo
+  # This class prevents retain cycle caused by WKUserContentController
+  class ScriptMessageHandler
+
+    attr_accessor :delegate
+
+    def initWithDelegate(delegate)
+      self.delegate = delegate
+      self
+    end
+
+    def userContentController(userContentController, didReceiveScriptMessage: message)
+      delegate.scriptMessageHandlerDidReceiveMessage(message) if delegate
+    end
+  end
+end

data/lib/turbo/web_view/web_view_bridge.rb

@@ -0,0 +1,154 @@
+module Turbo
+  # The WebViewBridge is an internal class used for bi-directional communication
+  # with the web view/JavaScript
+  class WebViewBridge
+    attr_accessor :webView, :delegate, :pageLoadDelegate, :visitDelegate#, :navigationDelegate
+    def initWithWebView(webView)
+      @webView = webView
+      setup
+
+      self
+    end
+
+    private
+
+    def setup
+      messageHandlerName = "turbo"
+      webView.configuration.userContentController.addUserScript(userScript)
+      scriptMessageHandler = ScriptMessageHandler.alloc.initWithDelegate(self)
+      webView.configuration.userContentController.addScriptMessageHandler(scriptMessageHandler, name: messageHandlerName)
+    end
+
+    def userScript
+      url = self.class.bundle.URLForResource("turbo", withExtension: "js")
+      source = NSString.stringWithContentsOfURL(url, encoding: NSUTF8StringEncoding, error: nil)
+      WKUserScript.alloc.initWithSource(source, injectionTime: WKUserScriptInjectionTimeAtDocumentEnd, forMainFrameOnly: true)
+    end
+
+    def self.bundle
+      @bundle ||= NSBundle.bundleForClass(self)
+    end
+
+    public
+
+    def visitLocation(location, withOptions: options, restorationIdentifier: restorationIdentifier)
+      raise unless options.is_a? Turbo::VisitOptions
+      callJavaScriptFunction("window.turboNative.visitLocationWithOptionsAndRestorationIdentifier",
+        withArguments: [
+          location.absoluteString,
+          options.encode,
+          restorationIdentifier]
+      )
+    end
+
+    def clearSnapshotCache
+      callJavaScriptFunction("window.turboNative.clearSnapshotCache", withArguments: [])
+    end
+
+    def cancelVisitWithIdentifier(identifier)
+      callJavaScriptFunction("window.turboNative.cancelVisitWithIdentifier", withArguments: [identifier])
+    end
+
+    # JavaScript Evaluation
+
+    def callJavaScriptFunction(functionExpression, withArguments: arguments)
+      callJavaScriptFunction(functionExpression, withArguments: arguments, completionHandler: nil)
+    end
+
+    def callJavaScriptFunction(functionExpression, withArguments: arguments, completionHandler: completionHandler)
+      script = scriptForCallingJavaScriptFunction(functionExpression, withArguments: arguments)
+      unless script
+        NSLog("Error encoding arguments for JavaScript function `%@'", functionExpression)
+        return
+      end
+
+      debugLog("[Bridge] → #{functionExpression} #{arguments}")
+
+      webView.evaluateJavaScript(script, completionHandler: -> (result, error) {
+        debugLog("[Bridge] = #{functionExpression} evaluation complete")
+
+        if result
+          if error = result["error"]
+            stack = result["stack"]
+            NSLog("Error evaluating JavaScript function `%@': %@\n%@", functionExpression, error, stack)
+          else
+            completionHandler.call(result["value"]) if completionHandler
+          end
+        elsif error
+          delegate.webView(self, didFailJavaScriptEvaluationWithError: error) if delegate
+        end
+      })
+    end
+
+    def scriptForCallingJavaScriptFunction(functionExpression, withArguments: arguments)
+      encodedArguments = encodeJavaScriptArguments(arguments)
+      return unless encodedArguments
+
+      script = "(function(result) {\n" +
+               "  try {\n" +
+               "    result.value = " + functionExpression + "(" + encodedArguments + ")\n" +
+               "  } catch (error) {\n" +
+               "    result.error = error.toString()\n" +
+               "    result.stack = error.stack\n" +
+               "  }\n" +
+               "  return result\n" +
+               "})({})"
+      return script
+    end
+
+    def encodeJavaScriptArguments(arguments)
+      arguments = arguments.map {|v| v.nil? ? NSNull.alloc.init() : v }
+
+      data = NSJSONSerialization.dataWithJSONObject(arguments, options: 0, error: nil)
+      if data
+        dataString = NSString.alloc.initWithData(data, encoding: NSUTF8StringEncoding)
+        return dataString[1..-2]
+      end
+      return nil
+    end
+
+    def scriptMessageHandlerDidReceiveMessage(message)
+      message = ScriptMessage.parse(message)
+      return unless message
+
+      if message.name.to_sym != :log
+        debugLog("[Bridge] ← #{message.name} #{message.data}")
+      end
+
+      case message.name.to_sym
+      when :page_loaded
+        pageLoadDelegate.webView(self, didLoadPageWithRestorationIdentifier: message.restorationIdentifier) if pageLoadDelegate
+      when :page_load_failed
+        delegate.webView(self, didFailInitialPageLoadWithError: TurboError.pageLoadFailure) if delegate
+      when :form_submission_started
+        delegate.webView(self, didStartFormSubmissionToLocation: message.location) if delegate
+      when :form_submission_finished
+        delegate.webView(self, didFinishFormSubmissionToLocation: message.location) if delegate
+      when :page_invalidated
+        delegate.webViewDidInvalidatePage(self) if delegate
+      when :visit_proposed
+        delegate.webView(self, didProposeVisitToLocation: message.location, withOptions: message.options) if delegate
+      when :visit_started
+        visitDelegate.webView(self, didStartVisitWithIdentifier: message.identifier, hasCachedSnapshot: message.data["hasCachedSnapshot"]) if visitDelegate
+      when :visit_request_started
+        visitDelegate.webView(self, didStartRequestForVisitWithIdentifier: message.identifier, date: message.date) if visitDelegate
+      when :visit_request_completed
+        visitDelegate.webView(self, didCompleteRequestForVisitWithIdentifier: message.identifier) if visitDelegate
+      when :visit_request_failed
+        visitDelegate.webView(self, didFailRequestForVisitWithIdentifier: message.identifier, statusCode: message.data["statusCode"]) if visitDelegate
+      when :visit_request_finished
+        visitDelegate.webView(self, didFinishRequestForVisitWithIdentifier: message.identifier, date: message.date) if visitDelegate
+      when :visit_rendered
+        visitDelegate.webView(self, didRenderForVisitWithIdentifier: message.identifier) if visitDelegate
+      when :visit_completed
+        visitDelegate.webView(self, didCompleteVisitWithIdentifier: message.identifier, restorationIdentifier: message.restorationIdentifier) if visitDelegate
+      when :error_raised
+        error = message.data["error"] || "<unknown error>"
+        debugLog("JavaScript error: #{error}")
+      when :log
+        msg = message.data["message"]
+        debugLog("[Bridge] ← log: #{msg}") if msg.is_a?(String)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: motion-turbo-ios
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Andrew Havens
+- Petrik de Heus
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-06-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Turbo for RubyMotion apps
+email:
+- email@andrewhavens.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/motion-turbo-ios.rb
+- lib/turbo/logging.rb
+- lib/turbo/path_configuration/path_configuration.rb
+- lib/turbo/path_configuration/path_configuration_decoder.rb
+- lib/turbo/path_configuration/path_configuration_loader.rb
+- lib/turbo/path_configuration/path_rule.rb
+- lib/turbo/session/navigation_delegate_methods.rb
+- lib/turbo/session/session.rb
+- lib/turbo/session/session_delegate_methods.rb
+- lib/turbo/session/visit_delegate_methods.rb
+- lib/turbo/session/visitable_delegate_methods.rb
+- lib/turbo/session/web_view_delegate_methods.rb
+- lib/turbo/turbo_error.rb
+- lib/turbo/visit/cold_boot_visit.rb
+- lib/turbo/visit/javascript_visit.rb
+- lib/turbo/visit/visit.rb
+- lib/turbo/visit/visit_options.rb
+- lib/turbo/visit/visit_proposal.rb
+- lib/turbo/visit/visit_response.rb
+- lib/turbo/visitable/visitable.rb
+- lib/turbo/visitable/visitable_view.rb
+- lib/turbo/visitable/visitable_view_controller.rb
+- lib/turbo/visitable_view/activity_indicator.rb
+- lib/turbo/visitable_view/constraints.rb
+- lib/turbo/visitable_view/refresh_control.rb
+- lib/turbo/visitable_view/screenshots.rb
+- lib/turbo/visitable_view/scroll_view.rb
+- lib/turbo/visitable_view/web_view.rb
+- lib/turbo/web_view/script_message.rb
+- lib/turbo/web_view/script_message_handler.rb
+- lib/turbo/web_view/web_view_bridge.rb
+homepage: https://github.com/p8/motion-turbo-ios
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: Turbo for RubyMotion apps
+test_files: []