diamonds 0.1.5

data/lib/diamonds/opal/browser/http.rb

@@ -0,0 +1,169 @@
+require 'promise'
+
+require 'browser/http/binary'
+require 'browser/http/headers'
+require 'browser/http/request'
+require 'browser/http/response'
+
+module Browser
+
+module HTTP
+  # Check if HTTP requests are supported.
+  def self.supported?
+    Browser.supports?('XHR') || Browser.supports?('ActiveXObject')
+  end
+
+  # Send an asynchronous request.
+  #
+  # @param method [Symbol] the HTTP method to use
+  # @param url [String] the URL to request
+  # @param data [String, Hash] the data to send
+  #
+  # @yieldparam request [Request] the request to configure
+  #
+  # @return [Promise] a promise that will be resolved with the response
+  def self.send(method, url, data = nil, &block)
+    Promise.new.tap {|promise|
+      Request.new(&block).tap {|req|
+        req.on :success do |res|
+          promise.resolve(res)
+        end
+
+        req.on :failure do |res|
+          promise.reject(res)
+        end
+      }.open(method, url).send(data)
+    }
+  end
+
+  # Send an asynchronous GET request.
+  #
+  # @param url [String] the URL to request
+  #
+  # @yieldparam request [Request] the request to configure
+  #
+  # @return [Promise] a promise that will be resolved with the response
+  def self.get(url, &block)
+    send(:get, url, &block)
+  end
+
+  # Send an asynchronous HEAD request.
+  #
+  # @param url [String] the URL to request
+  #
+  # @yieldparam request [Request] the request to configure
+  #
+  # @return [Promise] a promise that will be resolved with the response
+  def self.head(url, &block)
+    send(:head, url, &block)
+  end
+
+  # Send an asynchrnous POST request.
+  #
+  # @param url [String] the URL to request
+  # @param data [String, Hash] the data to send
+  #
+  # @yieldparam request [Request] the request to configure
+  #
+  # @return [Promise] a promise that will be resolved with the response
+  def self.post(url, data = nil, &block)
+    send(:post, url, data, &block)
+  end
+
+  # Send an asynchronous PUT request.
+  #
+  # @param url [String] the URL to request
+  # @param data [String, Hash] the data to send
+  #
+  # @yieldparam request [Request] the request to configure
+  #
+  # @return [Promise] a promise that will be resolved with the response
+  def self.put(url, data = nil, &block)
+    send(:put, url, data, &block)
+  end
+
+  # Send an asynchronous DELETE request.
+  #
+  # @param url [String] the URL to request
+  # @param data [String, Hash] the data to send
+  #
+  # @yieldparam request [Request] the request to configure
+  #
+  # @return [Promise] a promise that will be resolved with the response
+  def self.delete(url, data = nil, &block)
+    send(:delete, url, data, &block)
+  end
+
+  # Send a synchronous request.
+  #
+  # @param method [Symbol] the HTTP method to use
+  # @param url [String] the URL to request
+  # @param data [String, Hash] the data to send
+  #
+  # @yieldparam request [Request] the request to configure
+  #
+  # @return [Response] the response
+  def self.send!(method, url, data = nil, &block)
+    Request.new(&block).open(method, url, false).send(data)
+  end
+
+  # Send a synchronous GET request.
+  #
+  # @param url [String] the URL to request
+  #
+  # @yieldparam request [Request] the request to configure
+  #
+  # @return [Response] the response
+  def self.get!(url, &block)
+    send!(:get, url, &block)
+  end
+
+  # Send a synchronous HEAD request.
+  #
+  # @param url [String] the URL to request
+  #
+  # @yieldparam request [Request] the request to configure
+  #
+  # @return [Response] the response
+  def self.head!(url, &block)
+    send!(:head, url, &block)
+  end
+
+  # Send a synchronous POST request.
+  #
+  # @param url [String] the URL to request
+  # @param data [String, Hash] the data to send
+  #
+  # @yieldparam request [Request] the request to configure
+  #
+  # @return [Response] the response
+  def self.post!(url, data = nil, &block)
+    send!(:post, url, data, &block)
+  end
+
+  # Send a synchronous PUT request.
+  #
+  # @param url [String] the URL to request
+  # @param data [String, Hash] the data to send
+  #
+  # @yieldparam request [Request] the request to configure
+  #
+  # @return [Response] the response
+  def self.put!(url, data = nil, &block)
+    send!(:put, url, data, &block)
+  end
+
+  # Send a synchronous DELETE request.
+  #
+  # @param url [String] the URL to request
+  # @param data [String, Hash] the data to send
+  #
+  # @yieldparam request [Request] the request to configure
+  #
+  # @return [Response] the response
+  def self.delete!(url, data = nil, &block)
+    send!(:delete, url, data, &block)
+  end
+end
+
+end

