webmate 0.1.4 → 0.1.5

data/.gitignore

@@ -17,4 +17,5 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
-.DS_Store
+.DS_Store
+log

data/README.md

@@ -1,6 +1,19 @@
 # Webmate
 
-Real-time web applications framework in Ruby, based on WebSockets and EventMachine.
+Webmate is a fully asynchronous real-time web application framework in Ruby. It is built using EventMachine and WebSockets. Webmate primarily designed for providing full-duplex bi-directional communication.
+
+## Why Webmate?
+
+Webmate provides high-level api to create applications based on Websocket. Instead of separating code to http/websocket, you write one code, which may work using http or websocket (or both).
+
+Sample:
+
+    Webmate::Application.define_routes do
+      resources :tasks, transport: [:http, :WS]
+    end
+
+This simple route will allow you create, update, delete tasks using ONE websocket connection.
+
 
 ## Quick start
 

data/lib/webmate.rb

@@ -15,6 +15,7 @@ require 'webmate/application'
 require 'webmate/config'
 require 'webmate/websockets'
 require 'webmate/logger'
+require 'webmate/support/json'
 
 require 'bundler'
 Bundler.setup
@@ -30,8 +31,9 @@ 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'
+require 'webmate/routes/collection'
+require 'webmate/routes/base'
+require 'webmate/routes/handler'
 
 Bundler.require(:default, Webmate.env.to_sym)
 
@@ -52,10 +54,13 @@ 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)
+# require priority initialization files
+configatron.app.priotity_initialize_files.each do |path|
+  file = "#{Webmate.root}/#{path}"
+  require file if FileTest.exists?(file)
+end
 
+# auto-load files
 configatron.app.load_paths.each do |path|
   Dir[ File.join( Webmate.root, path, '**', '*.rb') ].each do |file|
     class_name = File.basename(file, '.rb')
@@ -65,17 +70,17 @@ configatron.app.load_paths.each do |path|
   end
 end
 
-# run observers
-Dir[ File.join( Webmate.root, 'app', 'observers', '**', '*.rb')].each do |file|
-  require file
+# require initialization files
+configatron.app.initialize_paths.each do |path|
+  Dir[ File.join( Webmate.root, path, '**', '*.rb')].each do |file|
+    require file
+  end
 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
 

data/lib/webmate/application.rb

@@ -1,102 +1,25 @@
 module Webmate
   class Application < Sinatra::Base
     # override sinatra's method
-    def route!(base = settings, pass_block = nil) 
-      transport = @request.websocket? ? 'WS' : 'HTTP'
-
-      route_info = base.routes.match(@request.request_method, transport, @request.path)
+    def route!(base = settings, pass_block = nil)
+      route_info = find_route(base.routes, @request)
 
       # no route case - use default sinatra's processors
-      if !route_info
+      if route_info
+        handler = Webmate::Routes::Handler.new(base, @request)
+        handler.handle(route_info)
+      else
         route_eval(&pass_block) if pass_block
         route_missing
       end
-
-      if @request.websocket?
-        unless authorized_to_open_connection?(route_info[:params][:scope])
-          return  [401, {}, []]
-        end
-
-        session_id = route_info[:params][:session_id].inspect
-        Webmate::Websockets.subscribe(session_id, @request) do |message|
-          if route_info = base.routes.match(message['method'], 'WS', message.path)
-            request_info = {
-              path: message.path,
-              metadata: message.metadata || {},
-              action: route_info[:action],
-              params: message.params.merge(route_info[:params]),
-              request: @request
-            }
-            # here we should create subscriber who can live
-            # between messages.. but not between requests.
-            response = route_info[:responder].new(request_info).respond
-
-            # result of block will be sent back to user
-            response
-          end
-        end
-
-        # this response not pass to user - so we keep connection alive.
-        # passing other response will close connection and socket
-        non_pass_response = [-1, {}, []]
-        return non_pass_response
-
-      else # HTTP
-        # this should return correct Rack response..
-        request_info = params_for_responder(route_info)
-        response = route_info[:responder].new(request_info).respond
-
-        return response.rack_format
-      end
-    end
-
-    # this method prepare data for responder
-    # {
-    #   path: '/', 
-    #   metadata: {}, 
-    #   action: 'index', 
-    #   params: { test: true } 
-    # }
-    def params_for_responder(route_info)
-      # create unified request info 
-      # request_info = { path: '/', metadata: {}, action: 'index', params: { test: true } }
-      request_params = parsed_request_params
-      metadata = request_params.delete(:metadata)
-      {
-        path: @request.path,
-        metadata: metadata || {},
-        action: route_info[:action],
-        params: request_params.merge(route_info[:params]),
-        request: @request
-      }
-    end
-
-    # @request.params  working only for get params
-    # and params in url line ?key=value
-    def parsed_request_params
-      request_params = HashWithIndifferentAccess.new
-      request_params.merge!(@request.params || {})
-
-      # read post or put params. this will erase  params
-      # {code: 123, mode: 123}
-      # "code=123&mode=123"
-      request_body = @request.body.read
-      if request_body.present?
-        body_params = begin
-          JSON.parse(request_body) # {code: 123, mode: 123}
-        rescue JSON::ParserError
-          Rack::Utils.parse_nested_query(request_body) # "code=123&mode=123"
-        end
-      else
-        body_params = {}
-      end
-
-      request_params.merge(body_params) 
     end
 
