zena 0.15.2 → 0.16.0

data/app/models/node.rb

@@ -120,6 +120,8 @@ and the 'photos' url is now in the worldTour project's basepath:
 Setting 'custom_base' on a node should be done with caution as the node's zip is on longer in the url and when you move the node around, there is no way to find the new location from the old url. Custom_base should therefore only be used for nodes that are not going to move.
 =end
 class Node < ActiveRecord::Base
+  extend Zena::Use::Upload::UploadedFile
+  extend Zena::Use::Search::NodeClassMethods
 
   include RubyLess::SafeClass
   safe_attribute :created_at, :updated_at, :event_at, :log_at, :publish_from, :basepath, :inherit
@@ -142,13 +144,14 @@ class Node < ActiveRecord::Base
   has_and_belongs_to_many :cached_pages
   belongs_to         :virtual_class, :foreign_key => 'vclass_id'
   belongs_to         :site
-  before_validation  :node_before_validation  # run our 'before_validation' after 'secure'
+  before_validation  :set_defaults
+  before_validation  :node_before_validation
   validates_presence_of :name
   validate           :validate_node
   before_create      :node_before_create
   before_save        :change_klass
   after_save         :spread_project_and_section
-  after_save         :clear_children_fullpath
+  after_save         :rebuild_children_fullpath
   after_create       :node_after_create
   attr_protected     :site_id, :zip, :id, :section_id, :project_id, :publish_from
   attr_protected     :site_id
@@ -161,16 +164,15 @@ class Node < ActiveRecord::Base
   nested_attributes_alias %r{^c_(\w+)} => ['version', 'content']
   nested_attributes_alias %r{^d_(\w+)} => ['version', 'dyn']
 
-  zafu_context       :author => "Contact", :parent => "Node",
-                     :project => "Project", :section => "Section",
-                     :real_project => "Project", :real_section => "Section",
-                     :user => "User",
-                     :version => "Version", :comments => ["Comment"],
-                     :data   => {:node_class => ["DataEntry"], :data_root => 'node_a'},
-                     :data_a => {:node_class => ["DataEntry"], :data_root => 'node_a'},
-                     :data_b => {:node_class => ["DataEntry"], :data_root => 'node_b'},
-                     :data_c => {:node_class => ["DataEntry"], :data_root => 'node_c'},
-                     :data_d => {:node_class => ["DataEntry"], :data_root => 'node_d'}
+  safe_context       :author => 'Contact', :parent => 'Node',
+                     :project => 'Project', :section => 'Section',
+                     :real_project => 'Project', :real_section => 'Section',
+                     :user => 'User', :version => 'Version', :comments => ['Comment'],
+                     :data   => {:class => ['DataEntry'], :data_root => 'node_a'},
+                     :data_a => {:class => ['DataEntry'], :data_root => 'node_a'},
+                     :data_b => {:class => ['DataEntry'], :data_root => 'node_b'},
+                     :data_c => {:class => ['DataEntry'], :data_root => 'node_c'},
+                     :data_d => {:class => ['DataEntry'], :data_root => 'node_d'}
 
   extend  Zena::Acts::SecureNode
   extend  Zena::Acts::Multiversion
@@ -299,7 +301,7 @@ class Node < ActiveRecord::Base
         find_by_zip(str)
       elsif str =~ /\A:?([0-9a-zA-Z ]+)(\+*)\Z/
         offset = $2.to_s.size
-        find(:first, Node.match_query($1.gsub('-',' '), :offset => offset))
+        Node.search_records($1.gsub('-',' '), :offset => offset, :limit => 1).first
       elsif path = str[/\A\(([^\)]*)\)\Z/,1]
         if path[0..0] == '/'
           find_by_path(path[1..-1])
@@ -367,9 +369,6 @@ class Node < ActiveRecord::Base
     def create_node(new_attributes)
       attributes = transform_attributes(new_attributes)
 
