zena 1.0.0.beta3 → 1.0.0.rc1

data/lib/zena/use/recursion.rb

@@ -51,8 +51,8 @@ module Zena
               set_context_var('recursion', @name, {:proc_name => proc_name, :klass => klass})
               depth = get_var_name('recursion', 'depth')
               out "<% #{proc_name} = Proc.new do |#{depth}, #{var}| %>"
-              out "<% next if #{depth} > #{inc.params[:depth] ? [inc.params[:depth].to_i,30].min : 5} -%>"
-              @recursion_call =  "<% end -%><% #{proc_name}.call(0,#{node}) %>"
+              out "<% next if #{depth} > #{inc.params[:depth] ? [inc.params[:depth].to_i,30].min : 5} %>"
+              @recursion_call =  "<% end %><% #{proc_name}.call(0,#{node}) %>"
               @context[:node] = node.move_to(var, node.klass)
               @var = nil # avoid reuse of our 'var' as new var name
             end

data/lib/zena/use/relations.rb

@@ -11,7 +11,8 @@ module Zena
         DUMMY = Class.new do
           def other_id;   nil; end
           def other_ids;  [];  end
-          def other_zids; [];  end
+          def other_zips; [];  end
+          def to_s; 'nil'; end
         end.new.freeze
 
         def initialize(node)
@@ -37,11 +38,21 @@ module Zena
       module ClassMethods
 
         # All relations related to the current class/virtual_class with its ancestors.
-        def all_relations(start=nil)
-          rel_as_source = RelationProxy.find(:all, :conditions => ["site_id = ? AND source_kpath IN (?)", current_site[:id], split_kpath])
-          rel_as_target = RelationProxy.find(:all, :conditions => ["site_id = ? AND target_kpath IN (?)", current_site[:id], split_kpath])
-          rel_as_source.each {|rel| rel.source = start } if start
-          rel_as_target.each {|rel| rel.target = start } if start
+        def all_relations(start=nil, group_filter=nil)
+          if group_filter
+            group_filter = "#{group_filter}%"
+            rel_as_source = RelationProxy.find(:all,
+              :conditions => ["site_id = ? AND source_kpath IN (?) AND rel_group LIKE ?", current_site[:id], split_kpath, group_filter])
+            rel_as_target = RelationProxy.find(:all,
+              :conditions => ["site_id = ? AND target_kpath IN (?) AND rel_group LIKE ?", current_site[:id], split_kpath, group_filter])
+          else
+            rel_as_source = RelationProxy.find(:all,
+              :conditions => ["site_id = ? AND source_kpath IN (?)", current_site[:id], split_kpath])
+            rel_as_target = RelationProxy.find(:all,
+              :conditions => ["site_id = ? AND target_kpath IN (?)", current_site[:id], split_kpath])
+          end
+          rel_as_source.each {|rel| rel.source = start }
+          rel_as_target.each {|rel| rel.target = start }
           (rel_as_source + rel_as_target).sort {|a,b| a.other_role <=> b.other_role}
         end
 
@@ -156,8 +167,11 @@ module Zena
         # FIXME: this method does an 'update' not only 'add'
         def add_link(role, hash)
           if rel = relation_proxy(role)
-            rel.other_id  = hash[:other_id]  if hash.has_key?(:other_id)
-            rel.other_ids = hash[:other_ids] if hash.has_key?(:other_ids)
+            rel.qb         = hash[:qb]         if hash.has_key?(:qb)
+            rel.other_id   = hash[:other_id]   if hash.has_key?(:other_id)
+            rel.other_ids  = hash[:other_ids]  if hash.has_key?(:other_ids)
+            rel.other_zip  = hash[:other_zip]  if hash.has_key?(:other_zip)
+            rel.other_zips = hash[:other_zips] if hash.has_key?(:other_zips)
             LINK_ATTRIBUTES.each do |k|
               rel.send("other_#{k}=", hash[k]) if hash.has_key?(k)
             end
@@ -187,11 +201,15 @@ module Zena
             elsif role =~ /^(.+)_attributes$/
               # key used as role
               definition['role'] ||= $1
-            else
+            elsif definition.kind_of?(Hash)
               # key used as role, without the '_attributes'
               definition['role'] ||= role
