motion-turbo 0.1

data/lib/turbo/session/web_view_delegate_methods.rb

@@ -0,0 +1,46 @@
+module Turbo
+  class Session
+    module WebViewDelegateMethods
+      def webView(webView, didProposeVisitToLocation: location, withOptions: options)
+        properties = pathConfiguration ? pathConfiguration.propertiesForURL(location) : {}
+        proposal = VisitProposal.alloc.initWithURL(location, options: options, properties: properties)
+        delegate.session(self, didProposeVisit: proposal) if delegate
+      end
+
+      def webView(webView, didStartFormSubmissionToLocation: location)
+        delegate.sessionDidStartFormSubmission(self) if delegate
+      end
+
+      def webView(webView, didFinishFormSubmissionToLocation: location)
+        delegate.sessionDidFinishFormSubmission(self) if delegate
+      end
+
+      def webViewDidInvalidatePage(webView)
+        if topmostVisitable
+          topmostVisitable.updateVisitableScreenshot
+          topmostVisitable.showVisitableScreenshot
+          topmostVisitable.showVisitableActivityIndicator
+          reload
+        end
+      end
+
+      # Initial page load failed, this will happen when we couldn't find Turbo JS on the page
+      def webView(webView, didFailInitialPageLoadWithError: error)
+        return unless currentVisit = self.currentVisit && !initialized
+
+        @initialized = false
+        currentVisit.cancel
+        visitDidFail(currentVisit)
+        visit(currentVisit, requestDidFailWithError: error)
+      end
+
+      def webView(webView, didFailJavaScriptEvaluationWithError: error)
+        return unless currentVisit = self.currentVisit && initialized
+
+        @initialized = false
+        currentVisit.cancel
+        visit(currentVisit.visitable)
+      end
+    end
+  end
+end

data/lib/turbo/turbo_error.rb

@@ -0,0 +1,30 @@
+module Turbo
+  class TurboError < NSError
+    ERROR_DOMAIN = "com.basecamp.Turbolinks"
+    ERROR_CODES = {
+      http_failure: 0,
+      network_failure: -1,
+      content_type_mismatch: -2
+    }
+    attr_accessor :statusCode
+
+    def self.pageLoadFailure
+      localizedDescription = "The page could not be loaded due to a configuration error."
+      errorWithDomain(ERROR_DOMAIN, code: 123, userInfo: { NSLocalizedDescriptionKey => localizedDescription })
+    end
+
+    def self.errorWithCode(code, localizedDescription: localizedDescription)
+      errorWithDomain(ERROR_DOMAIN, code: ERROR_CODES[code], userInfo: { NSLocalizedDescriptionKey => localizedDescription })
+    end
+
+    def self.errorWithCode(code, statusCode: statusCode)
+      error = errorWithDomain(ERROR_DOMAIN, code: ERROR_CODES[code], userInfo: { "statusCode" => statusCode, NSLocalizedDescriptionKey => "HTTP Error: #{statusCode}" })
+      error.statusCode = statusCode
+      error
+    end
+
+    def self.errorWithCode(code, error: error)
+      errorWithDomain(ERROR_DOMAIN, code: ERROR_CODES[code], userInfo: { "error" => error, NSLocalizedDescriptionKey => error.localizedDescription })
+    end
+  end
+end

data/lib/turbo/visit/cold_boot_visit.rb

