webmate 0.1.0

data/lib/webmate.rb

@@ -0,0 +1,129 @@
+ENV["RACK_ENV"] ||= "development"
+
+require "em-synchrony"
+require "sinatra"
+require "sinatra/cookies"
+require "sinatra/reloader"
+require "sinatra-websocket"
+require 'sinatra_more/markup_plugin'
+require "configatron"
+require "rack/contrib/post_body_content_type_parser"
+require "yajl"
+
+require 'webmate/env'
+require 'webmate/application'
+require 'webmate/config'
+require 'webmate/websockets'
+require 'webmate/logger'
+
+require 'bundler'
+Bundler.setup
+if Webmate.env == 'development'
+  Bundler.require(:assets)
+end
+
+require 'webmate/views/scope'
+require 'webmate/responders/exceptions'
+require 'webmate/responders/abstract'
+require 'webmate/responders/base'
+require 'webmate/responders/response'
+require 'webmate/responders/templates'
+require 'webmate/observers/base'
+require 'webmate/decorators/base'
+require 'webmate/route_helpers/routes_collection'
+require 'webmate/route_helpers/route'
+
+Bundler.require(:default, Webmate.env.to_sym)
+
+require 'webmate/socket.io/actions/handshake'
+require 'webmate/socket.io/actions/connection'
+require 'webmate/socket.io/packets/base'
+require 'webmate/socket.io/packets/disconnect'
+require 'webmate/socket.io/packets/connect'
+require 'webmate/socket.io/packets/heartbeat'
+require 'webmate/socket.io/packets/message'
+require 'webmate/socket.io/packets/json'
+require 'webmate/socket.io/packets/event'
+require 'webmate/socket.io/packets/ack'
+require 'webmate/socket.io/packets/error'
+require 'webmate/socket.io/packets/noop'
+
+require 'webmate/presenters/base'
+require 'webmate/presenters/scoped'
+require 'webmate/presenters/base_presenter'
+
+# it's not correct. app config file should be required by app
+file = "#{Webmate.root}/config/config.rb"
+require file if FileTest.exists?(file)
+
+configatron.app.load_paths.each do |path|
+  Dir[ File.join( Webmate.root, path, '**', '*.rb') ].each do |file|
+    class_name = File.basename(file, '.rb')
+    eval <<-EOV
+      autoload :#{class_name.camelize}, "#{file}"
+    EOV
+  end
+end
+
+# run observers
+Dir[ File.join( Webmate.root, 'app', 'observers', '**', '*.rb')].each do |file|
+  require file
+end
+
+class Webmate::Application
+  #register Webmate::RouteHelpers::Channels
+  register Sinatra::Reloader
+  register SinatraMore::MarkupPlugin
+
+  #helpers Webmate::Views::Helpers
+  helpers Sinatra::Cookies
+  helpers Webmate::Sprockets::Helpers
+
+  set :public_path, "#{Webmate.root}/public"
+  set :root, Webmate.root
+  set :reloader, !configatron.app.cache_classes
+
+  set :views, Proc.new { File.join(root, 'app', "views") }
+  set :layouts, Proc.new { File.join(root, 'app', "views", "layouts") }
+
+  if Webmate.env == 'development' # use cache classes here?
+    set :template_cache, Proc.new { Tilt::Cache.new }
+  else
+    set :template_cache, Tilt::Cache.new
+  end
+
+  # auto-reloading dirs
+  also_reload("#{Webmate.root}/config/config.rb")
+  also_reload("#{Webmate.root}/config/application.rb")
+  configatron.app.load_paths.each do |path|
+    also_reload("#{Webmate.root}/#{path}/**/*.rb")
+  end
+
+  use Webmate::Logger
+  use Rack::PostBodyContentTypeParser
+  use Rack::Session::Cookie, key: configatron.cookies.key,
+                           domain: configatron.cookies.domain,
+                           path: '/',
+                           expire_after: 14400,
+                           secret: configatron.cookies.secret
+end
+
+Webmate::Sprockets.configure do |config|
+  config.app = Webmate::Application
+  ['stylesheets', 'javascripts', 'images'].each do |dir|
+    # require application assets
+    config.append_path(File.join('app', 'assets', dir))
+  end
+  config.precompile = [ /\w+\.(?!js|css).+/, /application.(css|js)/ ]
+  config.compress = configatron.assets.compress
+  config.debug = configatron.assets.debug
+  config.compile = configatron.assets.compile
+  config.digest = configatron.assets.digest
+end
+
+path = File.expand_path("#{WEBMATE_ROOT}/config/initializers/*.rb")
+Dir[path].each { |initializer| require_relative(initializer) }
+
+# it's not correct. app config file should be required by app
+file_path = "#{WEBMATE_ROOT}/config/application.rb"
+require file_path if FileTest.exists?(file_path)

data/spec/lib/route_helpers/route_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+# responder to use as param for route creation.
+# should not be used for another
+class TestResponder; end
+
+def build_route_for(path, action = "any", responder = "test_responder")
+  route_args = {
+    method: "any",
+    transport: "transport",
+  }.merge(
+    path: path,
+    action: action,
+    responder: responder
+  )
+
+  Webmate::Route.new(route_args)
+end
+
+describe Webmate::Route do
+  it "should match simple routes" do
+    result = build_route_for('/projects').match("/projects")
+    result.should_not be_nil
+  end
+
+  it "should match empty routes" do
+    result = build_route_for('/').match("/")
+    result.should_not be_nil
+  end
+
+  it "should match routes with placements" do
+    result = build_route_for('/projects/:project_id').match("/projects/qwerty")
+    result.should_not be_nil
+    result[:params][:project_id].should == 'qwerty'
+  end
+
+  it "should match routes with wildcards" do
+    route  = build_route_for('/projects/*')
+    result = build_route_for('/projects/*').match("/projects/qwerty/code")
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+dir = File.expand_path(File.dirname(__FILE__))
+
+WEBMATE_ROOT = File.join(dir, '..')
+
+SPECDIR = dir 
+$LOAD_PATH.unshift("#{dir}/../lib")
+
+require 'rubygems'
+#require 'mocha'
+#require 'rspec'
+#require 'facter'
+#require 'fileutils'
+
+require File.join(dir, '..', 'lib', 'webmate.rb')
+
+RSpec.configure do |config|
+  #config.mock_with :mocha
+end

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
+  ###

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

@@ -0,0 +1,7 @@
+window.Webmate or= {}
+window.Webmate.channels = {}
+
+window.App = {}
+window.App.Models = {}
+window.App.Collections = {}
+window.App.Views = {}