+            else
+              # qb
+              definition = {'role' => role, 'qb' => definition}
             end
-            add_link(definition.delete('role'), definition.symbolize_keys)  # TODO: only use string keys
+            # TODO: only use string keys
+            add_link(definition.delete('role'), definition.symbolize_keys)
           end
         end
 
@@ -283,9 +301,9 @@ module Zena
           # icon_comment::  get comment field for link to icon
           # icon_for_ids::  get all node ids for which the image is an icon
           # icon_for_zips:: get all node zips for which the image is an icon
-          def method_missing(meth, *args)
+          def method_missing(meth, *args, &block)
             # first try rails' version of method missing
-            super
+            super(meth, *args, &block)
           rescue NoMethodError => err
             # 1. is this a method related to a relation ?
             if meth.to_s =~ LINK_REGEXP
@@ -296,12 +314,6 @@ module Zena
               if rel = relation_proxy(role)
                 if mode == '='
                   # set
-                  case field
-                  when 'zip', 'zips'
-                    # not used to set relations (must use 'translate_attributes' to chagen zip into id before call)
-                    raise err
-                  end
-                  # set value
                   rel.send("other_#{field}=", args[0])
                 else
                   # get
@@ -341,7 +353,7 @@ module Zena
             @relation_proxies.each do |role, rel|
               next unless rel
               unless rel.attributes_to_update_valid?
-                errors.add(role, rel.link_errors.join(', '))
+                errors.add(role, rel.link_errors.map {|k,v| "#{k} => #{v}"}.join(', '))
               end
             end
           end

data/lib/zena/use/rendering.rb

@@ -14,11 +14,15 @@ module Zena
             js
           end
         end
+
+        def set_headers(params)
+          zafu_headers.merge!(params)
+        end
       end
 
       module ControllerMethods
         def self.included(base)
-          base.send(:helper_attr, :js_data)
+          base.send(:helper_attr, :js_data, :zafu_headers)
           base.send(:layout, false)
         end
 
@@ -26,6 +30,10 @@ module Zena
           @js_data ||= []
         end
 
+        def zafu_headers
+          @zafu_headers ||= {}
+        end
+
         # TODO: test
         # Our own handling of exceptions
         def rescue_action_in_public(exception)
@@ -98,42 +106,83 @@ module Zena
           opts = {:skin => @node[:skin], :cache => true}.merge(options)
           opts[:mode  ] ||= params[:mode]
           opts[:format] ||= params[:format].blank? ? 'html' : params[:format]
+          #
           # cleanup before rendering
           params.delete(:mode)
           if opts[:format] != 'html'
-            # Document data or special renderings.
-            content_type  = (Zena::EXT_TO_TYPE[opts[:format]] || ['application/octet-stream'])[0]
-            template_path = template_url(opts)
-            data = render_to_string(:file => template_path, :layout=>false)
-            # TODO: use plugins...
-            #if opts[:format] == 'pdf' && ((Zena::ENABLE_LATEX && data =~ /\A% (latex)\n/) || (Zena::ENABLE_FOP && data =~ /\A<\?(xml)/))
-             # render_pdf($1 == 'xml' ? 'fop' : $1)
 
-            if opts[:format] == 'pdf'
-              Data2pdf.engine =  'Xhtml2pdf'
-              disposition = params['disposition']   || 'inline'
-              if params.keys.include?("debug")
-                render :text => data
+            method = "render_to_#{opts[:format]}"
+            if params.keys.include?('debug')
+              template_path = template_url(opts)
+              result = {
+                :data         => render_to_string(:file => template_path, :layout=>false),
+                :disposition  => params['disposition'] || 'inline',
+                :type         => 'text/html',
+              }
+              opts[:cache] = false
+            elsif respond_to?(method)
+              # Call custom rendering engine 'render_to_pdf' for example.
+              result = send(method, opts)
+            else
+              template_path = template_url(opts)
+              # FIXME: Use Mime types to resolve content type...
+              content_type  = (Zena::EXT_TO_TYPE[opts[:format]] || ['application/octet-stream'])[0]
+              result = {
+                :data         => render_to_string(:file => template_path, :layout=>false),
+                :disposition  => 'inline',
+                :type         => content_type,
+                :filename     => @node.title
+              }
+            end
+
+            if result[:type] == 'text/html'
+              # error reporting from rendering engine
+              opts[:cache] = false
+              render :text => result[:data]
+            else
+              if zafu_headers
+                if disposition = zafu_headers.delete('Content-Disposition')
+                  result.delete(:filename) if disposition =~ /filename\s*=/
+                  result[:disposition] = disposition
+                end
+
+                if type = zafu_headers.delete('Content-Type')
+                  result[:type] = type
+                end
+
+                if filename = zafu_headers.delete('filename')
+                  result[:filename] = filename
+                end
+
+                headers.merge!(zafu_headers)
+              end
+
+              if data = result.delete(:data)
+                send_data(data , result)
+              elsif file = result.delete(:file)
+                send_file(file , result)
               else
