IOWA 1.0.0

data/src/iowa/Element.rb

@@ -0,0 +1,100 @@
+module Iowa
+
+	# Superclass for all Iowa elements.  An element is something that looks
+	# like an HTML tag, and is in many cases named like an HTML tag, but
+	# that implements some sort of dynamic behavior.
+
+	class Element
+
+		ElementClasses={Celement => Element}
+		def Element.inherited(subclass)
+			if subclass.name[0,33] == 'Iowa::Application::ContentClasses'
+				ElementClasses[subclass.name.sub(/Iowa::Application::ContentClasses::/,C_empty).downcase] = subclass
+			else
+				ElementClasses[subclass.name.split(ClassSeparator).last.downcase] = subclass
+			end
+		end
+	
+		def Element.newElement(classname, name, bindings, attributes, namespace = nil)
+			if name == CBodyContent
+				BodyContent.new(name, bindings, attributes)
+			else
+				klass = nil
+				if namespace
+					# Is there a more efficient way to do this?
+					cn = (namespace.gsub(/Iowa::Application::ContentClasses(::)*/,C_empty).split(ClassSeparator)[0..-2] << classname).join(ClassSeparator)
+					klass = ElementClasses[cn.downcase] if ElementClasses.has_key? cn.downcase
+				end
+				klass ||= ElementClasses[classname.downcase]
+				
+				begin
+					unless klass.ancestors.include?(Iowa::Component)
+						klass.new(name, bindings, attributes)	
+					else
+						ComponentProxy.new(klass, name, bindings, attributes)
+					end
+				rescue Exception => ex
+				raise "unknown Element type: #{classname}\n<br />#{ex}<br/>\n#{ex.backtrace}"
+					
+				end
+			end
+		end
+	
+		attr_accessor :name, :children, :raw_template, :raw_bindings, :attributes
+	
+		def initialize(name, bindings, attributes, raw_template = nil, raw_bindings = nil)
+			@name = name
+			@raw_template = raw_template
+			@raw_bindings = raw_bindings
+			@attributes = attributes
+			@bindings = {}
+			@cached_associations = {}
+			defaultBindings()
+
+			bindings.each do |key,val|
+				@bindings[key]=val
+			end
+
+			@children = []
+		end
+	
+		def self; self; end
+
+		def cached_associations
+			@cached_associations
+		end
+
+		def addChild(child)
+			@children.push child
+		end
+	
+		def each(&b)
+			@children.each(&b)
+		end
+	
+		def defaultBindings
+		end
+	
+		def handleChildren(method, context)
+			context.pushElement
+			for child in @children
+				context.nextElement!
+				child.__send__(method, context)
+			end
+			context.popElement
+		end
+	
+		def handleRequestOrResponse(method, context)
+			handleChildren(method, context) if @children.length > 0
+		end
+	
+		def handleRequest(context)
+			handleRequestOrResponse(:handleRequest, context)
+		end
+
+		def handleResponse(context)
+			handleRequestOrResponse(:handleResponse, context)
+		end	
+	end
+
+end

data/src/iowa/Email.rb

