nitro 0.1.2

data/lib/n/ui/pager.rb

@@ -0,0 +1,187 @@
+# = Pager
+#
+# code: gmosx
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: pager.rb 71 2004-10-18 10:50:22Z gmosx $
+
+module N; module UI
+
+# === Design:
+#
+# The new version is carefully designed for scaleability. It stores 
+# only the items for one page.
+# The name parameter is needed, multiple pagers can coexist in
+# a single page. Unlike the v1/v2 pagers this pager leverages the 
+# SQL LIMIT option to optimize database interaction.
+#
+# The pager does not extend Array (it includes an Array instead) to
+# avoid a concat() in the initialization step. 
+#
+# TODO:
+# - Extend from array? (would be more elegant)
+#
+# === Example:
+#
+# INVESTIGATE:
+# mysql> SELECT SQL_CALC_FOUND_ROWS * FROM tbl_name
+#    -> WHERE id > 100 LIMIT 10;
+#	mysql> SELECT FOUND_ROWS();
+#
+class Pager < Array
+	attr_accessor :name, :idx, :page, :page_count 
+	# total count of items
+	attr_accessor :total_count
+	# page items
+	attr_accessor :page_items
+	# read needed variables from the request.
+	attr_accessor :request
+	
+	def initialize(name, request, items_per_page, items = nil)
+		raise "items_per_page should be > 0" unless items_per_page > 0
+	
+		@request, @name = request, name
+		@page = request.get("__pg#{@name}", 1)
+		@items_per_page = items_per_page
+		@start_idx = (@page - 1) * items_per_page
+		
+		if items
+			set(items.size())			
+			# gmosx, FIXME: not exactly what i want!
+			items.slice!(@start_idx, @items_per_page)
+		end
+	end
+	
+	def set(total_count)
+		@total_count = total_count
+		@page_count = (@total_count.to_f() / @items_per_page).ceil()
+	end
+	
+	def first_page
+		return 1
+	end
+	
+	def last_page 
+		return @page_count
+	end
+	
+	def previous_page
+		return [@page - 1, 1].max()
+	end
+	
+	def next_page
+		return [@page + 1, @page_count].min()
+	end
+	
+	# Iterator
+	#
+	def each(&block)
+		@page_items.each(&block)
+	end
+	
+	# Iterator
+	# Returns 1-based index.
+	#
+	def each_with_index
+		idx = @start_idx
+		for item in @page_items
+			yield(idx + 1, item)
+			idx += 1
+		end
+	end
+	
+	def empty?
+		return @items.empty?
+	end
+	
+	def size
+		return @items.size()
+	end
+	
+	# Returns the range of the current page.
+	#
+	def page_range
+		s = @idx
+		e = [@idx + @items_per_page - 1, all_total_count].min
+		
+		return [s, e]
+	end
+	
+	# Override if needed.
+	#
+	def nav_range
+		# effective range = 10 pages.
+		s = [@page - 5, 1].max()
+		e = [@page + 9, @page_count].min()
+		
+		d = 9 - (e - s)
+		e += d if d < 0
+		
+		return (s..e)
+	end
+	
+	# Override this method in your application
+	# if needed.
+	# TODO: better markup.
+	#
+	def navigation
+		nav = ""
+		
+		unless @page == first_page()
+			nav << %{
+				<div class="first"><a href="#{target_uri(first_page())}">����</a></div>
+				<div class="previous"><a href="#{target_uri(previous_page())}">�����������</a></div>
+			}
+		end
+		
+		unless @page == last_page()
+			nav << %{
+				<div class="last"><a href="#{target_uri(last_page())}">�����</a></div>
+				<div class="next"><a href="#{target_uri(next_page())}">�������</a></div>
+			}
+		end
+
+		nav << %{<ul>}
+		
+		for i in nav_range()
+			if i == @page
+				nav << %{
+					<li class="active">#{i}</li>
+				}
+			else
+				nav << %{
+					<li><a href="#{target_uri(i)}">#{i}</a></li>
+				}			
+			end
+		end
+		
+		nav << %{</ul>}
+		
+		return nav
+	end
+
+	# Create an appropriate SQL limit clause.
+	# Returns postgres/mysql compatible limit.
+	#
+	def sql_limit
+		if @start_idx > 0
+			return "LIMIT #{@items_per_page} OFFSET #{@start_idx}"
+		else
+			# gmosx: perhaps this is optimized ? naaaaaah...
+			return "LIMIT #{@items_per_page}"
+		end
+	end
+	
+	# ------------------------------------------------------------------
+	
+	# Generate the target URI.
+	# 
+	def target_uri(page)
+		params = {"__pg#{@name}" => page}
+		return N::UriUtils.update_query_string(@request.uri, params)
+	end
+	private :target_uri
+
+end
+
+end; end # module

