nitro 0.6.0 → 0.7.0

data/lib/glue/property.rb.old

@@ -0,0 +1,307 @@
+# code:
+# * George Moschovitis  <gm@navel.gr>
+# design:
+# * Anastastios Koutoumanos  <ak@navel.gr>
+# * Elias Karakoulakis  <ekarak@ktismata.com>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id: property.rb 185 2004-12-10 13:29:09Z gmosx $
+
+require "glue/array"
+require "glue/hash"
+
+module G
+
+# = Property
+#
+# Ruby attributes are typeless and generally this is good. Some times
+# we need extra metadata though, for example in relational mapping,
+# or web form population.
+#
+# Only Fixnums, Strings, Floats, Times, Booleans are converted.
+#
+# The default = methods do not force the  types. A special 
+# __force_set method should be used instead.
+#
+#--
+# TODO:
+# Inject only the really needd methods into Module.
+# Perhaps a sync is needed in evals (!!!!)
+#++
+#
+class Property
+	# the symbol of the property
+	attr_accessor :symbol
+	# the string representation of the symbol
+	attr_accessor :name
+	# the class of the property
+	attr_accessor :klass
+	# additional metadata (like sql declaratio, sql index, etc)
+	attr_accessor :meta
+	
+	def initialize(symbol, klass, meta = {})
+		@symbol, @klass = symbol, klass
+		@meta = meta
+		@name = @symbol.to_s()
+	end
+	
+	def ==(other)
+		return @symbol == other.symbol
+	end
+	
+	def to_s
+		return name
+	end
+end
+
+end # module
+
+class Module
+
+	# Define a property (== typed attribute)
+	# This works like Ruby's standard attr method, ie creates
+	# only one property. 
+	#
+	# Use the prop_reader, prop_writer, prop_accessor methods 
+	# for multiple properties.
+	#
+	# Examples:
+	#	prop String, :name, :sql => "char(32), :sql_index => "name(32)"
+	# --> creates only writer.
+	# prop Fixnum, :oid, writer = true, :sql => "integer PRIMARY KEY"
+	#	--> creates reader and writer.
+	# 
+	def prop(*params)
+		meta = {}
+		klass = Object
+		
+		for param in params
+			if param.is_a?(Class)
+				klass = param
+			elsif param.is_a?(Symbol)
+				symbol = param
+			elsif param.is_a?(TrueClass) or param.is_a?(TrueClass) 
+				writer = param
+			elsif param.is_a?(Hash)
+				# the meta hash.
+				meta = param
+			else
+				raise "Error when defining property!"
+			end
+		end
+
+		unless self.methods.include?(:__props)
+			eval %{
+				# Properties
+				# An array is used to enforce order.
+				def __props
+					@__props
+				end
+
+				def __props=(props)
+					@__props = props
+				end
+				
+				def __meta
+					@__meta
+				end
+
+				def __meta=(meta)
+					@__meta = meta
+				end				
+			}
+		end
+
+		@__props = G::SafeArray.new() unless @__props
+				
+		property = G::Property.new(symbol, klass, meta)
+		
+		reader = meta[:reader] || true
+		writer = writer || meta[:writer] || false
+		
+		__add_prop(property, reader, writer)
+	end
+
+	# Helper method. Accepts a collection of symbols and generates
+	# properties. Only generates reader.
+	#
+	# Example:
+	#	prop_reader String, :name, :title, :body, :sql => "char(32)"
+	#
+	def prop_reader(*params)
+		meta = {}
+		klass = Object
+		symbols = []
+
+		for param in params
+			if param.is_a?(Class)
+				klass = param
+			elsif param.is_a?(Symbol)
+				symbols << param
+			elsif param.is_a?(Hash)
+				# the meta hash.
+				meta = param
+			else
+				raise "Error when defining property!"
+			end
+		end
+		
+		meta[:reader] = true
+		meta[:writer] = false
+		
+		for symbol in symbols
+			prop(klass, symbol, meta)
+		end
+	end
+
+	# Helper method. Accepts a collection of symbols and generates
+	# properties. Only generates writer.
+	#
+	# Example:
+	#	prop_writer String, :name, :title, :body, :sql => "char(32)"
+	#
+	def prop_writer(*params)
+		meta = {}
+		klass = Object
+		symbols = []
+
+		for param in params
+			if param.is_a?(Class)
+				klass = param
+			elsif param.is_a?(Symbol)
+				symbols << param
+			elsif param.is_a?(Hash)
+				# the meta hash.
+				meta = param
+			else
+				raise "Error when defining property!"
+			end
+		end
+		
+		meta[:reader] = false
+		meta[:writer] = true
+		
+		for symbol in symbols
+			prop(klass, symbol, meta)
+		end
+	end
+
+	# Helper method. Accepts a collection of symbols and generates
+	# properties. Generates reader and writer.
+	#
+	# Example:
+	#	prop_accessor String, :name, :title, :body, :sql => "char(32)"
+	#
+	def prop_accessor(*params)
+		meta = {}
+		klass = Object
+		symbols = []
+
+		for param in params
+			if param.is_a?(Class)
+				klass = param
+			elsif param.is_a?(Symbol)
+				symbols << param
+			elsif param.is_a?(Hash)
+				# the meta hash.
+				meta = param
+			else
+				raise "Error when defining property!"
+			end
+		end
+		
+		meta[:reader] = true
+		meta[:writer] = true
+		
+		for symbol in symbols
+			prop(klass, symbol, meta)
+		end
+	end
+	
+	# Add the property
+	#
+	def __add_prop(prop, reader = true, writer = true)
+		if idx = @__props.index(prop)
+			# override in case of duplicates. Keep the order of the props.
+			@__props[idx] = prop
+		else
+			@__props << prop
+		end
+		
+		# Precompile the property read/write methods
+
+		s, klass = prop.symbol, prop.klass 
+
+		if reader		
+			module_eval %{
+				def #{s}
+					return @#{s}
+				end
+			}
+		end
+			
+		# gmosx: __force_xxx reuses xxx= to allow for easier
+		# overrides.
+		if writer 
+			module_eval %{
+				def #{s}=(val)
+					@#{s} = val
+				end
+				
+				def __force_#{s}(val)
+						self.#{s}=(} + case klass.name
+													when Fixnum.name
+														"val.to_i()"
+													when String.name
+														"val.to_s()"
+													when Float.name
+														"val.to_f()"
+													when Time.name
+														"Time.parse(val.to_s())"
+													when TrueClass.name, FalseClass.name
+														"val.to_i() > 0"
+													else
+														"val"
+												end + %{) 
+				end
+			}
+		end
+	end
+	
+	# Attach metadata 
+	#
+	def meta(key, val)
+		@__meta = G::SafeHash.new unless @__meta
+
+		@__meta[key] = [] unless @__meta[key]
+
+		# guard against duplicates, no need to keep order.
+		@__meta[key].delete_if { |v| val == v }
+		@__meta[key] << val			
+	end
+	
+	# This method is typically called before including other
+	# modules to preserve properties order. 
+	#
+	def inherit_meta(mod = superclass)
+		# concat props.
+		if mod.__props
+			@__props = G::SafeArray.new unless @__props
+			
+			mod.__props.each { |p|
+				__add_prop(p)
+			} 
+		end
+
+		# concat metadata
+		if mod.__meta
+			mod.__meta.each { |k, val|
+				val.each { |v|
+					meta(k, v)
+				} if val
+			}
+		end
+	end
+	
+end
+

