glue 0.20.0 → 0.21.0

data/lib/glue/sanitize.rb

@@ -8,41 +8,41 @@ VERBOTEN_TAGS = %w(form script) unless defined?(VERBOTEN_TAGS)
 VERBOTEN_ATTRS = /^on/i unless defined?(VERBOTEN_ATTRS)
 
 class String
-	# Sanitizes the given HTML by making form and script tags into regular
-	# text, and removing all "onxxx" attributes (so that arbitrary Javascript
-	# cannot be executed). Also removes href attributes that start with
-	# "javascript:".
-	#
-	# Returns the sanitized text.
-	def self.sanitize(html)
-	  # only do this if absolutely necessary
-	  if html.index("<")
-	    tokenizer = HTML::Tokenizer.new(html)
-	    new_text = ""
+  # Sanitizes the given HTML by making form and script tags into regular
+  # text, and removing all "onxxx" attributes (so that arbitrary Javascript
+  # cannot be executed). Also removes href attributes that start with
+  # "javascript:".
+  #
+  # Returns the sanitized text.
+  def self.sanitize(html)
+    # only do this if absolutely necessary
+    if html.index("<")
+      tokenizer = HTML::Tokenizer.new(html)
+      new_text = ""
 
-	    while token = tokenizer.next
-	      node = HTML::Node.parse(nil, 0, 0, token, false)
-	      new_text << case node
-	        when HTML::Tag
-	          if VERBOTEN_TAGS.include?(node.name)
-	            node.to_s.gsub(/</, "&lt;")
-	          else
-	            if node.closing != :close
-	              node.attributes.delete_if { |attr,v| attr =~ VERBOTEN_ATTRS }
-	              if node.attributes["href"] =~ /^javascript:/i
-	                node.attributes.delete "href"
-	              end
-	            end
-	            node.to_s
-	          end
-	        else
-	          node.to_s.gsub(/</, "&lt;")
-	      end
-	    end
+      while token = tokenizer.next
+        node = HTML::Node.parse(nil, 0, 0, token, false)
+        new_text << case node
+          when HTML::Tag
+            if VERBOTEN_TAGS.include?(node.name)
+              node.to_s.gsub(/</, "&lt;")
+            else
+              if node.closing != :close
+                node.attributes.delete_if { |attr,v| attr =~ VERBOTEN_ATTRS }
+                if node.attributes["href"] =~ /^javascript:/i
+                  node.attributes.delete "href"
+                end
+              end
+              node.to_s
+            end
+          else
+            node.to_s.gsub(/</, "&lt;")
+        end
+      end
 
-	    html = new_text
-	  end
+      html = new_text
+    end
 
-	  html
-	end
+    html
+  end
 end

data/lib/glue/settings.rb

@@ -2,4 +2,4 @@
 
 require 'glue/configuration'
 
-# * George Moschovitis <gm@navel.gr> 	
+# * George Moschovitis <gm@navel.gr>   

data/lib/glue/snapshot.rb

@@ -0,0 +1,104 @@
+module Glue
+
+# 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 
+# (method Glue::Snapshot#add) as well as to restore all objects 
+# of the snapshot to their state stored in the snapshot (method
+# Glue::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
+
+module DupReplaceSnapshotMixin
+  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 ValueHolder 
+  attr_accessor :value
+
+  def initialize(value=nil)
+    @value = value
+  end
+
+  def take_snapshot
+    @value
+  end
+
+  def restore_snapshot(value)
+    @value = value
+  end
+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 restore_snapshot(snap)
+    instance_variables.each do |iv|
+      instance_variable_set(iv, snap[iv])
+    end
+  end
+end
+
+class Array; include Glue::DupReplaceSnapshotMixin end 
+
+class String; include Glue::DupReplaceSnapshotMixin end 
+
+class Hash; include Glue::DupReplaceSnapshotMixin 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
+
+# * Michael Neumann <mneumann@ntecs.de>

data/lib/glue/string.rb

