packet 0.1.0 → 0.1.1

data/lib/buftok.rb

@@ -1,127 +0,0 @@
-# BufferedTokenizer - Statefully split input data by a specifiable token
-#
-# Authors:: Tony Arcieri, Martin Emde
-#
-#----------------------------------------------------------------------------
-#
-# Copyright (C) 2006-07 by Tony Arcieri and Martin Emde
-# 
-# Distributed under the Ruby license (http://www.ruby-lang.org/en/LICENSE.txt)
-#
-#---------------------------------------------------------------------------
-#
-
-# (C)2006 Tony Arcieri, Martin Emde
-# Distributed under the Ruby license (http://www.ruby-lang.org/en/LICENSE.txt)
-
-# BufferedTokenizer takes a delimiter upon instantiation, or acts line-based
-# by default.  It allows input to be spoon-fed from some outside source which
-# receives arbitrary length datagrams which may-or-may-not contain the token
-# by which entities are delimited.
-
-class BufferedTokenizer
-  # New BufferedTokenizers will operate on lines delimited by "\n" by default
-  # or allow you to specify any delimiter token you so choose, which will then
-  # be used by String#split to tokenize the input data
-  def initialize(delimiter = "\n", size_limit = nil)
-    # Store the specified delimiter
-    @delimiter = delimiter
-
-    # Store the specified size limitation
-    @size_limit = size_limit
-
-    # The input buffer is stored as an array.  This is by far the most efficient
-    # approach given language constraints (in C a linked list would be a more
-    # appropriate data structure).  Segments of input data are stored in a list
-    # which is only joined when a token is reached, substantially reducing the
-    # number of objects required for the operation.
-    @input = []
-
-    # Size of the input buffer
-    @input_size = 0
-  end
-
-  # Extract takes an arbitrary string of input data and returns an array of
-  # tokenized entities, provided there were any available to extract.  This
-  # makes for easy processing of datagrams using a pattern like:
-  #
-  #   tokenizer.extract(data).map { |entity| Decode(entity) }.each do ...
-  def extract(data)
-    # Extract token-delimited entities from the input string with the split command.
-    # There's a bit of craftiness here with the -1 parameter.  Normally split would
-    # behave no differently regardless of if the token lies at the very end of the 
-    # input buffer or not (i.e. a literal edge case)  Specifying -1 forces split to
-    # return "" in this case, meaning that the last entry in the list represents a
-    # new segment of data where the token has not been encountered
-    entities = data.split @delimiter, -1
-
-    # Check to see if the buffer has exceeded capacity, if we're imposing a limit
-    if @size_limit
-      raise 'input buffer full' if @input_size + entities.first.size > @size_limit
-      @input_size += entities.first.size
-    end
-    
-    # Move the first entry in the resulting array into the input buffer.  It represents
-    # the last segment of a token-delimited entity unless it's the only entry in the list.
-    @input << entities.shift
-
-    # If the resulting array from the split is empty, the token was not encountered
-    # (not even at the end of the buffer).  Since we've encountered no token-delimited
-    # entities this go-around, return an empty array.
-    return [] if entities.empty?
-
-    # At this point, we've hit a token, or potentially multiple tokens.  Now we can bring
-    # together all the data we've buffered from earlier calls without hitting a token,
-    # and add it to our list of discovered entities.
-    entities.unshift @input.join
-
-=begin
-	# Note added by FC, 10Jul07. This paragraph contains a regression. It breaks
-	# empty tokens. Think of the empty line that delimits an HTTP header. It will have
-	# two "\n" delimiters in a row, and this code mishandles the resulting empty token.
-	# It someone figures out how to fix the problem, we can re-enable this code branch.
-    # Multi-character token support.
-    # Split any tokens that were incomplete on the last iteration buf complete now.
-    entities.map! do |e|
-      e.split @delimiter, -1
-    end
-    # Flatten the resulting array.  This has the side effect of removing the empty
-    # entry at the end that was produced by passing -1 to split.  Add it again if
-    # necessary.
-    if (entities[-1] == [])
-      entities.flatten! << []
-    else
-      entities.flatten!
-    end
-=end
-
-    # Now that we've hit a token, joined the input buffer and added it to the entities
-    # list, we can go ahead and clear the input buffer.  All of the segments that were
-    # stored before the join can now be garbage collected.
-    @input.clear
-    
-    # The last entity in the list is not token delimited, however, thanks to the -1
-    # passed to split.  It represents the beginning of a new list of as-yet-untokenized  
-    # data, so we add it to the start of the list.
-    @input << entities.pop
-    
-    # Set the new input buffer size, provided we're keeping track
-    @input_size = @input.first.size if @size_limit
-
-    # Now we're left with the list of extracted token-delimited entities we wanted
-    # in the first place.  Hooray!
-    entities
-  end
-  
-  # Flush the contents of the input buffer, i.e. return the input buffer even though
-  # a token has not yet been encountered
-  def flush
-    buffer = @input.join
-    @input.clear
-    buffer
-  end
-
-  def empty?
-    @input.empty?
-  end
-end

data/lib/cpu_worker.rb