@@ -0,0 +1,109 @@
+module Turbo
+  # A "Cold Boot" visit is the initial visit to load the page, including all resources
+  # Subsequent visits go through Turbo and use `JavaScriptVisit`
+  class ColdBootVisit < Visit
+    attr_reader :navigation
+
+    def startVisit
+      log("startVisit")
+      webView.navigationDelegate = self
+      bridge.pageLoadDelegate = self
+
+      request = NSURLRequest.alloc.initWithURL(location)
+      @navigation = webView.loadRequest(request)
+
+      delegate.visitDidStart(self) if delegate
+      startRequest
+    end
+
+    def cancelVisit
+      log("cancelVisit")
+      removeNavigationDelegate
+      webView.stopLoading
+      finishRequest
+    end
+
+    def completeVisit
+      log("completeVisit")
+      removeNavigationDelegate
+      delegate.visitDidInitializeWebView(self) if delegate
+    end
+
+    def failVisit
+      log("cancelVisit")
+      removeNavigationDelegate
+      finishRequest
+    end
+
+    def removeNavigationDelegate
+      if webView.navigationDelegate == self
+        webView.navigationDelegate = nil
+      end
+    end
+
+    private
+
+    def log(name)
+      Turbo.logger.debug("[ColdBootVisit] #{name} #{location.absoluteString}", :cyan)
+    end
+
+    # WKNavigationDelegate methods
+
+    public
+
+    def webView(webView, didFinishNavigation: navigation)
+      if navigation == self.navigation
+        finishRequest
+      end
+    end
+
+    def webView(webView, decidePolicyForNavigationAction: navigationAction, decisionHandler: decisionHandler)
+      @navigationActionDecisionHandler = decisionHandler
+      # Ignore any clicked links before the cold boot finishes navigation
+      if navigationAction.navigationType == WKNavigationTypeLinkActivated
+        @navigationActionDecisionHandler.call(WKNavigationActionPolicyCancel)
+        if url = navigationAction.request.URL
+          UIApplication.sharedApplication.openURL(url)
+        end
+      else
+        @navigationActionDecisionHandler.call(WKNavigationActionPolicyAllow)
+      end
+    end
+
+    def webView(webView, decidePolicyForNavigationResponse: navigationResponse, decisionHandler: decisionHandler)
+      if httpResponse = navigationResponse.response
+        if httpResponse.statusCode >= 200 && httpResponse.statusCode < 300
+          decisionHandler.call(WKNavigationResponsePolicyAllow)
+        else
+          decisionHandler.call(WKNavigationResponsePolicyCancel)
+          fail(TurboError.errorWithCode(:http_failure, statusCode: httpResponse.statusCode))
+        end
+      else
+        decisionHandler.call(WKNavigationResponsePolicyCancel)
+        fail(TurboError.errorWithCode(:network_failure, localizedDescription: "An unknown error occurred"))
+      end
+    end
+
+    def webView(webView, didFailProvisionalNavigation: navigation, withError: originalError)
+      if navigation == self.navigation
+        fail(TurboError.errorWithCode(:network_failure, error: originalError))
+      end
+    end
+
+    def webView(webView, didFailNavigation: navigation, withError: originalError)
+      if navigation === self.navigation
+        fail(TurboError.errorWithCode(:network_failure, error: originalError))
+      end
+    end
+
+    # WebViewPageLoadDelegate
+
+    def webView(webView, didLoadPageWithRestorationIdentifier: restorationIdentifier)
+      @restorationIdentifier = restorationIdentifier
+      delegate.visitDidRender(self) if delegate
+      complete
+    end
+
+  end
+end
+

data/lib/turbo/visit/javascript_visit.rb

