nitro 0.1.2

data/lib/n/utils/mail.rb

@@ -0,0 +1,28 @@
+# = Mail utilities
+#
+# A thin wrapper arround net/smtp
+#
+# code:
+# George Moschovitis  <gm@navel.gr>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: mail.rb 71 2004-10-18 10:50:22Z gmosx $
+
+require "net/smtp"
+
+module N
+
+module Mail
+	
+	# Send an email
+	#
+	#
+	def self.send(from, to, body)
+		Net::SMTP.start($smtp_server, 25) { |smtp|
+      smtp.send_message(body, from, to)
+		}
+	end
+	
+end
+
+end # module

data/lib/n/utils/number.rb

@@ -0,0 +1,31 @@
+# = General number utilities collection
+#
+# code: gmosx
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: number.rb 71 2004-10-18 10:50:22Z gmosx $
+
+module N;
+
+# = NumberUtils
+#
+# === 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.
+#
+module NumberUtils
+
+	# Returns the multiple ceil of a number
+	#
+	def self.ceil_multiple(num, multiple)
+		# gmosx: to_f is needed!s
+		# gmosx: IS THERE a more optimized way to do this?
+		return ((num.to_f/multiple).ceil*multiple)
+	end
+
+end
+
+end # module

data/lib/n/utils/pool.rb

@@ -0,0 +1,66 @@
+# = Pool
+#
+# Generalized object pool implementation.
+#
+# code: gmosx
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: pool.rb 71 2004-10-18 10:50:22Z gmosx $
+
+require "thread"
+require "monitor"
+
+module N
+
+# = Pool
+#
+# Implemente 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 # module

data/lib/n/utils/string.rb

@@ -0,0 +1,297 @@
+# = General string utilities collection
+#
+# code: gmosx, drak, ekarak
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: string.rb 71 2004-10-18 10:50:22Z gmosx $
+
+require "uri"
+
+module N;
+
+# = StringUtils
+#
+# === 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
+
+	@@map_to_greeklish = {
+		"�" => "a", "�" => "A", "�" => "a", "�" => "A",
+		"�" => "b", "�" => "B",
+		"�" => "g", "�" => "G",
+		"�" => "d", "�" => "D",
+		"�" => "e", "�" => "E", "�" => "e", "�" => "E",
+		"�" => "z", "�" => "Z",
+		"�" => "h", "�" => "H", "�" => "h", "�" => "H",
+		"�" => "8", "�" => "8",
+		"�" => "i", "�" => "I", "�" => "i", "�" => "I",
+		"�" => "k", "�" => "K",
+		"�" => "l", "�" => "L",
+		"�" => "m", "�" => "M",
+		"�" => "n", "�" => "N",
+		"�" => "3", "�" => "3",
+		"�" => "o", "�" => "O", "�" => "o", "�" => "O",
+		"�" => "p", "�" => "P",
+		"�" => "r", "�" => "R",
+		"�" => "s", "�" => "s", "�" => "S",
+		"�" => "t", "�" => "T",
+		"�" => "y", "�" => "Y", "�" => "y", "�" => "Y",
+		"�" => "f", "�" => "F",
+		"�" => "x", "�" => "X",
+		"�" => "ps","�" => "PS",
+		"�" => "w", "�" => "W", "�" => "w", "�"=>"W"
+	}
+
+	# Convert the input string to greeklish
+	#
+	def self.to_greeklish(input)
+		return nil unless input
+		output = ""
+		# gmosx: also parse new lines
+		input.scan(/./m) { |w|
+			c = @@map_to_greeklish[w]
+			output << (c.nil?? w: c)
+		}
+		return output
+	end
+
+	# 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
+	#
+	# === Input:
+	# the string to be wrapped
+	# the enforced width
+	# the separator used for wrapping
+	#
+	# === Output:
+	# the wrapped string
+	#
+	# === Example:
+	#  text = "1111111111111111111111111111111111111111111"
+	#  text = Web::Utils::Html.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
+
+	# extracts the extension from a path or filename.
+	#
+	# === Input:
+	# the path to a file (or just a plain filename)
+	#
+	# === Output:
+	# the extension of the filename
+	# returns empty string if no exception
+	# the extension is DOWNCASED!
+
+	EXTENSION_REGEX = /\.(\w+)$/
+
+	def self.extension_from_path(path)
+		if md = EXTENSION_REGEX.match(path)
+			return md[1].downcase
+		else
+			# gmosx: "" is safer, no??? and it is logical too.
+			return ""
+		end
+	end
+
+	# Extracts the (file)name from a path or filename.
+	#
+	# === Input:
+	# the path to a file (or just a plain filename)
+	#
+	# === Output:
+	# the name part of the filename (the extension is stripped)
+	# returns empty string if input is nil (safer?)
+	#
+	def self.filename_from_path(path)
+		# gmosx: "" is safer, no??? and it is logical too.
+		return "" unless path
+		parts = path.split(EXTENSION_REGEX)
+		return parts[0]
+	end
+
+	# Extracts the file part from a path or filename.
+	#
+	# === Input:
+	# the path to a file (or just a plain filename)
+	#
+	# === Output:
+	# the file part (the directory is stripped)
+	# returns empty string if input is nil (safer?)
+	#
+	def self.file_from_path(path)
+		return "" unless path
+		return path.split("/").slice(-1)
+	end	
+	
+	# Extracts the directory part from a path or filename.
+	#
+	# === Input:
+	# the path to a file (or just a plain filename)
+	#
+	# === Output:
+	# the directory part (the filename is stripped)
+	# returns empty string if input is nil (safer?)
+	#
+	def self.directory_from_path(path)
+		return "" unless path
+		return path.chomp(self.file_from_path(path)).chop()
+	end
+	
+	# Replace dangerours chars in filenames
+	#
+	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
+
+	# 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
+
+  # Converts unicode to ISO8859-7 (unfortunately Ruby is a little poor at i18n)
+	# Usefull for parsing xmls with libxml.
+	#
+	# === Input:
+	# the string to convert
+	#
+	# === Output:
+	# the converted string
+	#
+	# === TODO:
+	# - MORE TEST UNITS !!!!
+	#
+	def self.unicode_to_iso88597(string)
+		return string.to_s.unpack('U*').collect {|ch|
+			ch>127 ? ch-0x02d0 : ch
+		}.pack('C*')
+	end
+
+
+	# Screen an IP address
+	#
+	# gmosx: copied this method from n1, check how it works!
+	#
+	def self.screen_ip_address(address)
+		if address
+			return address.split(',').collect { |hostip|
+				hostip.gsub(/\.[^\.]*$/, ".*")
+			}.join(', ')
+		else
+			return "*.*.*.*"
+		end
+	end
+	
+end
+
+end # module

data/lib/n/utils/template.rb

@@ -0,0 +1,38 @@
+# = Template
+#
+# A simple templating mechanism.
+#
+# code:
+# George Moschovitis  <gm@navel.gr>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id$
+
+module N;
+
+# = Template
+#
+class Template
+	attr_accessor :body
+	
+	#
+	#
+	def initialize(filename)
+		@body = File.read(filename)
+	end
+	
+	# Apply the substitutions to the template.
+	#
+	def gsub(hash)
+		res = body.dup()
+		
+		hash.each {|k, v|
+			res.gsub!(k, v)
+		}
+		
+		return res
+	end
+	alias_method :render, :gsub
+end
+
+end # module