xmlconv2 2.0.0

data/src/view/foot.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# View::Foot -- xmlconv2 -- 09.06.2004 -- hwyss@ywesee.com
+
+require 'htmlgrid/composite'
+require 'view/navigation'
+require 'date'
+
+module XmlConv
+	module View
+		class Foot < HtmlGrid::Composite
+			COMPONENTS = {
+				[0,0]	=>	:copyright,
+				[1,0]	=>	Navigation,
+			}
+			CSS_CLASS = 'foot composite'
+			LEGACY_INTERFACE = false
+			def copyright(model)
+				link = HtmlGrid::Link.new(:copyright, model, @session, self)
+				link.href = 'http://www.ywesee.com'
+				link.value = @lookandfeel.lookup(:copyright, Date.today.strftime('%Y'))
+				link.css_class = 'foot'
+				link.target = '_blank'
+				link
+			end
+		end
+	end
+end

data/src/view/head.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# View::Head -- xmlconv2 -- 09.06.2004 -- hwyss@ywesee.com
+
+require 'htmlgrid/composite'
+
+module XmlConv
+	module View
+		class Head < HtmlGrid::Composite
+			COMPONENTS = {
+			}
+		end
+	end
+end

data/src/view/login.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+# View::Login -- xmlconv2 -- 09.06.2004 -- hwyss@ywesee.com
+
+require 'view/template'
+require 'htmlgrid/form'
+require 'htmlgrid/pass'
+
+module XmlConv
+	module View
+		class LoginForm < HtmlGrid::Form
+			COMPONENTS = {
+				[0,0]	=>	:pass,
+				[1,1]	=>	:submit,
+			}
+			CSS_CLASS = 'component'
+			EVENT = :login
+			LABELS = true
+			SYMBOL_MAP = {
+				:pass =>  HtmlGrid::Pass,
+			}
+		end
+		class LoginComposite < HtmlGrid::Composite
+			COMPONENTS = {
+				[0,0]	=>	"login_welcome",
+				[0,1]	=>	LoginForm,
+			}
+			CSS_CLASS = 'composite'
+			CSS_MAP = {
+				[0,0]	=>	'th',
+			}
+		end
+		class Login < Template
+			CONTENT = LoginComposite
+		end
+	end
+end

data/src/view/navigation.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+# View::Navigation -- xmlconv2 -- 09.06.2004 -- hwyss@ywesee.com
+
+require 'htmlgrid/composite'
+require 'view/navigationlink'
+
+module XmlConv
+	module View
+		class Navigation < HtmlGrid::Composite
+			COMPONENTS = {}
+			CSS_CLASS = "navigation"
+			#HTML_ATTRIBUTES = {"align"=>"right"}
+			SYMBOL_MAP = {
+				:navigation_divider =>  HtmlGrid::Text,
+			}
+			def init
+				build_navigation()
+				super
+			end
+			def build_navigation
+				@lookandfeel.navigation.each_with_index { |state, idx|
+					evt = state.is_a?(Symbol) ? state : state.direct_event
+					symbol_map.store(evt, NavigationLink)
+					components.store([idx*2,0], evt)
+					components.store([idx*2-1,0], :navigation_divider) if(idx > 0)
+				}
+			end
+		end
+	end
+end

data/src/view/navigationlink.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# View::NavigationLink -- xmlconv2 -- 09.06.2004 -- hwyss@ywesee.com
+
+require 'htmlgrid/link'
+
+module XmlConv
+	module View
+		class NavigationLink < HtmlGrid::Link
+			#CSS_CLASS = "navigation"
+			def init
+				super
+				unless(@lookandfeel.direct_event == @name)
+					@attributes.store("href", @lookandfeel.event_url(@name))
+				end
+			end
+		end
+	end
+end
+
+
+

