glue 0.22.0 → 0.23.0

data/lib/glue/hash.rb

@@ -1,122 +0,0 @@
-# * George Moschovitis  <gm@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: hash.rb 182 2005-07-22 10:07:50Z gmosx $
-
-require 'sync'
-
-module Glue 
-
-# A thread-safe hash. We use a sync object instead of a mutex,
-# because it is re-entrant. An exclusive lock is needed when 
-# writing, a shared lock IS NEEDED when reading
-# uses the delegator pattern to allow for multiple
-# implementations!
-
-class SafeHash < Hash
-  attr :sync
-
-  # gmosx: delegator is not used.
-  #
-  def initialize(delegator = nil)
-    @sync = ::Sync.new
-  end
-
-  def [](key)
-    @sync.synchronize(::Sync::SH) { super }
-  end
-
-  def []=(key, value)
-    @sync.synchronize(::Sync::EX) { super }
-  end
-
-  def delete(key)
-    @sync.synchronize(::Sync::EX) { super }
-  end
-
-  def clear
-    @sync.synchronize(::Sync::EX) {  super }
-  end
-
-  def size
-    @sync.synchronize(::Sync::SH) {  super }
-  end
-
-  def values
-    @sync.synchronize(::Sync::SH) { super }
-  end
-
-  def keys
-    @sync.synchronize(::Sync::SH) { super }
-  end
-
-end 
-
-# A thread-safe hash. We use a sync object instead of a mutex,
-# because it is re-entrant. An exclusive lock is needed when 
-# writing, a shared lock IS NEEDED when reading.
-#
-# === Design
-#
-# This class uses the delegator pattern. However we dont use rubys
-# delegation facilities, they are more general and powerfull than we
-# need here (and slower). Instead a custom (but simple) solution is
-# used.
-#
-# === Example
-#
-# hash = SafeHashDelegator.new(Hash.new)
-# hash = SafeHashDelegator.new(Hash.new)
-
-class SafeHashDelegator < Hash
-  attr :delegate, :sync
-
-  def initialize(delegate)
-    @delegate = delegate
-    @sync = ::Sync.new
-  end
-
-  def [](key)
-    @sync.synchronize(::Sync::SH) {
-      @delegate[key]
-    }
-  end
-
-  def []=(key, value)
-    @sync.synchronize(::Sync::EX) {
-      @delegate[key] = value
-    }
-  end
-
-  def delete(key)
-    @sync.synchronize(::Sync::EX) {
-      @delegate.delete(key)
-    }
-  end
-
-  def clear
-    @sync.synchronize(::Sync::EX) {
-      @delegate.clear
-    }
-  end
-
-  def size
-    @sync.synchronize(::Sync::SH) {
-      @delegate.size()
-    }
-  end
-
-  def values
-    @sync.synchronize(::Sync::SH) {
-      @delegate.values()
-    }
-  end
-
-  def keys
-    @sync.synchronize(::Sync::SH) {
-      @delegate.keys()
-    }
-  end
-
-end
-
-end 

data/lib/glue/misc.rb

@@ -1,15 +0,0 @@
-# * George Moschovitis  <gm@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: misc.rb 182 2005-07-22 10:07:50Z gmosx $
-
-# Executes a Ruby block without warnings.
-
-def silence_warnings
-  old_verbose, $VERBOSE = $VERBOSE, nil
-  begin
-    yield
-  ensure
-    $VERBOSE = old_verbose
-  end
-end
-

data/lib/glue/number.rb

@@ -1,24 +0,0 @@
-# * George Moschovitis  <gm@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: number.rb 182 2005-07-22 10:07:50Z gmosx $
-
-module Glue;
-
-# Implement as a module to avoid class polution. You can
-# still use Ruby's advanced features to include the module in your
-# class. Passing the object to act upon allows to check for nil,
-# which isn't possible if you use self.
-
-module NumberUtils
-
-  # Returns the multiple ceil of a number
-  
-  def self.ceil_multiple(num, multiple)
-    # gmosx: to_f is needed!
-    # gmosx: IS THERE a more optimized way to do this?
-    return ((num.to_f/multiple).ceil*multiple)
-  end
-
-end
-
-end

data/lib/glue/object.rb

@@ -1,35 +0,0 @@
-# Original code from RubyOnRails (http://www.rubyonrails.com)
-#--
-# TODO: suggest inclusion in Facets.
-#++
-
-class Object #:nodoc:
-  def remove_subclasses_of(superclass)
-    subclasses_of(superclass).each do |subclass| 
-      Object.send(:remove_const, subclass) rescue nil 
-    end
-  end
-
-  def subclasses_of(superclass)
-    subclasses = []
-    ObjectSpace.each_object(Class) do |c|
-      if c.ancestors.include?(superclass) and superclass != c
-        subclasses << c
-      end
-    end
-    return subclasses
-  end
-end
-
-class Class #:nodoc:
-  def remove_subclasses
-    Object.remove_subclasses_of(self)
-  end
-
-  def subclasses
-    Object.subclasses_of(self)
-  end
-  alias_method :descendants, :subclasses
-end
-
-# * George Moschovitis <gm@navel.gr>

data/lib/glue/pool.rb

@@ -1,60 +0,0 @@
-# * George Moschovitis  <gm@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: pool.rb 182 2005-07-22 10:07:50Z gmosx $
-
-require 'thread'
-require 'monitor'
-
-module Glue 
-
-# Generalized object pool implementation. Implemented as a thread 
-# safe stack. Exclusive locking is needed both for push and pop. 
-#
-# INVESTIGATE: Could use the SizedQueue/Queue.
-
-class Pool < Array
-  include MonitorMixin
-  
-  def initialize
-    super
-    @cv = new_cond()
-  end
-
-  # Add, restore an object to the pool.
-  
-  def push(obj)
-    synchronize do
-      super
-      @cv.signal()
-    end
-  end
-  
-  # Obtain an object from the pool.
-  
-  def pop
-    synchronize do
-      @cv.wait_while { empty? }
-      super
-    end
-  end
-
-  # Obtains an object, passes it to a block for processing
-  # and restores it to the pool.
-
-  def obtain
-    result = nil
-    
-    begin
-      obj = pop()
-
-      result = yield(obj)
-    ensure
-      push(obj)
-    end
-
-    return result
-  end
-  
-end
-
-end

data/lib/glue/snapshot.rb

@@ -1,104 +0,0 @@
-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

@@ -1,162 +0,0 @@
-# * George Moschovitis  <gm@navel.gr>
-# * Anastasios Koutoumanos  <ak@navel.gr>
-# * Elias Karakoulakis  <ekarak@ktismata.com>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: string.rb 182 2005-07-22 10:07:50Z gmosx $
-
-require 'uri'
-
-module Glue;
-
-# General string utilities collection.
-#
-# === Design:
-#
-# Implement as a module to avoid class polution. You can
-# still Ruby's advanced features to include the module in your
-# class. Passing the object to act upon allows to check for nil,
-# which isn't possible if you use self.
-#
-# === TODO:
-#
-# - implement a method that returns easy to remember
-#   pseudo-random strings
-# - add aliases for those methods in Kernel.
-
-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
-=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
-=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]/)
-    # 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
-
-end
-
-end