sidekick-client 0.2.1 → 0.2.2

data/lib/ext/eventmachine-0.12.10/lib/em/protocols/linetext2.rb

@@ -1,161 +0,0 @@
-#--
-#
-# Author:: Francis Cianfrocca (gmail: blackhedd)
-# Homepage::  http://rubyeventmachine.com
-# Date:: 15 November 2006
-# 
-# See EventMachine and EventMachine::Connection for documentation and
-# usage examples.
-#
-#----------------------------------------------------------------------------
-#
-# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-# Gmail: blackhedd
-# 
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of either: 1) the GNU General Public License
-# as published by the Free Software Foundation; either version 2 of the
-# License, or (at your option) any later version; or 2) Ruby's License.
-# 
-# See the file COPYING for complete licensing information.
-#
-#---------------------------------------------------------------------------
-#
-# 
-
-module EventMachine
-  module Protocols
-    # In the grand, time-honored tradition of re-inventing the wheel, we offer
-    # here YET ANOTHER protocol that handles line-oriented data with interspersed
-    # binary text. This one trades away some of the performance optimizations of
-    # EventMachine::Protocols::LineAndTextProtocol in order to get better correctness
-    # with regard to binary text blocks that can switch back to line mode. It also
-    # permits the line-delimiter to change in midstream.
-    # This was originally written to support Stomp.
-    module LineText2
-      # TODO! We're not enforcing the limits on header lengths and text-lengths.
-      # When we get around to that, call #receive_error if the user defined it, otherwise
-      # throw exceptions.
-
-      MaxLineLength = 16*1024
-      MaxBinaryLength = 32*1024*1024
-
-      #--
-      # Will be called recursively until there's no data to read.
-      # That way the user-defined handlers we call can modify the
-      # handling characteristics on a per-token basis.
-      #
-      def receive_data data
-        return unless (data and data.length > 0)
-
-        # Do this stuff in lieu of a constructor.
-        @lt2_mode ||= :lines
-        @lt2_delimiter ||= "\n"
-        @lt2_linebuffer ||= []
-
-        if @lt2_mode == :lines
-          if ix = data.index( @lt2_delimiter )
-            @lt2_linebuffer << data[0...ix]
-            ln = @lt2_linebuffer.join
-            @lt2_linebuffer.clear
-            if @lt2_delimiter == "\n"
-              ln.chomp!
-            end
-            receive_line ln
-            receive_data data[(ix+@lt2_delimiter.length)..-1]
-          else
-            @lt2_linebuffer << data
-          end
-        elsif @lt2_mode == :text
-          if @lt2_textsize
-            needed = @lt2_textsize - @lt2_textpos
-            will_take = if data.length > needed
-                          needed
-                        else
-                          data.length
-                        end
-
-            @lt2_textbuffer << data[0...will_take]
-            tail = data[will_take..-1]
-
-            @lt2_textpos += will_take
-            if @lt2_textpos >= @lt2_textsize
-              # Reset line mode (the default behavior) BEFORE calling the
-              # receive_binary_data. This makes it possible for user code
-              # to call set_text_mode, enabling chains of text blocks
-              # (which can possibly be of different sizes).
-              set_line_mode
-              receive_binary_data @lt2_textbuffer.join
-              receive_end_of_binary_data
-            end
-
-            receive_data tail
-          else
-            receive_binary_data data
-          end
-        end
-      end
-
-
-      def set_delimiter delim
-        @lt2_delimiter = delim.to_s
-      end
-
-      # Called internally but also exposed to user code, for the case in which
-      # processing of binary data creates a need to transition back to line mode.
-      # We support an optional parameter to "throw back" some data, which might
-      # be an umprocessed chunk of the transmitted binary data, or something else
-      # entirely.
-      def set_line_mode data=""
-        @lt2_mode = :lines
-        (@lt2_linebuffer ||= []).clear
-        receive_data data.to_s
-      end
-
-      def set_text_mode size=nil
-        if size == 0
-          set_line_mode
-        else
-          @lt2_mode = :text
-          (@lt2_textbuffer ||= []).clear
-          @lt2_textsize = size # which can be nil, signifying no limit
-          @lt2_textpos = 0
-        end
-      end
-
-      # Alias for #set_text_mode, added for back-compatibility with LineAndTextProtocol.
-      def set_binary_mode size=nil
-        set_text_mode size
-      end
-
-      # In case of a dropped connection, we'll send a partial buffer to user code
-      # when in sized text mode. User overrides of #receive_binary_data need to
-      # be aware that they may get a short buffer.
-      def unbind
-        @lt2_mode ||= nil
-        if @lt2_mode == :text and @lt2_textpos > 0
-          receive_binary_data @lt2_textbuffer.join
-        end
-      end
-
-      # Stub. Should be subclassed by user code.
-      def receive_line ln
-        # no-op
-      end
-
-      # Stub. Should be subclassed by user code.
-      def receive_binary_data data
-        # no-op
-      end
-
-      # Stub. Should be subclassed by user code.
-      # This is called when transitioning internally from text mode
-      # back to line mode. Useful when client code doesn't want
-      # to keep track of how much data it's received.
-      def receive_end_of_binary_data
-        # no-op
-      end
-    end
-  end
-end
-