data/lib/diamonds/opal/browser/http/binary.rb

@@ -0,0 +1,58 @@
+module Browser; module HTTP
+
+# Represents a binary result from a HTTP response.
+class Binary
+  # @!attribute [r] type
+  # @return [:string, :buffer] the type of binary
+  attr_reader :type
+
+  # Create a binary from a value.
+  #
+  # @param value [String, Buffer] the binary
+  def initialize(value)
+    if String === value
+      @type = :string
+      @data = value
+    else
+      @type = :buffer
+      @data = value.to_a
+    end
+  end
+
+  include Enumerable
+
+  # Iterate over each byte in the binary.
+  #
+  # @yield [byte] the byte
+  #
+  # @return [self]
+  def each(&block)
+    return enum_for :each unless block
+
+    index  = 0
+    length = self.length
+
+    while index < length
+      block.call(self[index])
+
+      index += 1
+    end
+
+    self
+  end
+
+  # Access a byte from the binary.
+  #
+  # @return [Integer] a byte
+  def [](index)
+    @type == :string ? `#@data.charCodeAt(index) & 0xff` : @data[index]
+  end
+
+  # @!attribute [r] length
+  # @return [Integer] the length of the binary
+  def length
+    @data.length
+  end
+end
+
+end; end

data/lib/diamonds/opal/browser/http/headers.rb

@@ -0,0 +1,109 @@
+module Browser; module HTTP
+
+# Represents a single HTTP header.
+Header = Struct.new(:name, :value)
+
+# Represents HTTP headers.
+class Headers
+  # Parse HTTP headers from a string.
+  #
+  # @param string [String] the whole HTTP headers response
+  # @return [Headers] the parsed headers
+  def self.parse(string)
+    self[string.lines.map { |l| l.chomp.split(/\s*:\s*/) }]
+  end
+
+  # Create {Headers} from a hash.
+  #
+  # @param hash [Hash]
+  def self.[](hash)
+    result = new
+
+    hash.each {|name, value|
+      result[name] = value
+    }
+
+    result
+  end
+
+  include Enumerable
+
+  # Create an empty {Headers}.
+  def initialize
+    @hash = Hash.new
+  end
+
+  # 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
+  #
+  # @return [self]
+  def each(&block)
+    return enum_for :each unless block
+
+    @hash.each {|_, header|
+      block.call [header.name, header.value]
+    }
+
+    self
+  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)
+
+    @hash[name.downcase] = header
+  end
+
+  # Push a header.
+  #
+  # @param header [Header] the header to push
+  #
+  # @return [self]
+  def <<(header)
+    @hash[header.name.downcase] = header
+
+    self
+  end
+
+  alias push <<
+
+  # Merge in place other headers.
+  #
+  # @param other [Headers, Hash, #each] the headers to merge
+  #
+  # @return [self]
+  def merge!(other)
+    other.each {|name, value|
+      self[name] = value
+    }
+
+    self
+  end
+
+  # @!attribute [r] length
+  # @return [Integer] the number of headers
+  def length
+    @hash.length
+  end
+end
+
+end; end

data/lib/diamonds/opal/browser/http/request.rb

