bowser 0.4.3 → 0.5.0

data/opal/bowser/http.rb

@@ -8,6 +8,13 @@ module Bowser
   module HTTP
     module_function
 
+    # Send a request to the given URL
+    #
+    # @param url [String] the URL to send the request to
+    # @keywordparam method [String] the HTTP method, defaults to GET
+    # @keywordparam headers [Hash] the HTTP headers to send with the request
+    # @keywordparam data [Hash, String, nil] the data to send with the request,
+    #   only useful for POST, PATCH, or PUT requests
     def fetch(url, method: :get, headers: {}, data: nil, &block)
       promise = Promise.new
       request = Request.new(method, url)
@@ -20,6 +27,13 @@ module Bowser
       promise
     end
 
+    # Shorthand method for sending a request with JSON data
+    #
+    # @param url [String] the URL to send the request to
+    # @param data [Hash, String, nil] the data to send with the request,
+    #   only useful for POST, PATCH, or PUT requests. Otherwise, use `fetch`.
+    # @keywordparam method [String] the HTTP method, defaults to GET
+    # @keywordparam content_type [String] the MIME type of the request
     def upload(url, data, content_type: 'application/json', method: :post, &block)
       promise = Promise.new
       request = Request.new(method, url)
@@ -32,6 +46,15 @@ module Bowser
       promise
     end
 
+    # Upload files from a file input field
+    #
+    # @param url [String] the URL to send the request to
+    # @param files [Bowser::FileList] the files to attach
+    # @keywordparam key [String] the name to use for the POST param, defaults to `"files"`
+    # @keywordparam key_suffix [String] the suffix for the key, defaults to
+    #   `"[]"`. This is how several web frameworks determine that the key should
+    #   be treated as an array.
+    # @keywordparam method [String] the HTTP method to use, defaults to `"POST"`
     def upload_files(url, files, key: 'files', key_suffix: '[]', method: :post, &block)
       promise = Promise.new
       request = Request.new(method, url)
@@ -49,10 +72,17 @@ module Bowser
       promise
     end
 
+    # Upload a single file from a file input field
+    #
+    # @param url [String] the URL to send the request to
+    # @param file [Bowser::File] the file to attach
+    # @keywordparam key [String] the name to use for the POST param, defaults to `"files"`
+    # @keywordparam method [String] the HTTP method to use, defaults to `"POST"`
     def upload_file(url, file, key: 'file', method: :post, &block)
       upload_files(url, [file], key: key, key_suffix: nil, method: method, &block)
     end
 
+    # @api private
     def connect_events_to_promise(request, promise)
       request.on :load do
         promise.resolve request.response

data/opal/bowser/http/form_data.rb

@@ -1,6 +1,8 @@
 module Bowser
   module HTTP
+    # Data to be attached to a form or sent in with a Bowser::HTTP::Request
     class FormData
+      # @param attributes [Hash, nil] the attributes to attach
       def initialize attributes={}
         @native = `new FormData()`
         attributes.each do |key, value|
@@ -14,6 +16,8 @@ module Bowser
         end
       end
 
+      # @param key [String] the name of the attribute
+      # @param value [String] the value of the attribute
       def append key, value
         data = if `!!value['native']`
                  `value['native']`

data/opal/bowser/http/request.rb

@@ -3,6 +3,7 @@ require 'bowser/event_target'
 
 module Bowser
   module HTTP
+    # A Ruby object representing an HTTP request to a remote server.
     class Request
       include EventTarget
 
@@ -15,6 +16,8 @@ module Bowser
       LOADING          = 3
       DONE             = 4
 
+      # @param method [String] the HTTP method to use
+      # @param url [String] the URL to send the request to
       def initialize(method, url, native: `new XMLHttpRequest()`)
         @native = native
         @method = method
@@ -22,6 +25,11 @@ module Bowser
         @response = Response.new(@native)
       end
 
+      # Send the HTTP request
+      #
+      # @keywordparam data [Hash, Bowser::HTTP::FormData, nil] the data to send
+      #   with the request.
+      # @keywordparam headers [Hash] the HTTP headers to attach to the request
       def send(data: {}, headers: {})
         `#@native.open(#{method}, #{url})`
         @data = data
@@ -40,6 +48,10 @@ module Bowser
         self
       end
 
+      # Set the headers to the keys and values of the specified hash
+      #
+      # @param headers [Hash] the hash whose keys and values should be added as
+      #   request headers
       def headers= headers
         @headers = headers
         headers.each do |attr, value|
