webmate-client 0.1.1

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+pkg

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in webmate.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    webmate-client (0.1.1)
+      coffee-script
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coffee-script (2.2.0)
+      coffee-script-source
+      execjs
+    coffee-script-source (1.6.3)
+    execjs (1.4.0)
+      multi_json (~> 1.0)
+    multi_json (1.7.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  webmate-client!

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Iskander Haziev
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/webmate-client.rb

@@ -0,0 +1 @@
+require 'webmate-client/version'

data/lib/webmate-client/version.rb

@@ -0,0 +1,3 @@
+module WebmateClient
+  VERSION = '0.1.1'
+end

data/vendor/assets/javascripts/webmate.js

@@ -0,0 +1,10 @@
+//= require webmate/libs/underscore
+//= require webmate/libs/backbone
+//= require webmate/libs/icanhaz
+//= require webmate/libs/benchmark
+//= require webmate/libs/socket.io
+//= require webmate/init
+//= require webmate/client
+//= require webmate/auth
+//= require webmate/backbone_ext/sync
+//= require webmate/backbone_ext/resources

data/vendor/assets/javascripts/webmate/auth.coffee

@@ -0,0 +1,63 @@
+window.Webmate or= {}
+
+# this will assign to WebmateAuth
+#   {
+#     token:              "string"
+#     getToken:           "function(callback)"
+#     isAuthorized:       "function()"
+#   }
+#
+#  token - is reference to currentUserToken. 
+#
+#  getToken(callback) 
+#  - returns current  current user token
+#  - callback invoked if/when token will be available
+#
+#  authorized?
+#    returns true if user already received a non-blank token
+#
+#  for now, delayed applies of callback not implemented
+
+window.Webmate.Auth = (->
+  authToken = null
+
+  _setToken = (token) ->
+    authToken = token
+    if $("meta[name='websocket-token']").length > 0
+      $("meta[name='websocket-token']").attr('content', token)
+    else
+      $('head').append( $("<meta>", { name: 'websocket-token', content: token }))
+
+  _getToken = ->
+    if authToken then authToken else $("meta[name='websocket-token']").attr('content')
+
+  _fetchToken = (callback) ->
+    $.ajax
+      url: "/users/sessions/token"
+      dataType: 'JSON',
+      success: (data) ->
+        if data && data.token
+          _setToken(data.token)
+          callback.call(window, data.token)
+
+  publicGetToken = (callback) ->
+    if publicIsAuthorized()
+      callback.call(window, _getToken()) if callback
+    else
+      _fetchToken(callback)
+
+    _getToken()
+
+   # check null or empty string
+  publicIsAuthorized = () ->
+    not (not _getToken())
+
+  publicUnauthorize = () ->
+    _setToken(null)
+
+
+    # return object
+  getToken: publicGetToken
+  isAuthorized: publicIsAuthorized
+  unAuthorize: publicUnauthorize
+)()

data/vendor/assets/javascripts/webmate/backbone_ext/resources.coffee

@@ -0,0 +1,60 @@
+Backbone.Model::idAttribute = 'id'
+Backbone.Model::resourceName = -> @collection.resourceName()
+Backbone.Model::collectionName = -> @collection.collectionName()
+Backbone.Model::channel = -> _.result(@collection, 'channel')
+
+Backbone.Collection::resourceName = -> @resource
+Backbone.Collection::collectionName = -> "#{@resource}s"
+
+Backbone.Collection::bindSocketEvents = () ->
+  return false if not @channel?
+  collection  = @
+
+  # note: possible, this should be in webmate
+  client = Webmate.channels[@channel]
+  client or= Webmate.connect(@channel)
+
+  path = _.result(@, 'url')
+
+  client.on "#{path}/read", (response, params) =>
+    if collection.set(collection.parse(response))
+      collection.trigger('sync', collection, response, {})
+      collection.trigger('reset', collection, response, {})
+
+  client.on "#{path}/create", (response, params) =>
+    if collection.add(collection.parse(response))
+      collection.trigger('add', collection, response, {})
+
+  client.on "#{path}/update", (response, params) =>
+    if collection.add(collection.parse(response), { merge: true })
+      collection.trigger('change', collection, response, {})
+
+  client.on "#{path}/delete", (response, params) =>
+    if collection.remove(collection.parse(response))
+      collection.trigger('change', collection, response, {})
+
+  ###
+  # bind
+  client.on "#{path}/update", (response, params) =>
+    return unless response._id
+    @get(response._id).set(response)
+
+  client.on "#{@collectionName()}/read", (response, params)->
+    model.reset(response)
+    model.trigger "sync", model, response
+
+  client.on "#{@collectionName()}/create", (response, params)->
+    model.add(response)
+    #model.get(response._id).trigger 'sync', response
+    #if clientId is params._client_id
+    #  model.add(response)
+    #else
+    #  model.get(params._cid).set(response)
+  ###
+
+# update existing functions
+
+Backbone.Collection::_prepareModelWithoutAssociations = Backbone.Collection::_prepareModel
+Backbone.Collection::_prepareModel = (attrs, options) ->
+  attrs = _.extend(attrs, @sync_data) if @sync_data
+  @._prepareModelWithoutAssociations(attrs, options)

data/vendor/assets/javascripts/webmate/backbone_ext/sync.coffee

@@ -0,0 +1,131 @@
+# Improved Backbone Sync
+(->
+
+  methodMap =
+    create: "POST"
+    update: "PUT"
+    patch: 'PATCH'
+    delete: "DELETE"
+    read: "GET"
+    read_all: "GET"
+
+  # get an alias
+  window.Backbone.sync_with_ajax = window.Backbone.sync
+
+  window.Backbone.sync = (method, model, options) ->
+    # use default behaviour
+    if not (window.Webmate && window.Webmate.websocketsEnabled)
+      # clean options?
+      window.Backbone.sync_with_ajax(method, model, options)
+    else
+      # websocket messages protocol.
+      #   method: 'post'
+      #   path: '/projects/:project_id/tasks'
+      #   params: {}
+      #   metadata: {} # data to passback
+      url = _.result(model, 'url')
+      collection_url = if model.collection then _.result(model.collection, 'url') else url
+
+      packet_data = {
+        method: methodMap[method],
+        path: url,
+        metadata: {
+          collection_url: collection_url,
+          method: method,
+          user_websocket_token: Webmate.Auth.getToken()
+        },
+        params: {}
+      }
+      if (method == 'create' || method == 'update' || method == 'patch')
+        packet_data.params = JSON.stringify(options.attrs || model.toJSON(options))
+
+      Webmate.channels['api'].send(url, packet_data, methodMap[method])
+      model.trigger "request", model
+
+      ###
+      # TODO use prepare model for this logic
+      if model and model.sync_data
+        data = _.extend(data, model.sync_data)
+      token = $('meta[name="websocket-token"]').attr('content')
+      data.user_websocket_token = token
+      client = Webmate.channels[getChannel(model)]
+      client.send("#{model.collectionName()}/#{method}", data, type)
+      model.trigger "request", model
+      ###
+
+).call(this)
+###
+(->
+  methodMap =
+    create: "POST"
+    update: "PUT"
+    patch: 'PATCH'
+    delete: "DELETE"
+    read: "GET"
+    read_all: "GET"
+
+  getUrl = (object, method) ->
+    channel = _.result(object, "channel")
+    if channel
+      "/#{channel}/#{object.collectionName()}/#{method}"
+    else
+      return null unless object and object.url
+      (if _.isFunction(object.url) then object.url() else object.url)
+
+  getChannel = (object) ->
+    return null unless object and object.channel
+    (if _.isFunction(object.channel) then object.channel() else object.channel)
+
+  urlError = ->
+    throw new Error("A 'url' property or function must be specified")
+
+  window.Backbone.sync = (method, model, options) ->
+    type = methodMap[method]
+    data = {}
+
+    if model and (method is "create")
+      data['_cid'] = model.cid
+    if model and (method is "create" or method is "update" or method is 'patch')
+      data[model.resourceName()] = (options.attrs || model.toJSON())
+    if model and (method is "update" or method is 'patch')
+      delete data[model.resourceName()][model.idAttribute]
+    if model and (method is "delete" or method is "update" or method is 'patch')
+      data[model.idAttribute] = model.id
+
+    if window.Webmate && window.Webmate.websocketsEnabled
+      # TODO use prepare model for this logic
+      if model and model.sync_data
+        data = _.extend(data, model.sync_data)
+      token = $('meta[name="websocket-token"]').attr('content')
+      data.user_websocket_token = token
+      client = Webmate.channels[getChannel(model)]
+      client.send("#{model.collectionName()}/#{method}", data, type)
+      model.trigger "request", model
+
+    else
+      params =
+        type: type
+        dataType: "json"
+
+      # Ensure that we have a URL.
+      params.url = getUrl(model, method) or urlError()
+      params.contentType = "application/json"
+      params.data = JSON.stringify(data)
+
+      # Don't process data on a non-GET request.
+      params.processData = false if params.type isnt "GET"
+      success = options.success
+      options.success = (resp, status, xhr) ->
+        success resp.response, status, xhr  if success
+        model.trigger "sync", model, resp.response, options
+
+      error = options.error
+      options.error = (xhr, status, thrown) ->
+        error model, xhr, options  if error
+        model.trigger "error", model, xhr, options
+      # Make the request, allowing the user to override any Ajax options.
+      xhr = Backbone.ajax(_.extend(params, options))
+      model.trigger "request", model, xhr, options
+
+).call(this)
+###

data/vendor/assets/javascripts/webmate/client.coffee

@@ -0,0 +1,133 @@
+class Webmate.Client
+  constructor: (channel_name) ->
+    self = @
+    @bindings = {}
+    @channel_name = channel_name
+
+    if @useWebsockets()
+      @websocket = @createConnection( (message) ->
+        metadata = message.request.metadata
+        eventBindings = @bindings["#{metadata.collection_url}/#{metadata.method}"]
+        
+        _.each eventBindings, (eventBinding) ->
+          eventBinding(message.response.body, message.request.metadata)
+      )
+  
+  useWebsockets: ->
+    window.Webmate.websocketsEnabled isnt false && io && io.Socket
+
+  createConnection: (onMessageHandler) ->
+    self = @
+    @clientId or= Math.random().toString(36).substr(2)
+
+    # pass callback func, if needed be sure what callback exists
+    token = Webmate.Auth.getToken()
+    return false unless token?
+
+    socket = new io.Socket
+      resource: @channel_name
+      host: location.hostname
+      port: Webmate.websocketsPort or location.port
+      query: $.param(token: token)
+
+    socket.on "connect", () ->
+      console.log("connection established")
+
+    socket.onPacket = (packet) ->
+      console.log(packet)
+      return unless packet.type is 'message'
+      parsed_packet = Webmate.Client::parsePacketData(packet.data)
+      onMessageHandler.call(self, parsed_packet)
+
+    socket.connect()
+    socket
+
+  on: (action, callback) ->
+    @bindings[action] = [] if !@bindings[action]
+    @bindings[action].push(callback)
+    @
+
+  send: (path, data, method) ->
+    data.path = path
+    data.method = method
+    packet = {
+      type: 'message',
+      data: JSON.stringify(data)
+    }
+    @websocket.packet(packet)
+
+Webmate.Client::parsePacketData = (packet_data) ->
+  data = JSON.parse(packet_data)
+  data.response.body = JSON.parse(data.response.body)
+  data
+
+Webmate.connect = (channel, callback)->
+  client = new Webmate.Client(channel, callback)
+  Webmate.channels[channel] = client
+  client
+
+  ###
+class Webmate.Client
+  getFullPath: ->
+    "#{location.hostname}:#{Webmate.websocketsPort or location.port}/#{@channel}"
+
+  getClientId: ->
+    @clientId or= Math.random().toString(36).substr(2)
+
+  buildSocket: (onMessageHandler) ->
+
+  constructor: (channel, callback) ->
+    self = @
+    @bindings = {}
+    @channel = channel
+
+    if window.Webmate.websocketsEnabled isnt false && window.WebSocket
+      @websocket = buildSocket( (message) ->
+      )
+
+      @websocket = new WebSocket("ws://#{@fullPath}")
+      # prepare queue to store requests if socket not ready
+      @callsQueue = new Array()
+      @websocket.onmessage = (e) ->
+        data = JSON.parse(e.data)
+        eventBinding = self.bindings[data.action]
+        _.each eventBinding, (binding)->
+          binding(data.response, data.params)
+      @websocket.onopen = (e) ->
+        # process pending queues
+        while data = self.callsQueue.pop()
+          self.websocket.send(JSON.stringify(data))
+        callback() if callback
+    else
+      if window.Webmate.websocketsEnabled is false
+        console.log("Websockets is disabled. Using http.")
+      else
+        console.log("Websocket not supported. Using http.")
+      callback() if callback
+    @
+  on: (action, callback)->
+    @bindings[action] = [] if !@bindings[action]
+    @bindings[action].push(callback)
+    @
+  send: (action, data, method)->
+    data = {} if !data
+    method = 'get' if !method
+    data.action = action
+    data.channel = @channel
+    data._client_id = @clientId
+
+    if @websocket
+      if @websocket.readyState == @websocket.OPEN
+        @websocket.send(JSON.stringify(data))
+      else
+        @callsQueue.push(data)
+    else
+      $.ajax("http://#{@fullPath}/#{action}", type: method).success (data) ->
+        console.log(data)
+    @
+
+Webmate.connect = (channel, callback)->
+  client = new Webmate.Client(channel, callback)
+  Webmate.channels[channel] = client
+  client
+  ###