-    # update this method to create auth restrictions
-    def authorized_to_open_connection?(scope = :user)
-      return true
+    # Find matched route by routes collection and request
+    # @param Webmate::Routes::Collection routes
+    # @param Sinatra::Request request
+    def find_route(routes, request)
+      transport = request.websocket? ? 'WS' : 'HTTP'
+      routes.match(request.request_method, transport, request.path)
     end
 
     class << self
@@ -108,11 +31,11 @@ module Webmate
 
       def define_routes(&block)
         settings = Webmate::Application
-        unless settings.routes.is_a?(RoutesCollection)
-          routes = RoutesCollection.new()
+        unless settings.routes.is_a?(Routes::Collection)
+          routes = Routes::Collection.new()
           settings.set(:routes, routes)
         end
-        settings.routes.define_routes(&block)
+        settings.routes.define(&block)
 
         routes
       end
@@ -121,14 +44,6 @@ module Webmate
         channel_name = "some-unique-key-for-app-#{user_id}"
       end
 
-      def dump(obj)
-        Yajl::Encoder.encode(obj)
-      end
-
-      def restore(str)
-        Yajl::Parser.parse(str)
-      end
-
       def load_tasks
         file_path = Pathname.new(__FILE__)
         load File.join(file_path.dirname, "../../tasks/routes.rake")

data/lib/webmate/config.rb

@@ -1,8 +1,10 @@
 Webmate::Application.configure do |config|
-  config.app.load_paths = [
-    "app/responders", "app/models", "app/services",
-    "app/observers", "app/decorators", "app/routes"
-  ]
+  # these files will be required with high priority
+  config.app.priotity_initialize_files = ["config/config.rb"]
+  # files from these paths will be required on prod env and auto-loaded on dev env
+  config.app.load_paths = ["app/responders", "app/models", "app/services", "app/decorators"]
+  # files from these paths will be required on on any env
+  config.app.initialize_paths = ["app/observers", "app/routes"]
   config.app.cache_classes = false
 
   config.app.name = 'webmate'
@@ -23,4 +25,5 @@ Webmate::Application.configure do |config|
 
   config.websockets.enabled = true
   config.websockets.port = 80
+  config.websockets.namespace = 'http_over_websocket'
 end

data/lib/webmate/presenters/base_presenter.rb

@@ -55,61 +55,3 @@ module Webmate
     end
   end
 end
-=begin
-class BasePresenter
-  include Serializers::Scoped
-
-  attr_accessor :accessor, :resources
-
-  def initialize(resources)
-    raise ArgumentError, "Resources should not be blank" if resources.blank?
-    @resources = resources
-  end
-
-  def to_serializable
-    build_serialized default_resource do |object|
-      attributes object.attributes.keys
-    end
-  end
-
-  def errors
-    resource_by_name(:errors) || []
-  end
-
-  def to_json(options = {})
-    serialize_resource.to_json
-  end
-
-  private
-
-  def serialize_resource
-    if errors.present?
-      serialize_errors
-    else
-      to_serializable
-    end
-  end
-
-  def serialize_errors
-    errors = resource_by_name(:errors)
-    build_serialized do
-      namespace 'errors' do
-        errors.each do |error|
-          attribute error.key do
-            error.value
-          end
-        end
-      end
-    end
-  end
-
-  def resource_by_name(name)
-    @resources.resource(name.to_sym)
-  end
-
-  def default_resource
-    @resources.resource(:default)
-  end
-
-end
-=end

data/lib/webmate/responders/abstract.rb

@@ -85,7 +85,7 @@ module Webmate::Responders
 
     def build_connection
       EM::Hiredis.connect