@@ -2,7 +2,7 @@
 # * Anastasios Koutoumanos  <ak@navel.gr>
 # * Elias Karakoulakis  <ekarak@ktismata.com>
 # (c) 2004-2005 Navel, all rights reserved.
-# $Id: string.rb 1 2005-04-11 11:04:30Z gmosx $
+# $Id: string.rb 182 2005-07-22 10:07:50Z gmosx $
 
 require 'uri'
 
@@ -25,137 +25,137 @@ module Glue;
 
 module StringUtils
 
-	# Move this in String class?
-	#
-	# Tests a string for a valid value (non nil, not empty)
-	#
-	def self.valid?(string)
-		return (not ((nil == string) or (string.empty?)))
-	end
-
-	# returns short abstract of long strings (first 'count'
-	# characters, chopped at the nearest word, appended by '...')
-	# force_cutoff: break forcibly at 'count' chars. Does not accept
-	# count < 2.
-	
-	def self.head(string, count = 128, force_cutoff = false, ellipsis="...")
-		return nil unless string
-		return nil if count < 2
-
-		if string.size > count
-			cut_at = force_cutoff ? count : (string.index(' ', count-1) || count)
-			xstring = string.slice(0, cut_at)
-			return xstring.chomp(" ") + ellipsis
-		else
-			return string
-		end
-	end
-
-	# Apply a set of rules (regular expression matches) to the
-	# string
-	#
-	# === Requirements:
-	# - the rules must be applied in order! So we cannot use a
-	#   hash because the ordering is not guaranteed! we use an
-	#	array instead.
-	#
-	# === Input:
-	# the string to rewrite
-	# the array containing rule-pairs (match, rewrite)
-	#
-	# === Output:
-	# the rewritten string
-
-	MATCH = 0
-	REWRITE = 1
-
-	def self.rewrite(string, rules)
-		return nil unless string
-
-		# gmosx: helps to find bugs
-		raise ArgumentError.new('The rules parameter is nil') unless rules
-
-		rewritten_string = string.dup
-
-		for rule in rules
-			rewritten_string.gsub!(rule[MATCH], rule[REWRITE])
-		end
-
-		return (rewritten_string or string)
-	end
-
-	# Enforces a maximum width of a string inside an
-	# html container. If the string exceeds this maximum width
-	# the string gets wraped.
-	#
-	# Not really useful, better use the CSS overflow: hidden
-	# functionality.
-	#
-	# === Input:
-	# the string to be wrapped
-	# the enforced width
-	# the separator used for wrapping
-	#
-	# === Output:
-	# the wrapped string
-	#
-	# === Example:
-	#  text = "1111111111111111111111111111111111111111111"
-	#  text = wrap(text, 10, " ")
-	#  p text # => "1111111111 1111111111 1111111111"
-	#
-	# See the test cases to better understand the behaviour!
-	
-	def self.wrap(string, width = 20, separator = " ")
-		return nil unless string
-
-		re = /([^#{separator}]{1,#{width}})/
-		wrapped_string = string.scan(re).join(separator)
-
-		return wrapped_string
-	end
-
-	# Replace dangerours chars in filenames
+  # Move this in String class?
+  #
+  # Tests a string for a valid value (non nil, not empty)
+  #
+  def self.valid?(string)
+    return (not ((nil == string) or (string.empty?)))
+  end
+
+  # returns short abstract of long strings (first 'count'
+  # characters, chopped at the nearest word, appended by '...')
+  # force_cutoff: break forcibly at 'count' chars. Does not accept
+  # count < 2.
+  
+  def self.head(string, count = 128, force_cutoff = false, ellipsis="...")
+    return nil unless string
+    return nil if count < 2
+
+    if string.size > count
+      cut_at = force_cutoff ? count : (string.index(' ', count-1) || count)
+      xstring = string.slice(0, cut_at)
+      return xstring.chomp(" ") + ellipsis
+    else
+      return string
+    end
+  end
+
+  # Apply a set of rules (regular expression matches) to the
+  # string
+  #
+  # === Requirements:
+  # - the rules must be applied in order! So we cannot use a
+  #   hash because the ordering is not guaranteed! we use an
+  #  array instead.
+  #
+  # === Input:
+  # the string to rewrite
+  # the array containing rule-pairs (match, rewrite)
+  #
+  # === Output:
+  # the rewritten string
+
+  MATCH = 0
+  REWRITE = 1
+
+  def self.rewrite(string, rules)
+    return nil unless string
+
+    # gmosx: helps to find bugs
+    raise ArgumentError.new('The rules parameter is nil') unless rules
+
+    rewritten_string = string.dup
+
+    for rule in rules
+      rewritten_string.gsub!(rule[MATCH], rule[REWRITE])
+    end
+
+    return (rewritten_string or string)
+  end
+
+  # Enforces a maximum width of a string inside an
+  # html container. If the string exceeds this maximum width
+  # the string gets wraped.
+  #
+  # Not really useful, better use the CSS overflow: hidden
+  # functionality.
+  #
+  # === Input:
+  # the string to be wrapped
+  # the enforced width
+  # the separator used for wrapping
+  #
+  # === Output:
+  # the wrapped string
+  #
+  # === Example:
+  #  text = "1111111111111111111111111111111111111111111"
+  #  text = wrap(text, 10, " ")
+  #  p text # => "1111111111 1111111111 1111111111"
+  #
+  # See the test cases to better understand the behaviour!
+  
+  def self.wrap(string, width = 20, separator = " ")
+    return nil unless string
+
+    re = /([^#{separator}]{1,#{width}})/
+    wrapped_string = string.scan(re).join(separator)
+
+    return wrapped_string
+  end
+
+  # Replace dangerours chars in filenames
 =begin
-	def self.rationalize_filename(filename)
-		return nil unless filename
-		# gmosx: rationalize a copy!!! (add unit test)
-		xfilename = filename.dup()
-		# gmosx: replace some dangerous chars!
-		xfilename.gsub!(/ /, "-")
-		xfilename.gsub!(/!/, "")
-		xfilename.gsub!(/'/, "")
-		xfilename.gsub!(/\(/, "")
-		xfilename.gsub!(/\)/, "")
-		# xfilename = self.to_greeklish(xfilename)
-		return xfilename
-	end
+  def self.rationalize_filename(filename)
+    return nil unless filename
+    # gmosx: rationalize a copy!!! (add unit test)
+    xfilename = filename.dup()
+    # gmosx: replace some dangerous chars!
+    xfilename.gsub!(/ /, "-")
+    xfilename.gsub!(/!/, "")
+    xfilename.gsub!(/'/, "")
+    xfilename.gsub!(/\(/, "")
+    xfilename.gsub!(/\)/, "")
+    # xfilename = self.to_greeklish(xfilename)
+    return xfilename
+  end
 =end
-	
-	# Returns a random string. one possible use is
-	# password initialization.
-	#
-	# === Input:
-	# the maximum length of the string
-	#
-	# === Output:
-	# the random string
-	
-	def self.random(max_length = 8, char_re = /[\w\d]/)
+  
+  # Returns a random string. one possible use is
+  # password initialization.
+  #
+  # === Input:
+  # the maximum length of the string
+  #
+  # === Output:
+  # the random string
+  
+  def self.random(max_length = 8, char_re = /[\w\d]/)
     # gmosx: this is a nice example of input parameter checking.
-		# this is NOT a real time called method so we can add this
-		# check. Congrats to the author.
-		raise ArgumentError.new('char_re must be a regular expression!') unless char_re.is_a?(Regexp)
-		
-		string = ""
-
-		while string.length < max_length
-				ch = rand(255).chr
-				string << ch if ch =~ char_re
-		end
-
-		return string
-	end
+    # this is NOT a real time called method so we can add this
+    # check. Congrats to the author.
+    raise ArgumentError.new('char_re must be a regular expression!') unless char_re.is_a?(Regexp)
+    
+    string = ""
+
+    while string.length < max_length
+        ch = rand(255).chr
+        string << ch if ch =~ char_re
+    end
+
+    return string
+  end
 
 end