IOWA 1.0.0

data/src/iowa/SessionStats.rb

@@ -0,0 +1,78 @@
+module Iowa
+
+	class SessionStats
+
+		def initialize(page_cache)
+			@creation_time = Time.now
+			@session_hits = 0
+			@rolling_interval = 60
+			@rolling_log = []
+			@page_cache = page_cache
+			@access_time = nil
+		end
+
+		def creation_time
+			@creation_time
+		end
+
+		def hits
+			@session_hits
+		end
+
+		def uptime
+			Time.now.to_i - creation_time.to_i
+		end
+
+		def hits_per_second
+			@session_hits > 0 ? (hits.to_f / uptime.to_f) : nil
+		end
+
+		def pages_maxsize
+			@page_cache.maxsize
+		end
+
+		def pages_size
+			@page_cache.size
+		end
+
+		def pages_queue
+			@page_cache.queue
+		end
+
+		def page(k)
+			!@page_cache[k].nil? ? @page_cache[k].dup : nil
+		end
+
+		def rolling_interval
+			@rolling_interval
+		end
+
+		def rolling_interval=(i)
+			@rolling_interval = i
+		end
+
+		def rolling_hits_total
+			@rolling_log.length
+		end
+
+		def rolling_hits_per_second
+			(@rolling_log.length.to_f / rolling_interval.to_f)
+		end
+
+		def access_time
+			@access_time
+		end
+
+		def hit
+			@session_hits += 1
+			@access_time = Time.now
+			n = @access_time.to_i
+			@rolling_log.push n
+
+			while (@rolling_log[0] < (n - @rolling_interval) and @rolling_log.length > 0)
+				@rolling_log.shift
+			end
+		end
+
+	end
+end

data/src/iowa/String.rb

@@ -0,0 +1,65 @@
+class String
+  alias :each :each_line
+end
+	
+module Iowa
+	class String < ::String
+		def unescape
+		 	   self.gsub(/\+/, ' ').gsub(/%([0-9a-fA-F]{2})/){ [$1.hex].pack("c") }
+		end
+
+		def unescape!
+			self.gsub!(/\+/, ' ')
+			self.gsub!(/%([0-9a-fA-F]{2})/){ [$1.hex].pack("c") }
+		end
+
+		def camelCase
+			return self if self == ''
+			parts = split(/[_\s]/)
+			Iowa::String.new(([parts[0].to_s.downcase] + parts[1..-1].collect {|x| x.capitalize}).join)
+		end
+		alias :camel_case :camelCase
+	
+		def camelCase!
+			replace(camelCase)
+		end
+		alias :camel_case! :camelCase!
+
+		def constantCase
+			return self if self == '' or (self =~ /^[A-Z]/ and self !~ /[_\s]/)
+			tmp = camelCase
+			tmp[0] = tmp[0].chr.upcase
+			Iowa::String.new(tmp)
+		end
+		alias :constant_case :constantCase
+
+		def constantCase!
+			replace(constantCase)
+		end
+		alias :constant_case! :constantCase!
+
+		# This still is not ideal.  Can be improved more.
+		#
+		def snake_case(group = true)
+			return self unless self =~ %r/[A-Z\s]/
+			reverse.scan(%r/[A-Z]+|[^A-Z]*[A-Z]+?|[^A-Z]+/).reverse.map{|word| word.reverse.downcase}.join('_').gsub(/\s/,'_')
+		end
+		alias :snakeCase :snake_case
+
+		def snake_case!
+			replace(snake_case)
+		end
+		alias :snakeCase! :snake_case
+
+		def human_case
+			snake_case.gsub('_',' ').capitalize
+		end
+		alias :humanCase :human_case
+
+		def human_case!
+			replace(human_case)
+		end
+		alias :humanCase! :human_case!
+
+	end
+end

data/src/iowa/Tag.rb

