zena 1.0.0.beta3 → 1.0.0.rc1

data/lib/zena/use/fulltext.rb

@@ -6,21 +6,32 @@ module Zena
 
       module VirtualClassMethods
         def self.included(base)
-          base.validate :validate_fulltext_indices
+          base.class_eval do
+            validate :validate_fulltext_indices
+            attr_accessible *FULLTEXT_FIELDS
+            property do |p|
+              FULLTEXT_FIELDS.each do |fld|
+                p.string fld
+              end
+            end
+          end
         end
 
         private
           def validate_fulltext_indices
-            # Create a temporary class and load roles
-            klass = Zena::Acts::Enrollable.make_class(self)
+            # Load attached roles to test RubyLess
+            load_attached_roles!
 
             FULLTEXT_FIELDS.each do |idx_group|
-              next unless code = self[idx_group]
+              next unless code = self.prop[idx_group]
 
               begin
-                ruby = RubyLess.translate_string(klass, code)
+                # Use the VirtualClass as a proxy for the real class
+                ruby = RubyLess.translate(self, code)
 
-                unless ruby.klass <= String
+                klass = ruby.klass
+
+                unless klass.kind_of?(Class) && klass <= String
                   errors.add(idx_group, _('Compilation should produce a String. Found %s.') % ruby.klass.name)
                 end
               rescue RubyLess::Error => err
@@ -28,7 +39,6 @@ module Zena
               end
             end
           end
-
       end # VirtualClassMethods
 
       module ModelMethods
@@ -58,7 +68,6 @@ module Zena
           # Prepare roles to add/remove to object.
           def build_fulltext_indices(rebuild_version = nil)
             # Make sure roles are loaded because we compile RubyLess.
-            load_roles!
 
             if rebuild_version
               version = rebuild_version
@@ -69,18 +78,23 @@ module Zena
               version = self.version
             end
 
-            klass = self.virtual_class || {}
+            if vclass = self.virtual_class
+              vclass_prop = vclass.prop
+            else
+              vclass_prop = {}
+            end
 
             FULLTEXT_FIELDS.each do |idx_group|
-              code = klass[idx_group]
-              if !code.blank?
+              code = vclass_prop[idx_group]
+              if code.blank?
+                # default fulltext index
+                version[idx_group] = prop[DEFAULT_INDEX[idx_group]]
+              else
                 begin
-                  version[idx_group] = safe_eval_string(code)
+                  version[idx_group] = safe_eval(code)
                 rescue RubyLess::Error => err
                   errors.add('base', "Error while building '#{idx_group}' index: #{err.message}")
                 end
-              else
-                version[idx_group] = prop[DEFAULT_INDEX[idx_group]]
               end
             end
           end

data/lib/zena/use/html_tags.rb

@@ -14,7 +14,7 @@ module Zena
         #TODO: test
         # Return the list of possible templates
         def form_skins
-          @form_skins ||= secure!(Skin) { Skin.find(:all, :order=>'node_name ASC') }.map {|r| [r.title, r.zip]}
+          @form_skins ||= secure!(Skin) { Skin.find(:all, :order=>'zip ASC') }.map {|r| [r.title, r.zip]}
         end
 
         # Display an input field to select an id. The user can enter an id or a name in the field and the
@@ -153,29 +153,6 @@ module Zena
           res << ">"
           res
         end
-
-
-        # show current path with links to ancestors
-        def show_path(opts={})
-          node = opts.delete(:node) || @node
-          tag  = opts.delete(:wrap) || 'li'
-          join = opts.delete(:join) || ''
-          if tag != ''
-            open_tag  = "<#{tag}>"
-            close_tag = "</#{tag}>"
-          else
-            open_tag  = ""
-            close_tag = ""
-          end
-          nav = []
-          node.ancestors.each do |obj|
-            nav << link_to(obj.title, zen_path(obj, opts))
-          end
-
-          nav << "<a href='#{url_for(zen_path(node))}' class='current'>#{node.title}</a>"
-          res = "#{res}#{open_tag}#{nav.join("#{close_tag}#{open_tag}#{join}")}#{close_tag}"
-        end
-
       end # LinkTags
 
       module ViewMethods