@@ -47,30 +59,37 @@ module Bowser
         end
       end
 
+      # @return [Boolean] true if this request is a POST request, false otherwise
       def post?
         method == :post
       end
 
+      # @return [Boolean] true if this request is a GET request, false otherwise
       def get?
         method == :get
       end
 
+      # @return [Numeric] the numeric readyState of the underlying XMLHttpRequest
       def ready_state
         `#@native.readyState`
       end
 
+      # @return [Boolean] true if this request has been sent, false otherwise
       def sent?
         ready_state >= OPENED
       end
 
+      # @return [Boolean] true if we have received response headers, false otherwise
       def headers_received?
         ready_state >= HEADERS_RECEIVED
       end
 
+      # @return [Boolean] true if we are currently downloading the response body, false otherwise
       def loading?
         ready_state == LOADING
       end
 
+      # @return [Boolean] true if the response has been completed, false otherwise
       def done?
         ready_state >= DONE
       end

data/opal/bowser/http/response.rb

@@ -2,27 +2,35 @@ require 'json'
 
 module Bowser
   module HTTP
+    # Ruby class representing an HTTP response from a remote server
     class Response
+      # @param xhr [JS] a native XMLHttpRequest object
       def initialize xhr
         @xhr = xhr
       end
 
+      # @return [Numeric] the HTTP status code of the response
       def code
         `#@xhr.status`
       end
 
+      # @return [String] the body of the response as a string
       def body
         `#@xhr.response`
       end
 
+      # @return [Hash, Array, String] the response body deserialized from JSON
       def json
         @json ||= JSON.parse(body) if `#{body} !== undefined`
       end
 
+      # @return [Boolean] true if this was a successful response (2xx-3xx), false otherwise
       def success?
         (200...400).cover? code
       end
+      alias ok? success?
 
+      # @return [Boolean] true if this represents a failed response (4xx-5xx)
       def fail?
         !success?
       end

data/opal/bowser/indexed_db.rb

