lapillus 0.0.2

data/lib/lapillus/dispatcher.rb

@@ -0,0 +1,216 @@
+require 'cgi'
+require 'cgi/session'
+require 'yaml'
+require 'thread'
+
+class Dispatcher
+  #  @@guard = Mutex.new
+  
+  
+  HTTPHEADER = { 'status'=> 'OK', 'Content-Type' => 'text/html; charset=utf-8'}
+  def Dispatcher.dispatch(cgi, application)
+    #    @@guard.synchronize do
+    request_method = cgi.env_table['REQUEST_METHOD']
+    case request_method
+    when "GET"
+      Dispatcher.get(cgi, application)
+    when "POST"
+      Dispatcher.post(cgi, application)
+    else
+      raise "unexpected request method: "+request_method
+    end
+    #    end
+  end
+  
+  #TODO: remove duplication between get and post
+  #TODO: set request cycle to nil when done
+  #TODO: remove duplication between new page and respond to event
+  def Dispatcher.get(cgi, application)
+    #    log = WEBrick::Log.new
+    #    log.info("URI path= #{cgi.env_table['PATH_INFO']}")
+    
+#    puts;puts cgi.env_table.each {|k,v| puts k.to_s+":"+v.to_s};puts    
+    
+    session = Dispatcher.get_session(cgi)
+    
+    request_cycle = RequestCycle.new(session)
+    RequestCycle.set(request_cycle)
+    path_info = cgi.env_table['PATH_INFO']
+    
+    if cgi.has_key?'listener'
+      puts "AJAXREQUEST!   "+cgi['listener'].to_s
+      
+      pathparts=cgi.env_table['REQUEST_URI'].split('/')
+      if pathparts.length==2 
+        page_identifier = application.homepage.to_s
+      else
+        pagepath = pathparts[2]
+        page_identifier = application.bookmarkable_pages[pagepath].to_s
+      end
+      
+      page = restore_page_from_session(page_identifier, path_info, session)
+      path_to_listener = cgi['listener']
+      listener = page[path_to_listener]
+      #TODO: this should be moved to the listener
+      #TODO: we should always store the session whether we
+      #rerender something or not
+      puts "!!"+listener.class.to_s
+      path_to_component = cgi['component']
+      #NOTICE: non existing cgi variables are return as empty string
+      if cgi.has_key?'menuitem'
+        listener.on_menu(cgi['menuitem'])
+        store_page_in_session(page,path_info,session)
+        path_to_redirect_to = cgi.env_table['REQUEST_URI']
+        path_to_redirect_to = path_to_redirect_to.split("?")[0]
+        puts "!!"+path_to_redirect_to
+        cgi.out({"status" => "302", "Location" => path_to_redirect_to}) do
+  ""
+        end
+        #        cgi.header("Location" => path_to_redirect_to)
+        #        cgi.out(HTTPHEADER) { page.render }
+        return
+        
+      else
+        if path_to_component!=""
+          component = page[path_to_component]
+          listener.on_drop(component)
+        else
+          listener.on_click
+        end
+        store_page_in_session(page,path_info,session)
+        
+        cgi.out(HTTPHEADER) { listener.render_component }
+        return
+      end
+    end
+    
+    pathparts=path_info.split('/')
+    if pathparts.length<=2 
+      page_identifier = application.homepage.to_s
+    else
+      pagepath = pathparts[2]
+      page_identifier = application.bookmarkable_pages[pagepath].to_s
+    end
+    
+#    attribute = "pagemap_#{page_identifier}"
+#    page = session[attribute][1] if !session[attribute].nil?
+    page = session[path_info]
+    if !page.nil? #&& path_info == session[attribute][0]
+        render_page_and_store_in_session(request_cycle, page, session, cgi, path_info)
+        return
+    end
+    
+    pathparts=path_info.split('/')
+#    puts "pathparts.length #{pathparts.length}"
+#    puts pathparts.join("::")
+    if (pathparts.length<2)
+      page = application.homepage.new
+    else
+      page_params = Hash.new
+      pagepath = pathparts[1]
+      (2..pathparts.length-1).step(2){|i| page_params[pathparts[i]]=pathparts[i+1]}
+#      puts pagepath
+      page = application.bookmarkable_pages[pagepath].new(page_params)
+    end
+    
+    render_page_and_store_in_session(request_cycle, page, session, cgi, path_info)
+  end
+  
+  def Dispatcher.post(cgi, application)
+    session = Dispatcher.get_session(cgi)
+    
+    request_cycle = RequestCycle.new(session)
+    RequestCycle.set=request_cycle
+#    puts "cgi_page=#{cgi['page'].string}"
+    page = restore_page_from_session(cgi['page'].string, cgi.env_table['PATH_INFO'], session)
+    
+    values = Hash.new()
+    cgi.keys.each { |key| values[key] = cgi[key]}
+    page.post(values)
+    path_info = cgi.env_table['PATH_INFO']
+    render_page_and_store_in_session(request_cycle, page, session, cgi, path_info)
+  end
+  
+  private
+  def Dispatcher.get_session(cgi)
+    session = CGI::Session.new(cgi, 'database_manager' => CGI::Session::MemoryStore)
+    #    puts "session id= #{session.session_id}"
+    return session
+  end
+  
+  def Dispatcher.render_page_and_store_in_session(request_cycle, page, session, cgi, path_info)
+#    puts "Dispatcher.render_page_and_store_in_session(#{request_cycle}, #{page}, #{session}, #{cgi}, #{path_info})"
+    if (request_cycle.response_page_set?)
+      page = request_cycle.response_page
+    end
+    
+    store_page_in_session(page, path_info, session)   
+    
+    cgi.out(HTTPHEADER) { page.render }
+  end
+  
+  #TODO: restrict the number of pages remembered
+  def Dispatcher.store_page_in_session(page, path_info, session)
+#    pagename = page.class.to_s #key
+#    page_info = [path_info, page]  #value
+#    puts "Storing: "+pagename
+#    puts "STORING path_info: "+path_info
+    session[path_info] = page
+    # NOTE: We need to close the session before we can start streaming the output
+    session.close
+  end
+  
+    #TODO: restrict the number of pages remembered
+  def Dispatcher.restore_page_from_session(page_identifier, path_info, session)
+    #puts "Restoring: "+page_identifier
+#    attribute = "pagemap_#{page_identifier}"
+#        puts "RESTORING path_info: "+path_info
+#    page_info = session[attribute]
+#    page = page_info[1]
+#    puts "session=#{session.to_yaml}"
+#    puts "path_info=[#{path_info}]"
+    page = session[path_info]
+    raise "page expired!" if (page==nil)          
+    return page  #if path_info == page_info[0]
+#    return nil
+  end    
+end
+
+
+class RequestCycle
+  @response_page
+  @session
+  
+  def initialize(session) 
+    super()
+    @session = session
+  end
+  
+  #TODO: attr_accessor
+  def response_page= page
+    @response_page = page
+  end
+  
+  #TODO: attr_accessor
+  def response_page
+    @response_page
+  end
+  
+  def response_page_set?
+    return response_page!=nil
+  end
+  
+  #TODO: attr_reader
+  def session
+    @session
+  end
+  
+  def RequestCycle.get
+    current_request_cycle = Thread.current["current_request_cycle"]
+    return current_request_cycle
+  end
+  
+  def RequestCycle.set(request_cycle)
+    Thread.current["current_request_cycle"]= request_cycle
+  end
+end

