zena 1.0.0.rc2 → 1.0.0.rc3

data/app/helpers/users_helper.rb

@@ -5,7 +5,7 @@ module UsersHelper
     begin
       @node = @user.node || visitor.prototype
       begin
-        res =render :file => template_url(:mode => '+user', :format => 'html')
+        res = render :file => template_url(:mode => '+user', :format => 'html')
       rescue ActiveRecord::RecordNotFound
         res = render :file => 'versions/custom_tab'
       end

data/app/models/column.rb

@@ -1,5 +1,4 @@
 class Column < ActiveRecord::Base
-  attr_accessor :import_result
   include RubyLess
   include Property::StoredColumn
   TYPES_FOR_FORM   = %w{string datetime integer float}
@@ -14,6 +13,7 @@ class Column < ActiveRecord::Base
   validates_presence_of :role
   validates_uniqueness_of :name, :scope => :site_id
   validate :name_not_in_models
+  validate :valid_ptype_and_index
 
   after_save :expire_vclass_cache
   after_destroy :expire_vclass_cache
@@ -48,55 +48,6 @@ class Column < ActiveRecord::Base
         FIELD_INDICES << idx
       end
     end
-
-    # Import a hash of virtual class definitions and try to build the virtual classes.
-    def import(data)
-      data.keys.map do |klass|
-        build_column(klass, data)
-      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 build_column(klass, data)
-      # TODO
-      # 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
-      #   else
-      #     virtual_class.errors.add(:base, 'conflict')
-      #     return data[klass]['result'] = virtual_class
-      #   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')
-      #       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.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
-      # end
-    end
-
-    def export
-      # TODO
-    end
   end
 
   def kpath
@@ -108,8 +59,16 @@ class Column < ActiveRecord::Base
     self.index.to_s.gsub(/\A\./,'')
   end
 
+  def export
+    {
+      'ptype' => ptype,
+      'index' => index,
+    }
+  end
+
   protected
     def set_defaults
+      self.index = nil if index.blank?
       self[:site_id] = current_site.id
     end
 
@@ -134,4 +93,14 @@ class Column < ActiveRecord::Base
     def expire_vclass_cache
       VirtualClass.expire_cache!
     end
+
+    def valid_ptype_and_index
+      if !TYPES_FOR_FORM.include?(self.ptype)
+        errors.add(:ptype, 'invalid')
+      end
+
+      if !index.blank? && !(INDICES_FOR_FORM + FIELD_INDICES.map {|i| ".#{i}"}).include?(index)
+        errors.add(:index, 'invalid')
+      end
+    end
 end

data/app/models/comment.rb

@@ -13,7 +13,8 @@ class Comment < ActiveRecord::Base
                     :discussion_id => Number,
                     :user_name => {:class => String, :nil => true},
                     :user => {:class => 'User', :nil => true},
-                    :author => Node.author_proc
+                    :author => Node.author_proc,
+                    :author_name => String
 
   safe_context      :replies => ['Comment'], :node => 'Node'
 

data/app/models/node.rb

@@ -113,6 +113,10 @@ class Node < ActiveRecord::Base
     end
   end
 
+  def klass_changed?
+    kpath_changed?
+  end
+
   def virtual_class=(vclass)
     @virtual_class = vclass
     self[:vclass_id] = vclass.id
@@ -174,9 +178,11 @@ class Node < ActiveRecord::Base
   belongs_to         :skin
   before_validation  :set_defaults
   before_validation  :node_before_validation
+  # We need to change class before validation so that prop_eval is triggered with
+  # the new class.
+  before_validation  :change_klass
   validate           :validate_node
   before_create      :node_before_create
-  before_save        :change_klass
   after_save         :spread_project_and_section
   after_create       :node_after_create
   attr_protected     :zip, :id, :section_id, :project_id, :publish_from, :created_at, :updated_at
@@ -220,7 +226,7 @@ class Node < ActiveRecord::Base
                      :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,
