webmate 0.1.0

data/lib/webmate/presenters/base_presenter.rb

@@ -0,0 +1,115 @@
+module Webmate
+  class BasePresenter
+    include Webmate::Presenters::Scoped
+
+    attr_accessor :accessor, :resources
+
+    def initialize(resources)
+      raise ArgumentError, "Resources should not be blank" if resources.blank?
+      @resources = resources
+      @errors = []
+    end
+
+    def to_serializable
+      build_serialized default_resource do |object|
+        attributes object.attributes.keys
+      end
+    end
+
+    def errors
+      @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
+      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
+    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/presenters/scoped.rb

@@ -0,0 +1,30 @@
+module Webmate::Presenters
+  module Scoped
+    extend ActiveSupport::Concern
+
+    def build_serialized(*args, &block)
+      object = args.first
+      if object.is_a?(Array)
+        object.map do |obj|
+          get_serializable_attributes(obj, &block)
+        end
+      else
+        get_serializable_attributes(object, &block)
+      end
+    end
+
+    private
+
+    def get_serializable_attributes(object, &block)
+      serializer = serializable_class.new(object)
+      instance_exec do
+        serializer.instance_exec(object, &block)
+      end
+      serializer.attrs
+    end
+
+    def serializable_class
+      Webmate::Presenters::Base
+    end
+  end
+end

data/lib/webmate/responders/abstract.rb

@@ -0,0 +1,127 @@
+require 'em-hiredis'
+require 'webmate/responders/callbacks'
+
+module Webmate::Responders
+  class Abstract
+    attr_accessor :action, :path, :metadata, :params
+    attr_reader :request
+
+    # request info - current request params
+    def initialize(request_info)
+      @action   = request_info[:action]
+      @path     = request_info[:path]
+      @metadata = request_info[:metadata]
+      @params   = request_info[:params]
+      @request  = request_info[:request]
+
+      # publishing actions
+      @users_to_notify = []
+
+      @response = nil
+    end
+
+    def action_method
+      action.to_s
+    end
+
+    def params
+      @params.with_indifferent_access
+    end
+
+    def respond
+      process_action
+    rescue Exception => e
+      rescue_with_handler(e)
+    end
+
+    def respond_with(response, options = {})
+      if @response.is_a?(Response)
+        @response = response
+      else
+        default_options = {
+          status: 200,
+          path: path,
+          metadata: metadata,
+          params: params,
+          action: action
+        }
+        options = default_options.merge(options)
+        @response = Response.new(response, options)
+      end
+      # publish changes to users actions
+      async { publish(@response) }
+
+      @response
+    end
+
+    def rescue_with_handler(exception)
+      if handler = handler_for_rescue(exception)
+        handler.arity != 0 ? handler.call(exception) : handler.call
+      else
+        raise(exception)
+      end
+    end
+
+    def process_action
+      raise ActionNotFound unless respond_to?(action_method)
+      respond_with send(action_method)
+    end
+
+    def render_not_found
+      @response = Response.new("Action not Found", status: 200)
+    end
+
+    def async(&block)
+      block.call
+    end
+
+    include ActiveSupport::Rescuable
+    include Webmate::Responders::Callbacks
+
+    # subscriptions
+    def publisher
+      @publisher ||= build_connection
+    end
+
+    def build_connection
+      EM::Hiredis.connect
+    rescue 
+      warn("problem with connections to redis")
+      nil
+    end
+
+    # publish current response to private channels
+    # for users in user_ids
+    #
+    # publish_to(123, 456)
+    def publish_to(*user_ids)
+      @users_to_notify += user_ids
+    end
+
+    # take @users_to_notify
+    # and pass back channels names with listeners
+    #
+    def channels_to_publish
+      @users_to_notify.flatten.each_with_object([]) do |user_id, channels|
+        channel_name = Webmate::Application.get_channel_name_for(user_id)
+        channels << channel_name if channel_active?(channel_name)
+      end
+    end
+
+    def channel_active?(channel_name)
+      return true # in development
+    end
+
+    def publish(response)
+      return if publisher.nil?
+
+      # prepare args for socket.io message packet
+      # 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)
+
+      channels_to_publish.each {|channel_name| publisher.publish(channel_name, data) }
+    end
+  end
+end

data/lib/webmate/responders/base.rb

@@ -0,0 +1,21 @@
+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
+        Webmate::Observers::Base.execute_all(action, @response)
+      end
+    end
+  end
+end

data/lib/webmate/responders/callbacks.rb