-                pdf = Data2pdf.render(data)
-                send_data(pdf,  :type=> 'application/pdf', :disposition=>disposition)
+                # Should never happen
+                raise Exception.new("Render '#{params[:format]}' should return either :file or :data (none found).")
               end
-            else
-              # send data inline
-              filepath = nil
-              send_data( data , :filename=>@node.title, :type => content_type, :disposition=>'inline')
             end
 
-            cache_page(:content_data => data, :content_path => filepath) if opts[:cache]
+            cache_page(:content_data => result[:data], :content_path => result[:file]) if opts[:cache]
           else
             # html
             render :file => template_url(opts), :layout=>false, :status => opts[:status]
+            headers.merge!(zafu_headers)
             cache_page(:url => opts[:cache_url]) if opts[:cache]
           end
         end
 
         # Cache page content into a static file in the current sites directory : SITES_ROOT/test.host/public
         def cache_page(opts={})
+          if cachestamp_format?(params['format'])
+            headers['Expires'] = (Time.now + 365*24*3600).strftime("%a, %d %b %Y %H:%M:%S GMT")
+            headers['Cache-Control'] = (!current_site.authentication? && @node.public?) ? 'public' : 'private'
+          end
+
           return unless perform_caching && caching_allowed(:authenticated => opts.delete(:authenticated))
           url = page_cache_file(opts.delete(:url))
           opts = {:expire_after  => nil,
@@ -142,10 +191,6 @@ module Zena
                   :node_id       => @node[:id]
                   }.merge(opts)
           secure!(CachedPage) { CachedPage.create(opts) }
-          if cachestamp_format?(params['format'])
-            headers['Expires'] = (Time.now + 365*24*3600).strftime("%a, %d %b %Y %H:%M:%S GMT")
-            headers['Cache-Control'] = 'public'
-          end
         end
 
         # Return true if we can cache the current page
@@ -160,6 +205,9 @@ module Zena
           path = ((path.empty? || path == "/") ? "/index" : URI.unescape(path))
           ext = params[:format].blank? ? 'html' : params[:format]
           path << ".#{ext}" unless path =~ /\.#{ext}(\?\d+|)$/
+          #
+          # QUERY_STRING in cached page ?
+          #
           # Do not cache filename with query or apache will not see it !
           # if cachestamp_format?(params['format'])
           #   path << "?" << make_cachestamp(@node, params['mode'])
@@ -180,114 +228,56 @@ module Zena
           template_url(:mode=>'+popupLayout')
         end
 
+        # Return the window title to use.
+        def title_for_layout
+          return '' unless @node
+          @node.title + (@node.kind_of?(Document) ? ".#{@node.ext}" : '')
+        end
+
         # Use the current visitor as master node.
         def visitor_node
-          @node = visitor.contact
-          zafu_node('@node', BaseContact)
+          @node = visitor.node
+          zafu_node('@node', Node)
         end
 