data/lib/ext/eventmachine-0.12.10/lib/em/protocols/memcache.rb

@@ -1,323 +0,0 @@
-module EventMachine
-  module Protocols
-    # Implements the Memcache protocol (http://code.sixapart.com/svn/memcached/trunk/server/doc/protocol.txt).
-    # Requires memcached >= 1.2.4 w/ noreply support
-    #
-    # == Usage example
-    #
-    #   EM.run{
-    #     cache = EM::P::Memcache.connect 'localhost', 11211
-    #
-    #     cache.set :a, 'hello'
-    #     cache.set :b, 'hi'
-    #     cache.set :c, 'how are you?'
-    #     cache.set :d, ''
-    #
-    #     cache.get(:a){ |v| p v }
-    #     cache.get_hash(:a, :b, :c, :d){ |v| p v }
-    #     cache.get(:a,:b,:c,:d){ |a,b,c,d| p [a,b,c,d] }
-    #
-    #     cache.get(:a,:z,:b,:y,:d){ |a,z,b,y,d| p [a,z,b,y,d] }
-    #
-    #     cache.get(:missing){ |m| p [:missing=, m] }
-    #     cache.set(:missing, 'abc'){ p :stored }
-    #     cache.get(:missing){ |m| p [:missing=, m] }
-    #     cache.del(:missing){ p :deleted }
-    #     cache.get(:missing){ |m| p [:missing=, m] }
-    #   }
-    #
-    module Memcache
-      include EM::Deferrable
-
-      ##
-      # constants
-
-      # :stopdoc:
-      unless defined? Cempty
-        Cstored    = 'STORED'.freeze
-        Cend       = 'END'.freeze
-        Cdeleted   = 'DELETED'.freeze
-        Cunknown   = 'NOT_FOUND'.freeze
-        Cerror     = 'ERROR'.freeze
-
-        Cempty     = ''.freeze
-        Cdelimiter = "\r\n".freeze
-      end
-      # :startdoc:
-
-      ##
-      # commands
-
-      # Get the value associated with one or multiple keys
-      #
-      #  cache.get(:a){ |v| p v }
-      #  cache.get(:a,:b,:c,:d){ |a,b,c,d| p [a,b,c,d] }
-      #
-      def get *keys
-        raise ArgumentError unless block_given?
-
-        callback{
-          keys = keys.map{|k| k.to_s.gsub(/\s/,'_') }
-          send_data "get #{keys.join(' ')}\r\n"
-          @get_cbs << [keys, proc{ |values|
-            yield *keys.map{ |k| values[k] }
-          }]
-        }
-      end
-
-      # Set the value for a given key
-      #
-      #  cache.set :a, 'hello'
-      #  cache.set(:missing, 'abc'){ puts "stored the value!" }
-      #
-      def set key, val, exptime = 0, &cb
-        callback{
-          val = val.to_s
-          send_cmd :set, key, 0, exptime, val.respond_to?(:bytesize) ? val.bytesize : val.size, !block_given?
-          send_data val
-          send_data Cdelimiter
-          @set_cbs << cb if cb
-        }
-      end
-
-      # Gets multiple values as a hash
-      #
-      #  cache.get_hash(:a, :b, :c, :d){ |h| puts h[:a] }
-      #
-      def get_hash *keys
-        raise ArgumentError unless block_given?
-
-        get *keys do |*values|
-          yield keys.inject({}){ |hash, k| hash.update k => values[keys.index(k)] }
-        end
-      end
-
-      # Delete the value associated with a key
-      #
-      #  cache.del :a
-      #  cache.del(:b){ puts "deleted the value!" }
-      #
-      def delete key, expires = 0, &cb
-        callback{
-          send_data "delete #{key} #{expires}#{cb ? '' : ' noreply'}\r\n"
-          @del_cbs << cb if cb
-        }
-      end
-      alias del delete
-
-      # Connect to a memcached server (must support NOREPLY, memcached >= 1.2.4)
-      def self.connect host = 'localhost', port = 11211
-        EM.connect host, port, self, host, port
-      end
-
-      # :stopdoc:
-
-      def send_cmd cmd, key, flags = 0, exptime = 0, bytes = 0, noreply = false # :nodoc:
-        send_data "#{cmd} #{key} #{flags} #{exptime} #{bytes}#{noreply ? ' noreply' : ''}\r\n"
-      end
-      private :send_cmd
-
-      ##
-      # errors
-
-      class ParserError < StandardError
-      end
-
-      ##
-      # em hooks
-
-      def initialize host, port = 11211
-        @host, @port = host, port
-      end
-
-      def connection_completed
-        @get_cbs = []
-        @set_cbs = []
-        @del_cbs = []
-
-        @values = {}
-
-        @reconnecting = false
-        @connected = true
-        succeed
-        # set_delimiter "\r\n"
-        # set_line_mode
-      end
-
-      #--
-      # 19Feb09 Switched to a custom parser, LineText2 is recursive and can cause
-      #         stack overflows when there is too much data.
-      # include EM::P::LineText2
-      def receive_data data
-        (@buffer||='') << data
-
-        while index = @buffer.index(Cdelimiter)
-          begin
-            line = @buffer.slice!(0,index+2)
-            process_cmd line
-          rescue ParserError
-            @buffer[0...0] = line
-            break
-          end
-        end
-      end
-
-      #--
-      # def receive_line line
-      def process_cmd line
-        case line.strip
-        when /^VALUE\s+(.+?)\s+(\d+)\s+(\d+)/ # VALUE <key> <flags> <bytes>
-          bytes = Integer($3)
-          # set_binary_mode bytes+2
-          # @cur_key = $1
-          if @buffer.size >= bytes + 2
-            @values[$1] = @buffer.slice!(0,bytes)
-            @buffer.slice!(0,2) # \r\n
-          else
-            raise ParserError
-          end
-
-        when Cend # END
-          if entry = @get_cbs.shift
-            keys, cb = entry
-            cb.call(@values)
-          end
-          @values = {}
-
-        when Cstored # STORED
-          if cb = @set_cbs.shift
-            cb.call(true)
-          end
-
-        when Cdeleted # DELETED
-          if cb = @del_cbs.shift
-            cb.call(true)
-          end
-
-        when Cunknown # NOT_FOUND
-          if cb = @del_cbs.shift
-            cb.call(false)
-          end
-
-        else
-          p [:MEMCACHE_UNKNOWN, line]
-        end
-      end
-
-      #--
-      # def receive_binary_data data
-      #   @values[@cur_key] = data[0..-3]
-      # end
-
-      def unbind
-        if @connected or @reconnecting
-          EM.add_timer(1){ reconnect @host, @port }
-          @connected = false
-          @reconnecting = true
-          @deferred_status = nil
-        else
-          raise 'Unable to connect to memcached server'
-        end
-      end
-
-      # :startdoc:
-    end
-  end
-end
-
-if __FILE__ == $0
-  # ruby -I ext:lib -r eventmachine -rubygems lib/protocols/memcache.rb
-  require 'em/spec'
-
-  class TestConnection # :nodoc:
-    include EM::P::Memcache
-    def send_data data
-      sent_data << data
-    end
-    def sent_data
-      @sent_data ||= ''
-    end
-
-    def initialize
-      connection_completed
-    end
-  end
-
-  EM.describe EM::Protocols::Memcache do
-
-    before{
-      @c = TestConnection.new
-    }
-
-    should 'send get requests' do
-      @c.get('a'){}
-      @c.sent_data.should == "get a\r\n"
-      done
-    end
-
-    should 'send set requests' do
-      @c.set('a', 1){}
-      @c.sent_data.should == "set a 0 0 1\r\n1\r\n"
-      done
-    end
-
-    should 'use noreply on set without block' do
-      @c.set('a', 1)
-      @c.sent_data.should == "set a 0 0 1 noreply\r\n1\r\n"
-      done
-    end
-
-    should 'send delete requests' do
-      @c.del('a')
-      @c.sent_data.should == "delete a 0 noreply\r\n"
-      done
-    end
-
-    should 'work when get returns no values' do
-      @c.get('a'){ |a|
-        a.should.be.nil
-        done
-      }
-
-      @c.receive_data "END\r\n"
-    end
-
-    should 'invoke block on set' do
-      @c.set('a', 1){
-        done
-      }
-
-      @c.receive_data "STORED\r\n"
-    end
-
-    should 'invoke block on delete' do
-      @c.delete('a'){ |found|
-        found.should.be.false
-      }
-      @c.delete('b'){ |found|
-        found.should.be.true
-        done
-      }
-
-      @c.receive_data "NOT_FOUND\r\n"
-      @c.receive_data "DELETED\r\n"
-    end
-
-    should 'parse split responses' do
-      @c.get('a'){ |a|
-        a.should == 'abc'
-        done
-      }
-
-      @c.receive_data "VAL"
-      @c.receive_data "UE a 0 "
-      @c.receive_data "3\r\n"
-      @c.receive_data "ab"
-      @c.receive_data "c"
-      @c.receive_data "\r\n"
-      @c.receive_data "EN"
-      @c.receive_data "D\r\n"
-    end
-
-  end
-end

