IOWA 1.0.0

data/src/iowa/Hash.rb

@@ -0,0 +1,85 @@
+module Iowa
+
+	# This is a subclass of Ruby's Hash that implements a few convenient
+	# methods used by IOWA.
+	
+	class Hash < Hash
+
+		# A simple little routine to downcase any String used as a key
+		# in a hash or any hash nested as value somewhere within the hash.
+		# Thanks to Daniel Berger for this implementation.
+
+		def downcase_keys!
+			upper = /A-Z/
+			self.each do |k,v|
+				next unless k.kind_of? String
+				self[k.dup.downcase] = v
+				self.delete(k) if upper.match(k)
+			end
+		end
+
+		# Convert any symbolic keys to strings.
+		
+		def stringify_keys!
+			current_keys = self.keys
+			current_keys.each do |k|
+				v = self[k]
+				self.delete k
+				self[k.to_s] = v
+			end
+		end
+		
+		# Convert any string keys to symbols.
+		
+		def symbolify_keys!
+			current_keys = self.keys
+			current_keys.each do |k|
+				v = self[k]
+				self.delete k
+				self[k.to_s.intern] = v
+			end
+		end
+
+		def symbolify_all_keys!
+			current_keys = self.keys
+			current_keys.each do |k|
+				v = self[k]
+				v.symbolify_all_keys! if v.respond_to?(:has_key?)
+				self.delete k
+				self[k.to_s.intern] = v
+			end
+		end
+		
+		def step_merge!(h)
+			h.each do |k,v|
+				if v.kind_of?(::Hash)
+					if self[k].kind_of?(::Hash)
+						unless self[k].respond_to?(:step_merge!)
+							if dp = self[k].default_proc
+								self[k] = Iowa::Hash.new {|h,k| dp.call(h,k)}.step_merge!(self[k])
+							else
+								osk = self[k]
+								self[k] = Iowa::Hash.new
+								self[k].step_merge!(osk)
+							end
+						end
+						self[k].step_merge!(v)
+					else
+						if self.default_proc
+							self.delete k
+							self[k]
+						end
+						unless self[k].kind_of?(::Hash)
+							self.delete k
+							self[k] = Iowa::Hash.new
+						end
+						self[k].step_merge!(v)
+					end
+				else
+					self[k] = v
+				end
+			end
+		end
+
+	end
+end

data/src/iowa/ISAAC.rb

