goshrine_bot 0.1.1 → 0.1.5

data/lib/goshrine_bot/faye/channel.rb

@@ -1,143 +0,0 @@
-module Faye
-  class Channel
-    
-    include Observable
-    attr_reader :name
-    
-    def initialize(name)
-      @name = name
-    end
-    
-    def <<(message)
-      changed(true)
-      notify_observers(:message, message)
-    end
-    
-    HANDSHAKE   = '/meta/handshake'
-    CONNECT     = '/meta/connect'
-    SUBSCRIBE   = '/meta/subscribe'
-    UNSUBSCRIBE = '/meta/unsubscribe'
-    DISCONNECT  = '/meta/disconnect'
-    
-    META        = :meta
-    SERVICE     = :service
-    
-    class << self
-      def valid?(name)
-        Grammar::CHANNEL_NAME =~ name or
-        Grammar::CHANNEL_PATTERN =~ name
-      end
-      
-      def parse(name)
-        return nil unless valid?(name)
-        name.split('/')[1..-1].map { |s| s.to_sym }
-      end
-      
-      def meta?(name)
-        segments = parse(name)
-        segments ? (segments.first == META) : nil
-      end
-      
-      def service?(name)
-        segments = parse(name)
-        segments ? (segments.first == SERVICE) : nil
-      end
-      
-      def subscribable?(name)
-        return nil unless valid?(name)
-        not meta?(name) and not service?(name)
-      end
-    end
-    
-    class Tree
-      include Enumerable
-      attr_accessor :value
-      
-      def initialize(value = nil)
-        @value = value
-        @children = {}
-      end
-      
-      # Remove channels that have no subscribers
-      def delete_unobserved_channels
-        total_observers = 0
-        if @value
-          total_observers += @value.count_observers
-          @value = nil if @value.count_observers == 0
-        end
-        
-        @children.delete_if { |key, subtree|
-          num_child_observers = subtree.delete_unobserved_channels
-          total_observers += num_child_observers
-          num_child_observers == 0
-        }
-        total_observers
-      end
-      
-      def each_child
-        @children.each { |key, subtree| yield(key, subtree) }
-      end
-      
-      def each(prefix = [], &block)
-        each_child { |path, subtree| subtree.each(prefix + [path], &block) }
-        yield(prefix, @value) unless @value.nil?
-      end
-      
-      def keys
-        map { |key, value| '/' + key * '/' }
-      end
-      
-      def [](name)
-        subtree = traverse(name)
-        subtree ? subtree.value : nil
-      end
-      
-      def []=(name, value)
-        subtree = traverse(name, true)
-        subtree.value = value unless subtree.nil?
-      end
-      
-      def traverse(path, create_if_absent = false)
-        path = Channel.parse(path) if String === path
-        
-        return nil if path.nil?
-        return self if path.empty?
-        
-        subtree = @children[path.first]
-        return nil if subtree.nil? and not create_if_absent
-        subtree = @children[path.first] = self.class.new if subtree.nil?
-        
-        subtree.traverse(path[1..-1], create_if_absent)
-      end
-      
-      def glob(path = [])
-        path = Channel.parse(path) if String === path
-        
-        return [] if path.nil?
-        return @value.nil? ? [] : [@value] if path.empty?
-        
-        if path == [:*]
-          return @children.inject([]) do |list, (key, subtree)|
-            list << subtree.value unless subtree.value.nil?
-            list
-          end
-        end
-        
-        if path == [:**]
-          list = map { |key, value| value }
-          list.pop unless @value.nil?
-          return list
-        end
-        
-        list = @children.values_at(path.first, :*).
-                         compact.
-                         map { |t| t.glob(path[1..-1]) }
-        
-        list << @children[:**].value if @children[:**]
-        list.flatten
-      end
-    end
-    
-  end
-end
-

data/lib/goshrine_bot/faye/client.rb

