zena 1.0.0.beta3 → 1.0.0.rc1

data/app/models/template.rb

@@ -6,11 +6,11 @@ Definitions:
 
 Render ---> Master template --include--> helper template --include--> ...
 
-For master templates, the node_name is build from the different filters (target_klass, mode, format):
+For master templates, the title is build from the different filters (target_klass, mode, format):
 
 Klass-mode-format. Examples: Node-index, Node--xml, Project-info. Note how the format is omitted when it is 'html'.
 
-Other templates have a node_name built from the given name, just like any other node.
+Other templates have a title built from the given name, just like any other node.
 
 =end
 class Template < TextDocument
@@ -29,7 +29,7 @@ class Template < TextDocument
         'skin_id'   => record[:section_id],
       }
     end
-
+    
     safe_property :tkpath, :mode, :target_klass, :format
   end
 
@@ -63,14 +63,14 @@ class Template < TextDocument
       # Force template content-type to 'text/zafu'
       self.content_type = 'text/zafu'
 
-      if node_name_changed?
-        if node_name =~ /^([A-Z][a-zA-Z]+?)(-(([a-zA-Z_\+]*)(-([a-zA-Z_]+)|))|)(\.|\Z)/
-          # node_name/title changed force  update
+      if prop.title_changed?
+        if title =~ /^([A-Z][a-zA-Z]+?)(-(([a-zA-Z_\+]*)(-([a-zA-Z_]+)|))|)(\.|\Z)/
+          # title changed force  update
           prop['target_klass']  = $1            unless prop.target_klass_changed?
           prop['mode']   = ($4 || '').url_name  unless prop.mode_changed?
           prop['format'] = ($6 || 'html')       unless prop.format_changed?
         else
-          # node_name set but it is not a master template name
+          # title set but it is not a master template name
           prop['target_klass']  = nil
           prop['mode']   = nil
           prop['format'] = nil
@@ -78,13 +78,12 @@ class Template < TextDocument
       end
 
       if version.edited?
-         prop['mode'] = prop['mode'].url_name if prop['mode']
+         prop['mode'] = prop['mode'].gsub(/[^a-zA-Z]/, '') if prop['mode']
 
         if !prop['target_klass'].blank?
-          # update node_name
+          # update title
           prop['format'] = 'html' if prop['format'].blank?
-          self.node_name = node_name_from_mode_and_format
-          self.title = self.node_name
+          self.title = title_from_mode_and_format
 
           if text.blank? && prop['format'] == 'html' && prop['mode'] != '+edit'
             # set a default text
@@ -121,7 +120,7 @@ END_TXT
       end
     end
 
-    def node_name_from_mode_and_format(opts={})
+    def title_from_mode_and_format(opts={})
       opts[:format]  ||= prop['format']
       opts[:mode  ]  ||= prop['mode']
       opts[:target_klass ]  ||= prop['target_klass']

data/app/models/text_document.rb

@@ -43,8 +43,6 @@ class TextDocument < Document
         return text
       end
 