@@ -0,0 +1,175 @@
+module Crypt
+
+	# This is included in IOWA for convenience.  This PRNG is packaged
+	# separately for use independly from IOWA, and can be found on
+	# Rubyforge at http://rubyforge.org/projects/crypt-isaac
+	#
+	# ISAAC is a fast, strong random number generator.  Details on the
+	# algorithm can be found here: http://burtleburtle.net/bob/rand/isaac.html
+	# This provides a consistent and capable algorithm for producing
+	# independent streams of quality random numbers.
+
+	class ISAAC
+
+		attr_accessor :randrsl, :randcnt
+		attr_accessor :mm, :aa, :bb, :cc
+
+		# When a Crypt::ISAAC object is created, it needs to be seeded for
+		# random number generation.  If the system has a /dev/urandom file,
+		# that will be used to do the seeding by default.  If false is explictly
+		# passed when creating the object, it will instead use /dev/random to
+		# generate its seeds.  Be warned that this may make for SLOW
+		# initialization.
+		# If the requested source (/dev/urandom or /dev/random) do not exist,
+		# the system will fall back to a simplistic initialization mechanism
+		# using the builtin Mersenne Twister PRNG.
+
+		def initialize(noblock = true)
+			@mm = []
+			@randrsl = []
+			# Best initialization of the generator would be by pulling
+			# numbers from /dev/random.
+			rnd_source = noblock ? '/dev/urandom' : '/dev/random'
+			if (FileTest.exist? rnd_source)
+				File.open(rnd_source,'r') do |r|
+					256.times do |t|
+						z = r.sysread(4)
+						x = z.unpack('V')[0]
+						@randrsl[t] = x
+					end
+				end
+			else
+				# If urandom isn't available, the standard Ruby PRNG makes an
+				# adequate fallback.
+				256.times do |t|
+					@randrsl[t] = Kernel.rand(4294967295)
+				end
+			end
+			randinit(true)
+			nil
+		end
+
+		# Works just like the standard rand() function.  If called with an
+		# integer argument, rand() will return positive random number in
+		# the range of 0 to (argument - 1).  If called without an integer
+		# argument, rand() returns a positive floating point number less than 1.
+  
+		def rand(*num)
+			if (@randcnt == 1)
+				isaac
+				@randcnt = 256
+			end
+			@randcnt -= 1
+			if num[0].to_i > 0
+				@randrsl[@randcnt].modulo(num[0])
+			else
+				@randrsl[@randcnt]/4294967296.0
+			end
+		end
+
+		def isaac
+			i = 0
+			x = 0
+			y = 0
+
+			@cc += 1
+			@bb += @cc
+			@bb &= 0xffffffff
+
+			while (i < 256) do 
+				x = @mm[i]
+				@aa = (@mm[(i + 128) & 255] + (@aa^(@aa << 13)) ) & 0xffffffff
+				@mm[i] = y = (@mm[(x>>2)&255] + @aa + @bb ) & 0xffffffff
+				@randrsl[i] = @bb = (@mm[(y>>10)&255] + x ) & 0xffffffff
+				i += 1
+
+				x = @mm[i]
+				@aa = (@mm[(i+128)&255] + (@aa^(0x03ffffff & (@aa >> 6))) ) & 0xffffffff
+				@mm[i] = y = (@mm[(x>>2)&255] + @aa + @bb ) & 0xffffffff
+				@randrsl[i] = @bb = (@mm[(y>>10)&255] + x ) & 0xffffffff
+				i += 1
+
+				x = @mm[i]
+				@aa = (@mm[(i + 128)&255] + (@aa^(@aa << 2)) ) & 0xffffffff
+				@mm[i] = y = (@mm[(x>>2)&255] + @aa + @bb ) & 0xffffffff
+				@randrsl[i] = @bb = (@mm[(y>>10)&255] + x ) & 0xffffffff
+				i += 1
+
+				x = @mm[i]
+				@aa = (@mm[(i+128)&255] + (@aa^(0x0000ffff & (@aa >> 16))) ) & 0xffffffff
+				@mm[i] = y = (@mm[(x>>2)&255] + @aa + @bb ) & 0xffffffff
+				@randrsl[i] = @bb = (@mm[(y>>10)&255] + x ) & 0xffffffff
+				i += 1
+			end
+		end
+
+		def randinit(flag)
+			i = 0
+			a = 0
+			b = 0
+			c = 0
+			d = 0
+			e = 0
+			f = 0
+			g = 0
+			@aa = @bb = @cc = 0
+			a = b = c = d = e = f = g = h = 0x9e3779b9
+
+			while (i < 4) do
+				a ^= b<<1; d += a; b += c
+				b ^= 0x3fffffff & (c>>2); e += b; c += d
+				c ^= d << 8; f += c; d += e
+				d ^= 0x0000ffff & (e >> 16); g += d; e += f
+				e ^= f << 10; h += e; f += g
+				f ^= 0x0fffffff & (g >> 4); a += f; g += h
+				g ^= h << 8; b += g; h += a
+				h ^= 0x007fffff & (a >> 9); c += h; a += b
+				i += 1
+			end
+
+			i = 0
+			while (i < 256) do
+				if (flag)
+					a+=@randrsl[i  ].to_i; b+=@randrsl[i+1].to_i;
+					c+=@randrsl[i+2]; d+=@randrsl[i+3];
+					e+=@randrsl[i+4]; f+=@randrsl[i+5];
+					g+=@randrsl[i+6]; h+=@randrsl[i+7];
+				end
+
+				a^=b<<11; d+=a; b+=c;
+				b^=0x3fffffff & (c>>2);  e+=b; c+=d;
+				c^=d<<8;  f+=c; d+=e;
+				d^=0x0000ffff & (e>>16); g+=d; e+=f;
+				e^=f<<10; h+=e; f+=g;
+				f^=0x0fffffff & (g>>4);  a+=f; g+=h;
+				g^=h<<8;  b+=g; h+=a;
+				h^=0x007fffff & (a>>9);  c+=h; a+=b;
+				@mm[i]=a;@mm[i+1]=b; @mm[i+2]=c; @mm[i+3]=d;
+				@mm[i+4]=e; @mm[i+5]=f; @mm[i+6]=g; @mm[i+7]=h;
+				i += 8
+			end
+
+			if flag
+				i = 0
+				while (i < 256)
+					a+=@mm[i  ]; b+=@mm[i+1]; c+=@mm[i+2]; d+=@mm[i+3];
+					e+=@mm[i+4]; f+=@mm[i+5]; g+=@mm[i+6]; h+=@mm[i+7];
+					a^=b<<11; d+=a; b+=c;
+					b^=0x3fffffff & (c>>2);  e+=b; c+=d;
+					c^=d<<8;  f+=c; d+=e;
+					d^=0x0000ffff & (e>>16); g+=d; e+=f;
+					e^=f<<10; h+=e; f+=g;
+					f^=0x0fffffff & (g>>4);  a+=f; g+=h;
+					g^=h<<8;  b+=g; h+=a;
+					h^=0x007fffff & (a>>9);  c+=h; a+=b;
+					@mm[i  ]=a; @mm[i+1]=b; @mm[i+2]=c; @mm[i+3]=d;
+					@mm[i+4]=e; @mm[i+5]=f; @mm[i+6]=g; @mm[i+7]=h;
+					i += 8
+				end
+			end
+
+  		isaac()
+   		@randcnt=256;        # /* prepare to use the first set of results */
+		end
+	end
+end

