zena 1.0.0.beta2 → 1.0.0.beta3

data/lib/zena/use/fulltext.rb

@@ -18,7 +18,7 @@ module Zena
               next unless code = self[idx_group]
 
               begin
-                ruby = RubyLess.translate_string(code, klass)
+                ruby = RubyLess.translate_string(klass, code)
 
                 unless ruby.klass <= String
                   errors.add(idx_group, _('Compilation should produce a String. Found %s.') % ruby.klass.name)

data/lib/zena/use/i18n.rb

@@ -5,6 +5,67 @@ module Zena
     module I18n
       ::ENV['LANG'] = 'C'
 
+      class TranslationDict
+        attr_reader :last_error
+
+        include Zena::Acts::Secure
+        include RubyLess
+
+        # never returns nil
+        safe_method [:get, String] => {:class => String, :accept_nil => true}
+
+        def initialize(node_id)
+          @node_id = node_id
+        end
+
+        def get(key)
+          load!
+          get_without_loading(key)
+        end
+
+        def get_without_loading(key)
+          @dict[key] || ApplicationController.send(:_, key)
+        end
+
+        def load!(text = nil)
+          unless text
+            unless dict = secure(Node) { Node.find(:first, :conditions => {:id => @node_id}) }
+              return error("missing 'dictionary'")
+            end
+            text = dict.prop['text']
+          end
+
+          begin
+            definitions = YAML::load(text)
+            if translations = definitions['translations']
+              if translations.kind_of?(Hash)
+                # ok
+                @dict = translations
+                true
+              else
+                return error("bad 'translations' content (should be a dictionary)")
+              end
+            else
+              return error("missing 'translations' top-level key in dictionary")
+            end
+          rescue
+            return error("invalid dictionary content #{dict.inspect}")
+          end
+
+          class << self
+            alias get get_without_loading
+          end
+
+          true
+        end
+
+        private
+          def error(message)
+            @last_error = message
+            nil
+          end
+      end
+
       module FormatDate
 
         # display the time with the format provided by the translation of 'long_time'
@@ -125,12 +186,7 @@ module Zena
 
       module ViewMethods
         include RubyLess
-        translate = { :class  => String,
-                      :method => 'trans',
-                      :pre_processor => Proc.new {|str| self.rubyless_translate(str)}
-                    }
-        safe_method [:trans, String] => translate
-        safe_method [:t,     String] => translate
+
         safe_method [:lang_links, {:wrap => String, :join => String}] => String
 
         def self.included(base)
@@ -144,11 +200,6 @@ module Zena
           will_paginate_without_i18n(collection, options.merge(:prev_label => _('img_prev_page'), :next_label => _('img_next_page')))
         end
 
-        def self.rubyless_translate(str)
-          str = str.kind_of?(Hash) ? str['text'] : str
-          ApplicationController.send(:_, str)
-        end
-
         # translation of static text using gettext
         # FIXME: I do not know why this is needed in order to have <%= _('blah') %> find the translations on some servers
         def _(str)
@@ -159,6 +210,9 @@ module Zena
           ApplicationController.send(:_, str)
         end
 
+        def load_dictionary(node_id)
+          Zena::Use::I18n::TranslationDict.new(node_id)
+        end
 
         # show language selector
         def lang_links(opts={})
@@ -189,13 +243,16 @@ module Zena
       end # ViewMethods
 
       module ZafuMethods
