zena 1.0.0.rc2 → 1.0.0.rc3

data/lib/zena/use/dates.rb

@@ -1,6 +1,9 @@
+require 'tzinfo'
+
 module Zena
   module Use
     module Dates
+      ISO_DATE_FORMAT = '%Y-%m-%dT%H:%M:%S'
       module Common
 
         # This is like strftime but with better support for i18n (translate day names, month abbreviations, etc)
@@ -8,14 +11,18 @@ module Zena
           return '' if thedate.blank?
 
           theformat, tz_name, lang = opts[:format], opts[:tz], opts[:lang]
-          format = theformat || '%Y-%m-%d %H:%M:%S'
+          format = theformat || _('datetime')
 
           if tz_name
-            # display time local to event's timezone
-            begin
-              tz = TZInfo::Timezone.get(tz_name)
-            rescue TZInfo::InvalidTimezoneIdentifier
-              return "<span class='parser_error'>invalid timezone #{tz_name.inspect}</span>"
+            if tz_name.kind_of?(TZInfo::Timezone)
+              tz = tz_name
+            else
+              # display time local to event's timezone
+              begin
+                tz = TZInfo::Timezone.get(tz_name)
+              rescue TZInfo::InvalidTimezoneIdentifier
+                return "<span class='parser_error'>invalid timezone #{tz_name.inspect}.</span>"
+              end
             end
           else
             tz = visitor.tz
@@ -115,7 +122,12 @@ module Zena
       	  defaults = {  :id=>"datef#{rnd_id}", :button=>"dateb#{rnd_id}", :display=>"dated#{rnd_id}" }
       	  opts = defaults.merge(opts)
       	  date = opts[:value] || obj.safe_send(name)
-      	  value = tformat_date(date,'datetime')
+      	  showsTime = opts[:time] || 'true'
+      	  # TODO: could we pass the format from the view so that it is
+      	  # translated with the view's dictionary during compilation ?
+      	  dateFormat = showsTime == 'true' ? _('datetime') : _('long_date')
+      	  value = format_date(date, :format => dateFormat)
+
       	  # TODO: migrate code to Zafu::Markup (needs Zafu 0.7.7)
       	  # fld = Zafu::Markup.new('input')
       	  # fld.params = (opts[:html] || {}).merge(:name => "node[#{name}]", :id => opts[:id], :type => 'text', :value => value)
@@ -124,17 +136,18 @@ module Zena
           else
             fld = "<input id='#{opts[:id]}' name='node[#{name}]' type='text' value='#{value}' class='#{opts[:class]}'/>"
           end
+
+          js_data << %Q{Calendar.setup({
+              inputField  : "#{opts[:id]}",      // id of the input field
+              button      : "#{opts[:button]}",  // trigger for the calendar (button ID)
+              singleClick : true,
+              showsTime   : #{showsTime},
+              ifFormat    : '#{dateFormat}'
+          });}
+
       		<<-EOL
       <span class="date_box"><img src="/calendar/iconCalendar.gif" id="#{opts[:button]}" alt='#{_('date selection')}'/>
-      #{fld}
-      	<script type="text/javascript">
-          Calendar.setup({
-              inputField     :    "#{opts[:id]}",      // id of the input field
-              button         :    "#{opts[:button]}",  // trigger for the calendar (button ID)
-              singleClick    :    true,
-              showsTime      :    true
-          });
-      </script></span>
+      #{fld}</span>
       		EOL
       	end
       end
@@ -144,15 +157,30 @@ module Zena
         include FormTags
 
         # default date used to filter events in templates
-        def main_date
-          # TODO: timezone for @date ?
-          # .to_utc(_('datetime'), visitor.tz)
-          @main_date ||= params[:date] ? DateTime.parse(params[:date]) : DateTime.now
+        def main_date(tz = visitor.tz)
+          @main_dates ||= {}
+          @main_dates[tz] ||= begin
+            if params[:date]
+              if date = params[:date].to_utc(ISO_DATE_FORMAT, tz)
+                date
+              else
+                # FIXME: when date parsing fails: show an error, not a 500...
+                Node.logger.warn "Could not parse 'date' parameter: #{params[:date].inspect}."
+                # malformed url... 404 ?
+                Time.now.utc
+              end
+            else
+              # no 'date' parameter
+              Time.now.utc
+            end
+          end
         end
 
-        def parse_date(string)
+        def parse_date(string, format = nil, tz = nil)
           return nil unless string