@@ -0,0 +1,287 @@
+if RUBY_VERSION =~ /^1\.8/
+  require 'tmail'
+else
+  require 'mail'
+end
+
+require 'net/smtp'
+require 'forwardable'
+
+module Iowa
+	# A specialized component that lets one easily create and send customize
+	# email.  An instance of Iowa::Email can send itself, or can return a text
+	# representation suitable for piping into some other sending system.
+	class Email < Component
+		extend Forwardable
+		def_delegators('@mail_obj','to','to=','from','from=','subject','subject=','date','date=','mime_version','mime_version=','content_type','content_type=','body','body=','cc','cc=','bcc','bcc=','reply_to','reply_to=','sender','sender=','message_id','message_id=','in_reply_to','in_reply_to=','references','references=','transfer_encoding','transfer_encoding=','disposition','disposition=')
+
+		attr_accessor :has_mimetypes, :mail_obj, :smtp_account, :smtp_password, :smtp_connection, :attachments
+
+		class Attachment < Hash
+			def preamble
+				r = ''
+				if self[:attachment_type] == :as_content
+					r << "Content-Type: #{self[:content_type]}\r\n"
+					r << "Content-Transfer-Encoding: bit\r\n"
+				else
+					r << "Content-Type: #{self[:content_type]}; name=#{self[:filename]}\r\n"
+					r << "Content-Transfer-Encoding: base64\r\n"
+					r << "Content-Disposition: attachment; filename=#{self[:filename]}\r\n"
+				end
+				r
+			end
+		end
+
+		def initialize(name, bindings, attributes, parent)
+			super(name,bindings,attributes,parent)
+			email_init
+		end
+
+		def unique_id
+			t = Time.now
+			[sprintf('%08x',Iowa.app.rand(2147483647)),
+				sprintf('%02x',t.to_i),
+				sprintf('%02x',t.usec),
+				sprintf('%08x',Iowa.app.rand(2147483647))].join
+		end
+
+		def mime_boundary
+			"iowa_mime_part_#{unique_id}"
+		end
+
+		def boundary
+			@boundary ||= mime_boundary
+			@boundary
+		end
+
+		def naive_mimetype_checker(fn)
+			filename = File.basename(fn).downcase
+			case filename
+			when /\.jp(e?)g$/
+				['image/jpg']
+			when /\.gif$/
+				['image/gif']
+			when /\.htm?l$/
+				['text/html']
+			when /\.png$/
+				['image/png']
+			when /\.txt$/
+				['text/plain']
+			when /\.zip$/
+				['application/zip']
+			else
+				['application/data']
+			end
+		end
+
+		def check_mimetype(filename)
+			if has_mimetypes?
+				r = MIME::Types.type_for(filename)
+			else
+				r = naive_mimetype_checker(filename)
+			end
+
+			r.length > 0 ? r[0] : 'application/data'
+		end
+
+		def attach_file(file_or_handle, email_filename, attachment_type = nil)
+			# Use MIME::Types to get the type for the filename
+			# (use email_filename for this), if it is availble.
+			# If it is not, then fallback to a naive internal
+			# routine.
+			unless has_mimetypes
+				begin
+					require 'mime/types'
+					has_mimetypes = true
+				rescue Exception
+					has_mimetypes = false
+				end
+			end
+			mimetype = check_mimetype(email_filename)
+			fh = file_or_handle.kind_of?(File) ?
+				file_or_handle : File.new(file_or_handle)
+			unless attachment_type
+				if /^text\//.match(mimetype)
+					attachment_type = :as_content
+				else
+					attachment_type = :as_attachment
+				end
+			end
+			attach_content(fh.readlines.join,mimetype,email_filename,attachment_type)
+		end
+
+		def attach_content(content, content_type, email_filename=nil, attachment_type=:as_attachment)
+			# Attach the given content, with the given type.
+			# It'd be cool if there were code that could guess
+			# the MIME type based on the content itself, if a
+			# type were not given.
+			@boundary = mime_boundary unless @boundary
+			unless @attachments
+				@attachments = []
+			end
+			unless email_filename
+				@attach_name_count ||= 0
+				@attach_name_count += 1
+				email_filename = "file_#{@attach_name_count}"
+			end
+			attachment = {
+				:content_type => content_type,
+				:filename => File.basename(email_filename),
+				:content => content,
+				:attachment_type => attachment_type}
+		end
+		
+		def mime_preamble
+			"\r\nThis is a multi-part message in MIME format.\r\n\r\n"
+		end
+
+		def email_init(params = {})
+			@body_generated_flag = false
+			@mail_obj = ::Mail.new unless mail_obj
+			self.subject = " "
+			self.content_type = 'text/plain' unless self.content_type
+			if h = self.class.instance_variable_get('@additional_headers')
+				h.each do |k,v|
+					@mail_obj[k] = v
+				end
+			end
+			[:smtp_server, :smtp_port, :helo_domain, :authentication, :smtp_account, :smtp_password, :recipients, :to, :from, :subject, :date, :sent_on, :mime_version, :content_type, :body, :cc, :bcc, :reply_to, :sender, :message_id, :in_reply_to, :references, :transfer_encoding, :disposition].each do |param|
+				if p = self.class.instance_variable_get("@#{param}")
+					self.__send__("#{param}=", p)
+				end
+				self.__send__("#{param}=", params[param])if params.has_key?(param)
+				params.delete(param)
+			end
+			params.each {|k,v| self[k] = v}
+		end
+		
+		remove_method(:body)
+		def body
+			generate_body unless body_generated?
+			mail_obj.body
+		end
+		
+		def preamble
+			generate_body unless body_generated?
+			mail_obj.preamble
+		end
+			
+		def epilogue
+			generate_body unless body_generated?
+			mail_obj.epilogue
+		end
+				
+		def multipart?
+			generate_body unless body_generated?
+			mail_obj.multipart?
+		end
+			
+		def body_generated?
+			@body_generated_flag
+		end
+		
+		def recipients
+			mail_obj.to
+		end
+		
+		def recipients=(recip_list)
+			mail_obj.to = recip_list
+		end
+		
+		def smtp_server
+			@smtp_server.nil? ? "smtp.#{Socket.gethostname}" : @smtp_server
+		end
+		
+		def smtp_server=(server)
+			@smtp_server = server
+		end
+		
+		def smtp_port
+			@smtp_port.nil? ? 25 : @smtp_port
+		end
+		
+		def smtp_port=(port)
+			@smtp_port = port
+		end
+		
+		def helo_domain
+			@helo_domain.nil? ? Socket.gethostname : @helo_comain
+		end
+		
+		def helo_domain=(domain)
+			@helo_domain = domain
+		end
+		
+		def authentication
+			@authentication
+		end
+		
+		def authentication=(value)
+			@authentication = case value.to_s
+				when 'plain'
+					:plain
+				when 'login'
+					:login
+				when 'cram_md5'
+					:cram_md5
+				else
+					@authentication
+			end
+		end
+
+		def sent_on
+			date
+		end
+		
+		def sent_on=(value)
+			self.date = value
+		end
+		
+		def [](key)
+			mail_obj[key]
+		end
+		
+		def []=(key,value)
+			mail_obj[key] = value
+		end
+		
+		def generate_body
+			@body_generated_flag = true
+			email_context = Iowa::Context.new(session.context.request,Iowa::Response.new)
+			email_context.sessionID = session.context.sessionID
+			email_context.requestID = session.requestCount
+			handleResponse(email_context)
+			self.body = email_context.response_buffer
+		end
+		
+		def encoded
+			mail_obj.encoded
+		end
+		
+		def send
+			if @attachments
+				content_type = 'multipart/mime'
+				mime_version = '1.0'
+			end
+			generate_body unless body_generated?
+			if RUBY_VERSION =~ /^1\.8/
+				if smtp_connection
+					smtp_connection.send_message(mail_obj.encoded, from, recipients)
+				else
+					args = []
+					args.push smtp_account if smtp_account
+					args.push smtp_password if smtp_password
+					args.push authentication if authentication
+					Net::SMTP.start(smtp_server, smtp_port, helo_domain, *args) {|smtp| smtp.send_message(mail_obj.encoded, from, recipients) }
+				end
+                        else
+			  @mail_obj.delivery_method(:smtp, :address => self.smtp_server, :port => self.smtp_port)
+                          @mail_obj.deliver
+                        end
+		rescue Exception => e
+			Logger['iowa_log'].info "EMAIL SEND FAILED: #{e}\n#{e.backtrace.join("\n")}"
+		end
+		alias :send_email :send
+
+	end
+end

