zena 0.16.9 → 1.0.0.beta1

data/db/migrate/20100519091711_add_index_definition_to_columns.rb

@@ -0,0 +1,9 @@
+class AddIndexDefinitionToColumns < ActiveRecord::Migration
+  def self.up
+    add_column :columns, :index, :integer
+  end
+
+  def self.down
+    remove_column :columns, :index
+  end
+end

data/db/migrate/20100519091940_create_idx_nodes_string.rb

@@ -0,0 +1,14 @@
+class CreateIdxNodesString < ActiveRecord::Migration
+  def self.up
+    # index strings for nodes
+    create_table :idx_nodes_strings, :options => Zena::Db.table_options do |t|
+      t.integer 'node_id', :null => false
+      t.string  'key'
+      t.string  'value'
+    end
+  end
+
+  def self.down
+    drop_table 'idx_nodes_strings'
+  end
+end

data/db/migrate/20100519232432_create_idx_nodes_ml_string.rb

@@ -0,0 +1,15 @@
+class CreateIdxNodesMlString < ActiveRecord::Migration
+  def self.up
+    # index strings for nodes
+    create_table :idx_nodes_ml_strings, :options => Zena::Db.table_options do |t|
+      t.integer 'node_id', :null => false
+      t.string  'key'
+      t.string  'lang', :limit => 10
+      t.string  'value'
+    end
+  end
+
+  def self.down
+    drop_table 'idx_nodes_ml_strings'
+  end
+end

data/db/migrate/20100525113858_add_porperties_to_users.rb

@@ -0,0 +1,9 @@
+class AddPorpertiesToUsers < ActiveRecord::Migration
+  def self.up
+    add_column :users, :properties, :text
+  end
+
+  def self.down
+    remove_column :users, :properties
+  end
+end

data/db/migrate/20100526090140_renamed_contact_model_to_base_contact.rb

@@ -0,0 +1,13 @@
+class RenamedContactModelToBaseContact < ActiveRecord::Migration
+  def self.up
+    unless $migrating_new_site
+      execute "UPDATE nodes SET type = 'BaseContact' WHERE type = 'Contact'"
+      execute "UPDATE roles SET real_class = 'BaseContact' WHERE real_class = 'Contact'"
+    end
+  end
+
+  def self.down
+    execute "UPDATE nodes SET type = 'Contact' WHERE type = 'BaseContact'"
+    execute "UPDATE roles SET real_class = 'Contact' WHERE real_class = 'BaseContact'"
+  end
+end

data/db/migrate/20100527130937_change_column_index_to_string.rb

@@ -0,0 +1,9 @@
+class ChangeColumnIndexToString < ActiveRecord::Migration
+  def self.up
+    change_column :columns, :index, :string, :limit => 30
+  end
+
+  def self.down
+    change_column :columns, :index, :boolean
+  end
+end

data/db/migrate/20100531135128_add_fulltext_builder_fields.rb

@@ -0,0 +1,28 @@
+class AddFulltextBuilderFields < ActiveRecord::Migration
+  def self.up
+    rename_column 'versions', :title, :idx_text_high
+    rename_column 'versions', :summary, :idx_text_medium
+    rename_column 'versions', :text, :idx_text_low
+
+    add_column 'roles', :idx_text_low, :text
+    add_column 'roles', :idx_text_medium, :text
+    add_column 'roles', :idx_text_high, :text
+
+    #add_index 'versions', Zena::Use::Fulltext::FULLTEXT_FIELDS, :index_type => "FULLTEXT"
+    #remove_index 'versions', %w{title text summary}
+  end
+
+  def self.down
+    #remove_index 'versions', Zena::Use::Fulltext::FULLTEXT_FIELDS
+
+    rename_column 'versions', :idx_text_high, :title
+    rename_column 'versions', :idx_text_medium, :summary
+    rename_column 'versions', :idx_text_low, :text
+
+    remove_column 'roles', :idx_text_low
+    remove_column 'roles', :idx_text_medium
+    remove_column 'roles', :idx_text_high
+
+    #add_index 'versions', %w{title text summary}, :index_type => "FULLTEXT"
+  end
+end

