persia 0.1.0

data/lib/base.rb

@@ -0,0 +1,175 @@
+require 'persia'
+
+module ActionController #:nodoc:
+  class Base
+    include ActionView::Helpers::TextHelper
+
+    # original version of method in actionpack 1.12.5
+    # def render_file(template_path, status = nil, use_full_path = false, locals = {}) #:nodoc:
+    #   add_variables_to_assigns
+    #   assert_existence_of_template_file(template_path) if use_full_path
+    #   logger.info("Rendering #{template_path}" + (status ? " (#{status})" : '')) if logger
+    #   render_text(@template.render_file(template_path, use_full_path, locals), status)
+    # end
+
+    def render_file(template_path, status = nil, use_full_path = false, locals = {}) #:nodoc:
+      add_variables_to_assigns
+      r = check_mdml and return r
+      assert_existence_of_template_file(template_path) if use_full_path
+      logger.info("Rendering #{template_path}" + (status ? " (#{status})" : '')) if logger
+      render_text(@template.render_file(template_path, use_full_path, locals), status)
+    end
+
+    # original version of method in actionpack 1.12.5
+    # def render_action(action_name, status = nil, with_layout = true) #:nodoc:
+    #   template = default_template_name(action_name.to_s)
+    #   if with_layout && !template_exempt_from_layout?(template) 
+    #     render_with_layout(template, status)
+    #   else
+    #     render_without_layout(template, status)
+    #   end
+    # end
+
+    def render_action(action_name, status = nil, with_layout = true) #:nodoc:
+      r = check_mdml(action_name) and return r
+      template = default_template_name(action_name.to_s)
+      if with_layout && !template_exempt_from_layout?(template) 
+        render_with_layout(template, status)
+      else
+        render_without_layout(template, status)
+      end
+    end
+
+    def check_mdml(action = nil)
+      begin
+        handle_mdml(view_class, action)
+      rescue Exception => e
+        logger.error(e)
+        render_text "<h1>Exception</h1> <pre>#{ERB::Util.h(e.to_s)}\n#{e.backtrace.join("\n")}</pre>"
+      end 
+    end
+
+    def view_class
+      # set to false if missing
+      return nil if @view_class == false
+      require_dependency "views/#{self.class.controller_name}/view"
+      view_classname = "#{self.class.controller_class_name.to_s[0...-10]}View"
+      if Module.constants.include?(view_classname)
+        @view_class = eval(view_classname)
+      else
+        @view_class = false
+      end
+    end
+
+    def handle_mdml(view_class, action = nil)
+      action ||= self.action_name
+      vc = self.view_class
+      return false unless vc and vc.public_method_defined?(action)
+      view = vc.new
+      view.controller = self
+      add_variables_to_assigns
+      view.load_assigns(@assigns)
+      html = Persia::Element.new 'html'
+      cursor = Persia::Cursor.create_element(html, view)
+      view.send(action, cursor)
+      render_text cursor.to_s
+    end
+  end
+end
+
+module ActionView #:nodoc:
+  class PersiaView
+    include Persia
+    include ActionView::Helpers::UrlHelper
+    include ActionView::Helpers::TagHelper
+    include ActionView::Helpers::AssetTagHelper
+    include ActionView::Helpers::ActiveRecordHelper
+
+    # resources used by view -  :logical_name => "file_name"
+    class << self
+      attr_accessor :view_resources
+    end
+
+    attr_accessor :request, :controller
+
+    # filename (relative to project root) => id_hash
+    # only used in PersiaView itself
+    @resources = {}
+
+    def PersiaView.inherited(subclass)
+      pattern = "app/views/#{subclass.view_name}/*.mdml"
+      glob = Dir.glob(pattern)
+      r = glob.map{|x|[x[(pattern.size-6)...-5].to_sym, x]}.flatten
+      h = (subclass.view_resources = Hash[*r]).values
+      puts "Found #{h.size} mdml files in view dir."
+      h.each do |fn| 
+        puts "Loading resources for file #{fn} in class #{subclass.name}"
+        load_resource fn 
+      end
+      subclass.update_id_hash h
+    end
+
+    # load and parse resource
+    def PersiaView.load_resource(fn)
+      rexml = File.open(fn, 'r') do |f|
+        begin
+          REXML::Document.new f
+        rescue REXML::ParseException => e
+          puts "Error parsing file [#{fn}]:", e.to_s
+          return
+        end
+      end
+      r = @resources[fn] = {}
+      Element.new(rexml, r)
+      puts "Loaded #{r.size} resources"
+    end
+
+    # return resources id_hash for filename
+    def PersiaView.resource_for(filename)
+      @resources[filename]
+    end
+
+    # define resources outside view dir: :logical_name => "file_name"
+    def self.define_resources(hash)
+      @view_resources.merge! hash
+      hash.each_value {|fn| PersiaView.load_resource fn }
+      update_id_hash(hash.values)
+    end
+
+    def self.update_id_hash(filenames)
+      # merged hashes of used resources
+      # only used in subclasses of PersiaView
+      @id_hash ||= {}
+      filenames.each do |fn|
+        r = PersiaView.resource_for(fn) 
+        @id_hash.merge! r
+      end
+    end
+
+    def self.resource_by_id(id, logical_resource = nil)
+      hash = if logical_resource
+        fn = @view_resources[logical_resource.to_sym]
+        r = PersiaView.resource_for(fn)
+        r.empty? and raise "No resources found in file #{fn}.\nPlease set xmlns attribute on root and mark resources with id tags."
+        r
+      else
+        @id_hash
+      end
+      hash.empty? and raise "No resources found at all.\nPlease set xmlns attribute on root and mark resources with id tags for all mdml files in your view directory."
+      hash[id.to_sym] or raise "No resource with id[#{id}] found in resources #{hash.keys.inspect}"
+    end
+
+    def self.id_hash
+      @id_hash
+    end
+    
+    # returns the name of class, minus 'View' in under_score notation
+    def self.view_name
+      self.name.split('::')[-1][0...-4].underscore
+    end
+    
+    def load_assigns(assigns)
+      assigns.each {|k,v| instance_variable_set("@#{k}",v) }
+    end
+  end
+end

