og 0.12.0 → 0.13.0

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 259 2005-02-15 08:54:54Z gmosx $
-
-require "uri"
-
-module N;
-
-# 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

data/lib/glue/time.rb

@@ -1,85 +0,0 @@
-# * George Moschovitis  <gm@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id: time.rb 259 2005-02-15 08:54:54Z gmosx $
-
-require 'time.rb'
-
-module N;
-
-# General time utilities collection
-#
-# 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
-#
-# - SOS: add test units.
-# - add aliases for those methods in Kernel ?
-
-module TimeUtils
-
-	NOW = Time.now
-	NEVER = Time.mktime(2038)
-	ZERO = Time.mktime(1972)
-
-	# Convert the time to a nice String representation. 
-		
-	def self.date_time(time)
-		return nil unless time 
-		return time.strftime("%d-%m-%Y %H:%M")
-	end
-	
-	# This method calculates the days extrema given two time objects.
-	# start time is the given time1 at 00:00:00
-	# end time is the given time2 at 23:59:59:999
-	#
-	# Input:
-	# - the two times (if only time1 is provided then you get an extrema
-	#   of exactly one day extrema.
-	#
-	# Output
-	# - the time range. you can get the start/end times using
-	#   range methods.
-	
-	def self.days_extrema(time1, time2=nil)
-		time2 = time1 if (not time2.valid? Time)
-		time2 = NEVER if (time2 <= time1)
-		start_time = Time.self.start_of_day(time1)
-		end_time = self.end_of_day(time2)
-		return (start_time..end_time)
-	end
-
-	# Set time to start of day
-	
-	def self.start_of_day(time)
-		return Time.mktime(time.year, time.month, time.day, 0, 0, 0, 0)
-	end
-
-	
-	# Set time to end of day
-	
-	def self.end_of_day(time)
-		return Time.mktime(time.year, time.month, time.day, 23, 59, 59, 999)
-	end
-
-
-	# Returns true only if day of time is included in the
-	# range (stime..etime). Only year days are checked.
-	
-	def self.time_in_day_range(time, stime=ZERO, etime=NEVER)
-		if (etime <= stime)
-			Logger.debug "Invalid end time (#{etime} < #{stime})" if $DBG
-			etime = NEVER
-		end
-
-		stime = start_of_day(stime)
-		etime = end_of_day(etime)
-
-		return (stime..etime).include?(time)
-	end
-
-end
-
-end 

data/lib/glue/validation.rb

