glue 0.0.1 → 0.13.0

data/lib/glue/string.rb

@@ -0,0 +1,162 @@
+# * 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 282 2005-03-10 12:24:53Z 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

@@ -0,0 +1,85 @@
+# * George Moschovitis  <gm@navel.gr>
+# (c) 2004-2005 Navel, all rights reserved.
+# $Id: time.rb 282 2005-03-10 12:24:53Z 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

@@ -0,0 +1,461 @@
+# * 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.
+#
+# The following validation macros are available:
+#
+#	* validate_value
+#	* validate_confirmation
+#	* validate_format
+#	* validate_length
+#	* validate_inclusion
+#
+# Og/Database specific validation methods are added in the
+# file og/validation.rb
+#
+# === 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'
+		cattr_accessor :no_numeric, 'The value must be numeric'
+		cattr_accessor :not_unique, 'The value is already used'
+
+		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		
+		}
+
+		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.
+		# WARNING: regexp options are ignored.
+		#
+		# === Example
+		# 
+		# validate_format :name, :format => /$A*/, :msg => 'My error', :on => :create
+		#
+		#--
+		# FIXME: how to get the Regexp options?
+		#++
+		
+		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(/#{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
+
+		# Validates that the attributes have numeric values.
+		#
+		# [+:integer+]
+		#		Only accept integers
+		#
+		#	[+:msg]
+		#		Custom message
+		#
+		#	[+:on:]
+		#		When to validate
+		#		
+		# === Example
+		#
+		# validate_numeric :age, :msg => 'Must be an integer'
+
+		def validate_numeric(*params)
+			c = { 
+				:integer => false,
+				:msg => N::Validation::Errors.no_numeric, 
+				:on => :save 
+			}
+			c.update(params.pop) if params.last.is_a?(Hash)
+
+			for name in params
+				if c[:integer]
+					code = %{
+						unless obj.#{name}.to_s =~ /^[\\+\\-]?\\d+$/
+							errors.add(:#{name}, '#{c[:msg]}')
+						end;
+					}
+				else
+					code = %{
+						begin
+							Kernel.Float(obj.#{name})
+						rescue ArgumentError, TypeError
+							errors.add(:#{name}, '#{c[:msg]}')
+						end;
+					}
+				end
+
+				__meta[:validations] << [code, c[:on]]
+			end																								
+		end
+		alias_method :validate_numericality, :validate_numeric
+
+	end
+
+end
+
+end
+
+class Module # :nodoc: all
+	include N::Validation::MetaLanguage
+end
+