@@ -0,0 +1,344 @@
+module Browser; module HTTP
+
+class Request
+  include Native
+  include Event::Target
+
+  # 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
+
+  # @!attribute [r] response
+  # @return [Response] the response associated with this request
+  attr_reader :response
+
+  # @!attribute [r] method
+  # @return [Symbol] the HTTP method for this request
+  attr_reader :method
+
+  # @!attribute [r] url
+  # @return [String, #to_s] the URL for this request
+  attr_reader :url
+
+  # Create a request with the optionally given configuration block.
+  #
+  # @yield [request] if the block has a parameter the request is passed
+  #                  otherwise it's instance_exec'd
+  def initialize(&block)
+    super(transport)
+
+    @parameters   = {}
+    @query        = {}
+    @headers      = Headers[HEADERS]
+    @method       = :get
+    @asynchronous = true
+    @binary       = false
+    @cacheable    = true
+    @opened       = false
+    @sent         = false
+    @completed    = false
+    @callbacks    = Hash.new { |h, k| h[k] = [] }
+
+    if block.arity == 0
+      instance_exec(&block)
+    else
+      block.call(self)
+    end if block
+  end
+
+  # @!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.
+  def opened?
+    @opened
+  end
+
+  # Check if the request has been sent.
+  def sent?
+    @sent
+  end
+
+  # Check if the request has completed.
+  def completed?
+    @completed
+  end
+
+  # Check the request is asynchronous.
+  def asynchronous?
+    @asynchronous
+  end
+
+  # Check the request is synchronous.
+  def synchronous?
+    !@asynchronous
+  end
+
+  # Make the request asynchronous.
+  def asynchronous!
+    @asynchronous = true
+  end
+
+  # Make the request synchronous.
+  def synchronous!
+    @asynchronous = false
+  end
+
+  # Check the request is binary.
+  def binary?
+    @binary
+  end
+
+  # Make the request binary.
+  def binary!
+    @binary = true
+  end
+
+  # Check if the request is cacheable.
+  def cacheable?
+    @cacheable
+  end
+
+  # Disable caching for this request.
+  def no_cache!
+    @cacheable = false
+  end
+
+  # Get or set the user used for authentication.
+  #
+  # @param value [String] when passed it sets, when omitted it gets
+  #
+  # @return [String]
+  def user(value = nil)
+    value ? @user = value : @user
+  end
+
+  # Get or set the password used for authentication.
+  #
+  # @param value [String] when passed it sets, when omitted it gets
+  #
+  # @return [String]
+  def password(value = nil)
+    value ? @password = value : @password
+  end
+
+  # Get or set the MIME type of the request.
+  #
+  # @param value [String] when passed it sets, when omitted it gets
+  #
+  # @return [String]
+  def mime_type(value = nil)
+    value ? @mime_type = value : @mime_type
+  end
+
+  # Get or set the Content-Type of the request.
+  #
+  # @param value [String] when passed it sets, when omitted it gets
+  #
+  # @return [String]
+  def content_type(value = nil)
+    value ? @content_type = value : @content_type
+  end
+
+  # Get or set the encoding of the request.
+  #
+  # @param value [String] when passed it sets, when omitted it gets
+  #
+  # @return [String]
+  def encoding(value = nil)
+    value ? @encoding = value : @encoding
+  end
+
+  # Set the request parameters.
+  #
+  # @param hash [Hash] the parameters
+  #
+  # @return [Hash]
+  def parameters(hash = nil)
+    hash ? @parameters = hash : @parameters
+  end
+
+  # 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
+  #
+  # @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.
+  #
+  # @param method [Symbol] the HTTP method to use
+  # @param url [String, #to_s] the URL to send the request to
+  # @param asynchronous [Boolean] whether the request is asynchronous or not
+  # @param user [String] the user to use for authentication
+  # @param password [String] the password to use for authentication
+  #
+  # @return [self]
+  def open(method = nil, url = nil, asynchronous = nil, user = nil, password = nil)
+    raise 'the request has already been opened' if opened?
+
+    @method       = method       unless method.nil?
+    @url          = url          unless url.nil?
+    @asynchronous = asynchronous unless asynchronous.nil?
+    @user         = user         unless user.nil?
+    @password     = password     unless password.nil?
+
+    url = @url
+
+    # add a dummy random parameter to the query to try circumvent caching
+    unless cacheable?
+      @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 += @query.encode_uri
+    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
+
+    @opened = true
+
+    self
+  end
+
+  # Send the request with optional parameters.
+  #
+  # @param parameters [String, Hash] the data to send
+  #
+  # @return [Response] the response
+  def send(parameters = @parameters)
+    raise 'the request has not been opened' unless opened?
+
+    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
+
+    @headers.each {|name, value|
+      `#@native.setRequestHeader(#{name.to_s}, #{value.to_s})`
+    }
+
+    if @content_type
+      header  = @content_type
+      header += "; charset=#{@encoding}" if @encoding
+
+      `#@native.setRequestHeader('Content-Type', header)`
+    end
+
+    if binary?
+      if Buffer.supported?
+        `#@native.responseType = 'arraybuffer'`
+      else
+        `#@native.overrideMimeType('text/plain; charset=x-user-defined')`
+      end
+    end
+
+    if mime_type && !binary?
+      `#@native.overrideMimeType(#@mime_type)`
+    end
+
+    @sent     = true
+    @response = Response.new(self)
+
+    if String === parameters
+      data = parameters
+    elsif Hash === parameters && !parameters.empty?
+      data = parameters.map {|vals|
+        vals.map(&:encode_uri_component).join(?=)
+      }.join(?&)
+
+      unless @content_type
+        `#@native.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded')`
+      end
+    else
+      data = `null`
+    end
+
+    `#@native.send(#{data})`
+
+    @response
+  end
+
+  # Abort the request.
+  def abort
+    `#@native.abort()`
+  end
+
+private
+  def callback
+    -> event {
+      state = STATES[`#@native.readyState`]
+      res   = response
+
+      @callbacks[state].each { |b| b.(res) }
+
+      if state == :complete
+        @completed = true
+
+        @callbacks[res.status.code].each { |b| b.(res) }
+
+        if res.success?
+          @callbacks[:success].each { |b| b.(res) }
+        else
+          @callbacks[:failure].each { |b| b.(res) }
+        end
+      end
+    }
+  end
+end
+
+end; end