zena 1.0.0.beta3 → 1.0.0.rc1

data/lib/zena/use/search.rb

@@ -8,13 +8,13 @@ module Zena
           if query == '.' && node
             return options.merge(
               :conditions => ["parent_id = ?",node[:id]],
-              :order  => 'node_name ASC' )
+              :order  => 'zip ASC' )
           elsif !query.blank?
             if Zena::Db.adapter == 'mysql' && RAILS_ENV != 'test'
-              match  = sanitize_sql(["MATCH (vs.idx_text_high,vs.idx_text_medium,vs.idx_text_low) AGAINST (?) OR nodes.node_name LIKE ?", query, "#{options[:name_query] || query.url_name}%"])
-              select = sanitize_sql(["nodes.*, MATCH (vs.idx_text_high,vs.idx_text_medium,vs.idx_text_low) AGAINST (?) + (5 * (nodes.node_name LIKE ?)) AS score", query, "#{query}%"])
+              match  = sanitize_sql(["MATCH (vs.idx_text_high,vs.idx_text_medium,vs.idx_text_low) AGAINST (?)", query, "#{options[:name_query] || query.url_name}%"])
+              select = sanitize_sql(["nodes.*, MATCH (vs.idx_text_high,vs.idx_text_medium,vs.idx_text_low) AGAINST (?) AS score", query, "#{query}%"])
             else
-              match = sanitize_sql(["nodes.node_name LIKE ?", "#{query}%"])
+              match = sanitize_sql(["nodes._id LIKE ?", "#{query}%"])
               select = "nodes.*, #{match} AS score"
             end
 
@@ -69,7 +69,7 @@ module Zena
 
             query = "nodes where #{query_args.join(' and ')} in site"
           end
-
+          
           res = node.find(count, query, options.merge(:errors => true, :rubyless_helper => self, :default => default))
 
           if res.kind_of?(::QueryBuilder::Error)
@@ -103,8 +103,8 @@ module Zena
         #   node_count = get_var_name('paginate', 'nodes')
         #   page_count = get_var_name('paginate', 'count')
         #   curr_page  = get_var_name('paginate', 'current')
-        #   out "<% set_#{pagination_key}_count = (set_#{pagination_key}_nodes / @search_per_page).ceil; set_#{pagination_key} = [1,params[:page].to_i].max -%>"
-        #   out "<% #{node_count} = @search_count; #{page_count} = (#{node_count} / @search_per_page).ceil; #{curr_page} = [1,params[:#{pagination_key}].to_i].max -%>"
+        #   out "<% set_#{pagination_key}_count = (set_#{pagination_key}_nodes / @search_per_page).ceil; set_#{pagination_key} = [1,params[:page].to_i].max %>"
+        #   out "<% #{node_count} = @search_count; #{page_count} = (#{node_count} / @search_per_page).ceil; #{curr_page} = [1,params[:#{pagination_key}].to_i].max %>"
         #   expand_if....
         # end
       end

data/lib/zena/use/urls.rb

@@ -1,6 +1,8 @@
 module Zena
   module Use
     module Urls