data/src/view/pager.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+# View::Pager -- xmlconv2 -- 01.07.2004 -- ywesee@ywesee.com
+
+require 'htmlgrid/link'
+require 'htmlgrid/list'
+
+module XmlConv
+	module View
+		class Pager < HtmlGrid::List
+			BACKGROUND_SUFFIX = ''
+			COMPONENTS = {
+				[0,0]	=>	:number_link,
+			}
+			CSS_CLASS = 'pager'
+			CSS_HEAD_MAP = {
+				#[0,0]	=>	'pager-head',
+			}
+			CSS_MAP = {
+				#[0,0]	=>	'pager',
+			}
+			LEGACY_INTERFACE = false
+			OFFSET_STEP = [1,0]
+			SORT_DEFAULT = :to_i
+			SORT_HEADER = false
+			def init
+				@page = @container.model
+				super
+			end
+			def compose_header(offset)
+				@grid.add(page_number(@model), *offset)
+				@grid.add_style('head', *offset)
+				offset = resolve_offset(offset, self::class::OFFSET_STEP)
+				if(@page != @model.first)
+					link = page_link(@page.previous)
+					link.value = @lookandfeel.lookup(:page_back)
+					@grid.add(link, *offset)
+				end
+				#@grid.add_attribute('class', 'pager', *offset)
+				resolve_offset(offset, self::class::OFFSET_STEP)
+			end
+			def compose_footer(offset)
+				if(@page != @model.last)
+					link = page_link(@page.next)
+					link.value = @lookandfeel.lookup(:page_fwd)
+					@grid.add(link, *offset)
+				else
+					@grid.add(nil, *offset)
+				end
+			end
+			private
+			def number_link(model)
+				page_link(model)
+			end
+			def page_link(page)
+				if(page != @page)
+					link = HtmlGrid::Link.new(:self, page, @session, self)
+					link.value = page.to_s
+					#link.set_attribute("class", "pager")
+					values = {
+						:page	=>	page.to_i.to_s,
+					}
+					link.href = @lookandfeel.event_url(:self, values)
+					link
+				else
+					page.to_s
+				end
+			end
+			def page_number(model)
+				@lookandfeel.lookup(:page_number, @page, @page.total)
+			end
+		end
+	end
+end

data/src/view/preformatted.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+# View::Preformatted -- xmlconv2 -- 09.06.2004 -- hwyss@ywesee.com
+
+require 'htmlgrid/value'
+
+module XmlConv
+	module View
+		BREAK_WIDTH = 65
+		class Preformatted < HtmlGrid::Value
+			def init
+				super
+				if(@value)	
+					raw = @value.gsub(/>\s+</, "><").gsub(/\r\n?/, "\n")
+						pretty = CGI.pretty(raw)
+					wrap = ''
+					pretty.each_line { |line|
+						if(line.length < BREAK_WIDTH)
+							wrap << line
+						else
+							parts = line.split('" "')
+							wrapline = parts.shift
+							while(part = parts.shift)
+								if((wrapline.length + part.length) >= BREAK_WIDTH)
+									wrap << wrapline
+									wrap << "\"\n"
+									wrapline = "     \"" << part
+								else
+									wrapline << '" "' << part
+								end
+							end
+							wrap << wrapline
+						end
+					}
+					@value = CGI.escapeHTML(wrap)
+				end
+			end
+		end
+	end
+end

data/src/view/template.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# View::Template -- xmlconv2 -- 09.06.2004 -- hwyss@ywesee.com
+
+require 'htmlgrid/divtemplate'
+require 'view/foot'
+
+module XmlConv
+	module View
+		class Template < HtmlGrid::DivTemplate
+			COMPONENTS = {
+				[0,0]	=>	:content,
+				[0,1]	=>	:foot,
+			}
+			FOOT = Foot
+		end
+	end
+end