@@ -0,0 +1,107 @@
+module Turbo
+  # A JavaScript managed visit through the Turbo library
+  # All visits are JavaScriptVisits except the initial ColdBootVisit
+  # or if a reload() is issued
+  class JavaScriptVisit < Visit
+    attr_writer :identifier, :hasCachedSnapshot
+    def identifier
+      @identifier ||= "(pending)"
+    end
+
+    def initWithVisitable(visitable, options: options, bridge: bridge, restorationIdentifier: restorationIdentifier)
+      initWithVisitable(visitable, options: options, bridge: bridge)
+      self.restorationIdentifier = restorationIdentifier
+      self
+    end
+
+    def description
+      "<#{dynamicType} #{identifier}: state=#{state} location=#{location}>"
+    end
+
+    def startVisit
+      log("startVisit")
+      bridge.visitDelegate = self
+      bridge.visitLocation(location, withOptions: options, restorationIdentifier: restorationIdentifier)
+    end
+
+    def cancelVisit
+      log("cancelVisit")
+      bridge.cancelVisitWithIdentifier(identifier)
+      finishRequest
+    end
+
+    def failVisit
+      log("failVisit")
+      finishRequest
+    end
+
+    # WebViewVisitDelegate
+
+    def webView(webView, didStartVisitWithIdentifier: identifier, hasCachedSnapshot: hasCachedSnapshot)
+      log("didStartVisitWithIdentifier", arguments: { identifier: identifier, hasCachedSnapshot: hasCachedSnapshot })
+      self.identifier = identifier
+      self.hasCachedSnapshot = hasCachedSnapshot
+
+      delegate.visitDidStart(self) if delegate
+    end
+
+    def webView(webView, didStartRequestForVisitWithIdentifier: identifier, date: date)
+      log("didStartRequestForVisitWithIdentifier", arguments: { identifier: identifier, date: date })
+      if identifier == self.identifier
+        startRequest
+      end
+    end
+
+    def webView(webView, didCompleteRequestForVisitWithIdentifier: identifier)
+      log("didCompleteRequestForVisitWithIdentifier", arguments: { identifier: identifier })
+      if identifier == self.identifier
+        delegate.visitWillLoadResponse(self) if hasCachedSnapshot && delegate
+      end
+    end
+
+    def webView(webView, didFailRequestForVisitWithIdentifier: identifier, statusCode: statusCode)
+      log("didCompleteRequestForVisitWithIdentifier", arguments: { identifier: identifier, statusCode: statusCode })
+      if identifier == self.identifier
+        # TODO implemented differently
+        if statusCode == 0
+          error = TurboError.errorWithCode(:network_failure, localizedDescription: "A network error occurred.")
+        else
+          error = TurboError.errorWithCode(:http_failure, statusCode: statusCode)
+        end
+        fail(error)
+      end
+    end
+
+    def webView(webView, didFinishRequestForVisitWithIdentifier: identifier, date: date)
+      log("didFinishRequestForVisitWithIdentifier", arguments: { identifier: identifier, date: date })
+      if identifier == self.identifier
+        finishRequest
+      end
+    end
+
+    def webView(webView, didRenderForVisitWithIdentifier: identifier)
+      log("didRenderForVisitWithIdentifier", arguments: { identifier: identifier })
+      if identifier == self.identifier
+        delegate.visitDidRender(self) if delegate
+      end
+    end
+
+    def webView(webView, didCompleteVisitWithIdentifier: identifier, restorationIdentifier: restorationIdentifier)
+      log("didCompleteVisitWithIdentifier", arguments: { identifier: identifier, restorationIdentifier: restorationIdentifier })
+      if identifier == self.identifier
+        @restorationIdentifier = restorationIdentifier
+        complete
+      end
+    end
+
+    private
+
+    def log(name)
+      log(name, arguments: nil)
+    end
+
+    def log(name, arguments: arguments)
+      Turbo.logger.debug("[JavaScriptVisit] #{name} #{location.absoluteString}", :green)
+    end
+  end
+end

data/lib/turbo/visit/visit.rb

@@ -0,0 +1,91 @@
+module Turbo
+  class Visit
+    attr_accessor :delegate, :restorationIdentifier
+    attr_reader :visitable,
+                :webView,
+                :bridge,
+                :options,
+                :state,
+                :location,
+                :hasCachedSnapshot
+
+    def initWithVisitable(visitable, options: options, bridge: bridge)
+      raise visitable.visitableURL.inspect if visitable.visitableURL.is_a?(Hash)# TODO
+      raise options.inspect unless options.is_a?(VisitOptions)# TODO
+      @visitable = visitable
+      @location = visitable.visitableURL
+      @options = options
+      @bridge = bridge
+      @webView = @bridge.webView
+      @state = :initialized
+      @hasCachedSnapshot = false
+      self
+    end
+
+    def start
+      if state == :initialized
+        delegate.visitWillStart(self) if delegate
+        @state = :started
+        startVisit
+      end
+    end
+
+    def cancel
+      if state == :started
+        @state = :canceled
+        cancelVisit
+      end
+    end
+
+    def complete
+      if state == :started
+        @state = :completed
+        completeVisit
+        delegate.visitDidComplete(self) if delegate
+        delegate.visitDidFinish(self) if delegate
+      end
+    end
+
+    def fail(error)
+      if state == :started
+        @state = :failed
+        delegate.visit(self, requestDidFailWithError: error) if delegate
+        failVisit
+        delegate.visitDidFail(self) if delegate
+        delegate.visitDidFinish(self) if delegate
+      end
+    end
+
+    # Hooks for subclasses
+    def startVisit; end
+    def cancelVisit; end
+    def completeVisit; end
+    def failVisit; end
+
+    private
+
+    # Request state
+
+    def requestStarted
+      @requestStarted ||= false
+    end
+
+    def requestFinished
+       @requestFinished ||= false
+    end
+
+    def startRequest
+      unless requestStarted
+        @requestStarted = true
+        delegate.visitRequestDidStart(self) if delegate
+      end
+    end
+
+    def finishRequest
+      if requestStarted && !requestFinished
+        @requestFinished = true
+        delegate.visitRequestDidFinish(self) if delegate
+      end
+    end
+  end
+end

