bowser 0.4.3 → 0.5.0

data/opal/bowser/service_worker/cache_storage.rb

@@ -0,0 +1,49 @@
+require 'bowser/service_worker/response'
+require 'bowser/service_worker/promise'
+
+module Bowser
+  module ServiceWorker
+    class CacheStorage
+      def initialize
+        @native = `caches`
+      end
+
+      def match request, options={}
+        Promise.from_native(`
+          #@native.match(#{request.to_n}, #{options.to_n})
+            .then(#{proc { |value| value && Response.from_native(value) }})
+        `)
+      end
+
+      def has name
+        Promise.from_native(`#@native.has(name)`)
+      end
+
+      def open name
+        Promise.from_native(`
+          #@native.open(name)
+            .then(#{proc { |native| Cache.new(native) }})
+            .catch(#{proc { |native| `console.error(native)` }})
+        `)
+      end
+
+      class Cache
+        def initialize native
+          @native = native
+        end
+
+        def add_all requests
+          Promise.from_native(`#@native.addAll(#{requests.map(&:to_n)})`)
+        end
+
+        def put request, response
+          Promise.from_native(`#@native.put(#{request.to_n}, #{response.to_n})`)
+        end
+
+        def to_n
+          @native
+        end
+      end
+    end
+  end
+end

data/opal/bowser/service_worker/clients.rb

@@ -0,0 +1,19 @@
+require 'bowser/service_worker/promise'
+
+module Bowser
+  module ServiceWorker
+    class Clients
+      def initialize native
+        @native = native
+      end
+
+      def claim
+        Promise.from_native(`#@native.claim()`)
+      end
+
+      def to_n
+        @native
+      end
+    end
+  end
+end

data/opal/bowser/service_worker/context.rb