data/src/view/transaction.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+# View::Transaction -- xmlconv2 -- 09.06.2004 -- hwyss@ywesee.com
+
+require 'htmlgrid/value'
+require 'view/template'
+require 'view/preformatted'
+
+module XmlConv
+	module View
+		class TransactionComposite < HtmlGrid::Composite
+			COMPONENTS = {
+				[0,0]	=>	'th_input',
+				[1,0]	=>	'th_output',
+				[0,1]	=>	:input,
+				[1,1]	=>	:output,
+				[0,2]	=>	'th_error',
+				[0,3]	=>	:error_string,
+			}
+			CSS_CLASS = 'composite'
+			CSS_MAP = {
+				[0,0,2]	=>	'th',
+				[0,1,2]	=>	'helfti preformatted',
+				[0,2]		=>	'th',
+				[0,3]		=>	'list preformatted bg',
+			}
+			COLSPAN_MAP = {
+				[0,2]	=>	2,
+				[0,3]	=>	2,
+			}
+			DEFAULT_CLASS = View::Preformatted
+			LEGACY_INTERFACE = false
+			def error_string(model)
+				if(err = model.error)
+					[err.class, err.message, err.backtrace].join("\n")
+				end
+			end
+		end
+		class Transaction < Template
+			CONTENT = TransactionComposite
+		end
+	end
+end

data/src/view/transactions.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+# View::Transactions -- xmlconv2 -- 09.06.2004 -- hwyss@ywesee.com
+
+require 'htmlgrid/list'
+require 'htmlgrid/value'
+require 'view/template'
+require 'view/pager'
+
+module XmlConv
+	module View
+		class TransactionsList < HtmlGrid::List
+			BACKGROUND_SUFFIX = ' bg'
+			COMPONENTS = {
+				[0,0]	=>	:transaction_id,
+				[1,0]	=>	:origin,
+				[2,0]	=>	:commit_time,
+				[3,0]	=>	:uri_comparable,
+				[4,0]	=>	:status_comparable,
+			}
+			CSS_CLASS = 'composite'
+			CSS_HEAD_MAP = {
+				[0,0]	=>	'right',
+			}
+			CSS_MAP = {
+				[0,0]		=>	'list right',
+				[1,0,4]	=>	'list',
+			}
+			DEFAULT_CLASS = HtmlGrid::Value
+			LEGACY_INTERFACE = false
+			SORT_DEFAULT = nil #:commit_time
+			SORT_REVERSE = false
+			def commit_time(model)
+				time_format(model.commit_time || model.start_time)
+			end
+			def origin(model)
+				uri_fmt(model.origin)
+			end
+			def uri_comparable(model)
+				uri_fmt(model.uri)
+			end
+			def uri_fmt(uri)
+				uri = uri.to_s
+				if((i1 = uri.index(/([^\/])\/[^\/]/, 1)) \
+						&& (i2 = uri.rindex(/(\/[^\/]+){3}/)) \
+						&& (i2 > i1))
+					uri[0..(i1.next)] << '...' << uri[i2..-1]
+				else 
+					uri
+				end
+			end
+			def status_comparable(model)
+				model.update_status
+				status = model.status
+				@lookandfeel.lookup("status_#{status}") or status.to_s
+			end
+			def time_format(a_time)
+				if(a_time.respond_to?(:strftime))
+					a_time.strftime("%d.%m.%Y %H:%M:%S") 
+				end
+			end
+			def transaction_id(model)
+				link = HtmlGrid::Link.new(:transaction_id, model, @session, self)
+				args = {
+					'transaction_id'	=>	model.transaction_id,
+				}
+				link.href = @lookandfeel.event_url(:transaction, args)
+				link.value = model.transaction_id
+				link
+			end
+		end
+		class TransactionsComposite < HtmlGrid::Composite
+			COMPONENTS = {
+				[0,0]	=>	:pager,
+				[0,1]	=>	:transactions,
+			}
+			CSS_CLASS = 'composite'
+			LEGACY_INTERFACE = false
+			def pager(model)
+				Pager.new(model.pages, @session, self)
+			end
+			def transactions(page)
+				TransactionsList.new(page.model, @session, self)
+			end
+		end
+		class Transactions < Template
+			CONTENT = TransactionsComposite
+			#CONTENT = TransactionsList
+		end
+	end
+end

data/test/mock.rb

