eventmachine 0.12.8-x86-mswin32-60 → 0.12.10-x86-mswin32-60

data/lib/em/protocols/line_and_text.rb

@@ -1,126 +1,125 @@
-#--
-#
-# 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.
-#
-#---------------------------------------------------------------------------
-#
-# 
-# 
-require File.dirname(__FILE__) + '/../buftok'
-
-module EventMachine
-  module Protocols
-    # A protocol that handles line-oriented data with interspersed binary text.
-    #
-    # This version is optimized for performance. See EventMachine::Protocols::LineText2
-    # for a version which is optimized for correctness with regard to binary text blocks
-    # that can switch back to line mode.
-    class LineAndTextProtocol < Connection
-      MaxLineLength = 16*1024
-      MaxBinaryLength = 32*1024*1024
-
-      def initialize *args
-        super
-        lbp_init_line_state
-      end
-      def receive_data data
-        if @lbp_mode == :lines
-          begin
-            @lpb_buffer.extract(data).each do |line| 
-              receive_line(line.chomp) if respond_to?(:receive_line)
-            end
-          rescue Exception
-            receive_error('overlength line') if respond_to?(:receive_error)
-            close_connection
-            return
-          end
-        else
-          if @lbp_binary_limit > 0
-            wanted = @lbp_binary_limit - @lbp_binary_bytes_received
-            chunk = nil
-            if data.length > wanted
-              chunk = data.slice!(0...wanted)
-            else
-              chunk = data
-              data = ""
-            end
-            @lbp_binary_buffer[@lbp_binary_bytes_received...(@lbp_binary_bytes_received+chunk.length)] = chunk
-            @lbp_binary_bytes_received += chunk.length
-            if @lbp_binary_bytes_received == @lbp_binary_limit
-              receive_binary_data(@lbp_binary_buffer) if respond_to?(:receive_binary_data)
-              lbp_init_line_state
-            end
-            receive_data(data) if data.length > 0
-          else
-            receive_binary_data(data) if respond_to?(:receive_binary_data)
-            data = ""
-          end
-        end
-      end
-
-      def unbind
-        if @lbp_mode == :binary and @lbp_binary_limit > 0
-          if respond_to?(:receive_binary_data)
-            receive_binary_data( @lbp_binary_buffer[0...@lbp_binary_bytes_received] )
-          end
-        end
-      end
-
-      # Set up to read the supplied number of binary bytes.
-      # This recycles all the data currently waiting in the line buffer, if any.
-      # If the limit is nil, then ALL subsequent data will be treated as binary
-      # data and passed to the upstream protocol handler as we receive it.
-      # If a limit is given, we'll hold the incoming binary data and not
-      # pass it upstream until we've seen it all, or until there is an unbind
-      # (in which case we'll pass up a partial).
-      # Specifying nil for the limit (the default) means there is no limit.
-      # Specifiyng zero for the limit will cause an immediate transition back to line mode.
-      #
-      def set_binary_mode size = nil
-        if @lbp_mode == :lines
-          if size == 0
-            receive_binary_data("") if respond_to?(:receive_binary_data)
-            # Do no more work here. Stay in line mode and keep consuming data.
-          else
-            @lbp_binary_limit = size.to_i # (nil will be stored as zero)
-            if @lbp_binary_limit > 0
-              raise "Overlength" if @lbp_binary_limit > MaxBinaryLength # arbitrary sanity check
-              @lbp_binary_buffer = "\0" * @lbp_binary_limit
-              @lbp_binary_bytes_received = 0
-            end
-
-            @lbp_mode = :binary
-            receive_data @lpb_buffer.flush
-          end
-        else
-          raise "invalid operation"
-        end
-      end
-
-      #--
-      # For internal use, establish protocol baseline for handling lines.
-      def lbp_init_line_state
-        @lpb_buffer = BufferedTokenizer.new("\n", MaxLineLength)
-        @lbp_mode = :lines
-      end
-      private :lbp_init_line_state
-    end
-  end
-end
+#--
+#
+# 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
+    # A protocol that handles line-oriented data with interspersed binary text.
+    #
+    # This version is optimized for performance. See EventMachine::Protocols::LineText2
+    # for a version which is optimized for correctness with regard to binary text blocks
+    # that can switch back to line mode.
+    class LineAndTextProtocol < Connection
+      MaxLineLength = 16*1024
+      MaxBinaryLength = 32*1024*1024
+
+      def initialize *args
+        super
+        lbp_init_line_state
+      end
+      def receive_data data
+        if @lbp_mode == :lines
+          begin
+            @lpb_buffer.extract(data).each do |line| 
+              receive_line(line.chomp) if respond_to?(:receive_line)
+            end
+          rescue Exception
+            receive_error('overlength line') if respond_to?(:receive_error)
+            close_connection
+            return
+          end
+        else
+          if @lbp_binary_limit > 0
+            wanted = @lbp_binary_limit - @lbp_binary_bytes_received
+            chunk = nil
+            if data.length > wanted
+              chunk = data.slice!(0...wanted)
+            else
+              chunk = data
+              data = ""
+            end
+            @lbp_binary_buffer[@lbp_binary_bytes_received...(@lbp_binary_bytes_received+chunk.length)] = chunk
+            @lbp_binary_bytes_received += chunk.length
+            if @lbp_binary_bytes_received == @lbp_binary_limit
+              receive_binary_data(@lbp_binary_buffer) if respond_to?(:receive_binary_data)
+              lbp_init_line_state
+            end
+            receive_data(data) if data.length > 0
+          else
+            receive_binary_data(data) if respond_to?(:receive_binary_data)
+            data = ""
+          end
+        end
+      end
+
+      def unbind
+        if @lbp_mode == :binary and @lbp_binary_limit > 0
+          if respond_to?(:receive_binary_data)
+            receive_binary_data( @lbp_binary_buffer[0...@lbp_binary_bytes_received] )
+          end
+        end
+      end
+
+      # Set up to read the supplied number of binary bytes.
+      # This recycles all the data currently waiting in the line buffer, if any.
+      # If the limit is nil, then ALL subsequent data will be treated as binary
+      # data and passed to the upstream protocol handler as we receive it.
+      # If a limit is given, we'll hold the incoming binary data and not
+      # pass it upstream until we've seen it all, or until there is an unbind
+      # (in which case we'll pass up a partial).
+      # Specifying nil for the limit (the default) means there is no limit.
+      # Specifiyng zero for the limit will cause an immediate transition back to line mode.
+      #
+      def set_binary_mode size = nil
+        if @lbp_mode == :lines
+          if size == 0
+            receive_binary_data("") if respond_to?(:receive_binary_data)
+            # Do no more work here. Stay in line mode and keep consuming data.
+          else
+            @lbp_binary_limit = size.to_i # (nil will be stored as zero)
+            if @lbp_binary_limit > 0
+              raise "Overlength" if @lbp_binary_limit > MaxBinaryLength # arbitrary sanity check
+              @lbp_binary_buffer = "\0" * @lbp_binary_limit
+              @lbp_binary_bytes_received = 0
+            end
+
+            @lbp_mode = :binary
+            receive_data @lpb_buffer.flush
+          end
+        else
+          raise "invalid operation"
+        end
+      end
+
+      #--
+      # For internal use, establish protocol baseline for handling lines.
+      def lbp_init_line_state
+        @lpb_buffer = BufferedTokenizer.new("\n", MaxLineLength)
+        @lbp_mode = :lines
+      end
+      private :lbp_init_line_state
+    end
+  end
+end

data/lib/em/protocols/linetext2.rb

@@ -1,160 +1,161 @@
-#--
-#
-# 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
-        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
-
+#--
+#
+# 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
+