data/lib/lapillus/form_components.rb

@@ -0,0 +1,88 @@
+require 'lapillus/base'
+
+module Lapillus
+  class FormComponent < Component
+    def post(values)
+      self.value=values[path] if values.has_key?(path)
+    end
+    
+    def render_to_element(element)
+      element.attributes['name'] = path
+    end 
+    def value
+      return super if has_model?
+      return parent.model.send(identifier) if parent.has_model?
+      raise "model not set!"
+    end
+    
+    def value=new_value
+      if property.nil?
+        @model=new_value
+      else
+        model.send(property.to_s+"=", new_value)
+      end
+    end
+    
+  end
+  
+  class FormTextComponent < FormComponent
+    def render_to_element(element)
+      super
+      text = value
+      text = '' if text.nil?  # TODO: should this be done here, or is this the responsibility of the model ?
+      render_text(element, text)
+    end
+    
+    #TODO: current form test are not real life enough
+    #TODO: use stringio in test instead of string  
+    def value=text
+      text = text.string if (text.kind_of?(StringIO))
+      super(text)
+    end
+  end
+  
+  class TextField < FormTextComponent
+    def render_text(element, text)
+      element.add_attribute('value', text)
+    end
+  end
+  
+  def Container.textfield(id, options={})
+    options.keys.each {|key|
+      raise "Unknown key: #{key}" if key!=:model and key!=:property  
+    }
+    internal_add_component(id) { TextField.new(id, options[:model]||"", options[:property]) }
+  end
+    
+  class TextArea < FormTextComponent
+    def render_text(element, text)
+      element.text = text
+    end
+  end
+  
+  def Container.textarea(id, options={})
+    options.keys.each {|key|
+      raise "Unknown key: #{key}" if key!=:model and key!=:property  
+    }
+    internal_add_component(id) { TextArea.new(id, options[:model]||"", options[:property]) }
+  end
+    
+  class FileUploadField < FormComponent
+  end
+  
+  def Container.fileuploadfield(id, options={})
+    options.keys.each {|key|
+      raise "Unknown key: #{key}" if key!=:model and key!=:property  
+    }
+    internal_add_component(id) { FileUploadField.new(id, options[:model]||"", options[:property]) }
+  end
+
+  class PasswordTextField < TextField
+    def reset_password(bool)
+    end
+  end
+  
+  def Container.password_textfield(id, model="", options={})
+    internal_add_component(id) { PasswordTextField.new(id, model, options[:property]) }
+  end
+end