@@ -1,283 +0,0 @@
-module Faye
-  class Client
-    include EventMachine::Deferrable
-    include Timeouts
-    
-    UNCONNECTED         = 1
-    CONNECTING          = 2
-    CONNECTED           = 3
-    DISCONNECTED        = 4
-    
-    HANDSHAKE           = 'handshake'
-    RETRY               = 'retry'
-    NONE                = 'none'
-    
-    CONNECTION_TIMEOUT  = 60.0
-    
-    attr_reader :endpoint, :namespace, :cookie
-    
-    def initialize(endpoint = nil, options = {})
-      @endpoint  = endpoint || RackAdapter::DEFAULT_ENDPOINT
-      @options   = options
-      @timeout   = @options[:timeout] || CONNECTION_TIMEOUT
-      @cookie    = @options[:cookie]
-      
-      @transport = Transport.get(self)
-      @state     = UNCONNECTED
-      @namespace = Namespace.new
-      @outbox    = []
-      @channels  = Channel::Tree.new
-      @current_id = 0
-      
-      @advice = {'reconnect' => RETRY, 'interval' => Connection::INTERVAL}
-    end
-    
-    # Request
-    # MUST include:  * channel
-    #                * version
-    #                * supportedConnectionTypes
-    # MAY include:   * minimumVersion
-    #                * ext
-    #                * id
-    # 
-    # Success Response                             Failed Response
-    # MUST include:  * channel                     MUST include:  * channel
-    #                * version                                    * successful
-    #                * supportedConnectionTypes                   * error
-    #                * clientId                    MAY include:   * supportedConnectionTypes
-    #                * successful                                 * advice
-    # MAY include:   * minimumVersion                             * version
-    #                * advice                                     * minimumVersion
-    #                * ext                                        * ext
-    #                * id                                         * id
-    #                * authSuccessful
-    def handshake(&block)
-      return if @advice['reconnect'] == NONE
-      return if @state != UNCONNECTED
-      
-      @state = CONNECTING
-      @transport.send({
-        'channel'     => Channel::HANDSHAKE,
-        'version'     => BAYEUX_VERSION,
-        'supportedConnectionTypes' => Transport.supported_connection_types
-        
-      }) do |response|
-        unless response['successful']
-          EventMachine.add_timer(@advice['interval'] / 1000.0) { handshake(&block) }
-          return @state = UNCONNECTED
-        end
-        
-        @state     = CONNECTED
-        @client_id = response['clientId']
-        @transport = Transport.get(self, response['supportedConnectionTypes'])
-        
-        block.call if block_given?
-      end
-    end
-    
-    # Request                              Response
-    # MUST include:  * channel             MUST include:  * channel
-    #                * clientId                           * successful
-    #                * connectionType                     * clientId
-    # MAY include:   * ext                 MAY include:   * error
-    #                * id                                 * advice
-    #                                                     * ext
-    #                                                     * id
-    #                                                     * timestamp
-    def connect(&block)
-      
-      return if @advice['reconnect'] == NONE or
-                @state == DISCONNECTED
-      
-      if @advice['reconnect'] == HANDSHAKE or @state == UNCONNECTED
-        begin_reconnect_timeout
-        return handshake { connect(&block) }
-      end
-      
-      return callback(&block) if @state == CONNECTING
-      return unless @state == CONNECTED
-      
-      set_deferred_status(:succeeded)
-      set_deferred_status(:deferred)
-      block.call if block_given?
-      
-      return unless @connection_id.nil?
-      
-      @connection_id = @namespace.generate
-      @transport.send({
-        'channel'         => Channel::CONNECT,
-        'clientId'        => @client_id,
-        'connectionType'  => @transport.connection_type,
-        'id'              => @connection_id
-        
-      }, &verify_client_id { |response|
-        @namespace.release(@connection_id) if @connection_id
-        @connection_id = nil
-        remove_timeout(:reconnect)
-        EventMachine.add_timer(@advice['interval'] / 1000.0) { connect }
-      })
-      
-      begin_reconnect_timeout
-    end
-    
-    # Request                              Response
-    # MUST include:  * channel             MUST include:  * channel
-    #                * clientId                           * successful
-    # MAY include:   * ext                                * clientId
-    #                * id                  MAY include:   * error
-    #                                                     * ext
-    #                                                     * id
-    def disconnect
-      return unless @state == CONNECTED
-      @state = DISCONNECTED
-      
-      @transport.send({
-        'channel'   => Channel::DISCONNECT,
-        'clientId'  => @client_id
-      })
-      
-      @channels = Channel::Tree.new
-      remove_timeout(:reconnect)
-    end
-    
-    # Request                              Response
-    # MUST include:  * channel             MUST include:  * channel
-    #                * clientId                           * successful
-    #                * subscription                       * clientId
-    # MAY include:   * ext                                * subscription
-    #                * id                  MAY include:   * error
-    #                                                     * advice
-    #                                                     * ext
-    #                                                     * id
-    #                                                     * timestamp
-    def subscribe(channels, &block)
-      connect {
-        channels = [channels].flatten
-        validate_channels(channels)
-        
-        @transport.send({
-          'channel'       => Channel::SUBSCRIBE,
-          'clientId'      => @client_id,
-          'subscription'  => channels
-          
-        }, &verify_client_id { |response|
-          if response['successful'] and block
-            channels = [response['subscription']].flatten
-            channels.each { |channel| @channels[channel] = block }
-          end
-        })
-      }
-    end
-    
-    # Request                              Response
-    # MUST include:  * channel             MUST include:  * channel
-    #                * clientId                           * successful
-    #                * subscription                       * clientId
-    # MAY include:   * ext                                * subscription
-    #                * id                  MAY include:   * error
-    #                                                     * advice
-    #                                                     * ext
-    #                                                     * id
-    #                                                     * timestamp
-    def unsubscribe(channels, &block)
-      connect {
-        channels = [channels].flatten
-        validate_channels(channels)
-        
-        @transport.send({
-          'channel'       => Channel::UNSUBSCRIBE,
-          'clientId'      => @client_id,
-          'subscription'  => channels
-          
-        }, &verify_client_id { |response|
-          if response['successful']
-            channels = [response['subscription']].flatten
-            channels.each { |channel| @channels[channel] = nil }
-          end
-        })
-      }
-    end
-    
-    # Request                              Response
-    # MUST include:  * channel             MUST include:  * channel
-    #                * data                               * successful
-    # MAY include:   * clientId            MAY include:   * id
-    #                * id                                 * error
-    #                * ext                                * ext
-    def publish(channel, data, id=nil)
-      connect {
-        validate_channels([channel])
-        
-        enqueue({
-          'id'        => (id || next_id),
-          'channel'   => channel,
-          'data'      => data,
-          'clientId'  => @client_id
-        })
-        
-        add_timeout(:publish, Connection::MAX_DELAY) { flush! }
-      }
-    end
-    
-    def handle_error(msg_id, error)
-      puts "Message #{msg_id} Error #{error}"
-    end
-    
-    def handle_advice(advice)
-      @advice.update(advice)
-      @client_id = nil if @advice['reconnect'] == HANDSHAKE
-    end
-    
-    def deliver_messages(messages)
-      messages.each do |message|
-        channels = @channels.glob(message['channel'])
-        channels.each { |callback| callback.call(message['data']) }
-      end
-    end
-    
-  private
-    
-    def begin_reconnect_timeout
-      add_timeout(:reconnect, @timeout) do
-        @namespace.release(@connection_id) if @connection_id
-        @connection_id = nil
-        @client_id = nil
-        @state = UNCONNECTED
-        subscribe(@channels.keys)
-      end
-    end
-    
-    def enqueue(message)
-      @outbox << message
-    end
-    
-    def flush!
-      @transport.send(@outbox)
-      @outbox = []
-    end
-    
-    def next_id
-      @current_id += 1
-    end
-    
-    def validate_channels(channels)
-      channels.each do |channel|
-        raise "'#{ channel }' is not a valid channel name" unless Channel.valid?(channel)
-        raise "Clients may not subscribe to channel '#{ channel }'" unless Channel.subscribable?(channel)
-      end
-    end
-    
-    def verify_client_id(&block)
-      lambda do |response|
-        if response['clientId'] != @client_id
-          false
-        else
-          block.call(response)
-          true
-        end
-      end
-    end
-    
-  end
-end
-

