zena 0.16.9 → 1.0.0.beta1

data/app/models/cache.rb

@@ -22,8 +22,8 @@ class Cache < ActiveRecord::Base
     def sweep(hash)
       if kpath  = hash[:kpath]
         klasses = []
-        kpath.split(//).each_index { |i| klasses << kpath[0..i].inspect }
-        kpath_selector = " AND kpath IN (#{klasses.join(',')})"
+        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

data/app/models/cached_page.rb

@@ -109,9 +109,9 @@ class CachedPage < ActiveRecord::Base
     def cached_page_after_save
       # create cache file
       filepath = "#{SITES_ROOT}#{path}"
-      FileUtils.mkpath(File.dirname(filepath))
+      FileUtils.mkpath(File.dirname(filepath))           # if symlink points to a dead file, exist? returns false...
+      FileUtils.rm(filepath) if File.exist?(filepath) || File.symlink?(filepath)
       if content_path
-        FileUtils.rm(filepath) if File.exist?(filepath)
         FileUtils.symlink_or_copy(content_path, filepath)
       else
         File.open(filepath, "wb+") { |f| f.write(content_data) }
@@ -120,7 +120,7 @@ class CachedPage < ActiveRecord::Base
       # create join values from context for automatic expire
       if (ids = @expire_with_ids || visitor.visited_node_ids) != []
         values = ids.compact.uniq.map {|id| [self[:id], id]}
-        Zena::Db.insert_many('cached_pages_nodes', ['cached_page_id', 'node_id'], values)
+        Zena::Db.insert_many('cached_pages_nodes', %w{cached_page_id node_id}, values)
       end
     end
 
@@ -128,7 +128,8 @@ class CachedPage < ActiveRecord::Base
     def cached_page_on_destroy
       filepath = "#{SITES_ROOT}#{path.gsub('..','')}" # just in case...
       CachedPage.logger.info "remove #{filepath}"
-      FileUtils.rm(filepath) if File.exist?(filepath)
+      # if symlink points to a dead file, exist? returns false...
+      FileUtils.rm(filepath) if File.exist?(filepath) || File.symlink?(filepath)
       CachedPage.connection.execute "DELETE FROM cached_pages_nodes WHERE cached_page_id = '#{id}'"
     end
 end

data/app/models/column.rb

@@ -0,0 +1,90 @@
+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}
+
+  belongs_to :role
+  before_validation :set_defaults
+
+  validates_presence_of :role
+  validates_uniqueness_of :name, :scope => :site_id
+  validate :name_not_in_models
+
+  class << self
+    include Zena::Acts::Secure
+
+    def roles_for_form
+      secure(Role) { Role.all(:order => 'kpath ASC') }.map {|r| [r.name, r.id]}
+    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
+    @kpath ||= role.kpath
+  end
+
+  protected
+    def set_defaults
+      self[:site_id] = current_site.id
+    end
+
+    def name_not_in_models
+      Node.native_classes.each do |kpath, klass|
+        if column = klass.schema.columns[self.name]
+          # find column origin
+          errors.add(:name, _('has already been taken in %s') % column.role.name)
+          break
+        end
+      end
+    end
+end

data/app/models/comment.rb