@@ -0,0 +1,149 @@
+# Ruby/Mock version 1.0
+# 
+# A class for conveniently building mock objects in RUnit test cases.
+# Copyright (c) 2001 Nat Pryce, all rights reserved
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+require 'runit/error'
+
+
+class Mock
+    # Creates a new, named mock object. The name is reported in exceptions
+    # thrown by the mock object when method invocations are incorrect.
+    # 
+    def initialize( mock_name = self.to_s )
+        @mock_calls = []
+        @next_call = 0
+        @name = mock_name
+    end
+    
+    # Mock the next method call to be made to this mock object.
+    # 
+    # A mock method is defined by the method name (a symbol) and a block
+    # that defines the arity of the method and the mocked behaviour for
+    # this call.  The mocked behaviour should assert preconditions and
+    # return a value.  Mocked behaviour should rarely be any more complex
+    # than that.  If it is,  that's probably an indication that the tests
+    # need some restructuring or that the tested code needs refactoring.
+    # 
+    # If no block is given and preconditions have been defined for the named
+    # method, a block is created for the mocked methodthat has the same arity
+    # as the precondition and returns self.
+    # 
+    def __next( name, &test )
+        if test == nil
+            if respond_to?( Mock.__pre(name) )
+                test = proc { |*args| self }
+            else
+                raise "no block given for mocked method #{name}"
+            end
+        end
+        @mock_calls.push( [name,test] )
+    end
+    
+    # Call this at the end of a test to ensure that all scheduled calls
+    # have been made to the mock
+    #
+    def __verify
+        if @next_call != @mock_calls.length
+            raise RUNIT::AssertionFailedError,
+                  "not all expected method calls were made to #{@name}",
+                  caller
+        end
+    end
+    
+    
+private
+    # Dispatches aribtrary method calls to the next mocked behaviour
+    # 
+    def method_missing( name, *args, &block )
+        __mock_call( name, args, (block_given? ? block : nil) )
+    end
+    
+    # Implements a method call using the next mocked behaviour and asserts
+    # that the expected method is called with the expected number of 
+    # arguments.
+    #
+    def __mock_call( name, args, block )
+        if @next_call >= @mock_calls.length
+            raise RUNIT::AssertionFailedError,
+                  "unexpected call to #{name} method of #{@name}",
+                  caller(2)
+        end
+        
+        expected_name,body = @mock_calls[@next_call]
+        @next_call += 1
+        
+        if name != expected_name
+            raise RUNIT::AssertionFailedError,
+                  "wrong method called on #{@name}; " +
+                      "expected #{expected_name}, was #{name}",
+                  caller(2)
+        end
+        
+        args_length = args.length + (block ? 1 : 0)
+        
+        if body.arity < 0
+            if (body.arity+1).abs > args_length 
+                raise RUNIT::AssertionFailedError,
+                      "too few arguments to #{name} method of #{@name}; " +
+                          "require #{(body.arity+1).abs}, got #{args.length}",
+                      caller(2)
+            end
+        else
+            if body.arity != args_length
+                raise RUNIT::AssertionFailedError,
+                      "wrong number of arguments to " +
+                          "#{name} method of #{@name}; " +
+                          "require #{body.arity}, got #{args.length}",
+                      caller(2)
+            end
+        end
+        
+        if respond_to? Mock.__pre(name)
+            if block
+                precondition_ok = __send__( Mock.__pre(name), *args, &block )
+            else
+                precondition_ok = __send__( Mock.__pre(name), *args )
+            end
+            
+            if not precondition_ok
+                raise RUNIT::AssertionFailedError,
+                    "precondition of #{name} method violated",
+                    caller(2)
+            end
+        end
+        
+        if block
+            instance_eval { body.call( block, *args ) }
+        else
+            instance_eval { body.call( *args ) }
+        end
+    end
+
+    #  The name of a precondition for a method
+    def Mock.__pre( method )
+        "__pre_#{method.to_i}".intern
+    end
+    
+		
+    def Mock.method_added( name )
+			unless(/^__pre_/.match(name.to_s))
+        pre = self.__pre(name)
+        alias_method( pre, name )
+        undef_method(name)
+			end
+    end
+end