nitro 0.1.2

data/lib/n/shaders.rb

@@ -0,0 +1,167 @@
+# = Shader
+#
+# The equivalent of a 3d engine shader. Converts the page representation 
+# to the html output. Actually converts it to a dynamic page ready for
+# evaluation.
+#
+# === Design:
+#
+# We follow the xp methodology: the shader as simple as possible.
+# In the future we may add mulitple xsls (xsl pipeline) but
+# we done need them now, so we wont code them!
+#
+# - when compiling get the default shader and keep it in the
+#   script structure.
+#
+#   noo better push them in a request stack!
+#
+# - when rendering:
+#	if there is an override shader use it! (example: inject shader)
+#	if there is a parent shader use it!
+#	if there is a script shader use it!
+#	if there is a user shader use it!
+#	if there is an app shader use it!
+#	no shading!
+#
+# === Think:
+#
+# - are inject override shaders possible ? (no they are
+#   dynamic)
+#
+# === TODO:
+#
+# - add monitoring support for xsl's.
+#
+# code:
+# George Moschovitis  <gm@navel.gr>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: shaders.rb 89 2004-10-20 12:55:58Z gmosx $
+
+module N;
+
+# = Shader
+#
+# One shader can utilize several xsls to render different pages.
+# the shader selection may be time consuming but is performed once
+# when transforming the script, so its essentially for free (and
+# anyway the xsl transoformation is orders of magnitude slower)
+#
+# There is no need to keep post xsl. I can reuse the same xsl 
+# by calling transform again. 
+#
+class Shader
+	attr_accessor :name
+	attr_accessor :xsl_filename
+	# the xslt transoformer.
+	attr_accessor :xslt
+	attr_accessor :mtime
+	
+	def initialize(name, xsl_filename)
+		# leave this require here. only inlcude the xslt 
+		# library if the project needs it.
+		require "xml/xslt"
+
+		@name = name
+		@xsl_filename = xsl_filename
+		@xslt = XML::XSLT.new
+		parse_xsl!
+	end
+	
+	# transform the given document
+	#
+	def xsl_transform(document)
+		@xslt.xml = document
+		return @xslt.serve()
+	end
+	alias_method :transform, :xsl_transform
+	
+	def xsl
+		parse_xsl! if $reload_xsl
+		return @xsl
+	end
+	
+	def to_s
+		@name
+	end
+	
+private 
+	
+	# Parse the xsl.
+	#
+	def parse_xsl!
+		$log.debug "Parsing xsl '#{@xsl_filename}'" if $DBG
+		@mtime = File.stat(@xsl_filename).mtime
+		@xslt.xsl = File.read(@xsl_filename)
+	end
+
+end
+
+# = NilShader
+#
+# A shader that does absolutely nothing.
+#
+# === WARNING: not tested.
+#
+class NilShader < Shader
+	def initialize
+		@name = "nil"
+		@mtime = Time.at(0)
+	end
+
+	# No transform, just convert to a String.	
+	def transform(document)
+		return document.to_s
+	end
+end
+
+# = ShaderManager
+#
+# Manages the shaders for the webapp.
+#
+# TODO: integrate with sitemap.
+#
+# === Design:
+#
+# - the shader selection may be time consuming but is performed once
+#   when transforming the script, so its essentially for free (and
+# 	anyway the xsl transoformation is orders of magnitude slower)
+#
+class ShaderManager
+	# corresponding arrays
+	attr_accessor :regex, :shaders 
+	attr_accessor :default_shader
+
+	def initialize
+		@regex = []
+		@shaders = []
+	end
+
+	def set_default(shader)
+		@default_shader = shader
+	end
+
+	def add(regex, shader)
+		@regex << regex
+		@shaders << shader
+	end
+
+	def shader_for_path(path)
+		@regex.each_with_index { |rx, idx|
+			if path =~ rx
+				return @shaders[idx]
+			end
+		}
+		return @default_shader
+	end
+
+	def delete(regex)
+		if idx = @regex.index(regex)
+			@regex.delete_at(idx)
+			@shaders.delete_at(idx)
+		end
+	end
+
+end
+
+end # module;

data/lib/n/sitemap.rb

