opal-browser 0.1.0.beta1 → 0.3.1

data/opal/browser/form_data.rb

@@ -0,0 +1,225 @@
+module Browser
+
+class FormData
+  include NativeCachedWrapper
+
+  module Converter
+    # Encode as URI component.
+    #
+    # @return [String] the string encoded for usage as URI component
+    def encode(string)
+      `encodeURIComponent(#{string})`
+    end
+
+    # Decode as URI component.
+    #
+    # @return [String] the string decoded as URI component
+    def decode(string)
+      `decodeURIComponent(#{string})`
+    end
+
+    # Encode as URI.
+    #
+    # @return [String] the string encoded as URI
+    def encode_uri(string)
+      `encodeURI(#{string})`
+    end
+
+    # Decode as URI.
+    #
+    # @return [String] the string decoded as URI
+    def decode_uri(string)
+      `decodeURI(#{string})`
+    end
+
+    # Flattens a hash to build a flat array, later to be formatted to
+    # produce a nested query.
+    #
+    # This code should be compatible with what Rack::Utils#build_nested_query [1]
+    # does.
+    #
+    # [1] https://github.com/rack/rack/blob/master/lib/rack/utils.rb
+    def flatten(value, key="")
+      case value
+      when Hash
+        out = []
+        value.each do |k,v|
+          k = "#{key}[#{k}]" if key != ''
+          out += flatten(v,k)
+        end
+        out
+      when Array
+        out = []
+        value.each do |v|
+          k = "#{key}[]"
+          out += flatten(v,k)
+        end
+        out
+      else
+        [[key,value]]
+      end
+    end
+
+    # Converts a flat array to a Hash.
+    #
+    # This code should be compatible with what Rack::Utils#parse_nested_query [1]
+    # does.
+    #
+    # [1] https://github.com/rack/rack/blob/master/lib/rack/utils.rb
+    def unflatten(array)
+      out = {}
+      array.each do |k,v|
+        path = [k.split("[").first] + k.scan(/\[(.*?)\]/).flatten
+        c = out
+
+        set = proc { |v,weak| } # Do nothing for the first level
+
+        path.each do |i|
+          case i
+          when "" # Array
+            set.([], true)
+            set = proc do |v,weak|
+              c << v
+              c = c.last
+            end
+          else # Hash
+            set.({}, true)
+            set = proc do |v,weak|
+              c[i] ||= v
+              c[i] = v if !weak
+              c = c[i]
+            end
+          end
+        end
+        set.(v, false)
+
+      end
+      out
+    end
+
+    # Checks if a query Hash contains any files.
+    def contain_files?(hash)
+      flatten(hash).any? { |k,v| [File, Blob].include?(v.class) }
+    end
+
+    # Convert a query Hash to a query string
+    #
+    # @return [String] the string encoded as URI
+    def build_query(hash, sep=?&)
+      flatten(hash).map { |k,v| encode(k) + ?= + encode(v.to_s) }.join(sep)
+    end
+
+    # Convert a query Hash to a FormData instance
+    #
+    # @return [FormData] the instance of FormData
+    def build_form_data(hash)
+      fd = FormData.create
+      flatten(hash).each { |k,v| fd << [k,v] }
+      fd
+    end
+
+    # Convert a query string to a query Hash
+    #
+    # @return [Hash] the query hash
+    def parse_query(string, sep=?&)
+      unflatten(string.split(sep).map { |s| s.split(?=).map(&method(:decode)) })
+    end
+
+    # Converts a JS native value to a wrapped one if possible.
+    #
+    # @return [String, File, Blob]
+    def from_native(n)
+      %x{
+        var c = #{n}.constructor;
+        if (c === File) {
+          #{n = File.new(n)}
+        }
+        else if (c === Blob) {
+          #{n = Blob.new(n)}
+        }
+      }
+      n
+    end
+  end
+
+  extend Converter
+  include Enumerable
+
+  # Create a new FormData instance
+  def self.create(hash=nil)
+    if Hash === hash
+      FormData.build_form_data(hash)
+    elsif DOM::Element::Form === hash
+      new(`new FormData(#{hash.to_n})`)
+    else
+      new(`new FormData()`)
+    end
+  end
+
+  # Append a tuple to this FormData instance
+  #
+  # @param tuple [Array(String, String), Array(String, Blob), Array(String, File),
+  #               Array(String, Blob, String), Array(String, File, String)]
+  #        a tuple of a key, value and possibly a filename
+  def <<(tuple)
+    key, value, filename = tuple
+
+    unless filename
+      `#@native.append(#{key}, #{Native.convert(value)})`
+    else
+      `#@native.append(#{key}, #{Native.convert(value)}, #{filename})`
+    end
+  end
+
+  # Get a field from this FormData instance with a given name
+  def [](key)
+    FormData.from_native(`#@native.get(#{key})`)
+  end
+
+  # Set a field in this FormData instance with a given name
+  def set(key, value, filename = nil)
+    unless filename
+      `#@native.set(#{key}, #{Native.convert(value)})`
+    else
+      `#@native.set(#{key}, #{Native.convert(value)}, #{filename})`
+    end
+  end
+  alias []= set
+
+  # Convert to hash
+  def to_h
+    hash = {}
+    %x{
+      var pair, v, e = #@native.entries();
+      while (true) {
+        v = e.next();
+        if (v.done) break;
+        pair = v.value;
+        #{hash[`pair[0]`] = FormData.from_native(`pair[1]`)}
+      }
+    }
+    hash
+  end
+
+  # Convert to array
+  def to_a
+    to_h.to_a
+  end
+
+  # Iterate over all elements of this FormData
+  def each(&block)
+    to_h.each(&block)
+  end
+
+  # Checks if a field of this name exists in this FormData instance
+  def include?(key)
+    `#@native.has(#{key})`
+  end
+
+  # Delete a field from this FormData instance
+  def delete(key)
+    `#@native.delete(#{key})`
+  end
+end
+
+end

