lapillus 0.0.2

data/lib/lapillus/behaviours.rb

@@ -0,0 +1,208 @@
+require 'rexml/attribute'
+require 'yaml'
+
+module Lapillus
+
+class Behaviour < Component
+  def initialize(id="", value=nil)
+    super(id, value)
+  end
+  
+  #  def add_javascript_to_header root, src
+  #    # add the neccesary javascript links to the head of the html file
+  #    head=root.get_elements("/html/head")[0]
+  #    raise "Error: no html head found in:\n#{root}" if head.nil?
+  #
+  #    script_already_set=false
+  #    head.each_element_with_attribute('src', src, 1, 'script'){ |e| script_already_set=true }
+  #    return if script_already_set
+  #    
+  #    script= REXML::Element.new('script')
+  #    script.add_attributes({'type'=>'text/javascript', 'language'=>'javascript', 'src'=>src})
+  #    script.add_text(";")
+  #    head.add_element(script)
+  #  end
+  
+end
+
+class AttributeModifier < Behaviour
+  def render_to_element(element)
+    attribute = REXML::Attribute.new(identifier, value)
+    def attribute.to_string
+      return "#@expanded_name=\"#@value\""
+    end
+    element.add_attribute(attribute)
+  end
+end
+
+#TODO test
+class UniqueIdentifier < AttributeModifier
+  def initialize
+    super("id")
+  end
+  def value
+    parent.path
+  end
+end
+
+class FadeIn < Behaviour
+  def render_to_element(element)
+    attribute = REXML::Attribute.new(identifier, "new Effect.Appear('#{value}');")
+    def attribute.to_string
+      return "#@expanded_name=\"#@value\""
+    end
+    element.add_attribute(attribute)
+  end
+end
+
+class Draggable < UniqueIdentifier
+  
+  def initialize(options=[])
+    super()
+    @extra_options=options.to_a
+    @option=Hash.new
+  end
+  
+  def handle= handleclass
+    @option[:handle] = "'#{handleclass}'"
+  end
+
+  def revert= value
+    @option[:revert]= value ? "true" : "false"
+  end
+  
+  def snap= value
+    @option[:snap]= value ? "true" : "false"
+  end
+
+  def zindex= value
+    @option[:zindex]= value
+  end
+
+  def constraint= value
+    @option[:constraint]="'#{value}'"
+  end
+
+  def ghosting= value
+    @option[:ghosting]= value ? "true" : "false"
+  end
+
+  def start_effect= value
+    @option[:starteffect]= value
+  end
+
+  def revert_effect= value
+    @option[:reverteffect]= value
+  end
+
+  def end_effect= value
+    @option[:endeffect]= value
+  end
+
+  def change= value
+    @option[:change]= value
+  end
+  
+  def render_to_element(element)
+    super
+    #add_javascript_to_header(element.root_node,"/editiemachine/context/javascript/prototype.js")
+    #add_javascript_to_header(element.root_node,"/editiemachine/context/javascript/scriptaculous.js")
+    
+    script = REXML::Element.new('script')
+    script.add_attributes({'type'=>'text/javascript', 'language'=>'javascript'})
+    options=@option.to_a.collect{|o| "#{o[0]}:#{o[1]}" }.sort.concat(@extra_options).join(",")
+    text=REXML::Text.new("\n// <![CDATA[\nnew Draggable('#{parent.path}', {#{options}});\n// ]]>\n")
+    def text.to_s
+      @normalized=@string
+    end
+    script.add_text(text)
+    element.add_element(script)
+  end
+end
+
+# duplication between OnClick and AjaxLink
+# todo: add test
+class OnClick < Behaviour
+  def initialize(component_to_refresh=nil) 
+    super(nil, component_to_refresh)
+    component_to_refresh.add_behaviour(UniqueIdentifier.new) if has_model?
+  end
+  
+  def render_to_element(element)
+    if has_model?
+      javascript = "new Ajax.Updater('#{value.path}', '', { evalScripts: true, method:'get', parameters: { listener:'#{parent.path}' }}); return false;"
+    else
+      javascript = "new Ajax.Request('', { method: 'get', parameters: { listener:'#{parent.path}' }}); return false;"
+    end  
+    attribute = REXML::Attribute.new("onclick", javascript)
+    # TODO: this should be the default for attributes in
+    # Lapillus somewhere!
+    def attribute.to_string
+      return "#@expanded_name=\"#@value\""
+    end
+    element.add_attribute(attribute)
+  end
+end
+
+# value is the component to rerender when a link is clicked
+# the component should have an id attribute which is set to its path
+class AjaxLink < Container
+  def initialize(id, value=nil)
+    super(id, value)
+    value.add_behaviour(UniqueIdentifier.new) if has_model?
+  end
+  
+  def render_to_element(element)
+    if has_model?
+      javascript = "new Ajax.Updater('#{value.path}', '', { evalScripts: true, method:'get', parameters: { listener:'#{path}' }}); return false;"
+    else
+      javascript = "new Ajax.Request('', { method: 'get', parameters: { listener:'#{path}' }}); return false;"
+    end  
+    attribute = REXML::Attribute.new("onclick", javascript)
+    def attribute.to_string
+      return "#@expanded_name=\"#@value\""
+    end
+    element.add_attribute(attribute)
+    element.add_attribute("href","#")
+  end
+  
+  def on_click_handler=function
+    @function=function
+  end
+  
+  def on_click
+    instance_eval(&@function)
+  end
+  
+  def render_component
+    value.render_component if has_model?
+  end
+end
+
+class Droppable < UniqueIdentifier
+  def render_to_element(element)
+    javascript = <<EOF
+      Droppables.add('#{parent.path}', {
+        onDrop: function(element) { 
+          new Ajax.Updater('#{parent.path}', '', { 
+            method:'get', parameters: { 
+              listener:'#{parent.path}',
+              component:element.id
+            }
+          }); return false;
+        }
+      });
+EOF
+    super
+    script= REXML::Element.new('script')
+    script.add_attributes({'type'=>'text/javascript', 'language'=>'javascript'})
+    text=REXML::Text.new("\n// <![CDATA[\n#{javascript}\n// ]]>\n")
+    def text.to_s
+      @normalized=@string
+    end
+    script.add_text(text)
+    element.add_element(script)
+  end
+end
+
+end