@@ -0,0 +1,188 @@
+# = SiteMap
+#
+# Encapsulates the page structure and additional metadata.
+#
+# === TODO:
+#
+# move out of the UI namespace.
+# include url remapping functionality.
+# 
+# === Design
+# 
+# Unlike the original version, this is presentation agnostic, and 
+# greatly simplified.
+#
+# === Todo:
+#
+# - support strings as titles.
+# - add support to read the map from a config file.
+# - rename to appmap ? 
+#
+# code: 
+# George Moschovitis  <gm@navel.gr>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: sitemap.rb 71 2004-10-18 10:50:22Z gmosx $
+
+require "n/utils/hash"
+
+module N
+
+# = SitePage
+#
+class SitePage
+	# the uri for this page
+	attr_accessor :uri
+	# the real uri to this page calculated by the page overloader)
+	attr_accessor :real_uri
+	attr_accessor :realm
+	# the shader for this page, overrided the shader calculated
+	# by the engine
+	attr_accessor :shader
+	attr_accessor :level
+	# title of the page
+	attr_accessor :title
+	# description of the page
+	attr_accessor :description
+	attr_accessor :parent, :children
+	attr_accessor :flag
+	
+	# the realm this page belongs to, typically the part name.
+	# put symbols in this variable
+	attr_accessor :realm
+
+	def initialize(uri, title = nil, parent = nil, realm = nil)
+		@uri, @title, @parent = uri, title, parent
+
+		# inherit realm from parent if exists
+		if parent and parent.realm
+			@realm = parent.realm 
+		else
+			@realm = realm
+		end
+
+		@children = []
+		@parent.children << self if parent
+
+		# gmosx: is this good?
+		# automatically add to the sitemap.		
+		$sitemap << self		
+	end
+	
+	# Return string representation
+	#
+	def to_s
+		return @title
+	end
+end
+
+# = SiteMap
+# 
+# === TODO:
+# Use a second class in the UI namespace for rendering 
+# related stuff?
+#
+class SiteMap < N::SafeHash
+
+	# The root page for this sitemap
+	attr_accessor :root
+	
+	# The separator used when creating paths
+	attr_accessor :separator
+
+	def initialize(separator = " > ")
+		super
+		@separator = separator
+	end
+
+	def << (page)
+		self[page.uri] = page
+		unless page.parent
+			@root = page
+			page.realm = :root
+		end
+	end
+
+	# Path as array of pages
+	#
+	def path(uri)
+		return nil unless uri
+		
+		if page = self[uri]
+			res = Array.new;
+			
+			res << page
+			while page = page.parent
+				res.unshift(page)
+			end
+			
+			return res
+		else
+			$log.warn "The uri #{uri} is not registered in the SiteMap!"
+		end
+		
+		return nil
+	end
+		
+	# Calculates the linked path to the given uri.
+	#
+	def linked_path(uri, lc = nil, args = nil)
+	  if the_path = path(uri)
+			i = -1
+			j, s = 0, the_path.size()
+			return the_path.collect { |p|
+				j += 1
+				if p.title.is_a?(String)
+					j == s ? p.title : %|<a href="#{p.uri}">#{p.title}</a>|					
+				elsif p.title.is_a?(Symbol)
+					j == s ? lc[p.title] : %|<a href="#{p.uri}">#{lc[p.title]}</a>|
+				else
+					i += 1
+					title, qs = p.title.call(args[i])
+					j == s ? title : %|<a href="#{p.uri}#{qs}">#{title}</a>|				
+				end
+			}.join(@separator)
+			
+		else
+			return nil
+		end
+	end
+	
+	# Calculates the path to the given uri.
+	#
+	def str_path(uri, lc = nil, args = nil)
+	  if the_path = path(uri)
+			i = -1
+			return the_path.collect { |p| 
+				if p.title.is_a?(String)
+					p.title
+				elsif p.title.is_a?(Symbol)
+					lc[p.title]
+				else
+					i += 1
+					p.title.call(args[i])[0]
+				end
+			}.join(@separator)
+		else
+			return nil
+		end
+	end
+
+	# Returns a String representation of the Sitemap.
+	# 	
+	def to_s
+		str = "#{root}"
+		arr = []
+		self.each_pair { |page, title|
+				arr << "#{title}: #{page}"
+		}
+		return "#{str} {" + arr.join(",") + "}"
+	end
+
+end
+
+end # module
+
+# the default sitemap.
+$sitemap = N::SiteMap.new
+