data/opal/browser/history.rb

@@ -2,50 +2,82 @@ require 'browser/location'
 
 module Browser
 
+# {History} allows manipulation of the session history.
+#
+# @see https://developer.mozilla.org/en-US/docs/Web/API/History
 class History
-  include Native
+  # Check if HTML5 history is supported.
+  def self.supported?
+    Browser.supports? 'History'
+  end
+
+  include Browser::NativeCachedWrapper
 
+  # @!attribute [r] length
+  # @return [Integer] how many items are in the history
   alias_native :length
 
+  # Go back in the history.
+  #
+  # @param number [Integer] how many items to go back
   def back(number = 1)
     `#@native.go(-number)`
-
-    self
   end
 
+  # Go forward in the history.
+  #
+  # @param number [Integer] how many items to go forward
   def forward(number = 1)
     `#@native.go(number)`
-
-    self
   end
 
-  def push(url, data = nil)
-    data = `null` if data.nil?
-
-    `#@native.pushState(data, null, url)`
-
-    self
+  # Push an item in the history.
+  #
+  # @param item [String] the item to push in the history
+  # @param data [Object] additional state to push
+  def push(item, data = nil)
+    `#@native.pushState(#{data.to_n}, null, item)`
   end
 
-  def replace(url, data = nil)
-    data = `null` if data.nil?
-
-    `#@native.replaceState(data, null, url)`
+  # Replace the current history item with another.
+  #
+  # @param item [String] the item to replace with
+  # @param data [Object] additional state to replace
+  def replace(item, data = nil)
+    `#@native.replaceState(#{data.to_n}, null, item)`
   end
 
+  # @!attribute [r] current
+  # @return [String] the current item
   def current
-    $window.location.path
+    $window.location.full_path
   end
 
-  def state
-    `#@native.state`
+  # @!attribute [r] state
+  # @return [Object] the current state
+  if Browser.supports? 'History.state'
+    def state
+      %x{
+        var state = #@native.state;
+
+        if (state == null) {
+          return nil;
+        }
+        else {
+          return state;
+        }
+      }
+    end
+  else
+    def state
+      raise NotImplementedError, 'history state unsupported'
+    end
   end
 end
 
 class Window
-  # Get the {History} object for this window.
-  #
-  # @return [History]
+  # @!attribute [r] history
+  # @return [History] the history for this window
   def history
     History.new(`#@native.history`) if `#@native.history`
   end

data/opal/browser/http/binary.rb

@@ -24,6 +24,7 @@ class Binary
   # Iterate over each byte in the binary.
   #
   # @yield [byte] the byte
+  #
   # @return [self]
   def each(&block)
     return enum_for :each unless block

data/opal/browser/http/headers.rb