+  safe_method        :kpath => String, :user_zip => Number, :user_id => Number,
                      :parent_zip => Number, :project_zip => Number, :section_zip => Number,
                      :ref_lang => String,
                      :position => Number, :rgroup_id => Number,
@@ -229,7 +235,7 @@ class Node < ActiveRecord::Base
                      :m_text => String, :m_title => String, :m_author => String,
                      :id => {:class => Number, :method => 'zip'},
                      :skin => 'Skin', :ref_lang => String,
-                     :visitor => 'User', [:ancestor?, Node] => Boolean,
+                     :visitor => 'User', [:is_ancestor?, Node] => Boolean,
                      :comments_count => Number,
                      :v => {:class => 'Version', :method => 'version'},
                      :version => 'Version', :v_status => Number, :v_lang => String,
@@ -257,7 +263,7 @@ class Node < ActiveRecord::Base
   # compute vhash (must come before Fulltext)
   include Zena::Use::VersionHash::ModelMethods
 
-  # computed properties (vclass prop_eval)
+  # computed properties (vclass prop_eval, must come after MLIndex)
   include Zena::Use::PropEval::ModelMethods
 
   # fulltext indices (must come after PropEval)
@@ -424,8 +430,8 @@ class Node < ActiveRecord::Base
     def get_class(rel, opts={})
       # mushroom_types ==> MushroomType
       class_name = rel =~ /\A[a-z]/ ? rel.singularize.camelize : rel
-      vclass = VirtualClass.find_by_name(class_name)
-      if opts[:create] && vclass.id
+      vclass = VirtualClass[class_name]
+      if vclass && 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
@@ -461,9 +467,6 @@ class Node < ActiveRecord::Base
       if str =~ /\A\d+\Z/
         # zip
         find_by_zip(str)
-      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]
         if path[0..0] == '/'
           path = path[1..-1].split('/').map {|p| String.from_filename(p) }
@@ -495,6 +498,9 @@ class Node < ActiveRecord::Base
           # FIXME: path pseudo is needed for links... and it should be done here (egg and hen problem)
           nil
         end
+      elsif str =~ /\A:?([^\+]+)(\+*)\Z/
+        offset = $2.to_s.size
+        Node.search_records($1.gsub('-',' '), :offset => offset, :limit => 1).first
       end
     end
 
@@ -601,6 +607,7 @@ class Node < ActiveRecord::Base
       parent_id = opts[:parent_id] || opts[:parent][:id]
       folder    = opts[:folder]
       defaults  = (opts[:defaults] || {}).stringify_keys
+      # Initial object class
       klass     = opts[:class] || opts[:klass] || "Page"
       res       = {}
 
@@ -652,6 +659,15 @@ class Node < ActiveRecord::Base
           attrs['v_lang'] = lang || attrs['v_lang'] || visitor.lang
           attrs['ext']  = $3
           document_path = path
+        else
+          # Document without extension
+          type      = :document
+          title     = filename
+          attrs     = defaults.dup
+          lang      = nil
+          attrs['v_lang'] = lang || attrs['v_lang'] || visitor.lang
+          attrs['ext']  = 'bin'
+          document_path = path
         end
 
         index += 1
@@ -839,6 +855,9 @@ 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{link_id}.include?(key)
+          # Link id, not translated
+          res[key] = value
         elsif %w{id create_at updated_at}.include?(key)
           # ignore (can be present in xml)
         elsif %w{log_at event_at v_publish_from}.include?(key) || (is_link && %w{date}.include?(key))
@@ -890,6 +909,7 @@ class Node < ActiveRecord::Base
         RubyLess::SafeClass.safe_method_type_for(self, signature)
       else
         method = signature.first
+
         if type = super
           type
         elsif method == 'cached_role_ids'
@@ -898,13 +918,6 @@ class Node < ActiveRecord::Base
         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])}