-      base_path = parent.fullpath
-
       res.gsub!(/url\(\s*(.*?)\s*\)/) do
         match, src = $&, $1
         if src =~ /('|")(.*?)\1/
@@ -71,14 +69,14 @@ class TextDocument < Document
         else
           if new_src = helper.send(:template_url_for_asset,
               :src          => src,
-              :base_path    => base_path,
+              :parent       => parent,
               :parse_assets => true )
 
             "url(#{quote}#{new_src}#{quote})"
           elsif !(src =~ /\.\./) && File.exist?(File.join(SITES_ROOT, current_site.public_path, src))
             "url(#{quote}#{src}?#{File.mtime(File.join(SITES_ROOT, current_site.public_path, src)).to_i}#{quote})"
           else
-            errors.add('asset', '{{asset}} not found', :asset => src.inspect)
+            errors.add('asset', _('%{asset} not found') % {:asset => src.inspect})
             "url(#{quote}#{src}#{quote})"
           end
         end
@@ -129,12 +127,13 @@ class TextDocument < Document
             zip, mode = $1, $2
             if asset = secure(Node) { Node.find_by_zip(zip) }
               if asset.fullpath =~ /\A#{base_path}\/(.+)/
-                "url(#{quote}#{$1}#{mode}.#{asset.prop['ext']}#{quote})"
+                path = fullpath_as_title($1)
+                "url(#{quote}#{path}#{mode}.#{asset.prop['ext']}#{quote})"
               else
-                "url(#{quote}/#{asset.fullpath}#{mode}.#{asset.prop['ext']}#{quote})"
+                "url(#{quote}/#{asset.fullpath_as_title.map(&:to_filename).join('/')}#{mode}.#{asset.prop['ext']}#{quote})"
               end
             else
-              errors.add('asset', '{{zip}} not found', :zip => zip)
+              errors.add('asset', '%{zip} not found', :zip => zip)
               "url(#{quote}#{url}#{quote})"
             end
           elsif File.exist?(File.join(SITES_ROOT, current_site.public_path, url.sub(/\?\d+\Z/,'')))

data/app/models/user.rb

@@ -45,23 +45,36 @@ class User < ActiveRecord::Base
     c.validate_password_field = false
   end
 
+  # Dynamic resolution of the author class from the prototype
+  def self.node_user_proc
+    Proc.new do |h, r, s|
+      res = {:method => 'node', :nil => true}
+      if prototype = visitor.prototype
+        res[:class] = prototype.vclass
+      else
+        res[:class] = VirtualClass['Node']
+      end
+      res
+    end
+  end
+
   include RubyLess
 
-  safe_attribute          :login, :name, :first_name, :email, :time_zone, :created_at, :updated_at, :lang, :id
-  safe_method             :initials => String, :fullname => String, :status => Number, :status_name => String,
+  safe_attribute          :login, :time_zone, :created_at, :updated_at, :lang, :id
+  safe_method             :initials => String, :status => Number, :status_name => String,
                           :is_anon? => Boolean, :is_admin? => Boolean, :user? => Boolean, :commentator? => Boolean,
                           :moderated? => Boolean
 
-  safe_context            :contact => 'BaseContact', :node => {:method => 'contact', :class => 'BaseContact'},
+  safe_context            :node => node_user_proc,
                           :to_publish => ['Version'], :redactions => ['Version'], :proposed => ['Version'],
                           :comments_to_publish => ['Comment']
 
-  attr_accessible         :login, :lang, :first_name, :name, :email, :time_zone, :status, :group_ids, :site_ids, :crypted_password, :password
+  attr_accessible         :login, :lang, :node, :time_zone, :status, :group_ids, :site_ids, :crypted_password, :password, :dev_skin_id
   attr_accessor           :visited_node_ids
   attr_accessor           :ip
 
   belongs_to              :site
-  belongs_to              :contact, :dependent => :destroy, :class_name => 'BaseContact'
+  belongs_to              :node, :dependent => :destroy # Do we want this ? (won't work if there are sub-nodes...)
   has_and_belongs_to_many :groups
   has_many                :nodes
   has_many                :versions
@@ -69,11 +82,12 @@ class User < ActiveRecord::Base
   before_validation       :user_before_validation
   validate                :valid_groups
   validate                :valid_user
+  validate                :valid_node
   validates_uniqueness_of :login, :scope => :site_id
 
   before_destroy          :dont_destroy_protected_users
   validates_presence_of   :site_id
-  before_create           :create_contact
+  before_create           :create_node
 
   Status = {
     :su          => 80,
@@ -88,6 +102,8 @@ class User < ActiveRecord::Base
 
 
   class << self
+    # This method is used by authlogic and is only called from withing a Secure scope that
+    # enforces the proper site_id.
     def find_allowed_user_by_login(login)
       first(:conditions=>["login = ? and status > 0", login])
     end
@@ -110,10 +126,10 @@ class User < ActiveRecord::Base
 
   end
 
-  def contact_with_secure
-    @contact ||= secure(BaseContact) { contact_without_secure }
+  def node_with_secure
+    @node ||= secure(Node) { node_without_secure }
   end
-  alias_method_chain :contact, :secure
+  alias_method_chain :node, :secure
 
 
   # Each time a node is found using secure (Zena::Acts::Secure or Zena::Acts::SecureNode), this method is
@@ -131,16 +147,51 @@ class User < ActiveRecord::Base
     @visited_node_ids ||= []
   end
 
-  def fullname
-    (first_name ? (first_name + " ") : '') + name.to_s
+  # Return the prototype user (used by Zafu and QueryBuilder to know the class
+  # of the visitor and during user creation)
+  def prototype
+    @prototype ||= begin
+      secure(Node) { Node.new_node(prototype_attributes) }
+    end
   end
 
-  def initials
-    fullname.split(" ").map {|w| w[0..0].capitalize}.join("")
+  # Return a new Node to be used by a new User as base for creating the visitor Node.
+  def prototype_attributes
+    @prototype_attributes ||= begin
+      attrs = begin
+        if code = current_site.prop['usr_prototype_attributes']
+          hash = safe_eval(code)
+          if hash.kind_of?(Hash)
+            hash
+          else
+            {}
+          end
+        else
+          {}
+        end
+      rescue RubyLess::Error => err
+        {}
+      end
+
+      # This is a security feature to avoid :_parent_id set manually in usr_prototype_attributes.
+      attrs.stringify_keys!
+      unless attrs['parent_id']
+        attrs[:_parent_id] = current_site[:root_id]
+      end
+
+      attrs['klass'] ||= attrs.delete('class') || 'Node'
+
+      attrs
+    end
   end
 
-  def email
-    self[:email] || ""
+  def node_attributes=(node_attrs)
+    if self[:node_id]
+      @node = secure!(Node) { node_without_secure }
+    else
+      @node = secure(Node) { Node.new_node(prototype_attributes) }
+    end
+    @node.attributes = node_attrs || {}
   end
 
   def status_name
@@ -149,7 +200,7 @@ class User < ActiveRecord::Base
 
   # Return true if the user is in the admin group or if the user is the super user.
   def is_admin?
-    is_su? || status.to_i >= User::Status[:admin]
+    status.to_i >= User::Status[:admin]
   end
 
   # Return true if the user is the anonymous user for the current visited site
@@ -158,12 +209,6 @@ class User < ActiveRecord::Base
     user_site.anon_id == self[:id] && (!new_record? || self[:login].nil?) # (when creating a new site, anon_id == nil)
   end
 
-  # Return true if the user is the super user for the current visited site
-  def is_su?
-    # tested in site_test
-    user_site.su_id == self[:id]
-  end
-
   # Return true if the user's status is high enough to start editing nodes.
   def user?
     status >= User::Status[:user]
@@ -244,13 +289,8 @@ class User < ActiveRecord::Base
   end
 
   def comments_to_publish
-    if is_su?
-      # su can view all
-      secure(Comment) { Comment.find(:all, :conditions => ['status = ?', Zena::Status[:prop]]) }
-    else
-      secure(Comment) { Comment.find(:all, :select=>'comments.*, nodes.node_name', :from=>'comments, nodes, discussions',
+    secure(Comment) { Comment.find(:all, :select=>'comments.*', :from=>'comments, nodes, discussions',
                    :conditions => ['comments.status = ? AND discussions.node_id = nodes.id AND comments.discussion_id = discussions.id AND nodes.dgroup_id IN (?)', Zena::Status[:prop], visitor.group_ids]) }
-    end
   end
 
   # List all versions proposed for publication that the user has the right to publish.
@@ -274,31 +314,21 @@ class User < ActiveRecord::Base
       self.site || visitor.site # site when User is new
     end
 
-    def create_contact
-      return unless visitor.site[:root_id] # do not try to create a contact if the root node is not created yet
+    def create_node
+      return unless visitor.site[:root_id] # do not try to create a node if the root node is not created yet
 
-      @contact = secure!(BaseContact) { BaseContact.new(
-        # owner is the user except for anonymous and super user.
-        :user_id     => visitor[:id],
-        :title       => (name.blank? || first_name.blank?) ? login : fullname,
-        :first_name  => first_name,
-        :name        => (name || login),
-        :email       => email,
-        :v_status    => Zena::Status[:pub]
-      )}
+      @node.version.status = Zena::Status[:pub]
 
-      @contact[:parent_id] = site[:root_id]
-
-      unless @contact.save
+      unless @node.save
         # What do we do with this error ?
-        raise Zena::InvalidRecord, "Could not create contact node for user #{self.id} in site #{site_id} (#{@contact.errors.map{|k,v| [k,v]}.join(', ')})"
+        raise Zena::InvalidRecord, "Could not create contact node for user #{self.id} in site #{site_id} (#{@node.errors.map{|k,v| [k,v]}.join(', ')})"
       end
 
-      unless @contact.publish_from
-        raise Zena::InvalidRecord, "Could not publish contact node for user #{user_id} in site #{site_id} (#{@contact.errors.map{|k,v| [k,v]}.join(', ')})"
+      unless @node.publish_from
+        raise Zena::InvalidRecord, "Could not publish contact node for user #{user_id} in site #{site_id} (#{@node.errors.map{|k,v| [k,v]}.join(', ')})"
       end
 
-      self[:contact_id] = @contact[:id]
+      self[:node_id] = @node[:id]
     end
 
     # Set user defaults.
@@ -362,6 +392,25 @@ class User < ActiveRecord::Base
       end
     end
 
+    def valid_node
+      return unless visitor.site[:root_id] # do not validate node if the root node is not created yet
+      return if !new_record? && !@node
+      if !@node
+        # force creation of node, even if it is a plain copy of the prototype
+        self.node_attributes = {'title' => login}
+      else
+        @node.title ||= login
+      end
+
+      if @node.valid?
+        # ok
+      else
+        @node.errors.each_error do |err, msg|
+          errors.add("node[#{err}]", msg)
+        end
+      end
+    end
+
     # Make sure all users are in the _public_ and _site_ groups. Make sure
     # the user only belongs to groups in the same site.
     def valid_groups #:doc:

data/app/models/version.rb

@@ -6,7 +6,7 @@ class Version < ActiveRecord::Base
   safe_attribute     :created_at, :updated_at, :publish_from, :status, :lang
   safe_method        :node => 'Node', :id => {:class => Number, :method => 'number'},
                      :number => Number, :user => 'User',
-                     :author => {:class => 'User', :method => 'user'}
+                     :author => Node.author_proc
 
   # We need to include Property::Base so that we can read the properties that
   # we store (useful when listing versions or comparing them).
@@ -54,7 +54,7 @@ class Version < ActiveRecord::Base
   end
 
   def author
-    user.contact
+    user.node
   end
 
   def mark_for_destruction

data/app/models/virtual_class.rb

@@ -1,57 +1,292 @@
 # encoding: utf-8
+
+# The virtual class holds type information and other attributes to build indices
+# and computed properties. This class acts as the "schema" for nodes.
+#
+# Since this class also _uses_ Property to store some of it's data, confusion must not
+# be made between the VirtualClass as a schema (containing Node property definitions) and
+# the VirtualClass' own schema.
+#
+# The roles in the vclass contain self, super and all the attached roles like this (roles for
+# the Letter virtual class):
+#
+#     [
+#       <VirtualClass:'Letter' paper, search_mono, search>,
+#       [
+#         <VirtualClass:'Note' >,
+#    -->  <Role:'Note' >,
+#         [
+#           <VirtualClass:'Node' >,
+#    -->    <Role:'Node' cached_role_ids, title, text, summary>,
+#           <Role:'Original' weight, origin, tz>,
+#           <Role:'Task' assigned>
+#         ]
+#       ]
+#     ]
+#
+# Elements marked with '-->' above are the 'schema' roles used by the real classes to store
+# ruby declared properties. Since Zena is multi-site, there is one VirtualClass instance of
+# the real classes for each site: this is why the ruby declarations are not stored in the
+# VirtualClass itself for real classes.
+#
 class VirtualClass < Role
   attr_accessor :import_result
   belongs_to    :create_group, :class_name => 'Group', :foreign_key => 'create_group_id'
   validate      :valid_virtual_class
+  attr_accessible :create_group_id, :auto_create_discussion
+
+  include Property::StoredSchema
   include Zena::Use::Relations::ClassMethods
   include Zena::Use::Fulltext::VirtualClassMethods
+  include Zena::Use::PropEval::VirtualClassMethods
+  include Zena::Use::ScopeIndex::VirtualClassMethods
+
+  safe_method  :roles     => {:class => ['Role'], :method => 'sorted_roles'}
+  safe_method  :relations => {:class => ['RelationProxy'], :method => 'all_relations'}
+  safe_method  [:relations, String] => {:class => ['RelationProxy'], :method => 'filtered_relations'}
+  # All columns defined for a VirtualClass (kpath based).
+  safe_method :all_columns => {:class => ['Column'], :method => 'safe_columns'}
 
-  # Import a hash of virtual class definitions and try to build the virtual classes.
-  def self.import(data)
-    data.keys.map do |klass|
-      build_virtual_class(klass, data)
+  class Cache
+    def initialize
+      clear_cache!
     end
-  end
 
-  # Build a virtual class from a name and a hash of virtual class definitions. If
-  # the superclass is in the data hash, it is built first.
-  def self.build_virtual_class(klass, data)
-    return data[klass]['result'] if data[klass].has_key?('result')
-    if virtual_class = Node.get_class(klass)
-      if virtual_class.superclass.to_s == data[klass]['superclass']
-        virtual_class.import_result = 'same'
-        return data[klass]['result'] = virtual_class
+    def find_by_id(id)
+      clear_cache! if stale?
+
+      @cache_by_id[id] || load_vclass(:id => id)
+    end
+
+    def find_by_kpath(kpath)
+      clear_cache! if stale?
+
+      @cache_by_kpath[kpath] || load_vclass(:kpath => kpath)
+    end
+
+    def find_by_name(name)
+      clear_cache! if stale?
+
+      @cache_by_name[name] || load_vclass(:name => name)
+    end
+
+    def all_classes(base_kpath = 'N', without_list = nil)
+      load_all_classes!
+
+      filter_on = %r{\A#{base_kpath}}
+
+      if without_list
+        regexp = []
+        without_list.split(',').map(&:strip).each do |without|
+          if filter_class = VirtualClass[without]
+            regexp << "\\A#{filter_class.kpath}"
+          end
+        end
+        unless regexp.empty?
+          filter_off = %r{\A#{regexp.join('|')}}
+        end
+      end
+
+      @cache_by_kpath.values.select do |vclass|
+        (vclass.kpath =~ filter_on) &&
+        (filter_off.nil? || !(vclass.kpath =~ filter_off))
+      end.sort {|a, b| a.kpath <=> b.kpath}
+    end
+
+    def clear_cache!
+      @updated_at = current_site[:roles_updated_at].to_f
+      @cache_by_id    = {}
+      @cache_by_kpath = {}
+      @cache_by_name  = {}
+      @all_classes_loaded = false
+    end
+
+    def load_all_classes!
+      return if @all_classes_loaded
+
+      conditions = [["site_id = ?"], current_site.id]
+      unless @cache_by_id.empty?
+        conditions[0] << "id NOT IN (?)"
+        conditions << @cache_by_id.keys
+      end
+
+      conditions[0] = conditions[0].join(' AND ')
+
+      Node.native_classes.each do |kpath, real_class|
+        load_roles_and_cache(build_vclass_from_real_class(real_class))
+      end
+
+      VirtualClass.all(
+        :conditions => conditions,
+        :order      => 'kpath ASC').each do |vclass|
+        load_roles_and_cache(vclass)
+      end
+
+      @all_classes_loaded = true
+    end
+
+    def stale?
+      @updated_at < current_site[:roles_updated_at].to_f
+    end
+
+    def load_vclass(conditions)
+      if kpath = conditions[:kpath]
+        real_class = Node.native_classes[kpath]
+      elsif name = conditions[:name]
+        raise if name.kind_of?(Fixnum)
+        real_class = Node.native_classes_by_name[name]
+      end
+
+      if real_class
+        vclass = build_vclass_from_real_class(real_class)
       else
-        virtual_class.errors.add(:base, 'conflict')
-        return data[klass]['result'] = virtual_class
+        vclass = VirtualClass.first(:conditions => conditions.merge(:site_id => current_site.id))
       end
-    else
-      superclass_name = data[klass]['superclass']
-      if data[superclass_name]
-        superclass = build_virtual_class(superclass_name, data)
-        unless superclass.errors.empty?
-          virtual_class = VirtualClass.new(:name => klass, :superclass => superclass_name, :create_group_id => current_site.public_group_id)
-          virtual_class.errors.add(:base, 'conflict in superclass')
+
+      load_roles_and_cache(vclass) if vclass
+
+      vclass
+    end
+
+    def build_vclass_from_real_class(real_class)
+      vclass = VirtualClass.new(:name => real_class.name)
+      vclass.kpath      = real_class.kpath
+      vclass.real_class = real_class
+      vclass.include_role real_class.schema
+      vclass.instance_variable_set(:@is_real_class, true)
+      vclass
+    end
+
+    def load_roles_and_cache(vclass)
+      vclass.load_attached_roles!
+      @cache_by_id[vclass.id] = vclass if vclass.id
+      @cache_by_kpath[vclass.kpath] = vclass
+      @cache_by_name[vclass.name]  = vclass
+    end
+  end # Cache
+
+  class << self
+    attr_accessor :caches_by_site
+
+    # Import a hash of virtual class definitions and try to build the virtual classes.
+    def import(data)
+      data.keys.map do |klass|
+        build_virtual_class(klass, data)
+      end
+    end
+
+    def [](name)
+      find_by_name(name)
+    end
+
+    def find_by_id(id)
+      (self.caches_by_site[current_site.id] ||= Cache.new).find_by_id(id)
+    end
+
+    def find_by_kpath(kpath)
+      (self.caches_by_site[current_site.id] ||= Cache.new).find_by_kpath(kpath)
+    end
+
+    def find_by_name(name)
+      (self.caches_by_site[current_site.id] ||= Cache.new).find_by_name(name)
+    end
+
+    def expire_cache!
+      Zena::Db.set_attribute(current_site, 'roles_updated_at', Time.now.utc)
+      self.caches_by_site[current_site.id] = Cache.new
+    end
+
+    def all_classes(base_kpath = 'N', without_list = nil)
+      (self.caches_by_site[current_site.id] ||= Cache.new).all_classes(base_kpath, without_list)
+    end
+
+    # Build a virtual class from a name and a hash of virtual class definitions. If
+    # the superclass is in the data hash, it is built first.
+    def build_virtual_class(klass, data)
+      return data[klass]['result'] if data[klass].has_key?('result')
+      if virtual_class = VirtualClass[klass]
+        virtual_class = virtual_class.dup
+        if virtual_class.superclass.to_s == data[klass]['superclass']
+          virtual_class.import_result = 'same'
+          return data[klass]['result'] = virtual_class
+        else
+          virtual_class.errors.add(:base, 'conflict')
           return data[klass]['result'] = virtual_class
         end
-      elsif superclass = Node.get_class(superclass_name)
-        # ok
       else
-        virtual_class = VirtualClass.new(:name => klass, :superclass => superclass_name, :create_group_id => current_site.public_group_id)
-        virtual_class.errors.add(:base, 'missing superclass')
+        superclass_name = data[klass]['superclass']
+        if data[superclass_name]
+          superclass = build_virtual_class(superclass_name, data)
+          unless superclass.errors.empty?
+            virtual_class = VirtualClass.new(:name => klass, :superclass => superclass_name, :create_group_id => current_site.public_group_id)
+            virtual_class.errors.add(:base, 'conflict in superclass')
+            return data[klass]['result'] = virtual_class
+          end
+        elsif superclass = Node.get_class(superclass_name)
+          # ok
+        else
+          virtual_class = VirtualClass.new(:name => klass, :superclass => superclass_name, :create_group_id => current_site.public_group_id)
+          virtual_class.errors.add(:base, 'missing superclass')
+          return data[klass]['result'] = virtual_class
+        end
+
+        # build
+        create_group_id = superclass.id ? superclass.create_group_id : current_site.public_group_id
+        virtual_class = create(data[klass].merge(:name => klass, :create_group_id => create_group_id))
+        virtual_class.import_result = 'new'
         return data[klass]['result'] = virtual_class
       end
+    end
+
+    def export
+      # TODO
+    end
+  end
 
-      # build
-      create_group_id = superclass.kind_of?(VirtualClass) ? superclass.create_group_id : current_site.public_group_id
-      virtual_class = create(data[klass].merge(:name => klass, :create_group_id => create_group_id))
-      virtual_class.import_result = 'new'
-      return data[klass]['result'] = virtual_class
+  self.caches_by_site ||= {}
+
+  # FIXME: how to make sure all sub-classes of Node are loaded before this is called ?
+  # TODO: move into helper
+  def classes_for_form(opts={})
+    group_ids = visitor.group_ids
+    if klass = opts.delete(:class)
+      if klass = VirtualClass[klass]
+        base_kpath = klass.kpath
+      else
+        base_kpath = self.kpath
+      end
+    else
+      base_kpath = self.kpath
     end
+
+    kpath_len = base_kpath.size
+
+    VirtualClass.all_classes(base_kpath, opts[:without]).map do |vclass|
+      if vclass.create_group_id.nil? || group_ids.include?(vclass.create_group_id)
+        # white spaces are insecable spaces (not ' ')
+        a, b = vclass.kpath, vclass.name
+        [('  ' * (a.size - kpath_len)) + b, b]
+      else
+        nil
+      end
+    end.compact
   end
 
-  def self.export
-    # TODO
+  # Include all roles into the this schema. By including the superclass
+  # and all roles related to this class.
+  def load_attached_roles!
+    return if @attached_roles_loaded
+
+    super_kpath = kpath[0..-2]
+    if super_kpath != ''
+      include_role VirtualClass.find_by_kpath(super_kpath)
+    end
+
+    attached_roles.each do |role|
+      include_role role
+    end
+
+    @attached_roles_loaded = true
   end
 
   def to_s
@@ -62,35 +297,137 @@ class VirtualClass < Role
     self[:icon] = txt.gsub('..', '.') # SECURITY
   end
 
-  # FIXME: how to make sure all sub-classes of Node are loaded before this is called ?
-  def classes_for_form(opts={})
-    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 ' ')
+  # check inheritance chain through kpath
+  def kpath_match?(kpath)
+    self.kpath =~ /^#{kpath}/
+  end
+
+  # Return true if the class reflects a real class (proxy for Ruby class).
+  def real_class?
+    @is_real_class
   end
 
-  def all_classes(opts={})
-    classes = VirtualClass.find(:all, :conditions => ["site_id = ? AND create_group_id IN (?) AND kpath LIKE '#{self.kpath}%'", current_site[:id], visitor.group_ids]).map{|r| [r.kpath, r.name] }.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}/ }
+  # Proxy methods for real class --------------
+
+  # We use the VirtualClass to act as a proxy for the real class when resolving
+  # RubyLess methods. If the class reflects a 'real' class, only the methods
+  # explicitely declared as safe are safe. If the VirtualClass reflects a virtual
+  # class, all properties are considered safe.
+  def safe_method_type(signature, receiver = nil)
+    if signature.size == 1 && (type = safe_column_types[signature.first])
+      type
+    else
+      real_class.safe_method_type(signature, receiver)
     end
-    classes
   end
 
-  # check inheritance chain through kpath
-  def kpath_match?(kpath)
-    self.kpath =~ /^#{kpath}/
+  # Return safe columns including super class's safe columns
+  def defined_safe_columns
+    @defined_safe_columns ||= if real_class?
+      # Get columns from the 'native' schema of the real class (this schema is a Property::Role,
+      # not a VirtualClass or ::Role).
+      #
+      # Only columns explicitly declared safe are safe here
+      real_class.schema.defined_columns.values.select do |col|
+        real_class.safe_method_type([col.name])
+      end.sort {|a,b| a.name <=> b.name}
+    else
+      super
+    end
   end
 
+  # Return safe columns including super class's safe columns. The columns are
+  # sorted by kpath, origin (VirtualClass first, Role next) and name.
+  def safe_columns
+    @safe_columns ||= begin
+      (superclass.kind_of?(VirtualClass) ? superclass.safe_columns : []) +
+      defined_safe_columns +
+      attached_roles.map(&:defined_safe_columns).flatten.sort {|a,b| a.name <=> b.name}
+    end
+  end
+
+  # Returns a hash of all column types that are RubyLess safe (declared as safe in a real class
+  # or just dynamic properties declared in the DB). In the Role: everything is safe
+  # (see VirtualClass#safe_column_types).
+  def safe_column_types
+    @safe_column_types ||= Hash[*safe_columns.map do |column|
+      [column.name, RubyLess::SafeClass.safe_method_type_for_column(column, true)]
+    end.flatten]
+  end
+
+  # List all roles ordered by ascending kpath and name
+  def sorted_roles
+    @sorted_roles ||= begin
+      res = []
+      if superclass.kind_of?(VirtualClass)
+        res << superclass.sorted_roles
+      end
+      res << self unless defined_safe_columns.empty?
+      attached_roles.sort{|a,b| a.name <=> b.name}.each do |role|
+        res << role unless role.defined_safe_columns.empty?
+      end
+      res.flatten!
+      res
+    end
+  end
+
+  # Return virtual class' super class or Node for the virtual class of
+  # Node.
   def superclass
-    if new_record?
+    if kpath && kpath.size > 1
+      VirtualClass.find_by_kpath(kpath[0..-2])
+    else
       Node
+    end
+  end
+
+  # This is used by RubyLess in method signatures: [:zen_path, #<VirtualClass 'Post'>] ---> [:zen_path, Node]
+  def ancestors
+    @ancestors ||= [real_class] + real_class.ancestors
+  end
+
+  # Test ancestry
+  def <=(other_class)
+    if other_class.kind_of?(VirtualClass)
+      kpath = other_class.kpath
+      self.kpath[0..(kpath.length-1)] == kpath
+    else
+      real_class <= other_class
+    end
+  end
+
+  # Test ancestry
+  def <(other_class)
+    if other_class.kind_of?(VirtualClass)
+      kpath = other_class.kpath
+      self.kpath != kpath && self.kpath[0..(kpath.length-1)] == kpath
+    elsif real_class.kpath != self.kpath
+      # Sub class of real_class
+      real_class <= other_class
     else
-      Node.get_class_from_kpath(kpath[0..-2])
+      # VirtualClass of the real_class
+      real_class < other_class
     end
   end
 
+
+  # Return the SQLiss query compiler.
+  def query_compiler
+    real_class.query_compiler
+  end
+
+  # Build SQLiss query.
+  def build_query(*args)
+    real_class.build_query(*args)
+  end
+
+  # Execute find
+  def do_find(*args)
+    real_class.do_find(*args)
+  end
+
   def superclass=(klass)
-    if k = Node.get_class(klass)
+    if k = VirtualClass[klass]
       @superclass = k
     else
       errors.add('superclass', 'invalid')
@@ -99,54 +436,63 @@ class VirtualClass < Role
 
   # Build new nodes instances of this VirtualClass
   def new_instance(hash={})
-    real_class.new(hash.merge(:kpath => self.kpath, :vclass_id => self.id))
+    real_class.new(hash, self)
   end
 
   # Create new nodes instances of this VirtualClass
   def create_instance(*args)
-    if @scope
-      # FIXME: remove 'with_exclusive_scope' once scopes are clarified and removed from 'secure'
-      real_class.send(:with_exclusive_scope, @scope) {
-        obj = self.new_instance(*args)
-        obj.save
-        obj
-      }
-    else
-      obj = self.new_instance(*args)
-      obj.save
-      obj
-    end
+    obj = self.new_instance(*args)
+    obj.save
+    obj
   end
 
   def real_class
-    klass = Module::const_get(self[:real_class])
-    raise NameError unless klass.ancestors.include?(Node)
-    klass
+    @real_class ||= begin
+      klass = Module::const_get(self[:real_class] || 'Node')
+      raise NameError unless klass.ancestors.include?(Node)
+      klass
+    end
   end
 
-  def with_exclusive_scope(scope, &block)
-    @scope = scope
-    res = yield
-    @scope = nil
-    res
+  def real_class=(klass)
+    @real_class = klass
   end
 
   def import_result
     @import_result || errors[:base]
   end
 
+  # List all relations that can be set for this class, filtering by
+  # relation group.
+  def filtered_relations(group_filter)
+    all_relations(nil, group_filter)
+  end
+
+  # Cache index groups
+  def index_groups
+    @index_groups ||= super
+  end
+
   private
+    def attached_roles
+      ::Role.all(
+        :conditions => ['kpath = ? AND site_id = ? AND type != ?',
+          kpath, current_site.id, 'VirtualClass'],
+        :order => 'kpath ASC'
+      )
+    end
+
     def valid_virtual_class
       return if !errors.empty?
       @superclass ||= self.superclass
 
-      if new_record? || name_changed? || @superclass != old.superclass
+      if real_class? || name_changed? || @superclass != old.superclass
         index = 0
         kpath = nil
         while index < self[:name].length
           try_kpath = @superclass.kpath + self[:name][index..index].upcase
-          if found = Node.get_class_from_kpath(try_kpath)
-            if found.kind_of?(VirtualClass) && found[:id] == self[:id]
+          if found = VirtualClass.find_by_kpath(try_kpath)
+            if found.id && found.id == self[:id]
               kpath = try_kpath
               break
             end
@@ -169,7 +515,6 @@ class VirtualClass < Role
       unless self[:real_class]
         errors.add('superclass', 'invalid')
       end
-
     end
 
     def get_real_class(klass)