data/lib/goshrine_bot/faye/connection.rb

@@ -1,122 +0,0 @@
-module Faye
-  class Connection
-    include EventMachine::Deferrable
-    include Observable
-    include Timeouts
-    
-    MAX_DELAY = 0.1
-    INTERVAL  = 0.4
-    TIMEOUT   = 60.0
-    
-    attr_reader :id
-    
-    def initialize(id, options = {})
-      @id        = id
-      @options   = options
-      @timeout   = @options[:timeout] || TIMEOUT
-      @channels  = Set.new
-      @inbox     = Set.new
-      @connected = false
-      @connection_listener = options[:connection_listener]
-      
-      # This is for clients that subscribe, but never re-connect to get messages
-      # (prevents a memory leak)
-      add_timeout(:deletion, 60 * INTERVAL) do
-        puts "Deleting orphaned connection: #{@id}"
-        delete
-      end
-      
-    end
-    
-    def update(message, event)
-      return unless message == :message
-      @inbox.add(event)
-      begin_delivery_timeout!
-    end
-    
-    def subscribe(channel)
-      if @channels.add?(channel)
-        channel.add_observer(self)
-        if @options[:subscription_listener]
-          @options[:subscription_listener].subscribed(self, channel)
-        end
-      end
-    end
-    
-    def unsubscribe(channel)
-      return @channels.each(&method(:unsubscribe)) if channel == :all
-      return unless @channels.member?(channel)
-      @channels.delete(channel)
-      channel.delete_observer(self)
-      if @options[:subscription_listener]
-        @options[:subscription_listener].unsubscribed(self, channel)
-      end
-    end
-    
-    def connect(transport_authentication, &block)
-      callback(&block)
-      return if @connected
-      
-      @connected = true
-      
-      if @connection_listener
-        @connection_listener.connected(id, transport_authentication)
-      end
-      
-      remove_timeout(:deletion)
-      
-      begin_delivery_timeout!
-      begin_connection_timeout!
-    end
-    
-    def flush!
-      return unless @connected
-      release_connection!
-      
-      events = @inbox.entries
-      @inbox = Set.new
-      
-      set_deferred_status(:succeeded, events)
-      set_deferred_status(:deferred)
-    end
-    
-    def disconnect!
-      unsubscribe(:all)
-      flush!
-    end
-    
-  private
-    
-    def begin_delivery_timeout!
-      if @delivery_timeout.nil? && @connected && (!@inbox.empty? || @channels.empty?)
-        add_timeout(:delivery, MAX_DELAY) { flush! }
-      end
-    end
-    
-    def begin_connection_timeout!
-      return unless @connection_timeout.nil? and @connected
-      add_timeout(:connection, @timeout) { flush! }
-    end
-    
-    def delete
-      unsubscribe(:all)
-      if @connection_listener
-        @connection_listener.disconnected(id)
-      end
-      changed(true)
-      notify_observers(:stale_client, self)
-    end
-    
-    def release_connection!
-      remove_timeout(:connection)
-      remove_timeout(:delivery)
-      @connected = false
-      
-      add_timeout(:deletion, 10 * INTERVAL) do
-        delete
-      end
-    end
-    
-  end
-end
-