@@ -0,0 +1,101 @@
+require 'iowa/Constants'
+require 'iowa/Util'
+module Iowa
+
+# Superclass for all Iowa tags.  Tag provides a self referential
+# method to determine the tag's name, and to output opening and closing
+# HTML representations of the tag.
+
+class Tag < Element
+
+	# Return the name of the tag.
+
+	def tagName
+		if @bindings.has_key?(Ctag)
+			@bindings[Ctag].get
+		else
+			self.class.name.split(ClassSeparator).last.downcase
+		end
+	end
+		
+	# Output the HTML to open the tag.
+
+	def openTag(*args)
+		context = nil
+		if args.last.is_a?(Iowa::Context)
+			context = args.pop
+		end
+		#extraAttributes = Hash[*args]
+		if args.first.is_a? Hash
+			extraAttributes = args.first
+		else
+			extraAttributes = Hash[*args]
+		end
+		
+		newAttributes = @attributes.dup.update(extraAttributes)
+
+		if context
+			@bindings.each do |k,v|
+				next if Iowa::BindingKeywords.has_key?(k) and Iowa::BindingKeywords[k][1]
+				context.bound_tag = self
+				gb = context.getBinding(v)
+				newAttributes[k] = gb if gb
+				context.bound_tag = nil
+			end
+		end
+		
+		tag = "<#{tagName.downcase}"
+		newAttributes.each do |key, value| 
+			key = Cclass if key == Ctagclass
+			if value
+				value = Iowa::Util.escapeHTML(value.to_s)
+				tag << " #{key}=\"#{value}\""
+			else
+				tag << " #{key}=\"\""
+			end
+		end
+		tag << C_gt
+	end
+
+	def lonelyTag(*args)
+		context = nil
+		context = args.pop if args.last.is_a?(Iowa::Context)
+		if args.first.is_a? Hash
+			extraAttributes = args.first
+		else
+			extraAttributes = Hash[*args]
+		end
+		
+		newAttributes = @attributes.dup.update(extraAttributes)
+
+		if context
+			@bindings.each do |k,v|
+				next if Iowa::BindingKeywords.has_key?(k) and Iowa::BindingKeywords[k][1]
+				context.bound_tag = self
+				gb = context.getBinding(v)
+				newAttributes[k] = gb if gb
+				context.bound_tag = nil
+			end
+		end
+		
+		tag = "<#{tagName.downcase}"
+		newAttributes.each do |key, value| 
+			key = Cclass if key == Ctagclass
+			if value
+				value = Iowa::Util.escapeHTML(value.to_s)
+				tag << " #{key}=\"#{value}\""
+			else
+				tag << " #{key}=\"\""
+			end
+		end
+		tag << Clonely_tag_terminator
+	end
+	
+	# Output the HTML to close the tag.
+
+	def closeTag
+		"</#{tagName.downcase}>"
+	end
+end
+
+end

data/src/iowa/TemplateParser.rb

