zena 1.0.0.beta3 → 1.0.0.rc1

data/app/models/cache.rb

@@ -4,44 +4,49 @@ class Cache < ActiveRecord::Base
   cattr_accessor :perform_caching
   before_save    :set_site_id
 
+  # The code is here too bad to be kept.
+  # TODO: Rewrite
   class << self
 
     def with(visitor_id, visitor_groups, kpath, *context)
-      return yield unless perform_caching
-      if cached = self.find(:first, :conditions => ["visitor_id = ? AND site_id = ? AND context = ?", visitor_id, visitor.site.id, context.join('.').hash.abs])
-        cached[:content]
-      else
-        content = yield
-        self.create(:visitor_id=>visitor_id, :visitor_groups=>".#{visitor_groups.join('.')}.", :kpath=>kpath,
-                    :context=>context.join('.').hash.abs, :content=>content )
-        content
-      end
+      yield
+
+      # return yield unless perform_caching
+      # if cached = self.find(:first, :conditions => ["visitor_id = ? AND site_id = ? AND context = ?", visitor_id, visitor.site.id, context.join('.').hash.abs])
+      #   cached[:content]
+      # else
+      #   content = yield
+      #   self.create(:visitor_id=>visitor_id, :visitor_groups=>".#{visitor_groups.join('.')}.", :kpath=>kpath,
+      #               :context=>context.join('.').hash.abs, :content=>content )
+      #   content
+      # end
     end
 
     # We can provide a kpath selector for sweeping. If the kpath is in the cached scope, the cache is removed.
     def sweep(hash)