data/lib/zena/use/i18n.rb

@@ -1,3 +1,5 @@
+require 'iconv'
+
 module Zena
   module Use
     # On load this module changes ENV['LANG'] to 'C' in order to behave consitently without
@@ -18,13 +20,13 @@ module Zena
           @node_id = node_id
         end
 
-        def get(key)
+        def get(key, use_global = true)
           load!
-          get_without_loading(key)
+          get_without_loading(key, use_global)
         end
 
-        def get_without_loading(key)
-          @dict[key] || ApplicationController.send(:_, key)
+        def get_without_loading(key, use_global = true)
+          @dict[key] || (use_global && ApplicationController.send(:_, key))
         end
 
         def load!(text = nil)
@@ -258,8 +260,24 @@ module Zena
           end
         end
 
+        def r_iconv
+          return parser_error("missing 'to' parameter") unless to = @params[:to]
+          begin
+            Iconv.iconv(to, 'utf8', 'éaïl')
+          rescue
+            return parser_error("invalid encoding #{to.inspect}")
+          end
+
+          data_name = get_var_name('iconv', 'data')
+          out "<% #{data_name} = capture do %>"
+          out expand_with
+          out "<% end %>"
+          out "<%= Iconv.iconv(#{to.inspect}, 'utf8', #{data_name}) %>"
+        end
+
         def r_load
           if dict = @params[:dictionary]
+            # FIXME: replace @options[:base_path] by @options[:skin_id]
             dict_content, absolute_url, base_path, doc = @options[:helper].send(:get_template_text, dict, @options[:base_path])
             return parser_error("dictionary #{dict.inspect} not found") unless base_path
             # Lazy dictionary used for literal resolution
@@ -270,10 +288,10 @@ module Zena
               dict_name = get_var_name('dictionary', 'dict')
 
               # This is to use in RubyLess translations and static translations in Zafu
-              set_context_var('set_var', 'dictionary', RubyLess::TypedString.new(dict_name, :class => TranslationDict, :literal => dict))
+              set_context_var('set_var', 'dictionary', RubyLess::TypedString.new(dict_name, :class => TranslationDict, :literal => dict, :dictionary_id => doc.id))
 
               # Lazy loading (loads file on first request)
-              out "<% #{dict_name} = load_dictionary(#{doc.id}) -%>"
+              out "<% #{dict_name} = load_dictionary(#{doc.id}) %>"
             else
               return parser_error(dict.last_error)
             end
@@ -294,25 +312,62 @@ module Zena
             { :class  => String,
               :method => "#{dict}.get",
               :accept_nil => true,
-              :pre_processor => Proc.new {|str| trans(str)}
+              :pre_processor => Proc.new {|this, str| trans(str)}
             }
           else
             { :class  => String,
               :method => 'trans',
               :accept_nil => true,
-              :pre_processor => Proc.new {|str| trans(str)}
+              :pre_processor => Proc.new {|this, str| trans(str)}
             }
           end
         end
 
-        def trans(text)
-          dict = get_context_var('set_var', 'dictionary')
+        def trans(text, use_global = true)
+          dictionary = get_context_var('set_var', 'dictionary')
 
-          if dict && dict.klass <= TranslationDict && lit = dict.literal
+          if dictionary && dictionary.klass <= TranslationDict && dict = dictionary.literal
             # will call ApplicationController(:_) if key is not found
-            lit.get(text)
-          else
+            dict.get(text, use_global)
+          elsif use_global
             helper.send(:_, text)
