Sipper 1.1.3

data/sipper/ruby_ext/module.rb

@@ -0,0 +1,27 @@
+# Extension for finding class names from a string with class definition
+class Module
+  def all_class_names
+    class_names = []
+    constants.each do |const_name|
+      const = const_get(const_name)
+      case const
+      when Class
+        class_names << const.to_s.split(/::/,2)[1]
+      when Module
+        class_names += const.all_class_names
+      end
+    end
+    class_names.uniq
+  end
+  
+  # Extension to allow for snap_fields directive in the class of which snapshot is to be
+  # taken. This creates a method by name __snap_fields used by snapshot.rb in the class
+  # being snapshotted. 
+  def snap_fields(*symbols)
+    str = "["
+    symbols.each {|s| str << ":" << s.to_s <<  "," }
+    str << "]"
+    module_eval("def __snap_fields() #{str}; end")
+  end
+ 
+end

data/sipper/ruby_ext/mutable_class.rb

@@ -0,0 +1,17 @@
+class NilClass
+  def dup
+    self
+  end
+end
+
+class TrueClass
+  def dup
+    self
+  end
+end
+
+class FalseClass
+  def dup
+    self
+  end
+end

data/sipper/ruby_ext/object.rb

@@ -0,0 +1,38 @@
+
+# Extension to flatten the classname to make it amenable
+# to logging.
+
+class Object
+  def class_name
+    begin
+      self.classname
+    rescue NoMethodError
+      name = self.class.name.split("::").join("_")
+      self.class.class_eval do
+        define_method(:classname) {
+          name
+        }
+      end
+      retry
+    end #rescue
+  end  #method
+  
+  
+  def is_request?
+    self.class == Request
+  end
+  
+  def is_response?
+    self.class == Response
+  end
+  
+  # clears the given instance variables as symbols arrays
+  # e.g  o.clear_ivs([:@a, :@b]) sets the instance variable @a and @b to nil
+  # in the object o. 
+  def clear_ivs(arr)
+    arr.each do |i|
+      instance_variable_set(i, nil)
+    end
+  end
+  
+end

data/sipper/ruby_ext/pqueue.rb