data/lib/goshrine_bot/faye/error.rb

@@ -1,44 +0,0 @@
-module Faye
-  class Error
-    
-    def self.parse(string)
-      return nil unless Grammar::ERROR =~ string
-      parts = string.split(':')
-      args  = parts[1].split(',')
-      new(parts[0].to_i, args, parts[2])
-    end
-    
-    def self.method_missing(type, *args)
-      code = const_get(type.to_s.upcase)
-      new(code[0], args, code[1]).to_s
-    end
-    
-    attr_reader :code, :args, :message
-    
-    def initialize(code, args, message)
-      @code     = code
-      @args     = args
-      @message  = message
-    end
-    
-    def to_s
-      "#{ @code }:#{ @args * ',' }:#{ @message }"
-    end
-    
-    # http://code.google.com/p/cometd/wiki/BayeuxCodes
-    VERSION_MISMATCH    = [300, 'Version mismatch']
-    CONNTYPE_MISMATCH   = [301, 'Connection types not supported']
-    EXT_MISMATCH        = [302, 'Extension mismatch']
-    BAD_REQUEST         = [400, 'Bad request']
-    CLIENT_UNKNOWN      = [401, 'Unknown client']
-    PARAMETER_MISSING   = [402, 'Missing required parameter']
-    CHANNEL_FORBIDDEN   = [403, 'Forbidden channel']
-    CHANNEL_UNKNOWN     = [404, 'Unknown channel']
-    CHANNEL_INVALID     = [405, 'Invalid channel']
-    EXT_UNKNOWN         = [406, 'Unknown extension']
-    PUBLISH_FAILED      = [407, 'Failed to publish']
-    SERVER_ERROR        = [500, 'Internal server error']
-    
-  end
-end
-