-        def render_pdf(rendering_egine)
-          # 1. find cached PDF. If found, send data.
-          if @node[:user_id] == visitor[:id]
-            # owner
-            filename = "u#{@node[:user_id]}.pdf"
-          else
-            # group
-            filename = "g#{@node[:rgroup_id]}.pdf"
-          end
-          filepath = @node.asset_path(filename)
-          if File.exist?(filepath)
-            # ok send data
-            data = File.read(filepath)
-            send_data( data , :filename=>@node.title, :type => content_type, :disposition=>'inline')
-          else
-            # generate pdf
-            FileUtils::mkpath(File.dirname(filepath)) unless File.exist?(File.dirname(filepath))
-
-            tempf = Tempfile.new("#{@node[:id]}_#{@node.version.lang}")
-            pdf_path = "#{tempf.path}.pdf"
-            failure  = nil
-            case rendering_egine
-            when 'latex'
-              # Parse data to produce LateX
-              data = data.gsub(/\\input/,'input not supported')
-              data = data.gsub(/\\includegraphics(\*|)(\[[^\{]*\]|)\{([^\}]*?)(\.(\w+)|)\}/) do
-                cmd_name = "includegraphics#{$1}"
-                img_opts = $2
-                img_id   = $3
-                img_mode = $5
-                if id = Node.translate_pseudo_id(img_id)
-                  img = secure(Image) { Image.find_by_id(id) }
-                  if img
-                    if img_mode
-                      format = Iformat[img_mode]
-                      img_path = img.filepath(format)
-                      if !File.exists?(img_path)
-                        img_file = img.file(format) # force rendering of image
-                        img_file.close
-                      end
-                    else
-                      img_path = img.filepath(nil)
-                    end
-                  end
-                  "\\includegraphics#{img_opts}{#{img_path}}"
-                else
-                  "(image '#{img_id}' not found)"
-                end
-              end
-
-              tempf = Tempfile.new("#{@node[:id]}_#{@node.version.lang}")
-              tex_path = "#{tempf.path}.tex"
-              pdf_path = "#{tempf.path}.pdf"
-              File.open(tex_path, 'wb') { |f| f.syswrite(data) }
-              if !system("pdflatex -halt-on-error -output-directory '#{File.dirname(tex_path)}' '#{tex_path}' &> '#{tempf.path}'")
-                failure = tempf.read
-              end
-            when 'fop'
-              # FOP rendering
-              xml_path  = "#{tempf.path}.xml"
-              fo_path   = "#{tempf.path}.fo"
-
-              # write xml to file
-              File.open(xml_path, 'wb') { |f| f.syswrite(data) }
-
-              # find stylesheet path is in the zafu folder
-              xsl_path = template_path.sub(/\.erb\Z/,'.xsl')
-              raise Excpetion.new("xsl content not found #{xsl_path.inspect} while rendering #{template_path.inspect} (node #{@node[:id]})") unless File.exist?(xsl_path)
-
-              # run xsl with 'xml' content and stylesheet ==> 'xsl-fo' file
-              if !system("xsltproc -o '#{fo_path}' '#{xsl_path}' '#{xml_path}' &> '#{tempf.path}'")
-                failure = tempf.read
+        private
+          # This is called before rendering for special formats (pdf) in order to rewrite
+          # urls to localhost (the rendering engine is external to Zena and will need to
+          # make calls to get assets).
+          def baseurl
+            if Zena::ASSET_PORT
+              if Zena::ASSET_PORT == request.port
+                raise Exception.new("Custom rendering not allowed on this process (port == asset_port).")
               else
-                # run fop ==> PDF
-                if !system("fop '#{fo_path}' '#{pdf_path}' &> '#{tempf.path}'")
-                  failure = tempf.read
-                end
+                "http://localhost:#{Zena::ASSET_PORT}"
               end
-            end
-
-            if !failure
-              if data =~ /<!-- xsl_id:(\d+)/
-                # make sure changes in xsl stylesheet expires cached PDF
-                expire_with_ids = visitor.visited_node_ids + [$1.to_i]
-              else
-                expire_with_ids = visitor.visited_node_ids
-              end
-
-              data = File.read(pdf_path)
-              # cache pdf data
-              filepath = filepath[(SITES_ROOT.size)..-1]
-              secure!(CachedPage) { CachedPage.create(:expire_after => nil, :path => filepath, :content_data => data, :node_id => @node[:id], :expire_with_ids => expire_with_ids) }
-              send_data( data , :filename=>@node.title, :type => content_type, :disposition=>'inline')
             else