data/lib/turbo/visit/visit_options.rb

@@ -0,0 +1,36 @@
+module Turbo
+  class VisitOptions
+    attr_reader :action, :response
+
+    # TODO not used for now
+    def initWithAction(action, response: response)
+      @action = action
+      if response
+        @response = VisitResponse.alloc.initWithStatusCode(response["statusCode"], responseHTML: response["innerHTML"])
+      end
+      self
+    end
+
+    def initFromHash(options)
+      raise "options is not a Hash" unless options.is_a?(Hash) # TODO remove?
+      @action = options["action"] || 'advance'
+      if response = options["response"]
+        @response = VisitResponse.alloc.initWithStatusCode(response["statusCode"], responseHTML: response["responseHTML"])
+      end
+      self
+    end
+
+    # TODO Codable, JSONCodable?
+    def encode
+      if response
+        { action: @action, response: response.encode }
+      else
+        { action: @action }
+      end
+    end
+
+    def inspect
+      "#<VisitOptions action=#{action} response=#{response}>"
+    end
+  end
+end

data/lib/turbo/visit/visit_proposal.rb

@@ -0,0 +1,13 @@
+module Turbo
+  class VisitProposal
+    attr_reader :url, :options, :properties
+
+    def initWithURL(url, options: options, properties: properties)
+      @url = url
+      raise unless options.is_a?(VisitOptions)
+      @options = options
+      @properties = properties || {}
+      self
+    end
+  end
+end

data/lib/turbo/visit/visit_response.rb

@@ -0,0 +1,29 @@
+module Turbo
+  class VisitResponse
+    attr_reader :statusCode, :responseHTML
+
+    def initWithStatusCode(statusCode, responseHTML: responseHTML)
+      @statusCode = statusCode
+      @responseHTML = responseHTML
+      self
+    end
+
+    # TODO Codable, JSONCodable?
+    def encode
+      { statusCode: statusCode, responseHTML: responseHTML }
+    end
+
+    def inspect
+      "#<VisitResponse statusCode=#{statusCode} responseHTML=#{responseHTML.inspect}>"
+    end
+
+    #TODO public var isSuccessful: Bool {
+        #switch statusCode {
+        #case 200...299:
+            #return true
+        #default:
+            #return false
+        #}
+    #}
+  end
+end

data/lib/turbo/visitable/visitable.rb

@@ -0,0 +1,58 @@
+module Turbo
+  module Visitable
+    attr_accessor :visitableDelegate
+    attr_reader :visitableView, :visitableURL
+
+    def reloadVisitable
+      visitableDelegate.visitableDidRequestReload(self) if visitableDelegate
+    end
+
+    def showVisitableActivityIndicator
+      visitableView.showActivityIndicator
+    end
+
+    def hideVisitableActivityIndicator
+      visitableView.hideActivityIndicator
+    end
+
+    def activateVisitableWebView(webView)
+      visitableView.activateWebView(webView, forVisitable: self)
+    end
+
+    def deactivateVisitableWebView
+      visitableView.deactivateWebView
+    end
+
+    def updateVisitableScreenshot
+      visitableView.updateScreenshot
+    end
+
+    def showVisitableScreenshot
+      visitableView.showScreenshot
+    end
+
+    def hideVisitableScreenshot
+      visitableView.hideScreenshot
+    end
+
+    def clearVisitableScreenshot
+      visitableView.clearScreenshot
+    end
+
+    def visitableWillRefresh
+      visitableView.refreshControl.beginRefreshing
+    end
+
+    def visitableDidRefresh
+      visitableView.refreshControl.endRefreshing
+    end
+
+    def visitableViewDidRequestRefresh
+      visitableDelegate.visitableDidRequestRefresh(self) if visitableDelegate
+    end
+
+    def visitableViewController
+      self
+    end
+  end
+end

data/lib/turbo/visitable/visitable_view.rb