data/lib/goshrine_bot/faye/grammar.rb

@@ -1,58 +0,0 @@
-module Faye
-  module Grammar
-    
-    def self.rule(&block)
-      source = instance_eval(&block)
-      %r{^#{string(source)}$}
-    end
-    
-    def self.choice(*list)
-      '(' + list.map(&method(:string)) * '|' + ')'
-    end
-    
-    def self.repeat(*pattern)
-      '(' + string(pattern) + ')*'
-    end
-    
-    def self.oneormore(*pattern)
-      '(' + string(pattern) + ')+'
-    end
-    
-    def self.string(item)
-      return item.map(&method(:string)) * '' if Array === item
-      String === item ? item : item.source.gsub(/^\^/, '').gsub(/\$$/, '')
-    end
-    
-    LOWALPHA          = rule {[ '[a-z]' ]}
-    UPALPHA           = rule {[ '[A-Z]' ]}
-    ALPHA             = rule {[ choice(LOWALPHA, UPALPHA) ]}
-    DIGIT             = rule {[ '[0-9]' ]}
-    ALPHANUM          = rule {[ choice(ALPHA, DIGIT) ]}
-    MARK              = rule {[ choice(*%w[\\- \\_ \\! \\~ \\( \\) \\$ \\@]) ]}
-    STRING            = rule {[ repeat(choice(ALPHANUM, MARK, ' ', '\\/', '\\*', '\\.')) ]}
-    TOKEN             = rule {[ oneormore(choice(ALPHANUM, MARK)) ]}
-    INTEGER           = rule {[ oneormore(DIGIT) ]}
-    
-    CHANNEL_SEGMENT   = rule {[ TOKEN ]}
-    CHANNEL_SEGMENTS  = rule {[ CHANNEL_SEGMENT, repeat('\\/', CHANNEL_SEGMENT) ]}
-    CHANNEL_NAME      = rule {[ '\\/', CHANNEL_SEGMENTS ]}
-    
-    WILD_CARD         = rule {[ '\\*{1,2}' ]}
-    CHANNEL_PATTERN   = rule {[ repeat('\\/', CHANNEL_SEGMENT), '\\/', WILD_CARD ]}
-    
-    VERSION_ELEMENT   = rule {[ ALPHANUM, repeat(choice(ALPHANUM, '\\-', '\\_')) ]}
-    VERSION           = rule {[ INTEGER, repeat('\\.', VERSION_ELEMENT) ]}
-    
-    CLIENT_ID         = rule {[ oneormore(ALPHANUM) ]}
-    
-    ID                = rule {[ oneormore(ALPHANUM) ]}
-    
-    ERROR_MESSAGE     = rule {[ STRING ]}
-    ERROR_ARGS        = rule {[ STRING, repeat(',', STRING) ]}
-    ERROR_CODE        = rule {[ DIGIT, DIGIT, DIGIT ]}
-    ERROR             = rule {[ choice(string([ERROR_CODE, ':', ERROR_ARGS, ':', ERROR_MESSAGE]),
-                                       string([ERROR_CODE, ':', ':', ERROR_MESSAGE])) ]}
-    
-  end
-end
-

data/lib/goshrine_bot/faye/namespace.rb

@@ -1,20 +0,0 @@
-module Faye
-  class Namespace
-    
-    def initialize
-      @used = {}
-    end
-    
-    def generate
-      name = Faye.random
-      name = Faye.random while @used.has_key?(name)
-      @used[name] = name
-    end
-    
-    def release(name)
-      @used.delete(name)
-    end
-
-  end
-end
-