data/lib/n/ui/popup.rb

@@ -0,0 +1,45 @@
+# = Popup
+#
+# code: gmosx
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: popup.rb 71 2004-10-18 10:50:22Z gmosx $
+
+module N; module UI
+
+# = Popup
+#
+class Popup
+
+	#  Emit the needed javascript.
+	#  Alternatively use this code: <script src="/r/js/std.js">#{}</script>
+	# 
+	def self.script
+%[
+function newWin(url, name, w, h, scroll) {
+	var pleft = (screen.width - w) / 2;
+	var ptop = (screen.height - h) / 2;
+	var settings = 'height=' + h + ',width=' + w + ',top=' + ptop + ',left=' + pleft + ',scrollbars=' + scroll + ',resizable';
+
+	win = window.open(url, name, settings);
+
+	return false;
+}
+]
+	end
+
+	# gmosx: keep the leading / to be IE friendly.
+	#
+	def self.onclick(uri, width, height, title = "Popup", type="PAGE", options = "scrollbars=yes,resizable", container = "/p/glue/popup.sx")
+		%[javascript: var pwl = (screen.width - #{width}) / 2; var pwt = (screen.height - #{height}) / 2; window.open('#{container}?uri=#{uri};type=#{type}', '#{title}', 'width=#{width},height=#{height},top='+pwt+',left='+pwl+', #{options}'); return false"]		
+	end	
+	
+	# gmosx: keep the leading / to be IE friendly.
+	#
+	def self.link(uri, width, height, link = "link", title = "Popup", type="PAGE", options = "scrollbars=yes,resizable", container = "/p/glue/popup.sx")
+		%[<a href="#" onclick="#{self.onclick(uri, width, height, title, type, options, container)}">#{link}</a>]
+	end
+end
+
+end; end # module
+

data/lib/n/ui/select.rb

@@ -0,0 +1,41 @@
+# = Select
+#
+# code: gmosx
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: select.rb 71 2004-10-18 10:50:22Z gmosx $
+
+module N; module UI
+
+class Select
+
+# Generalized select. Dont create the enclosing selects to
+# be flexible.
+# Example:
+#
+# <select name="param" onchange="submit()">
+# 	#{N::UI::Select.render_options(
+#		paramvalue,
+#		[-1, 1, 2, 3],
+#		["-- Enter Options --", "Man", "Woman", "None"]
+#	)}
+# </select>
+#
+def self.render_options(paramvalue, values, options)
+	str = ""
+	
+	values.each_with_index { |val, idx|
+		if paramvalue == val
+			str << %{<option value="#{val}" selected="1">#{options[idx]}</option>}
+		else
+			str << %{<option value="#{val}">#{options[idx]}</option>}
+		end
+	}
+	
+	return str
+end
+
+end 
+
+end; end # module
+

data/lib/n/ui/tabs.rb

@@ -0,0 +1,34 @@
+# = Tabs
+#
+# code: gmosx
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: tabs.rb 71 2004-10-18 10:50:22Z gmosx $
+
+module N; module UI
+
+	# Render a tabs bar
+	#
+	# Example:
+	#
+	# #{N::UI.tabs(request,
+	#		["Page1", "Page2", "Page3"]
+	#	}
+	#
+	def self.tabs(request, options, param)
+		tabs = []
+	
+		selected = request.get(param, 0)
+		
+		options.each_with_index { |opt, idx|
+			if idx == selected
+				tabs << %|<strong>#{opt}</strong>|
+			else
+				tabs << %|<a href="#{request.expand_uri(param => idx)}">#{opt}</a>|
+			end
+		}
+		
+		return %|<div class="tabs">#{tabs.join('<span class="sep">|</span>')}</div>| 
+	end
+	
+end; end # module

data/lib/n/utils/array.rb

@@ -0,0 +1,92 @@
+# = General arrays utilities collection
+#
+# === Design:
+#
+# Implement as a module to avoid class polution. You can still Ruby's
+# advanced features to include the module in your class.
+# Passing the object to act upon allows to check for nil, which isn't
+# possible if you use self.
+#
+# code:: gmosx, ekarak
+#
+# (c) 2002-2003 Navel, all rights reserved.
+# $Id: array.rb 71 2004-10-18 10:50:22Z gmosx $
+
+require "sync"
+
+module N
+
+# == SafeArray
+#
+# A thread-safe array. We use a sync object instead of a mutex,
+# because it is re-entrant.
+# An exclusive lock is needed when writing, a shared lock IS NEEDED
+# when reading
+
+class SafeArray < Array
+	
+	attr :sync
+
+	# gmosx: delegator is not used.
+
+	def initialize(delegator = nil)
+		@sync = ::Sync.new()
+	end
+
+	def << (value)
+		return @sync.synchronize(::Sync::SH) {
+			super
+		}		
+	end
+	
+	def delete_if(&block) 
+		return @sync.synchronize(::Sync::SH) {
+			super
+		}				
+	end
+	
+	def [](key)
+		return @sync.synchronize(::Sync::SH) {
+			super
+		}
+	end
+
+	def []=(key, value)
+		return @sync.synchronize(::Sync::EX) {
+			super
+		}
+	end
+
+	def delete(key)
+		return @sync.synchronize(::Sync::EX) {
+			super
+		}
+	end
+
+	def clear
+		@sync.synchronize(::Sync::EX) {
+			super
+		}
+	end
+
+	def size
+		return @sync.synchronize(::Sync::SH) {
+			super
+		}
+	end
+
+	def shift
+		return @sync.synchronize(::Sync::EX) {
+			super
+		}
+	end
+
+	def unshift(el)
+		return @sync.synchronize(::Sync::EX) {
+			super
+		}
+	end
+		
+end # SafeArray
+
+end # module

data/lib/n/utils/cache.rb

@@ -0,0 +1,144 @@
+# = Cache
+#
+# Various caching mechanisms.
+#
+# code:
+# George Moschovitis  <gm@navel.gr>
+# Anastasios Koutoumanos  <ak@navel.gr>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: cache.rb 71 2004-10-18 10:50:22Z gmosx $
+
+module N;
+
+# = LRUCache
+#
+# A cache utilizing a simple LRU (Least Recently Used) policy.
+# The items managed by this cache must respond to the #key method.
+# Attempts to optimize reads rather than inserts!
+#
+# LRU semantics are enforced by inserting the items in a queue.
+# The lru item is always at the tail. Two special sentinels
+# (head, tail) are used to simplify (?) the code.
+#
+class LRUCache < Hash
+
+	# Mix this in your class to make LRU-managable.
+	#
+	module Item
+		attr_accessor :lru_key, :lru_prev, :lru_next
+	end
+
+	# head-tail sentinels
+	#
+	class Sentinel; include Item; end
+
+	# the maximum number of items in the cache
+	attr_accessor :max_items
+
+	# the head sentinel
+	attr :head
+	# the tail sentinel, tail.prev points to the lru item.
+	attr :tail
+
+	#
+	#	
+	def initialize(max_items)
+		@max_items = max_items
+		lru_clear()
+	end
+
+	# Lookup an item in the cache
+	#
+	def [](key)
+		if item = super
+			return lru_touch(item)
+		end
+	end
+
+	# The inserted item is considered mru!
+	#
+	def []=(key, item)
+		item = super
+		item.lru_key = key
+		lru_insert(item)
+	end
+
+	# Delete an item from the cache
+	#
+	def delete(key)
+		if item = super
+			lru_delete(item)
+		end
+	end
+
+	# Clear the cache
+	#
+	def clear
+		super
+		lru_clear()
+	end
+
+	# The first (mru) element in the cache
+	#
+	def first
+		@head.lru_next
+	end
+
+	# The last (lru) element in the cache
+	#
+	def last
+		@tail.lru_prev
+	end
+	alias_method :lru, :last
+
+	private
+
+	# Delete an item from the lru list.
+	#
+	def lru_delete(item)
+		lru_join(item.lru_prev, item.lru_next)
+		return item
+	end
+
+	# Join two items in the lru list
+	# Return y to allow for chaining
+	#
+	def lru_join(x, y)
+		x.lru_next = y
+		y.lru_prev = x
+		return y
+	end
+
+	# Append a child item to a parent item in the lru list
+	# (Re)inserts the child in the list.
+	#
+	def lru_append(parent, child)
+		lru_join(child, parent.lru_next)
+		lru_join(parent, child)
+	end
+
+	# Insert an item
+	#
+	def lru_insert(item)
+		delete(last.lru_key) if size() > @max_items
+		lru_append(@head, item)
+	end
+	
+	# Touch an item, make mru!
+	# Returns the item
+	#
+	def lru_touch(item)
+		lru_append(@head, lru_delete(item))
+	end
+	
+	# Clear the lru
+	#
+	def lru_clear
+		@head = Sentinel.new
+		@tail = Sentinel.new
+		lru_join(@head, @tail)
+	end	
+end
+
+end # module