@@ -0,0 +1,190 @@
+# = pqueue.rb
+#
+# == Copyright (c) 2005 K.Kodama
+#
+#   GNU General Public License
+#
+#   This program is free software; you can redistribute it and/or modify
+#   it under the terms of 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.
+#
+#   This program is distributed in the hope that it will be useful, but
+#   WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#   General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with this program; if not, write to the Free Software
+#   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+#
+# == Special Thanks
+#
+# Rick Bradley 2003/02/02, patch for Ruby 1.6.5. Thank you!
+#
+# == Author(s)
+#
+# * K.Kodama
+
+# Author::    K.Kodama
+# Copyright:: Copyright (c) 2005 K.Kodama
+# License::   Ruby License
+
+# = PQueue
+#
+# Priority queue with array based heap.
+
+class PQueue
+
+  attr_accessor :qarray # format: [nil, e1, e2, ..., en]
+  attr_reader :size # number of elements
+  attr_reader :gt # compareProc
+
+  def initialize(compareProc=lambda{|x,y| x>y})
+    # By default, retrieves maximal elements first. 
+    @qarray=[nil]; @size=0; @gt=compareProc; make_legal
+  end
+  private :initialize
+
+  def upheap(k)
+    k2=k.div(2); v=@qarray[k];
+    while ((k2>0)and(@gt[v,@qarray[k2]]));
+      @qarray[k]=@qarray[k2]; k=k2; k2=k2.div(2)
+    end;
+    @qarray[k]=v;
+  end
+  private :upheap
+
+  def downheap(k)
+    v=@qarray[k]; q2=@size.div(2)
+    loop{
+      if (k>q2); break; end;
+      j=k+k; if ((j<@size)and(@gt[@qarray[j+1],@qarray[j]])); j=j+1; end;
+      if @gt[v,@qarray[j]]; break; end;
+      @qarray[k]=@qarray[j]; k=j;
+    }
+    @qarray[k]=v;
+  end;
+  private :downheap
+
+  def make_legal
+    for k in 2..@size do; upheap(k); end;
+  end;
+
+  def empty?
+    return (0==@size)
+  end
+
+  def clear
+    @qarray.replace([nil]); @size=0;
+  end;
+
+  def replace_array(arr=[])
+    # Use push_array.
+    @qarray.replace([nil]+arr); @size=arr.size; make_legal
+  end;
+
+  def clone
+    q=new; q.qarray=@qarray.clone; q.size=@size; q.gt=@gt; return q;
+  end;
+
+  def push(v)
+    @size=@size+1; @qarray[@size]=v; upheap(@size);
+  end;
+
+  def push_array(arr=[])
+    @qarray[@size+1,arr.size]=arr; arr.size.times{@size+=1; upheap(@size)}
+  end;
+
+  def pop
+    # return top element.  nil if queue is empty.
+    if @size>0;
+      res=@qarray[1]; @qarray[1]=@qarray[@size]; @size=@size-1;
+      downheap(1);
+      return res;
+    else return nil
+    end;
+  end;
+
+  def pop_array(n=@size)
+    # return top n-element as an sorted array. (i.e. The obtaining array is decreasing order.)
+    # See also to_a.
+    a=[]
+    n.times{a.push(pop)}
+    return a
+  end;
+
+  def to_a
+    # array sorted as increasing order.
+    # See also pop_array.
+    res=@qarray[1..@size];
+    res.sort!{|x,y| if @gt[x,y]; 1;elsif @gt[y,x]; -1; else 0; end;}
+    return res
+  end
+
+  def top
+    # top element. not destructive.
+    if @size>0; return @qarray[1]; else return nil; end;
+  end;
+
+  def replace_top_low(v)
+    # replace top element if v<top element.
+    if @size>0; @qarray[0]=v; downheap(0); return @qarray[0];
+    else @qarray[1]=v; return nil;
+    end;
+  end;
+
+  def replace_top(v)
+    # replace top element
+    if @size>0; res=@qarray[1]; @qarray[1]=v; downheap(1); return res;
+    else @qarray[1]=v; return nil;
+    end;
+  end;
+
+  def each_pop
+    # iterate pop. destructive. Use as self.each_pop{|x| ... }. 
+    while(@size>0); yield self.pop; end;
+  end;
+
+  def each_with_index
+    # Not ordered. Use as self.each_with_index{|e,i| ... }. 
+    for i in 1..@size do; yield @qarray[i],i; end;
+  end
+
+end # class PQueue
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin test
+
+  require 'test/unit'
+
+  # TODO Expand on these tests.
+
+  class TC01 < Test::Unit::TestCase
+
+    def setup
+      @pq=PQueue.new(proc{|x,y| x>y})
+    end
+
+    def test_01
+      @pq.push(2)
+      @pq.push(3)
+      @pq.push(4)
+      @pq.push(3)
+      @pq.push(2)
+      @pq.push(4)
+      @pq.push_array([3,5,4])
+      assert_equal( 9, @pq.size )
+      assert_equal( [2, 2, 3, 3, 3, 4, 4, 4, 5], @pq.to_a )
+    end
+  end
+
+=end

data/sipper/ruby_ext/snapshot.rb