data/doc/zafu_changes.yml

@@ -4,8 +4,8 @@ CHANGESET1:
 
   CHANGES:
     if_or:
-      old: "<r:if can='write' or_test='[d_foo]'>hello</r:if>"
-      new: "<r:if can='write' or_test='d_foo'>hello</r:if>"
+      old: "<r:if eval='can_write?' or_test='[d_foo]'>hello</r:if>"
+      new: "<r:if eval='can_write?' or_test='d_foo'>hello</r:if>"
 
 SHOULD_CHANGE:
   basic:

data/lib/bricks/loader.rb

@@ -26,19 +26,41 @@ module Bricks
       bricks.map {|f| Dir["#{f}/models"] }.flatten
     end
 
-    def libs_paths
-      bricks.map {|f| Dir["#{f}/lib"] }.flatten
+    def init_paths
+      bricks.map {|f| Dir["#{f}/zena/init.rb"] }.flatten
     end
 
-    def foreach_brick(&block)
+    def migrations_for(brick)
+      File.join(Zena::ROOT, 'bricks', brick, 'zena', 'migrate')
+    end
+
+    def fixtures_path_for(brick)
+      File.join(Zena::ROOT, 'bricks', brick, 'zena', 'test', 'sites')
+    end
+
+    def zafu_tests
+      ["#{Zena::ROOT}/bricks/*/zena/test/zafu", "#{RAILS_ROOT}/bricks/*/zena/test/zafu"]
+    end
+
+    def test_files
+      [
+        'bricks/*/zena/test/unit/*_test.rb',
+        'bricks/*/zena/test/functional/*_test.rb',
+        'bricks/*/zena/test/integration/*_test.rb',
+      ]
+     end
+
+    # FIXME: remove
+    def old_foreach_brick(&block)
       bricks.each do |path|
         block.call(path)
       end
     end
 
+    # FIXME: remove
     def apply_patches(file_name = nil)
       file_name ||= caller[0].split('/').last.split(':').first
-      foreach_brick do |brick_path|
+      old_foreach_brick do |brick_path|
         patch_file = File.join(brick_path, 'patch', file_name)
         if File.exist?(patch_file)
           load patch_file
@@ -46,32 +68,15 @@ module Bricks
       end
     end
 
-    def load_bricks
-      # load all libraries in bricks
-      libs_paths.each do |lib_path|
-        Dir.foreach(lib_path) do |f|
-          next unless f =~ /\A.+\.rb\Z/
-          require File.join(lib_path, f)
-        end
-      end
-
-      # FIXME: do we really need to load these now, load_path isn't enough ?
-      models_paths.each do |models_path|
-        Dir.foreach(models_path) do |f|
-          next unless f =~ /\A.+\.rb\Z/
-          require File.join(models_path, f)
-        end
-      end
-    end
-
-    def load_misc(filename)
-      bricks.map {|f| Dir["#{f}/misc/#{filename}.rb"] }.flatten.each do |file|
+    def load_filename(filename)
+      bricks.map {|f| Dir["#{f}/zena/#{filename}.rb"] }.flatten.each do |file|
         require file
       end
     end
 
+    # FIXME: remove
     def load_zafu(mod)
-      foreach_brick do |brick_path|
+      old_foreach_brick do |brick_path|
         brick_name = File.basename(brick_path)
         zafu_path  = File.join(brick_path, 'zafu')
         next unless File.exist?(zafu_path)
@@ -79,7 +84,24 @@ module Bricks
           next if rules_name =~ /\A\./
           load File.join(zafu_path, rules_name)
         end