@@ -6,7 +6,7 @@ belong to the user _anon_ (see #User) and must have the 'athor_name' field set.
 If anonymous is moderated (User#moderated?), all public comments are set to 'prop' and are not directly seen on the site.
 =end
 class Comment < ActiveRecord::Base
-  include RubyLess::SafeClass
+  include RubyLess
 
   safe_attribute    :title, :created_at, :updated_at, :status
   safe_method       :text => String, :author_name => {:class => String, :nil => true},
@@ -21,6 +21,8 @@ class Comment < ActiveRecord::Base
   before_validation :comment_before_validation
   after_save :sweep_cache
 
+  include Zena::Use::QueryComment::ModelMethods
+
   def author
     @author ||= secure(User) { User.find(self[:user_id]) }
   end

data/app/models/contact_content.rb

@@ -1,9 +1,9 @@
 =begin rdoc
-Used by Contact to store contact data. See the documentation on this class for more information.
+Used by BaseContact to store contact data. See the documentation on this class for more information.
 
 === Attributes
 
-Provides the following attributes to Contact :
+Provides the following attributes to BaseContact :
 
 first_name:: first name
 name::       name
@@ -16,7 +16,7 @@ email::      email address
 birthday::   birthday (date)
 =end
 class ContactContent < ActiveRecord::Base
-  include RubyLess::SafeClass
+  include RubyLess
   safe_method    :created_at => Time, :updated_at => Time, :fullname => String, :initials => String,
                  :address => String
   safe_attribute :name, :first_name, :city, :country, :telephone, :mobile, :email, :zip
@@ -26,8 +26,8 @@ class ContactContent < ActiveRecord::Base
   after_initialize   :set_contact_content_defaults
   before_validation  :content_before_validation
 
-  extend  Zena::Acts::Multiversion
-  act_as_content
+  #extend  Zena::Use::Multiversion
+  #act_as_content
 
   # Full contact name to show in views.
   def fullname(first_name = self.first_name, name = self.name)

data/app/models/contact_version.rb

@@ -1,11 +1,11 @@
 =begin rdoc
-This class stores version text for Contact. See Version for details.
+This class stores version text for BaseContact. See Version for details.
 
 === Content
 
 Uses ContactContent.
 =end
-class ContactVersion < Version
+class BaseContactVersion < Version
 
   def self.content_class
     ContactContent

data/app/models/data_entry.rb

@@ -13,13 +13,13 @@ A visitor needs write access in all nodes the data should link to. A visitor als
 A visitor can edit a data entry if he/she has write access to the reference node (node_a).
 =end
 class DataEntry < ActiveRecord::Base
-  include RubyLess::SafeClass
+  include RubyLess
   safe_attribute :created_at, :updated_at, :date, :text, :value_a, :value_b
   safe_context   :value => {:class => Number, :method => 'value_a'},
                  :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 => 'Contact', :user => 'User'
+                 :node_d => 'Node', :nodes => ['Node'], :author => 'BaseContact', :user => 'User'
 
   attr_protected :site_id
 
@@ -36,23 +36,24 @@ class DataEntry < ActiveRecord::Base
   end
 
   # modify attributes so ext sees 'zip' values but we store 'ids'
-  def self.transform_attributes(new_attributes)
+  def self.transform_attributes(new_attributes, base_node = nil, parse_dates = true)
     attributes = new_attributes.stringify_keys
 
     attributes.keys.each do |key|
       if key == 'date'
+        next unless parse_dates
         attributes[key] = attributes[key].to_utc(_('datetime'), visitor.tz)
       elsif key =~ /^(\w+)_id$/
         if key[0..4] == 'node_'
-          attributes[key] = Node.translate_pseudo_id(attributes[key]) || attributes[key]
+          attributes[key] = Node.translate_pseudo_id(attributes[key], :id, base_node) || attributes[key]
         else
-          attributes[key] = Node.translate_pseudo_id(attributes[key]) || attributes[key]
+          attributes[key] = Node.translate_pseudo_id(attributes[key], :id, base_node) || attributes[key]
         end
       elsif key == 'text'
         # translate zazen
         value = attributes[key]
         if value.kind_of?(String)
-          attributes[key] = ZazenParser.new(value,:helper=>self, :node=>self).render(:translate_ids=>:zip)
+          attributes[key] = ZazenParser.new(value,:helper=>self, :node=>base_node).render(:translate_ids=>:zip)
         end
       end
     end
@@ -96,8 +97,8 @@ class DataEntry < ActiveRecord::Base
   end
 
   # Update a data entry's attributes, transforming the attributes first from the visitor's context to internal context.
-  def update_attributes_with_transformation(new_attributes)
-    update_attributes(DataEntry.transform_attributes(new_attributes))
+  def update_attributes_with_transformation(new_attributes, parse_dates = true)
+    update_attributes(DataEntry.transform_attributes(new_attributes, ref_node, parse_dates))
   end
 
   def clone

data/app/models/discussion.rb

@@ -8,6 +8,10 @@ language and if the current visitor is a commentator (User.commentator?).
 =end
 class Discussion < ActiveRecord::Base
 
+  include RubyLess
+  safe_context :comments => ['Comment']
+  safe_method  :comments_count => Number
+
   attr_protected :site_id
   has_many :all_comments, :class_name=>'Comment', :foreign_key=>'discussion_id', :order=>'created_at ASC', :dependent=>:delete_all
   belongs_to :node

data/app/models/document.rb

@@ -27,13 +27,28 @@ The version class used by documents is the DocumentVersion.
 
 Content (file data) is managed by the DocumentContent. This class is responsible for storing the file and retrieving the data. It provides the following attributes to the Document :
 
-c_size::  file size
-c_ext::   file extension
-c_content_type:: file content-type
+ size::  file size
+ ext::   file extension
+ content_type:: file content-type
 =end
 # should be a sub-class of Node, not Page (#184). Write a migration, fix fixtures and test.
 class Document < Node
-  safe_method :filename => String
+
+  include Versions::Attachment
+  store_attachments_in :version,  :attachment_class => 'Attachment'
+
+  property do |p|
+    p.integer 'size'
+    p.string  'content_type'
+    p.string  'ext'
+  end
+
+  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
 
   class << self
 
@@ -47,32 +62,24 @@ class Document < Node
     def new(attrs = {})
 
       scope = self.scoped_methods[0] || {}
-      klass = self
+
       attrs = attrs.stringify_keys
-      file  = attrs['c_file'] || ((attrs['version_attributes'] || {})['content_attributes'] || {})['file']
-      if file && file.respond_to?(:content_type)
+      file  = attrs['file'] || ((attrs['version_attributes'] || {})['content_attributes'] || {})['file']
+      if attrs['content_type']
+        content_type = attrs['content_type']
+      elsif file && file.respond_to?(:content_type)
         content_type = file.content_type
-      elsif ct = attrs['c_content_type'] || ((attrs['version_attributes'] || {})['content_attributes'] || {})['content_type']
+      elsif ct = attrs['content_type']
         content_type = ct
-      elsif attrs['name'] =~ /^.*\.(\w+)$/ && types = Zena::EXT_TO_TYPE[$1.downcase]
+      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
 
-      if content_type
-        if Image.accept_content_type?(content_type)
-          klass = Image
-        elsif Template.accept_content_type?(content_type)
-          klass = Template
-        elsif TextDocument.accept_content_type?(content_type)
-          klass = TextDocument
-        end
-      elsif self == Document
-        # no content_type means no file. Only TextDocuments can be created without files
-        content_type = 'text/plain'
-        klass = TextDocument
-      end
+      klass = document_class_from_content_type(content_type)
 
-      attrs['c_content_type'] = content_type
+      attrs['content_type'] = content_type
 
       if klass != self
         klass.with_scope(scope) { klass.o_new(attrs) }
@@ -85,6 +92,50 @@ class Document < Node
     def change_to_classes_for_form
       classes_for_form(:class => 'Document', :without => 'Image')
     end
+
+    # Return document class and content_type from content_type
+    def document_class_from_content_type(content_type)
+      if content_type
+        if Image.accept_content_type?(content_type)
+          Image
+        elsif Template.accept_content_type?(content_type)
+          Template
+        elsif TextDocument.accept_content_type?(content_type)
+          TextDocument
+        else
+          self
+        end
+      elsif self == Document
+        # no content_type means no file. Only TextDocuments can be created without files
+        TextDocument
+      else
+        self
+      end
+    end
+
+    # Return true if the content_type can change independantly from the file
+    def accept_content_type_change?
+      false
+    end
+  end # class << self
+
+  # Create an attachment with a file in file system. Create a new version if file is updated.
+  def file=(new_file)
+    if new_file = super(new_file)
+      self.size = new_file.kind_of?(StringIO) ? new_file.size : new_file.stat.size
+      @new_file = new_file
+    end
+  end
+
+  # Return the file size.
+  def size(mode=nil)
+    if prop['size']
+      prop['size']
+    elsif !new_record? && File.exist?(self.filepath)
+      prop['size'] = File.size(self.filepath)
+      self.save
+      prop['size']
+    end
   end
 
   # Return true if the document is an image.
@@ -92,40 +143,117 @@ class Document < Node
     kind_of?(Image)
   end
 
-  # Return the document's public filename using the name and the file extension.
+  # Get the document's public filename using the name and the file extension.
   def filename
-    "#{name}.#{version.content.ext}"
+    version.attachment.filename
+  end
+
+  # Get the file path defined in attachment.
+  def filepath(format=nil)
+    version.attachment.filepath(format)
   end
 
+  # Get the node's rootpath with the file's extention.
   def rootpath
-    super + ".#{version.content.ext}"
+    super + ".#{prop['ext']}"
   end
 
-  private
+  protected
     def set_defaults
-      base = name
-      base = version.title if base.blank?
-      if base.blank? && file = version.content.file
-        base = file.original_filename
+      set_defaults_from_file
+
+      self.ext = get_extension if self.ext.blank? || @new_file
+
+      if title.to_s =~ /\A(.*)\.#{self.ext}$/i
+        self.title = $1
       end
 
-      if base
-        if base =~ /(.*)\.(\w+)$/
-          self.name = $1 if new_record?
-          self.version.content.ext ||= $2
+      if node_name.to_s =~ /\A(.*)\.#{self.ext}$/i
+        self.node_name = $1
+      end
+
+      super
+
+      set_attachment_filename
+      true
+    end
+
+    # Overwriten in TextDocument
+    def set_attachment_filename
+      if @new_file
+        version.attachment.filename = "#{title}.#{ext}"
+      end
+    end
+
+    # Make sure we have a file.
+    def valid_file
+      if new_record? && !@new_file
+        errors.add('file', "can't be blank")
+        false
+      else
+        true
+      end
+    end
+
+    # Make sure the new file
+    def valid_content_type
+      return true unless prop.content_type_changed?
+
+      if !@new_file && !self.class.accept_content_type_change?
+        errors.add('content_type', 'incompatible with this file')
+        return false
+      end
+
+      klass = Document.document_class_from_content_type(content_type)
+
+      if klass != self.class
+        if @new_file
+          errors.add('file', 'incompatible with this class')
         else
-          self.name = base if new_record?
+          errors.add('content_type', 'incompatible with this class')
         end
-        if version.title.to_s =~ /\A(.*)\.#{version.content.ext}$/i
-          version.title = $1
+      end
+    end
+
+    def clear_new_file
+      @new_file = nil
+      true
+    end
+
+    def set_defaults_from_file
+      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
       end
-      super
     end
 
-    # Make sure name is unique
-    def node_before_validation
-      get_unique_name_in_scope('ND%')
+    # 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%')
     end
+
+    def get_extension
+      extensions = Zena::TYPE_TO_EXT[prop['content_type']]
+      if extensions && content_type != 'application/octet-stream' # use 'bin' extension only if we do not have any other ext.
+        (prop['ext'] && extensions.include?(prop['ext'].downcase)) ? self.prop['ext'].downcase : extensions[0]
+      elsif @new_file
+        # unknown content_type or 'application/octet-stream', just keep the extension we have
+        if @new_file.original_filename =~ /\w\.(\w+)$/
+          $1.downcase
+        else
+          'bin'
+        end
+      else
+        nil
+      end
+    end
+
 end