+      ALLOWED_REGEXP = /\A(([a-zA-Z]+)([0-9]+)|([#{String::ALLOWED_CHARS_IN_FILENAME}]+))(_[a-zA-Z]+|)(\..+|)\Z/
+
       module Common
         CACHESTAMP_FORMATS = ['jpg', 'png', 'gif', 'css', 'js']
         def prefix
@@ -13,9 +15,15 @@ module Zena
 
         # We overwrite some url writers that might use Node so that they use
         # zip instead of id.
-        %w{edit delete drop zafu}.each do |method|
+        ['', 'edit_', 'delete_', 'drop_', 'zafu_'].each do |method|
           class_eval %Q{
-            def #{method}_node_path(node, options={}) # def edit_node_path(node, options={})
+            def #{method}node_path(node, options={}) # def edit_node_path(node, options={})
+              if ep = options.delete(:encode_params)
+                ep.split(',').map(&:strip).each do |key|
+                  value = params[key]
+                  options[key] = value unless value.blank?
+                end
+              end
               if node.kind_of?(Node)                  #   if node.kind_of?(Node)
                 super(node.zip, options)              #     super(node.zip, options)
               else                                    #   else
@@ -80,13 +88,13 @@ module Zena
             "#{abs_url_prefix}/#{pre}" # index page
           elsif node[:custom_base]
             "#{abs_url_prefix}/#{pre}/" +
-            node.basepath +
+            basepath_as_url(node.basepath) +
             (mode  ? "_#{mode}"  : '') +
             (asset ? ".#{asset}" : '') +
             (format == 'html' ? '' : ".#{format}")
           else
             "#{abs_url_prefix}/#{pre}/" +
-            ((node.basepath != '' && !node.basepath.nil? )? "#{node.basepath}/" : '') +
+            (node.basepath.blank? ? '' : "#{basepath_as_url(node.basepath)}/") +
             (node.klass.downcase   ) +
             (node[:zip].to_s       ) +
             (mode  ? "_#{mode}"  : '') +
@@ -96,23 +104,49 @@ module Zena
           append_query_params(path, opts)
         end
 
+        def basepath_as_url(path)
+          path.split('/').map do |zip|
+            if n = secure(Node) { Node.find_by_zip(zip) }
+              n.title.url_name
+            else
+              nil
+            end
+          end.compact.join('/')
+        end
+
         def append_query_params(path, opts)
           if opts == {}
             path
           else
             cachestamp = opts.delete(:cachestamp)
             list = opts.keys.map do |k|
-              if value = opts[k]
+              # FIXME: DOC
+              if k.to_s == 'encode_params'
+                opts[k].split(',').map(&:strip).map do |key|
+                  value = params[key]
+                  if value.kind_of?(Hash)
+                    {key => value}.to_query
+                  elsif !value.blank?
+                    "#{key}=#{CGI.escape(value)}"
+                  else
+                    nil
+                  end
+                end
+              elsif value = opts[k]
                 if value.respond_to?(:strftime)
                   # FIXME: I think this is not needed anymore (and removing time might not be a good idea).
                   "#{k}=#{value.strftime('%Y-%m-%d')}"
+                elsif value.kind_of?(Hash)
+                  "#{k}=#{value.to_query}"
+                elsif !value.blank?
+                  "#{k}=#{CGI.escape(value.to_s)}"
                 else
-                  "#{k}=#{CGI.escape(opts[k].to_s)}"
+                  nil
                 end
               else
                 nil
               end
-            end.compact
+            end.flatten.compact
             if cachestamp
               result = path + "?#{cachestamp}" + (list.empty? ? '' : "&#{list.sort.join('&')}")
               result
@@ -200,6 +234,9 @@ module Zena
 
         safe_method [:zafu_node_path, Node, Hash]   => {:class => String, :accept_nil => true}
         safe_method [:zafu_node_path, Node]         => {:class => String, :accept_nil => true}
+        safe_method [:update_node_path, Node, Hash]   => {:class => String, :accept_nil => true, :method => 'node_path'}
+        safe_method [:update_node_path, Node]         => {:class => String, :accept_nil => true, :method => 'node_path'}
+
         safe_method [:edit_node_path, Node, Hash]   => {:class => String, :accept_nil => true}
         safe_method [:edit_node_path, Node]         => {:class => String, :accept_nil => true}
         safe_method [:delete_node_path, Node, Hash] => {:class => String, :accept_nil => true}
@@ -266,6 +303,7 @@ module Zena
         #
         def make_link(options = {})
           remote_target = (options[:update] || @params.delete(:update))
+          options[:action] ||= @params.delete(:action)
 
           @markup.tag ||= 'a'
 
@@ -291,7 +329,7 @@ module Zena
             # ajax link (link_to_remote)
 
             # Add href to non-ajax method.
-            markup.set_param(:href, "<%= #{make_href(nil, options.merge(:update => false))} %>")
+            markup.set_dyn_param(:href, "<%= #{make_href(nil, options.merge(:update => false))} %>")
 
 
             # Use onclick with Ajax.
@@ -417,6 +455,7 @@ module Zena
               elsif node.will_be?(Version)
                 'version#{node.id}_#{id}'
               else
+                # ???
                 anchor_name
                 # force compilation with Node context. Why ?
                 #node_bak = @context[:node]
@@ -445,7 +484,7 @@ module Zena
             anchor = @params[:anchor]
             if anchor && !@params[:href]
               # Link on same page
-              return ::RubyLess.translate_string(self, "##{get_anchor_name(anchor)}")
+              return ::RubyLess.translate(self, "%Q{##{get_anchor_name(anchor)}}")
             end
 
             # if opts[:action] == 'edit' && !remote_target
@@ -453,6 +492,8 @@ module Zena
             # els
             if %w{edit drop unlink}.include?(opts[:action])
               method = "#{opts[:action]}_node_path"
+            elsif %w{update}.include?(opts[:action])
+              method = 'update_node_path'
             elsif remote_target
               method = 'zafu_node_path'
             else
@@ -489,6 +530,7 @@ module Zena
                 value = get_anchor_name(value)
               end
 
+              # FIXME: Do not force string interpolation.
               hash_params << "#{key.inspect} => %Q{#{value}}"
             end
 
@@ -504,7 +546,11 @@ module Zena
           def insert_ajax_args(target, hash_params, action)
             hash_params << ":s => start_id"
             hash_params << ":link_id => this.link_id" if @context[:has_link_id] && node.will_be?(Node)
-            if target.kind_of?(String)
+            if target == '_page'
+              # reload full page
+              hash_params << ":udom_id => '_page'"
+              return
+            elsif target.kind_of?(String)
               # named target
               return nil unless target = find_target(target)
             end
@@ -521,9 +567,16 @@ module Zena
               @insert_dom_id = %Q{"#{node.dom_id(:erb => false)}"}
               hash_params << ":dom_id => insert_dom_id"
               hash_params << ":t_url  => %Q{#{template_url(target.name)}}"
-            else # drop
-              hash_params << ":dom_id => %Q{#{target.name}}" # target.node.dom_id
-              hash_params << ":t_url  => %Q{#{template_url(target.name)}}"
+            else # drop, swap
+              if target.context && target.node
+                # target loaded
+                dom_name = target.node.dom_prefix
+              else
+                # hack until we find a way to prebuild the target....
+                dom_name = target.name
+              end
+              hash_params << ":dom_id => %Q{#{dom_name}}"
+              hash_params << ":t_url  => %Q{#{template_url(dom_name)}}"
             end
 
             # method = opts[:method] || :get
@@ -561,16 +614,16 @@ module Zena
             # query_params << start_node_s_param(:string)
             #
             # res = ''
-            # res += "<% if #{opts[:cond]} -%>" if opts[:cond]
+            # res += "<% if #{opts[:cond]} %>" if opts[:cond]
             # res += "<%= tag_to_remote({:url => \"#{url}?#{query_params.join('&')}\", :method => #{method.inspect}}#{params_to_erb(html_params)}) %>"
             # res += text_for_link(opts[:default_text])
             # res += "</a>"
             # if opts[:cond]
             #   if opts[:else] != :void
-            #     res += "<% else -%>"
+            #     res += "<% else %>"
             #     res += text_for_link(opts[:default_text])
             #   end
-            #   res += "<% end -%>"
+            #   res += "<% end %>"
             # end
             # res
           end
@@ -587,9 +640,9 @@ module Zena
               prev_or_next = get_var_name('paginate', page_direction)
 
               if page_direction == 'previous'
-                out "<% if #{prev_or_next} = (#{current} > 1 ? #{current} - 1 : nil) -%>"
+                out "<% if #{prev_or_next} = (#{current} > 1 ? #{current} - 1 : nil) %>"
               else
-                out "<% if #{prev_or_next} = (#{count} - #{current} > 0 ? #{current} + 1 : nil) -%>"
+                out "<% if #{prev_or_next} = (#{count} - #{current} > 0 ? #{current} + 1 : nil) %>"
               end
 
               # previous_page // next_page
@@ -601,7 +654,7 @@ module Zena
               if descendant('else')
                 out expand_with(:in_if => true, :only => ['else', 'elsif'])
               end
-              out "<% end -%>"
+              out "<% end %>"
             when 'list'
 
               node_count  = get_context_var('paginate', 'nodes')
@@ -609,6 +662,10 @@ module Zena
               curr_page   = get_context_var('paginate', 'current')
               page_number = get_var_name('paginate', 'page')
               page_join   = get_var_name('paginate', 'join')
+              page_name   = get_var_name('paginate', 'page_name')
+              # give access to page_name
+              # FIXME: DOC
+              set_context_var('set_var', 'page_name', RubyLess::TypedString.new(page_name, String))
 
               if @blocks == [] || (@blocks.size == 1 && !@blocks.first.kind_of?(String) && @blocks.first.method == 'else')
                 # We need to insert the default 'link' tag: <r:link href='@node' #{pagination_key}='#{this}' ... do='this'/>
@@ -622,7 +679,7 @@ module Zena
 
                 link[:html_tag] = tag if tag
                 link[:href] = '@node'
-                link[:eval] = 'this'
+                link[:eval] = 'page_name'
                 link[pagination_key.to_sym] = '#{this}'
 
                 # <r:link href='@node' href='@node' p='#{this}' ... eval='this'/>
@@ -640,12 +697,12 @@ module Zena
                 remove_instance_variable(:@all_descendants)
               end
 
-              out "<% page_numbers(#{curr_page}, #{page_count}, #{(@params[:join] || ' ').inspect}, #{@params[:page_count] ? @params[:page_count].to_i : 'nil'}) do |#{page_number}, #{page_join}| %>"
+              out "<% page_numbers(#{curr_page}, #{page_count}, #{(@params[:join] || ' ').inspect}, #{@params[:page_count] ? @params[:page_count].to_i : 'nil'}) do |#{page_number}, #{page_join}, #{page_name}| %>"
               out "<%= #{page_join} %>"
               with_context(:node => node.move_to(page_number, Number)) do
                 out expand_if("#{page_number} != #{curr_page}")
               end
-              out "<% end -%>"
+              out "<% end %>"
             else
               parser_error("unkown option for 'page' #{@params[:page].inspect} should be ('previous', 'next' or 'list')")
             end
@@ -655,8 +712,13 @@ module Zena
             if dynamic_blocks?
               expand_with
             else
-              if method = get_attribute_or_eval(false)
-                method.literal || "<%= #{method} %>"
+              method = get_attribute_or_eval(false)
+              if !method && (@params.keys & [:attr, :eval, :text]) != []
+                out @errors.last
+              end
+
+              if method
+                method.literal ? erb_escape(method.literal) : "<%= #{method} %>"
               elsif default
                 default
               elsif node.will_be?(Node)
@@ -676,7 +738,7 @@ module Zena
             case action
             when 'delete', 'unlink'
               'delete'
-            when 'drop'
+            when 'drop', 'update'
               'put'
             else
               'get'

data/lib/zena/use/version_hash.rb

@@ -7,148 +7,148 @@ module Zena
     # Technically, the vhash field contains two dictionaries "readonly" and "write". Each of these dictionaries
     # provide mapping from languages to version id.
     module VersionHash
+      def self.cached_values_from_records(records)
+        r_hash, w_hash = {}, {}
+        vhash = {'r' => r_hash, 'w' => w_hash}
+        lang  = nil
+        n_pub = nil
+        records.each do |record|
+          if record['lang'] != lang
+            lang   = record['lang']
+            # highest status for this lang
+            if record['status'].to_i == Zena::Status[:pub]
+              # ok for readers & writers
+              w_hash[lang] = r_hash[lang] = record['id'].to_i
+              v_pub = record['publish_from']
 
-      class << self
-        def cached_values_from_records(records)
-          r_hash, w_hash = {}, {}
-          vhash = {'r' => r_hash, 'w' => w_hash}
-          lang  = nil
-          n_pub = nil
-          records.each do |record|
-            if record['lang'] != lang
-              lang   = record['lang']
-              # highest status for this lang
-              if record['status'].to_i == Zena::Status[:pub]
-                # ok for readers & writers
-                w_hash[lang] = r_hash[lang] = record['id'].to_i
-                v_pub = record['publish_from']
-
-                if v_pub.kind_of?(String)
-                  v_pub = DateTime.parse(record['publish_from']) rescue Time.now
-                end
-
-                if n_pub.nil? || v_pub < n_pub
-                  n_pub = v_pub
-                end
-              else
-                # too high, only ok for writers
-                w_hash[lang] = record['id'].to_i
+              if v_pub.kind_of?(String)
+                v_pub = DateTime.parse(record['publish_from']) rescue Time.now
               end
-            elsif record['status'].to_i == Zena::Status[:pub]
-              # ok for readers
-              r_hash[lang] = record['id'].to_i
-              v_pub = DateTime.parse(record['publish_from']) rescue Time.now
+
               if n_pub.nil? || v_pub < n_pub
                 n_pub = v_pub
               end
+            else
+              # too high, only ok for writers
+              w_hash[lang] = record['id'].to_i
+            end
+          elsif record['status'].to_i == Zena::Status[:pub]
+            # ok for readers
+            r_hash[lang] = record['id'].to_i
+            v_pub = DateTime.parse(record['publish_from']) rescue Time.now
+            if n_pub.nil? || v_pub < n_pub
+              n_pub = v_pub
             end
           end
-          {:publish_from => n_pub, :vhash => vhash}
         end
+        {:publish_from => n_pub, :vhash => vhash}
       end
 
-      def version
-        @version ||= begin
-          if v_id = version_id
-            version = ::Version.find(v_id)
-          else
-            version = ::Version.new
+      module ModelMethods
+        def version
+          @version ||= begin
+            if v_id = version_id
+              version = ::Version.find(v_id)
+            else
+              version = ::Version.new
+            end
+            version.node = self
+            version
           end
-          version.node = self
-          version
         end
-      end
 
-      def version_id
-        access = can_see_redactions? ? vhash['w'] : vhash['r']
-        access[visitor.lang] || access[self[:ref_lang]] || access.values.first
-      end
+        def version_id
+          access = can_see_redactions? ? vhash['w'] : vhash['r']
+          access[visitor.lang] || access[self[:ref_lang]] || access.values.first
+        end
 
-      # Return the list of versions that are stored in the vhash and could be loaded depending
-      # on the visitor.
-      def visible_versions
-        @visible_versions ||= begin
-          ids = (vhash['w'].values + vhash['r'].values).uniq
-          ::Version.find(ids).tap do |list|
-            list.each do |version|
-              version.node = self
+        # Return the list of versions that are stored in the vhash and could be loaded depending
+        # on the visitor.
+        def visible_versions
+          @visible_versions ||= begin
+            ids = (vhash['w'].values + vhash['r'].values).uniq
+            ::Version.find(ids).tap do |list|
+              list.each do |version|
+                version.node = self
+              end
             end
           end
         end
-      end
 
-      def vhash
-        @vhash ||= JSON.parse(self[:vhash] || '{"r":{}, "w":{}}')
-      end
+        def vhash
+          @vhash ||= JSON.parse(self[:vhash] || '{"r":{}, "w":{}}')
+        end
 
-      def rebuild_vhash
-        cached = VersionHash.cached_values_from_records(connection.select_all("SELECT id,lang,status,publish_from FROM #{Version.table_name} WHERE node_id = #{self.id} ORDER BY lang ASC, status DESC", "Version Load"))
-        # We also rebuild publish_from here: yes, that's a leak with Workflow.
-        self[:publish_from] = cached[:publish_from]
-        self[:vhash] = cached[:vhash].to_json
-        @vhash = cached[:vhash]
-      end
+        def rebuild_vhash
+          cached = VersionHash.cached_values_from_records(connection.select_all("SELECT id,lang,status,publish_from FROM #{Version.table_name} WHERE node_id = #{self.id} ORDER BY lang ASC, status DESC", "Version Load"))
+          # We also rebuild publish_from here: yes, that's a leak with Workflow.
+          self[:publish_from] = cached[:publish_from]
+          self[:vhash] = cached[:vhash].to_json
+          @vhash = cached[:vhash]
+        end
 
-      private
-        def update_vhash
-          version = self.version
+        private
+          def update_vhash
+            version = self.version
 
-          case @current_transition[:name]
-          when :edit, :redit
-            vhash['w'][version.lang] = version.id
-          when :publish, :auto_publish
-            vhash['r'][version.lang] = vhash['w'][version.lang] = version.id
-          when :unpublish
-            vhash['r'].delete(version.lang)
-          when :remove
-            if v_id = vhash['r'][version.lang]
-              vhash['w'][version.lang] = v_id
-            end
-          when :destroy_version
-            v_id = version.id
-            lang = version.lang
-            if vhash['w'][lang] == v_id
-              # Writers were looking at old version
-              if vhash['r'][lang] && vhash['r'][lang] != v_id
-                # There is a publication that can be used
-                vhash['w'][lang] = v_id
-              else
-                # Nothing to see here for this lang
-                vhash['w'].delete(lang)
-                vhash['r'].delete(lang)
+            case @current_transition[:name]
+            when :edit, :redit
+              vhash['w'][version.lang] = version.id
+            when :publish, :auto_publish
+              vhash['r'][version.lang] = vhash['w'][version.lang] = version.id
+            when :unpublish
+              vhash['r'].delete(version.lang)
+            when :remove
+              if v_id = vhash['r'][version.lang]
+                vhash['w'][version.lang] = v_id
+              end
+            when :destroy_version
+              v_id = version.id
+              lang = version.lang
+              if vhash['w'][lang] == v_id
+                # Writers were looking at old version
+                if vhash['r'][lang] && vhash['r'][lang] != v_id
+                  # There is a publication that can be used
+                  vhash['w'][lang] = v_id
+                else
+                  # Nothing to see here for this lang
+                  vhash['w'].delete(lang)
+                  vhash['r'].delete(lang)
+                end
               end
-            end
 
-            if vhash['w'].values == []
-              if last = versions.last
-                # We have a last version (not destroying node)
-                vhash['w'][last.lang] = last.id
+              if vhash['w'].values == []
+                if last = versions.last
+                  # We have a last version (not destroying node)
+                  vhash['w'][last.lang] = last.id
+                end
               end
+
+              # force reload
+              @version = nil
             end
+            self[:vhash] = vhash.to_json
+          end
 
-            # force reload
-            @version = nil
+          # Overwrite MultiVersion. This is called before update.
+          def set_current_version_before_update
+            super
+            update_vhash
           end
-          self[:vhash] = vhash.to_json
-        end
 
-        # Overwrite MultiVersion. This is called before update.
-        def set_current_version_before_update
-          super
-          update_vhash
-        end
+          # Overwrite MultiVersion. This is called after create.
+          def set_current_version_after_create
+            update_vhash
+            Zena::Db.set_attribute(self, :vhash, self[:vhash])
+          end
 
-        # Overwrite MultiVersion. This is called after create.
-        def set_current_version_after_create
-          update_vhash
-          Zena::Db.set_attribute(self, :vhash, self[:vhash])
-        end
+          # Overwrite MultiVersion. This is called after a version is destroyed.
+          def version_destroyed
+            super
+            rebuild_vhash
+          end
 
-        # Overwrite MultiVersion. This is called after a version is destroyed.
-        def version_destroyed
-          super
-          rebuild_vhash
-        end
-    end
+      end # ModelMethods
+    end # VersionHash
   end
 end