@@ -1,394 +0,0 @@
-# * George Moschovitis  <gm@navel.gr>
-# (c) 2004-2005 Navel, all rights reserved.
-# $Id$
-
-module N 
-
-# Implements a meta-language for validating managed
-# objects. Typically used in Validator objects but can be
-# included in managed objects too.
-#
-# === Example
-#
-# class User
-#		prop_accessor :name, String 
-#		prop_accessor :level, Fixnum
-#
-#		validate_length :name, :range => 2..6 
-#		validate_unique :name, :msg => :name_allready_exists 
-#		validate_format :name, :format => /[a-z]*/, :msg => 'invalid format', :on => :create 
-#	end
-#
-#	class N::CustomUserValidator 
-#		include N::Validation
-#		validate_length :name, :range => 2..6, :msg_short => :name_too_short, :msg_long => :name_too_long 
-#	end
-#
-#	user = @request.fill(User.new)
-#	user.level = 15
-#
-#	unless user.valid?
-#		user.save
-#	else
-#		p user.errors[:name]
-#	end
-#
-#	unless user.save
-#		p user.errors.on(:name)
-#	end
-#
-#	unless errors = N::CustomUserValidator.errors(user)
-#		user.save
-#	else
-#		p errors[:name]
-#	end
-#
-#--
-# TODO: all validation methods should imply validate_value
-# TODO: add validate_unique
-#++
-
-module Validation
-
-	# Encapsulates a list of validation errors.
-	
-	class Errors
-		attr_accessor :errors 
-
-		cattr_accessor :no_value, 'No value provided'
-		cattr_accessor :no_confirmation, 'Invalid confirmation'
-		cattr_accessor :invalid_format, 'Invalid format'
-		cattr_accessor :too_short, 'Too short, must be more than %d characters long'
-		cattr_accessor :too_long, 'Too long, must be less than %d characters long'
-		cattr_accessor :invalid_length, 'Must be %d characters long'
-		cattr_accessor :no_inclusion, 'The value is invalid'
-
-		def initialize
-			@errors = {}
-		end
-
-		def add(attr, message)
-			(@errors[attr] ||= []) << message
-		end
-
-		def on(attr)
-			@errors[attr]
-		end
-		alias_method :[], :on
-	
-		# Yields each attribute and associated message.
-		
-		def each
-			@errors.each_key do |attr| 
-				@errors[attr].each { |msg| yield attr, msg }
-			end
-		end
-
-		def size
-			@errors.size
-		end
-		alias_method :count, :size
-
-		def empty?
-			@errors.empty?
-		end
-
-		def clear
-			@errors.clear
-		end
-	end
-		
-	# If the validate method returns true, this
-	# attributes holds the errors found.
-	
-	attr_accessor :errors
-
-	# Call the #validate method for this object.
-	# If validation errors are found, sets the
-	# @errors attribute to the Errors object and 
-	# returns true.
-	
-	def valid?
-		begin
-			@errors = self.class.validate(self)
-			return @errors.empty?
-		rescue NoMethodError => e
-			# gmosx: hmm this is potentially dangerous.
-			N::Validation.eval_validate(self.class)
-			retry 
-		end
-	end
-		
-	# Evaluate the 'validate' method for the calling
-	# class.
-	#
-	# WARNING: for the moment only evaluates for 
-	# on == :save
-	
-	def self.eval_validate(klass)
-		code = %{	
-			def self.validate(obj, on = :save)
-				errors = Errors.new
-		}
-
-		for val, on in klass.__meta[:validations]
-			code << %{
-				#{val}
-			} 
-		end
-
-		code << %{
-				return errors
-			end		
-		}
-
-		# puts '-->', code, '<--'
-
-		klass.module_eval(code)
-	end
-
-	def self.append_features(base)
-		super
-
-		base.module_eval <<-"end_eval", __FILE__, __LINE__
-			meta :validations, []
-		end_eval
-
-		base.extend(MetaLanguage)
-	end
-
-	# Implements the Validation meta-language.
-	
-	module MetaLanguage 
-		
-		# the postfix attached to confirmation attributes.
-		
-		mattr_accessor :confirmation_postfix, '_confirmation'
-
-		# Validates that the attributes have a values, ie they are
-		# neither nil or empty.
-		#
-		# === Example
-		#
-		# validate_value :param, :msg => 'No confirmation'
-		
-		def validate_value(*params)
-			c = { 
-				:msg => N::Validation::Errors.no_value, 
-				:on => :save 
-			}
-			c.update(params.pop) if params.last.is_a?(Hash)
-
-			idx = 0
-			for name in params
-				code = %{
-					if obj.#{name}.nil?
-						errors.add(:#{name}, '#{c[:msg]}')
-					elsif obj.#{name}.respond_to?(:empty?)
-						errors.add(:#{name}, '#{c[:msg]}') if obj.#{name}.empty?
-					end
-				}
-				
-				__meta[:validations] << [code, c[:on]]
-			end
-		end
-
-		# Validates the confirmation of +String+ attributes.
-		#
-		# === Example
-		#
-		# validate_confirmation :password, :msg => 'No confirmation'
-		
-		def validate_confirmation(*params)
-			c = { 
-				:msg => N::Validation::Errors.no_confirmation, 
-				:postfix => N::Validation::MetaLanguage.confirmation_postfix,
-				:on => :save 
-			}
-			c.update(params.pop) if params.last.is_a?(Hash)
-
-
-			for name in params
-				confirm_name = "#{name}#{c[:postfix]}"
-				eval "attr_accessor :#{confirm_name}"
-
-				code = %{
-					if obj.#{confirm_name}.nil? or (obj.#{confirm_name} != obj.#{name})
-						errors.add(:#{name}, '#{c[:msg]}')
-					end
-				}
-				
-				__meta[:validations] << [code, c[:on]]
-			end
-		end
-
-		# Validates the format of +String+ attributes.
-		#
-		# === Example
-		# 
-		# validate_format :name, :format => /$A*/, :msg => 'My error', :on => :create
-		
-		def validate_format(*params)
-			c = { 
-				:format => nil, 
-				:msg_no_value => N::Validation::Errors.no_value,
-				:msg => N::Validation::Errors.invalid_format, 
-				:on => :save 
-			}
-			c.update(params.pop) if params.last.is_a?(Hash)
-		
-			unless c[:format].is_a?(Regexp)
-				raise(ArgumentError, 
-						'A regular expression must be supplied as the :format option')
-			end
-
-			for name in params
-				code = %{
-					if obj.#{name}.nil?
-						errors.add(:#{name}, '#{c[:msg_no_value]}')
-					else
-						unless obj.#{name}.to_s.match(/#{Regexp.quote(c[:format].source)}/)
-							errors.add(:#{name}, '#{c[:msg]}')
-						end
-					end;
-				}
-
-				__meta[:validations] << [code, c[:on]]
-			end																								
-		end
-		
-		# Validates the length of +String+ attributes.
-		#
-		# === Example
-		# 
-		# validate_length :name, :max => 30, :msg => 'Too long'
-		# validate_length :name, :min => 2, :msg => 'Too sort'
-		# validate_length :name, :range => 2..30
-		# validate_length :name, :length => 15, :msg => 'Name should be %d chars long'
-		
-		def validate_length(*params)
-			c = { 
-				:min => nil, :max => nil, :range => nil, :length => nil, 
-				:msg => nil, 
-				:msg_no_value => N::Validation::Errors.no_value,
-				:msg_short => N::Validation::Errors.too_short,
-				:msg_long => N::Validation::Errors.too_long,
-				:on => :save 
-			}
-			c.update(params.pop) if params.last.is_a?(Hash)
-
-			min, max = c[:min], c[:max]
-			range, length = c[:range], c[:length]
-
-			count = 0
-			[min, max, range, length].each { |o| count += 1 if o }
-
-			if count == 0 
-				raise(ArgumentError, 
-						'One of :min, :max, :range, :length must be provided!')
-			end
-
-			if count > 1
-				raise(ArgumentError, 
-						'The :min, :max, :range, :length options are mutually exclusive!')
-			end
-
-			for name in params
-				if min
-					c[:msg] ||= N::Validation::Errors.too_short 
-					code = %{
-						if obj.#{name}.nil?
-							errors.add(:#{name}, '#{c[:msg_no_value]}')
-						elsif obj.#{name}.to_s.length < #{min}
-							msg = '#{c[:msg]}'
-							msg = (msg % #{min}) rescue msg
-							errors.add(:#{name}, msg)
-						end;
-					}
-				elsif max 
-					c[:msg] ||= N::Validation::Errors.too_long
-					code = %{
-						if obj.#{name}.nil?
-							errors.add(:#{name}, '#{c[:msg_no_value]}')
-						elsif obj.#{name}.to_s.length > #{max}
-							msg = '#{c[:msg]}'
-							msg = (msg % #{max}) rescue msg
-							errors.add(:#{name}, msg)
-						end;
-					}
-				elsif range
-					code = %{
-						if obj.#{name}.nil?
-							errors.add(:#{name}, '#{c[:msg_no_value]}')
-						elsif obj.#{name}.to_s.length < #{range.first}
-							msg = '#{c[:msg_short]}'
-							msg = (msg % #{range.first}) rescue msg
-							errors.add(:#{name}, msg)
-						elsif obj.#{name}.to_s.length > #{range.last}
-							msg = '#{c[:msg_long]}'
-							msg = (msg % #{range.last}) rescue msg
-							errors.add(:#{name}, msg)
-						end;
-					}
-				elsif length
-					c[:msg] ||= N::Validation::Errors.invalid_length
-					code = %{
-						if obj.#{name}.nil?
-							errors.add(:#{name}, '#{c[:msg_no_value]}')
-						elsif obj.#{name}.to_s.length != #{length}
-							msg = '#{c[:msg]}'
-							msg = (msg % #{length}) rescue msg
-							errors.add(:#{name}, msg)
-						end;
-					}
-				end
-
-				__meta[:validations] << [code, c[:on]]
-			end																								
-		end
-		
-		# Validates that the attributes are included in 
-		# an enumeration.
-		#
-		# === Example
-		#
-		# validate_inclusion :sex, :in => %w{ Male Female }, :msg => 'huh??'
-		# validate_inclusion :age, :in => 5..99 
-
-		def validate_inclusion(*params)
-			c = { 
-				:in => nil, 
-				:msg => N::Validation::Errors.no_inclusion, 
-				:allow_nil => false,
-				:on => :save 
-			}
-			c.update(params.pop) if params.last.is_a?(Hash)
-		
-			unless c[:in].respond_to?('include?')
-				raise(ArgumentError, 
-						'An object that responds to #include? must be supplied as the :in option')
-			end
-
-			for name in params
-				if c[:allow_nil]
-					code = %{
-						unless obj.#{name}.nil? or (#{c[:in].inspect}).include?(obj.#{name})
-							errors.add(:#{name}, '#{c[:msg]}')
-						end;
-					}
-				else
-					code = %{
-						unless (#{c[:in].inspect}).include?(obj.#{name})
-							errors.add(:#{name}, '#{c[:msg]}')
-						end;
-					}
-				end
-
-				__meta[:validations] << [code, c[:on]]
-			end																								
-		end
-
-	end
-end
-
-end