-    rescue 
+    rescue
       warn("problem with connections to redis")
       nil
     end
@@ -119,7 +119,7 @@ module Webmate::Responders
       # this should be prepared data to create socket.io message
       # without any additional actions
       packet_data = Webmate::SocketIO::Packets::Message.prepare_packet_data(response)
-      data = Webmate::Application.dump(packet_data)
+      data = Webmate::JSON.dump(packet_data)
 
       channels_to_publish.each {|channel_name| publisher.publish(channel_name, data) }
     end

data/lib/webmate/responders/base.rb

@@ -2,15 +2,6 @@ require 'webmate/responders/abstract'
 module Webmate::Responders
   class Base < Abstract
     after_filter :_run_observer_callbacks
-    after_filter :_send_websocket_events
-
-    def _send_websocket_events
-      packet = Webmate::SocketIO::Packets::Message.new(@response.packed)
-
-      #async do
-      #  #Webmate::Websockets.publish(params[:channel], packet.to_packet)
-      #end
-    end
 
     def _run_observer_callbacks
       async do

data/lib/webmate/responders/response.rb

@@ -11,25 +11,7 @@ module Webmate::Responders
       @path = options[:path] || "/"
     end
 
-    def json
-      Yajl::Encoder.new.encode(self.packed)
-    end
-
-    def packed
-      { action: @action, resource: @resource, response: @data, params: safe_params }
-    end
-
-    def safe_params
-      safe_params = {}
-      params.each do |key, value|
-        if value.is_a?(String) || value.is_a?(Integer)
-          safe_params[key] = value
-        end
-      end
-      safe_params
-    end
-
-    def rack_format
+    def to_rack
       [@status, {}, @data]
     end
   end

data/lib/webmate/routes/base.rb

@@ -0,0 +1,99 @@
+module Webmate::Routes
+  class Base
+    FIELDS = [:method, :path, :action, :transport, :responder, :route_regexp, :static_params]
+    attr_reader *FIELDS
+    attr_reader :regexp, :substitution_attrs
+
+    # method: GET/POST/PUT/DELETE
+    # path  : /user/123/posts/123/comments
+    # transport: HTTP/WS/
+    # responder: class, responsible to 'respond' action
+    # action: method in webmate responders, called to fetch data
+    # static params: additional params hash, which will be passed to responder
+    #   for example, { :scope => :user }
+    #
+    def initialize(args)
+      values = args.with_indifferent_access
+      FIELDS.each do |field_name|
+        instance_variable_set("@#{field_name.to_s}", values[field_name])
+      end
+
+      normalize_data
+      create_matching_regexp
+      create_substitution_attrs
+    end
+
+    # method should check coincidence of path pattern and
+    # given path
+    # '/projects/qwerty123/tasks/asdf13/comments/zxcv123'
+    # will be parsed with route
+    # /projects/:project_id/tasks/:task_id/comments/:comment_id
+    # and return
+    #  result = {
+    #    action: 'read',
+    #    responder: CommentsResponder,
+    #    params: {
+    #      project_id: 'qwerty123',
+    #      task_id: :asdf13,
+    #      comment_id: :zxcv123
+    #    }
+    #  }
+    def match(request_path)
+      if regexp.match(request_path)
+        {
+          action: action,
+          responder: responder,
+          params: (static_params || {}).merge(params_from_path(request_path))
+        }
+      end
+    end
+
+    def params_from_path(path)
+      match_data = regexp.match(path)
+      params = {}
+      substitution_attrs.each_with_index do |key, index|
+        if key == :splat
+          params[key] ||= []
+          params[key] += match_data[index.next].split('/')
+        else
+          params[key] = match_data[index.next]
+        end
+      end
+      params
+    end
+
+    private
+
+      # /projects/:project_id/tasks/:task_id/comments/:comment_id
+      # result should be
+      # substitution_attrs = [:project_id, :task_id, :comment_id]
+      # route_regexp =
+      #   (?-mix:^\/projects\/([\w\d]*)\/tasks\/([\w\d]*)\/comments\/([\w\d]*)\/?$)
+      #
+      # substitute :resource_id elements with regexp group in order
+      # to easy extract
+      def create_substitution_attrs
+        substitutions = path.scan(/\/:(\w*)|\/(\*)/)
+        @substitution_attrs = substitutions.each_with_object([]) do |scan, attrs|
+          if scan[0]
+            attrs << scan[0].to_sym
+          elsif scan[1]
+            attrs << :splat
+          end
+        end
+      end
+
+      def create_matching_regexp
+        regexp_string = path.gsub(/\/:(\w*_id)/) {|t| "/([\\w\\d]*)" }
+        regexp_string = regexp_string.gsub(/\/\*/) {|t| "\/(.*)"}
+        @regexp = Regexp.new("^#{regexp_string}\/?$")
+      end
+
+      # update attributes by following rules
+      # - responder should be a Class, not String
+      # - ..
+      def normalize_data
+        @responder = @responder.to_s.classify.constantize unless @responder.is_a?(Class)
+      end
+  end
+end

