IOWA 1.0.0

data/src/iowa/Client.rb

@@ -0,0 +1,192 @@
+# Iowa::Client encapsulates the methods necessary to make a connection
+# to an Iowa servlet, receive the response back from the servlet, and to
+# deliver that response.
+
+require 'socket'
+require 'iowa/Request'
+require 'iowa/Response'
+require 'iowa/Constants'
+require 'time'
+
+module Iowa
+
+	class Client
+
+		EX_HEADERS = {CDate => true, CServer => true, CConnection => true, CContent_Type => true} unless const_defined?(:EX_HEADERS)
+
+		# When an Iowa::Client is created, it takes as its argument a
+		# socket definition.  It uses that definition to establish either
+		# a TCPSocket or a UNIXSocket to the servlet.
+		#
+		# The socket defenition can be either in the form of:
+		#   hostname:port
+		# or it can be a filesystem path.  If one uses the hostname:port
+		# form, then a TCPSocket will be used.  Otherwise, a UNIXSocket
+		# will be used.
+		
+		def initialize(sp)
+			@start_time = Time.now
+			socket_path = sp.dup
+			socket_path.untaint
+			tcp_pattern = Regexp.new('^([^:]*):(\d+)')
+			tcp_match = tcp_pattern.match(socket_path)
+			if tcp_match
+				# Connect to a TCP socket.
+				socket_host = tcp_match[1]
+				socket_port = tcp_match[2]
+				TCPSocket.do_not_reverse_lookup = true
+				@socket = TCPSocket.new(socket_host,socket_port)
+			else
+				@socket = UNIXSocket.new(socket_path)
+			end
+		end
+
+		# One calls initiate() to send the request off to the servlet.
+		
+		def initiate(request=nil)
+			@request = Iowa::Request.new_request(request)
+			m = Marshal.dump(@request)
+			@socket.write(m)
+			@socket.flush
+			@socket.shutdown(1)
+		end
+
+		# This receives the response back from the servlet.
+		
+		def receive
+			m = ''
+			while (recv = @socket.recv(8192)) != ""
+			  m << recv
+			end
+			@socket.close
+			@socket = nil
+			@response = Marshal.load(m)
+			@response.content_type = Ctext_html unless @response.content_type.to_s != C_empty
+		end
+
+		# Prints/sends the HTTP headers for the response.
+		
+		# This path selection for how to output the data is UGLY.  Make it better.
+		def printHeaders(ios=nil)
+			@response.calculate_runtime = false unless @response.content_type == Ctext_html
+			@response.content.sub!(/^[\s\r\n]*/m,C_empty)
+			calculate_runtime if @response.calculate_runtime
+			if ENV[CMOD_RUBY]
+				r = Apache.request
+				r.content_type = @response.content_type
+				r.status_line = @response.status_line if @response.status_line
+				r.status = @response.status if @response.status
+				@response.headers_out.each do |key,value|
+					r.headers_out.set(key,value.to_s)
+				end
+				r.headers_out.set(CContent_Length,@response.content.length.to_s)
+				r.send_http_header
+			elsif ::Object.const_defined?(:Mongrel) and !::Object.const_defined?(:EventMachine)
+				ios.status = @response.status
+#				@response.headers_out[CDate] ||= Time.now.httpdate
+				@response.headers_out[CExpires] ||= Time.now.httpdate
+				ioshead = ios.header
+			 	ioshead.out << "#{CContent_Type}: #{@response.content_type}\r\n"
+#				@response.headers_out[CContent_Length] = @response.content.length unless @response.headers_out[CContent_Length]
+				@response.headers_out.each do |key, value|
+					ioshead.out << "#{key}: #{value}\r\n"
+				end
+			elsif ios
+				outbuf = ''
+				@response.headers_out[CDate] ||= Time.now.httpdate
+				@response.headers_out[CExpires] ||= @response.headers_out[CDate]
+				outbuf << "Date: #{@response.headers_out[CDate]}\r\n"
+
+				@response.headers_out[CContent_Length] = @response.content.length unless @response.headers_out[CContent_Length]
+
+				@response.headers_out.each do |key, value|
+					next if EX_HEADERS.has_key? key
+					outbuf << "#{key}: #{value}\r\n"
+				end
+				outbuf << "Content-Type: #{@response.content_type}\r\n\r\n"
+				ios.print outbuf
+			else
+				@response.headers_out[CDate] ||= Time.now.httpdate
+				@response.headers_out[CExpires] ||= @response.headers_out[CDate]
+#				@response.headers_out[CServer] ||= ENV['SERVER_SOFTWARE']
+				puts "Date: #{@response.headers_out['Date']}"
+				puts "Content-Type: #{@response.content_type}"
+				if @response.headers_out['Content-Length']
+					EX_HEADERS['Content-Length'] = true
+				else
+					puts "Content-Length: #{@response.content.length}"
+				end
+				@response.headers_out.each do |key, value|
+					next if EX_HEADERS.has_key? key
+					puts "#{key}: #{value}"
+				end
+				puts ""
+			end
+		end
+
+		# Deliver the content of the request.
+		
+		def printBody(ios=nil)
+			unless @request.request_method == CHEAD
+				if ios
+					if ::Object.const_defined?(:Mongrel) and !::Object.const_defined?(:EventMachine)
+						ios.body << @response.content
+					else
+						ios.print @response.content
+					end
+				else
+					puts @response.content
+				end
+			end
+		end
+
+		def clearOld
+			@socket = nil
+			@request = nil
+			@response = nil
+		end
+		
+		# Deliver both the header and the content of the request, then clear
+		# the client.
+		
+		def print(ios = nil)
+			printHeaders(ios)
+			printBody(ios)
+			clearOld
+		end
+		
+		def calculate_runtime
+			@runtime = Time.now - @start_time
+			@response.content << "\n<!-- #{@runtime} -->\n"
+		end
+		
+		def handle_request(args = {:request => nil, :ios => nil})
+			initiate(args[:request])
+			receive
+			print(args[:ios])
+		end
+	end
+
+	# An InlineClient doesn't do any socket communications.  It just handles printing
+	# a response.
+	class InlineClient < Client
+		def initialize(request,response)
+			@request = request
+			@response = response
+			@start_time = Time.now
+		end
+
+		def reset(request,response)
+			@request = request
+			@response = response
+			@start_time = Time.now
+		end
+
+		def initiate; end
+		def receive; end
+
+		def handle_request(args = {:ios => nil})
+			print(args[:ios])
+		end
+	end
+end