data/src/iowa/Extensions/AllExtensions.rb

@@ -0,0 +1,4 @@
+require 'iowa/Extensions/TimeExtensions'
+require 'iowa/Extensions/Class'
+require 'iowa/Extensions/Object'
+require 'iowa/Extensions/Hash'

data/src/iowa/Extensions/Class.rb

@@ -0,0 +1,94 @@
+class Class
+	# Return an array containing each of the subclasses of the class.
+	# Accepts an optional true/false argument (defaults to false).
+	# If false, only returns classes that can currently be instantiated.
+	# If true, returns all classes that currently exist.
+	def subclasses(all = false)
+		found = Hash.new
+		ObjectSpace.each_object(Class) do |klass|
+			next unless klass.ancestors.include?(self)
+			next if (klass == self) or found.has_key?(klass)
+			unless all
+				if class_exists?(klass)
+					found[klass] = true
+				end
+			else
+				found[klass] = true
+			end
+		end
+		found.keys
+	end
+
+	# Removes constant definitions for all subclasses of the current class.
+	def remove_subclasses
+		self.subclasses.each do |klass|
+			front = klass.name
+			if /::/.match(front)
+				front,back = parts(klass.name)
+				front_class = front.split('::').inject(Object) { |o,n| o.const_get n }
+				front_class.__send__(:remove_const, back)
+			else
+				Object.__send__(:remove_const, front)
+			end
+		end
+		nil
+	end
+
+	# Removes the current class, and all subclasses if true is passed as
+	# an argument.
+	def remove(all = false)
+		remove_subclasses if all
+		Object.__send__(:remove_const, self.name)
+		nil
+	end
+
+	def Class.remove_subclasses(superclass, all = false)
+		superclass.remove_subclasses(all)
+	end
+
+	def Class.remove(superclass, all = false)
+		superclass.remove(all)
+	end
+
+	def Class.class_by_name(name)
+			name.split('::').inject(Object) { |o,n| o.const_get n }
+	end
+
+	def Class.new_by_name(name, *args)
+		clean_name = String.new(name.untaint)
+		obj = nil
+		begin
+			obj = Class.class_by_name(clean_name).new(*args)
+		rescue Exception => e
+			begin
+				require clean_name
+				obj = Class.class_by_name(clean_name).new(*args)
+			rescue Exception
+				raise "Unable to create object for class #{clean_name}: #{e}" unless obj
+			end
+		end
+		obj
+	end
+
+	private
+
+        def parts(path)
+                pieces = path.split('::')
+		back = pieces.pop
+		front = pieces.join('::')
+		[front,back]
+        end
+
+	def class_exists?(klass)
+		front = klass.name
+		if /::/.match(front)
+			front, back = parts(front)
+			front_class = front.split('::').inject(Object) { |o,n| o.const_get n }
+			front_class.constants.include?(back)
+		else
+			Object.constants.include?(front)
+		end
+		rescue Exception
+			nil
+	end
+end