-        elsif receiver && query = receiver.opts[:query]
-          # Resolve by using information in the SELECT part of the query that found this node
-          if query.select_keys.include?(method)
-            {:class => String, :method => "attributes[#{method.inspect}]", :nil => true}
-          else
-            nil
-          end
         else
           nil
         end
@@ -978,9 +991,7 @@ class Node < ActiveRecord::Base
 
   # include virtual classes to check inheritance chain
   def vkind_of?(klass)
-    if self.class.ancestors.map{|k| k.to_s}.include?(klass)
-      true
-    elsif virt = VirtualClass.find(:first, :conditions=>["site_id = ? AND name = ?",current_site[:id], klass])
+    if virt = VirtualClass[klass.to_s]
       kpath_match?(virt.kpath)
     end
   end
@@ -1606,6 +1617,7 @@ class Node < ActiveRecord::Base
       errors.add(:base, 'You do not have the rights to post comments.') if @add_comment && !can_comment?
 
       if @new_klass
+        # If you change this, update 'change_klass' (triggered before_validation)
         if !can_drive? || !self[:parent_id]
           errors.add('klass', 'You do not have the rights to change class.')
         else
@@ -1726,17 +1738,28 @@ class Node < ActiveRecord::Base
     end
 
     def change_klass
+      if @new_klass
+        if !can_drive? || !self[:parent_id]
+          return
+        elsif !self.class.allowed_change_to_classes.include?(@new_klass)
+          return
+        end
+      end
+
       if @new_klass && !new_record?
         old_kpath = self.kpath
-# FIXME ! (new virtual_class as schema...)
+        # Reset 'schema' and 'virtual_class'
+        @virtual_class = nil
+
         klass = Node.get_class(@new_klass)
         if klass.kind_of?(VirtualClass)
-          self[:vclass_id] = klass.kind_of?(VirtualClass) ? klass[:id] : nil
+          self[:vclass_id] = klass[:id]
           self[:type]      = klass.real_class.to_s
         else
-          self[:vclass_id] = klass.kind_of?(VirtualClass) ? klass[:id] : nil
+          self[:vclass_id] = nil
           self[:type]      = klass.to_s
         end
+
         self[:kpath] = klass.kpath
 
         if old_kpath[/^NPS/] && !self[:kpath][/^NPS/]

data/app/models/relation.rb

@@ -1,4 +1,6 @@
 class Relation < ActiveRecord::Base
+  EXPORT_FIELDS   = %w{target_kpath target_icon target_unique source_role source_icon source_unique rel_group}
+
   before_validation :singularize_roles
   validate        :valid_relation
   attr_accessor   :side, :link_errors, :start, :link
@@ -16,6 +18,17 @@ class Relation < ActiveRecord::Base
     target_unique ? self[:target_role] : self[:target_role].pluralize
   end
 
+  def export
+    res = Zafu::OrderedHash.new
+    EXPORT_FIELDS.each do |key|
+      value = self[key]
+      if !value.blank?
+        res[key] = value
+      end
+    end
+    res
+  end
+
   private
     def singularize_roles
       self.source_role = self[:source_role].singularize unless self[:source_role].blank?

data/app/models/relation_proxy.rb

@@ -268,6 +268,7 @@ class RelationProxy < Relation
         elsif link_id = @start.link_id
           @other_link = Link.find(link_id)
           @attributes_to_update[:id] = @other_link[other_side]
+          @attributes_to_update[:link_id] = link_id
         elsif unique?
           if other_id
             @attributes_to_update[:id] = other_id
@@ -309,7 +310,7 @@ class RelationProxy < Relation
         # TODO: this could be optimzed (avoid loading all links...)
         other_links.each do |link|
           obj_id = link[other_side]
-          if add_link_ids.include?(obj_id) && (@attributes_to_update[:date].nil? || @attributes_to_update[:date] == link[:date])
+          if add_link_ids.include?(obj_id) && (@attributes_to_update[:date].nil? || @attributes_to_update[:link_id] || @attributes_to_update[:date] == link[:date])
             # ignore existing link
             add_link_ids.delete(obj_id)
           else