-      if kpath  = hash[:kpath]
-        klasses = []
-        kpath.split(//).each_index { |i| klasses << kpath[0..i] }
-        kpath_selector = " AND kpath IN (#{klasses.map{|k| connection.quote(k)}.join(',')})"
-      else
-        kpath_selector = ""
-      end
-      if hash[:visitor_id]
-        self.connection.execute "DELETE FROM #{self.table_name} WHERE visitor_id = '#{hash[:visitor_id]}'" + kpath_selector
-      end
-      if hash[:visitor_groups]
-        hash[:visitor_groups].each do |g|
-          self.connection.execute "DELETE FROM #{self.table_name} WHERE visitor_groups LIKE '%.#{g}.%'" + kpath_selector
-        end
-      end
-      if hash[:context]
-        context = [hash[:context]].flatten.join('.').hash.abs
-        self.connection.execute "DELETE FROM #{self.table_name} WHERE context = '#{context}'" + kpath_selector
-      end
-      if hash[:older_than]
-        self.connection.execute "DELETE FROM #{self.table_name} WHERE updated_at < '#{hash[:older_than]}'" + kpath_selector
-      end
+      return
+      # if kpath  = hash[:kpath]
+      #   klasses = []
+      #   kpath.split(//).each_index { |i| klasses << kpath[0..i] }
+      #   kpath_selector = " AND kpath IN (#{klasses.map{|k| connection.quote(k)}.join(',')})"
+      # else
+      #   kpath_selector = ""
+      # end
+      # if hash[:visitor_id]
+      #   self.connection.execute "DELETE FROM #{self.table_name} WHERE visitor_id = '#{hash[:visitor_id]}'" + kpath_selector
+      # end
+      # if hash[:visitor_groups]
+      #   hash[:visitor_groups].each do |g|
+      #     self.connection.execute "DELETE FROM #{self.table_name} WHERE visitor_groups LIKE '%.#{g}.%'" + kpath_selector
+      #   end
+      # end
+      # if hash[:context]
+      #   context = [hash[:context]].flatten.join('.').hash.abs
+      #   self.connection.execute "DELETE FROM #{self.table_name} WHERE context = '#{context}'" + kpath_selector
+      # end
+      # if hash[:older_than]
+      #   self.connection.execute "DELETE FROM #{self.table_name} WHERE updated_at < '#{hash[:older_than]}'" + kpath_selector
+      # end
     end
   end
 

data/app/models/column.rb

@@ -2,8 +2,11 @@ class Column < ActiveRecord::Base
   attr_accessor :import_result
   include RubyLess
   include Property::StoredColumn
-  TYPES_FOR_FORM   = %w{string datetime integer}
-  INDICES_FOR_FORM = %w{string ml_string}
+  TYPES_FOR_FORM   = %w{string datetime integer float}
+
+  INDICES_FOR_FORM = %w{string ml_string datetime integer float}
+
+  FIELD_INDICES = []
 
   belongs_to :role
   before_validation :set_defaults
@@ -12,14 +15,37 @@ class Column < ActiveRecord::Base
   validates_uniqueness_of :name, :scope => :site_id
   validate :name_not_in_models
 
+  after_save :expire_vclass_cache
+  after_destroy :expire_vclass_cache
+
   safe_method :name => String
 
   class << self
     include Zena::Acts::Secure
 
     def roles_for_form
-      secure(Role) { Role.all(:order => 'name ASC') }.map do |role|
-        [role.name, role.id]
+      if roles = secure(Role) { Role.all(:order => 'name ASC') }
+        roles.map do |role|
+          [role.name, role.id]
+        end
+      else
+        []
+      end
+    end
+
+    def indices_for_form
+      [
+        ['key/value',
+          INDICES_FOR_FORM.map {|i| [i, i]}],
+        ['field',
+          FIELD_INDICES.map {|i| [i, ".#{i}"]}]
+      ]
+    end
+
+    # Declare a new index table or field
+    def add_field_index(*args)
+      args.flatten.each do |idx|
+        FIELD_INDICES << idx
       end
     end
 
@@ -77,18 +103,35 @@ class Column < ActiveRecord::Base
     @kpath ||= role.kpath
   end
 
+  # Used to display index name in forms
+  def index_name
+    self.index.to_s.gsub(/\A\./,'')
+  end
+
   protected
     def set_defaults
       self[:site_id] = current_site.id
     end
 
     def name_not_in_models
-      Node.native_classes.each do |kpath, klass|
+      Node.native_classes.to_a.sort{|a,b| a[0] <=> b[0]}.each do |kpath, klass|
+        name, set_name = self.name, "#{self.name}="
         if column = klass.schema.columns[self.name]
           # find column origin
           errors.add(:name, _('has already been taken in %s') % column.role.name)
           break
+        elsif self.name =~ %r{_ids?$}
+          errors.add(:name, _('invalid (cannot end with _id or _ids)'))
+          break
+        elsif klass.method_defined?(name)     || klass.protected_method_defined?(name)     || klass.private_method_defined?(name) ||
+           klass.method_defined?(set_name) || klass.protected_method_defined?(set_name) || klass.private_method_defined?(set_name)
+          errors.add(:name, _('invalid (method defined in %s)') % klass.to_s)
+          break
         end
       end
     end
+
+    def expire_vclass_cache
+      VirtualClass.expire_cache!
+    end
 end

data/app/models/comment.rb

@@ -9,8 +9,11 @@ class Comment < ActiveRecord::Base
   include RubyLess
 
   safe_attribute    :title, :created_at, :updated_at, :status
-  safe_method       :text => String, :author_name => {:class => String, :nil => true},
-                    :discussion_id => Number
+  safe_method       :text => String,
+                    :discussion_id => Number,
+                    :user_name => {:class => String, :nil => true},
+                    :user => {:class => 'User', :nil => true},
+                    :author => Node.author_proc
 
   safe_context      :replies => ['Comment'], :node => 'Node'
 
@@ -23,8 +26,14 @@ class Comment < ActiveRecord::Base
 
   include Zena::Use::QueryComment::ModelMethods
 
+  # Who wrote the comment (author's User model)
+  def user
+    @user ||= secure(User) { User.find(self[:user_id]) }
+  end
+
+  # Who wrote the comment (author's Node model)
   def author
-    @author ||= secure(User) { User.find(self[:user_id]) }
+    @author ||= (user ? user.node : nil)
   end
 
   def node
@@ -32,7 +41,7 @@ class Comment < ActiveRecord::Base
   end
 
   def author_name
-    self[:author_name] || (self[:user_id] ? author.fullname : nil)
+    self[:author_name] || (author ? author.title : nil)
   end
 
   def parent
@@ -111,7 +120,7 @@ class Comment < ActiveRecord::Base
       errors.add('text', "can't be blank") if self[:text].blank?
       errors.add('discussion', 'invalid') unless discussion
       errors.add('ip', "can't be blank") unless self[:ip] || !visitor.is_anon?
-      if author.is_anon?
+      if user.is_anon?
         errors.add('author_name', "can't be blank") unless self[:author_name] && self[:author_name] != ""
       end
     end

data/app/models/data_entry.rb

@@ -19,7 +19,7 @@ class DataEntry < ActiveRecord::Base
                  :node_a_zip => Number, :node_b_zip => Number,
                  :node_c_zip => Number, :node_d_zip => Number,
                  :node_a => 'Node', :node_b => 'Node', :node_c => 'Node',
-                 :node_d => 'Node', :nodes => ['Node'], :author => 'BaseContact', :user => 'User'
+                 :node_d => 'Node', :nodes => ['Node'], :author => 'Node', :user => 'User'
 
   attr_protected :site_id
 
@@ -84,7 +84,7 @@ class DataEntry < ActiveRecord::Base
   end
 
   def author
-    user.contact
+    user.node
   end
 
   def nodes

data/app/models/document.rb

@@ -46,9 +46,10 @@ class Document < Node
   safe_property :size, :content_type, :ext
   safe_method   :filename => String, :file => File, :filepath => String
 
-  validate :valid_file
-  validate :valid_content_type
-  after_save :clear_new_file
+  validate          :make_unique_title
+  validate          :valid_file
+  validate          :valid_content_type
+  after_save        :clear_new_file
 
   class << self
 
@@ -59,10 +60,7 @@ class Document < Node
     alias o_new new
 
     # Return a new Document or a sub-class of Document depending on the file's content type. Returns a TextDocument if there is no file.
-    def new(attrs = {})
-
-      scope = self.scoped_methods[0] || {}
-
+    def new(attrs = {}, vclass = nil)
       attrs = attrs.stringify_keys
       file  = attrs['file'] || ((attrs['version_attributes'] || {})['content_attributes'] || {})['file']
       if attrs['content_type']
@@ -71,23 +69,29 @@ class Document < Node
         content_type = file.content_type
       elsif ct = attrs['content_type']
         content_type = ct
-      elsif attrs['node_name'] =~ /^.*\.(\w+)$/ && types = Zena::EXT_TO_TYPE[$1.downcase]
-        content_type = types[0]
       elsif attrs['title'] =~ /^.*\.(\w+)$/ && types = Zena::EXT_TO_TYPE[$1.downcase]
         content_type = types[0]
       end
+      
+      real_class = document_class_from_content_type(content_type)
 
-      klass = document_class_from_content_type(content_type)
+      unless vclass && vclass.kpath =~ /\A#{real_class.kpath}/
+        # vclass is not compatible (force kpath)
+        vclass = VirtualClass[real_class.to_s]
+      end
 
       attrs['content_type'] = content_type
 
-      if klass != self
-        klass.with_scope(scope) { klass.o_new(attrs) }
+      if real_class != self
+        secure(real_class) { real_class.o_new(attrs, vclass) }
       else
-        klass.o_new(attrs)
+        super(attrs, vclass)
       end
     end
 
+    # Compatibility with VirtualClass
+    alias new_instance new
+    
     # Class list to which this class can change to
     def change_to_classes_for_form
       classes_for_form(:class => 'Document', :without => 'Image')
@@ -144,6 +148,7 @@ class Document < Node
   end
 
   # Get the document's public filename using the name and the file extension.
+  # FIXME: shouldn't we use title here ?
   def filename
     version.attachment.filename
   end
@@ -153,11 +158,6 @@ class Document < Node
     version.attachment.filepath(format)
   end
 
-  # Get the node's rootpath with the file's extention.
-  def rootpath
-    super + ".#{prop['ext']}"
-  end
-
   protected
     def set_defaults
       set_defaults_from_file
@@ -168,10 +168,6 @@ class Document < Node
         self.title = $1
       end
 
-      if node_name.to_s =~ /\A(.*)\.#{self.ext}$/i
-        self.node_name = $1
-      end
-
       super
 
       set_attachment_filename
@@ -224,20 +220,14 @@ class Document < Node
       return unless @new_file
       self.content_type = @new_file.content_type unless prop.content_type_changed?
 
-      if base = node_name || title || @new_file.original_filename
-        if base =~ /(.*)\.(\w+)$/
-          self.node_name = $1 if new_record?
-        else
-          self.node_name = base if new_record?
-        end
+      if base = @new_file.original_filename
+        self.title = base if title.blank?
       end
     end
 
-    # Make sure node_name is unique. This should be run after sync_node_name, this is why we
-    # hack around the name and use super.
-    def sync_node_name
-      super
-      get_unique_node_name_in_scope('ND%')
+    # Make sure title is unique. This should be run after prop_eval.
+    def make_unique_title
+      get_unique_title_in_scope('ND')
     end
 
     def get_extension

data/app/models/idx_nodes_datetime.rb

@@ -0,0 +1,4 @@
+# This is a dummy class that is only loaded during testing (to load fixtures and
+# to count/find index entries).
+class IdxNodesDatetime < ActiveRecord::Base
+end

data/app/models/idx_nodes_float.rb

@@ -0,0 +1,4 @@
+# This is a dummy class that is only loaded during testing (to load fixtures and
+# to count/find index entries).
+class IdxNodesFloat < ActiveRecord::Base
+end

data/app/models/idx_project.rb

@@ -0,0 +1,3 @@
+class IdxProject < ActiveRecord::Base
+  include Zena::Use::ScopeIndex::IndexMethods
+end # IdxProject

data/app/models/node.rb

@@ -25,44 +25,13 @@ Node (manages access and publication cycle)
   |                    +--- Template  (entry for rendering)
   |
   +-- Note (date related information, event)
-  |     |
-  |     +--- Post (blog entry)
-  |     |
-  |     +--- Task
-  |     |      |
-  |     |      +--- Letter
-  |     |      |
-  |     |      +--- Request
-  |     |             |
-  |     |             +--- Bug
-  |     |
-  |     +--- Milestone
-  |
-  +-- Reference
         |
-        +-- BaseContact (address, name, phone)
-
-=== Node, Version and Content
-
-The +nodes+ table only holds columns to secure the access. This table does not hold every possible data for every sub-class of Node. The text data is stored into the +versions+ table and any other specific content goes in its own table (+document_contents+ for example). This is an example of how an Image is stored :
+        +--- Post (blog entry)
 
-Node         o-----------   Version   o---------  Content
-dgroup_id                   title                 width
-wgroup_id                   text                  height
-user_id                     summary               content_type
-...                         ...                   ...
 
-=== Acessing version and content data
+=== Properties
 
-To ease the work to set/retrieve the data from the version and or content, we use some special notation. This notation abstracts this Node/Version/Content structure so you can use a version's attribute as if it was in the node directly.
-
-TODO: DOC removed (was out of sync)
-
-=== Dynamic attributes
-
-The Version class uses dynamic attributes. These let you add any attribute you like to the versions (see DynAttribute for details). These attributes can be accessed by using the +d_+ prefix :
-
- @node.d_whatever  ===> @node.version.prop[:whatever]
+The Version class stores the node's properties (attributes). You need to declare the attributes either in the virtual class or as a Role attached to an existing class in order to use them.
 
 === Attributes
 
@@ -71,13 +40,15 @@ Each node uses the following basic attributes:
 Base attributes:
 
 zip:: unique id (incremented in each site's scope).
-node_name:: used to build the node's url when 'custom_base' is set.
+_id:: cached title (used to identify nodes in DB: not used in Zena)
 site_id:: site to which this node belongs to.
 parent_id:: parent node (every node except root is inserted in a unique place through this attribute).
-user_id:: owner of the node.
+user_id:: creator of the node.
 ref_lang:: original node language.
 created_at:: creation date.
 updated_at:: modification date.
+log_at:: announcement date.
+event_at:: event date.
 custom_base:: boolean value. When set to true, the node's url becomes it's fullpath. All it descendants will use this node's fullpath as their base url. See below for an example.
 inherit:: inheritance mode (0=custom, 1=inherit, -1=private).
 
@@ -91,11 +62,13 @@ skin_id:: Skin to use when rendering the page ('theme').
 Attributes used internally:
 publish_from:: earliest publication date from all published versions.
 kpath:: inheritance hierarchy. For example an Image has 'NPDI' (Node, Page, Document, Image), a Letter would have 'NNTL' (Node, Note, Task. Letter). This is used to optimize sql queries.
-fullpath:: cached full path made of ancestors' node_names (<gdparent node_name>/<parent node_name>/<self node_name>).
+fullpath:: cached full path made of ancestors' zip (<gdparent zip>/<parent zip>/<self zip>).
 basepath:: cached base path (the base path is used to build the url depending on the 'custom_base' flag).
 
 === Node url
+
 A node's url is made of it's class and +zip+. For the examples below, this is our site tree:
+
  root
    |
    +--- projects (Page)
@@ -121,11 +94,53 @@ and the 'photos' url is now in the worldTour project's basepath:
 Setting 'custom_base' on a node should be done with caution as the node's zip is on longer in the url and when you move the node around, there is no way to find the new location from the old url. Custom_base should therefore only be used for nodes that are not going to move.
 =end
 class Node < ActiveRecord::Base
+  # Only store partial class name in 'type' field (Page instead of ::Page)
+  self.store_full_sti_class = false
+
   extend Zena::Use::Upload::UploadedFile
   extend Zena::Use::Search::NodeClassMethods
 
   include Property
 
+  # This must come before the first call to make_schema.
+  include Zena::Use::Kpath::InstanceMethods
+
+  def virtual_class
+    @virtual_class ||= if self[:vclass_id]
+      VirtualClass.find_by_id(self[:vclass_id])
+    else
+      VirtualClass.find_by_name(self.class.name)
+    end
+  end
+
+  def virtual_class=(vclass)
+    @virtual_class = vclass
+    self[:vclass_id] = vclass.id
+    self[:kpath] = vclass.kpath
+  end
+
+  # We want to use a Role as schema for properties defined in the real_class instead of Property::Schema.
+  def self.make_schema
+    ::Role.new(:name => name).tap do |role|
+      role.kpath = self.kpath
+      # Enable property method definitions.
+      role.klass      = self
+      # Used for property inheritance.
+      role.real_class = self
+    end
+  end
+
+  alias schema virtual_class
+
+  # We use the virtual_class as proxy for method type resolution.
+  # def safe_eval(code)
+  #   eval RubyLess.translate(schema, code)
+  # end
+
+  def safe_method_type(signature, receiver = nil)
+    schema.safe_method_type(signature, receiver)
+  end
+
   # Should be the same serialization as in Version and Site
   include Property::Serialization::JSON
 
@@ -133,37 +148,19 @@ class Node < ActiveRecord::Base
 
   property do |p|
     # Multilingual string index on 'title'
-    p.string  'title', :index => Proc.new {|r| {'title' => r.version.idx_text_high}}, :index_group => :ml_string
+    p.string  'title', :index => :ml_string
 
     p.string  'text'
     p.string  'summary'
-    p.string  'comment'
   end
 
   # This is used to enable multilingual indexes
   include Zena::Use::MLIndex::ModelMethods
 
-  include RubyLess
-  safe_property  :title, :text, :summary, :comment
-
-  safe_attribute :created_at, :updated_at, :event_at, :log_at, :publish_from, :basepath, :inherit, :position
-
-  # we use safe_method because the columns can be null, but the values are never null
-  safe_method   :node_name => String, :kpath => String, :user_zip => Number, :parent_zip => Number,
-                :project_zip => Number, :section_zip => Number, :skin => String, :ref_lang => String,
-                :fullpath => String, :rootpath => String, :position => Number, :rgroup_id => Number,
-                :wgroup_id => Number, :dgroup_id => Number, :custom_base => Boolean, :klass => String,
-                :m_text => String, :m_title => String, :m_author => String,
-                :id => {:class => Number, :method => 'zip'},
-                :skin => 'Skin', :lang => String, :content_lang => {:class => String, :nil => true},
-                :visitor => 'User',
-                [:ancestor?, Node] => Boolean
-  safe_method   :defaults => {:nil => true},
-                :score => Number, :comments_count => Number,
-                :custom_a => Number, :custom_b => Number
-
-  # same with parent_zip, section_zip, etc...
+  # Must come after Property
+  include Zena::Use::FieldIndex::ModelMethods
 
+  include RubyLess
 
   # This is used to load roles in an instance or on a class during compilation. Module
   # inclusion has to come *after* RubyLess because we overwrite safe_method_type.
@@ -173,12 +170,10 @@ class Node < ActiveRecord::Base
   has_many           :discussions, :dependent => :destroy
   has_many           :links
   has_and_belongs_to_many :cached_pages
-  belongs_to         :virtual_class, :foreign_key => 'vclass_id'
   belongs_to         :site
   belongs_to         :skin
   before_validation  :set_defaults
   before_validation  :node_before_validation
-  validates_presence_of :node_name
   validate           :validate_node
   before_create      :node_before_create
   before_save        :change_klass
@@ -191,25 +186,58 @@ class Node < ActiveRecord::Base
   # A possible solution could be to use the other syntax exclusively ('rel' => {'friend' => [4,5,6]})
   include Zena::Use::NestedAttributesAlias::ModelMethods
 
-  #nested_attributes_alias %r{^v_(\w+)} => ['version']
-  #nested_attributes_alias %r{^c_(\w+)} => ['version', 'content']
-  #nested_attributes_alias %r{^d_(\w+)} => ['version', 'dyn']
+  # Dynamic resolution of the author class from the user prototype
+  def self.author_proc
+    Proc.new do |h, r, s|
+      res = {:method => 'author', :nil => true}
+      if prototype = visitor.prototype
+        res[:class] = prototype.vclass
+      else
+        res[:class] = VirtualClass['Node']
+      end
+      res
+    end
+  end
+
+  safe_property  :title, :text, :summary
 
-  safe_context       :parent => 'Node', :project => 'Project', :section => 'Section',
-                     :real_project => 'Project', :real_section => 'Section',
+  safe_attribute :created_at, :updated_at, :event_at, :log_at, :publish_from, :basepath, :inherit, :position
+
+
+  # safe_node_context defined in Enrollable
+  safe_node_context  :parent => 'Node', :project => 'Project', :section => 'Section',
+                     :real_project => 'Project', :real_section => 'Section'
+
+  safe_context       :custom_a => Number, :custom_b => Number, #, :score => Number
                      :comments => ['Comment'],
+                     # Code language for syntax highlighting
+                     :content_lang => String,
                      :data   => {:class => ['DataEntry'], :zafu => {:data_root => 'node_a'}},
                      :data_a => {:class => ['DataEntry'], :zafu => {:data_root => 'node_a'}},
                      :data_b => {:class => ['DataEntry'], :zafu => {:data_root => 'node_b'}},
                      :data_c => {:class => ['DataEntry'], :zafu => {:data_root => 'node_c'}},
                      :data_d => {:class => ['DataEntry'], :zafu => {:data_root => 'node_d'}},
-                     :traductions => ['Version'],
-                     :discussion  => 'Discussion'
-  safe_method        :v => {:class => 'Version', :method => 'version'},
+                     :traductions => ['Version'], :discussion  => 'Discussion'
+
+  # we use safe_method because the columns can be null, but the values are never null
+  safe_method        :kpath => String, :user_zip => Number,
+                     :parent_zip => Number, :project_zip => Number, :section_zip => Number,
+                     :ref_lang => String,
+                     :position => Number, :rgroup_id => Number,
+                     :wgroup_id => Number, :dgroup_id => Number, :custom_base => Boolean,
+                     :klass => String,
+                     :m_text => String, :m_title => String, :m_author => String,
+                     :id => {:class => Number, :method => 'zip'},
+                     :skin => 'Skin', :ref_lang => String,
+                     :visitor => 'User', [:ancestor?, Node] => Boolean,
+                     :comments_count => Number,
+                     :v => {:class => 'Version', :method => 'version'},
                      :version => 'Version', :v_status => Number, :v_lang => String,
                      :v_publish_from => Time, :v_backup => Boolean,
                      :zip => Number, :parent_id => {:class => Number, :nil => true, :method => 'parent_zip'},
-                     :author => {:method => 'user', :class => 'User'}, :user => 'User'
+                     :user => 'User',
+                     :author => author_proc,
+                     :vclass => {:class => 'VirtualClass', :method => 'virtual_class'}
 
   # This is needed so that we can use secure_scope and secure in search.
   extend  Zena::Acts::Secure
@@ -221,13 +249,18 @@ class Node < ActiveRecord::Base
   has_multiple :versions, :inverse => 'node'
 
   include Zena::Use::Workflow
-  include Zena::Use::NodeName # must be included after Workflow
-  include Zena::Use::VersionHash
+  include Zena::Use::Ancestry::ModelMethods
 
   # to_xml
-  include Zena::Acts::Serializable::NodeMethods
+  include Zena::Acts::Serializable::ModelMethods
+
+  # compute vhash (must come before Fulltext)
+  include Zena::Use::VersionHash::ModelMethods
+
+  # computed properties (vclass prop_eval)
+  include Zena::Use::PropEval::ModelMethods
 
-  # fulltext indices
+  # fulltext indices (must come after PropEval)
   include Zena::Use::Fulltext::ModelMethods
 
   # List of version attributes that should be accessed as proxies 'v_lang', 'v_status', etc
@@ -262,16 +295,20 @@ class Node < ActiveRecord::Base
 
   include Zena::Use::Relations::ModelMethods
 
+  # model based indices (must come after Relations)
+  include Zena::Use::ScopeIndex::ModelMethods
+
   include Zena::Use::QueryNode::ModelMethods
 
   @@native_node_classes = {'N' => self}
+  @@native_node_classes_by_name = {'Node' => self}
   @@unhandled_children  = []
-  class << self
 
-    def new(hash={})
+  class << self
+    def new(hash={}, vclass = nil)
       node = super()
-      # set kpath before loading roles
-      node.kpath = hash[:kpath] || self.kpath
+      # set virtual_class (acts as schema) before setting attributes
+      node.virtual_class = vclass || VirtualClass[self.name]
       node.attributes = hash
       node
     end
@@ -290,17 +327,66 @@ class Node < ActiveRecord::Base
       end
     end
 
+    def find_by_parent_title_and_kpath(parent_id, title, kpath = nil, opts = {})
+      if cond = opts[:conditions]
+        cond[0] = Array(cond[0])
+      else
+        cond = opts[:conditions] = [[]]
+      end
+
+      if kpath
+        cond[0] << "kpath like ?"
+        cond << "#{kpath}%"
+      end
+      cond[0] << "site_id = ? AND parent_id = ?"
+      cond << current_site.id << parent_id
+
+      find_by_title(title, opts)
+    end
+
+    # Find node by the indexed title.
+    def find_by_title(title, opts = {})
+      if cond = opts[:conditions]
+        cond[0] = Array(cond[0])
+      else
+        cond = opts[:conditions] = [[]]
+      end
+
+      if opts.delete(:like)
+        cond[0] << "id1.value LIKE ?"
+      else
+        cond[0] << "id1.value = ?"
+      end
+      cond << title
+
+      cond[0] = cond[0].join(' AND ')
+
+      opts[:joins] = Node.title_join
+      opts[:select] = 'nodes.*'
+
+      Node.find(:first, opts)
+    end
+
     # Return the list of (kpath,subclasses) for the current class.
     def native_classes
+      load_unhandled_children
+      @@native_node_classes
+    end
+
+    # Return the list of (name,class) for the current class.
+    def native_classes_by_name
+      load_unhandled_children
+      @@native_node_classes_by_name
+    end
+
+    def load_unhandled_children
       # this is to make sure subclasses are loaded before the first call
       # TODO: find a better way to make sure they are all loaded
-      [Note,Page,Project,Section,Reference,BaseContact,Document,Image,TextDocument,Skin,Template]
-
+      [Note,Page,Project,Section,Document,Image,TextDocument,Skin,Template]
       while child = @@unhandled_children.pop
         @@native_node_classes[child.kpath] = child
+        @@native_node_classes_by_name[child.name] = child
       end
-
-      @@native_node_classes.reject {|kpath,klass| !(kpath =~ /^#{self.kpath}/) }
     end
 
     # check inheritance chain through kpath
@@ -310,7 +396,7 @@ class Node < ActiveRecord::Base
 
     # Class list to which this class can change to
     def change_to_classes_for_form
-      classes_for_form(:class => 'Node', :without => 'Document, BaseContact')
+      classes_for_form(:class => 'Node', :without => 'Document')
     end
 
     # List of classes that a node can change to.
@@ -318,50 +404,33 @@ class Node < ActiveRecord::Base
       change_to_classes_for_form.map {|k,v| v}
     end
 
-    # FIXME: how to make sure all sub-classes of Node are loaded before this is called ?
+    # TODO: remove and use VirtualClass[...].classes_for_form directly
     def classes_for_form(opts={})
-      if klass = opts.delete(:class)
-        if klass = get_class(klass)
-          klass.classes_for_form(opts)
-        else
-          return ['', ''] # bad class
-        end
-      else
-        all_classes(opts).map{|a,b| [a[0..-1].sub(/^#{self.kpath}/,'').gsub(/./,'  ') + b.to_s, b.to_s] } # white spaces are insecable spaces (not ' ')
-      end
+      VirtualClass[self.name].classes_for_form(opts)
     end
 
     # FIXME: how to make sure all sub-classes of Node are loaded before this is called ?
+    # TODO: move into helper
     def kpaths_for_form(opts={})
-      all_classes(opts).map{|a,b| [a[1..-1].gsub(/./,'  ') + b.to_s, a.to_s] } # white spaces are insecable spaces (not ' ')
-    end
-
-    def all_classes(opts={})
-      virtual_classes = VirtualClass.find(:all, :conditions => ["site_id = ? AND create_group_id IN (?) AND kpath LIKE '#{self.kpath}%'", current_site[:id], visitor.group_ids])
-      classes = (virtual_classes.map{|r| [r.kpath, r.name]} + native_classes.to_a).sort{|a,b| a[0] <=> b[0]}
-      if opts[:without]
-        reject_kpath =  opts[:without].split(',').map(&:strip).map {|name| Node.get_class(name) }.compact.map { |kla| kla.kpath }.join('|')
-        classes.reject! {|k,c| k =~ /^#{reject_kpath}/ }
+      VirtualClass.all_classes(opts).map do |vclass|
+        # white spaces are insecable spaces (not ' ')
+        a, b = vclass.kpath, vclass.name
+        [a[1..-1].gsub(/./,'  ') + b, a]
       end
-      classes
     end
 
     # Return class or virtual class from name.
+    # FIXME: remove once everything can use VirtualClass[name]
     def get_class(rel, opts={})
       # mushroom_types ==> MushroomType
       class_name = rel =~ /\A[a-z]/ ? rel.singularize.camelize : rel
-      begin
-        klass = Module.const_get(class_name)
-        raise NameError unless klass.ancestors.include?(Node)
-      rescue NameError
-        # find the virtual class
-        if opts[:create]
-          klass = VirtualClass.find(:first, :conditions=>["site_id = ? AND create_group_id IN (?) AND name = ?",current_site[:id], visitor.group_ids, class_name])
-        else
-          klass = VirtualClass.find(:first, :conditions=>["site_id = ? AND name = ?",current_site[:id], class_name])
-        end
+      vclass = VirtualClass.find_by_name(class_name)
+      if opts[:create] && vclass.id
+        # TODO: how do we deal with real class ? (Currently = pass).
+        visitor.group_ids.include?(vclass.create_group_id) ? vclass : nil
+      else
+        vclass
       end
-      klass
     end
 
     # Find a role by name.
@@ -371,19 +440,6 @@ class Node < ActiveRecord::Base
       Role.first(:conditions => ['name = ? AND site_id = ?', role_name, current_site.id])
     end
 
-    # Return a new object of the class name or nil if the class name does not exist.
-    def new_from_class(rel)
-      if k = get_class(rel, :create => true)
-        k.new_instance
-      else
-        nil
-      end
-    end
-
-    def get_class_from_kpath(kp)
-      native_classes[kp] || VirtualClass.find(:first, :conditions=>["site_id = ? AND kpath = ?",current_site[:id], kp])
-    end
-
     # Find a node's attribute based on a pseudo (id or path). Used by zazen to create a link for ""::art or "":(people/ant) for example.
     def translate_pseudo_id(id, sym = :id, base_node = nil)
       if id.to_s =~ /\A(-?)(\d+)\Z/
@@ -408,11 +464,32 @@ class Node < ActiveRecord::Base
       elsif str =~ /\A:?([0-9a-zA-Z ]+)(\+*)\Z/
         offset = $2.to_s.size
         Node.search_records($1.gsub('-',' '), :offset => offset, :limit => 1).first
-      elsif path = str[/\A\(([^\)]*)\)\Z/,1]
+      elsif path = str[/\A\(([^\)]+)\)\Z/,1]
         if path[0..0] == '/'
-          find_by_path(path[1..-1])
+          path = path[1..-1].split('/').map {|p| String.from_filename(p) }
+          find_by_path(path)
         elsif base_node
-          find_by_path(path.abs_path(base_node.fullpath))
+          # transform ../../foo and 45/32/61/72 ==> 'foo' and 45/32
+          path = path.split('/')
+          root = base_node.fullpath.split('/')
+          while path[0] == '..'
+            root.pop
+            path.shift
+          end
+
+          path = path.map {|p| String.from_filename(p) }
+
+          if base_node.zip == root.last.to_i
+            find_by_path(path, base_node.id)
+          elsif root.last
+            if base = find_by_zip(root.last)
+              find_by_path(path, base.id)
+            else
+              nil
+            end
+          else
+            find_by_path(path)
+          end
         else
           # do not use (path) pseudo when there is no base_node (during create_or_update_node for example).
           # FIXME: path pseudo is needed for links... and it should be done here (egg and hen problem)
@@ -430,23 +507,32 @@ class Node < ActiveRecord::Base
 
     def create_or_update_node(new_attributes)
       attributes = transform_attributes(new_attributes)
-      unless attributes['node_name'] && attributes['parent_id']
-        node = Node.new
-        node.errors.add('node_name', "can't be blank") unless attributes['node_name']
-        node.errors.add('parent_id', "can't be blank") unless attributes['parent_id']
-        return node
+
+      v_lang = attributes['v_lang']
+      if !current_site.lang_list.include?(v_lang)
+        attributes['v_lang'] = current_site.lang_list.first
       end
 
-      begin
-        klass = Node.get_class(attributes['klass'] || 'Node')
-        klass = klass.real_class if klass.kind_of?(VirtualClass)
-      rescue NameError
-        klass = Node
+      if zip = attributes.delete('parent_zip')
+        if id = secure(Node) { Node.translate_pseudo_id(zip, :id, self) }
+          attributes['parent_id'] = id
+        else
+          node = Node.new
+          node.errors.add('parent_id', 'could not be found')
+          return node
+        end
+      end
+
+      unless attributes['title'] && attributes['parent_id']
+        node = Node.new
+        node.errors.add('title', "can't be blank")     if attributes['title'].blank?
+        node.errors.add('parent_id', "can't be blank") if attributes['parent_id'].blank?
+        return node
       end
 
       # FIXME: remove 'with_exclusive_scope' once scopes are clarified and removed from 'secure'
-      node = klass.send(:with_exclusive_scope) do
-        Zena::Db.insensitive_find(klass, :first, :site_id => current_site[:id], :parent_id => attributes['parent_id'], :node_name => attributes['node_name'].url_name)
+      node = Node.send(:with_exclusive_scope) do
+        find_by_parent_title_and_kpath(attributes['parent_id'], attributes['title'], nil)
       end
 
       if node
@@ -463,7 +549,7 @@ class Node < ActiveRecord::Base
           node[:create_or_update] = 'same'
         end
       else
-        node = create_node(new_attributes)
+        node = create_node(attributes, false)
         node[:create_or_update] = 'new'
       end
 
@@ -471,31 +557,38 @@ class Node < ActiveRecord::Base
     end
 
     # TODO: cleanup and rename with something indicating the attrs cleanup that this method does.
-    def create_node(new_attributes)
-      attributes = transform_attributes(new_attributes)
-
-      # TODO: replace this hack with a proper class method 'secure' behaving like the
-      # instance method. It would get the visitor and scope from the same hack below.
-      scope   = self.scoped_methods[0] || {}
+    def new_node(new_attributes, transform = true)
+      attributes = transform ? transform_attributes(new_attributes) : new_attributes
 
-      klass_name   = attributes.delete('class') || attributes.delete('klass') || 'Page'
-      unless klass = get_class(klass_name, :create => true)
-        node = Node.new
-        node.instance_eval { @attributes = attributes }
-        node.errors.add('klass', 'invalid')
-        # This is to show the klass in the form seizure
-        node.instance_variable_set(:@klass, klass_name.to_s)
-        def node.klass; @klass; end
-        return node
+      klass_name = attributes.delete('class') || attributes.delete('klass') || 'Page'
+      if klass_name.kind_of?(VirtualClass) || klass_name.kind_of?(Class)
+        klass = klass_name
+      else
+        unless klass = get_class(klass_name, :create => true)
+          node = Node.new
+          node.instance_eval { @attributes.merge!(attributes) }
+          node.errors.add('klass', 'invalid')
+          # This is to show the klass in the form seizure
+          node.instance_variable_set(:@klass, klass_name.to_s)
+          def node.klass; @klass; end
+          return node
+        end
       end
 
-      if klass != self
-        # FIXME: remove 'with_exclusive_scope' once scopes are clarified and removed from 'secure'
-        node = klass.send(:with_exclusive_scope, scope) { klass.create_instance(attributes) }
+      if klass.kind_of?(VirtualClass)
+        node = secure(klass.real_class) { klass.new_instance(attributes) }
       else
-        node = self.create_instance(attributes)
+        node = secure(klass) { klass.new_instance(attributes) }
       end
+      node
+    end
 
+    # TODO: cleanup and rename with something indicating the attrs cleanup that this method does.
+    def create_node(new_attributes, transform = true)
+      node = new_node(new_attributes, transform)
+      if node.errors.empty?
+        node.save
+      end
       node
     end
 
@@ -508,7 +601,7 @@ class Node < ActiveRecord::Base
       parent_id = opts[:parent_id] || opts[:parent][:id]
       folder    = opts[:folder]
       defaults  = (opts[:defaults] || {}).stringify_keys
-      klass     = opts[:klass] || "Page"
+      klass     = opts[:class] || opts[:klass] || "Page"
       res       = {}
 
       unless folder
@@ -521,7 +614,9 @@ class Node < ActiveRecord::Base
         return res
       end
 
-      entries = Dir.entries(folder).reject { |f| f =~ /^([\._~]|[^\w])/ }.sort
+      entries = Dir.entries(folder).reject { |f| f =~ /^([\._~])/ }.map do |filename|
+        String.from_filename(filename)
+      end.sort
 
       index  = 0
 
@@ -534,24 +629,24 @@ class Node < ActiveRecord::Base
 
         if File.stat(path).directory?
           type       = :folder
-          node_name  = filename
+          title      = filename
           sub_folder = path
           attrs      = defaults.dup
           attrs['v_lang'] ||= visitor.lang
         elsif filename =~ /^(.+?)(\.\w\w|)(\.\d+|)\.zml$/  # bird.jpg.en.zml
           # node content in yaml
           type      = :node
-          node_name = "#{$1}#{$4}"
+          title     = "#{$1}#{$4}"
           lang      = $2.blank? ? nil : $2[1..-1]
 
           # no need for base_node (this is done after all with parse_assets in the controller)
           attrs  = defaults.merge(get_attributes_from_yaml(path))
-          attrs['node_name'] = node_name
+          attrs['title'] = title
           attrs['v_lang']    = lang || attrs['v_lang'] || visitor.lang
           versions << attrs
         elsif filename =~ /^((.+?)\.(.+?))(\.\w\w|)(\.\d+|)$/ # bird.jpg.en
           type      = :document
-          node_name = $1
+          title     = $1
           attrs     = defaults.dup
           lang      = $4.blank? ? nil : $4[1..-1]
           attrs['v_lang'] = lang || attrs['v_lang'] || visitor.lang
@@ -560,15 +655,15 @@ class Node < ActiveRecord::Base
         end
 
         index += 1
-        while entries[index] =~ /^#{node_name}(\.\w\w|)(\.\d+|)\.zml$/ # bird.jpg.en.zml
+        while entries[index] =~ /^#{title}(\.\w\w|)(\.\d+|)\.zml$/ # bird.jpg.en.zml
           lang   = $1.blank? ? visitor.lang : $1[1..-1]
           path   = File.join(folder,entries[index])
 
           # we have a zml file. Create a version with this file
           # no need for base_node (this is done after all with parse_assets in the controller)
           attrs = defaults.merge(get_attributes_from_yaml(path))
-          attrs['node_name']   = node_name
-          attrs['v_lang']    ||= lang
+          attrs['title']  ||= title
+          attrs['v_lang'] ||= lang
           versions << attrs
 
           index += 1
@@ -577,14 +672,14 @@ class Node < ActiveRecord::Base
         if versions.empty?
           if type == :folder
             # minimal node for a folder
-            attrs['node_name'] = node_name
-            attrs['v_lang']  ||= lang
-            attrs['class']     = klass
+            attrs['title']    = title
+            attrs['v_lang'] ||= lang
+            attrs['class']    = klass
             versions << attrs
           elsif type == :document
             # minimal node for a document
-            attrs['node_name'] = node_name
-            attrs['v_lang']  ||= lang
+            attrs['title']    = title
+            attrs['v_lang'] ||= lang
             versions << attrs
           end
         end
@@ -594,14 +689,14 @@ class Node < ActiveRecord::Base
           # FIXME: same lang: remove before update current_obj.remove if current_obj.v_lang == attrs['v_lang'] && current_obj.v_status != Zena::Status[:red]
           # FIXME: current_obj.publish if attrs['v_status'].to_i == Zena::Status[:pub]
           if type == :document
-            attrs['node_name' ] = attrs['node_name'].split('.')[0..-2].join('.')
+            attrs['title' ] = attrs['title'].split('.')[0..-2].join('.')
             if document_path
               attrs['ext'] ||= document_path.split('.').last
               # file
               insert_zafu_headings = false
-              if opts[:parent_class] == 'Skin' && ['html','xhtml'].include?(attrs['ext']) && attrs['node_name'] == 'index'
-                attrs['ext']       = 'zafu'
-                attrs['node_name'] = 'Node'
+              if opts[:parent_class] == 'Skin' && ['html','xhtml'].include?(attrs['ext']) && attrs['title'] == 'index'
+                attrs['ext']   = 'zafu'
+                attrs['title'] = 'Node'
                 insert_zafu_headings = true
               end
 
@@ -690,14 +785,6 @@ class Node < ActiveRecord::Base
       node
     end
 
-    # Find a node by it's full path. Cache 'fullpath' if found. This is useless now
-    # that fullpath is properly cached. REMOVE !
-    def find_by_path(path)
-      return nil unless scope = scoped_methods[0]
-      return nil unless scope[:find]   # not secured find. refuse.
-      Zena::Db.insensitive_find(Node, :first, :fullpath => path)
-    end
-
     # FIXME: Where is this used ?
     def class_for_relation(rel)
       case rel
@@ -727,7 +814,7 @@ class Node < ActiveRecord::Base
 
     # Translate attributes from the visitor's reference to the application.
     # This method translates dates, zazen shortcuts and zips and returns a stringified hash.
-    def transform_attributes(new_attributes, base_node = nil, change_timezone = true)
+    def transform_attributes(new_attributes, base_node = nil, change_timezone = true, is_link = false)
       res = {}
       res['parent_id'] = new_attributes[:_parent_id] if new_attributes[:_parent_id] # real id set inside zena.
 
@@ -740,11 +827,11 @@ class Node < ActiveRecord::Base
       end
 
       if !res['parent_id'] && p = attributes['parent_id']
-        res['parent_id'] = Node.translate_pseudo_id(p, :id, base_node) || p
+        res['parent_zip'] = p
       end
 
       attributes.each do |key, value|
-        next if ['_parent_id', 'parent_id'].include?(key)
+        next if ['parent_id', 'parent_zip', '_parent_id'].include?(key)
 
         if %w{rgroup_id wgroup_id dgroup_id}.include?(key)
           res[key] = Group.translate_pseudo_id(value, :id) || value
@@ -752,9 +839,11 @@ class Node < ActiveRecord::Base
           res["#{key}_id"] = Group.translate_pseudo_id(value, :id) || value
         elsif %w{user_id}.include?(key)
           res[key] = User.translate_pseudo_id(value, :id) || value
-        elsif %w{create_at updated_at}.include?(key)
+        elsif %w{id create_at updated_at}.include?(key)
           # ignore (can be present in xml)
-        elsif %w{log_at event_at v_publish_from date}.include?(key)
+        elsif %w{log_at event_at v_publish_from}.include?(key) || (is_link && %w{date}.include?(key))
+          # FIXME: !!! We need to fix timezone parsing in dates depending on the Schema used. This means
+          # that we probably need to do this at the property level (during write).
           if value.kind_of?(Time)
             res[key] = value
           elsif value
@@ -767,26 +856,15 @@ class Node < ActiveRecord::Base
             end
           end
         elsif key =~ /^(\w+)_id$/
-          if key[0..1] == 'd_'
-            res[key] = Node.translate_pseudo_id(value, :zip, base_node) || value
-          else
-            res[key] = Node.translate_pseudo_id(value,  :id, base_node) || value
-          end
+          res["#{$1}_zip"] = value
         elsif key =~ /^(\w+)_ids$/
-          # Id list. Bad ids are removed.
-          values = value.kind_of?(Array) ? value : value.split(',')
-          if key[0..1] == 'd_'
-            values.map! {|v| Node.translate_pseudo_id(v, :zip, base_node) }
-          else
-            values.map! {|v| Node.translate_pseudo_id(v,  :id, base_node) }
-          end
-          res[key] = values.compact
+          res["#{$1}_zips"] = value.kind_of?(Array) ? value : value.split(',')
         elsif key == 'file'
           unless value.blank?
             res[key] = value
           end
         elsif value.kind_of?(Hash)
-          res[key] = transform_attributes(value, base_node, change_timezone)
+          res[key] = transform_attributes(value, base_node, change_timezone, %w{link rel rel_attributes}.include?(key) || is_link)
         else
           # translate zazen
           if value.kind_of?(String)
@@ -814,6 +892,9 @@ class Node < ActiveRecord::Base
         method = signature.first
         if type = super
           type
+        elsif method == 'cached_role_ids'
+          # TODO: how to avoid everything ending in '_id' being caught as relations ?
+          nil
         elsif method =~ /^(.+)_((id|zip|status|comment)(s?))\Z/ && !instance_methods.include?(method)
           key = $3 == 'id' ? "zip#{$4}" : $2
           {:method => "rel[#{$1.inspect}].try(:other_#{key})", :nil => true, :class => ($4.blank? ? Number : [Number])}
@@ -849,6 +930,13 @@ class Node < ActiveRecord::Base
     end
   end
 
+  # Remove loaded version and properties on reload.
+  def reload
+    @version    = nil
+    @properties = nil
+    super
+  end
+
   # TODO: remove when :inverse_of works.
   def versions_with_secure(*args)
     proxy = versions_without_secure(*args)
@@ -869,6 +957,8 @@ class Node < ActiveRecord::Base
   end
 
   # virtual class
+  # FIXME: alias vclass to virtual_class
+  # alias vclass virtual_class
   def vclass
     virtual_class || self.class
   end
@@ -902,7 +992,6 @@ class Node < ActiveRecord::Base
 
   # Replace [id], [title], etc in attributes values
   def replace_attributes_in_values(hash)
-    load_roles!
     hash.each do |k,v|
       hash[k] = safe_eval_string(v)
     end
@@ -920,66 +1009,6 @@ class Node < ActiveRecord::Base
     ZazenParser.new(text,:helper=>helper).render(:translate_ids => :relative_path, :node=>self)
   end
 
-  # Return the list of ancestors (without self): [root, obj, obj]
-  # ancestors to which the visitor has no access are removed from the list
-  def ancestors(start=[])
-    raise Zena::InvalidRecord, "Infinit loop in 'ancestors' (#{start.inspect} --> #{self[:id]})" if start.include?(self[:id])
-    start += [self[:id]]
-    if self[:id] == current_site[:root_id]
-      []
-    elsif self[:parent_id].nil?
-      []
-    else
-      parent = @parent || Node.find(self[:parent_id])
-      parent.visitor = visitor
-      if parent.can_read?
-        parent.ancestors(start) + [parent]
-      else
-        parent.ancestors(start)
-      end
-    end
-  end
-
-  # Return true if the current node is an ancestor for the given child
-  def ancestor?(child)
-    child.fullpath =~ %r{\A#{fullpath}}
-  end
-
-  # url base path. If a node is in 'projects' and projects has custom_base set, the
-  # node's basepath becomes 'projects', so the url will be 'projects/node34.html'.
-  # The basepath is cached. If rebuild is set to true, the cache is updated.
-  def basepath
-    self[:basepath]
-  end
-
-  # Same as fullpath, but the path includes the root node.
-  def rootpath
-    current_site.name + (fullpath != "" ? "/#{fullpath}" : "")
-  end
-
-  alias path rootpath
-
-  # Return an array with the node name and the last two parents' names.
-  def short_path
-    path = self.rootpath.split('/')
-    if path.size > 2
-      ['..'] + path[-2..-1]
-    else
-      path
-    end
-  end
-
-  def pseudo_id(root_node, sym)
-    case sym
-    when :zip
-      self.zip
-    when :relative_path
-      full = self.fullpath
-      root = root_node ? root_node.fullpath : ''
-      "(#{full.rel_path(root)})"
-    end
-  end
-
   # Return save path for an asset (element produced by text like a png file from LateX)
   def asset_path(asset_filename)
     # It would be nice to move this outside 'self[:id]' so that the same asset can
@@ -1067,8 +1096,7 @@ class Node < ActiveRecord::Base
 
   # Create a child and let him inherit from rwp groups and section_id
   def new_child(opts={})
-    klass = opts.delete(:class) || Page
-    c = klass.new(opts)
+    c = Node.new_node(opts)
     c.parent_id  = self[:id]
     c.instance_variable_set(:@parent, self)
 
@@ -1085,9 +1113,8 @@ class Node < ActiveRecord::Base
   end
 
   # ACCESSORS
-  # FIXME: remove
   def author
-    user.contact
+    user.node
   end
 
   alias o_user user
@@ -1117,12 +1144,6 @@ class Node < ActiveRecord::Base
     end
   end
 
-  # set node_name: remove all accents and camelize
-  def node_name=(str)
-    return unless str && str != ""
-    self[:node_name] = str.url_name
-  end
-
   # Return current discussion id (used by query_builder)
   def get_discussion_id
     (discussion && !discussion.new_record?) ? discussion[:id] : '0'
@@ -1142,7 +1163,21 @@ class Node < ActiveRecord::Base
 
   # Id to zip mapping for parent_id. Used by zafu and forms.
   def parent_zip
-    parent ? parent[:zip] : nil
+    @parent_zip || parent.try(:zip)
+  end
+
+  # When setting parent trough controllers, we receive parent_zip=.
+  def parent_zip=(zip)
+    @parent_zip = zip
+  end
+
+  # When setting skin trough controllers, we receive skin_zip=.
+  def skin_zip=(zip)
+    @skin_zip = zip.to_i
+  end
+
+  def skin_zip
+    @skin_zip || skin.try(:zip)
   end
 
   # Id to zip mapping for section_id. Used by zafu and forms.
@@ -1323,14 +1358,15 @@ class Node < ActiveRecord::Base
     n = 0
     while true
       folder_path = File.join(RAILS_ROOT, 'tmp', sprintf('%s.%d.%d', 'archive', $$, n))
+      n += 1
       break unless File.exists?(folder_path)
     end
 
     begin
       FileUtils::mkpath(folder_path)
       export_to_folder(folder_path)
-      tempf = Tempfile.new(node_name)
-      `cd #{folder_path}; tar czf #{tempf.path} *`
+      tempf = Tempfile.new(title.to_filename)
+      `cd #{folder_path.inspect}; tar czf #{tempf.path.inspect} *`
     ensure
       FileUtils::rmtree(folder_path)
     end
@@ -1341,13 +1377,13 @@ class Node < ActiveRecord::Base
   def export_to_folder(path)
     children = secure(Node) { Node.find(:all, :conditions=>['parent_id = ?', self[:id] ]) }
 
-    if kind_of?(Document) && title == node_name && (kind_of?(TextDocument) || text.blank? || text == "!#{zip}!")
+    if kind_of?(Document) && (kind_of?(TextDocument) || text.blank? || text == "!#{zip}!")
       # skip zml
       # TODO: this should better check that version content is really useless
-    elsif title == node_name && text.blank? && klass == 'Page' && children
+    elsif text.blank? && klass == 'Page' && children
       # skip zml
     else
-      File.open(File.join(path, node_name + '.zml'), 'wb') do |f|
+      File.open(File.join(path, title.to_filename + '.zml'), 'wb') do |f|
         f.puts self.to_yaml
       end
     end
@@ -1358,8 +1394,10 @@ class Node < ActiveRecord::Base
     end
 
     if children
-      content_folder = File.join(path, node_name)
-      FileUtils::mkpath(content_folder)
+      content_folder = File.join(path, title.to_filename)
+      if !FileUtils::mkpath(content_folder)
+        puts "Problem..."
+      end
       children.each do |child|
         child.export_to_folder(content_folder)
       end
@@ -1406,10 +1444,7 @@ class Node < ActiveRecord::Base
   # Safe dynamic method dispatching when the method is not known during compile time. Currently this
   # only works for methods without arguments.
   def safe_send(method)
-    # We need to load roles or all properties will be ignored
-    load_roles!
-
-    return nil unless type = safe_method_type([method])
+    return nil unless type = virtual_class.safe_method_type([method])
     res = eval(type[:method])
     res ? res.to_s : nil
   end
@@ -1417,7 +1452,11 @@ class Node < ActiveRecord::Base
   protected
 
     # after node is saved, make sure it's children have the correct section set
+    # FIXME: move this into Ancestry
     def spread_project_and_section
+      # clear parent_zip
+      @parent_zip = nil
+
       if @spread_section_id || @spread_project_id
         # update children
         sync_section_and_project(@spread_section_id, @spread_project_id)
@@ -1478,14 +1517,32 @@ class Node < ActiveRecord::Base
 
   private
     def set_defaults
-      self.title     = self.node_name if title.blank?
-      self.node_name = self.title     if node_name.blank?
-
       self[:custom_base] = false unless kind_of?(Page)
       true
     end
 
     def node_before_validation
+      if @parent_zip
+        if id = secure(Node) { Node.translate_pseudo_id(@parent_zip, :id, new_record? ? nil : self) }
+          self.parent_id = id
+        else
+          @parent_zip_error = _('could not be found')
+        end
+      end
+
+      if @skin_zip
+        if node = secure(Node) { Node.find_by_zip(@skin_zip) }
+          if !node.kind_of?(Skin)
+            @skin_zip_error = _('type mismatch (%{type} is not a Skin)') % {:type => node.klass}
+          else
+            self.skin_id = node.id
+          end
+        else
+          @skin_zip_error = _('could not be found')
+        end
+      end
+
+
       self[:kpath] = self.vclass.kpath
 
       # make sure section is the same as the parent
@@ -1529,6 +1586,18 @@ class Node < ActiveRecord::Base
 
     # Make sure the node is complete before creating it (check parent and project references)
     def validate_node
+      errors.add(:title, "can't be blank") if title.blank?
+
+      if @parent_zip_error
+        errors.add('parent_id', @parent_zip_error)
+        @parent_zip_error = nil
+      end
+
+      if @skin_zip_error
+        errors.add('skin_id', @skin_zip_error)
+        @skin_zip_error = nil
+      end
+
       # when creating root node, self[:id] and :root_id are both nil, so it works.
       if parent_id_changed? && self[:id] == current_site[:root_id]
         errors.add("parent_id", "root should not have a parent") unless self[:parent_id].blank?
@@ -1659,7 +1728,7 @@ class Node < ActiveRecord::Base
     def change_klass
       if @new_klass && !new_record?
         old_kpath = self.kpath
-
+# FIXME ! (new virtual_class as schema...)
         klass = Node.get_class(@new_klass)
         if klass.kind_of?(VirtualClass)
           self[:vclass_id] = klass.kind_of?(VirtualClass) ? klass[:id] : nil
@@ -1716,26 +1785,21 @@ class Node < ActiveRecord::Base
       end
     end
 
-    def get_unique_node_name_in_scope(kpath)
-
-      if node_name_changed? || parent_id_changed? || kpath_changed?
+    def get_unique_title_in_scope(kpath)
+      if prop.title_changed? || parent_id_changed? || kpath_changed?
         Node.send(:with_exclusive_scope) do
-          if new_record?
-            cond = ["node_name = ? AND parent_id = ? AND kpath LIKE ?", self[:node_name], self[:parent_id], kpath]
+          if !new_record?
+            cond = ['nodes.id != ?', id]
           else
-            cond = ["node_name = ? AND parent_id = ? AND kpath LIKE ? AND id != ? ", self[:node_name], self[:parent_id], kpath, self[:id]]
+            cond = nil
           end
 
-          if taken_name = Node.find(:first, :select => 'node_name', :conditions => cond, :order => "LENGTH(node_name) DESC")
-            if taken_name =~ /^#{self[:node_name]}-(\d)/
-              self[:node_name] = "#{self[:node_name]}-#{$1.to_i + 1}"
-              i = $1.to_i + 1
+          if taken_name = Node.find_by_parent_title_and_kpath(parent_id, title, kpath, :order => "LENGTH(id1.value) DESC", :select => 'id1.value', :conditions => cond)
+            if taken_name =~ /^#{title}-(\d)/
+              self.title = "#{title}-#{$1.to_i + 1}"
             else
-              self[:node_name] = "#{self[:node_name]}-1"
-              i = 1
+              self.title = "#{title}-1"
             end
-
-            self.title = "#{title}-#{i}" unless title.blank?
           end
         end
       end