data/lib/lapillus/lapillus_server.rb

@@ -0,0 +1,21 @@
+require 'lapillus'
+require 'lapillus/webrick_server'
+
+class LapillusServer
+  attr_reader :server
+  def initialize(params={})
+    root_url = params[:root_url]
+    homepage = params[:homepage]
+    port = params[:port]
+    raise "root_url not set!" if root_url.nil?
+    raise "homepage not set!" if homepage.nil?
+    raise "port not set!" if port.nil?
+    @server = WebrickServer.new(port)
+    web_application = WebApplication.new
+    web_application.homepage = homepage
+    server.mount(root_url, web_application)
+  end
+  def start
+    server.start
+  end
+end

data/lib/lapillus/lapillus_testers.rb

@@ -0,0 +1,167 @@
+require 'test/unit'
+require 'lapillus'
+require 'yaml'
+
+class LapillusTester
+  include Test::Unit::Assertions
+  attr_reader :html
+  
+  @page_class
+  @page_instance
+  
+  def initialize
+    super()
+    RequestCycle.set(RequestCycle.new(Hash.new))
+  end
+    
+  def start_page(page)
+    @page_class = page
+    @page_instance = @page_class.new()
+    render
+  end
+
+  def start_page_instance(page_instance)
+    @page_class = page_instance.class
+    @page_instance = page_instance
+    render
+  end
+
+  #TODO: should this method be public?
+  def render
+    @html = @page_instance.render
+  end
+  
+  def assert_component(path, expected_component_class)
+    component = get_component_from_last_rendered_page(path)
+    assert_kind_of(expected_component_class, component,"Component #{component} on path #{path} is not a(n) #{expected_component_class}")
+  end
+
+  def assert_contains(expected_content, actual_content=@html)
+    full_message = build_message(nil, "content ? not found, but was ? ", expected_content, actual_content)
+    assert_block full_message do
+      !@html[expected_content].nil? 
+    end
+  end
+  
+  def assert_error_messages(expected_error_messages)
+    # TODO: implement assert_error_messages(expected_error_messages)
+    flunk 'You need to implement assert_error_messages(expected_error_messages) first!'
+  end
+
+  def assert_expire_previous_page
+    # TODO: implement assert_expire_previous_page
+    flunk 'You need to implement assert_expire_previous_page first!'
+  end
+
+  def assert_info_messages(expected_info_messages)
+    # TODO: implement assert_info_messages(expected_info_messages)
+    flunk 'You need to implement assert_info_messages(expected_info_messages) first!'
+  end
+  
+  def assert_invisible(path)
+    # TODO: implement assert_invisible(path)
+    flunk 'You need to implement assert_invisible(path) first!'
+  end
+
+  def assert_label(path, expected_label_text)
+    assert_component(path, Lapillus::Label)
+    assert_equal(expected_label_text, get_component_from_last_rendered_page(path).value)
+  end
+  
+  def assert_list_view(path, expected_list)
+    # TODO: implement assert_list_view(path, expected_list)
+    flunk 'You need to implement assert_list_view(path, expected_list) first!'
+  end
+
+  def assert_no_error_message
+    # TODO: implement assert_no_error_message
+    flunk 'You need to implement assert_no_error_message first!'
+  end
+
+  def assert_no_info_message
+    # TODO: implement assert_no_info_message
+    flunk 'You need to implement assert_no_info_message first!'
+  end
+
+  def assert_page_link(path, expected_page_class)
+    click_link(path)
+    assert_rendered_page(expected_page_class)
+  end
+
+  def assert_rendered_page(expected_rendered_page_class)
+    assert_kind_of(expected_rendered_page_class, @page_instance)
+  end
+  
+  def assert_visible(path)
+    # TODO: implement assert_visible(path)
+    flunk 'You need to implement assert_visible(path) first!'
+  end
+
+  def click_link(path)
+    link = get_component_from_last_rendered_page(path)
+    assert_not_nil(link,"Link <#{path}> not found!")
+    page_parameters = link.page_parameters
+    @page_instance = @page_class.new(page_parameters)   # TODO: page can be found in the link!
+    @html = @page_instance.render
+  end
+  
+  def debug_component_trees
+    # TODO: implement debug_component_trees
+  end
+  
+  def dump_page
+    puts @html
+  end
+  
+  def get_component_from_last_rendered_page(path)
+    path_parts=path.split(":")
+    component=@page_instance[path_parts[0]]
+    assert_not_nil(component, "No component found on path '#{path_parts[0]}'")
+    (1..path_parts.size-1).each { |i| 
+      component=component[path_parts[i]]
+      assert_not_nil(component, "No component found on path '#{path_parts.slice(0..i).join(':')}'")
+    }
+    component
+  end
+  
+  def get_messages(level)
+    # TODO: implement get_messages(level)
+  end
+  
+  def new_form_tester(path)
+    form = get_component_from_last_rendered_page(path)
+    assert_not_nil(form, "Form <#{path}> not found!")
+    return FormTester.new(form, self)
+  end
+end
+
+class FormTester
+  include Test::Unit::Assertions
+
+  @values
+
+  def initialize(form, tester)
+    @form = form
+    @values = Hash[]
+    @tester = tester
+  end
+  
+  def set_value(key, value)
+    field = @form[key]
+    assert_not_nil(field, "TextField <#{key}> in Form not found!")
+    @values["#{@form.identifier}.#{key}"] = value
+  end
+  
+  def submit(button=nil)
+    request_cycle = RequestCycle.new(Hash.new())
+    RequestCycle.set(request_cycle)
+    @values['submit']= StringIO.new(button) if !button.nil?
+    @form.post(@values)
+    @tester.render
+  end
+
+  def model
+    @form.model
+  end    
+  
+end