data/lib/persia.rb

@@ -0,0 +1,439 @@
+require 'xml'
+
+module Persia
+  # Creates a macro which stores commands, and which can be 
+  # played back later on a Cursor.
+  def macro
+    Macro.new
+  end
+  
+  # A cursor points to a position within a DOM tree. Some methods
+  # in the cursor class return a new cursor pointing at a new position,
+  # other modify the DOM tree at the current position.
+  # When the cursor points at a list of elements, it will be interpreted as
+  # pointing to the first element of that list if the command would otherwise 
+  # be nonsensical:
+  # cursor.tr => points to list of tr elements that are children of current element.
+  # cursor.tr.td => points to list of td elements that are children of first tr element of current element.
+  # cursor.tr[1].td => points to list of td elements that are children of second tr element of current element.
+  # cursor.id![:title] => find element within current element with id = :title
+  class Cursor
+    attr_reader :view
+    
+    protected
+
+    def initialize(el, v, state = nil) #:nodoc:
+      raise "Not allowed to call Cursor.new with nil element" unless @current_element = el
+      raise "Not allowed to call Cursor.new with empty array" if Array === el and el.empty?
+      raise "Not allowed to call Cursor.new with element object of type '#{el.class.name}'" unless [String,Array,Element].include?(el.class)
+      @current_element = el.clone if el.frozen?
+      @view, @state = v, state
+    end
+
+    public
+
+    # Creates new cursor with given element and optionally a view
+    # Some method need the view for the instance variables, the 
+    # resources or the url_for method of the view.
+    def Cursor.create_element(el, view = nil)
+      Cursor.new el, view
+    end
+    
+    # returns current element
+    def current_element
+      return @current_element unless array?
+      @current_element.empty? and raise "Empty array" or @current_element.first
+    end
+    
+    # is current element a list of elements
+    def array?
+      @current_element.kind_of? Array
+    end
+
+    # is current element a single element
+    def element?
+      !@state or array? 
+    end
+
+    # is current node a textnode
+    def text?
+      @state == :text
+    end
+
+    # is current node an attribute
+    def attribute?
+      @state.kind_of? Symbol
+    end
+    
+    # Does the cursor point to the root of the document
+    def root?
+      !current_element.parent
+    end
+
+    # finds all input fields of type text, hidden, radio, checkbox, all textarea's and select fields.
+    # argument for fill_with is domain object name d
+    # domain object o is instance_variable_get "@#{d.to_s}"
+    # indexes these fields by name
+    # creates macro object with method_missing implemented
+    # instance_evals block on macro object
+    # for every call to method m in block:
+    #   finds field in index
+    def fill_with!(d, &blk)
+      o = @view.instance_variable_get "@#{d.to_s}"
+      raise "No domain object with name '#{d}' found" unless o
+      index = create_name_index
+      mod = Module.new
+      cursor = self
+      mod.send :define_method, :method_missing do |m, *args|
+        f = index[m.to_sym]
+        raise "#{m} not found in form fields #{index.keys.inspect}" unless f
+        f = [f] unless Array === f
+        f.each {|x| raise 'nil? WTF' unless x; x.fill_field! d, o, m, *args }
+      end
+      macro = Object.new
+      macro.extend mod
+      macro.instance_eval &blk
+    end
+    
+    # d = domain object name
+    # o = domain object
+    # p = property
+    # for all fields, set id to #{d}_#{m} and name to #{d}[#{m}] 
+    # for hidden, text, set value to o.send m
+    # for textarea, set textnode to o.send m
+    # for checkbox, value="1", add hidden same name value="0", if o.send "#{m}?" set checked="checked"
+    # for radio, if o.send "#{m}" == value set checked="checked"
+    # for select, if no argument, use options in mdml - find selected option, set selected="selected", unselect rest
+    # for select, if argument, delete all options and generate them with given hash, and set selected.
+    def fill_field!(d, o, p, *args)
+      raise "Domain object #{d} doesn't respond to #{p}" unless o.respond_to? p
+      self[:id] <= "#{d}_#{p}"
+      self[:name] <= "#{d}[#{p}]"
+      current_element.name == 'textarea' and return self[] <= o.send(p)
+
+      return handle_select(o, p, args) if current_element.name == 'select' 
+
+      type = self[:type].to_s or return
+      type = type.to_sym
+      [:hidden, :text].include?(type) and return self[:value] <= o.send(p)
+      if type == :radio
+        self[:checked] <= ((o.send(p).to_s == self[:value].to_s) and 'checked')
+      elsif type == :checkbox
+        handle_checkbox(d, o, p)
+      else
+        raise "Unknown type #{type}"
+      end
+    end
+    
+    def handle_checkbox(d, o, p)
+      self[:value] <= '1'
+      self[:checked] <= (o.send("#{p}?") and 'checked')
+      hidden = Element.new 'input'
+      hidden.change_attributes do |att|
+        att[:type] = 'hidden'
+        att[:name] = "#{d}[#{p}]"
+        att[:value] = '0'
+      end
+      self.current_element.insert_after_self hidden
+    end
+
+    def handle_select(o, p, args)
+      puts args.inspect
+      mk_node = lambda do |key, label|
+        node = Element.new 'option'
+        node.change_attributes {|at| at[:value] = key.to_s }
+        node.insert_child_last label.to_s
+        node
+      end
+      unless args.empty?
+        current_element.delete_all_children
+        if args.size > 1
+          args[0].each do |e|
+            current_element.insert_child_last mk_node[e.send(args[1]), e.send(args[2])]
+          end
+        else
+          args[0].each do |e|
+            current_element.insert_child_last mk_node[e.first, e.last]
+          end
+        end
+      end
+      # set selected
+      selected_key = o.send(p).to_s
+      puts "selected_key: #{selected_key.inspect}"
+      current_element.children.each do |c|
+        if c.attributes[:value] == selected_key
+          c.change_attributes {|at| at[:selected] = 'selected' }
+        end
+      end
+    end
+
+    def create_name_index
+      index = {}
+      current_element.each_descendant_element do |el|
+        puts "processing element #{el.name}"
+        type = el.attributes[:type]
+        if %w(select textarea).include?(el.name) or el.name == 'input' && %w(hidden text radio checkbox).include?(type)
+          name = el.attributes[:name].to_sym
+          raise "name attribute missing in element #{el.to_s}" unless name
+          if type == 'radio'
+            (index[name] ||= []) << clone!(el)
+          else
+            raise "Two elements with name #{name}" if index[name]
+            index[name] = clone!(el)
+          end
+        end
+      end
+      index
+    end
+
+    # cursor[] references text node of current element
+    # cursor[2] references 3rd element of current element list
+    # cursor[:onclick] references attribute onclick of current element
+    # cursor['#onclick'] references child with id 'onclick' (identical to cursor.id![:onclick])
+    def [](index = nil)
+      raise "hey, this is not an element" if @state
+      if !index
+        clone! @current_element, :text
+      elsif index.kind_of?(String)
+        raise "You called ['#{index}'] on this cursor. Did you mean ['##{index}'] or [:#{index}]?" unless index[0] == ?# or index.size > 1
+        id![index[1..-1]]
+      elsif index.kind_of? Numeric
+        raise "hey, this is not an array" unless array?
+        raise unless @current_element = @current_element[index]
+        self
+      elsif index.kind_of? Array
+        raise "no array allowed here"
+      else
+        clone! @current_element, index.to_sym
+      end
+    end
+    
+    # insert textnode before current element
+    # e.g. cursor << 'Homepage'
+    def <<(text)
+      raise "hey, this is not an element" if @state
+      raise "not implemented"
+    end
+    
+    # insert textnode after current element
+    # e.g. cursor >> 'Homepage'
+    def >>(text)
+      raise "hey, this is not an element" if @state
+      raise "not implemented"
+    end
+    
+    # if cursor references a textnode, appends string to textnode
+    # e.g. cursor[] < 'world'
+    # if cursor references an attribute, appends string to attribute
+    # e.g. cursor[:href] < '?id=foo'
+    def <(text)
+      raise "hey, this is an element" unless @state
+      if text?
+        current_element.insert_child_first(current_element.delete_child(0) + text.to_s)
+      else
+        current_element.change_attributes {|attr| attr[@state] += text.to_s}
+      end
+    end
+    
+    # if cursor references text, replaces textnode with new ESCAPED textnode.
+    # e.g. cursor[] =~ '<div>&nbsp;</div>' gives: '&lt;div&gt;&amp;nbsp;&lt;/div&gt;'
+    def =~(text)
+      raise "The =~ works only on text elements" unless text?
+      raise "You can't set text on an element unless it is childless or has one child that is a textnode" if current_element.children[0].kind_of? Element
+      current_element.delete_child(0) unless current_element.children.empty?
+      current_element.insert_child_first(ERB::Util.h(text.to_s))
+    end
+    
+    # if cursor references element, replaces element (+children) with textnode
+    # cursor <= 'Next page'
+    # if cursor references text, replaces textnode with new textnode.
+    # e.g. cursor[] <= 'Updated!'
+    # if cursor references attribute, replaces attribute value with new value
+    # e.g. cursor[:class] <= 'hidden'
+    # deletes the attributes when called with nil or false
+    def <=(text)
+      if !@state
+        current_element.insert_after_self text.to_s
+        current_element.delete_self
+      elsif text?
+        raise "You can't set text on an element with element children" if current_element.children[0].kind_of? Element
+        current_element.delete_child 0
+        current_element.insert_child_first text.to_s
+      else
+        current_element.change_attributes do |attr| 
+          text ? attr[@state] = text.to_s : attr.delete(@state)
+        end
+      end
+    end
+    
+    # Calculates new value by calling 'call' on param cmd with current value.
+    # if cursor references text, replaces textnode with new value.
+    # e.g. cursor[] <=> lambda &:upcase
+    # if cursor references attribute, replaces attribute value with new value
+    # e.g. cursor[:class] <=> lambda {|x| x.reverse }
+    # (Note that operators do not take blocks)
+    def <=>(cmd)
+      raise "hey, this is an element" unless @state
+      self <= cmd.call(to_s).to_s
+    end
+    
+    # renders what cursors refers to as a string
+    def to_s
+      if text?
+        return '' if !current_element.children or current_element.children.empty?
+        return current_element.children[0] if current_element.children.size == 1
+        raise "More than one node where single text node expected."
+      end
+      return current_element.attributes[@state] if attribute?
+      current_element.to_s
+    end
+    
+    def method_missing(meth, *args, &block) #:nodoc:
+      return super if meth.to_s =~ /^should/
+      raise "hey, this is not an element" if @state
+      el = current_element.elements.select{|c| c.name == meth.to_s }
+      raise "#{current_element.name} has no #{meth} elements" if el.empty?
+      clone! el
+    end
+    
+    # returns new cursor pointing to element with current id
+    # searches only in descendants of current element
+    def id!
+      lambda do |n|
+        el = find_by_id!(n.to_sym)
+        raise "Missing element with id #{n} in children of element #{current_element.name}\n#{current_element.to_s}" unless el
+        clone! el
+      end
+    end
+    
+    # Calls each proc in list on each element in current nodelist in
+    # the equivalent position
+    # e.g. list[0].call node
+    # +proclist+ A list of procs
+    def /(proclist)
+      raise "Current element moet array zijn" unless array?
+      proclist.zip(@current_element).each do|tuple|
+        raise "@current_element[x] is nil, #{@current_element}" unless tuple.last
+        tuple.first.call clone!(tuple.last)
+      end
+    end
+    
+    # replaces current single element by resource with given id
+    # for each pair k,v in replacements param, replaces element
+    # with id == k with resource with id v.
+    def replace!(id, replacements = {})
+      raise "hey, this is not a single element" unless element?
+      el = view.class.resource_by_id id
+      c = el.clone @current_element.parent
+      if root?
+        @current_element = c
+      else
+        @current_element.insert_after_self c
+        @current_element.delete_self
+      end
+      replacements.each {|k,v| self.id![k].replace! v }
+      c
+    end
+    
+    # Replaces current element by list of elements
+    def swap!(list)
+      raise "trying to swap nil" unless list
+      raise "you cannot call swap on a text node" if text?
+      raise "you cannot call swap on an attribute" if attribute?
+      raise "you cannot call swap on root; use replace" if root?
+      list.each {|i| current_element.insert_before_self i}
+      current_element.delete_self
+      @current_element = list.empty? ? @current_element.parent : list[0]
+    end
+    
+    def unwrap!
+      parent = current_element.parent
+      current_element.children.each do |child|
+        parent.insert_child_after_node current_element, child
+      end
+      parent.delete_child current_element
+      current_element = parent
+    end
+    
+    # el ^ options is an alias for el['href'] <= url_for(options)
+    # el ^ [condition, options] does the same, unless the condition
+    # is false, in which case it will remove the anchor tag.
+    def ^(options)
+      if options.kind_of? Array
+        return unwrap! unless options[0]
+        options = options[1]
+      end
+      if current_element.name == 'a'
+        self[:href] <= view.url_for(options)
+      elsif current_element.name == 'form'
+        self[:action] <= view.url_for(options)
+      else
+        raise "Don't know how to set url on element [#{current_element.name}]"
+      end
+    end
+
+    # hash id => options
+    # for each entry, calls id![id] ^ options
+    def set_urls!(hash)
+      hash.each {|myid,options| self.id![myid] ^ options}
+    end
+
+    # call block on each cursor with persia:class == name
+    def each_cursor_with_class!(name)
+      current_element.each_descendant_element do |el|
+        yield clone!(el) if el.has_class?(name)
+      end
+    end
+
+    # Makes a clone of the element for each list item and calls
+    # block on each clone. 
+    def times!(list)
+      list.map do |obj|
+        e = current_element.clone
+        yield clone!(e), obj
+        e
+      end
+    end
+    
+    # Makes a clone of the element for each list item and calls
+    # block on each clone. Replaces the current elements with the list.
+    def times_and_swap!(list, &cmd)
+      raise "trying to times_and_swap nil" unless list
+      raise "you cannot call times_and_swap on a text node" if text?
+      raise "you cannot call times_and_swap on an attribute" if attribute?
+      raise "you cannot call times_and_swap on root; use replace" if root?
+      swap! times!(list, &cmd)
+    end
+
+    private
+
+    def find_by_id!(n)
+      if array?
+        @current_element.detect {|x| x.detect {|y| y.has_id?(n) } }
+      else
+        @current_element.detect {|x| x.has_id?(n) }
+      end
+    end
+    
+    def clone!(d, state = nil)
+      Cursor.new(d, view, state)
+    end
+  end
+  
+  class Macro #:nodoc:
+    def initialize
+      @cmds = []
+    end
+    
+    def method_missing(meth, *args, &block)
+      @cmds << [meth, args, block]
+      self
+    end
+    
+    def call(target)
+      @cmds.each do |cmd|
+        target = target.send(cmd[0], *cmd[1], &cmd[2])
+      end
+    end
+  end
+end