data/lib/lapillus/components.rb

@@ -0,0 +1,116 @@
+require 'lapillus/base'
+  
+module Lapillus
+
+  class Label < Component
+    def render_to_element(element)
+      element.text = value
+    end
+    
+    def value
+      super.to_s
+    end
+    
+    def to_s
+      result = "#{identifier}:"
+      result += " #{value}" if has_model?
+      result += " (not visible)" if(!visible?)
+      return result
+    end
+  end
+
+  def Container.label(id, options={})
+    options.keys.each {|key|
+      raise "Unknown key: #{key}" if key!=:model and key!=:property  
+    }
+    internal_add_component(id) { Label.new(id, options[:model], options[:property]) }
+  end
+
+  #TODO: Add test!
+  class ListItem < Container
+    def label(id, options={})
+      options.keys.each {|key|
+        raise "Unknown key: #{key}" if key!=:model and key!=:property  
+      }
+      add(Label.new(id, options[:model], options[:property]))
+    end
+  end
+
+  class MultiLineLabel < Component
+    attr_writer :html_content
+    
+    private
+    attr_reader :html_content
+    
+    public
+    def render_to_element(element)
+      element.text = ""
+      re = Regexp.new('\n\n+')
+      if((value =~ re)!=nil)
+        split_paragraphs(value,element,re)
+      else
+        split_breaks(value,element)
+      end
+    end
+    
+    def split_paragraphs(text,parent,re)
+      paragr_array = text.split(re)
+      paragr_array.each { |elem|
+        split_breaks(elem,parent.add_element("p"))
+      }
+    end
+    
+    def split_breaks(text,parent)
+      break_array = text.split(/\n/,-1)
+      if !break_array.empty?
+        add_text(parent, break_array[0])
+        break_array[1..-1].each { |elem|
+          parent.add_element("br")
+          add_text(parent, elem)
+        }
+      end
+    end
+    
+    def add_text(element, text)
+      text = REXML::Text.new(text)
+      text.raw = html_content
+      element.add_text(text)
+    end
+  end
+
+  #TODO: root_url could be extracted from application object
+  #but the question is how can an image object easily get the application object?
+  
+  class Image < Component
+    attr_reader :root_url
+    
+    def initialize(id, model, root_url)
+      super(id, model)
+      raise "root_url is not set!" if root_url.nil?
+      @root_url = root_url
+    end
+    
+    def render_to_element(element)
+      url = "/images/#{value}"
+      url = root_url + url  if root_url != "/"
+      element.add_attribute("src", url)
+    end
+  end
+
+  def Container.image(id, options={})
+    options.keys.each {|key|
+      raise "Unknown key: #{key}" if key!=:model and key!=:root_url  
+    }
+    internal_add_component(id) { Image.new(id, options[:model], options[:root_url]) }
+  end
+
+  class ListItem < Container
+    def image(id, options={})
+      options.keys.each {|key|
+        raise "Unknown key: #{key}" if key!=:model and key!=:root_url  
+      }
+      add(Image.new(id, options[:model], options[:root_url]))
+    end
+  end
+
+end