data/src/iowa/Component.rb

@@ -0,0 +1,405 @@
+require 'iowa/JSON-lexer'
+require 'iowa/caches/SimpleLRUCache'
+require 'iowa/Monkey'
+module Iowa
+
+	# Provides high level functionality for all component subclasses.
+	# Each "page" in an Iowa app is a Component subclass.
+
+	class Component < Element
+		include Iowa::Caches::SimpleLRUCache::Item
+
+		@max_cache_entries = nil
+		def self.max_cache_entries; @max_cache_entries; end
+		def self.MaxCacheEntries(val=nil)
+			if val
+				@max_cache_entries = val
+			else
+				@max_cache_entries
+			end
+		end
+
+		@@serializeCompiledTemplate = true
+
+		def Component.serializeCompiledTemplate
+			@@serializeCompiledTemplate
+		end
+
+		def Component.serializeCompiledTemplate=(val)
+			@@serializeCompiledTemplate = val
+		end
+
+		def Component.bindings
+			{}
+		end
+
+	  # Returns the template for the component.
+
+		def Component.template
+			Iowa.app.templateForComponent(self.name)
+		end
+
+	  # Finds and returns the named component.  Other methods calling this
+	  # one with different values for session and prevPage could induce some
+	  # interesting (or bizarre) behaviors.  See pageNamed(name) below for
+	  # the standard invocation.
+
+		def Component.pageNamed(name, session, prevPage=nil,import_attempted=nil,raise_exception=true)
+			Iowa.app.reloadModified(name,true)
+			klass = ElementClasses[name.to_s.downcase]
+			if(klass && klass.ancestors.include?(Component))
+				page = klass.new(Cpage, {}, {}, prevPage)
+				page.prevPage = prevPage
+				page.session = session
+				page
+			else
+				if !import_attempted
+					import_attempted = true
+					Iowa::Log.info("Attempting to import #{name} as a #{self.name}")
+					Iowa.app.import(name,self.name)
+					pageNamed(name.capitalize,session,prevPage,true,raise_exception)
+				elsif raise_exception
+					session.context.response.status = 404
+					raise "#{name}: No component found."
+				else
+					nil
+				end
+			end
+		end
+
+	  # Provides a method to define component attributes which another
+	  # component can bind to.
+	
+		def Component.attr_binding(*symbols)
+			symbols.each do |symbol|
+				class_eval %{
+					def #{symbol}
+						if @bindings.has_key?('#{symbol}')
+							@bindings['#{symbol}'].get(@parent)
+						else
+							nil
+						end
+					end
+					def #{symbol}=(val)
+						if @bindings.has_key?('#{symbol}')
+							@bindings['#{symbol}'].set(@parent, val)
+						else
+							@bindings['#{symbol}'] = LiteralAssociation.new(val)
+						end
+					end
+				}
+			end
+		end
+	
+		# If fingerprint is overridden to return a non-nil value, that value will
+		# be used as a cache key for the rendered content.  If a future request
+		# returns the same fingerprint, the cached content will be returned.
+		# IOWA will not permit any session-specific renderings to be cached.
+		def fingerprint
+			nil
+		end
+
+	  # Standard invocation of Component.pageNamed.  Returns the component
+	  # corresponding the the given name.
+	
+		def page_named(name, *args)
+			my_name = self.class.name.gsub(/Iowa::Application::ContentClasses::/,C_empty).split(ClassSeparator)
+			my_name.pop
+			my_name << name
+			#relative_name = "#{my_name.join('::')}::#{name}"
+			relative_name = my_name.join(ClassSeparator)
+
+			iter = 0
+			component = nil
+			loop do
+				begin
+					if ElementClasses.has_key?(relative_name.downcase)
+						break component = Component.pageNamed(relative_name, @session, self)
+					else
+						if iter < 1
+							iter += 1
+							Iowa.app.reloadModified(relative_name,true)
+							raise "retry"
+						else
+							break component = Component.pageNamed(name, @session, self)
+						end
+					end
+				rescue
+					retry
+				end
+			end
+			args.each do |arg|
+				if arg.respond_to?(:each)
+					arg.each {|k,v| component.__send__(k,v)}
+				else
+					component.__send__(arg)
+				end
+			end
+
+			component
+		end
+		alias :pageNamed :page_named
+		alias :componentNamed :page_named
+		alias :component_named :page_named
+
+		# Define a method called "meth" to show the page named "page".
+		def self.proceed(meth, page)
+			module_eval(<<-EVAL)
+				def #{meth}
+					yield page_named('#{page}')
+				end
+			EVAL
+		end
+
+		# Define a method called "meth" to show the page named "page"
+		# after executing the "block" in the destination page's context.
+		def self.proceed_with(meth, page, &block)
+			define_method("__#{meth}__primer__".intern, block)
+			module_eval(<<-EVAL)
+				def #{meth}
+					p = page_named('#{page}')
+					__#{meth}__primer__(p)
+					yield p
+				end
+			EVAL
+		end
+
+
+		# Default to individual components allowing themselves to be docroot cached.
+		# To change this, in the component, one can use the class method:
+		# 
+		#   disallow_docroot_caching
+		#
+		# or the object method:
+		#
+		#   self.allow_docroot_caching = false
+
+		attr_accessor :session, :prevPage, :subcomponents, :parent, :creation_time
+
+	  # Handle the initial tasks that establish the state of the new object.
+
+		def initialize(name, bindings, attributes, parent)
+			self.cacheable = true unless @cacheable == false
+			self.replaceable = false unless replaceable?
+			self.fragment = false unless fragment?
+			@creation_time = Time.now
+			@parent = parent
+			@session = parent ? parent.session : nil
+
+			self.allow_docroot_caching = false if allow_docroot_caching?.nil?
+
+			@subcomponents = {}
+			super(name, bindings, attributes)
+
+			awake()
+		end
+
+		def context
+			@session.context
+		end
+
+		def url_for_id
+			@session.context.url_for_id
+		end
+
+		def cacheable
+			@cacheable
+		end
+
+		def cacheable?
+			@session.context[:request_cacheable] || cacheable
+		end
+
+		def cacheable=(val)
+			@cacheable = val ? true : false
+		end
+
+		def replaceable
+			@replaceable
+		end
+
+		def replaceable?
+			replaceable
+		end
+
+		def replaceable=(val)
+			@replaceable = val ? true : false
+		end
+
+		def fragment
+			@fragment
+		end
+
+		def fragment=(val)
+			@fragment = val ? true : false
+		end
+
+		def fragment?
+			fragment
+		end
+
+		def self.allow_docroot_caching
+			@allow_docroot_caching = true
+		end
+
+		def self.disallow_docroot_caching
+			@allow_docroot_caching = false
+		end
+		
+		def self.allow_docroot_caching?
+			@allow_docroot_caching
+		end
+
+		def allow_docroot_caching?
+			self.class.allow_docroot_caching?
+		end
+
+		def allow_docroot_caching=(val)
+			klass = self.class
+			val ? klass.allow_docroot_caching : klass.disallow_docroot_caching
+		end
+
+	  # Stub, intended to be overridden in the subclasses, to define behavior
+	  # that occurs only once, when the object is first created.
+
+		def awake
+		end
+
+	  # Stub, intended to be overridden in the subclasses, to define behavior
+	  # that occurs when backtracking.
+
+		def handle_backtrack
+		end
+		alias :handleBacktrack :handle_backtrack
+
+		# Stub, intended to be overridden in the subclasses, to define behavior
+		# that occurs each time the component is displayed.
+		
+		def setup
+		end
+
+		# Takes the result of some method, plus the id of the originating
+		# JSON-RP call, and creates the JSON-RPC reponse
+		def format_repsonse( result, error, id )
+		quote = '"'
+			'{ "result" : ' + result.to_json + 
+				', "error":"' + error.to_s + 
+				'", "id": ' +  quote +  id.to_s + quote + ' }'
+		end
+		
+		def json_methods
+			[:list_methods]
+		end
+
+		def list_methods
+			json_methods
+		end
+
+		# Sets up a standard method that will return a URL for handling JSON-RPC
+		# requests.
+		def json
+			session.resource_url do
+				# Get the request info
+				content = @session.context.response.body
+				
+				# Create new JSON lexer
+				jsonobj = {}.from_json(JSON::Lexer.new(content))
+				# Decode request
+				r = nil
+				error = nil
+				# Verify that it is for an allowed method
+				# Call Method
+				params = jsonobj[Cparams] ? jsonobj[Cparams] : []
+				
+				begin
+					if json_methods.include?(jsonobj[Cmethod].to_sym)
+						r = params.size < 1 ?
+							self.__send__(jsonobj[Cmethod]) :
+							self.__send__(jsonobj[Cmethod], *jsonobj[Cparams])
+					end
+				rescue Exception => e
+					error = e.to_s
+				end
+				# Return Resource
+				Iowa::Resource.new(format_repsonse( r, error, jsonobj[Cid] || Cdefault ),Ctext_javascript)
+			end
+		end
+
+	  # Returns the Application object.
+
+		def application
+			Iowa.app
+		end
+	
+	  # Trigger an action on the component.
+	
+		def invokeAction(action, args, &b)
+			arty = method(action).arity
+			if args.length == arty or arty == -1
+				__send__(action, *args, &b)
+			end
+		end
+	
+		def handleResponse(context,return_response = false)
+			@template = self.class.template
+			setup
+			if return_response
+				old_response = context.response
+			end
+			handleRequestOrResponse(:handleResponse, context)
+			if return_response
+				context.response = old_response
+			end
+		end
+	
+		def handleRequest(context)
+			handleRequestOrResponse(:handleRequest, context)
+			end
+	
+		def handleRequestOrResponse(method, context)
+			Iowa.app.reloadModified(self.class.name,true)
+			
+			context.pushRoot self
+			@template.__send__(method, context)
+			context.popRoot
+		end
+	
+		def getBinding(binding)
+			@bindings[binding].get(@parent)
+		end
+	
+		def setBinding(binding, value)
+			@bindings[binding].set(@parent, value)
+		end
+	
+		def dup
+			copy = super
+			copy.subcomponents = {}
+			copy.creation_time = Time.now
+			@subcomponents.each do |name, child|
+				newChild = child.dup
+				newChild.parent = copy
+				copy.subcomponents[name] = newChild
+			end
+			copy
+		end
+	
+		def back; yield @prevPage if @prevPage; end
+	
+		def reload; end
+	
+		# This is a default method_missing handler that will keep Ruby from going
+		# down the path of a very, very long backtrace generation in the event
+		# of this kind of error (which is an easy error to make).
+		
+		def method_missing(*args)
+			raise "Method missing: #{args.inspect}"
+		end
+
+		def method_missing(*args)
+			Monkey.new("@#{args[0]}")
+		end
+			
+	end
+
+end