data/lib/webmate/{route_helpers/routes_collection.rb → routes/collection.rb}

@@ -1,5 +1,5 @@
-module Webmate
-  class RoutesCollection
+module Webmate::Routes
+  class Collection
     TRANSPORTS = [:ws, :http]
 
     attr_reader :routes
@@ -7,22 +7,28 @@ module Webmate
     def initialize
       @routes = {}
       @resource_scope = []
-      
-      enable_websockets_support
+
+      enable_websockets if configatron.websockets.enabled
     end
 
-    def define_routes(&block)
+    # Call this method to define routes in application
+    # Examples:
+    #   routes = Webmate::Routes::Collection.new
+    #   routes.define do
+    #     resources :projects
+    #   end
+    def define(&block)
       instance_eval(&block)
     end
 
-    # get info about matched route
-    #   method    - GET/POST/PUT/PATCH/DELETE
-    #   transport - HTTP / WS [ HTTPS / WSS ]
-    #   path      - /projects/123/tasks
+    # Get list of matched routes
     #
+    # @param String method    - GET/POST/PUT/PATCH/DELETE
+    # @param String transport - HTTP / WS [ HTTPS / WSS ]
+    # @param String path      - /projects/123/tasks
+    # @return [Hash, nil]
     def match(method, transport, path)
-      routes = get_routes(method, transport)
-      routes.each do |route|
+      get_routes(method, transport.upcase).each do |route|
         if info = route.match(path)
           return info
         end
@@ -30,6 +36,11 @@ module Webmate
       nil
     end
 
+    # Get routes by method and transport
+    #
+    # @param String method    - GET/POST/PUT/PATCH/DELETE
+    # @param String transport - HTTP / WS [ HTTPS / WSS ]
+    # @return Array list of routes
     def get_routes(method, transport)
       @routes[method] ||= {}
       @routes[method][transport] || []
@@ -40,32 +51,36 @@ module Webmate
     # if websockets enabled, we should add specific http routes
     #   - for handshake          [ get session id ]
     #   - for connection opening [ switch protocol from http to ws ]
-    def enable_websockets_support
+    def enable_websockets
       namespace = configatron.websockets.namespace
-      namespace = 'api' if namespace.blank? # || not working with configatron
+      namespace = 'http_over_websocket' if namespace.blank?
 
-      route_options = { method: 'GET', transport: ['HTTP'], action: 'websocket' }
+      route_options = { method: 'GET', transport: ['HTTP'] }
 
       # handshake
-      add_route(Webmate::Route.new(route_options.merge(
+      add_route(route_options.merge(
         path: "/#{namespace}/:version_id",
         responder: Webmate::SocketIO::Actions::Handshake,
-      )))
+        action: 'websocket'
+      ))
 
       # transport connection
-      add_route(Webmate::Route.new(route_options.merge(
+      add_route(route_options.merge(
         transport: ["WS"],
         path: "/#{namespace}/:version_id/websocket/:session_id",
         responder: Webmate::SocketIO::Actions::Connection,
         action: 'open'
-      )))
+      ))
     end
 
-    # we store routes in following structure
-    # { method:
-    #     transport: [ routes ]
-    # route - valid object of Webmate::Route class
+    # Add router object to routes
+    #
+    # @param [Webmate::Routes::Base, Hash] route
     def add_route(route)
+      unless route.is_a?(Webmate::Routes::Base)
+        route = Webmate::Routes::Base.new(route)
+      end
+
       # add route to specific node of routes hash
       @routes[route.method.to_s.upcase] ||= {}
       route.transport.each do |transport|
@@ -74,8 +89,9 @@ module Webmate
     end
 
     # define methods for separate routes
-    #   get '/path', to: , transport: ,
-    # or 
+    #
+    # Examples:
+    #   get '/path', to: 'tasks#list', transport: [:http]
     #   resources :projects
     #     member do
     #       get 'read_formatted'