data/lib/lapillus/mongrel_server.rb

@@ -0,0 +1,69 @@
+require 'rubygems' 
+require 'mongrel'
+require 'cgi'
+require 'active_record'
+
+class MongrelServer
+
+  def initialize(port)
+    $stdout.sync=true
+    $stderr.sync=true
+    @port = port
+    @server = Mongrel::HttpServer.new("0.0.0.0", @port)
+  end
+  
+  def start
+    trap("INT"){ @server.stop }
+    trap('TERM'){ @server.stop }
+    @server.run.join
+  end
+  
+  def mount(name, application)
+    @server.register(name, MongrelCGIWrapper.new(application))
+  end
+  
+  def mount_context(url, directory)
+    @server.register(url, Mongrel::DirHandler.new(directory))
+  end
+  
+  def allow_termination_for_test
+    Mongrel::Terminate.set_server=@server
+    @server.register("/terminate", Mongrel::Terminate.new)
+  end
+end
+
+class MongrelCGIWrapper < Mongrel::HttpHandler
+  @application
+  
+  def initialize(application)
+    super()
+    @application = application
+    ActiveRecord::Base.allow_concurrency=true
+  end
+  
+  def process(request, response)
+    cgi = Mongrel::CGIWrapper.new(request, response) 
+    begin  
+      Dispatcher.dispatch(cgi,@application)
+    rescue => e
+      STDERR.puts e
+      STDERR.puts e.backtrace.join("\n")
+    ensure
+      ActiveRecord::Base.clear_active_connections!
+    end
+  end
+end    
+
+module Mongrel
+  class Terminate < Mongrel::HttpHandler
+    def Terminate.set_server=server
+      @@server = server
+    end
+    def process(request, response)
+      puts "trying to shutdown server"
+      @@server.stop
+    end
+  end
+end
+ 
+