data/lib/lapillus/containers.rb

@@ -0,0 +1,234 @@
+require 'lapillus/base'
+require 'rexml/document'
+
+#TODO: remove in ruby 1.9
+#NOTE: see http://blog.jayfields.com/2006/09/ruby-instanceexec-aka-instanceeval.html
+class Object
+  module InstanceExecHelper; end
+  include InstanceExecHelper
+  def instance_exec(*args, &block)
+    begin
+      old_critical, Thread.critical = Thread.critical, true
+      n = 0
+      n += 1 while respond_to?(mname="__instance_exec#{n}")
+      InstanceExecHelper.module_eval{ define_method(mname, &block) }
+    ensure
+      Thread.critical = old_critical
+    end
+    begin
+      ret = send(mname, *args)
+    ensure
+      InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
+    end
+    ret
+  end
+end
+
+module REXML
+  class Attribute
+    #TODO: what if " occurs inside to_s
+    def to_string
+       "#@expanded_name=\"#{to_s}\""
+    end
+  end
+end
+
+module Lapillus
+  class Webpage < Container
+    
+    def initialize()
+      super("")
+    end
+    
+    def render(html=default_htmlfile)
+      # @html is al File
+      #    html = @html if !@html.nil?
+      doc = REXML::Document.new html
+      root_element = doc.root
+      new_root_element = render_container(root_element)
+      return doc.doctype.to_s + new_root_element.to_s.gsub('&apos;',"'").gsub('&quot;','"')
+    end
+    
+    def default_htmlfile
+      htmlfile = "html/" + self.class.to_s + ".html"
+      File.new( htmlfile ) 
+    end   
+  end
+  
+  class ListView < Container
+    def build_refresh_etc
+      raise "value is nil, it could be that the model/property is not set correctly!" if value.nil?
+      block = parent.class.block(identifier)
+      raise "listview without a block! #{self.path}" if block.nil?
+      value.each_with_index { |item, index| 
+        new_component = ListItem.new(index, item) 
+        new_component.parent = self #NOTE: I could do this in the constructor!
+        new_component.instance_exec(item, &block)
+        @components << new_component
+      }
+    end
+    def refresh #TODO write test
+      @components = []
+    end
+    def components 
+      if @components.empty?
+        build_refresh_etc
+      end
+      @components
+    end
+    def size #NOTE: move to container?
+      return components.size
+    end
+    #TODO: remove duplication
+    def [](index)
+      index = index.to_i if index.kind_of?(String)
+      return components[index]
+    end
+    def component(index)
+      index = index.to_i if index.kind_of?(String)
+      return components[index]
+    end
+    
+    #TODO: result is a duplicate with super class method!
+    def render_container(listview_element)
+      result = REXML::Element.new(listview_element)
+      components.each {|container|
+        container.render_children(listview_element,result)
+      }
+      return result
+    end
+  end
+  
+  class ListItem < Container
+    def method_missing(method)
+      component(method.to_s)
+    end
+  end
+  
+  class Container < Component
+    def self.listview(id, options={}, &block)
+      options.keys.each {|key|
+        raise "Unknown key: #{key}" if key!=:model and key!=:property  
+      }
+      raise "no block supplied!" if !block_given?
+      internal_add_component(id) { ListView.new(id, options[:model], options[:property]) }
+      internal_add_block(id, block)
+    end
+  end
+  
+  class Form < Container
+    def initialize(id, value=nil)
+      super(id, value)
+    end
+    def on_submit_handler=function
+      @function=function
+    end
+    def on_submit(button=nil)
+      instance_eval(&@function)
+    end
+    def render_to_element(element)
+      element.add_attribute("method", "post")
+      element.attributes['enctype'] = 'multipart/form-data'
+      input = element.add_element("input")
+      input.attributes['type'] = 'hidden'
+      input.attributes['name'] = 'page' 
+      input.attributes['value'] = webpage.class.to_s
+    end
+    def post(values) 
+      components.each {|component| component.post(values)}
+      if values.keys.find {|key| key.include?(identifier)}
+        on_submit(values['submit'].nil? ? nil : values['submit'].string)
+      end
+    end 
+    
+  end
+  
+  class BookmarkablePageLink < Container
+    attr_reader :page_parameters, :page_url
+    def initialize(id, page_url, page_parameters)
+      super(id, nil)
+      @page_url = page_url
+      @page_parameters = page_parameters
+    end
+    
+    def render_to_element(element)
+      element.add_attribute("href", url)
+    end
+    
+    def url
+    "#{@page_url}/"+page_parameters.sort.collect {|key, value| key.to_s+'/'+value.to_s}.join('/')    
+    end
+  end
+  
+  #TODO: merge constructor of BookmarkableWebpage and the standard Webpage class
+  class BookmarkableWebpage < Webpage
+    def initialize(page_parameters=Hash[])
+      super()
+    end
+  end
+  
+  class Fragment < Container
+    def initialize(id, fragment_id, model=nil)
+      super(id, model)
+      @fragment_id = fragment_id
+    end
+    
+    def render_container(container_element)
+      root_node=container_element.root
+      fragment = REXML::XPath.first( root_node, "//*[@lapillus:id=\"#{@fragment_id}\"]" )
+      raise "Fragment with identifier "+@fragment_id+" not found!" if fragment == nil 
+      new_element = REXML::Element.new(container_element)   
+      render_children(fragment, new_element)
+      return new_element
+    end
+  end
+  
+  class Panel < Container
+  end
+  
+  class Container
+    def self.panel(id, clazz, model=nil, options={})
+      add_component(id, clazz, model) 
+    end
+  end
+  
+  class ListItem
+    def panel(id, clazz, model=nil, options={})
+      add(clazz.new(id, model))
+    end
+  end
+  
+  #TODO: whats in a name
+  class RemotePanel < Container
+    def render_container(container_element)
+      #NOTE: duplicated in Webpage class above
+      doc = REXML::Document.new default_htmlfile
+      root_node = doc.root
+      fragment = REXML::XPath.first( root_node, "//body")
+      raise "Body element not found!" if fragment == nil
+      new_element = REXML::Element.new(container_element)   
+      render_children(fragment, new_element)
+      render_to_element(new_element)
+      render_behaviours(new_element)
+      return new_element
+    end
+    
+    #NOTE: duplicate between render and render_container
+    def render(html=default_htmlfile)
+      # @html is al File
+      #    html = @html if !@html.nil?
+      doc = REXML::Document.new html
+      root_element = doc.root
+      new_element = REXML::Element.new(root_element)   
+      render_children(root_element, new_element)
+      return doc.doctype.to_s + new_element.to_s
+    end
+    
+    #duplicate with methods in webpage!
+    def default_htmlfile
+      htmlfile = "html/" + self.class.to_s + ".html"
+      File.new( htmlfile ) 
+    end   
+    
+  end
+end