+          else
+            nil
+          end
+        end
+
+        # Translate a string representing a list of values separated with a comma ('dog,cat,house')
+        # to a list of strings.
+        def translate_list(str)
+          if trad = trans(str, false)
+            trad.split(',').map(&:strip)
+          else
+            str.split(',').map(&:strip).map{|v| trans(v)}
+          end
+        end
+
+        def r_block
+          # when saving template, add loaded dictionary
+          if @context[:block] == self
+            if @dict
+              # pass loaded dictionary to ajax templates
+
+              # Save dictionary in template for dynamic uses
+              dict_name = get_var_name('dictionary', 'dict')
+
+              # This is to use in RubyLess translations and static translations in Zafu
+              set_context_var('set_var', 'dictionary', @dict)
+
+              # Lazy loading (loads file on first request)
+              out "<% #{dict_name} = load_dictionary(#{@dict.opts[:dictionary_id]}) %>"
+            end
+            super
+          else
+            @dict = get_context_var('set_var', 'dictionary')
+            res = super
+            @dict = nil
+
+            res
           end
         end
 
@@ -325,7 +380,7 @@ module Zena
           dict = get_context_var('set_var', 'dictionary')
 
           if method.literal
-            trans(method.literal)
+            erb_escape trans(method.literal)
           elsif dict && dict.klass <= TranslationDict
             "<%= #{dict}.get(#{method}) %>"
           else

data/lib/zena/use/kpath.rb

@@ -0,0 +1,60 @@
+module Zena
+  module Use
+    module Kpath
+      module ClassMethods
+        # kpath selector for the current class
+        def ksel
+          self.to_s[0..0]
+        end
+        
+        # Replace Rails subclasses normal behavior
+        def type_condition
+          " #{table_name}.kpath LIKE '#{kpath}%' "
+        end
+      end # ClassMethods
+      
+      module InstanceMethods
+        def self.included(base)
+          base.class_eval do
+            extend ClassMethods
+            
+            before_validation :set_kpath
+          end
+          
+          class << base
+            # The kpath must be set in the class's metaclass so that each sub-class has its own
+            # @kpath.
+            
+            # kpath is a class shortcut to avoid tons of 'OR type = Page OR type = Document'
+            # we build this path with the first letter of each class. The example bellow
+            # shows how the kpath is built:
+            #           class hierarchy
+            #                Node --> N
+            #       Note --> NN          Page --> NP
+            #                    Document   Form   Section
+            #                       NPD      NPF      NPP
+            # So now, to get all Pages, your sql becomes : WHERE kpath LIKE 'NP%'
+            # to get all Documents : WHERE kpath LIKE 'NPD%'
+            # all pages without Documents : WHERE kpath LIKE 'NP%' AND NOT LIKE 'NPD%'
+            attr_accessor :kpath
+
+            def kpath
+              @kpath ||= make_kpath
+            end
+
+            private
+              def make_kpath
+                superclass.respond_to?(:kpath) ? (superclass.kpath + ksel) : ksel
+              end
+          end
+        end
+        
+        private
+          def set_kpath
+            self[:kpath] = self.vclass.kpath if vclass_id_changed? or type_changed?
+            true
+          end
+      end # InstanceMethods
+    end # Kpath
+  end # Use
+end # Zena

data/lib/zena/use/ml_index.rb

@@ -8,7 +8,7 @@ module Zena
 
         def rebuild_index_with_multi_lingual!
           # We call rebuild_index_without_multi_lingual first with our hack
-          # to avoid inclusion order probles with fulltext index.
+          # to avoid inclusion order problems with fulltext index.
 
           # Skip multi lingual indices
           @index_langs = []
@@ -23,7 +23,8 @@ module Zena
             self.version = version
             @properties  = version.prop
             @index_langs = nil # force rebuild
-            property_index
+            # Build ml index for each version
+            rebuild_index_without_multi_lingual!
           end
         end
 
@@ -40,11 +41,12 @@ module Zena
         end
 
         private
+          # Return the list of languages for which the current version is returned.
           def index_langs
             @index_langs ||= begin
-              v_id = version.id
+              v_id     = version.id
               ref_lang = self.ref_lang
-              read = vhash['w'].merge(vhash['r'])
+              read     = vhash['w'].merge(vhash['r'])
               current_site.lang_list.select do |lang|
                 (read[lang] || read[ref_lang] || read.values.first) == v_id
               end

data/lib/zena/use/node_context.rb