-      # the way this works here and in do_update_attributes is not good
-      publish_after_save = (attributes.delete('v_status').to_i == Zena::Status[:pub])
-
       # TODO: replace this hack with a proper class method 'secure' behaving like the
       # instance method. It would get the visitor and scope from the same hack below.
       scope   = self.scoped_methods[0] || {}
@@ -392,7 +391,6 @@ class Node < ActiveRecord::Base
         self.create_instance(attributes)
       end
 
-      node.publish if publish_after_save
       node
     end
 
@@ -526,22 +524,20 @@ class Node < ActiveRecord::Base
               # file
               insert_zafu_headings = false
               if opts[:parent_class] == 'Skin' && ['html','xhtml'].include?(attrs['c_ext']) && attrs['name'] == 'index'
-                attrs['c_ext'] = 'zafu'
-                attrs['name']  = 'Node'
+                attrs['c_ext']    = 'zafu'
+                attrs['name']     = 'Node'
                 insert_zafu_headings = true
               end
 
-              ctype = EXT_TO_TYPE[attrs['c_ext']]
+              ctype = Zena::EXT_TO_TYPE[attrs['c_ext']]
               ctype = ctype ? ctype[0] : "application/octet-stream"
               attrs['c_content_type'] = ctype
 
 
-              File.open(document_path) do |file|
+              File.open(document_path) do |f|
+                file = uploaded_file(f, filename, ctype)
                 (class << file; self; end;).class_eval do
-                  alias local_path path if defined?(:path)
                   alias o_read read
-                  define_method(:original_filename) { filename }
-                  define_method(:content_type) { ctype }
                   define_method(:read) do
                     if insert_zafu_headings
                       o_read.sub(%r{</head>},"  <r:stylesheets/>\n  <r:javascripts/>\n  <r:uses_datebox/>\n</head>")
@@ -578,88 +574,12 @@ class Node < ActiveRecord::Base
       node
     end
 
-    # Find a node by it's full path. Cache 'fullpath' if found.
+    # Find a node by it's full path. Cache 'fullpath' if found. This is useless now
+    # that fullpath is properly cached. REMOVE !
     def find_by_path(path)
       return nil unless scope = scoped_methods[0]
       return nil unless scope[:find]   # not secured find. refuse.