@@ -0,0 +1,79 @@
+module Webmate::Responders
+  module Callbacks
+    extend ActiveSupport::Concern
+    include ActiveSupport::Callbacks
+
+    included do
+      define_callbacks :process_action
+      class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+        alias_method :process_action!, :process_action
+        def process_action
+          run_callbacks(:process_action, action_method) do
+            process_action!
+          end
+        end
+      RUBY_EVAL
+    end
+
+    module ClassMethods
+      def _normalize_callback_options(options)
+        if only = options[:only]
+          only = Array(only).map {|o| "action_method == '#{o}'"}.join(" || ")
+          options[:per_key] = {:if => only}
+        end
+        if except = options[:except]
+          except = Array(except).map {|e| "action_method == '#{e}'"}.join(" || ")
+          options[:per_key] = {:unless => except}
+        end
+      end
+
+      def _insert_callbacks(callbacks, block)
+        options = callbacks.last.is_a?(Hash) ? callbacks.pop : {}
+        _normalize_callback_options(options)
+        callbacks.push(block) if block
+        callbacks.each do |callback|
+          yield callback, options
+        end
+      end
+
+      def skip_filter(*names, &blk)
+        skip_before_filter(*names)
+        skip_after_filter(*names)
+        skip_around_filter(*names)
+      end
+
+      [:before, :after, :around].each do |filter|
+        class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+          # Append a before, after or around filter. See _insert_callbacks
+          # for details on the allowed parameters.
+          def #{filter}_filter(*names, &blk)
+            _insert_callbacks(names, blk) do |name, options|
+              options[:if] = (Array.wrap(options[:if]) << "!halted") if #{filter == :after}
+              set_callback(:process_action, :#{filter}, name, options)
+            end
+          end
+
+          # Prepend a before, after or around filter. See _insert_callbacks
+          # for details on the allowed parameters.
+          def prepend_#{filter}_filter(*names, &blk)
+            _insert_callbacks(names, blk) do |name, options|
+              options[:if] = (Array.wrap(options[:if]) << "!halted") if #{filter == :after}
+              set_callback(:process_action, :#{filter}, name, options.merge(:prepend => true))
+            end
+          end
+
+          # Skip a before, after or around filter. See _insert_callbacks
+          # for details on the allowed parameters.
+          def skip_#{filter}_filter(*names, &blk)
+            _insert_callbacks(names, blk) do |name, options|
+              skip_callback(:process_action, :#{filter}, name, options)
+            end
+          end
+
+          # *_filter is the same as append_*_filter
+          alias_method :append_#{filter}_filter, :#{filter}_filter
+        RUBY_EVAL
+      end
+    end
+  end
+end

data/lib/webmate/responders/exceptions.rb

@@ -0,0 +1,4 @@
+module Webmate::Responders
+  class ActionNotFound < Exception; end
+  class TemplateNotFound < Exception; end
+end

data/lib/webmate/responders/response.rb

@@ -0,0 +1,36 @@
+require 'webmate/responders/abstract'
+module Webmate::Responders
+  class Response
+    attr_accessor :data, :status, :params, :action, :path, :metadata
+    def initialize(data, options = {})
+      @data = data
+      @status = options[:status] || 200
+      @params = options[:params] || {}
+      @action = options[:action] || @params[:action] || ''
+      @metadata = options[:metadata] || {}
+      @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
+      [@status, {}, @data]
+    end
+  end
+end

data/lib/webmate/responders/templates.rb

@@ -0,0 +1,65 @@
+module Webmate::Responders
+  module Templates
+
+    def slim(template, options = {}, locals = {}, &block)
+      render(:slim, template, options, locals, &block)
+    end
+
+    private 
+
+    def template_cache
+      @cache ||= Webmate::Application.template_cache
+    end
+
+    def scope
+      @scope ||= Webmate::Views::Scope.new(self)
+    end
+
+    def render(engine, data, options = {}, locals = {}, &block)
+      views     = Webmate::Application.views
+      layouts   = Webmate::Application.layouts
+
+      layout = options.delete(:layout) || false
+
+      # compile and render template
+      template        = compile_template(engine, data, options, views)
+      output          = template.render(scope, locals, &block)
+
+      if layout
+        layout_template = compile_template(engine, layout, options, layouts)
+        output          = layout_template.render(scope, locals) { output }
+      end
+
+      output
+    end
+
+    def compile_template(engine, data, options, views)
+      template_cache.fetch engine, data, options, views do
+        template = Tilt[engine]
+
+        # find template ./views  /name /action_name  engine_name
+        file = find_template(views, data, engine)
+
+        template.new(file)
+      end
+    end
+
+    # search through all available paths
+    # [./views/]name.[extension].[engine]/
+    # this will not search for responder's custom  folder
+    # responder
+    def find_template(views, name, engine)
+      responder_folder = self.class.name.underscore.sub(/_responder$/, '') # => namespace/responder_name
+
+      # NOTE: we can add shared, and other paths from settings
+      folders_to_search = [File.join(views, responder_folder, "*.#{engine.to_s}")]
+      folders_to_search << File.join(views, "*.#{engine.to_s}") 
+
+      search_regexp = /\/#{name}[\w|\.]*.#{engine}$/
+      Dir[*folders_to_search].each do |file_path|
+        return file_path if search_regexp.match(file_path)
+      end
+      raise TemplateNotFound.new
+    end
+  end
+end

data/lib/webmate/route_helpers/route.rb

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