data/src/iowa/ImageSize.rb

@@ -0,0 +1,279 @@
+# This is based on the image size library found at http://www.rubycgi.org/archive
+
+module Iowa
+class ImageSize
+# Image Type Constants
+	module Type
+		OTHER = "OTHER"
+		GIF  = "GIF"
+		PNG  = "PNG"
+		JPEG = "JPEG"
+		BMP  = "BMP"
+		PPM  = "PPM" # PPM is like PBM, PGM, & XV
+		PBM  = "PBM"
+		PGM  = "PGM"
+#		XV   = "XV"
+		XBM  = "XBM"
+		TIFF = "TIFF"
+		XPM  = "XPM"
+		PSD  = "PSD"
+		PCX  = "PCX"
+		SWF  = "SWF"
+	end
+
+	JpegCodeCheck = [
+		"\xc0", "\xc1", "\xc2", "\xc3",
+		"\xc5", "\xc6", "\xc7",
+		"\xc9", "\xca", "\xcb",
+		"\xcd", "\xce", "\xcf",
+	]
+
+# image type list
+	def ImageSize.type_list
+		Type.constants 
+	end
+
+# receive image & make size
+# argument is image String or IO
+	def initialize(img_data, img_type = nil)
+		@img_data = img_data.dup
+		@img_wedth = nil
+		@img_height = nil
+
+		if @img_data.is_a?(IO)
+			@img_top = @img_data.read(128)
+			@img_data.seek(0, 0)
+# define Singleton-method definition to IO (byte, offset)
+			def @img_data.read_o(length = 1, offset = nil)
+				self.seek(offset, 0) if offset
+				ret = self.read(length)
+				raise "cannot read!!" unless ret
+				ret
+			end
+		else
+			@img_data = @img_data.to_s
+			@img_top = @img_data[0, 128]
+# define Singleton-method definition to String (byte, offset)
+			def @img_data.read_o(length = 1, offset = nil)
+				@img_offset = 0 if !(defined?(@img_offset))
+				@img_offset = offset if offset
+				ret = self[@img_offset, length]
+				@img_offset += length
+				ret
+			end
+		end
+
+		if img_type.nil?
+			@img_type = check_type()
+		else
+			match = false
+			Type.constants.each do |t|
+				match = true if img_type == t
+			end
+			raise("img_type is failed. #{img_type}\n") if match == false
+			@img_type = img_type
+		end
+
+		@img_width, @img_height = __send__("measure_#{@img_type}") if @img_type != Type::OTHER
+#		eval("@img_width, @img_height = measure_" + @img_type + "()") if @img_type != Type::OTHER
+	end
+
+# get parameter
+	def type; @img_type; end
+	def height
+		if @img_type == Type::OTHER then nil else @img_height end
+	end
+	def width
+		if @img_type == Type::OTHER then nil else @img_width end
+	end
+
+	def check_type()
+		if @img_top =~ /^GIF8[7,9]a/                      then Type::GIF
+		elsif @img_top[0, 8] == "\x89PNG\x0d\x0a\x1a\x0a" then Type::PNG
+		elsif @img_top[0, 2] == "\xFF\xD8"                then Type::JPEG
+		elsif @img_top[0, 2] == 'BM'                      then Type::BMP
+		elsif @img_top =~ /^P[1-7]/                       then Type::PPM
+		elsif @img_top =~ /\#define\s+\S+\s+\d+/          then Type::XBM
+		elsif @img_top[0, 4] == "MM\x00\x2a"              then Type::TIFF
+		elsif @img_top[0, 4] == "II\x2a\x00"              then Type::TIFF
+		elsif @img_top =~ /\/\* XPM \*\//                 then Type::XPM
+		elsif @img_top[0, 4] == "8BPS"                    then Type::PSD
+		elsif @img_top[0, 3] == "FWS"                     then Type::SWF
+		elsif @img_top[0] == 10                           then Type::PCX
+		else Type::OTHER
+		end
+	end
+	private(:check_type)
+
+	def measure_GIF()
+		@img_data.read_o(6)
+		@img_data.read_o(4).unpack('vv')
+	end
+	private(:measure_GIF)
+
+	def measure_PNG()
+		@img_data.read_o(12)
+		raise "This file is not PNG." unless @img_data.read_o(4) == "IHDR"
+		@img_data.read_o(8).unpack('NN')
+	end
+	private(:measure_PNG)
+
+	def measure_JPEG()
+		c_marker = "\xFF"   # Section marker.
+		@img_data.read_o(2)
+		while(true)
+			marker, code, length = @img_data.read_o(4).unpack('aan')
+			raise "JPEG marker not found!" if marker != c_marker
+
+			if JpegCodeCheck.include?(code)
+				height, width = @img_data.read_o(5).unpack('xnn')
+				return([width, height])
+			end
+			@img_data.read_o(length - 2)
+		end
+	end
+	private(:measure_JPEG)
+
+	def measure_BMP()
+		@img_data.read_o(26).unpack("x18VV");
+	end
+	private(:measure_BMP)
+
+	def measure_PPM()
+		header = @img_data.read_o(1024)
+		header.gsub!(/^\#[^\n\r]*/m, "")
+		header =~ /^(P[1-6])\s+?(\d+)\s+?(\d+)/m
+		width = $2.to_i; height = $3.to_i
+		case $1
+			when "P1", "P4" then @img_type = "PBM"
+			when "P2", "P5" then @img_type = "PGM"
+			when "P3", "P6" then @img_type = "PPM"
+#			when "P7"
+#				@img_type = "XV"
+#				header =~ /IMGINFO:(\d+)x(\d+)/m
+#				width = $1.to_i; height = $2.to_i
+		end
+		[width, height]
+	end
+	private(:measure_PPM)
+
+	alias :measure_PGM :measure_PPM
+	private(:measure_PGM)
+	alias :measure_PBM :measure_PPM
+	private(:measure_PBM)
+
+	def measure_XBM()
+		@img_data.read_o(1024) =~ /^\#define\s*\S*\s*(\d+)\s*\n\#define\s*\S*\s*(\d+)/mi
+		[$1.to_i, $2.to_i]
+	end
+	private(:measure_XBM)
+
+	def measure_XPM()
+		width = height = nil
+		while(line = @img_data.read_o(1024))
+			if line =~ /"\s*(\d+)\s+(\d+)(\s+\d+\s+\d+){1,2}\s*"/m
+				width = $1.to_i; height = $2.to_i
+				break
+			end
+		end
+		[width, height]
+	end
+	private(:measure_XPM)
+
+	def measure_PSD()
+		y,x = @img_data.read_o(26).unpack("x14NN")
+		[x,y]
+	end
+	private(:measure_PSD)
+
+	def measure_TIFF()
+		endian = if (@img_data.read_o(4) =~ /II\x2a\x00/o) then 'v' else 'n' end
+# 'v' little-endian   'n' default to big-endian
+
+		packspec = [
+			nil,           # nothing (shouldn't happen)
+			'C',           # BYTE (8-bit unsigned integer)
+			nil,           # ASCII
+			endian,        # SHORT (16-bit unsigned integer)
+			endian.upcase, # LONG (32-bit unsigned integer)
+			nil,           # RATIONAL
+			'c',           # SBYTE (8-bit signed integer)
+			nil,           # UNDEFINED
+			endian,        # SSHORT (16-bit unsigned integer)
+			endian.upcase, # SLONG (32-bit unsigned integer)
+		]
+
+		offset = @img_data.read_o(4).unpack(endian.upcase)[0] # Get offset to IFD
+
+		ifd = @img_data.read_o(2, offset)
+		num_dirent = ifd.unpack(endian)[0]                   # Make it useful
+		offset += 2
+		num_dirent = offset + (num_dirent * 12);             # Calc. maximum offset of IFD
+
+		ifd = width = height = nil
+		while(width.nil? || height.nil?)
+			ifd = @img_data.read_o(12, offset)                 # Get first directory entry
+			break if (ifd.nil? || (offset > num_dirent))
+			offset += 12
+			tag = ifd.unpack(endian)[0]                       # ...and decode its tag
+			type = ifd[2, 2].unpack(endian)[0]                # ...and the data type
+
+     # Check the type for sanity.
+			next if (type > packspec.size + 0) || (packspec[type].nil?)
+			if tag == 0x0100                                  # Decode the value
+				width = ifd[8, 4].unpack(packspec[type])[0]
+			elsif tag == 0x0101                               # Decode the value
+				height = ifd[8, 4].unpack(packspec[type])[0]
+			end
+		end
+
+		raise "#{if width.nil? then 'width not defined.' end} #{if height.nil? then 'height not defined.' end}" if width.nil? || height.nil?
+		[width, height]
+	end
+	private(:measure_TIFF)
+
+	def measure_PCX()
+		header = @img_data.read_o(128)
+		head_part = header.unpack('C4S4')
+		width = head_part[6] - head_part[4] + 1
+		height = head_part[7] - head_part[5] + 1
+		[width, height]
+	end
+	private(:measure_PCX)
+
+	def measure_SWF()
+		header = @img_data.read_o(9)
+		raise("This file is not SWF.") unless header.unpack('a3')[0] == 'FWS'
+
+		bit_length = Integer("0b#{header.unpack('@8B5')}")
+		header << @img_data.read_o(bit_length*4/8+1)
+		str = header.unpack("@8B#{5+bit_length*4}")[0]
+		last = 5
+		x_min = Integer("0b#{str[last,bit_length]}")
+		x_max = Integer("0b#{str[(last += bit_length),bit_length]}")
+		y_min = Integer("0b#{str[(last += bit_length),bit_length]}")
+		y_max = Integer("0b#{str[(last += bit_length),bit_length]}")
+		width = (x_max - x_min)/20
+		height = (y_max - y_min)/20
+		[width, height]
+	end
+	private(:measure_PCX)
+end
+end
+
+
+if __FILE__ == $0
+	print "TypeList: #{ImageSize.type.inspect}\n"
+
+	Dir.glob("*").each do |file|
+		print "#{file} (string)\n"
+		open(file, "rb") do |fh|
+			img = ImageSize.new(fh.read)
+			print <<-EOF
+type:   #{img.type.inspect}
+width:  #{img.width.inspect}
+height: #{img.height.inspect}
+			EOF
+		end
+	end
+end