@@ -14,6 +14,8 @@ class Headers
   end
 
   # Create {Headers} from a hash.
+  #
+  # @param hash [Hash]
   def self.[](hash)
     result = new
 
@@ -31,9 +33,16 @@ class Headers
     @hash = Hash.new
   end
 
-  # Iterate over the headers.
+  # Clear the {Headers}.
+  def clear
+    @hash.clear
+  end
+
+  # Enumerate over the headers.
+  #
+  # @yieldparam name [String] the name of the header
+  # @yieldparam value [String] the value of the header
   #
-  # @yield [name, value] the header name and value
   # @return [self]
   def each(&block)
     return enum_for :each unless block
@@ -46,10 +55,18 @@ class Headers
   end
 
   # Get the value of a header.
+  #
+  # @param name [String] the name of the header
+  #
+  # @return [String] the value of the header
   def [](name)
     @hash[name.downcase]
   end
 
+  # Set a value for the header.
+  #
+  # @param name [String] the name of the header
+  # @param value [String] the value of the header
   def []=(name, value)
     header = Header.new(name, value)
 
@@ -59,6 +76,7 @@ class Headers
   # Push a header.
   #
   # @param header [Header] the header to push
+  #
   # @return [self]
   def <<(header)
     @hash[header.name.downcase] = header
@@ -71,6 +89,7 @@ class Headers
   # Merge in place other headers.
   #
   # @param other [Headers, Hash, #each] the headers to merge