@@ -1,19 +0,0 @@
-module Packet
-  class CPUWorker < Packet::Worker
-    @@worker_type = 'cpu'
-    cattr_accessor :worker_type
-    # this is the place where all the worker specific inititlization has to be done
-    def worker_init
-      @worker_started = true
-    end
-
-    def receive_data p_data
-      p p_data
-    end
-
-    def receive_internal_data p_data
-      p p_data
-    end
-
-  end
-end

data/lib/deferrable.rb

@@ -1,210 +0,0 @@
-# $Id: deferrable.rb 534 2007-09-15 23:06:15Z blackhedd $
-#
-# Author:: Francis Cianfrocca (gmail: blackhedd)
-# Homepage::  http://rubyeventmachine.com
-# Date:: 16 Jul 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.
-#
-#---------------------------------------------------------------------------
-#
-#
-
-# FIXME: Packet doesn't support timers on Deferables yet
-
-require 'forwardable'
-
-module Packet
-
-  module Deferrable
-
-    # Specify a block to be executed if and when the Deferrable object receives
-    # a status of :succeeded. See #set_deferred_status for more information.
-    #
-    # Calling this method on a Deferrable object whose status is not yet known
-    # will cause the callback block to be stored on an internal list.
-    # If you call this method on a Deferrable whose status is :succeeded, the
-    # block will be executed immediately, receiving the parameters given to the
-    # prior #set_deferred_status call.
-    #
-    #--
-    # If there is no status, add a callback to an internal list.
-    # If status is succeeded, execute the callback immediately.
-    # If status is failed, do nothing.
-    #
-    def callback &block
-      return unless block
-      if @deferred_status == :succeeded
-        block.call(*@deferred_args)
-      elsif @deferred_status != :failed
-        @callbacks ||= []
-        @callbacks.unshift block # << block
-      end
-    end
-
-    # Specify a block to be executed if and when the Deferrable object receives
-    # a status of :failed. See #set_deferred_status for more information.
-    #--
-    # If there is no status, add an errback to an internal list.
-    # If status is failed, execute the errback immediately.
-    # If status is succeeded, do nothing.
-    #
-    def errback &block
-      return unless block
-      if @deferred_status == :failed
-        block.call(*@deferred_args)
-      elsif @deferred_status != :succeeded
-        @errbacks ||= []
-        @errbacks.unshift block # << block
-      end
-    end
-
-    # Sets the "disposition" (status) of the Deferrable object. See also the large set of
-    # sugarings for this method.
-    # Note that if you call this method without arguments,
-    # no arguments will be passed to the callback/errback.
-    # If the user has coded these with arguments, then the
-    # user code will throw an argument exception.
-    # Implementors of deferrable classes <b>must</b>
-    # document the arguments they will supply to user callbacks.
-    #
-    # OBSERVE SOMETHING VERY SPECIAL here: you may call this method even
-    # on the INSIDE of a callback. This is very useful when a previously-registered
-    # callback wants to change the parameters that will be passed to subsequently-registered
-    # ones.
-    #
-    # You may give either :succeeded or :failed as the status argument.
-    #
-    # If you pass :succeeded, then all of the blocks passed to the object using the #callback
-    # method (if any) will be executed BEFORE the #set_deferred_status method returns. All of the blocks
-    # passed to the object using #errback will be discarded.
-    #
-    # If you pass :failed, then all of the blocks passed to the object using the #errback
-    # method (if any) will be executed BEFORE the #set_deferred_status method returns. All of the blocks
-    # passed to the object using # callback will be discarded.
-    #
-    # If you pass any arguments to #set_deferred_status in addition to the status argument,
-    # they will be passed as arguments to any callbacks or errbacks that are executed.
-    # It's your responsibility to ensure that the argument lists specified in your callbacks and
-    # errbacks match the arguments given in calls to #set_deferred_status, otherwise Ruby will raise
-    # an ArgumentError.
-    #
-    # --
-    # We're shifting callbacks off and discarding them as we execute them.
-    # This is valid because by definition callbacks are executed no more than
-    # once. It also has the magic effect of permitting recursive calls, which
-    # means that a callback can call #set_deferred_status and change the parameters
-    # that will be sent to subsequent callbacks down the chain.
-    #
-    # Changed @callbacks and @errbacks from push/shift to unshift/pop, per suggestion
-    # by Kirk Haines, to work around the memory leak bug that still exists in many Ruby
-    # versions.
-    #
-    # Changed 15Sep07: after processing callbacks or errbacks, CLEAR the other set of
-    # handlers. This gets us a little closer to the behavior of Twisted's "deferred,"
-    # which only allows status to be set once. Prior to making this change, it was possible
-    # to "succeed" a Deferrable (triggering its callbacks), and then immediately "fail" it,
-    # triggering its errbacks! That is clearly undesirable, but it's just as undesirable
-    # to raise an exception is status is set more than once on a Deferrable. The latter
-    # behavior would invalidate the idiom of resetting arguments by setting status from
-    # within a callback or errback, but more seriously it would cause spurious errors
-    # if a Deferrable was timed out and then an attempt was made to succeed it. See the
-    # comments under the new method #timeout.
-    #
-    def set_deferred_status status, *args
-      #cancel_timeout
-      @deferred_status = status
-      @deferred_args = args
-      case @deferred_status
-      when :succeeded
-        if @callbacks
-          while cb = @callbacks.pop
-            cb.call(*@deferred_args)
-          end
-        end
-        @errbacks.clear if @errbacks
-      when :failed
-        if @errbacks
-          while eb = @errbacks.pop
-            eb.call(*@deferred_args)
-          end
-        end
-        @callbacks.clear if @callbacks
-      end
-    end
-
-
-    # Setting a timeout on a Deferrable causes it to go into the failed state after
-    # the Timeout expires (passing no arguments to the object's errbacks).
-    # Setting the status at any time prior to a call to the expiration of the timeout
-    # will cause the timer to be cancelled.
-    #--
-    #
-    #
-    def timeout seconds
-      cancel_timeout
-      me = self
-      @deferred_timeout = EventMachine::Timer.new(seconds) {me.fail}
-    end
-
-
-    # Cancels an outstanding timeout if any. Undoes the action of #timeout.
-    #
-    #
-    def cancel_timeout
-      if @deferred_timeout
-        @deferred_timeout.cancel
-        @deferred_timeout = nil
-      end
-    end
-
-
-    # Equivalent to set_deferred_status(:succeeded, ...)
-    #
-    def set_deferred_success *args
-      set_deferred_status :succeeded, *args
-    end
-
-    # Equivalent to set_deferred_status(:failed, ...)
-    #
-    def set_deferred_failure *args
-      set_deferred_status :failed, *args
-    end
-
-    # And still more sugar
-    #
-    def succeed *args
-      set_deferred_success(*args)
-    end
-
-    # Can't get enough sugar
-    #
-    def fail *args
-      set_deferred_failure(*args)
-    end
-  end
-
-
-  # DefaultDeferrable is an otherwise empty class that includes Deferrable.
-  # This is very useful when you just need to return a Deferrable object
-  # as a way of communicating deferred status to some other part of a program.
-  #
-  class DefaultDeferrable
-    include Deferrable
-  end
-
-end
-