-      node = self.find_by_fullpath(path)
-      if node.nil?
-        path = path.split('/')
-        last = path.pop
-        # FIXME: remove 'with_exclusive_scope' once scopes are clarified and removed from 'secure'
-        Node.send(:with_exclusive_scope) do
-          node = Node.find(current_site[:root_id])
-          path.each do |p|
-            raise ActiveRecord::RecordNotFound unless node = Node.find_by_name_and_parent_id(p, node[:id])
-          end
-        end
-        raise ActiveRecord::RecordNotFound unless node = self.find_by_name_and_parent_id(last, node[:id])
-        path << last
-        node.fullpath = path.join('/')
-        # bypass callbacks here
-        Node.connection.execute "UPDATE #{Node.table_name} SET fullpath='#{path.join('/').gsub("'",'"')}' WHERE id='#{node[:id]}'"
-      end
-      node
-    end
-
-    # Paginate found results. Returns [previous_page, collection, next_page]. You can specify page and items per page in the query hash :
-    #  :page => 1, :per_page => 20. This should be wrapped into a secure scope.
-    def find_with_pagination(count, opts)
-      previous_page, collection, next_page, count_all = nil, [], nil, nil
-      per_page = (opts.delete(:per_page) || 20).to_i
-      page     = opts.delete(:page) || 1
-      page     = page > 0 ? page.to_i : 1
-      offset   = (page - 1) * per_page
-
-      if opts[:group]
-        count_select  = "DISTINCT #{opts[:group]}"
-      else
-        count_select  = opts.delete(:count) || 'nodes.id'
-      end
-
-      # FIXME: why do we need 'exclusive scope' here ?
-      with_exclusive_scope(self.scoped_methods[0] || {}) do
-        count_all = count(opts.merge( :select  => count_select, :order => nil, :group => nil ))
-        if count_all > offset
-          collection = find(count, opts.merge(:offset => offset, :limit => per_page))
-          if count_all > (offset + per_page)
-            next_page = page + 1
-          end
-          previous_page = page > 1 ? (page - 1) : nil
-        else
-          # offset too big, previous page = last page
-          previous_page = page > 1 ? ((count_all + per_page - 1) / per_page) : nil
-        end
-      end
-      [previous_page, collection, next_page, count_all]
-    end
-
-    # Return a hash to do a fulltext query.
-    def match_query(query, opts={})
-      node = opts.delete(:node)
-      if query == '.' && node
-        return opts.merge(
-          :conditions => ["parent_id = ?",node[:id]],
-          :order  => 'name ASC' )
-      elsif !query.blank?
-        if Zena::Db.adapter == 'mysql' && RAILS_ENV != 'test'
-          match  = sanitize_sql(["MATCH (vs.title,vs.text,vs.summary) AGAINST (?) OR nodes.name LIKE ?", query, "#{opts[:name_query] || query.url_name}%"])
-          select = sanitize_sql(["nodes.*, MATCH (vs.title,vs.text,vs.summary) AGAINST (?) + (5 * (nodes.name LIKE ?)) AS score", query, "#{query}%"])
-        else
-          match = sanitize_sql(["nodes.name LIKE ?", "#{query}%"])
-          select = "nodes.*, #{match} AS score"
-        end
-
-        return opts.merge(
-          :select => select,
-          :joins  => "INNER JOIN versions AS vs ON vs.node_id = nodes.id AND vs.status >= #{Zena::Status[:pub]}",
-          :conditions => match,
-          :group      => "nodes.id",
-          :order  => "score DESC, zip ASC")
-      else
-        # error
-        return opts.merge(:conditions => '0')
-      end
+      self.find_by_fullpath(path)
     end
 
     # FIXME: Where is this used ?
@@ -834,13 +754,14 @@ class Node < ActiveRecord::Base
   alias_method_chain :versions, :secure
 
   # Additional security so that unsecure finders explode when trying to update/save or follow relations.
-  def visitor
-    return @visitor if @visitor
-    # We need to be more tolerant during object creation since 'v_foo' can be
-    # set before 'visitor' and we need visitor.lang when creating versions.
-    return Thread.current.visitor if new_record?
-    raise Zena::RecordNotSecured.new("Visitor not set, record not secured.")
-  end
+  # def visitor
+  #   return @visitor if @visitor
+  #   @visitor = Thread.current[:visitor] || Zena::RecordNotSecured.new("Visitor not set, record not secured.")
+  #   # We need to be more tolerant during object creation since 'v_foo' can be
+  #   # set before 'visitor' and we need visitor.lang when creating versions.
+  #   #return Thread.current[:visitor] #if new_record?
+  #   #raise Zena::RecordNotSecured.new("Visitor not set, record not secured.")
+  # end
 
   # Return an attribute if it is safe (RubyLess allowed). Return nil otherwise.
   # This is mostly used when the zafu compiler cannot decide whether a method is safe or not at compile time.
@@ -946,38 +867,13 @@ class Node < ActiveRecord::Base
   end
 
 
-  # Return the same basepath as the parent. Is overwriten by 'Page' class.
-  def basepath(rebuild=false, update= true)
-    if !self[:basepath] || rebuild
-      if self[:parent_id]
-        parent = parent(false)
-        path = parent ? parent.basepath(rebuild) : ''
-      else
-        path = ''
-      end
-      self.connection.execute "UPDATE #{self.class.table_name} SET basepath='#{path}' WHERE id='#{self[:id]}'" if path != self[:basepath] && update
-      self[:basepath] = path
-    end
+  # url base path. If a node is in 'projects' and projects has custom_base set, the
+  # node's basepath becomes 'projects', so the url will be 'projects/node34.html'.
+  # The basepath is cached. If rebuild is set to true, the cache is updated.
+  def basepath
     self[:basepath]
   end
 