-          DateTime.parse(string) rescue nil
+          format = _('datetime') if format.blank?
+          tz     = visitor.tz if tz.blank?
+          string.to_utc(format, visitor.tz)
         end
       end # ViewMethods
 
@@ -174,21 +202,23 @@ module Zena
       end
 
       module StringMethods
+        SPLIT_STRING = /[^0-9]+/
+        SPLIT_FORMAT = /[^\w%]*%/
         # Parse date : return an utc date from a string and an strftime format. With the current implementation, you can only use '.', '-', ' ' or ':' to separate the different parts in the format.
         def to_utc(format, timezone=nil)
-          elements = split(/(\.|\-|\/|\s|:)+/)
-          format = format.split(/(\.|\-|\/|\s|:)+/)
+          elements = split(SPLIT_STRING)
+          format = format.sub('T', ' ').split(SPLIT_FORMAT)[1..-1]
           if elements
             hash = {}
             elements.each_index do |i|
               hash[format[i]] = elements[i]
             end
-            hash['%Y'] ||= hash['%y'] ? (hash['%y'].to_i + 2000) : Time.now.year
-            hash['%H'] ||= 0
-            hash['%M'] ||= 0
-            hash['%S'] ||= 0
-            if hash['%Y'] && hash['%m'] && hash['%d']
-              res = Time.utc(hash['%Y'], hash['%m'], hash['%d'], hash['%H'], hash['%M'], hash['%S'])
+            hash['Y'] ||= hash['y'] ? (hash['y'].to_i + 2000) : Time.now.year
+            hash['H'] ||= 0
+            hash['M'] ||= 0
+            hash['S'] ||= 0
+            if hash['Y'] && hash['m'] && hash['d']
+              res = Time.utc(hash['Y'], hash['m'], hash['d'], hash['H'], hash['M'], hash['S'])
               begin
                 timezone ? timezone.local_to_utc(res, true) : res
               rescue TZInfo::AmbiguousTime
@@ -247,21 +277,62 @@ module Zena
         end
       end
 
+      module TimeMethods
+
+        def strftime_tz(format, tz = nil)
+          if tz.blank?
+            tz = visitor.tz
+          elsif tz.kind_of?(String)
+            tz = TZInfo::Timezone.get(tz)
+          end
+          tz.utc_to_local(self).strftime(format.to_s)
+        rescue TZInfo::InvalidTimezoneIdentifier
+          ''
+        rescue TZInfo::AmbiguousTime
+          ''
+        end
+      end
+
       module ZafuMethods
         include RubyLess
         safe_method_for Time, :year       => {:class => Number, :pre_processor => true}
-        safe_method_for Time, [:strftime, String] => {:class => String, :pre_processor => true}
-        safe_method :main_date            => :get_date
-        safe_method [:parse_date, String] => {:class => Time, :nil => true, :accept_nil => true}
+        safe_method_for Time, [:strftime, String] => {:class => String, :pre_processor => true, :method => 'strftime_tz'}
+        safe_method_for Time, [:strftime, String, String] => {:class => String, :pre_processor => true, :method => 'strftime_tz'}
+        safe_method_for Time, [:strftime, String, TZInfo::Timezone] => {:class => String, :pre_processor => true, :method => 'strftime_tz'}
+        safe_method_for TZInfo::Timezone, :to_s => {:class => String, :pre_processor => true}
+
+        safe_method :date                     => :get_date
+        safe_method [:date, TZInfo::Timezone] => :get_date
+        safe_method :tz                       => :get_tz
+        safe_method [:parse_date, String]     => {:class => Time, :nil => true, :accept_nil => true}
+        safe_method [:parse_date, String, String] => {:class => Time, :nil => true, :accept_nil => true}
+        safe_method [:parse_date, String, String, TZInfo::Timezone] => {:class => Time, :nil => true, :accept_nil => true}
 
         def get_date(signature)
-          if var = get_context_var('set_var', 'main_date')
+          if var = get_context_var('set_var', 'date')
             {:class => var.klass, :method => var, :nil => var.could_be_nil?}
           else
             {:class => Time, :method => 'main_date'}
           end
         end
 
+        def get_tz(signature)
+          if var = get_context_var('set_var', 'tz')
+            {:class => var.klass, :method => var, :nil => var.could_be_nil?}
+          else
+            {:class => TZInfo::Timezone, :method => 'visitor.tz'}
+          end
+        end
+
+        def r_default
+          if tz_name = @params.delete(:tz)
+            set_tz_code, tz_var = set_tz_var(tz_name)
+            out set_tz_code
+          end
+          super
+        end
+
+
         # date_box seizure setup
         def r_uses_datebox
           if ZENA_CALENDAR_LANGS.include?(visitor.lang)