@@ -0,0 +1,244 @@
+require 'bowser/event_target'
+require 'promise'
+
+module Bowser
+  class IndexedDB
+    name = %w(
+      indexedDB
+      mozIndexedDB
+      webkitIndexedDB
+      msIndexedDB
+    ).find { |name| `!!window[#{name}]` }
+    NATIVE = `window[#{name}]`
+
+    def initialize name, version: 1
+      @thens = []
+
+      request = Request.new(`#{NATIVE}.open(#{name}, #{version})`)
+      request.on :error do |event|
+        `console.error(event)`
+      end
+      request.on :success do |event|
+        @native = event.target.result
+
+        @thens.each(&:call)
+        @thens.clear
+      end
+
+      request.on :upgradeneeded do |event|
+        puts 'upgradeneeded'
+        @native = event.target.result
+
+        if block_given?
+          yield self
+          puts 'upgraded'
+        else
+          raise ArgumentError, "You must provide a block to `#{self.class}.new` in order to set up the database if the user's browser does not have it."
+        end
+      end
+    end
+
+    def create_object_store name, key_path: `undefined`, unique: false
+      ObjectStore.new(`#@native.createObjectStore(#{name}, { keyPath: #{key_path} })`)
+    end
+
+    def delete_object_store name
+      `#@native.deleteObjectStore(#{name})`
+    rescue `TypeError` => e
+      # If the object store doesn't exist, we do nothing. The store not existing
+      # is the end state we want after this method call anyway.
+    end
+
+    def transaction name, mode=:readonly
+      Transaction.new(`#@native.transaction(#{name}, #{mode})`)
+    end
+
+    def then &block
+      if @native
+        block.call
+      else
+        @thens << block
+      end
+    end
+
+    def deserialize klass, native
+      `Object.assign(#{klass.allocate}, #{native})`
+    end
+
+    class ObjectStore
+      def initialize native
+        @native = native
+      end
+
+      def create_index name, key_path=name, unique: false
+        `#@native.createIndex(#{name}, #{key_path}, { unique: #{unique} })`
+      end
+
+      def add object
+        `#@native.add(#{object})`
+      end
+
+      def put object
+        `#@native.put(#{object})`
+      end
+
+      def delete key
+        p = Promise.new
+        key = yield Query.new if block_given?
+
+        request = Request.new(`#@native.delete(#{key})`)
+        request.on(:success) { p.resolve }
+        request.on(:error) { |error| p.reject error }
+
+        p
+      end
+
+      def get key
+        p = Promise.new
+        key = yield Query.new if block_given?
+
+        request = Request.new(`#@native.get(#{key})`)
+        request.on :success do |event|
+          js_obj = `#{event.target}.result`
+          if `!!#{js_obj}`
+            p.resolve `Object.assign(#{klass.allocate}, #{js_obj})`
+          else
+            p.resolve nil
+          end
+        end
+        request.on(:error) { |event| p.reject event.target.result }
+
+        p
+      end
+
+      def get_all klass, count: `undefined`
+        p = Promise.new
+        query = block_given? ? yield(Query.new) : `undefined`
+
+        request = Request.new(`#@native.getAll(#{query}, #{count})`)
+        request.on :success do |event|
+          p.resolve event.target.result.map { |js_obj|
+            `delete #{js_obj}.$$id` # Remove old Ruby runtime metadata
+            `Object.assign(#{klass.allocate}, #{js_obj})`
+          }
+        end
+        request.on :error do |event|
+          p.reject event.target.result
+        end
+
+        p
+      end
+
+      def index name
+        Index.new(`#@native.index(#{name})`)
+      end
+    end
+
+    class Index
+      def initialize native
+        @native = native
+      end
+
+      def get klass, key
+        p = Promise.new
+        key = yield Query.new if block_given?
+
+        request = Request.new(`#@native.get(#{key})`)
+        request.on :success do |event|
+          begin
+            p.resolve `Object.assign(#{klass.allocate}, #{event.target.result})`
+          rescue NoMethodError # Happens when there is no result above :-\
+            p.resolve nil
+          end
+        end
+
+        request.on :error do |event|
+          p.reject event.target.result
+        end
+
+        p
+      end
+
+      def get_all klass, count: `undefined`
+        p = Promise.new
+
+        query = if block_given?
+                  yield Query.new
+                else
+                  `undefined`
+                end
+
+        request = Request.new(`#@native.getAll(#{query}, #{count})`)
+        request.on :success do |event|
+          p.resolve event.target.result.map { |js_obj|
+            `delete #{js_obj}.$$id` # Remove old Ruby runtime metadata
+            `Object.assign(#{klass.allocate}, #{js_obj})`
+          }
+        end
+        request.on :error do |event|
+          p.reject event.target.result
+        end
+
+        p
+      end
+    end
+
+    class Query
+      name = %w(
+        IDBKeyRange
+        msIDBKeyRange
+        mozIDBKeyRange
+        webkitIDBKeyRange
+      ).find { |name| `!!window[#{name}]` }
+      NATIVE = `window[#{name}]`
+
+      def > value
+        lower_bound value, true
+      end
+
+      def >= value
+        lower_bound value
+      end
+
+      def < value
+        upper_bound value, true
+      end
+
+      def <= value
+        upper_bound value
+      end
+
+      def == value
+        `#{NATIVE}.only(#{value})`
+      end
+
+      def lower_bound value, exclusive=false
+        `#{NATIVE}.lowerBound(value, exclusive)`
+      end
+
+      def upper_bound value, exclusive=false
+        `#{NATIVE}.upperBound(value, exclusive)`
+      end
+    end
+
+    class Transaction
+      include Bowser::EventTarget
+
+      def initialize native
+        @native = native
+      end
+
+      def object_store name=`#@native.objectStoreNames[0]`
+        ObjectStore.new(`#@native.objectStore(#{name})`)
+      end
+    end
+
+    class Request
+      include Bowser::EventTarget
+
+      def initialize native
+        @native = native
+      end
+    end
+  end
+end

data/opal/bowser/service_worker.rb

@@ -0,0 +1,43 @@
+require 'promise'
+
+module Bowser
+  class ServiceWorker
+    NotSupported = Class.new(StandardError)
+
+    def self.register path, options={}
+      p = Promise.new
+
+      if supported?
+        %x{
+          navigator.serviceWorker.register(#{path}, #{options.to_n})
+            .then(#{proc { |reg| p.resolve new(reg) }})
+            .catch(#{proc { |error| p.fail error}});
+        }
+      else
+        p.reject NotSupported.new('Service worker is not supported in this browser')
+      end
+
+      p
+    end
+
+    def self.ready &block
+      `navigator.serviceWorker.ready.then(#{proc { |sw| block.call new(sw) }})`
+    end
+
+    def self.supported?
+      `'serviceWorker' in navigator`
+    end
+
+    def initialize native
+      @native = native
+    end
+
+    def scope
+      `#@native.scope`
+    end
+
+    def to_n
+      @native
+    end
+  end
+end