@@ -93,7 +109,7 @@ module Webmate
         end
         route_options[:method] = method_name.to_sym
 
-        add_route(Webmate::Route.new(route_options))
+        add_route(route_options)
       end
     end
 
@@ -195,7 +211,7 @@ module Webmate
     #
     #   member do
     #     get "do_on_member"
-    #   end 
+    #   end
     #   prefix /resource_name/resource_id
     def member(&block)
       return if @resource_scope.blank?
@@ -230,7 +246,7 @@ module Webmate
 
 
     # helper methods
-    # normalize_transport_option 
+    # normalize_transport_option
     #   returns array of requested transports, but available ones only
     def normalized_transport_option(transport = nil)
       return TRANSPORTS.dup if transport.blank?
@@ -250,7 +266,7 @@ module Webmate
       methods.map{|m| m.to_s.downcase.to_sym} & default_methods
     end
 
-    def define_resource_read_all_method(resource_name, route_args) 
+    def define_resource_read_all_method(resource_name, route_args)
       get "#{path_prefix}/#{resource_name}", route_args.merge(action: :read_all)
     end
 

data/lib/webmate/routes/handler.rb

@@ -0,0 +1,90 @@
+module Webmate::Routes
+  class Handler
+    attr_accessor :application, :request
+
+    def initialize(application, request)
+      @application = application
+      @request = request
+    end
+
+    def handle(route_info)
+      if request.websocket?
+        unless websocket_connection_authorized?(request)
+          return  [401, {}, []]
+        end
+
+        session_id = route_info[:params][:session_id]
+        Webmate::Websockets.subscribe(session_id, request) do |message|
+          if route_info = application.routes.match(message['method'], 'WS', message.path)
+            request_info = params_from_websoket(route_info, message)
+            # here we should create subscriber who can live
+            # between messages.. but not between requests.
+            route_info[:responder].new(request_info).respond
+          end
+        end
+
+        # this response not pass to user - so we keep connection alive.
+        # passing other response will close connection and socket
+        [-1, {}, []]
+
+      else # HTTP
+        # this should return correct Rack response..
+        request_info = params_from_http(route_info)
+        response = route_info[:responder].new(request_info).respond
+        response.to_rack
+      end
+    end
+
+    # this method prepare data for responder from http request
+    # @param Hash request_info = { path: '/', metadata: {}, action: 'index', params: { test: true } }
+    def params_from_http(route_info)
+      # create unified request info
+      request_params = http_body_request_params
+      metadata = request_params.delete(:metadata)
+      {
+        path: request.path,
+        metadata: metadata || {},
+        action: route_info[:action],
+        params: request_params.merge(route_info[:params]),
+        request: request
+      }
+    end
+
+    # this method prepare data for responder from http request
+    def params_from_websoket(route_info, message)
+      {
+        path: message.path,
+        metadata: message.metadata || {},
+        action: route_info[:action],
+        params: message.params.merge(route_info[:params])
+      }
+    end
+
+    # Get and parse all request params
+    def http_body_request_params
+      request_params = HashWithIndifferentAccess.new
+      request_params.merge!(@request.params || {})
+
+      # read post or put params. this will erase  params
+      # {code: 123, mode: 123}
+      # "code=123&mode=123"
+      request_body = @request.body.read
+      if request_body.present?
+        body_params = begin
+          JSON.parse(request_body) # {code: 123, mode: 123}
+        rescue JSON::ParserError
+          Rack::Utils.parse_nested_query(request_body) # "code=123&mode=123"
+        end
+      else
+        body_params = {}
+      end
+
+      request_params.merge(body_params)
+    end
+
+    # Check that client with that scope is authorized to open connection
+    def websocket_connection_authorized?(request)
+      true
+    end
+  end
+end

data/lib/webmate/socket.io/packets/base.rb

@@ -23,8 +23,8 @@ module Webmate
           @packet_data  = packet_data.with_indifferent_access
         end
 
-        # packet should be created by socket.io spec 
-        #[message type] ':' [message id ('+')] ':' [message endpoint] (':' [message data]) 
+        # packet should be created by socket.io spec
+        # [message type] ':' [message id ('+')] ':' [message endpoint] (':' [message data])
         # and webmate spec
         # message_data = {
         #   method: GET/POST/...
@@ -59,14 +59,13 @@ module Webmate
         end
 
         # convert response from Responders::Base to socket io message