+  #
   # @return [self]
   def merge!(other)
     other.each {|name, value|

data/opal/browser/http/request.rb

@@ -1,26 +1,18 @@
 module Browser; module HTTP
 
 class Request
-  include Native
+  include Native::Wrapper
+  include Event::Target
 
-  # Open and send a request.
-  #
-  # @param method [Symbol] the HTTP method to use
-  # @param url [String, #to_s] the URL to request
-  # @param parameters [String, Hash] the parameters to send
-  #
-  def self.open(method, url, parameters = nil, &block)
-    request = new(&block)
-    request.open(method, url)
-    request.send(*parameters)
-  end
-
-  DEFAULT_HEADERS = {
+  # Default headers.
+  HEADERS = {
     'X-Requested-With' => 'XMLHttpRequest',
     'X-Opal-Version'   => RUBY_ENGINE_VERSION,
     'Accept'           => 'text/javascript, text/html, application/xml, text/xml, */*'
   }
 
+  STATES = %w[uninitialized loading loaded interactive complete]
+
   # @!attribute [r] headers
   # @return [Headers] the request headers
   attr_reader :headers
@@ -44,11 +36,13 @@ class Request
   def initialize(&block)
     super(transport)
 
-    @headers      = Headers[DEFAULT_HEADERS]
+    @parameters   = {}
+    @query        = {}
+    @headers      = Headers[HEADERS]
     @method       = :get
     @asynchronous = true
     @binary       = false
-    @cacheable     = true
+    @cacheable    = true
     @opened       = false
     @sent         = false
     @completed    = false
@@ -61,8 +55,20 @@ class Request
     end if block
   end
 
-  def transport
-    `new XMLHttpRequest()`
+  # @!method transport
+  #   @private
+  if Browser.supports? :XHR
+    def transport
+      `new XMLHttpRequest()`
+    end
+  elsif Browser.supports? :ActiveX
+    def transport
+      `new ActiveXObject("MSXML2.XMLHTTP.3.0")`
+    end
+  else
+    def transport
+      raise NotImplementedError
+    end
   end
 
   # Check if the request has been opened.
@@ -91,21 +97,13 @@ class Request
   end
 
   # Make the request asynchronous.
-  #
-  # @return [self]
   def asynchronous!
     @asynchronous = true
-
-    self
   end
 
   # Make the request synchronous.
-  #
-  # @return [self]
   def synchronous!
     @asynchronous = false
-
-    self
   end
 
   # Check the request is binary.
@@ -116,8 +114,6 @@ class Request
   # Make the request binary.
   def binary!
     @binary = true
-
-    self
   end
 
   # Check if the request is cacheable.
@@ -126,12 +122,8 @@ class Request
   end
 
   # Disable caching for this request.
-  #
-  # @return [self]
   def no_cache!
     @cacheable = false
-
-    self
   end
 
   # Get or set the user used for authentication.
@@ -183,23 +175,31 @@ class Request
   #
   # @param hash [Hash] the parameters
   #
-  # @return [self]
-  def parameters(hash)
-    @parameters = hash
+  # @return [Hash]
+  def parameters(hash = nil)
+    hash ? @parameters = hash : @parameters
+  end
 
-    self
+  # Set the URI query.
+  #
+  # @param hash [Hash] the query
+  #
+  # @return [Hash]
+  def query(hash = nil)
+    hash ? @query = hash : @query
   end
 
   # Register an event on the request.
   #
   # @param what [Symbol, String] the event name
-  # @yield [response] yields the {Response}
   #
-  # @return [self]
-  def on(what, &block)
-    @callbacks[what] << block
-
-    self
+  # @yieldparam response [Response] the response for the event
+  def on(what, *, &block)
+    if STATES.include?(what) || %w[success failure].include?(what) || Integer === what
+      @callbacks[what] << block
+    else
+      super
+    end
   end
 
   # Open the request.
@@ -222,12 +222,27 @@ class Request
 
     url = @url
 
+    # add a dummy random parameter to the query to try circumvent caching
     unless cacheable?
-      url += (url.include?(??) ? ?& : ??) + "_=#{rand}"
+      @query[:_] = rand
+    end
+
+    # add the encoded query to the @url, prepending the right character if
+    # there was already a query in the defined @url or not
+    unless @query.empty?
+      if url.include? ??
+        url += ?&
+      else
+        url += ??
+      end
+
+      url += FormData.build_query(@query)
     end
 
     `#@native.open(#{@method.to_s.upcase}, #{url.to_s}, #{@asynchronous}, #{@user.to_n}, #{@password.to_n})`
 
+    # if there are no registered callbacks no point in setting the event
+    # handler
     unless @callbacks.empty?
       `#@native.onreadystatechange = #{callback}`
     end
@@ -247,6 +262,8 @@ class Request
 
     raise 'the request has already been sent' if sent?
 
+    # try to circumvent caching setting an If-Modified-Since header with a very
+    # old date
     unless cacheable?
       `#@native.setRequestHeader("If-Modified-Since", "Tue, 11 Sep 2001 12:46:00 GMT")`
     end
@@ -279,14 +296,29 @@ class Request
 
     if String === parameters
       data = parameters
-    elsif Hash === parameters
-      data = parameters.map {|vals|
-        vals.map(&:encode_uri_component).join(?=)
-      }.join(?&)
+    elsif (Hash === parameters && !parameters.empty?) || FormData === parameters
+      data = if Hash === parameters
+        if FormData.contain_files?(parameters)
+          FormData.build_form_data(parameters)
+        else
+          FormData.build_query(parameters)
+        end
+      else #if FormData === parameters
+        parameters
+      end
 
       unless @content_type
-        `#@native.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded')`
+        if FormData === data
+          # I thought it's done this way, but it isn't. It actually is
+          # "multipart/form-data; boundary=-----------.......". Let's miss it
+          # purposefully, because it's filled in automatically in this example.
+          # `#@native.setRequestHeader('Content-Type', 'multipart/form-data')`
+        else
+          `#@native.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded')`
+        end
       end
+
+      data = data.to_n
     else
       data = `null`
     end
@@ -297,18 +329,14 @@ class Request
   end
 
   # Abort the request.
-  #
-  # @return [self]
   def abort
     `#@native.abort()`
-
-    self
   end
 
 private
   def callback
-    proc {|event|
-      state = %w[uninitialized loading loaded interactive complete][`#@native.readyState`]
+    -> event {
+      state = STATES[`#@native.readyState`]
       res   = response
 
       @callbacks[state].each { |b| b.(res) }
@@ -324,7 +352,7 @@ private
           @callbacks[:failure].each { |b| b.(res) }
         end
       end
-    }.to_n
+    }
   end
 end
 

data/opal/browser/http/response.rb

@@ -4,7 +4,7 @@ module Browser; module HTTP
 
 # Represents an HTTP response.
 class Response
-  include Native
+  include Native::Wrapper
 
   Status = Struct.new(:code, :text)
 
@@ -47,6 +47,10 @@ class Response
     !success?
   end
 
+  # @!attribute [r] url
+  # @return [String] the response URL (after redirects)
+  alias_native :url, :responseURL
+
   # @!attribute [r] text
   # @return [String] the response body as text
   def text