@@ -0,0 +1,20 @@
+module Turbo
+  class VisitableView < UIView
+    include WebView
+    include Screenshots
+    include RefreshControl
+    include ActivityIndicator
+    include Constraints
+    include ScrollView
+
+    def initWithFrame(frame)
+      super
+      setup
+      self
+    end
+
+    def setup
+      installActivityIndicatorView
+    end
+  end
+end

data/lib/turbo/visitable/visitable_view_controller.rb

@@ -0,0 +1,71 @@
+module Turbo
+  class VisitableViewController < UIViewController
+    include Visitable
+
+    attr_accessor :visitableDelegate
+    attr_reader :visitableURL
+
+    def initWithURL(url)
+      if url.is_a? String
+        url = NSURL.alloc.initWithString(url)
+      end
+      @visitableURL = url
+      self
+    end
+
+    # View Lifecycle methods
+
+    def viewDidLoad
+      super
+      installVisitableView
+    end
+
+    def viewWillAppear(animated)
+      super
+      visitableDelegate.visitableViewWillAppear(self) if visitableDelegate
+    end
+
+    def viewDidAppear(animated)
+      super
+      visitableDelegate.visitableViewDidAppear(self) if visitableDelegate
+    end
+
+    # Visitable
+
+    def visitableDidRender
+      self.title = visitableView.webView.title if visitableView.webView
+    end
+
+    def showVisitableActivityIndicator
+      visitableView.showActivityIndicator
+    end
+
+    def hideVisitableActivityIndicator
+      visitableView.hideActivityIndicator
+    end
+
+    # Visitable View
+
+    def visitableView
+      @visitableView ||= begin
+        view = VisitableView.alloc.initWithFrame(CGRectZero)
+        view.translatesAutoresizingMaskIntoConstraints = false
+        view
+      end
+    end
+
+    private
+
+    def installVisitableView
+      view.addSubview(visitableView)
+      #view.insertSubview(visitableView, atIndex: 0)
+      self.edgesForExtendedLayout = UIRectEdgeAll # TODO document fix for fullscre
+      NSLayoutConstraint.activateConstraints([
+        visitableView.leadingAnchor.constraintEqualToAnchor(view.leadingAnchor),
+        visitableView.trailingAnchor.constraintEqualToAnchor(view.trailingAnchor),
+        visitableView.topAnchor.constraintEqualToAnchor(view.topAnchor),
+        visitableView.bottomAnchor.constraintEqualToAnchor(view.bottomAnchor)
+      ])
+    end
+  end
+end

data/lib/turbo/visitable_view/activity_indicator.rb

@@ -0,0 +1,36 @@
+module Turbo
+  class VisitableView < UIView
+    module ActivityIndicator
+      def activityIndicatorView
+        @activityIndicatorView ||= begin
+          view = UIActivityIndicatorView.alloc.initWithActivityIndicatorStyle(UIActivityIndicatorViewStyleMedium)
+          view.translatesAutoresizingMaskIntoConstraints = false
+          view.color = UIColor.grayColor
+          view.hidesWhenStopped = true
+          view
+        end
+      end
+
+      def showActivityIndicator
+        if !isRefreshing
+          activityIndicatorView.startAnimating
+          bringSubviewToFront(activityIndicatorView)
+        end
+      end
+
+      def hideActivityIndicator
+        activityIndicatorView.stopAnimating
+      end
+
+      private
+
+      def installActivityIndicatorView
+        addSubview(activityIndicatorView)
+        NSLayoutConstraint.activateConstraints([
+          activityIndicatorView.centerXAnchor.constraintEqualToAnchor(centerXAnchor),
+          activityIndicatorView.centerYAnchor.constraintEqualToAnchor(centerYAnchor)
+        ])
+      end
+    end
+  end
+end

data/lib/turbo/visitable_view/constraints.rb

@@ -0,0 +1,14 @@
+module Turbo
+  class VisitableView < UIView
+    module Constraints
+      def addFillConstraintsForSubview(view)
+        NSLayoutConstraint.activateConstraints([
+          view.leadingAnchor.constraintEqualToAnchor(leadingAnchor),
+          view.trailingAnchor.constraintEqualToAnchor(trailingAnchor),
+          view.topAnchor.constraintEqualToAnchor(topAnchor),
+          view.bottomAnchor.constraintEqualToAnchor(bottomAnchor)
+        ])
+      end
+    end
+  end
+end