-        # 
+        #
         def self.build_response_packet(response)
           new(self.prepare_packet_data(response))
         end
 
         def self.prepare_packet_data(response)
           packet_data = {
-            action:   response.action,
             body:     response.data,
             path:     response.path,
             params:   response.params,
@@ -75,12 +74,11 @@ module Webmate
         end
 
         # socket io spec
-        #[message type] ':' [message id ('+')] ':' [message endpoint] (':' [message data]) 
+        #[message type] ':' [message id ('+')] ':' [message endpoint] (':' [message data])
         def to_packet
           data = {
-            action: action,
-            request: { 
-              path:     path, 
+            request: {
+              path:     path,
               metadata: metadata
             },
             response: {
@@ -88,7 +86,7 @@ module Webmate
               status: status || 200
             }
           }
-          encoded_data = Yajl::Encoder.new.encode(data)
+          encoded_data = JSON.dump(data)
           [
             packet_type_id,
             packet_id,
@@ -117,10 +115,6 @@ module Webmate
           packet_data[:path]
         end
 
-        def action
-          packet_data[:action]
-        end
-
         def params
           packet_data[:params]
         end
@@ -137,14 +131,8 @@ module Webmate
           @id ||= generate_packet_id
         end
 
-        # update counter
-        def packet_id=(new_packet_id)
-          self.class.current_id = new_packet_id
-          @id ||= generate_packet_id
-        end
-
         # unique packet id
-        # didn't find any influence for now, 
+        # didn't find any influence for now,
         # uniqueness not matter
         def generate_packet_id
           self.class.current_id ||= 0

data/lib/webmate/support/json.rb

@@ -0,0 +1,15 @@
+module Webmate
+  class JSON
+    class << self
+      def dump(obj)
+        Yajl::Encoder.encode(obj)
+      end
+
+      def parse(str)
+        Yajl::Parser.parse(str)
+      rescue
+        raise JSON::ParserError
+      end
+    end
+  end
+end

data/lib/webmate/version.rb

@@ -1,3 +1,3 @@
 module Webmate
-  VERSION = '0.1.4'
+  VERSION = '0.1.5'
 end

data/lib/webmate/views/scope.rb

@@ -1,7 +1,6 @@
 module Webmate::Views
   class Scope
     include Sinatra::Cookies
-    include Webmate::Sprockets::Helpers
 
     def initialize(responder)
       @responder = responder

data/lib/webmate/websockets.rb

@@ -2,7 +2,7 @@ module Webmate
   class Websockets
     class << self
       def subscribe(session_id, request, &block)
-        user_id = request.env['warden'].user.id
+        user_id = request.env['warden'].try(:user).try(:id)
 
         request.websocket do |websocket|
           # subscribe user to redis channel
@@ -14,12 +14,14 @@ module Webmate
           end
 
           websocket.onmessage do |message|
-            response = block.call(Webmate::SocketIO::Packets::Base.parse(message))
+            request = Webmate::SocketIO::Packets::Base.parse(message)
+            response = block.call(request)
             if response
               packet = Webmate::SocketIO::Packets::Message.build_response_packet(response)
               websocket.send(packet.to_packet)
             else
-              warn("empty response for #{message.inspect}")
+              packet = Webmate::SocketIO::Packets::Error.build_response_packet("{error: 'empty response for #{message.inspect}'}")
+              websocket.send(packet.to_packet)
             end
           end
 
@@ -37,7 +39,7 @@ module Webmate
         warn("user has been subscribed to channel '#{channel_name}'")
 
         subscriber.on(:message) do |channel, message_data|
-          response_data = Webmate::Application.restore(message_data)
+          response_data = Webmate::JSON.parse(message_data)
           packet = Webmate::SocketIO::Packets::Message.new(response_data)
 
           websocket.send(packet.to_packet)

data/spec/lib/application_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+class FooResponder; end
+
+describe Webmate::Application do
+
+  let(:subject) { Webmate::Application }
+
+  describe "#define_routes" do
+    context "responder and action from params" do
+      it "should define applicatio routes" do
+        subject.define_routes do
+          get '/projects', responder: FooResponder, action: 'bar'
+        end
+        route = subject.routes.match('GET', 'HTTP', '/projects')
+        route[:responder].should == FooResponder
+      end
+    end
+  end
+end

data/spec/lib/routes/base_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+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::Routes::Base.new(route_args)
+end
+
+describe Webmate::Routes::Base do
+  describe "#match" 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
+
+    it "should return nil for unmatched route" do
+      route  = build_route_for('/foo').match('/bar')
+      route.should be_nil
+    end
+  end
+end

data/spec/lib/routes/collection_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+class FooResponder; end
+class ProjectsResponder; end
+
+describe Webmate::Routes::Collection do
+
+  let(:subject) { Webmate::Routes::Collection.new }
+
+  describe "#define" do
+    context "responder and action from params" do
+      it "should allow setting responder and action using params" do
+        subject.define do
+          get '/projects', responder: FooResponder, action: 'bar'
+        end
+        route = subject.match('GET', 'HTTP', '/projects')
+        route[:responder].should == FooResponder
+        route[:action].should == 'bar'
+      end
+
+      it "should allow setting responder and action using :to option" do
+        subject.define do
+          get '/projects', to: 'foo#bar'
+        end
+        route = subject.match('GET', 'HTTP', '/projects')
+        route[:responder].should == FooResponder
+        route[:action].to_s.should == 'bar'
+      end
+    end
+
+    context "responder and action by resource scope" do
+      before do
+        subject.define do
+          resources :projects
+        end
+      end
+
+      it "index action" do
+        route = subject.match('GET', 'HTTP', '/projects')
+        route[:responder].should == ProjectsResponder
+        route[:action].to_s.should == 'read_all'
+      end
+
+      it "show action" do
+        route = subject.match('GET', 'HTTP', '/projects/1')
+        route[:responder].should == ProjectsResponder
+        route[:action].to_s.should == 'read'
+      end
+    end
+  end
+
+  describe "#match" do
+    before do
+      subject.define do
+        get '/foo', responder: FooResponder, action: 'bar'
+        resources :projects, transport: [:http]
+      end
+    end
+
+    it "should return matched route" do
+      subject.match('GET', 'HTTP', '/foo').should_not be_nil
+      subject.match('GET', 'WS', '/foo').should_not be_nil
+    end
+
+    it "should return route only for matched transport" do
+      subject.match('GET', 'HTTP', '/projects/1').should_not be_nil
+      subject.match('GET', 'WS', '/projects/1').should be_nil
+    end
+
+    it "should return nil if no route found" do
+      subject.match('GET', 'HTTP', '/bar').should be_nil
+      subject.match('GET', 'WS', '/bar').should be_nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -2,7 +2,7 @@ dir = File.expand_path(File.dirname(__FILE__))
 
 WEBMATE_ROOT = File.join(dir, '..')
 
-SPECDIR = dir 
+SPECDIR = dir
 $LOAD_PATH.unshift("#{dir}/../lib")
 
 require 'rubygems'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: webmate
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-09 00:00:00.000000000 Z
+date: 2013-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thin
@@ -217,8 +217,9 @@ files:
 - lib/webmate/responders/exceptions.rb
 - lib/webmate/responders/response.rb
 - lib/webmate/responders/templates.rb
-- lib/webmate/route_helpers/route.rb
-- lib/webmate/route_helpers/routes_collection.rb
+- lib/webmate/routes/base.rb
+- lib/webmate/routes/collection.rb
+- lib/webmate/routes/handler.rb
 - lib/webmate/socket.io/actions/connection.rb
 - lib/webmate/socket.io/actions/handshake.rb
 - lib/webmate/socket.io/packets/ack.rb
@@ -231,11 +232,13 @@ files:
 - lib/webmate/socket.io/packets/json.rb
 - lib/webmate/socket.io/packets/message.rb
 - lib/webmate/socket.io/packets/noop.rb
-- lib/webmate/support/em_mongoid.rb
+- lib/webmate/support/json.rb
 - lib/webmate/version.rb
 - lib/webmate/views/scope.rb
 - lib/webmate/websockets.rb
-- spec/lib/route_helpers/route_spec.rb
+- spec/lib/application_spec.rb
+- spec/lib/routes/base_spec.rb
+- spec/lib/routes/collection_spec.rb
 - spec/spec_helper.rb
 - webmate.gemspec
 homepage: https://github.com/webmate/webmate
@@ -253,7 +256,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2410033587434335146
+      hash: 1691783446799875159
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -262,7 +265,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2410033587434335146
+      hash: 1691783446799875159
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25

data/lib/webmate/route_helpers/route.rb

@@ -1,91 +0,0 @@
-module Webmate
-  class Route
-    FIELDS = [:method, :path, :action, :transport, :responder, :route_regexp, :static_params]
-    attr_reader *FIELDS
-
-    # method: GET/POST/PUT/DELETE
-    # path  : /user/123/posts/123/comments
-    # transport: HTTP/WS/
-    # responder: class, responsible to 'respond' action
-    # action: method in webmate responders, called to fetch data
-    # static params: additional params hash, which will be passed to responder
-    #   for example, { :scope => :user }
-    #
-    def initialize(args)
-      values = args.with_indifferent_access
-      FIELDS.each do |field_name|
-        instance_variable_set("@#{field_name.to_s}", values[field_name])
-      end
-
-      normalize_data_if_needed
-      @route_regexp ||= construct_match_regexp
-    end
-
-    # method should check coincidence of path pattern and
-    # given path
-    # '/projects/qwerty123/tasks/asdf13/comments/zxcv123'
-    # will be parsed with route
-    # /projects/:project_id/tasks/:task_id/comments/:comment_id
-    # and return
-    #  result = {
-    #    action: 'read',
-    #    responder: CommentsResponder,
-    #    params: { 
-    #      project_id: 'qwerty123',
-    #      task_id: :asdf13,
-    #      comment_id: :zxcv123
-    #    }
-    #  }
-    def match(request_path)
-      if match_data = @route_regexp.match(request_path)
-        route_data = { 
-          action: @action,
-          responder: @responder,
-          params: HashWithIndifferentAccess.new(static_params || {})
-        }
-        @substitution_attrs.each_with_index do |key, index|
-          if key == :splat
-            route_data[:params][key] ||= []
-            route_data[:params][key] += match_data[index.next].split('/')
-          else
-            route_data[:params][key] = match_data[index.next]
-          end
-        end
-        route_data
-      else
-        nil # not matched.
-      end
-    end
-
-    private 
-
-    # /projects/:project_id/tasks/:task_id/comments/:comment_id
-    # result should be
-    # substitution_attrs = [:project_id, :task_id, :comment_id]
-    # route_regexp = 
-    #   (?-mix:^\/projects\/([\w\d]*)\/tasks\/([\w\d]*)\/comments\/([\w\d]*)\/?$)
-    #
-    # substitute :resource_id elements with regexp group in order
-    # to easy extract
-    def construct_match_regexp
-      substitutions = path.scan(/\/:(\w*)|\/(\*)/)
-      @substitution_attrs = substitutions.each_with_object([]) do |scan, attrs|
-        if scan[0]
-          attrs << scan[0].to_sym
-        elsif scan[1]
-          attrs << :splat
-        end
-      end
-      regexp_string = path.gsub(/\/:(\w*_id)/) {|t| "/([\\w\\d]*)" }
-      regexp_string = regexp_string.gsub(/\/\*/) {|t| "\/(.*)"}
-      Regexp.new("^#{regexp_string}\/?$")
-    end
-
-    # update attributes by following rules
-    # - responder should be a Class, not String
-    # - ..
-    def normalize_data_if_needed
-      @responder = @responder.to_s.classify.constantize unless @responder.is_a?(Class)
-    end
-  end
-end

data/lib/webmate/support/em_mongoid.rb

@@ -1,53 +0,0 @@
-# TODO: this is needed to use latest mongoid with moped, but it doesn't work at this moment
-
-begin
-  require "moped"
-rescue LoadError => error
-  raise "Missing EM-Synchrony dependency: gem install moped"
-end
-
-module Moped
-  class TimeoutHandler
-    def self.timeout(op_timeout, &block)
-      f = Fiber.current
-      timer = EM::Timer.new(op_timeout) { f.resume(nil) }
-      res = block.call
-      timer.cancel
-      res
-    end
-  end
-  module Sockets
-    module Connectable
-      module ClassMethods
-        def connect(host, port, timeout)
-          TimeoutHandler.timeout(timeout) do
-            sock = new(host, port)
-            #sock.set_encoding('binary')
-            #sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-            sock
-          end
-        end
-      end
-    end
-
-    class EM_TCP < ::EventMachine::Synchrony::TCPSocket
-      include Connectable
-
-      def connection_completed
-        @opening = false
-        @in_req.succeed(self) if @in_req
-      end
-    end
-    Mutex = ::EventMachine::Synchrony::Thread::Mutex
-    ConditionVariable = ::EventMachine::Synchrony::Thread::ConditionVariable
-  end
-  class Connection
-    def connect
-      @sock = if !!options[:ssl]
-        Sockets::SSL.connect(host, port, timeout)
-      else
-        Sockets::EM_TCP.connect(host, port, timeout)
-      end
-    end
-  end
-end

data/spec/lib/route_helpers/route_spec.rb

@@ -1,41 +0,0 @@
-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