jamesotron/faye-rails

module FayeRails
  class Filter

    attr_accessor :server
    attr_reader   :channel
    attr_writer   :logger

    # Create a new FayeRails::Filter which can be passed to
    # Faye::RackAdapter#add_extension.
    #
    # @param channel
    #   Optional channel name to limit messages to.
    # @param direction
    #   :in, :out or :any.
    # @param block
    #   A proc object to be called when filtering messages.
    def initialize(channel='/**', direction=:any, block)
      @channel = channel
      @block = block
      raise ArgumentError, "Block cannot be nil" unless block
      if (direction == :in) || (direction == :any)
        @in_filter = DSL
      end
      if (direction == :out) || (direction == :any)
        @out_filter = DSL
      end
    end

    def respond_to?(method)
      if (method == :incoming) 
        !!@in_filter
      elsif (method == :outgoing)
        !!@out_filter
      else
        super
      end
    end

    def logger
      if defined?(::Rails)
        @logger ||= Rails.logger
      end
    end

    def incoming(message, callback)
      @in_filter.new(@block, message, channel, callback, :incoming) if @in_filter
    end


    def outgoing(message, callback)
      @out_filter.new(@block, message, channel, callback, :outgoing) if @out_filter
    end

    def destroy
      if server
        server.remove_extension(self)
      end
    end

    class DSL

      # A small wrapper class around filter blocks to
      # add some sugar to ease filter (Faye extension)
      # creation.

      attr_reader :channel, :message, :callback, :original_message, :direction

      # Called by FayeRails::Filter when Faye passes
      # messages in for evaluation.
      # @param block
      #   The block you wish to execute whenever a matching
      #   message is recieved.
      # @param channel
      #  optional: if present then the block will only be called for matching messages, otherwise all messages will be passed.
      def initialize(block, message, channel='/**', callback, direction)
        raise ArgumentError, "Block cannot be nil" unless block
        @channel = channel
        @original_message = message.dup
        @message = message
        @callback = callback
        @direction = direction

        if channel_matches?(@channel, @original_message['channel']) ||
          (subscribing? && subscription?(@channel)) ||
          (unsubscribing? && subscription?(@channel))
          instance_eval(&block)
        else
          pass
        end
      end

      # Easier than testing message['channel'] every time
      def subscribing?
        message['channel'] == '/meta/subscribe'
      end

      def unsubscribing?
        message['channel'] == '/meta/unsubscribe'
      end

      def meta?
        message['channel'][0..5] == '/meta/'
      end

      def service?
        message['channel'][0..8] == '/service/'
      end

      def incoming?
        direction == :incoming
      end
      alias in? incoming?

      def outgoing?
        direction == :outgoing
      end
      alias out? outgoing?

      def data
        message['data']
      end

      def data?
        !!data
      end

      def client_id?(x=nil)
        if !!x
          message['client_id'] == x
        else
          !!message['client_id']
        end
      end

      def channel_matches?(glob,test)
        FayeRails::Matcher.match? glob, test
      end

      def subscription?(channel)
        message['subscription'] && channel_matches?(channel, message['subscription'])
      end
      
      # Syntactic sugar around callback.call which passes
      # back the original message unmodified.
      def pass
        callback.call(original_message)
      end

      # Syntactic sugar around callback.call which passes
      # the passed argument back to Faye in place of the 
      # original message.
      # @param new_message
      #   Replacement message to send back to Faye.
      def modify(new_message)
        callback.call(new_message)
      end

      # Syntactic sugar around callback.call which adds
      # an error message to the message and passes it back
      # to Faye, which will send back a rejection message to
      # the sending client.
      # @param reason
      #   The error message to be sent back to the client.
      def block(reason="Message blocked by filter")
        new_message = message
        new_message['error'] = reason
        callback.call(new_message)
      end

      # Syntactic sugar around callback.call which returns
      # nil to Faye - effectively dropping the message.
      def drop
        callback.call(nil)
      end

    end

  end
end