data/lib/io_worker.rb

@@ -1,6 +0,0 @@
-module Packet
-  class IOWorker < Packet::Worker
-    @@worker_type = :io
-    cattr_accessor :worker_type
-  end
-end

data/lib/ruby_hacks.rb

@@ -1,125 +0,0 @@
-# FIXME: ultimate goal should be remove dependence from activesupport gem altogether.
-
-class Object
-  def deep_copy
-    Marshal.load(Marshal.dump(self))
-  end
-
-  def nothing?
-    if respond_to?(:empty?) && respond_to?(:strip)
-      empty? or strip.empty?
-    elsif respond_to?(:empty?)
-      empty?
-    elsif respond_to?(:zero?)
-      zero?
-    else
-      !self
-    end
-  end
-
-  def clean!
-    if respond_to?(:empty?) && respond_to?(:strip)
-      return nil if empty?
-      (strip.empty?) ? nil : (self.strip)
-    elsif respond_to?(:empty?)
-      empty? ? nil : self
-    else
-      self
-    end
-  end
-
-  def blank?
-    if respond_to?(:empty?) && respond_to?(:strip)
-      empty? or strip.empty?
-    elsif respond_to?(:empty?)
-      empty?
-    else
-      !self
-    end
-  end
-
-  def self.metaclass; class << self; self; end; end
-
-  def self.iattr_accessor *args
-
-    metaclass.instance_eval do
-      attr_accessor *args
-      args.each do |attr|
-        define_method("set_#{attr}") do |b_value|
-          self.send("#{attr}=",b_value)
-        end
-      end
-    end
-
-    args.each do |attr|
-      class_eval do
-        define_method(attr) do
-          self.class.send(attr)
-        end
-        define_method("#{attr}=") do |b_value|
-          self.class.send("#{attr}=",b_value)
-        end
-      end
-    end
-  end
-end
-
-
-class NilClass #:nodoc:
-  def blank?
-    true
-  end
-end
-
-class FalseClass #:nodoc:
-  def blank?
-    true
-  end
-end
-
-class TrueClass #:nodoc:
-  def blank?
-    false
-  end
-end
-
-class Array #:nodoc:
-  alias_method :blank?, :empty?
-  def clean!
-    (empty?) ? nil : self
-  end
-
-  def extract_options!
-    last.is_a?(Hash) ? pop : {}
-  end
-end
-
-class Hash #:nodoc:
-  alias_method :blank?, :empty?
-  def clean!
-    (empty?) ? nil : self
-  end
-end
-
-class String #:nodoc:
-  def blank?
-    empty? || strip.empty?
-  end
-
-  def clean!
-    return nil if empty?
-    t_val = self.strip
-    (t_val.empty?) ? nil : t_val
-  end
-
-  def classify
-    word_parts = split('_')
-    return word_parts.map { |x| x.capitalize}.join
-  end
-end
-
-class Numeric #:nodoc:
-  def blank?
-    false
-  end
-end