@@ -337,7 +338,7 @@ class RelationProxy < Relation
           # delete
           @del_links = other_links.select {|l| @attributes_to_update[:date] == l[:date]}
         else
-          links = other_links.select {|l| l[other_side] == @attributes_to_update[:id] && (@attributes_to_update[:date].nil? || @attributes_to_update[:date] == l[:date])}
+          links = other_links.select {|l| l[other_side] == @attributes_to_update[:id] && (@attributes_to_update[:date].nil? || @attributes_to_update[:link_id] || @attributes_to_update[:date] == l[:date])}
           if links != []
             # update
             if (@attributes_to_update.keys & LINK_ATTRIBUTES) != []

data/app/models/role.rb

@@ -13,7 +13,7 @@ class Role < ActiveRecord::Base
   has_and_belongs_to_many :nodes
 
   before_validation :set_defaults
-  validate :check_can_save
+  validate :validate_role
   attr_accessible :name, :superclass, :icon
 
   after_save :expire_vclass_cache
@@ -28,6 +28,144 @@ class Role < ActiveRecord::Base
   # We use property to store index information, default values and such
   include Property
 
+  property do |p|
+    p.string 'icon'
+  end
+  safe_property :icon
+
+  class << self
+    def export
+      {'Node' => VirtualClass['Node'].export}
+    end
+
+    def import(definitions, delete = false)
+      res = []
+      post_import = []
+      # Create everything in a transaction
+      transaction do
+        definitions.each do |name, definition|
+          klass = VirtualClass[name]
+          if !klass || !klass.real_class?
+            # Error, missing superclass
+            raise Exception.new("Importation needs to start with a real class: '#{name}' is not a real class.")
+          else
+            # start importing
+            res += import_all(klass, definition, post_import)
+          end
+        end
+
+        post_import.each do |l|
+          l.call
+        end
+      end
+      res
+    end
+
+    private
+      def import_all(superclass, definitions, post_import)
+        res = []
+        definitions.each do |name, sub|
+          next unless name =~ /\A[A-Z]/
+
+          case sub['type']
+          when 'Class'
+            klass = VirtualClass[name]
+            if klass && klass.real_class?
+              res += import_all(klass, sub, post_import)
+            else
+              raise Exception.new("Unknown real class '#{name}'.")
+            end
+          when 'Role'
+            res << import_role(superclass, name, sub)
+          when 'VirtualClass'
+            # VirtualClass
+            res += import_vclass(superclass, name, sub, post_import)
+          when nil
+            klass = VirtualClass[name]
+            if klass && klass.real_class?
+              res += import_all(klass, sub, post_import)
+            else
+              res += import_vclass(superclass, name, sub, post_import)
+            end
+          else
+            # Invalid type
+            raise Exception.new("Cannot create '#{name}': invalid type '#{sub['type']}'.")
+          end
+        end
+        res
+      end
+
+      def import_role(superclass, name, definition)
+        role = ::Role.find_by_name_and_site_id(name, current_site.id)
+        if role && role.class != ::Role
+          # Change from vclass to role ?
+          # Reject
+          raise Exception.new("Cannot convert VirtualClass '#{name}' to Role.")
+        elsif !role
+          role = ::Role.new(:name => name, :superclass => superclass)
+          role.save!
+        end
+
+        # 1. create or update attributes
+        # noop
+
+        # 2. create or update columns (never delete)
+        if !role.new_record? && columns = definition['columns']
+          role.import_columns(columns)
+        end
+        role
+      end
+
+      def import_vclass(superclass, name, definition, post_import)
+        res = []
+        vclass = ::Role.find_by_name_and_site_id(name, current_site.id)
+        if vclass && vclass.class != VirtualClass
+          # Change from role to vclass ?
+          # Reject
+          raise Exception.new("Cannot convert Role '#{name}' to VirtualClass.")
+        elsif !vclass
+          vclass = VirtualClass.new(:name => name, :superclass => superclass)
+        end
+
+        # 1. create or update attributes
+        VirtualClass.export_attributes.each do |key|
+          if value = definition[key]
+            vclass.send(:"#{key}=", value)
+          else
+            # We do not clear attributes (import is ADD/UPDATE only).
+          end
+        end
+        vclass.save!
+        res << vclass
+
+        # 2. create or update columns (never delete)
+        if columns = definition['columns']
+          vclass.import_columns(columns)
+        end
+
+        # 3. create relations when all is done
+        if relations = definition['relations']
+          post_import << lambda do
+            vclass.import_relations(relations)
+          end
+        end
+
+        # 4. create or update sub-classes
+        res += import_all(vclass, definition, post_import)
+        res
+      end
+  end # class << self
+
+  def real_class?
+    false
+  end
+
+  def icon=(txt)
+    # FIXME: remove gsub when we stop using ImageBuilder on
+    # icon images. SECURITY
+    super(txt.gsub('..', '.'))
+  end
+
   def superclass
     if new_record?
       Node