@@ -0,0 +1,236 @@
+module Iowa
+
+  # Parse a template for dynamic elements.
+  
+  class TemplateParser
+  
+    Bodyless = {}
+    MandatoryBody = {}
+
+    def TemplateParser.register_tag(tag, type = nil)
+      # Currently the code only does anything with tags that are
+      # :bodyless or :mandatory_body.
+      tag_type = tag.name.split(/::/).last.downcase
+
+      case type
+      when :bodyless
+        Bodyless[tag_type] = true
+      when :mandatory_body
+        MandatoryBody[tag_type] = true
+      end
+    end
+
+    #Bodyless = Iowa::Util.hash_from_array(%w(input hr option img))
+    #MandatoryBody = Iowa::Util.hash_from_array(%w(repeat table ul ol tr if unless a form select))
+    OID = "oid"
+    PatternString = "(<\\s*([^>]+?)\\s+([^>]*?" + OID +
+            "\\s*=('|\")\\s*(.*?)\\s*(\\4)[^>]*?(/)?\\s*)>)" +
+            "|" + "(@{1,2}([\\w.]+))"
+            
+    # Regexp constant that defines the regexp to use to parse the template
+    # for dynamic content tags.
+    Pattern = Regexp.new(PatternString)
+
+    # Constant that defines the position in Pattern of the dynamic tag data.
+
+    DynamicTag = 1
+    Tag = 2
+    Attributes = 3
+    ID = 5
+    Close = 7
+    WholeShortform = 8
+    Shortform = 9
+    OpenTag = Shortform + 1
+    CloseTag = Shortform + 2
+
+    def TemplateParser.strip_html(text)
+      attribute_key = /[\w:_-]+/
+      attribute_value = /(?:[A-Za-z0-9]+|(?:'[^']*?'|"[^"]*?"))/
+      attribute = /(?:#{attribute_key}(?:\s*=\s*#{attribute_value})?)/
+      attributes = /(?:#{attribute}(?:\s+#{attribute})*)/
+      tag_key = attribute_key
+      tag = %r{<[!/?\[]?(?:#{tag_key}|--)(?:\s+#{attributes})?\s*(?:[!/?\]]+|--)?>}
+      text.gsub(tag, C_empty).gsub(/\s+/, C_).strip
+    end
+
+    # Take the data to parse and the bindings for the template.
+    # Store each in object variables, and then parse the template
+    # data for dynamic tags.
+
+    def initialize(data, bindings, namespace = nil, dirname = '.')
+      @data = data
+      @nodestack = [Element.new(CtemplateRoot, {}, {}, data, bindings)]
+      @bindings = bindings
+      @namespace = namespace.name
+      @re_tag_cache = {}
+
+      @pos = 0
+      @length = @data.length
+      @len = @data.length
+      begin
+        loop do
+          match = Pattern.match(@data[@pos,@len])
+          break unless match
+
+          #@data = match.post_match
+          @pos += match.end(0)
+          @len = @length - @pos
+          textToken(match.pre_match)
+          parseTag(match)
+        end
+      rescue Exception => e
+        raise "#{e}: parsed error around #{$&}; #{e.backtrace.inspect}"
+      end
+
+      textToken(@data[@pos,@len])
+      if Iowa.config[Capplication][Cserialize_templates] && namespace.serializeCompiledTemplate
+        begin
+          File.open(File.join(dirname,".#{@namespace}.iwt"),'w+') do |fh|
+            Logger[Ciowa_log].info "Saving compiled template for #{@namespace}"
+            fh.print Marshal.dump(root)
+          end
+        rescue Exception
+        end
+      else
+        Logger[Ciowa_log].info "NOT Saving compiled template for #{@namespace}: #{Iowa.config[Capplication][Cserialize_templates]} & #{namespace.serializeCompiledTemplate}"
+      end
+    end
+    
+    # Return the last element of the nodestack.
+  
+    def root
+      @nodestack.last
+    end
+    
+    # Determine if a given tag is part of the set of bodyless tags.
+  
+    def bodyless?(tag)
+      Bodyless.has_key? tag.downcase
+    end
+    
+    def mandatory_body?(tag)
+      MandatoryBody.has_key? tag.downcase
+    end
+
+    # Parse the contents of a single tag.
+  
+    def parseTag(match)
+      if(match[Shortform])
+        if match[WholeShortform][0,2] == C_atat
+          startToken(Clink, match[Shortform], C_)
+        else
+          startToken(CdynamicString, match[Shortform], C_)
+        end
+        endToken
+        return
+      end
+  
+      startToken(match[Tag], match[ID], match[Attributes])
+      
+      if (match[Close] and !mandatory_body?(match[Tag])) || bodyless?(match[Tag])
+        endToken
+        return
+      end
+
+      if (match[Close] and mandatory_body?(match[Tag]))
+        Logger[Ciowa_log].warn("<#{match[Tag]}> marked as bodyless at character #{@pos}.  Overriding; <#{match[Tag]}> not allowed to be bodyless.")
+      end
+    
+      parseTagBody match[Tag]
+    end
+    
+    # Traverse a tag's body, looking for other dynamic elements embedded
+    # within it.
+  
+    def parseTagBody(tag)
+    
+      tagRE = reForTag(tag)
+      
+      openTags = 1
+      
+      while(openTags > 0)
+      
+        tagMatch = tagRE.match(@data[@pos,@len])
+        begin
+          #@data = tagMatch.post_match
+          @pos += tagMatch.end(0)
+          @len = @length - @pos
+        rescue Exception => exception
+          raise exception, "Error while trying to match tag: #{tag}"
+        end
+        
+        if(tagMatch[DynamicTag] || tagMatch[Shortform])
+          textToken(tagMatch.pre_match)
+          parseTag(tagMatch)
+  
+        elsif(tagMatch[OpenTag])
+          openTags += 1
+          textToken(tagMatch.pre_match + tagMatch[0])
+  
+        elsif(tagMatch[CloseTag])
+          openTags -= 1
+          textToken(tagMatch.pre_match) 
+          textToken(tagMatch[0]) unless openTags == 0
+        end
+      end
+    
+      endToken()
+    
+    end
+  
+    # Returns a regular expression object that matches either a dynamic
+    # element as defined in the global template parsing Pattern, or an
+    # opening element of the given tag (argument passed to the method)
+    # or a closing element of the given tag.
+  
+    def reForTag(tag)
+      unless @re_tag_cache.has_key?(tag)
+        @re_tag_cache[tag] = Regexp.new( PatternString +
+          "|" +
+          "(<\\s*" + tag + ".*?>)" +
+          "|" +
+          "(<\\s*/" + tag + "\\s*>)"
+        )
+      end
+      @re_tag_cache[tag]
+    end
+    
+    def startToken(tag, id, attributeString)
+      id = "_anon_#{@pos}_#{Time.now.to_f.to_s.gsub('.','')}" if id == C_ or id == C_anon_
+      bindings = @bindings[id]
+      bindings = {} unless bindings
+      
+      bindings[Ctag] = LiteralAssociation.new(tag)
+      
+      attributes = {}
+      attributeString.scan(/([\w\-]+)\s*=\s*(["'])(.*?)(\2)/) do |key, quote, value|
+        # Attributes with a key that match a binding keyword are treated as a binding.
+        key.downcase!
+        if value.index('@') == 0
+          bindings[key] = Iowa::PathAssociation.new(value[1..-1])
+        elsif key != Cvalue and Iowa::BindingKeywords.has_key? key
+          bindings[key] = Iowa::BindingKeywords[key].first.new(value)
+        else
+          attributes[key] = Iowa::Util.unescapeHTML(value) unless key == OID
+        end
+      end
+      klass = bindings[Cklass] ? bindings[Cklass].get : tag
+      # Kludge.  I want a regexp that can match both key=value attributes and
+      # key only attributes.
+      attributes[Cchecked] = nil if attributeString =~ /\bvalue\s*=\s*(["'])checked(\2)/i
+      node = Element.newElement(klass, id, bindings, attributes, @namespace)
+      @nodestack.last.addChild node
+      @nodestack.push node
+    end
+    
+    def endToken
+      @nodestack.pop
+    end
+    
+    def textToken(text)
+      @nodestack.last.addChild TextElement.new(text)
+    end
+  
+  end
+
+end