data/lib/lapillus/multiview.rb

@@ -0,0 +1,45 @@
+require 'lapillus/containers'
+
+class SingleView < Lapillus::Fragment
+  def initialize(id)
+    super(id, id)
+  end
+end
+
+class MultiView < Lapillus::Component
+  attr_accessor :mode
+  def initialize(id, views)
+    super(id)
+    @views = views
+    views.each {|view| view.parent = self } #TODO: add test!
+    @mode=views[0].identifier
+  end
+  
+  def current_view(id=mode)
+    @views.each do |v|
+      return v  if v.identifier == id
+    end
+    raise "view with identifier #{id} not found!"
+    nil
+  end
+  
+  def render_container(html)
+    singleview = current_view
+    result = singleview.render_container(html)
+    render_behaviours(result)
+    return result
+  end
+  
+  # TODO: add test
+  def post(values)  
+    current_view.post(values)
+  end
+	# TODO: add test
+  def component(identifier)
+    return current_view.component(identifier)
+  end
+  # TODO: add test
+  def [](path)
+    current_view[path]
+  end
+end

data/lib/lapillus/pager.rb

@@ -0,0 +1,104 @@
+require 'lapillus'
+
+module Lapillus
+  
+  class Pager < Container
+    attr_reader :current, :page_container
+    attr_accessor :pages, :navigation, :first_button, :previous_button
+    attr_accessor :next_button, :last_button, :position
+    def initialize(id, pages, &block)
+      super(id)
+      raise "no block given!" if !block_given?
+      @pages = pages
+      @current = 1
+      @block = block
+      @navigation = Lapillus::Container.new("navigation")
+      @first_button = FirstButton.new("first", self)
+      @previous_button = PreviousButton.new("previous", self)
+      @next_button = NextButton.new("next", self)
+      @last_button = LastButton.new("last", self)
+      @position = Label.new("position")
+      navigation.add(first_button)
+      navigation.add(previous_button)
+      navigation.add(next_button)
+      navigation.add(last_button)
+      navigation.add(position)
+      build_hierarchy
+    end
+    
+    #TODO: this is not so handy
+    #components are recreated and stuff; split in constructor/on_render
+    #also parent and path do not work
+    def build_hierarchy
+      @page_container = ListItem.new("page") 
+      @page_container.parent = self #NOTE: I could do this in the constructor!  
+      if !@pages.empty?
+        @page_container.instance_exec(page_content, &@block)
+#        @components << @page_container ???
+        first_button.visible= previous_button.visible = current > 1
+        last_button.visible= next_button.visible = current < pages.size
+        position.model = "#{@current} van #{@pages.size}"
+        page_container.visible = true
+        navigation.visible = true
+      else
+        page_container.visible = false
+        navigation.visible = false
+      end
+      @components = []
+      add(page_container)
+      add(navigation)
+    end
+    
+    #TODO: rewrite using closures
+    class PagerButton < Lapillus::AjaxLink
+      def initialize(id, pager)
+        super(id, pager) #pager is the container to be refreshed!
+        @pager = pager
+      end
+    end
+    
+    class FirstButton < PagerButton
+      def on_click
+        @pager.current = 1
+      end
+    end
+    
+    class PreviousButton < PagerButton
+      def on_click
+        @pager.current -= 1
+      end
+    end
+    
+    class NextButton < PagerButton
+      def on_click
+        @pager.current += 1
+      end
+    end
+    
+    class LastButton < PagerButton
+      def on_click
+        @pager.current = @pager.pages.size
+      end
+    end
+    
+    def page_content
+      @pages[@current-1]
+    end
+    
+    def current=(current)
+      @current = current    
+      build_hierarchy      
+    end
+    
+    #  #NOTE: only for test.. see NOTE build.hierarchy
+    #  def get_component(path)
+    #    
+    #    super
+    #  end
+    
+    #  #TODO: only tested indirectly
+    #  def render_container(element)
+    #    super
+    #  end
+  end
+end