@@ -37,8 +175,8 @@ class Role < ActiveRecord::Base
   end
 
   def superclass=(klass)
-    if k = Node.get_class(klass)
-      self.kpath = k.kpath
+    if klass.kind_of?(VirtualClass) || klass = VirtualClass[klass]
+      @superclass = klass
     else
       errors.add('superclass', 'invalid')
     end
@@ -49,17 +187,88 @@ class Role < ActiveRecord::Base
     @safe_column ||= defined_columns.values.sort {|a,b| a.name <=> b.name}
   end
 
+  def export
+    res = Zafu::OrderedHash.new
+    res['type'] = real_class? ? 'Class' : type
+    if !defined_columns.empty?
+      res['columns'] = export_columns
+    end
+    res
+  end
+
+  def import_columns(columns)
+    transaction do
+      columns.each do |name, definition|
+        column = secure(::Column) { ::Column.find_by_name(name) }
+        if !column
+          # create
+          column = ::Column.new(:name => name)
+        elsif column.role_id != self.id
+          # error (do not move a column)
+          raise Exception.new("Cannot set property '#{name}' in '#{self.name}': already defined in '#{column.role.name}'.")
+        end
+        column.role_id = self.id
+        column.ptype   = definition['ptype']
+        column.index   = definition['index']
+        column.save!
+      end
+    end
+  end
+
+  def import_relations(relations)
+    relations.each do |name, definition|
+      relation = secure(::Relation) { ::Relation.first(
+        :conditions => ['target_role = ? AND source_kpath = ? AND site_id = ?',
+          name, self.kpath, self.site_id
+        ]
+      )}
+      if !relation
+        # create
+        relation = ::Relation.new(:target_role => name, :source_kpath => self.kpath)
+      end
+      Relation::EXPORT_FIELDS.each do |key|
+        value = definition[key]
+        if !value.blank?
+          relation[key] = value
+        end
+      end
+      relation.save!
+    end
+  end
+
   private
     def set_defaults
       self[:type] = self.class.to_s
       self.site_id = visitor.site.id
     end
 
-    def check_can_save
+    def validate_role
       errors.add('base', 'You do not have the rights to change roles.') unless visitor.is_admin?
+      if new_record?
+        errors.add('superclass', 'invalid') unless @superclass.kind_of?(VirtualClass) && @superclass.kpath
+      end
+
+      if @superclass && self.class == ::Role
+        self.kpath = @superclass.kpath
+      end
     end
 
     def expire_vclass_cache
       VirtualClass.expire_cache!
     end
+
+    def export_columns
+      res = Zafu::OrderedHash.new
+
+      defined_columns.keys.sort.each do |name|
+        column = defined_columns[name]
+        col = Zafu::OrderedHash.new
+        col['ptype'] = column.ptype.to_s
+        if column.index then
+          col['index'] = column.index
+        end
+        res[name] = col
+      end
+      res
+    end
 end