-              # failure: send log
-              send_data( failure , :filename=>"#{@node.title} - error", :type => 'text/plain', :disposition=>'inline')
+              raise Exception.new("Using custom rendering without an asset host ('asset_port' setting in bricks.yml).")
             end
-            #system("rm -rf #{tempf.path.inspect} #{(tempf.path + '.*').inspect}")
           end
-        end
 
+          def get_render_auth_params
+            {
+              :http_user     => visitor.id,
+              :http_password => visitor.persistence_token,
+              :baseurl       => baseurl
+            }
+          end
       end # ControllerMethods
+
+      module ZafuMethods
+        def r_headers
+          headers = []
+          @params.each do |k, v|
+            headers << "#{k.to_s.inspect} => #{RubyLess.translate_string(self, v)}"
+          end
+          if headers.empty?
+            out ""
+          else
+            out "<% set_headers(#{headers.join(', ')}) %>"
+          end
+        end
+      end # ZafuMethods
     end # Rendering
   end # Use
 end # Zena

data/lib/zena/use/scope_index.rb

@@ -0,0 +1,230 @@
+module Zena
+  module Use
+    module ScopeIndex
+      AVAILABLE_MODELS = []
+
+      def self.models_for_form
+        [''] + AVAILABLE_MODELS.map(&:to_s)
+      end
+
+      module VirtualClassMethods
+        def self.included(base)
+          base.validate :validate_idx_class, :validate_idx_scope
+          base.attr_accessible :idx_class
+          base.attr_accessible :idx_scope
+        end
+
+        protected
+          def validate_idx_class
+            self[:idx_class] = nil if self[:idx_class].blank?
+
+            if model_name = self[:idx_class]
+              if model_name =~ /\A[A-Z][a-zA-Z]+\Z/
+                if klass = Zena.const_get(model_name) rescue NilClass
+                  if klass < Zena::Use::ScopeIndex::IndexMethods
+                    # ok
+                  else
+                    errors.add('idx_class', 'invalid class (should include ScopeIndex::IndexMethods)')
+                  end
+                else
+                  errors.add('idx_class', 'invalid class')
+                end
+              else
+                errors.add('idx_class', 'invalid class name')
+              end
+            end
+          end
+
+          def validate_idx_scope
+            self[:idx_scope] = nil if self[:idx_scope].blank?
+            if scopes = self[:idx_scope]
+              # Try to compile query in instance of class self
+              begin
+                scopes = new_instance.safe_eval self[:idx_scope]
+                if scopes.kind_of?(Hash)
+                  scopes.each do |keys, query|
+                    unless keys.kind_of?(String) &&
+                      (
+                        query.kind_of?(String) ||
+                       (query.kind_of?(Array) && query.inject(true){|s,k| s && k.kind_of?(String)}))
+                      errors.add('idx_scope', "Invalid entry: keys should be a String and query should be a String or an Array of strings (#{keys.inspect} => #{query.inspect})")
+                      next
+                    end
+                    begin
+                      Array(query).each do |q|
+                        real_class.build_query(:all, q,
+                          :node_name       => 'self',
+                          :main_class      => self,
+                          :rubyless_helper => self
+                        )
+                      end
+                    rescue ::QueryBuilder::Error => err
+                      errors.add('idx_scope', "Invalid query: #{err.message}")
+                    end
+                  end
+                else
+                  errors.add('idx_scope', "Invalid type: should be a hash.")
+                end
+              rescue ::RubyLess::Error => err
+                errors.add('idx_scope', "Invalid rubyless: #{err.message}")
+              end
+            end
+          end
+      end # VirtualClassMethods
+
+      module IndexMethods
+        def self.included(base)
+          AVAILABLE_MODELS << base
+
+          class << base
+            attr_accessor :groups
+          end
+
+          base.class_eval do
+            include RubyLess
+            before_validation     :set_site_id
+            validates_presence_of :node_id
+          end
+
+          groups = base.groups = {}
+          base.column_names.each do |name|
+            next if %{created_at updated_at id node_id site_id}.include?(name)
+            if name =~ %r{\A([^_]+)_(.+)\Z}
+              (groups[$1] ||= []) << $2
+              unless $2 == 'id'
+                base.safe_attribute name
+              end
+            end
+          end
+        end
+
+        # The given node has been updated in the owner's project. Update index
+        # entries with this node's content if necessary.
+        def update_with(node, keys, force_create = false)
+          attrs = {}
+          prop_column_names = node.schema.column_names
+          groups = self.class.groups
+          keys.each do |group_key|
+            next unless list = groups[group_key]
+            next unless should_update_group?(group_key, node)
+            list.each do |key|
+              if prop_column_names.include?(key)
+                attrs["#{group_key}_#{key}"] = node.prop[key]
+              elsif node.respond_to?(key)
+                attrs["#{group_key}_#{key}"] = node.send(key)
+              end
+            end
+          end
+
+          if !attrs.empty? || force_create
+            self.attributes = attrs
+            save
+          end
+        end
+
+        # Return true if the indices from the given group should be altered by the node.
+        def should_update_group?(group_key, node)
+          node.id >= self["#{group_key}_id"].to_i
+        end
+
+        def set_site_id
+          self[:site_id] = current_site.id
+        end
+      end # ModelMethods
+
+      module ModelMethods
+        def self.included(base)
+          base.after_save  :update_scope_indices
+          base.safe_context :scope_index => scope_index_proc
+          base.alias_method_chain :rebuild_index!, :scope_index
+        end
+
+        def self.scope_index_proc
+          Proc.new do |helper, receiver, signature|
+            if receiver.respond_to?('idx_class') && receiver.idx_class && klass = Zena.resolve_const(receiver.idx_class) rescue nil
+              {:method => 'scope_index', :nil => true, :class => klass}
+            else
+              raise RubyLess::NoMethodError.new(receiver, receiver, signature)
+            end
+          end
+        end
+
+        # FIXME: test !
+        def rebuild_index_with_scope_index!
+          rebuild_index_without_scope_index!
+          update_scope_indices
+        end
+
+        # Access the index model inside the Project or Section.
+        def scope_index
+          @scope_index ||= begin
+            vclass = virtual_class
+            if vclass && klass = vclass.idx_class
+              if klass = Zena.resolve_const(klass) rescue nil
+                klass.find(:first, :conditions => {:node_id => self.id, :site_id => current_site.id}) || klass.new(:node_id => self.id)
+              else
+                nil
+              end
+            else
+              nil
+            end
+          end
+        end
+
+        protected
+          # Update scope indices (project/section).
+          def update_scope_indices
+            return unless version.status == Zena::Status[:pub]
+            update_scope_indices_on_prop_change
+            update_scope_indices_on_link_change
+           rescue ::QueryBuilder::Error
+             # log and ignore: we cannot recover here ?
+             # FIXME: raise when we have transactional save.
+          end
+
+          def update_scope_indices_on_prop_change
+            if virtual_class && scopes = virtual_class.idx_scope
+              scopes = safe_eval(scopes)
+              return unless scopes.kind_of?(Hash)
+              mapped_scopes = []
+              scopes.each do |keys, queries|
+                # Change key ('project,contract') to an array
+                keys = keys.split(',').map(&:strip) if keys.kind_of?(String)
+                Array(queries).each do |query|
+                  mapped_scopes << [keys, query]
+                end
+              end
+
+              mapped_scopes.each do |keys, query|
+                next unless query.kind_of?(String) && keys.kind_of?(Array) && keys.inject(true) {|s,k| s && k.kind_of?(String) }
+                if query.strip == 'self'
+                  models_to_update = [self]
+                else
+                  models_to_update = find(:all, query) || []
+                end
+
+                models_to_update.each do |m|
+                  if idx_model = m.scope_index
+                    # force creation of index record
+                    idx_model.update_with(self, keys, true)
+                  end
+                end
+              end
+            end
+          end
+
+          def update_scope_indices_on_link_change
+            (@relation_proxies || {}).values.compact.each do |rel|
+              if add_links = rel.add_links
+                add_links.each do |hash|
+                  if node = hash[:node]
+                    node.update_scope_indices
+                  end
+                end
+              end
+            end
+          end
+      end # ModelMethods
+    end # ScopeIndex
+  end # Acts
+end # Zena