data/lib/ext/eventmachine-0.12.10/lib/em/protocols/object_protocol.rb

@@ -1,45 +0,0 @@
-module EventMachine
-  module Protocols
-    # ObjectProtocol allows for easy communication using marshaled ruby objects
-    #
-    #  module RubyServer
-    #    include EM::P::ObjectProtocol
-    #
-    #    def receive_object obj
-    #      send_object({'you said' => obj})
-    #    end
-    #  end
-    #
-    module ObjectProtocol
-      # By default returns Marshal, override to return JSON or YAML, or any
-      # other serializer/deserializer responding to #dump and #load.
-      def serializer
-        Marshal
-      end
-
-      def receive_data data # :nodoc:
-        (@buf ||= '') << data
-
-        while @buf.size >= 4
-          if @buf.size >= 4+(size=@buf.unpack('N').first)
-            @buf.slice!(0,4)
-            receive_object serializer.load(@buf.slice!(0,size))
-          else
-            break
-          end
-        end
-      end
-
-      # Invoked with ruby objects received over the network
-      def receive_object obj
-        # stub
-      end
-
-      # Sends a ruby object over the network
-      def send_object obj
-        data = serializer.dump(obj)
-        send_data [data.respond_to?(:bytesize) ? data.bytesize : data.size, data].pack('Na*')
-      end
-    end
-  end
-end