-  # Return the full path as an array if it is cached or build it when asked for.
-  def fullpath(rebuild=false, update = true, loop_ids = [])
-    return "" if loop_ids.include?(self.id)
-    loop_ids << self.id
-    if !self[:fullpath] || rebuild
-      if parent = parent(false)
-        path = parent.fullpath(rebuild,true,loop_ids).split('/') + [name.gsub("'",'')]
-      else
-        path = []
-      end
-      path = path.join('/')
-      self.connection.execute "UPDATE #{self.class.table_name} SET fullpath='#{path}' WHERE id='#{self[:id]}'" if path != self[:fullpath] && update
-      self[:fullpath] = path
-    end
-    self[:fullpath]
-  end
-
   # Same as fullpath, but the path includes the root node.
   def rootpath
     current_site.name + (fullpath != "" ? "/#{fullpath}" : "")
@@ -1477,32 +1373,56 @@ class Node < ActiveRecord::Base
     end
 
   private
-    def node_before_validation
-      self[:kpath] = self.vclass.kpath
 
-      self.name ||= (version.title || '').url_name
+    def rebuild_fullpath
+      return unless new_record? || name_changed? || parent_id_changed? || fullpath.nil?
+      if parent = parent(false)
+        path = parent.fullpath.split('/') + [name]
+      else
+        path = []
+      end
+      self[:fullpath] = path.join('/')
+    end
+
+    def rebuild_basepath
+      return unless new_record? || name_changed? || parent_id_changed? || custom_base_changed? || basepath.nil?
+      if custom_base
+        self[:basepath] = self.fullpath
+      elsif parent = parent(false)
+        self[:basepath] = parent.basepath
+      else
+        self[:basepath] = ""
+      end
+    end
 
+    def set_defaults
+      # sync version title and name
       if ref_lang == version.lang &&
          ((full_drive? && version.status == Zena::Status[:pub]) ||
           (can_drive?  && vhash['r'][ref_lang].nil?))
         if name_changed? && !name.blank?
-          version.title = self.name.gsub(/([A-Z])/) { " #{$1.downcase}" }
+          version.title = self.name
         elsif !version.title.blank?
           self.name = version.title.url_name
         end
       end
 
+      self[:custom_base] = false unless kind_of?(Page)
+      true
+    end
+
+    def node_before_validation
+      self[:kpath] = self.vclass.kpath
+
+      self.name ||= (version.title || '').url_name
+
       unless name.blank?
-        # update cached fullpath
-        if new_record? || name_changed? || parent_id_changed?
-          self[:fullpath] = self.fullpath(true,false)
-        elsif !new_record? && custom_base_changed?
-          self[:basepath] = self.basepath(true,false)
-        end
-        if !new_record? && fullpath_changed?
-          # FIXME: update children's cached fullpaths
-          @clear_children_fullpath = true
-        end
+        # rebuild cached fullpath / basepath
+        rebuild_fullpath
+        rebuild_basepath
+        # we should use a full rebuild when there are corrupt values,
+        # if fullpath was blank, we have no way to find all children
+        @need_rebuild_children_fullpath = !new_record? && (fullpath_changed? || basepath_changed?) && !fullpath_was.blank?
       end
 
       # make sure section is the same as the parent
@@ -1510,7 +1430,7 @@ class Node < ActiveRecord::Base
         # root node
         self[:section_id] = self[:id]
         self[:project_id] = self[:id]
-      elsif parent
+      elsif ref = parent
         self[:section_id] = ref.get_section_id
         self[:project_id] = ref.get_project_id
       else
@@ -1715,16 +1635,38 @@ class Node < ActiveRecord::Base
       end
     end
 