data/lib/xml.rb

@@ -0,0 +1,358 @@
+module Persia
+  XMLNS = 'http://persia.rubyforge.org/specs'
+  class Element
+    SLOW_RENDER = false
+
+    attr_accessor :source, :name
+    attr_reader :children, :outer, :inner, :parent, :persia_id, :persia_class
+    
+    # create new element, creating from rexml document if document, or
+    # with name if string.
+    def initialize(r = nil, id_hash = nil)
+      @children = []
+      if r and r.kind_of?(String)
+        @name = r.to_s
+      elsif r and r.kind_of?(REXML::Document)
+        populate_document(r, id_hash) 
+      end
+    end
+
+    def populate_document(r, id_hash)
+      populate_from_rexml(r.root, nil, id_hash)
+      # cache roots
+      if id_hash
+        id_hash.values.select(&:root?).each(&:cache)
+        id_hash.freeze
+      end
+      each_descendant_element(&:freeze)
+    end
+
+    def freeze
+      @attributes.freeze
+      super
+    end
+    
+    # populate from rexml element with given parent 
+    def populate_from_rexml(e, parent = nil, id_hash = nil)
+      @name = e.name
+      @parent = parent
+      # skip children if element contains skip attribute
+      if load_attr(e.attributes, id_hash)
+        e.children.each do |c|
+          @children << Element.new.populate_from_rexml(c, self, id_hash) if c.kind_of? REXML::Element
+          if c.kind_of?(REXML::Text) && (s = c.to_s)
+            s.strip!
+            @children << s unless s.empty?
+          end
+        end
+      end
+
+      self
+    end
+    
+    # populate from native element with given parent
+    def populate_from_element(el, parent)
+      raise TypeError, "Element is frozen" if frozen?
+      @name = el.name
+      @parent = parent
+      @persia_id = el.persia_id
+      @persia_class = el.persia_class
+      load_attr(el.attributes)
+      @children = el.copy_children(self)
+      self
+    end
+    
+    # return copy of children
+    def copy_children(parent)
+      @children.map do |c|
+        c.kind_of?(String) ? c.dup : Element.new.populate_from_element(c, parent)
+      end if @children
+    end
+    
+    # returns first element for which block returns true, going depth first
+    def detect(&cmd)
+      if cmd.call self
+        return self
+      end
+      elements.each {|x| r = x.detect(&cmd) and return r }
+      nil
+    end
+
+    # calls each descendant element (no textnodes) including current one
+    def each_descendant_element(&cmd)
+      cmd.call self
+      @children.each do |c|
+        if c.kind_of? Element
+          c.each_descendant_element &cmd
+        end
+      end
+    end
+    
+    # has this element a persia id of name?
+    def has_id?(name)
+      name.to_sym == @persia_id
+    end
+    
+    # has this element a persia class of name?
+    def has_class?(name)
+      name.to_sym == @persia_class
+    end
+    
+    # returns attribute hash
+    def attributes
+      @attributes || {}
+    end
+  
+    # returns root element
+    def root
+      @parent ? @parent.root : self
+    end
+    
+    # clones current element, giving it parent as parent
+    def clone(parent = nil)
+      Element.populate_from_element self, parent
+    end
+        
+    # returns all children that are elements
+    def elements
+      @children.select {|c| c.kind_of?(Element) }
+    end
+    
+    # raise Exception unless current element is equal to obj
+    def assert_equal(obj)
+      unless obj.kind_of? Element
+        raise "element (#{name}) != #{obj.to_s}[#{obj.class}]"
+      end
+      obj.assert_attr_eql? @attributes
+      unless name == obj.name
+        raise "element (#{name}) != element(#{obj.name})"
+      end
+      @children.each_with_index do |e,i|
+        e2 = obj.children[i]
+        if e.kind_of?(Element)
+          e.assert_equal e2
+        elsif e != e2
+          raise "'#{e}'[#{e.class}] and '#{e2}'[#{e2.class}] not equal"
+        end
+      end
+    end
+    
+    # raise Exception unless attributes of element are equal to attrib param
+    def assert_attr_eql?(attrib)
+      unless @attributes == attrib
+        raise "Attributes #{attrib.inspect} and #{@attributes.inspect} not equal\nself:#{self.to_s}"
+      end
+    end
+    
+    # METHODS: modify document
+    
+    # insert node before self (as sibling)
+    def insert_before_self(node)
+      parent.insert_child index_self, node
+    end
+  
+    # insert node after self (as sibling)
+    def insert_after_self(node)
+      parent.insert_child index_self + 1, node
+    end
+    
+    # insert node as first child
+    def insert_child_first(node)
+      insert_child 0, node
+    end
+    
+    # insert node as last child
+    def insert_child_last(node)
+      insert_child -1, node
+    end
+    
+    def insert_child_before_node(node, newnode)
+      insert_child index(node), newnode
+    end
+    
+    def insert_child_after_node(node, newnode)
+      insert_child 1 + index(node), newnode
+    end
+    
+    def insert_child(index, node)
+      raise TypeError, "Element is frozen" if frozen?
+      clear_inner
+      (@children ||= []).insert index, node
+      attempt_concat(index - 1)
+      attempt_concat(index)
+    end
+    
+    def delete_self
+      raise TypeError, "Element is frozen" if frozen?
+      @parent.delete_child(self) if @parent
+    end
+    
+    def delete_child(index)
+      raise TypeError, "Element is frozen" if frozen?
+      clear_inner
+      index = index(index) unless Numeric === index 
+      @children.delete_at index
+      attempt_concat(index - 1)
+    end
+
+    def attempt_concat(first)
+      second = first + 1
+      return if second == 0
+      return unless second < @children.size
+      if String === @children[first] and String === @children[second]
+        @children[first] << @children[second]
+        @children.delete_at second
+      end
+    end
+    
+    def change_attributes
+      raise TypeError, "Element is frozen" if frozen?
+      @attributes ||= {}
+      yield @attributes
+      clear_outer
+    end
+    
+    def change_type(newtype)
+      raise TypeError, "Element is frozen" if frozen?
+      @name = newtype
+      clear_outer
+    end
+    
+    def index(node)
+      index = -1
+      @children.detect {|c| index += 1; node.equal? c }
+      index
+    end
+
+    def delete_all_children
+      @children = []
+    end
+    
+    def index_self
+      @parent.index self if @parent
+    end
+  
+    # end modify
+    
+    def render(array)
+      if SLOW_RENDER or not @inner
+        render_tags(array) { render_children(array) }
+      elsif @outer
+        array << root.source[@outer] if @outer
+      else
+        render_tags(array) { array << root.source[@inner] }
+      end
+    end
+
+    def render_tags(array)
+      array << el_open
+      yield
+      array << el_close
+    end
+    
+    def render_children(array)
+      @children.each do |c|
+        c.kind_of?(String) ? array << c : c.render(array)
+      end
+    end
+    
+    def clear_inner
+      @inner = nil
+      @parent.clear_inner if @parent
+    end
+  
+    def clear_outer
+      @outer = nil
+      @parent.clear_inner if @parent
+    end
+    
+    def root?
+      !@parent
+    end
+  
+    def cache
+      array = []
+      dump array
+      cursor = 0
+      array.each do |fr|
+        if fr.kind_of? Array
+          fr[1].touch(cursor, fr[0].size)
+          cursor += fr[0].size
+        else
+          cursor += fr.size
+        end
+      end
+      root.source = array.map {|x,*y| x }.join
+    end
+    
+    def to_s
+      render([]).join "\n"
+    end
+    
+    def dump(array)
+      array << [el_open, self]
+      @children.each do |c|
+        if c.kind_of? String
+          array << c 
+        else
+          c.dump array
+        end
+      end
+      array << [el_close, self]
+    end
+    
+    def touch(first, size)
+      if @first
+        @outer = @first ... first + size
+        @inner = @last ... first
+        @first,@last = nil, nil
+      else
+        @first,@last = first, first + size
+      end
+    end
+  
+    def el_open
+      "<#{@name}#{attributes.map{|k,v|%Q! #{k}="#{v}"!}.join}>"
+    end  
+  
+    def el_close
+      "</#{@name}>"
+    end
+    
+    private
+    
+    def self.populate_from_element(el, parent)
+      (e = Element.new).populate_from_element el, parent
+    end
+    
+    # returns nil if persia:skip attribute found. this means - ignore children
+    def load_attr(attrib, id_hash = nil)
+      raise TypeError, "Element is frozen" if frozen?
+      @attributes = {}
+      if attrib
+        attrib.each {|k,v| @attributes[k.to_sym] = v }
+      end
+      return true unless REXML::Attributes === attrib
+      l = lambda do |el, cmd|
+        if a = attrib.get_attribute_ns(XMLNS, el)
+          puts "Found marker #{a.inspect}"
+          @attributes.delete a.fully_expanded_name.to_sym
+          v = a.value.to_sym
+          cmd[v]
+        end
+        true
+      end
+      l['id', lambda do |v|
+        id_hash[v] = self if id_hash
+        @persia_id = v
+      end]
+      l['class', lambda do |v|
+        @persia_class = v
+      end]
+      l['skip', lambda do |v|
+        id_hash[v] = self if id_hash
+        @persia_id = v
+      end]
+    end
+  end
+end