@@ -0,0 +1,201 @@
+# = snapshot.rb
+#
+# == Copyright (c) 2004 Michael Neumann
+#
+#   Ruby License
+#
+#   This module is free software. You may use, modify, and/or redistribute this
+#   software under the same terms as Ruby.
+#
+#   This program is distributed in the hope that it will be useful, but WITHOUT
+#   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+#   FOR A PARTICULAR PURPOSE.
+#
+# == Author(s)
+#
+# * Michael Neumann
+#
+# == Developer Notes
+#
+#   TODO Perhaps extend to offer multiple depths.
+#
+#   TODO Should key consitancy be enforced? Currently
+#        Struct's will have symobl keys while other classes
+#        will have string keys in the form of "@name".
+#
+#   TODO Add other core classes.
+#
+#   TODO Convert to Kernel#to_data ?
+
+# Author::    Michael Neumann
+# Copyright:: Copyright (c) 2004 Michael Neumann
+# License::   Ruby License
+
+# = Snapshot
+#
+# A lightweight single-depth object state capture.
+# The #take_snapshot method reads the object's state, 
+# which is generally it's collection of instance variables,
+# and returns them in a hash. The state can be restored
+# with #apply_snapshot.
+#
+# == Usage
+#
+#   Customer = Struct.new("Customer", :name, :address, :zip)
+#   joe = Customer.new( "Joe Pitare", "1115 Lila Ln.", 47634 )
+#
+#   # simple transactions
+#   joe_snap = joe.take_snapshot
+#   begin
+#     do_something_with( joe )
+#   rescue
+#     joe.apply_snapshot( joe_snap )
+#   end
+#
+#   joe_snap[:name]     => "Joe Pitare"
+#   joe_snap[:address]  => "1115 Lila Ln."
+#   joe_snap[:zip]      => 47634
+#
+# == Details
+#
+# Class Snapshot simply represents a collection of objects from
+# which snapshots were taken via their methods #take_snapshot.
+# It provides methods to add an object to a snapshot
+# (Snapshot#add) as well as to restore all objects
+# of the snapshot to their state stored in the snapshot (method
+# Snapshot#restore).
+#
+# In Wee, this class is used to backtracking the state of
+# components (or decorations/presenters). Components that want
+# an undo-facility to be implemented (triggered for example by
+# a browsers back-button), have to overwrite the
+# Wee::Component#backtrack_state method.
+
+class Snapshot
+  def initialize
+    @objects = Hash.new
+  end
+
+  def add(object)
+    oid = object.object_id
+    @objects[oid] = [object, object.take_snapshot] unless @objects.include?(oid)
+  end
+
+  def restore
+    @objects.each_value { |object, value| object.restore_snapshot(value) }
+  end
+end
+
+# Simplist form of a snapshot.
+#
+#module SnapshotMixin
+#  def take_snapshot() dup end
+#  def restore_snapshot(snap) replace(snap) end
+#end
+
+# Implements a value holder. In Wee this is useful for
+# backtracking the reference assigned to an instance variable
+# (not the object itself!). An example where this is used is the
+# <tt>@__decoration</tt> attribute of class Wee::Component.
+
+class Snapshot::ValueHolder
+  attr_accessor :value
+
+  def initialize(value=nil)
+    @value = value
+  end
+
+  def take_snapshot
+    @value
+  end
+
+  def restore_snapshot(value)
+    @value = value
+  end
+end
+
+
+#--
+# Extend some base classes of Ruby (Object, Array, String, Hash, 
+# Struct) for the two methods #take_snapshot and
+# #restore_snapshot, required by Snapshot.
+#++
+
+class Object
+  def take_snapshot
+    snap = Hash.new
+    fields = self.__snap_fields if self.respond_to? :__snap_fields
+    fields = instance_variables unless fields
+    fields.each do |iv|
+      snap[iv] = instance_variable_get(iv)
+    end
+    snap
+  end
+
+  def restore_snapshot(snap)
+    fields = self.__snap_fields if self.respond_to? :__snap_fields
+    fields = instance_variables unless fields
+    fields.each do |iv|
+      instance_variable_set(iv, snap[iv])
+    end
+  end
+end
+
+class Array
+  def take_snapshot() dup end
+  def restore_snapshot(snap) replace(snap) end
+end
+
+class String
+  def take_snapshot() dup end
+  def restore_snapshot(snap) replace(snap) end
+end
+
+class Hash
+  def take_snapshot() dup end
+  def restore_snapshot(snap) replace(snap) end
+end
+
+class Struct
+  def take_snapshot
+    snap = Hash.new
+    each_pair {|k,v| snap[k] = v}
+    snap
+  end
+
+  def restore_snapshot(snap)
+    snap.each_pair {|k,v| send(k.to_s + "=", v)} 
+  end
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin testing
+
+require 'test/unit'
+
+class TC_Snapshot < Test::Unit::TestCase
+
+  def setup
+    customer = Struct.new("Customer", :name, :address, :zip)
+    joe = customer.new( "Joe Pitare", "1115 Lila Ln.", 47634 )
+    @joe_snap = joe.take_snapshot
+  end
+
+  def test_storage
+    assert_equal( "Joe Pitare", @joe_snap[:name]  )
+    assert_equal( "1115 Lila Ln.", @joe_snap[:address] )
+    assert_equal( 47634, @joe_snap[:zip] )
+  end
+
+end
+
+=end
+