data/lib/n/std.rb

@@ -0,0 +1,69 @@
+# = Navel Software Technology
+#
+# code: gmosx, drak, ekarak
+#
+# (c) 2001-2004 Navel, all rights reserved.
+# $Id: std.rb 71 2004-10-18 10:50:22Z gmosx $
+
+# we want readable code
+
+require "English"
+require "pp"
+
+class NilClass
+	# to_i, to_s are handled by default.
+	
+	def to_i
+		return nil
+	end
+	
+	def to_f
+		return 0.0
+	end
+	
+	# quite usefull for error tolerant apps.
+	# a bit dangerous though.
+	#
+	def empty?
+		return true
+	end
+end
+
+#
+#
+class Class
+	def to_i()
+		return self.hash()
+	end
+end
+
+#
+#
+module Kernel
+	# pretty prints an exception/error object
+	# usefull for helpfull debug messages
+	#
+	# Input:
+	# The Exception/StandardError object
+	#
+	# Output:
+	# the pretty printed string
+	#
+	def pp_exception(ex)
+		return %{#{ex.message}\n\tBACKTRACE:\n\t#{ex.backtrace.join("\n\t")}\n\tLOGGED FROM:\n\t#{caller[0]}}
+	end
+
+end
+
+# predefine some comonly used objects
+
+EMPTY_STRING = ""
+
+# This the default 72 chars separator, copy paste to use it
+# in your source file. Btw all lines in your source file should 
+# be less than 72 chars. So you can use this as a ruler if your 
+# editor does not support it.
+
+#-----------------------------------------------------------------------
+
+

data/lib/n/sync/clc.rb

@@ -0,0 +1,108 @@
+#!/usr/local/bin/ruby -w
+
+# = A Command Line Client (clc) for the Sync Server
+#
+# code: tml, drak
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: clc.rb 71 2004-10-18 10:50:22Z gmosx $
+
+require "logger"
+require "socket"
+require "thread"
+require "timeout"
+require "getoptlong"
+
+@opts = GetoptLong.new(
+  [ "--server", "-s", GetoptLong::REQUIRED_ARGUMENT ],
+  [ "--port", "-p",  GetoptLong::REQUIRED_ARGUMENT ],
+  [ "--file", "-f", "-l", GetoptLong::REQUIRED_ARGUMENT ]
+)
+
+def prompt
+	printf(Time.now.strftime("%H:%M:%S> "))
+end
+
+def connect(srv, port)
+	begin
+		@socket = TCPSocket.new(srv, port)
+	rescue
+		$log.error "Cannot connect to server, is it online?"
+		exit(0)
+	end
+	$log.info "Connected to #{@socket.addr[3]}:#{@socket.addr[1]}"
+end
+
+def send(str)
+	$log.info "write: #{str}"
+	@socket.send("#{str}\000", 0)
+end
+
+def read()
+	begin
+		loop do
+			timeout(0.7) do
+				while @socket.readline("\000")
+					$log.info "read: #{$_}"
+				end
+			end
+		end
+	rescue TimeoutError
+		#drink it
+	end
+end
+
+def write(cmd)
+	if cmd = cmd.strip() and not cmd.empty?
+		send(cmd)
+	 else
+		 $log.error "Syntax error"
+	 end
+end
+
+if __FILE__ == $0
+
+	$log = Logger.new(STDERR)
+
+	@opts.each { |opt, arg|
+		case opt
+			when "--file"
+				@file = File.new(arg)
+			when "--server"
+				@server = arg
+			when "--port"
+				port = port.to_i
+		end
+	}
+
+	@server ||= "localhost"
+	@port ||= 2121
+	
+	connect(@server, @port)
+	
+	reader = Thread.new {
+		loop do
+			read()
+		end
+	}
+
+	writer = Thread.new {
+		# replay input file
+		if @file
+			@file.each_line { |cmd|
+				write(cmd)				
+			}
+		end
+
+		# normal rep loop
+		loop do
+			prompt()
+			cmd = gets()
+			write(cmd)
+		end
+	}
+
+	reader.join()
+	writer.join()
+	
+end