@@ -0,0 +1,71 @@
+require 'opal'
+require 'native'
+require 'bowser/service_worker/extendable_event'
+require 'bowser/service_worker/fetch_event'
+require 'bowser/service_worker/cache_storage'
+require 'bowser/service_worker/request'
+require 'bowser/service_worker/response'
+require 'bowser/service_worker/promise'
+require 'bowser/service_worker/clients'
+
+# Opal uses `self` internally, but we can use `this` to get the worker reference
+%x{ var worker = this; }
+
+module Bowser
+  module ServiceWorker
+    class Context
+      def initialize native
+        @native = native
+      end
+
+      def on event_name, &block
+        event_type = EVENT_TYPES.fetch(event_name) { ExtendableEvent }
+        handler = proc { |event| block.call(event_type.new(event)) }
+
+        %x{#@native.addEventListener(event_name, handler);}
+
+        self
+      end
+
+      def to_n
+        @native
+      end
+
+      def caches
+        @caches ||= CacheStorage.new
+      end
+
+      def fetch url
+        Promise.new do |promise|
+          %x{
+            fetch(#{url.to_n})
+              .then(#{proc { |response|
+                promise.resolve Response.from_native(response)
+              }})
+              .catch(#{proc { |error| promise.reject error }})
+          }
+        end
+      end
+
+      def skip_waiting
+        Promise.from_native(`#{to_n}.skipWaiting()`)
+      end
+
+      def clients
+        @clients ||= Clients.new(`#{to_n}.clients`)
+      end
+
+      EVENT_TYPES = {
+        fetch: FetchEvent,
+      }
+    end
+  end
+end
+
+def self.worker
+  Bowser::ServiceWorker::Context.new(`worker`)
+end
+
+def self.method_missing(*args, &block)
+  worker.send(*args, &block)
+end

data/opal/bowser/service_worker/extendable_event.rb

@@ -0,0 +1,19 @@
+module Bowser
+  module ServiceWorker
+    class ExtendableEvent
+      def initialize native
+        @native = native
+      end
+
+      def wait_until promise
+        `#@native.waitUntil(#{promise.to_n})`
+
+        promise
+      end
+
+      def to_n
+        @native
+      end
+    end
+  end
+end

data/opal/bowser/service_worker/fetch_event.rb

@@ -0,0 +1,28 @@
+require 'bowser/service_worker/request'
+require 'bowser/service_worker/extendable_event'
+
+module Bowser
+  module ServiceWorker
+    class FetchEvent < ExtendableEvent
+      def url
+        `#@native.request.url`
+      end
+
+      def reload?
+        `#@native.isReload`
+      end
+
+      def client_id
+        `#@native.clientId`
+      end
+
+      def request
+        @request ||= Request.from_native(`#@native.request`)
+      end
+
+      def respond_with promise
+        `#@native.respondWith(#{promise.then(&:to_n).to_n})`
+      end
+    end
+  end
+end

data/opal/bowser/service_worker/promise.rb

@@ -0,0 +1,101 @@
+module Bowser
+  module ServiceWorker
+    class Promise
+      attr_reader :value, :failure
+
+      def initialize &block
+        @native = `new Promise(function(resolve, reject) {
+          #{@resolve = `resolve`};
+          #{@reject = `reject`};
+          #{block.call(self) if block_given?};
+        })`
+      end
+
+      def self.from_native promise
+        p = allocate
+        p.instance_exec { @native = promise }
+        p
+      end
+
+      def self.all promises
+        from_native `Promise.all(#{promises.map(&:to_n)})`
+      end
+
+      def self.race promises
+        from_native `Promise.race(#{promises.map(&:to_n)})`
+      end
+
+      def self.reject reason
+        new.reject reason
+      end
+
+      def self.resolve value
+        new.resolve value
+      end
+
+      def then &block
+        Promise.from_native `#@native.then(block)`
+      end
+
+      def fail &block
+        Promise.from_native `#@native.catch(block)`
+      end
+
+      def always &block
+        Promise.from_native `#@native.then(block).fail(block)`
+      end
+
+      def resolve value
+        return self if resolved?
+        if rejected?
+          `console.warn(#{self}, #{"tried to resolve, already #{resolved? ? 'resolved' : 'rejected'} with"}, #{@value || @failure})`
+        end
+
+        @value = value
+        @resolve.call value
+        self
+      end
+
+      def reject failure
+        return self if rejected?
+        if resolved?
+          `console.warn(#{self}, #{"tried to reject, already #{resolved? ? 'resolved' : 'rejected'} with"}, #{@value || @failure})`
+        end
+
+        @failure = failure
+        @reject.call failure
+        self
+      end
+
+      def realized?
+        resolved? || rejected?
+      end
+
+      def resolved?
+        !value.nil?
+      end
+
+      def rejected?
+        !failure.nil?
+      end
+
+      def to_n
+        @native
+      end
+
+      %x{
+        Opal.defn(self, 'then', function(callback) {
+          var self = this;
+
+          #{self.then(&`callback`)};
+        });
+
+        Opal.defn(self, 'catch', function(callback) {
+          var self = this;
+
+          #{self.fail(&`callback`)};
+        });
+      }
+    end
+  end
+end

data/opal/bowser/service_worker/request.rb

@@ -0,0 +1,33 @@
+module Bowser
+  module ServiceWorker
+    class Request
+      def initialize url, options={}
+        @url = url
+        @options = options
+        @native = `new Request(url, #{options.to_n})`
+      end
+
+      def self.from_native native
+        request = allocate
+        request.instance_exec { @native = native }
+        request
+      end
+
+      def inspect
+        "#<#{self.class.name}:0x#{object_id.to_s(16)} @url=#{url.inspect}>"
+      end
+
+      def to_s
+        inspect
+      end
+
+      def url
+        @url || `#@native.url`
+      end
+
+      def to_n
+        @native
+      end
+    end
+  end
+end

data/opal/bowser/service_worker/response.rb

@@ -0,0 +1,41 @@
+module Bowser
+  module ServiceWorker
+    class Response
+      def self.from_native native
+        new(native) if `#{native} != null`
+      end
+
+      def initialize native
+        @native = native
+      end
+
+      def json
+        @json ||= `#@native.json()`
+      end
+
+      def text
+        @text ||= `#@native.text()`
+      end
+
+      def to_n
+        @native
+      end
+
+      def url
+        `#@native.url`
+      end
+
+      def status
+        `#@native.status`
+      end
+
+      def inspect
+        "#<#{self.class.name}:0x#{(object_id * 2).to_s(16)} @url=#{url.inspect} @status=#{status.inspect}>"
+      end
+
+      def to_s
+        inspect
+      end
+    end
+  end
+end

data/opal/bowser/websocket.rb

@@ -2,6 +2,7 @@ require 'bowser/window'
 require 'json'
 
 module Bowser
+  # A Ruby WebSocket class
   class WebSocket
     EVENT_NAMES = %w(
       open
@@ -10,6 +11,8 @@ module Bowser
       close
     )
 
+    # param url [String] the URL to connect to
+    # keywordparam native [JS] the native WebSocket connection
     def initialize url, native: `new WebSocket(url)`
       @url = url
       @native = native
@@ -20,6 +23,9 @@ module Bowser
       on(:close) { @connected = false }
     end
 
+    # Attach the given block as a handler for the specified event
+    #
+    # @param event_target [String] the name of the event to handle
     def on event_name, &block
       if EVENT_NAMES.include? event_name
         @handlers[event_name] << block
@@ -28,16 +34,23 @@ module Bowser
       end
     end
 
+    # Send the given message across the connection
+    #
+    # @param msg [Hash, Array] the message to send. Should be a JSON-serializable structure.
     def send_message msg
       `#@native.send(#{JSON.dump(msg)})`
       self
     end
 
+    # @return [Boolean] true if this socket is connected, false otherwise
     def connected?
       @connected
     end
 
     # Reconnect the websocket after a short delay if it is interrupted
+    #
+    # @keywordparam delay [Numeric] the number of seconds to wait before
+    #   reconnecting. Defaults to 1 second.
     def autoreconnect!(delay: 1)
       return if @autoreconnect
       @autoreconnect = true
@@ -47,6 +60,9 @@ module Bowser
       end
     end
 
+    # Close the current connection
+    #
+    # @param reason [String, nil] the reason this socket is being closed
     def close reason=`undefined`
       `#@native.close(reason)`
     end
@@ -113,6 +129,8 @@ module Bowser
 
   module_function
 
+  # @param url [String] the URL to connect to
+  # @return [Bowser::WebSocket] a websocket connection to the given URL
   def websocket *args
     WebSocket.new(*args)
   end

data/opal/bowser/window.rb

@@ -11,6 +11,9 @@ module Bowser
     module_function
 
     if `#@native.requestAnimationFrame !== undefined`
+      # Add the given block to the current iteration of the event loop. If this
+      # is called from another `animation_frame` call, the block is run in the
+      # following iteration of the event loop.
       def animation_frame &block
         `requestAnimationFrame(function() { #{block.call} })`
         self
@@ -22,60 +25,84 @@ module Bowser
       end
     end
 
+    # Run the given block after the specified number of seconds has passed.
+    #
+    # @param duration [Numeric] the number of seconds to wait
     def delay duration, &block
       `setTimeout(function() { #{block.call} }, duration * 1000)`
       self
     end
 
+    # Run the given block every `duration` seconds
+    #
+    # @param duration [Numeric] the number of seconds between runs
     def interval duration, &block
       `setInterval(function() { #{block.call} }, duration * 1000)`
       self
     end
 
+    # @return [Location] the browser's Location object
     def location
       Location
     end
 
+    # Scroll to the specified (x,y) coordinates
     def scroll x, y
       `window.scrollTo(x, y)`
     end
 
+    # Wrapper for the browser's Location object
     module Location
       module_function
 
+      # The "hash" of the current URL
       def hash
         `window.location.hash`
       end
 
+      # Set the hash of the URL
+      #
+      # @param hash [String] the new value of the URL hash
       def hash= hash
         `window.location.hash = hash`
       end
 
+      # The path of the current URL
       def path
         `window.location.pathname`
       end
 
+      # The full current URL
       def href
         `window.location.href`
       end
 
+      # Set the current URL
+      #
+      # @param href [String] the URL to navigate to
       def href= href
         `window.location.href = href`
       end
     end
 
+    # The browser's history object
     module History
       module_function
 
+      # @return [Boolean] true if the browser supports pushState, false otherwise
       def has_push_state?
         `!!window.history.pushState`
       end
 
+      # Navigate to the specified path without triggering a full page reload
+      #
+      # @param path [String] the path to navigate to
       def push path
         `window.history.pushState({}, '', path)`
       end
     end
 
+    # return [History] the browser's History object
     def history
       History
     end
@@ -83,6 +110,7 @@ module Bowser
 
   module_function
 
+  # return [Window] the browser's Window object
   def window
     Window
   end