@@ -0,0 +1,63 @@
+module Zena
+  module Use
+    class NodeContext < Zafu::NodeContext
+      def node_klass?
+        single_class.kind_of?(VirtualClass)
+      end
+
+      def real_single_class
+        @real_single_class ||= if node_klass?
+          single_class.real_class
+        else
+          single_class
+        end
+      end
+
+      def real_class
+        @real_class ||= if node_klass?
+          klass.kind_of?(Array) ? [klass.first.real_class] : klass.real_class
+        else
+          klass
+        end
+      end
+
+      # Return true if the NodeContext represents an element of the given type. We use 'will_be' because
+      # it is equivalent to 'is_a', but for future objects (during rendering).
+      def will_be?(type)
+        if node_klass?
+          real_single_class <= type
+        else
+          super
+        end
+      end
+      
+      # Get an uppers NodeContext that is of the given class kind.
+      def get(klass)
+        if real_single_class <= klass
+          return self unless list_context?
+
+          res_class = self.klass
+          method = self.name
+          while res_class.kind_of?(Array)
+            method = "#{method}.first"
+            res_class = res_class.first
+          end
+          move_to(method, res_class)
+        elsif @up
+          @up.get(klass)
+        else
+          nil
+        end
+      end
+      
+      # Return the 'real' class name or the superclass name if the current class is an anonymous class.
+      def class_name
+        if list_context?
+          "[#{real_single_class}]"
+        else
+          real_single_class.name
+        end
+      end
+    end
+  end # Use
+end # Zena

data/lib/zena/use/prop_eval.rb

@@ -0,0 +1,90 @@
+module Zena
+  module Use
+    module PropEval
+      module VirtualClassMethods
+        def self.included(base)
+          base.class_eval do
+            validate :validate_prop_eval
+            attr_accessible :prop_eval
+            property do |p|
+              p.string 'prop_eval'
+            end
+          end
+        end
+
+        private
+          def validate_prop_eval
+            # Make sure the class is fully loaded
+            load_attached_roles!
+
+            code = self.prop_eval
+            if code.blank?
+              self.prop_eval = nil
+              return
+            end
+
+            begin
+              ruby = RubyLess.translate(self, code)
+              klass = ruby.klass
+
+              if !klass.kind_of?(Hash)
+                errors.add(:prop_eval, _('Compilation should produce a Hash (Found %s).') % klass)
+              end
+            rescue RubyLess::Error => err
+              errors.add(:prop_eval, err.message)
+            end
+          end
+      end # VirtualClassMethods
+
+      module ModelMethods
+
+        def self.included(base)
+          base.before_validation  :merge_prop_eval
+          base.before_validation  :need_set__id
+          base.before_save        :set__id
+          base.alias_method_chain :rebuild_index!, :prop_eval
+        end
+
+        def rebuild_index_with_prop_eval!
+          merge_prop_eval(true)
+          rebuild_index_without_prop_eval!
+        end
+
+        def need_set__id
+          # Set DB identifier _id with latest title
+          # This is not the best place to put this code, but it's hard to make sure it is only executed
+          # in the correct order (after all properties are evaluated).
+
+          @need_set__id = prop.title_changed?
+          true
+        end
+
+        # TODO: decide if we need to keep this (Zena::Remote makes a much better console the MySQL console...)
+        def set__id
+          self._id = self.title if @need_set__id
+        end
+
+        def merge_prop_eval(force_rebuild = false)
+          return unless self[:vclass_id]
+          return unless prop.changed? || force_rebuild
+
+          if code = vclass.prop_eval
+            hash = safe_eval(code)
+            if hash.kind_of?(Hash)
+              # forces a check on valid properties
+              self.attributes = hash
+              true
+            else
+              errors.add(:base, "Invalid computed properties result (expected a Hash, found #{hash.class}).")
+              false
+            end
+          end
+
+        rescue RubyLess::Error => err
+          errors.add(:base, "Error during evaluation of #{klass} computed properties (#{err.message}).")
+          return false # Will this properly halt the save chain ?
+        end
+      end # ModelMethods
+    end # PropEval
+  end # Use
+end # Zena