data/lib/nitro/builders/form.rb

@@ -2,7 +2,10 @@
 # * George Moschovitis  <gm@navel.gr>
 #
 # (c) 2004 Navel, all rights reserved.
-# $Id: form.rb 187 2004-12-10 13:34:28Z gmosx $
+# $Id: form.rb 200 2004-12-27 11:24:41Z gmosx $
+
+require 'glue/hash'
+require 'nitro/markup'
 
 module N
 
@@ -10,7 +13,7 @@ module N
 #
 class FormBuilder
 	
-	@@forms_cache = G::SafeHash.new
+	@@cache = G::SafeHash.new
 
 	# Render a standard form for the given managed object.
 	# If show_all is false then apply field filtering.
@@ -34,34 +37,39 @@ class FormBuilder
 			if p.klass.ancestors.include?(Integer) or
 					p.klass.ancestors.include?(Float) 
 				str << %{
-				<dt><label for="#{p.name}">#{p.name}</label></dt>
-				<dd>
-					<input type="text" name="#{p.name}" value="#{obj.send(p.symbol)}" />
-				</dd>
+	<dt><label for="#{p.name}">#{p.name}</label></dt>
+	<dd>
+		<input type="text" name="#{p.name}" value="#{obj.send(p.symbol)}" />
+	</dd>
 				}
 			elsif p.klass.ancestors.include?(String)
 				str << %{
-				<dt><label for="#{p.name}">#{p.name}</label></dt>
-				<dd>
+	<dt><label for="#{p.name}">#{p.name}</label></dt>
+	<dd>
 				}