data/test/persia_test.rb

@@ -0,0 +1,217 @@
+@@lib_path = File.join(File.dirname(__FILE__), "..", "lib")
+$:.unshift @@lib_path
+
+require 'rexml/document'
+require 'persia'
+require 'test/unit'
+
+def mockit(name, &blk)
+  o = Object.new
+  o.class.instance_variable_set('@blk', blk)
+  eval <<-"end_of_def"
+    class << o.class
+      def #{name}(a)
+        @blk.call a
+      end
+    end
+  end_of_def
+  o
+end
+
+class Symbol
+  def to_proc; Proc.new {|obj,*args| obj.send(self, *args) }; end
+end
+
+class PersiaTest < Test::Unit::TestCase
+  include REXML
+  include Persia
+  
+  def test_cursor_set_text
+    eval_xml '<div>1</div>', '<div>2</div>' do |cursor|
+      cursor[] <= '2'
+    end
+  end
+  
+  def test_cursor_set_text_alt_notation
+    eval_xml '<div>1</div>', '<div>2</div>' do |cursor|
+      cursor[] <= '2'
+    end
+  end
+  
+  def test_cursor_append_text
+    eval_xml '<div>1</div>', '<div>12</div>' do |cursor|
+      cursor[] < '2'
+    end
+  end
+  
+  def test_cursor_change_text
+    eval_xml '<div>3</div>', '<div>27</div>' do |cursor|
+      cursor[] <=> lambda {|x| x.to_i ** 3}
+    end
+  end
+  
+  def test_cursor_set_attribute
+    eval_xml '<div id="1"/>', '<div id="2"/>' do |cursor|
+      cursor[:id] <= '2'
+    end
+  end
+  
+  def test_cursor_append_attribute
+    eval_xml '<div id="1"/>', '<div id="12"/>' do |cursor|
+      cursor[:id] < '2'
+    end
+  end
+  
+  def test_cursor_change_attribute
+    eval_xml '<div id="3"/>', '<div id="27"/>' do |cursor|
+      cursor[:id] <=> lambda {|x| x.to_i ** 3}
+    end
+  end
+  
+  def test_hole
+    i1,i2 = {}, {}
+    e1 = to_element '<a persia:id="document"><b><c persia:skip="hole">LAYOUT.MDML BABY</c></b></a>', i1, {}
+    e2 = to_element '<X><Y persia:id="head"><Z persia:id="title">LAYOUT.MDML BABY</Z></Y></X>', i2, {}
+    id_hash = i1.merge i2
+    html = Element.new
+    html.name = 'html'
+    view = mockit('resource_by_id') {|x| id_hash[x.to_sym] }
+    cursor = Cursor.create_element(html, view)
+    cursor.replace! 'document'
+    cursor.id![:hole].replace! 'head'
+    cursor.id![:title]
+  end
+
+  def test_cursor
+    cursor = load_doc "set_text"
+    body = cursor.id!['body']
+    assert_equal "body", body.doc.name
+    assert_equal "div", body.div.doc.name
+    table = body.div.table
+    assert_equal "table", table.doc.name
+    assert_equal "tr", table.tr.doc.name
+    assert_equal Cursor, table.tr[2].class
+    assert table.tr
+    assert table.tr.array?
+    assert_equal "even", table.tr[2]['class'].to_s
+    tr = table.tr[2]
+    assert_equal "Ruby Wizard", tr.td[1][].to_s
+  end
+  
+  def test_cursor2
+    org = '<ul persia:id="ps"><li persia:id="lilo">bla</li></ul>'
+    expected = '<ul><li>bar</li></ul>'
+    eval_xml org, expected do |cursor|
+      assert cursor.doc.has_id?(:ps)
+      cursor.id!['lilo'][] <= 'bar'
+    end
+  end
+  
+  def test_find_id
+    org = '<html xmlns:persia="http://persia.finalist.com/" ><body><p style="color: blue" persia:id="flash">hello</p></body></html>'
+    eval_xml org, org do |cursor|
+      assert !cursor.doc.frozen?
+      assert_equal :flash, cursor.body.p[0].doc.persia_id
+      p = cursor.doc.detect {|x| x.has_id?(:flash) }
+      assert_equal 'p', p.name
+      cursor.body.id![:flash]
+      assert_equal 'p', cursor.id!['flash'].doc.name
+    end
+  end
+  
+  def test_multiply
+    xml_equal? "multiply" do |cursor|
+      assert !cursor.doc.frozen?
+      cursor.id!['flash'].times_and_swap!(1..3) { |e, x| e[] <= x }
+    end
+  end
+  
+  def test_times
+    org = '<div><p persia:id="ps">bla</p></div>'
+    expected = '<div><p>bla</p></div>'
+    eval_xml org, expected do |cursor|
+      cursor.id!['ps'].times!(1..3) { |e,i| e[] <= i }
+    end
+  end
+  
+  def test_times_and_swap
+    org = '<div><p persia:id="ps">bla</p></div>'
+    expected = '<div><p>1</p><p>2</p><p>3</p></div>'
+    eval_xml org, expected do |cursor|
+      cursor.id!['ps'].times_and_swap!(1..3) { |e,i| e[] <= i }
+    end
+  end
+   
+  def test_replace
+    org = '<div><p persia:id="ps">bla</p></div>'
+    expected = '<p>bla</p>'
+    eval_xml org, expected do |cursor|
+      assert cursor.p.doc.has_id?(:ps)
+      cursor.replace! 'ps'
+    end
+  end
+  
+  def test_slice
+    org = '<ul persia:id="ps"><li class="active">lisp</li><li class="active">2</li><li class="active">3</li></ul>'
+    expected = '<ul><li class="active">pascal</li><li class="hidden">2</li><li id="ruby" class="active">3</li></ul>'
+    eval_xml org, expected do |cursor|
+      cursor.id!['ps'].li / [
+        lambda {|e| e[] <= 'pascal'},
+        lambda {|e| e['class'] <= 'hidden'},
+        lambda {|e| e['id'] <= 'ruby'}
+      ]
+    end
+  end
+  
+  def test_slice2
+    org = '<ul persia:id="ps"><li class="active">lisp</li><li class="active">2</li><li class="active">3</li></ul>'
+    expected = '<ul><li class="active">pascal</li><li class="hidden">2</li><li id="ruby" class="active">3</li></ul>'
+    eval_xml org, expected do |cursor|
+      cursor.id!['ps'].li / [
+        macro[] <= 'pascal',
+        macro[:class] <= 'hidden',
+        macro[:id] <= 'ruby'
+      ]
+    end
+  end
+  
+  def test_href
+    eval_xml '<ul persia:id="ps"><li><a href="">bla</a></li></ul>', '<ul><li>bla</li></ul>' do |cursor|
+      cursor.id!['ps'].li.a ^ [false, {:action => 'list'}]
+    end
+  end
+  
+  private
+  
+  def load_doc(fname)
+    doc = Document.new(File.new("test/data/#{fname}.mdml"))
+    el = Element.new(doc, id_hash = {})
+    Cursor.create_element(el)
+  end
+  
+  def xml_equal?(fname)
+    expected = File.new("test/data/#{fname}.xml")
+    cursor = load_doc(fname)
+    yield cursor
+    assert_xml_equal(expected, cursor.doc)
+  end
+  
+  def eval_xml(orig, expected)
+    el = Element.new(Document.new(orig), id_hash = {}, {})
+    view = mockit('resource_by_id') {|x| id_hash[x.to_sym] }
+    yield cursor = Cursor.create_element(el, view)
+    assert_xml_equal(expected, cursor.doc)
+  end
+  
+  def to_element(obj, i = nil, c = nil)
+    obj = REXML::Document.new(obj) if obj.kind_of? String
+    obj = REXML::Document.new(obj) if obj.kind_of? File
+    obj = Persia::Element.new(obj, i, c) if obj.kind_of? REXML::Document
+    obj
+  end
+  
+  def assert_xml_equal(expected, doc)
+    a,b = to_element(expected), to_element(doc)
+    a.assert_equal b
+  end
+end