+        include RubyLess
+        safe_method [:trans, String] => :translate
+        safe_method [:t,     String] => :translate
 
         # Show a little [xx] next to the title if the desired language could not be found. You can
         # use a :text => '(lang)' option. The word 'lang' will be replaced by the real value.
         def r_wrong_lang(params = @params)
           if @blocks.empty? || @method != 'wrong_lang'
             text = params[:text] || %q{<span class='wrong_lang'>[#{v.lang}]</span> }
-            "<%=  #{node}.version.lang == lang ? '' : #{::RubyLess.translate_string(text, self)} %>"
+            "<%=  #{node}.version.lang == lang ? '' : #{::RubyLess.translate_string(self, text)} %>"
           else
             expand_if("#{node}.version.lang != lang")
           end
@@ -203,33 +260,59 @@ module Zena
 
         def r_load
           if dict = @params[:dictionary]
-            dict_content, absolute_url, base_path = self.class.get_template_text(dict, @options[:helper], @options[:base_path])
+            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
-            # TODO: How to use dict offline ?
-            # We could do:
-            # dict_name = get_var_name('dict', 'dictionary')
-            # set_context_var('set_var', 'dictionary', TypedString.new(dict_name, StringDictionary))
-            # Load with <% #{dict_name} = load_dictionary(#{dict_zip}) -%>
-            @context[:dict] ||= {}
-            begin
-              definitions = YAML::load(dict_content)
-              definitions['translations'].each do |elem|
-                @context[:dict][elem[0]] = elem[1]
-              end
-            rescue
-              return parser_error("invalid dictionary content #{dict.inspect}")
+            # Lazy dictionary used for literal resolution
+            dict = TranslationDict.new(doc.id)
+
+            if dict.load!(dict_content)
+              # 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', RubyLess::TypedString.new(dict_name, :class => TranslationDict, :literal => dict))
+
+              # Lazy loading (loads file on first request)
+              out "<% #{dict_name} = load_dictionary(#{doc.id}) -%>"
+            else
+              return parser_error(dict.last_error)
             end
           else
             return parser_error("missing 'dictionary'")
           end
+
           expand_with
         end
 
-        def _(text)
-          if @context[:dict]
-            @context[:dict][text] || helper.send(:_,text)
+        # Resolve RubyLess 't' and 'trans' methods
+        def translate(signature, receiver = nil)
+          return nil unless signature.size == 2 && signature[1] <= String
+
+          dict = get_context_var('set_var', 'dictionary')
+
+          if dict && dict.klass <= TranslationDict
+            { :class  => String,
+              :method => "#{dict}.get",
+              :accept_nil => true,
+              :pre_processor => Proc.new {|str| trans(str)}
+            }
           else
-            helper.send(:_,text)
+            { :class  => String,
+              :method => 'trans',
+              :accept_nil => true,
+              :pre_processor => Proc.new {|str| trans(str)}
+            }
+          end
+        end
+
+        def trans(text)
+          dict = get_context_var('set_var', 'dictionary')
+
+          if dict && dict.klass <= TranslationDict && lit = dict.literal
+            # will call ApplicationController(:_) if key is not found
+            lit.get(text)
+          else
+            helper.send(:_, text)
           end
         end
 
@@ -239,8 +322,12 @@ module Zena
           klass = method.klass
           return parser_error("Cannot translate a '#{klass}'.") unless klass <= String
 
+          dict = get_context_var('set_var', 'dictionary')
+
           if method.literal
-            helper.send(:_, method.literal)
+            trans(method.literal)
+          elsif dict && dict.klass <= TranslationDict
+            "<%= #{dict}.get(#{method}) %>"
           else
             "<%= trans(#{method}) %>"
           end

data/lib/zena/use/query_builder.rb

@@ -30,10 +30,12 @@ module Zena
       #   <r:images in='site'>
       #
       # 2. r_unknown
-      #   try RubyLess.translate(xxxxxx, node) <-- pass context
+      #   try RubyLess.translate(node, xxxxxx) <-- pass context
       #
       # 3. helper (view) tries to resolve safe_method_type as RubyLess or PseudoSQL
       module ZafuMethods
+        QB_KEYS = [:find, :from, :else, :in, :where, :or, :limit, :order]
+
         include RubyLess
         # The :class argument in this method is only used when the String is not a literal value
         safe_method [:find, String] => {:method => 'nil', :pre_processor => :get_finder_type, :class => NilClass}
@@ -55,12 +57,12 @@ module Zena
           klass = [default_query.main_class]
 
           if sql = @params[:eval]
-            sql = RubyLess.translate(sql, self)
+            sql = RubyLess.translate(self, sql)
             unless sql.klass <= String
               return parser_error("Invalid compilation result for #{sql.inspect} (#{sql.klass})")
             end
           elsif sql = @params[:text]
-            sql = RubyLess.translate_string(sql, self)
+            sql = RubyLess.translate_string(self, sql)
           else
             sql = "params[:qb]"
           end
@@ -94,7 +96,7 @@ module Zena
 
         # Select the most pertinent error between RubyLess processing errors and QueryBuilder errors.
         def show_errors
-          if @method =~ / in | where | from / || ([:find, :from, :else, :in, :where, :or, :limit, :order] & @params.keys != [])
+          if @method =~ / in | where | from / || (QB_KEYS & @params.keys != [])
             # probably a query
             @errors.detect {|e| e =~ /Syntax/} || @errors.last
           else
@@ -168,7 +170,7 @@ module Zena
             finder = get_finder(query, count)
 
             if count != :count && else_clause = @params[:else]
-              else_clause = RubyLess.translate(else_clause, self)
+              else_clause = RubyLess.translate(self, else_clause)
 
               if else_clause.klass == Array
                 else_klass = else_clause.opts[:array_content_class]

data/lib/zena/use/query_node.rb

@@ -10,7 +10,6 @@ module Zena
       class StringDictionary
         include RubyLess
         safe_method ['[]', String] => {:class => String, :nil => true}
-        disable_safe_read # ?
       end
 
       module ModelMethods
@@ -29,11 +28,24 @@ module Zena
             self.send(type[:method])
           else
             begin
-              query = self.class.build_query(count, rel, :node_name => 'self', :main_class => Zena::Acts::Enrollable.make_class(self.vclass), :rubyless_helper => (opts[:rubyless_helper] || self))
+              query = self.class.build_query(count, rel,
+                :node_name       => 'self',
+                :main_class      => Zena::Acts::Enrollable.make_class(self.vclass),
+                :rubyless_helper => (opts[:rubyless_helper] || self),
+                :default         => opts[:default]
+              )
+
+              if limit = opts[:limit]
+                query.limit  = " LIMIT #{limit.to_i}"
+                query.offset = " OFFSET #{opts[:offset].to_i}"
+              end
             rescue ::QueryBuilder::Error => err
               return opts[:errors] ? err : nil
             end
-            self.class.do_find(count, eval(query.to_s))
+
+            type = [:all, :first].include?(count) ? :find : count
+
+            self.class.do_find(count, eval(query.to_s(type)))
           end
         end
 
@@ -97,7 +109,14 @@ module Zena
           end
         end
 
-        self.filter_fields = {'id' => {:key => 'zip'}}
+        # How to treat filters like "where id = 45" or "where parent_id = #{params[:parent_id]}"
+        self.filter_fields = {
+          'id'         => {:key => 'zip'},
+          'parent_id'  => {:key => 'zip', :join => ['nodes', 'nodes', 'TABLE2.id = TABLE1.parent_id AND TABLE2.site_id = TABLE1.site_id']},
+          'project_id' => {:key => 'zip', :join => ['nodes', 'nodes', 'TABLE2.id = TABLE1.project_id AND TABLE2.site_id = TABLE1.site_id']},
+          'section_id' => {:key => 'zip', :join => ['nodes', 'nodes', 'TABLE2.id = TABLE1.section_id AND TABLE2.site_id = TABLE1.site_id']}
+        }
+
         add_filter_field 'now', Zena::Db::NOW
 
         # Scope current context with previous context.
@@ -141,6 +160,13 @@ module Zena
               return map_def
             elsif table_def = map_def[:table]
               table_to_use = needs_join_table(*table_def)
+            elsif join_def = map_def[:join]
+              # current table
+              first_table  = table(join_def[0])
+              # filter table
+              add_table('jnode', join_def[1]) # join node
+              table_to_use = table('jnode')
+              add_filter join_def[2].gsub('TABLE1', first_table).gsub('TABLE2', table_to_use)
             else
               table_to_use = table
             end

data/lib/zena/use/rendering.rb

@@ -95,7 +95,7 @@ module Zena
         end
 
         def render_and_cache(options={})
-          opts = {:skin=>@node[:skin], :cache=>true}.merge(options)
+          opts = {:skin => @node[:skin], :cache => true}.merge(options)
           opts[:mode  ] ||= params[:mode]
           opts[:format] ||= params[:format].blank? ? 'html' : params[:format]
           # cleanup before rendering

data/lib/zena/use/search.rb

@@ -44,10 +44,11 @@ module Zena
             page = 1 if page < 1
             search_records(query, options.merge(:offset => (page - 1) * per_page, :limit => per_page))
           else
-            # Removed pagination clause
+            # Removed pagination clause or no pagination
             if query.kind_of?(Hash)
               search_index(query, options)
             else
+              # TODO: should we parse :_find (all, first, count) here ?
               search_text(query, options)
             end
           end
@@ -55,9 +56,9 @@ module Zena
 
         # Execute an index search using query builder. Either provide a full query with 'qb' or 'key'='value' parameters.
         def search_index(params, options = {})
-          query = ::QueryBuilder::Query.new(Node.query_compiler)
-          query.add_table(query.main_table)
-          filters = []
+          count   = (params.delete(:_find) || :all).to_sym
+          node    = options.delete(:node) || current_site.root_node
+          default = options.delete(:default)
 
           unless query = params[:qb]
             query_args = []
@@ -69,10 +70,10 @@ module Zena
             query = "nodes where #{query_args.join(' and ')} in site"
           end
 
-          res = current_site.root_node.find(:all, query, :errors => true, :rubyless_helper => self)
+          res = node.find(count, query, options.merge(:errors => true, :rubyless_helper => self, :default => default))
 
-          if res.kind_of?(Exception)
-            raise ActiveRecord::StatementInvalid.new("Error parsing query #{query.inspect} (#{res.message})")
+          if res.kind_of?(::QueryBuilder::Error)
+            raise ::QueryBuilder::Error.new("Error parsing query #{query.inspect} (#{res.message})")
           else
             return res
           end
@@ -84,6 +85,8 @@ module Zena
             limit = options[:limit] || 20
             Node.find(:all, match_query(query).merge(:offset => offset, :limit => limit))
           else
+            # :default argument not used here
+            options.delete(:default)
             Node.find(:all, match_query(query, options))
           end
         end

data/lib/zena/use/urls.rb

@@ -421,7 +421,7 @@ module Zena
                 # force compilation with Node context. Why ?
                 #node_bak = @context[:node]
                 #@context[:node] = node(Node)
-                #  anchor_name = ::RubyLess.translate_string(anchor_name, self)
+                #  anchor_name = ::RubyLess.translate_string(self, anchor_name)
                 #@context[:node] = node_bak
               end
             else
@@ -445,7 +445,7 @@ module Zena
             anchor = @params[:anchor]
             if anchor && !@params[:href]
               # Link on same page
-              return ::RubyLess.translate_string("##{get_anchor_name(anchor)}", self)
+              return ::RubyLess.translate_string(self, "##{get_anchor_name(anchor)}")
             end
 
             # if opts[:action] == 'edit' && !remote_target
@@ -498,7 +498,7 @@ module Zena
 
             method = "#{method}(#{method_args.join(', ')})"
 
-            ::RubyLess.translate(method, self)
+            ::RubyLess.translate(self, method)
           end
 
           def insert_ajax_args(target, hash_params, action)

data/lib/zena/use/zafu_attributes.rb

@@ -69,7 +69,7 @@ module Zena
                   var  = $1
                   code = params.delete(k)
                   begin
-                    typed_string = ::RubyLess.translate(code, self)
+                    typed_string = ::RubyLess.translate(self, code)
                     set_context_var('set_var', var, typed_string)
                   rescue RubyLess::NoMethodError => err
                     parser_error(err.message, code)
@@ -86,7 +86,7 @@ module Zena
 
                 @if_class_params.each do |class_name, code|
                   begin
-                    typed_string = ::RubyLess.translate(code, self)
+                    typed_string = ::RubyLess.translate(self, code)
                     @markup.append_dyn_param(:class, "<%= (#{typed_string}) ? ' #{class_name}' : '' %>", true)
                   rescue RubyLess::NoMethodError => err
                     text += parser_error(err.message, code)

data/lib/zena/use/zafu_eval.rb

@@ -7,7 +7,7 @@ module Zena
           if !text.kind_of?(String) || @blocks.size > 1
             parser_error("Cannot evaluate RubyLess codes with zafu methods")
           else
-            res = RubyLess.translate(text, self)
+            res = RubyLess.translate(self, text)
             if res.literal.kind_of?(String)
               res.literal
             else

data/lib/zena/use/zafu_safe_definitions.rb

@@ -12,6 +12,7 @@ module Zena
         safe_method :now    => {:method => 'Time.now', :class => Time}
         safe_method_for String, [:gsub, Regexp, String] => {:class => String, :pre_processor => true}
         safe_method_for String, :upcase => {:class => String, :pre_processor => true}
+        safe_method_for Number, :to_s   => {:class => String, :pre_processor => true}
         safe_method_for Object, :blank? => Boolean
 
         safe_method_for Node, [:kind_of?, String] => {:method => 'kpath_match?', :class => Boolean}