-        mod.send(:include, eval("Bricks::#{brick_name.capitalize}::Zafu"))
+        mod.send(:include, eval("Bricks::#{brick_name.capitalize}::ZafuMethods"))
+      end
+    end
+
+    def foreach_brick
+      bricks.each do |path|
+        yield File.basename(path)
+      end
+    end
+
+    def load_bricks
+      bricks.each do |path|
+        $LOAD_PATH << File.join(path, 'lib')
+      end
+
+      # load 'init'
+      init_paths.each do |init_path|
+        require init_path
       end
     end
   end

data/lib/exif_data.rb

@@ -2,7 +2,27 @@ require 'json'
 require 'rational'
 
 class ExifData < Hash
-  include RubyLess::SafeClass
+  include RubyLess
+
+  # Deserialization used by Property
+  def self.json_create(serialized)
+    if data = serialized['data']
+      ExifData.new(data)
+    else
+      nil
+    end
+  end
+
+  # Serialization used by Property
+  def to_json(*args)
+    { 'json_class' => 'ExifData', 'data' => Hash[self.to_a] }.to_json(*args)
+  end
+
+  # We need this extra rule to avoid ActiveSupport json encoder thinking Hash[self.to_a] is the
+  # same object as this. This is a temporary fix until ActiveSupport use object_id for :seen.
+  def ==(other)
+    other.class == self.class && super
+  end
 
   # You can create new ExifData objects with either a json representation (String), a
   # hash of key => value or an array of key,value pairs.

data/lib/gettext_strings.rb

@@ -14,6 +14,9 @@ module Zena
     N_('document_tab')      # edit form tab
     N_('contact_tab')       # edit form tab
 
+    N_('attach_img')  # version edit.rhtml
+    N_('dettach_img') # version edit.rhtml
+
     N_('file_tab')              # document form tab name
     N_('template_tab')          # document form tab name
     N_('text_doc_tab')          # document form tab name
@@ -78,6 +81,8 @@ module Zena
     N_('btn_unpublish')    # version action
     N_('btn_destroy')
     N_('btn_propose')
+    N_('btn_edit')
+    N_('btn_drive')
     N_('btn_refuse')
     N_('btn_destroy_version')
     N_('btn_redit')
@@ -153,7 +158,9 @@ module Zena
     N_('redaction saved')
 
     # failed to find
-    N_('rebuild') # application
+    N_('rebuild')     # zafu_templates.rb
+    N_('rebuild_btn')     # zafu_templates.rb
+    N_('turn_dev_off_btn') # zafu_templates.rb
     # contact
     N_('first_name')
     N_('name')

data/lib/tasks/zena.rake

@@ -8,7 +8,7 @@ RAILS_ENV = 'test' if ARGV.join(' ') =~ /zena:test/
 require File.join(File.dirname(__FILE__), '..', 'zena', 'info') # to have Zena::ROOT
 require File.join(File.dirname(__FILE__), '..', 'bricks') # to have Bricks
 
-Bricks.load_misc('tasks')
+Bricks.load_filename('tasks')
 
 def symlink_assets(from, to)
   from = File.expand_path(from)