-				if :textarea == p.meta[:form]
+				if p.meta[:markup]
+					val = N::Markup.compact(obj.send(p.symbol))
+				else
+					val = obj.send(p.symbol)
+				end
+				if :textarea == p.meta[:ui]
 					str << %{
-					<textarea name="#{p.name}">#{obj.send(p.symbol)}</textarea>
+		<textarea name="#{p.name}">#{val}</textarea>
 					}
 				else
 					str << %{
-					<input type="text" name="#{p.name}" value="#{obj.send(p.symbol)}" />
+		<input type="text" name="#{p.name}" value="#{val}" />
 					}				
 				end
 				str << %{
-				</dd>
+	</dd>
 				}
 			elsif p.klass.ancestors.include?(TrueClass)
 				str << %{
-					<dt><label for="#{p.name}">#{p.name}</label></dt>
-					<dd>
-						<input type="checkbox" name="${p.name}" />
-					</dd>
+	<dt><label for="#{p.name}">#{p.name}</label></dt>
+	<dd>
+		<input type="checkbox" name="${p.name}" />
+	</dd>
 				}
 =begin
 			elsif p.klass.ancestors.include?(Time)
@@ -74,7 +82,8 @@ class FormBuilder
 			end
 		end
 
-		str << '</dl>'
+		str << %{
+</dl>}
 		
 		return str
 	end

data/lib/nitro/events.rb

@@ -6,7 +6,7 @@
 # George Moschovitis  <gm@navel.gr>
 #
 # (c) 2002-2003 Navel, all rights reserved.
-# $Id: events.rb 152 2004-11-13 20:02:35Z gmosx $
+# $Id: events.rb 98 2004-10-22 07:36:20Z gmosx $
 
 module N;
 

data/lib/nitro/markup.rb

@@ -0,0 +1,120 @@
+# code:
+# * George Moschovitis  <gm@navel.gr>
+#
+# (c) 2004 Navel, all rights reserved.
+# $Id$
+
+require 'glue/property'
+
+module G
+
+#--
+# Override the default PropertyUtils implementation to
+# add markup support.
+#++
+module PropertyUtils
+	# Override to add markup code.	
+	#
+	def self.prop_setter(prop)
+		s = prop.symbol
+		if markup = prop.meta[:markup]
+			# if true, set to default Markup
+			markup = N::Markup if true == markup
+
+			return %{
+				def #{s}=(val)
+					@#{s} = #{markup}.expand(val)
+				end
+
+				def compact_#{s}
+					#{markup}.compact(@#{s})
+				end
+			}
+		else
+			return %{
+				def #{s}=(val)
+					@#{s} = val
+				end
+			}
+		end
+	end
+end
+
+end # module
+
+module N
+	
+# = Markup
+#
+# Generalised Markup transformations.
+#
+# The expand methods evaluate (expand) the markup
+# code to produce the final content. The compact
+# methods reverse this process to create the original
+# markup code. Not all markup transformations are
+# reversible.
+#
+# When this library is included, the default PropertyUtils 
+# implementation is overriden to add markup support.
+#
+# === Examples
+#
+# here comes the #{obj.body} # => prints the expanded version.
+#
+#	obj.body = N::Markup.expand(@params['body'])	
+#
+module Markup
+	def self.expand_html!(str)
+		return unless str
+		str.gsub!(/"/, '&quot;')		
+		str.gsub!(/'/, '&#39;')		
+		str.gsub!(/\r\n/, ' <br />')
+		return str
+	end
+
+	def self.compact_html!(str)
+		return unless str
+		str.gsub!(/&quot;/, '"')		
+		str.gsub!(/&#39;/, "'")
+		# gmosx: SOS! double quotes ARE needed for \r\n!!
+		str.gsub!(/\s<br \/>/, "\r\n")
+		return str
+	end
+
+	# Expand the markup code to produce the
+	# actual content.
+	#
+	def self.expand(str)
+		if str
+			xstr = str.dup
+			expand_html!(xstr)
+			expand_wiki!(xstr)
+			return xstr
+		else
+			return str
+		end
+	end
+
+	# Compact (reverse) the content to the origial markup
+	# code. Not all markup transformations are reversible.
+	#
+	def self.compact(str)
+		if str
+			xstr = str.dup
+			compact_html!(xstr)
+			compact_wiki!(xstr)
+			return xstr
+		else
+			return str
+		end
+	end
+
+	# Remove markup code from the input string.
+	# NOT IMPLEMENTED.
+	#
+	def self.clear(str)
+	end
+	
+end
+
+end # module