data/test/xml_test.rb

@@ -0,0 +1,69 @@
+@@lib_path = File.join(File.dirname(__FILE__), "..", "lib")
+$:.unshift @@lib_path
+
+require 'rexml/document'
+require 'persia'
+require 'test/unit'
+
+class XmlTest < Test::Unit::TestCase
+  include REXML
+  include Persia
+  
+  def test_insert_before_self
+    eval_xml '<div><b>1</b></div>', '<div>X<b>1</b></div>' do |e|
+      e.elements[0].insert_before_self "X"
+    end
+  end
+  
+  def test_insert_after_self
+    eval_xml '<div><b>1</b></div>', '<div><b>1</b>X</div>' do |e|
+      e.elements[0].insert_after_self "X"
+    end
+  end
+  
+  def test_insert_child_first
+    eval_xml '<div><b>1</b></div>', '<div>X<b>1</b></div>' do |e|
+      e.insert_child_first "X"
+    end
+  end
+  
+  def test_insert_child_last
+    eval_xml '<div><b>1</b></div>', '<div><b>1</b>X</div>' do |e|
+      e.insert_child_last "X"
+    end
+  end
+  
+  def test_id_hash
+    i,c = {}, {}
+    e = to_element '<div><p persia:id="ps">bla</p></div>', i, c
+    assert i.include?(:ps), e.inspect
+  end
+  
+  def test_skip
+    i,c = {}, {}
+    e = to_element '<div persia:skip="foo"><p persia:id="invisible">bla</p></div>', i, c
+    assert i.keys.include?(:foo)
+    assert !i.keys.include?(:invisible)
+  end
+  
+  private
+  
+  def eval_xml(orig, expected)
+    doc = REXML::Document.new(orig)
+    el = Persia::Element.new(doc).clone
+    yield el
+    assert_xml_equal(expected, el)
+  end
+  
+  def to_element(obj, i = nil, c = nil)
+    obj = REXML::Document.new(obj) if obj.kind_of? String
+    obj = REXML::Document.new(obj) if obj.kind_of? File
+    obj = Persia::Element.new(obj, i, c) if obj.kind_of? REXML::Document
+    obj
+  end
+  
+  def assert_xml_equal(expected, doc)
+    a,b = to_element(expected), to_element(doc)
+    a.assert_equal b
+  end
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: persia
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2006-09-15 00:00:00 +02:00
+summary: Alternative view layer for Rails based on separation of HTML and logic.
+require_paths: 
+- lib
+email: michiel@finalist.com
+homepage: http://persia.rubyforge.org/
+rubyforge_project: 
+description: 
+autorequire: base
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Michiel de Mare
+files: 
+- lib/base.rb
+- lib/persia.rb
+- lib/xml.rb
+test_files: 
+- test/persia_test.rb
+- test/xml_test.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+