@@ -270,47 +341,88 @@ module Zena
             l = visitor.site[:default_lang]
           end
 <<-EOL
-<script src="/calendar/calendar.js" type="text/javascript"></script>
-<script src="/calendar/calendar-setup.js" type="text/javascript"></script>
-<script src="/calendar/lang/calendar-#{l}-utf8.js" type="text/javascript"></script>
-<link href="/calendar/calendar-brown.css" media="screen" rel="Stylesheet" type="text/css" />
+<script src="#{helper.send(:compute_public_path, 'calendar', 'calendar', 'js')}" type="text/javascript"></script>
+<script src="#{helper.send(:compute_public_path, 'calendar-setup', 'calendar', 'js')}" type="text/javascript"></script>
+<script src="#{helper.send(:compute_public_path, "calendar-#{l}-utf8", 'calendar/lang', 'js')}" type="text/javascript"></script>
+<link href="#{helper.send(:compute_public_path, "calendar-brown", 'calendar', 'css')}" media="screen" rel="Stylesheet" type="text/css" />
 <% js_data << %Q{Calendar._TT["DEF_DATE_FORMAT"] = "#{_('datetime')}";} -%>
 <% js_data << %Q{Calendar._TT["FIRST_DAY"] = #{_('week_start_day')};} -%>
 EOL
         end
 
         # Select a date for the current context
-        def r_main_date
-          return nil unless code = get_attribute_or_eval
+        # FIXME: Remove ? Is this used ?
+        # def r_set_main_date
+        #   return nil unless code = get_attribute_or_eval
+        #
+        #   if format = @params[:format]
+        #     format = RubyLess.translate_string(self, format)
+        #   else
+        #     format = "'%Y-%m-%d %H:%M:%S'"
+        #   end
+        #
+        #   if code.klass <= String
+        #     if code.could_be_nil?
+        #       code = "(#{code} || '').to_utc(#{format})"
+        #     else
+        #       code = "#{code}.to_utc(#{format})"
+        #     end
+        #     could_be_nil = true
+        #   elsif code.klass <= Time
+        #     could_be_nil = code.could_be_nil?
+        #   else
+        #     return parser_error("should evaluate to a String or Time (found #{code.klass})")
+        #   end
+        #   v = get_var_name('set_var', 'date')
+        #   out "<% #{v} = #{code} %>"
+        #   set_context_var('set_var', 'date', RubyLess::TypedString.new(v, :class => Time, :nil => could_be_nil))
+        #   out expand_with
+        # end
 
-          if format = @params[:format]
-            format = RubyLess.translate_string(self, format)
-          else
-            format = "'%Y-%m-%d %H:%M:%S'"
+        protected
+
+          def set_tz_var(tz_name)
+            tz = TZInfo::Timezone.get(tz_name)
+            tz_var = get_var_name('dates', 'tz')
+
+            set_context_var('set_var', 'tz', RubyLess::TypedString.new(
+              tz_var,
+              :class => TZInfo::Timezone
+            ))
+            return "<% #{tz_var} = TZInfo::Timezone.get(#{tz.name.inspect}) %>", tz_var
+          rescue TZInfo::InvalidTimezoneIdentifier
+            parser_error("Invalid timezone #{tz_name.inspect}.")
           end
 
-          if code.klass <= String
-            if code.could_be_nil?
-              code = "(#{code} || '').to_utc(#{format})"
+          def show_time(method)
+            if tformat = param(:tformat)
+              tformat = RubyLess.translate(self, "t(%Q{#{tformat}})")
+              method = "#{method}, :format => #{tformat}"
+            end
+
+            if hash_arguments = extract_from_params(:tz, :lang, :format)
+              unless @params[:tz]
+                # We might have set_tz_var
+                if tz = get_context_var('set_var', 'tz')
+                  if tz.klass <= TZInfo::Timezone || tz.klass <= String
+                    hash_arguments << ":tz => #{tz}"
+                  end
+                end
+              end
+              "<%= format_date(#{method}, #{hash_arguments.join(', ')}) %>"
+            elsif tformat
+              "<%= format_date(#{method}) %>"
             else
-              code = "#{code}.to_utc(#{format})"
+              "<%= #{method} %>"
             end
-            could_be_nil = true
-          elsif code.klass <= Time
-            could_be_nil = code.could_be_nil?
-          else
-            return parser_error("should evaluate to a String or Time (found #{code.klass})")
           end
-          v = get_var_name('set_var', 'main_date')
-          out "<% #{v} = #{code} %>"
-          set_context_var('set_var', 'main_date', RubyLess::TypedString.new(v, :class => Time, :nil => could_be_nil))
-          out expand_with
-        end
-
-      end
+      end # ZafuMethods
     end # Dates
   end # Use
 end # Zena
 
 # FIXME: where should we put this ?
 String.send(:include, Zena::Use::Dates::StringMethods)
+
+# FIXME: where should we put this ?
+Time.send(:include, Zena::Use::Dates::TimeMethods)

data/lib/zena/use/display.rb

@@ -255,28 +255,28 @@ module Zena
             link_to_with_state(_('preferences'), preferences_user_path(visitor[:id]))
           when 'comments'
             return nil unless visitor.is_admin?
-            link_to_with_state(_('manage comments'), comments_path)
+            link_to_with_state(_('comments'), comments_path)
           when 'users'
             return nil unless visitor.is_admin?
-            link_to_with_state(_('manage users'), users_path)
+            link_to_with_state(_('users'), users_path)
           when 'groups'
             return nil unless visitor.is_admin?
-            link_to_with_state(_('manage groups'), groups_path)
+            link_to_with_state(_('groups'), groups_path)
           when 'relations'
             return nil unless visitor.is_admin?
-            link_to_with_state(_('manage relations'), relations_path)
+            link_to_with_state(_('relations'), relations_path)
           when 'virtual_classes'
             return nil unless visitor.is_admin?
-            link_to_with_state(_('manage classes'), virtual_classes_path)
+            link_to_with_state(_('classes'), virtual_classes_path)
           when 'properties'
             return nil unless visitor.is_admin?
-            link_to_with_state(_('manage properties'), columns_path)
+            link_to_with_state(_('properties'), columns_path)
           when 'iformats'
             return nil unless visitor.is_admin?
             link_to_with_state(_('image formats'), iformats_path)
           when 'sites'
             return nil unless visitor.is_admin?
-            link_to_with_state(_('manage sites'), sites_path)
+            link_to_with_state(_('sites'), sites_path)
           when 'dev'
             return nil unless visitor.is_admin?
             if visitor.dev_skin_id
@@ -394,7 +394,7 @@ module Zena
 
         safe_method [:zazen, String] => :r_zazen
 
-        # As a last resort, if the method cannot be compilated, use <r:show eval='...'/>
+        # As a last resort, if the method does not compile try to use <r:show eval='...'/>
         def self.included(base)
           base.process_unknown :show_eval
         end
@@ -429,28 +429,31 @@ module Zena
             else
               nil
             end
-          elsif node = node(Node)
+          else
+            node = node(Node) || '@node'
             return nil unless attribute = get_attribute_or_eval
             hash_arguments = extract_from_params(:code) || []
 
             hash_arguments.insert(0, ":node => #{node}")
 
             "<%= zazen(#{attribute}, #{hash_arguments.join(', ')}) %>"
-          else
-            parser_error("Cannot access 'Node' context")
           end
         end
 
         # Display an attribute or RubyLess code
         def r_show(code = nil)
-          if node.list_context?
+          if code.nil? && node.list_context?
             @context[:node] = node.move_to("#{node}.first", node.klass.first, :query => node.opts[:query])
             return r_show
-          elsif node.will_be?(String)
-            return "<%= #{node} %>"
           end
 
-          return nil unless method = code || get_attribute_or_eval
+          if method = code || get_attribute_or_eval(false)
+            # ok
+          elsif node.will_be?(String) || node.will_be?(Time)
+            method = RubyLess.translate(self, 'this')
+          else
+            return nil
+          end
 
           klass = method.klass
 
@@ -466,24 +469,24 @@ module Zena
             res = show_string(method)
           end
 
-          res = extract_label(res, @params, @params[:attr])
+          res = extract_label(res, @params[:attr])
 
-          if @params[:blank] == 'hide'
+          if param(:blank) == 'hide'
             "<% if !#{method}.blank? %>#{@markup.wrap(res)}<% end %>"
           else
             res
           end
         end
 
-        def extract_label(res, params, attribute)
-          if (label = params[:label] || params[:tlabel]) && attribute
+        def extract_label(res, attribute)
+          if (label = param(:label) || param(:tlabel)) && attribute
             case label
             when 'true'
               "<label>#{attribute}</label> <span>#{res}</span>"
             when 't'
               "<label>#{trans(attribute)}</label> <span>#{res}</span>"
             else
-              if params[:tlabel]
+              if @params[:tlabel]
                 code = ::RubyLess.translate(self, "t(%Q{#{label}})")
               else
                 code = ::RubyLess.translate_string(self, label)
@@ -511,7 +514,44 @@ module Zena
           else
             list = @params[:list].split(',').map{|e| e.strip}
           end
-          helper.javascript_include_tag(*list)
+
+          out helper.javascript_include_tag(*list)
+          return
+# Experimental: move all scripts at end of file
+          if list.include?('prototype')
+            list -= ['prototype']
+            out helper.javascript_include_tag('prototype')
+          end
+          return if list.empty?
+
+          list = list.map do |e|
+            "Script.load('#{helper.javascript_path(e)}');"
+          end
+          code = %Q{  var Script = {
+    _loadedScripts: [],
+    load: function(script){
+      if (this._loadedScripts.include(script)){
+        return false;
+      }
+      var code = new Ajax.Request(script, {
+        asynchronous: false, method: "GET",
+        evalJS: false, evalJSON: false
+      }).transport.responseText;
+      if (Prototype.Browser.IE) {
+        window.execScript(code);
+      } else if (Prototype.Browser.WebKit){
+        $$("head").first().insert(Object.extend(
+          new Element("script", {type: "text/javascript"}), {text: code}
+        ));
+      } else {
+        window.eval(code);
+      }
+      this._loadedScripts.push(script);
+    }
+  };
+  #{list.join("\n  ")}
+  }
+          out "<% js_data.unshift #{code.inspect} -%>"
         end
 
         # Insert stylesheet asset tags
@@ -613,17 +653,17 @@ module Zena
           return parser_error("not in a list context") unless node.list_context?
           return parser_error("not a Node list") unless node.single_class <= Node
           klass = "#{node.single_class.name}"
-          @blocks = [make(:void, :method => 'void', :text => %Q{<table class='grid'>
+          add_block %Q{<table class='grid'>
             <tr do='#{klass}' do='roles'><th class='role' colspan='\#{columns.size}' do='each' do='name'/></tr>
             <tr do='#{klass}' do='roles' do='each' do='columns'><th do='each' do='name'/></tr>
             <tr do='each'><r:#{klass} do='roles' do='each' do='columns'><td do='each' do='@node.send(name)'/></r:#{klass}></tr>
-          </table>})]
+          </table>}
           expand_with
         end
 
         private
           def show_number(method)
-            if fmt = @params[:format]
+            if fmt = param(:format)
               begin
                 # test argument
                 sprintf(fmt, 123.45)
@@ -639,7 +679,7 @@ module Zena
                 modifier = ''
               end
 
-              if @params[:zero] == 'hide'
+              if param(:zero) == 'hide'
                 "<%= sprintf_unless_zero(#{fmt.inspect}, #{method}#{modifier}) %>"
               else
                 "<%= sprintf(#{fmt.inspect}, #{method}#{modifier}) %>"
@@ -650,23 +690,14 @@ module Zena
           end
 
           def show_string(method)
-            "<%= #{method} %>"
-          end
-
-          def show_time(method)
-            if tformat = @params.delete(:tformat)
-              tformat = RubyLess.translate(self, "t(%Q{#{tformat}})")
-              method = "#{method}, :format => #{tformat}"
-            end
-
-            if hash_arguments = extract_from_params(:tz, :lang, :format)
-              "<%= format_date(#{method}, #{hash_arguments.join(', ')}) %>"
-            elsif tformat
-              "<%= format_date(#{method}) %>"
-            else
+            if param(:h) == 'false'
               "<%= #{method} %>"
+            else
+              "<%= h #{method} %>"
             end
           end
+
+          # show_time is in Dates
       end
     end # Display
   end # Use

data/lib/zena/use/error_rendering.rb

@@ -5,10 +5,8 @@ module Zena
 
         #TODO: test
         def error_messages_for(type, opts={})
-          super unless type == 'node'
-
           obj = opts[:object]
-          return '' if obj.errors.empty?
+          return '' if !obj || obj.errors.empty?
           res = ["<table class='#{opts[:class] || 'errors'}'>"]
           obj.errors.each_error do |er,msg|
             res << "<tr><td><b>#{er}</b></td><td>#{_(msg)}</td></tr>"

data/lib/zena/use/field_index.rb

@@ -10,7 +10,10 @@ module Zena
         end
 
         def property_field_index
-          if version.status == Zena::Status[:pub]
+          # Better rule
+          if new_record? ||
+             version.status == Zena::Status[:pub] ||
+             versions.count == 1
             super
           end
         end