@@ -254,7 +254,7 @@ namespace :zena do
         # migrate 'db/migrate'
         Zena::Migrator.migrate("#{Zena::ROOT}/db/migrate", ENV["BRICK"], ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
       else
-        mig_path = "#{Zena::ROOT}/bricks/#{ENV['BRICK']}/migrate"
+        mig_path = Bricks.migrations_for(ENV['BRICK'])
         if File.exist?(mig_path) && File.directory?(mig_path)
           Zena::Migrator.migrate(mig_path, ENV["BRICK"], ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
         else
@@ -266,9 +266,8 @@ namespace :zena do
       paths  = {'zena' => "#{RAILS_ROOT}/db/migrate"}
       bricks = ['zena']
 
-      Bricks.foreach_brick do |brick_path|
-        brick_name = brick_path.split('/').last
-        migration_path = File.join(brick_path, 'migrate')
+      Bricks.foreach_brick do |brick_name|
+        migration_path = Bricks.migrations_for(brick_name)
         next unless File.exist?(migration_path) && File.directory?(migration_path)
         paths[brick_name] = migration_path
         bricks << brick_name
@@ -282,35 +281,73 @@ namespace :zena do
     Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
   end
 
+  desc 'Reset development environment (drop database, migrate, rebuild and load fixtures, clone to test)'
+  task :reset => :environment do
+    if RAILS_ENV == 'production'
+      puts "You cannot reset database in production !"
+    else
+      %w{db:drop db:create zena:migrate zena:build_fixtures db:test:clone}.each do |task|
+        puts "******************************* #{task}"
+        Rake::Task[task].invoke
+      end
+    end
+  end
+
   desc 'Rebuild foxy fixtures for all sites'
   task :build_fixtures => :environment do
+    Dir["#{RAILS_ROOT}/test/fixtures/*.yml"].each do |f|
+      FileUtils.rm f
+    end
+
     tables = Node.connection.tables
-             # 0.    # 1.                # need vc   # vers.  # nodes  # need vc.   # need nodes
-    ordered_tables = ['virtual_classes', 'versions', 'nodes', 'zips', 'relations', 'links']
+    ordered_tables = %w{roles versions nodes attachments zips relations links}
+
     tables -= ordered_tables
     tables += ordered_tables
-    virtual_classes, versions, nodes = nil, nil, nil
+    roles, versions, nodes = nil, nil, nil
     tables.each do |table|
       case table
-      when 'virtual_classes'
-        virtual_classes = Zena::FoxyParser.new(table)
-        virtual_classes.run
+      when 'roles'
+        roles = Zena::FoxyParser.new(table)
+        roles.run
       when 'versions'
         versions = Zena::FoxyParser.new(table)
         versions.run
       when 'nodes'
-        nodes = Zena::FoxyParser.new(table, :versions => versions, :virtual_classes => virtual_classes)
+        nodes = Zena::FoxyParser.new(table, :versions => versions, :roles => roles)
         nodes.run
       when 'zips'
         Zena::FoxyParser.new(table, :nodes => nodes).run
       when 'relations'
-        Zena::FoxyParser.new(table, :virtual_classes => virtual_classes).run
+        Zena::FoxyParser.new(table, :roles => roles).run
       when 'links'
         Zena::FoxyParser.new(table, :nodes => nodes).run
       else
         Zena::FoxyParser.new(table).run
       end
     end
+
+    %w{db:fixtures:load zena:rebuild_index}.each do |task|
+      puts "******************************* #{task}"
+      Rake::Task[task].invoke
+    end
+
+    index_tables = Node.connection.tables.select {|t| t =~ /^idx_/ }
+    Zena::FoxyParser.dump_fixtures(index_tables)
+  end
+
+  desc 'Rebuild index for all sites (without SiteWorker)'
+  task :rebuild_index => :environment do
+    include Zena::Acts::Secure
+
+    Site.all.each do |site|
+      # We avoid SiteWorker because it's async.
+      Thread.current[:visitor] = User.find_by_login_and_site_id(nil, site.id)
+      nodes = Node.find(:all,
+        :conditions => ['site_id = ?', site.id]
+      )
+      site.rebuild_index(secure_result(nodes))
+    end
   end
 
   Rake::RDocTask.new do |rdoc|
@@ -334,12 +371,9 @@ namespace :zena do
     end
   end
 
-  # do not change the order in which these elements are loaded (adding 'lib/**/test/*_test.rb' fails)
-  tests = ['test/helpers/**/*_test.rb', 'test/unit/**/*_test.rb',
-           'lib/parser/test/*_test.rb', 'lib/query_builder/test/*_test.rb',
-           'test/functional/*_test.rb', #'test/integration/*_test.rb',
-           'bricks/**/test/unit/*_test.rb', 'bricks/**/test/functional/*_test.rb',
-           'bricks/**/test/integration/*_test.rb'].map {|p| "#{Zena::ROOT}/#{p}"}
+  tests = ['test/unit/**/*_test.rb', 'test/functional/*_test.rb', 'test/integration/*_test.rb'].map {|p| "#{Zena::ROOT}/#{p}"}
+
+  tests += Bricks.test_files
 
   Rake::TestTask.new(:test => ["zena:test:prepare", "zena:build_fixtures"]) do |t|
     t.libs << "test"
@@ -428,7 +462,8 @@ namespace :zena do
     # FIXME: how to run sub-task
     ENV['RAILS_ENV'] = RAILS_ENV || 'production'
     ENV['HOST']      ||= 'localhost'
-    ENV['LANG']      ||= 'en'
+    ENV['LANG']        = ENV['LANG'].to_s
+    ENV['LANG']        = 'en' if ENV['LANG'].empty?
     ENV['PASSWORD']  ||= 'admin'
 
     Rake::Task["db:create"].invoke

data/lib/version_off.rb

@@ -0,0 +1,323 @@
+=begin rdoc
+A version implements versioning and permits multiple publications (one for each language).
+
+=== Status
+
+A version's status changes over time. A version usually starts by being a 'redaction', these eventually a 'proposition', etc. The version's status changes by executing actions on the node (publish, remove, etc). Have a look at Acts::As::Multiversion for details. Zena::Status are :
+
+red (70):: version is being written (the redaction is only seen by its author)
+prop_with (65):: document proposed with the redaction. Will be automatically published/removed with the redaction.
+prop (60):: proposed for publication (seen only by the members of the publish group of the node)
+pub (50)::  version is published (can be seen by all readers)
+rep (20):: replaced by a newer version (can be an elligible version for rollback)
+rem (10):: removed (from a rollback)
+del (0):: this is like 'moved to trash'
+
+=== Version attributes
+
+title:: Node title.
+comment:: The comment is a little word saying what this particular version is about or a full text on all the modifications done or to be done or anything usefull that should be communicated inside the team.
+text:: The text is the full content of a version. The text usually contains zazen formatted text (textile with additions). See Zazen for details.
+
+=== Dynamic attributes
+
+Any attribute written using version.prop[:blah] = 'some text' is stored as a dynamic attribute. See DynAttributes for details.
+
+== Content
+If a we need to create a more sophisticated version class, all the required fields go in a 'content' class, like
+#DocumentContent stores document type and size for #DocumentVersion. See #Document for the details on the relation between Version and Content.
+=end
+class VersionOff < ActiveRecord::Base
+
+  # readable
+  include RubyLess
+  # writable
+  attr_accessible    :title, :text, :summary, :comment, :publish_from, :lang, :status, :content_attributes, :dyn_attributes
+  safe_context       :author => 'BaseContact', :user => 'User', :node => 'Node'
+
+  belongs_to            :user
+  before_validation     :version_before_validation
+  validates_presence_of :user, :site_id
+  validate              :valid_version
+  after_save            :save_content
+  after_save            :set_updated_at
+  after_destroy         :destroy_content
+  before_create         :set_number
+
+  include Zena::Use::DynAttributes::ModelMethods
+  extend  Zena::Acts::Multiversion
+
+  acts_as_version
+
+  class << self
+    # Some #Version sub-classes need to have more specific content than just 'text' and 'summary'.
+    # this content is stored in a delegate 'content' object found with the 'content_class' class method
+    def content_class
+      nil
+    end
+  end
+
+  def author
+    user.contact
+  end
+
+  # FIXME: This should not be needed ! Remove when find by id is cached.
+  def set_node(node)
+    @node ||= node
+  end
+
+  def user_zip
+    user_id
+  end
+
+  def zip
+    "#{node.zip}.#{number}"
+  end
+
+  # Return the content for the version. Can it's 'own' content or the same as the version this one was copied from.
+  def content
+    return nil unless content_class
+    return @content if @content
+    if self[:content_id]
+      @content = content_class.find_by_version_id(self[:content_id])
+      @content.preload_version(self) if @content
+    else
+      @content = content_class.find_by_version_id(self[:id])
+      @content.preload_version(self) if @content
+    end
+    unless @content
+      # create new content
+      @content = content_class.new
+      self[:content_id] = nil
+      @content.preload_version(self)
+      @redaction_content = @content
+    end
+    @content
+  end
+
+  # Return the version's own content or creates a new one so it can be edited.
+  def redaction_content
+    return @redaction_content if @redaction_content
+    return nil unless content_class
+    @content = content
+    if @content && @content[:version_id] == self[:id]
+      # own content, make sure no published version links to this content
+      if !new_record? && slave_version = Version.find(:first, :select=>'id', :conditions=>["content_id = ?",self[:id]])
+        # shared content, we need to build our own and alter others:
+        #
+        # 1. Current state
+        #   version[@id = A, @content_id = nil] ===> content[@version_id = A] <--- version[@content_id = A,   @id = B]
+        #
+        # 2. Changes to
+        #   version[@id = A, @content_id = B  ] ---> content[@version_id = B] <=== version[@content_id = nil, @id = B]
+        #
+        # Whatchout: we could have a race condition here...
+        old_master_id = self[:id]
+        new_master_id = slave_version[:id]
+        content_id    = @content[:id]
+        # version[@id = B, @content_id => nil]
+        Version.connection.execute "UPDATE #{Version.table_name} SET content_id = NULL WHERE id = #{new_master_id}"
+        # version[@id = A, @content_id => B]
+        Version.connection.execute "UPDATE #{Version.table_name} SET content_id = #{new_master_id} WHERE id = #{old_master_id}"
+        # content[@version_id => B]
+        Version.connection.execute "UPDATE #{@content.class.table_name} SET version_id = #{new_master_id} WHERE id = #{content_id}"
+
+        # content shared, make it our own
+        @old_content = @content # keep the old one in case we cannot save and need to rollback
+        @content = @old_content.clone
+        self[:content_id]     = nil
+        @content[:version_id] = nil # will be set on save
+        @content.preload_version(self)
+      end
+    elsif @content
+      # content shared, make it our own
+      @old_content = @content # keep the old one in case we cannot save and need to rollback
+      @content = @old_content.clone
+      self[:content_id]     = nil
+      @content[:version_id] = nil # will be set on save
+      @content.preload_version(self)
+    else
+      # create new content
+      @content = content_class.new
+      self[:content_id] = nil
+      @content.preload_version(self)
+    end
+    @redaction_content = @content
+  end
+
+  def content_class
+    self.class.content_class
+  end
+
+  def content_attributes=(h)
+    if content.would_edit?(h) && redaction_content
+      redaction_content.attributes = h
+    else
+      # ignore
+    end
+  end
+
+  # Return a new redaction from this version
+  def clone
+    ignore_attributes = self.attributes_to_ignore_on_clone
+    attrs = attributes.dup.reject {|k,v| ignore_attributes.include?(k.to_s) }
+
+    new_clone = self.class.new(attrs)
+    protected_attributes_on_clone.each do |k,v|
+      new_clone.send("#{k}=", v)
+    end
+    new_clone
+  end
+
+  # List of attribute keys to export in a zml file.
+  def export_keys
+    {
+      :zazen => {'title' => title, 'text' => text, 'summary' => summary}.merge(Hash[*dyn.map{|k,v| ["d_#{k}", v]}.flatten]),
+      :dates => {},
+    }
+  end
+
+  def attributes_to_ignore_on_clone
+    # /_ok$/ ?
+    %w{ user_id type created_at updated_at id }
+  end
+
+  def protected_attributes_on_clone
+    { 'content_id' => (content_class ? (content_id || id) : nil),
+      'user_id'    => visitor.id,
+      'node'       => self.node,
+      'number'     => self.number,
+      'dyn'        => self.dyn,
+      'status'     => Zena::Status[:red],
+      'lang'       => visitor.lang }
+  end
+
+  # Return true if the version can be updated by the current visitor without creating
+  # a new redaction.
+  def reusable?(lang, target_status)
+    self.lang    == lang                                        &&
+    user_id      == visitor.id                                  &&
+    [Zena::Status[:red], Zena::Status[:pub]].include?(status)   &&
+    target_status == status                                     &&
+    Time.now  < created_at + current_site[:redit_time].to_i
+  end
+
+  # Return true if we would need to create a new version or re-edit depending
+  # on the attributes
+  def would_edit?(new_attrs)
+    new_attrs.each do |k,v|
+      next if ['status', 'publish_from'].include?(k.to_s)
+      if k.to_s == 'content_attributes'
+        return true if content.would_edit?(v)
+      elsif k.to_s == 'dyn_attributes'
+        return true if dyn.would_edit?(v)
+      elsif type = self.class.safe_method_type([k])
+        return true if field_changed?(k, self.send(type[:method]), v)
+      end
+    end
+    false
+  end
+
+  def safe_content_read(signature)
+    if c = content
+      c.send(:safe_read, signature)
+    else
+      nil
+    end
+  end
+
+  # Return true if the version has been edited (not just status / publication date change)
+  # TODO: test
+  def edited?
+    new_record? || (changes.keys - ['status', 'publish_from'] != []) || (@redaction_content && @redaction_content.changed?)
+  end
+
+  def should_save?
+    new_record? || changed? || dyn.changed? || (@redaction_content && @redaction_content.changed?)
+  end
+
+  def attributes_with_defaults=(attrs)
+    self.attributes_without_defaults = attrs
+    %W{title summary text comment}.each do |txt_field|
+      self[txt_field] ||= ''
+    end
+  end
+  alias_method_chain :attributes=, :defaults
+
+  private
+    def set_number
+      last_record = node.id ? self.connection.select_one("select number from #{self.class.table_name} where node_id = '#{node[:id]}' ORDER BY number DESC LIMIT 1") : nil
+      self[:number] = (last_record || {})['number'].to_i + 1
+    end
+
+    def save_content
+      # TODO: Why don't we use @redaction_content ?
+      if @content && @content.changed?
+        @content[:version_id] ||= self[:id]
+        # validations checked with 'valid_content'
+        @content.save_without_validation
+      else
+        true
+      end
+    end
+
+    def set_updated_at
+      if @content_updated_but_not_saved
+        # not saved, set updated_at manually
+        Zena::Db.set_attribute(self, :updated_at, Time.now)
+      end
+      @content_updated_but_not_saved = nil
+      true
+    end
+
+    def destroy_content
+      content.destroy if content_class && content.can_destroy?
+    end
+
+    # Set version number and site_id before validation tests.
+    def version_before_validation
+      self[:site_id] = visitor.site.id
+      return unless node
+      self.title     = node.name if self.title.blank?
+      self.type    ||= self.class.to_s
+
+      self.lang      = visitor.lang if self.lang.blank?
+      self.status  ||= current_site.auto_publish? ? Zena::Status[:pub] : Zena::Status[:red]
+      self.publish_from ||= Time.now if self.status == Zena::Status[:pub]
+      self.user_id = visitor[:id] if new_record?
+
+      if @content
+        @content[:site_id] = self[:site_id]
+      end
+    end
+
+    # Make sure the version and it's related content are in a correct state.
+    def valid_version
+      errors.add('node', "can't be blank") unless node
+
+      # validate content
+      # TODO: we could use autosave here
+      @content_updated_but_not_saved = !changed? && @content && @content.changed?
+
+      if @content && @content.changed? && !@content.valid?
+        @content.errors.each_error do |attribute,message|
+          if attribute.to_s == 'base'
+            errors.add('content', message)
+          else
+            attribute = "content_#{attribute}"
+            errors.add(attribute, message) unless errors[attribute] # FIXME: rails 3: if errors[attribute].empty?
+          end
+        end
+
+        if @old_content
+          @content = @old_content # rollback initial content
+        else
+          # clean empty content
+          @content = content_class.new
+          @content.preload_version(self)
+          self[:content_id] = nil
+          @redaction_content = @content
+        end
+      end
+    end
+end