mack-facets 0.8.1 → 0.8.2

data/lib/gems/facets-2.4.5/lib/more/facets/snapshot.rb

@@ -0,0 +1,209 @@
+# = 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.
+#
+# == Todo
+#
+# * Perhaps extend to offer multiple depths.
+# * Should key consitancy be enforced? Currently
+#   Struct's will have symbol keys while other classes
+#   will have string keys in the form of "@name".
+# * Add other core classes.
+# * Convert to Kernel#to_data ?
+# * I've been thinking about renaming this to State.
+#
+# == Authors
+#
+# * Michael Neumann
+#
+# == Copying
+#
+# 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.
+
+# = 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 do
+      |object, value| object.restore_snapshot(value)
+    end
+  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
+    instance_variables.each do |iv|
+      snap[iv] = instance_variable_get(iv)
+    end
+    snap
+  end
+  
+  def to_data
+    task_snapshot
+  end
+
+  def restore_snapshot(snap)
+    instance_variables.each do |iv|
+      instance_variable_set(iv, snap[iv])
+    end
+  end
+
+  def from_data(snap)
+    restore_snapshot(snap)
+  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
+

data/lib/gems/facets-2.4.5/lib/more/facets/string/mask.rb

@@ -0,0 +1,278 @@
+require 'facets/functor'
+
+class String
+
+  # Create a mask.
+  def to_mask(re=nil)
+    Mask.new(self,re)
+  end
+
+  # = Mask
+  #
+  class Mask
+
+    ESC = "\032" # ASCII SUBSTITUTE
+
+  class << self
+
+    def [](string, re=nil)
+      new(string, re)
+    end
+
+    end # class<< self
+
+  protected
+
+    attr :string
+
+  private
+
+    def initialize(string, re=nil)
+      @string = string.dup
+      mask!(re) if re
+    end
+
+  public
+
+    def inspect ; string.inspect ; end
+    def to_s    ; string ; end
+
+    def [](*a)
+      string[*a]
+    end
+
+    def mask(re)
+      self.class.new(string,re)
+    end
+
+    def mask!(re)
+      string.gsub!(re){ |s| ESC * s.size }
+    end
+
+    # Mask subtraction. Where the characters are the same,
+    # the result is "empty", where they differ the result
+    # reflects the last string.
+    #
+    #     "abc..123"      "ab..789."
+    #   - "ab..789."    - "abc..123"
+    #     ----------      ----------
+    #     "....789."      "..c..123"
+    #
+    def -(other)
+      i = 0
+      o = ''
+      while i < string.size
+        if string[i,1] == other[i,1]
+          o << ESC
+        else
+          o << other[i,1]
+        end
+        i += 1
+      end
+      self.class.new(o)
+    end
+
+    # Mask ADD. As long as there is a value other
+    # then empty the character filters though.
+    # The last string takes precedence.
+    #
+    #     "abc..123"      "ab..789."
+    #   + "ab..789."    + "abc..123"
+    #     ----------      ----------
+    #     "abc.7893"      "abc.7123"
+    #
+    def +(other)
+      i = 0
+      o = ''
+      while i < string.size
+        if other[i,1] == ESC
+          o << string[i,1]
+        else
+          o << other[i,1]
+        end
+        i += 1
+      end
+      self.class.new(o)
+    end
+
+    # Mask OR is the same as ADD.
+    alias_method :|, :+
+
+    # Mask XAND. Where the characters are the same, the
+    # result is the same, where they differ the result
+    # reflects the later.
+    #
+    #     "abc..123"      "ab..789."
+    #   * "ab..789."    | "abc..123"
+    #     ----------      ----------
+    #     "ab..789."      "abc..123"
+    #
+    def *(other)
+      i = 0
+      o = ''
+      while i < string.size
+        if (c = string[i,1]) == other[i,1]
+          o << c
+        else
+          o << other[i,1]
+        end
+        i += 1
+      end
+      self.class.new(o)
+    end
+
+    # Mask AND. Only where they are
+    # then same filters through.
+    #
+    #     "abc..123"      "ab..789."
+    #   & "ab..789."    | "abc..123"
+    #     ----------      ----------
+    #     "ab......"      "ab......"
+    #
+    def &(other)
+      i = 0
+      o = ''
+      while i < string.size
+        if (c = string[i,1]) == other[i,1]
+          o << c
+        else
+          o << ESC
+        end
+        i += 1
+      end
+      self.class.new(o)
+    end
+
+    # Mask XOR operation. Only where there
+    # is an empty slot will the value filter.
+    #
+    #     "abc..123"      "ab..789."
+    #   | "ab..789."    | "abc..123"
+    #     ----------      ----------
+    #     "..c.7..3"      "..c.7..3"
+    #
+    def ^(other)
+      i = 0
+      o = ''
+      while i < string.size
+        if string[i,1] == ESC
+          o << other[i,1]
+        elsif other[i,1] == ESC
+          o << string[i,1]
+        else
+          o << ESC
+        end
+        i += 1
+      end
+      self.class.new(o)
+    end
+
+    #
+    def ==(other)
+      case other
+      when String::Mask
+        string == other.string
+      else
+        string == other.to_s
+      end
+    end
+
+    # Apply a method to the internal string
+    # and return a new mask.
+    def apply(s=nil,*a,&b)
+      if s
+        string.send(s,*a,&b).to_mask
+      else
+        @_self ||= Functor.new do |op, *a|
+          string.send(op,*a).to_mask
+        end
+      end
+    end
+
+    def replace(string)
+      @string = string.to_s
+    end
+
+    def instance_delegate
+      @string
+    end
+
+    # Functor on the interal string.
+    #def self
+    #  @_self ||= Functor.new do |op, *a|
+    #    @string = @string.send(op, *a)
+    #  end
+    #end
+
+    # Delegate any missing methods to underlying string.
+    #
+    def method_missing(s, *a, &b)
+      begin
+        str = string.send(s, *a, &b)
+      rescue NoMethodError
+        super(s, *a, &b)
+      end
+    end
+
+  end
+end
+
+
+=begin spec
+
+  require 'quarry/spec'
+
+  Quarry.spec "String::Mask" do
+
+    x1 = String::Mask["abc..123", '.']
+    x2 = String::Mask["ab..789.", '.']
+
+    verify "sub" do
+      r = x1 - x2
+      a = String::Mask["....789.", '.']
+      r.assert == a
+      r = x2 - x1
+      a = String::Mask["..c..123", '.']
+      r.assert == a
+    end
+
+    verify "add" do
+      r = x1 + x2
+      a = String::Mask["abc.7893", '.']
+      r.assert == a
+      r = x2 + x1
+      a = String::Mask["abc.7123", '.']
+      r.assert == a
+    end
+
+    verify "xand" do
+      r = x1 * x2
+      a = String::Mask["ab..789.", '.']
+      r.assert == a
+      r = x2 * x1
+      a = String::Mask["abc..123", '.']
+      r.assert == a
+    end
+
+    verify "and" do
+      r = x1 & x2
+      a = String::Mask["ab......", '.']
+      r.assert == a
+      r = x2 & x1
+      a = String::Mask["ab......", '.']
+      r.assert == a
+    end
+
+    verify "xor" do
+      r = x1 ^ x2
+      a = String::Mask["..c.7..3", '.']
+      r.assert == a
+      r = x2 ^ x1
+      a = String::Mask["..c.7..3", '.']
+      r.assert == a
+    end
+
+  end
+
+=end
+