motion-turbo 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a50ec993094594fc8592e14e3f127671cfc4b65e3e5c5523459269c9872029c3
+  data.tar.gz: fcd34843ff4ca1322cb91aad6ce665dd77e3d6d43583144f5f70cffde5ebf482
+SHA512:
+  metadata.gz: 98c870947f0fcacc45691a53e6781f6158cc50954ab22956bb5884dcff5f161be859518aae15e9f8711deab12456937e92af2f7c308bc44510e3b1c237ee13f5
+  data.tar.gz: 1f32a4f0f8f5a86f9284ec801008cda7dd4f539cdc2b674e20eb74bdb6bc450d3ce125347f89418e1cb301fa1987ba6d1e6c89d221a96c2307b8fdc5189ce916

data/README.md

@@ -0,0 +1,48 @@
+# Turbo Native for RubyMotion
+
+**Build high-fidelity hybrid apps with native navigation and a single shared web view.** Turbo Native for RubyMotion provides the tooling to wrap your [Turbo 7](https://github.com/hotwired/turbo)-enabled web app in a native iOS shell. It manages a single WKWebView instance across multiple view controllers, giving you native navigation UI with all the client-side performance benefits of Turbo.
+
+## Features
+
+- **Deliver fast, efficient hybrid apps.** Avoid reloading JavaScript and CSS. Save memory by sharing one WKWebView.
+- **Reuse mobile web views across platforms.** Create your views once, on the server, in HTML. Deploy them to iOS, [Android](https://github.com/hotwired/turbo-android), and mobile browsers simultaneously. Ship new features without waiting on App Store approval.
+- **Enhance web views with native UI.** Navigate web views using native patterns. Augment web UI with native controls.
+- **Produce large apps with small teams.** Achieve baseline HTML coverage for free. Upgrade to native views as needed.
+
+### Features of Turbo Native for RubyMotion
+
+- **Ruby syntax. Native performance.** Build native iOS and Android apps using the Ruby syntax you know and love with the same performance as Swift and Java by using [RubyMotion](http://www.rubymotion.com/).
+
+## Requirements
+
+Turbo Native for RubyMotion is compatible with all versions of RubyMotion.
+
+**Note:** You should understand how Turbo works with web applications in the browser before attempting to use Turbo iOS. See the [Turbo 7 documentation](https://github.com/hotwired/turbo) for details. Ensure that your web app sets the `window.Turbo` global variable as it's required by the native apps:
+
+```javascript
+import { Turbo } from "@hotwired/turbo-rails"
+window.Turbo = Turbo
+```
+
+## Getting Started
+
+The best way to get started with Turbo Native is to try out the demo app first to get familiar with the framework. The demo app walks you through all the basic Turbo flows as well as some advanced features. To run the demo, clone this repo and open `Demo/Demo.xcworkspace` in Xcode and run the Demo target. See [Demo/README.md](Demo/README.md) for more details about the demo. When you’re ready to start your own application, read through the rest of the documentation.
+
+## Documentation
+
+- [Quick Start](docs/QuickStartGuide.md)
+
+## Contributing
+
+Turbo iOS is open-source software, freely distributable under the terms of an [MIT-style license](LICENSE). The [source code is hosted on GitHub](https://github.com/hotwired/turbo-ios).
+Development is sponsored by [Basecamp](https://basecamp.com/).
+
+We welcome contributions in the form of bug reports, pull requests, or thoughtful discussions in the [GitHub issue tracker](https://github.com/hotwired/turbo-ios/issues).
+
+Please note that this project is released with a [Contributor Code of Conduct](CONDUCT.md). By participating in this project you agree to abide by its terms.
+
+---
+
+© 2020 Basecamp, LLC
+
+

data/lib/motion-turbo.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+lib_dir_path = File.dirname(File.expand_path(__FILE__))
+Motion::Project::App.setup do |app|
+  app.files.unshift(Dir.glob(File.join(lib_dir_path, "turbo/**/*.rb")))
+  app.resources_dirs.unshift(Dir.glob(File.join(lib_dir_path, "../resources")))
+  app.frameworks += ['WebKit']
+end
+
+module Turbo
+end

data/lib/turbo/logging.rb

@@ -0,0 +1,31 @@
+module Turbo
+  def self.logger
+    @logger ||= Motion::Lager.new(level: "debug")
+  end
+end
+
+class TurboLog
+  def self.debugLoggingEnabled
+    true # TODO NSBundle.mainBundle.objectForInfoDictionaryKey('DEBUG')
+  end
+end
+
+def debugLog(message)
+  debugLog(message, arguments: {})
+end
+
+def debugLog(message, arguments: arguments)
+  timestamp = NSDate.new
+
+  log2("#{timestamp} #{message} #{arguments}")
+end
+
+def debugPrint(message)
+  log2(message)
+end
+
+def log2(message)
+  if TurboLog.debugLoggingEnabled
+    NSLog(message)
+  end
+end

data/lib/turbo/path_configuration/path_configuration.rb

@@ -0,0 +1,55 @@
+module Turbo
+  class PathConfiguration
+
+    attr_accessor :sources, :loader, :delegate, :rules, :settings
+    # Multiple sources will be loaded in order
+    # Remote sources should be last since they're loaded async
+    def initWithSources(sources)
+      self.sources = sources
+      self.rules = []
+      load
+      self
+    end
+
+    # Returns a merged hash containing all the properties
+    # that match this url
+    # Note: currently only looks at path, not query, but most likely will
+    # add query support in the future, so it's best to always use this over the path variant
+    # unless you're sure you'll never need to reference other parts of the URL in the future
+    def propertiesForURL(url)
+      propertiesForPath(url.path)
+    end
+
+    # Returns a merged hash containing all the properties
+    # that match this path
+    def propertiesForPath(path)
+      #source = NSString.stringWithContentsOfURL(url, encoding: NSUTF8StringEncoding, error: nil)
+      properties = {}
+
+      rules.each do |rule|
+        if rule.match(path)
+          properties.merge!(rule.properties)
+        end
+      end
+      properties
+    end
+
+    private
+
+    def load
+      loader = PathConfigurationLoader.alloc.initWithSources(sources)
+      if loader
+        loader.load do |config|
+          self.send(:update, config)
+        end
+      end
+    end
+
+    def update(config)
+      # Update our internal state with the config from the loader
+      self.settings = config.settings
+      self.rules = config.rules
+      delegate.pathConfigurationDidUpdate if delegate
+    end
+  end
+end

data/lib/turbo/path_configuration/path_configuration_decoder.rb

@@ -0,0 +1,25 @@
+module Turbo
+  class PathConfigurationDecoder
+    attr_accessor :settings, :rules
+
+    def initWithSettings(settings, rules: rules)
+      self.settings = settings
+      self.rules = rules
+      self
+    end
+
+    def initWithJSON(json)
+      # rules must be present, settings are optional
+      #guard let rulesArray = json["rules"] as? [[String: AnyHashable]] else {
+        #throw JSONDecodingError.invalidJSON
+      #}
+
+      rules = json["rules"].map do |rule|
+        PathRule.alloc.initWithRule(rule)
+      end
+      settings = json["settings"]
+
+      initWithSettings(settings, rules: rules)
+    end
+  end
+end

data/lib/turbo/path_configuration/path_configuration_loader.rb

@@ -0,0 +1,62 @@
+module Turbo
+  class PathConfigurationLoader
+    PathConfigurationLoaderCompletionHandler = Class.new(PathConfigurationDecoder)
+
+    attr_accessor :sources, :completionHandler
+    def initWithSources(sources)
+      self.sources = sources
+      self
+    end
+
+    def load(&completionHandler)
+      #completionHandler = PathConfigurationLoaderCompletionHandler.new
+
+      sources.each do |source|
+        #case source
+        #when .data(let data)
+          #data = loadData(source)
+          data = loadFile(source)
+          completionHandler.call(data)
+
+        #when .file(let url):
+          #loadFile(source)
+        #when .server(let url):
+          #download(from: url)
+        #end
+      end
+    end
+
+    private
+
+    def cacheDirectory
+      "Turbo"
+    end
+
+    def configurationCacheFilename
+      "path-configuration.json"
+    end
+
+    # MARK: - File
+
+    def loadFile(url)
+      #precondition(url.isFileURL, "URL provided for file is not a file url")
+      error_ptr = Pointer.new(:object)
+      data = NSData.alloc.initWithContentsOfURL(url, options:NSDataReadingUncached, error:error_ptr)
+      #begin
+        #data = File.read(url) #try Data(contentsOf: url)
+        loadData(data)
+        #end catch {
+        #debugPrint("[path-configuration] *** error loading configuration from file: \(url), error: \(error)")
+        #end
+      #end
+    end
+
+    # MARK: - Data
+
+    def loadData(json) #, cache: cache)
+      error_ptr = Pointer.new(:object)
+      data = NSJSONSerialization.JSONObjectWithData(json, options: 0, error: error_ptr)
+      PathConfigurationDecoder.alloc.initWithJSON(data)
+    end
+  end
+end

data/lib/turbo/path_configuration/path_rule.rb

@@ -0,0 +1,34 @@
+module Turbo
+  class PathRule
+    # Array of regular expressions to match against
+    attr_accessor :patterns
+
+    # The properties to apply for matches
+    attr_accessor :properties
+
+    # Convenience method to retrieve a String value for a key
+    # Access `properties` directly to get a different type
+    def subscript(key)
+      properties[key].to_s
+    end
+
+    def initWithRule(rule)
+      self.patterns = rule["patterns"]
+      self.properties = rule["properties"]
+      self
+    end
+
+    # Returns true if any pattern in this rule matches `path`
+    def match(path)
+      patterns.each do |pattern|
+        #guard let regex = try? NSRegularExpression(pattern: pattern) else { continue }
+        regex = %r(#{pattern})
+
+        if path =~ regex
+          return true
+        end
+      end
+      false
+    end
+  end
+end

data/lib/turbo/session/navigation_delegate_methods.rb

@@ -0,0 +1,43 @@
+module Turbo
+  class Session
+    module NavigationDelegateMethods
+
+      attr_accessor :navigationAction
+
+      def webView(webview, decidePolicyForNavigationAction: navigationAction, decisionHandler: decisionHandler)
+        navigationDecision = NavigationDecision(navigationAction: navigationAction)
+        decisionHandler(navigationDecision.policy)
+
+        if url = navigationDecision.externallyOpenableURL
+          openExternalURL(url)
+        elsif navigationDecision.shouldReloadPage
+          reload
+        end
+      end
+
+      def policy
+        navigationAction.navigationType == WKNavigationTypeLinkActivated || isMainFrameNavigation ? WKNavigationResponsePolicyCancel : WKNavigationResponsePolicyAllow
+      end
+
+      def externallyOpenableURL
+        if url = navigationAction.request.url && shouldOpenURLExternally
+          url
+        end
+      end
+
+      def shouldOpenURLExternally
+        type = navigationAction.navigationType
+        return type == WKNavigationTypeLinkActivated || (isMainFrameNavigation && type == WKNavigationTypeOther)
+      end
+
+      def shouldReloadPage
+        type = navigationAction.navigationType
+        return isMainFrameNavigation && type == WKNavigationTypeReload
+      end
+
+      def isMainFrameNavigation
+        navigationAction.targetFrame.isMainFrame if navigationAction.targetFrame
+      end
+    end
+  end
+end

data/lib/turbo/session/session.rb

@@ -0,0 +1,183 @@
+module Turbo
+  # A Session represents the main interface for managing
+  # a Turbo app in a web view. Each Session manages a single web view
+  # so you should create multiple sessions to have multiple web views, for example
+  # when using modals or tabs
+  class Session
+    include VisitDelegateMethods
+    include VisitableDelegateMethods
+    include WebViewDelegateMethods
+    include SessionDelegateMethods
+    include NavigationDelegateMethods
+
+    attr_accessor :delegate, :webView, :pathConfiguration, :bridge
+    attr_reader :initialized,
+                :refreshing,
+                :activatedVisitable,
+                :currentVisit,
+                :topmostVisit,
+                :topmostVisitable
+
+    def init
+      initWithConfiguration(WKWebViewConfiguration.alloc.init)
+    end
+
+    def initWithConfiguration(configuration)
+      webViewConfiguration = configuration
+      webView = WKWebView.alloc.initWithFrame(CGRectZero, configuration: webViewConfiguration)
+      webView.layer.borderColor = UIColor.blueColor
+      webView.layer.borderWidth = 2
+
+      initWithWebView(webView)
+    end
+
+    def initWithWebView(webView)
+      @webView = webView
+      @initialized = false
+      @refreshing = false
+      setup
+      self
+    end
+
+    private
+
+    def bridge
+      @bridge ||= WebViewBridge.alloc.initWithWebView(webView)
+    end
+
+    def setup
+      webView.translatesAutoresizingMaskIntoConstraints = false
+      bridge.delegate = self
+    end
+
+    public
+
+    # The topmost visitable is the visitable that has most recently completed a visit
+    def topmostVisitable
+      topmostVisit.visitable if topmostVisit
+    end
+
+    # The active visitable is the visitable that currently owns the web view
+    def activeVisitable
+      activatedVisitable
+    end
+
+    def visitVisitable(visitable)
+      visitVisitable(visitable, options: nil)
+    end
+
+    def visitVisitable(visitable, action: action)
+      visitVisitable(visitable, options: VisitOptions.alloc.initWithAction(action, response: nil))
+    end
+
+    def visitVisitable(visitable, options: options)
+      visitVisitable(visitable, options: options, reload: false)
+    end
+
+    def visitVisitable(visitable, options: options, reload: reload)
+      # TODO raise instead?
+      raise "Visitable must provide a url! #{visitable}" unless visitable.visitableURL
+
+      visitable.visitableDelegate = self
+
+      if reload
+        @initialized = false
+      end
+
+      visit = makeVisit(visitable, options: options || VisitOptions.alloc.initFromHash({}))
+      @currentVisit.cancel if currentVisit
+      @currentVisit = visit
+
+      log("visit", { location: visit.location, options: visit.options, reload: reload })
+
+      visit.delegate = self
+      visit.start
+    end
+
+    def makeVisit(visitable, options: options)
+      if initialized
+        restorationIdentifier = restorationIdentifierForVisitable(visitable)
+        JavaScriptVisit.alloc.initWithVisitable(visitable, options: options, bridge: bridge, restorationIdentifier: restorationIdentifier)
+      else
+        ColdBootVisit.alloc.initWithVisitable(visitable, options: options, bridge: bridge)
+      end
+    end
+
+    def reload
+      return unless visitable = topmostVisitable
+      @initialized = false
+      visitVisitable(visitable)
+      @topmostVisit = currentVisit
+    end
+
+    def clearSnapshotCache
+      bridge.clearSnapshotCache
+    end
+
+    # Visitable activation
+
+    private
+
+    def activateVisitable(visitable)
+      return if isActivatedVisitable(visitable)
+
+      deactivateActivatedVisitable
+      visitable.activateVisitableWebView(webView)
+      @activatedVisitable = visitable
+    end
+
+    def deactivateActivatedVisitable
+      if activatedVisitable
+        deactivateVisitable(activatedVisitable, showScreenshot: true)
+      end
+    end
+
+    def deactivateVisitable(visitable, showScreenshot: showScreenshot)
+      if visitable == activatedVisitable
+        if showScreenshot
+          visitable.updateVisitableScreenshot
+          visitable.showVisitableScreenshot
+        end
+
+        visitable.deactivateVisitableWebView
+        @activatedVisitable = nil
+      end
+    end
+
+    def isActivatedVisitable(visitable)
+      visitable == activatedVisitable
+    end
+
+    # Visitable restoration identifiers
+
+    def visitableRestorationIdentifiers
+      @visitableRestorationIdentifiers ||= NSMapTable.weakToStrongObjectsMapTable
+    end
+
+    def restorationIdentifierForVisitable(visitable)
+      visitableRestorationIdentifiers.objectForKey(visitable.visitableViewController)
+    end
+
+    def storeRestorationIdentifier(restorationIdentifier, forVisitable: visitable)
+      visitableRestorationIdentifiers.setObject(restorationIdentifier, forKey: visitable.visitableViewController)
+    end
+
+    # MARK: - Navigation
+
+    def completeNavigationForCurrentVisit
+      if currentVisit
+        @topmostVisit = currentVisit
+      end
+    end
+
+    private
+
+    def log(name)
+      log(name, {})
+    end
+
+    def log(name, arguments)
+      Turbo.logger.debug("[Session] #{name} #{arguments}", :magenta)
+    end
+  end
+end

data/lib/turbo/session/session_delegate_methods.rb

@@ -0,0 +1,30 @@
+module Turbo
+  class Session
+    module SessionDelegateMethods
+
+      def sessionDidLoadWebView(session)
+        session.webView.navigationDelegate = session
+      end
+
+      def session(session, openExternalURL: url)
+        UIApplication.shared.open(url)
+      end
+
+      def sessionDidStartRequest(session)
+      end
+
+      def sessionDidFinishRequest(session)
+      end
+
+      def sessionDidStartFormSubmission(session)
+      end
+
+      def sessionDidFinishFormSubmission(session)
+      end
+
+      def session(session, didReceiveAuthenticationChallenge: challenge, &completionHandler)
+        completionHandler.call(NSURLAuthenticationChallengeSender.performDefaultHandlingForAuthenticationChallenge, nil)
+      end
+    end
+  end
+end

data/lib/turbo/session/visit_delegate_methods.rb

@@ -0,0 +1,67 @@
+module Turbo
+  class Session
+    module VisitDelegateMethods
+      def visitRequestDidStart(visit)
+        delegate.sessionDidStartRequest(self) if delegate
+      end
+
+      def visitRequestDidFinish(visit)
+        delegate.sessionDidFinishRequest(self) if delegate
+      end
+
+      def visit(visit, requestDidFailWithError: error)
+        delegate.session(self, didFailRequestForVisitable: visit.visitable, withError: error) if delegate
+      end
+
+      def visitDidInitializeWebView(visit)
+        @initialized = true
+        delegate.sessionDidLoadWebView(self) if delegate
+      end
+
+      def visitWillStart(visit)
+        visit.visitable.showVisitableScreenshot
+        activateVisitable(visit.visitable)
+      end
+
+      def visitDidStart(visit)
+        unless visit.hasCachedSnapshot
+          visit.visitable.showVisitableActivityIndicator
+        end
+      end
+
+      def visitWillLoadResponse(visit)
+        visit.visitable.updateVisitableScreenshot
+        visit.visitable.showVisitableScreenshot
+      end
+
+      def visitDidRender(visit)
+        visit.visitable.hideVisitableScreenshot
+        visit.visitable.hideVisitableActivityIndicator
+        visit.visitable.visitableDidRender
+      end
+
+      def visitDidComplete(visit)
+        if restorationIdentifier = visit.restorationIdentifier
+          storeRestorationIdentifier(restorationIdentifier, forVisitable: visit.visitable)
+        end
+      end
+
+      def visitDidFail(visit)
+        visit.visitable.clearVisitableScreenshot
+        visit.visitable.showVisitableScreenshot
+        visit.visitable.hideVisitableActivityIndicator
+      end
+
+      def visitDidFinish(visit)
+        if refreshing
+          @refreshing = false
+          visit.visitable.visitableDidRefresh
+        end
+      end
+
+      def visit(visit, didReceiveAuthenticationChallenge: challenge, &completionHandler)
+        delegate?.session(self, didReceiveAuthenticationChallenge: challenge, completionHandler: completionHandler)
+      end
+    end
+  end
+end

data/lib/turbo/session/visitable_delegate_methods.rb

@@ -0,0 +1,51 @@
+module Turbo
+  class Session
+    module VisitableDelegateMethods
+      def visitableViewWillAppear(visitable)
+        return unless topmostVisit && currentVisit
+
+        if visitable == topmostVisit.visitable && visitable.visitableViewController.isMovingToParentViewController
+          # Back swipe gesture canceled
+          if topmostVisit.state.to_sym == :completed
+            currentVisit.cancel
+          else
+            visitVisitable(visitable, action: :advance)
+          end
+        elsif visitable == currentVisit.visitable && currentVisit.state.to_sym == :started
+          # Navigating forward - complete navigation early
+          completeNavigationForCurrentVisit
+        elsif visitable != topmostVisit.visitable
+          # Navigating backward
+          visitVisitable(visitable, action: :restore)
+        end
+      end
+
+      def visitableViewDidAppear(visitable)
+        if currentVisit && visitable == currentVisit.visitable
+          # Appearing after successful navigation
+          completeNavigationForCurrentVisit
+          if currentVisit.state.to_sym != :failed
+            activateVisitable(visitable)
+          end
+        elsif topmostVisit && visitable == topmostVisit.visitable && topmostVisit.state == :completed
+          # Reappearing after canceled navigation
+          visitVisitable(visitable, action: :restore)
+        end
+      end
+
+      def visitableDidRequestReload(visitable)
+        if visitable == topmostVisitable
+          reload
+        end
+      end
+
+      def visitableDidRequestRefresh(visitable)
+        if visitable == topmostVisitable
+          @refreshing = true
+          visitable.visitableWillRefresh
+          reload
+        end
+      end
+    end
+  end
+end