-    def clear_children_fullpath(i = self[:id])
-      return true unless @clear_children_fullpath
-      base_class.connection.execute "UPDATE nodes SET fullpath = NULL WHERE #{ref_field(false)}='#{i}'"
-      ids = nil
-      # FIXME: remove 'with_exclusive_scope' once scopes are clarified and removed from 'secure'
-      base_class.send(:with_exclusive_scope) do
-        ids = Zena::Db.fetch_ids("SELECT id FROM #{base_class.table_name} WHERE #{ref_field(true)} = '#{i.to_i}' AND inherit='1'")
-      end
+    def rebuild_children_fullpath
+      return true unless @need_rebuild_children_fullpath
+
+      # Update descendants
+      fullpath_new = self.fullpath
+      fullpath_new = "#{fullpath_new}/" if fullpath_was == ''
+      fullpath_re  = fullpath_changed? ? %r{\A#{self.fullpath_was}} : nil
 
-      ids.each { |i| clear_children_fullpath(i) }
+      bases = [self.basepath]
+
+      i = 0
+      batch_size = 100
+      while true
+        list  = Zena::Db.fetch_attributes(['id', 'fullpath', 'basepath', 'custom_base'], 'nodes', "fullpath LIKE #{Zena::Db.quote("#{fullpath_was}%")} AND site_id = #{current_site.id} ORDER BY fullpath ASC LIMIT #{batch_size} OFFSET #{i * batch_size}")
+        break if list.empty?
+        list.each do |rec|
+          rec['fullpath'].sub!(fullpath_re, fullpath_new) if fullpath_re
+          if rec['custom_base'].to_i == 1
+            rec['basepath'] = rec['fullpath']
+            bases << rec['basepath']
+          else
+            while rec['fullpath'].size <= bases.last.size
+              bases.pop
+            end
+            rec['basepath'] = bases.last
+          end
+          id = rec.delete('id')
+          Zena::Db.execute "UPDATE nodes SET #{rec.map {|k,v| "#{Zena::Db.connection.quote_column_name(k)}=#{Zena::Db.quote(v)}"}.join(', ')} WHERE id = #{id}"
+        end
+        # 50 more
+        i += 1
+      end
       true
     end
 
@@ -1749,4 +1691,4 @@ class Node < ActiveRecord::Base
 
 end
 
-Bricks::Patcher.apply_patches
+Bricks.apply_patches

data/app/models/page.rb

@@ -10,28 +10,8 @@ Template::  subclass of TextDocument. Contains the zafu code to make the look an
 Skin::      subclass of Template. Contains other templates. The skin name must be unique throughout the site as it is used to identify the 'theme' of the site or parts of the site.
 =end
 class Page < Node
-  before_validation :update_base_path #, :if => 'custom_base.changed?'
-
-  # url base path. If a node is in 'projects' and projects has custom_base set, the
-  # node's basepath becomes 'projects', so the url will be 'projects/node34.html'.
-  # The basepath is cached. If rebuild is set to true, the cache is updated.
-  def basepath(rebuild=false, update = true)
-    if !self[:basepath] || rebuild
-      if self[:custom_base]
-        self.basepath = fullpath(rebuild, update)
-        # FIXME: REMOVE this UPDATE !
-        self.connection.execute "UPDATE #{self.class.table_name} SET basepath=#{Node.connection.quote(self.basepath)} WHERE id='#{self[:id]}'" if !new_record? && update && self.basepath_changed?
-      else
-        super
-      end
-    end
-    self[:basepath]
-  end
 
   private
-    def update_base_path
-      self[:basepath] = self.basepath(true)
-    end
 
     def validate_node
       super

data/app/models/site.rb

@@ -72,12 +72,7 @@ class Site < ActiveRecord::Base
         :first_name => "Super", :name => "User", :lang => site.default_lang, :status => User::Status[:su])
       su.site = site
 
-      unless Thread.current.respond_to?(:visitor)
-        class << Thread.current
-          attr_accessor :visitor
-        end
-      end
-      Thread.current.visitor = su
+      Thread.current[:visitor] = su
 
       unless su.save
         # rollback
@@ -109,8 +104,10 @@ class Site < ActiveRecord::Base
       # =========== CREATE Anonymous, admin =====================
       # create anon user
       # FIXME: make sure user_id = admin user
-      anon = site.send(:secure,User) { User.new_no_defaults( :login => nil, :password => nil,
-        :first_name => "Anonymous", :name => "User", :lang => site.default_lang, :status => User::Status[:moderated]) }
+
+      anon = site.send(:secure, User) {User.new_no_defaults( :login => nil, :password => nil,
+        :first_name => "Anonymous", :name => "User", :lang => site.default_lang, :status => User::Status[:moderated])}
+
       anon.site = site
       raise Exception.new("Could not create anonymous user for site [#{host}] (site#{site[:id]})\n#{anon.errors.map{|k,v| "[#{k}] #{v}"}.join("\n")}") unless anon.save
       site[:anon_id] = anon[:id]
@@ -134,7 +131,7 @@ class Site < ActiveRecord::Base
       #admin_user = site.send(:secure, User) { User.find(admin_user[:id]) }
 
       # make admin the current visitor
-      Thread.current.visitor = admin_user
+      Thread.current[:visitor] = admin_user
 
       root = site.send(:secure,Project) { Project.create( :name => site.name, :rgroup_id => pub[:id], :wgroup_id => sgroup[:id], :dgroup_id => admin[:id], :v_title => site.name, :v_status => Zena::Status[:pub]) }
       raise Exception.new("Could not create root node for site [#{host}] (site#{site[:id]})\n#{root.errors.map{|k,v| "[#{k}] #{v}"}.join("\n")}") if root.new_record?
@@ -204,13 +201,13 @@ class Site < ActiveRecord::Base
   # Return the anonymous user, the one used by anonymous visitors to visit the public part
   # of the site.
   def anon
-    @anon ||= secure!(User) { User.find(self[:anon_id]) }
+    @anon ||= User.find_by_id_and_site_id(self[:anon_id], self.id)
   end
 
   # Return the super user. This user has extended priviledges on the data (has access to private other's data).
   # This is an emergency user.
   def su
-    @su ||= secure!(User) { User.find(self[:su_id]) }
+    @su ||= User.find_by_id_and_site_id(self[:su_id], self.id)
   end
 
   # TODO: test
@@ -344,6 +341,39 @@ class Site < ActiveRecord::Base
     end
   end
 
+  def rebuild_fullpath(parent_id = nil, parent_fullpath = "", parent_basepath = "")
+    i = 0
+    batch_size = 100
+    children = []
+    while true
+      rec = Zena::Db.fetch_attributes(['id', 'fullpath', 'basepath', 'custom_base', 'name'], 'nodes', "parent_id #{parent_id ? "= #{parent_id}" : "IS NULL"} AND site_id = #{self.id} ORDER BY id ASC LIMIT #{batch_size} OFFSET #{i * batch_size}")
+      break if rec.empty?
+      rec.each do |rec|
+        if parent_id
+          rec['fullpath'] = parent_fullpath == '' ? rec['name'] : "#{parent_fullpath}/#{rec['name']}"
+        else
+          # root node
+          rec['fullpath'] = ''
+        end
+
+        if rec['custom_base'].to_i == 1
+          rec['basepath'] = rec['fullpath']
+        else
+          rec['basepath'] = parent_basepath
+        end
+
+        id = rec.delete('id')
+        children << [id, rec['fullpath'], rec['basepath']]
+        Zena::Db.execute "UPDATE nodes SET #{rec.map {|k,v| "#{Zena::Db.connection.quote_column_name(k)}=#{Zena::Db.quote(v)}"}.join(', ')} WHERE id = #{id}"
+      end
+      # 50 more
+      i += 1
+    end
+    children.each do |child|
+      rebuild_fullpath(*child)
+    end
+  end
+
   private
     def valid_site
       errors.add(:host, 'invalid') if self[:host].nil? || (self[:host] =~ /^\./) || (self[:host] =~ /[^\w\.\-]/)
@@ -352,4 +382,4 @@ class Site < ActiveRecord::Base
     end
 end
 
-Bricks::Patcher.apply_patches
+Bricks.apply_patches