zena 0.16.9 → 1.0.0.beta1

data/lib/zena/use/i18n.rb

@@ -1,139 +1,44 @@
 module Zena
   module Use
+    # On load this module changes ENV['LANG'] to 'C' in order to behave consitently without
+    # strange bugs when the locale is changed.
     module I18n
-      module Common
-
-        def format_date(thedate, theformat = nil, tz_name=nil, lang=visitor.lang)
-          format = theformat || '%Y-%m-%d %H:%M:%S'
-          return "" unless thedate
-          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>"
-            end
-          else
-            tz = visitor.tz
-          end
-          if thedate.kind_of?(Time)
-            utc_date = thedate
-            adate = tz.utc_to_local(thedate)
-          elsif thedate.kind_of?(String)
-            begin
-              adate    = Date.parse(thedate)
-              utc_date = adate
-
-            rescue
-              # only return error if there is a format (without = used in sql query)
-              return theformat ? "<span class='parser_error'>invalid date #{thedate.inspect}</span>" : Time.now.strftime('%Y-%m-%d %H:%M:%S')
-            end
-          else
-            adate    = thedate
-            utc_date = adate
-          end
-
-          # TODO: REFACTOR TO something like:
-          # with_locale(lang) do
-          # ...
-          # end
-          if visitor.lang != lang
-            ::I18n.locale = lang
-          end
-
-          if format =~ /^age\/?(.*)$/
-            format = $1.blank? ? _('long_date') : $1
-            # how long ago/in how long is the date
-            # FIXME: when using 'age', set expire_at (+1 minute, +1 hour, +1 day, never)
-            age = (Time.now.utc - utc_date) / 60
-
-            if age > 7 * 24 * 60
-              # far in the past, use strftime
-            elsif age >= 2 * 24 * 60
-              # days
-              return _("%{d} days ago") % {:d => (age/(24*60)).floor}
-            elsif age >= 24 * 60
-              # days
-              return _("yesterday")
-            elsif age >= 2 * 60
-              # hours
-              return _("%{h} hours ago") % {:h => (age/60).floor}
-            elsif age >= 60
-              return _("1 hour ago")
-            elsif age > 2
-              # minutes
-              return _("%{m} minutes ago") % {:m => age.floor}
-            elsif age > 0
-              return _("1 minute ago")
-            elsif age >= -1
-              return _("in 1 minute")
-            elsif age > -60
-              return _("in %{m} minutes") % {:m => -age.ceil}
-            elsif age > -2 * 60
-              return _("in 1 hour")
-            elsif age > -24 * 60
-              return _("in %{h} hours") % {:h => -(age/60).ceil}
-            elsif age > -2 * 24 * 60
-              return _("tomorrow")
-            elsif age > -7 * 24 * 60
-              return _("in %{d} days") % {:d => -(age/(24*60)).ceil}
-            else
-              # too far in the future, use strftime
-            end
-          end
-
-          # month name
-          format = format.gsub("%b", _(adate.strftime("%b")) )
-          format.gsub!("%B", _(adate.strftime("%B")) )
-
-          # weekday name
-          format.gsub!("%a", _(adate.strftime("%a")) )
-          format.gsub!("%A", _(adate.strftime("%A")) )
-
-          if visitor.lang != lang
-            ::I18n.locale = visitor.lang
-          end
-
-          adate.strftime(format)
-        end
-
-      end # Common
+      ::ENV['LANG'] = 'C'
 
       module FormatDate
 
         # display the time with the format provided by the translation of 'long_time'
         def long_time(atime)
-          format_date(atime, _("long_time"))
+          format_date(atime, :format => _("long_time"))
         end
 
         # display the time with the format provided by the translation of 'short_time'
         def short_time(atime)
-          format_date(atime, _("short_time"))
+          format_date(atime, :format => _("short_time"))
         end
 
         # display the time with the format provided by the translation of 'full_date'
         def full_date(adate)
-          format_date(adate, _("full_date"))
+          format_date(adate, :format => _("full_date"))
         end
 
         # display the time with the format provided by the translation of 'long_date'
         def long_date(adate)
-          format_date(adate, _("long_date"))
+          format_date(adate, :format => _("long_date"))
         end
 
         # display the time with the format provided by the translation of 'short_date'
         def short_date(adate)
-          format_date(adate, _("short_date"))
+          format_date(adate, :format => _("short_date"))
         end
 
         # format a date with the given format. Translate month and day names.
         def tformat_date(thedate, fmt)
-          format_date(thedate, _(fmt))
+          format_date(thedate, :format => _(fmt))
         end
       end
 
       module ControllerMethods
-        include Common
 
         def self.included(base)
           FastGettext.add_text_domain 'zena', :path => "#{Zena::ROOT}/locale"
@@ -162,6 +67,7 @@ module Zena
           chosen_lang = nil
           [
             params[:lang],
+            params[:node] ? params[:node][:v_lang] : nil,
             visitor.is_anon? ? session[:lang] : visitor.lang,
             (request.headers['HTTP_ACCEPT_LANGUAGE'] || '').split(',').sort {|a,b| (b.split(';q=')[1] || 1.0).to_f <=> (a.split(';q=')[1] || 1.0).to_f }.map {|l| l.split(';')[0].split('-')[0] },
             (visitor.is_anon? ? visitor.lang : nil), # anonymous user's lang comes last
@@ -218,11 +124,19 @@ module Zena
       end
 
       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)
           base.send(:alias_method_chain, :will_paginate, :i18n) if base.respond_to?(:will_paginate)
         end
 
-        include Common
         include FormatDate
 
         # Enable translations for will_paginate
@@ -230,21 +144,170 @@ 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)
           ApplicationController.send(:_, str)
         end
 
+        def trans(str)
+          ApplicationController.send(:_, str)
+        end
+
+
+        # show language selector
+        def lang_links(opts={})
+          if opts[:wrap]
+            tag_in  = "<#{opts[:wrap]}>"
+            tag_out = "</#{opts[:wrap]}>"
+          else
+            tag_in = tag_out = ''
+          end
+          res = []
+          visitor.site.lang_list.each do |l|
+            if l == visitor.lang
+              if opts[:wrap]
+                res << "<#{opts[:wrap]} class='on'>#{l}" + tag_out
+              else
+                res << "<em>#{l}</em>"
+              end
+            else
+              if params[:controller] == 'nodes'
+                res << tag_in + "<a href='#{zen_path(@node, :lang => l)}'>#{l}</a>"
+              else
+                res << tag_in + link_to(l, params.merge(:lang => l)) + tag_out
+              end
+            end
+          end
+          res.join(opts[:join] || '')
+        end
+      end # ViewMethods
+
+      module ZafuMethods
+
         # 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 check_lang(obj, opts={})
-          wlang = (opts[:text] || '[#LANG]').sub('#LANG', obj.version.lang).sub('_LANG', _(obj.version.lang))
-          obj.version.lang != lang ? "<#{opts[:wrap] || 'span'} class='#{opts[:class] || 'wrong_lang'}'>#{wlang}</#{opts[:wrap] || 'span'}>" : ""
+        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)} %>"
+          else
+            expand_if("#{node}.version.lang != lang")
+          end
         end
 
-      end # ViewMethods
+        def r_load
+          if dict = @params[:dictionary]
+            dict_content, absolute_url, base_path = self.class.get_template_text(dict, @options[:helper], @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}")
+            end
+          else
+            return parser_error("missing 'dictionary'")
+          end
+          expand_with
+        end
 
+        def _(text)
+          if @context[:dict]
+            @context[:dict][text] || helper.send(:_,text)
+          else
+            helper.send(:_,text)
+          end
+        end
+
+        def r_trans
+          # _1 ==> insert this param ==> trans(@params[:text])
+          return nil unless method = get_attribute_or_eval
+          klass = method.klass
+          return parser_error("Cannot translate a '#{klass}'.") unless klass <= String
+
+          if method.literal
+            helper.send(:_, method.literal)
+          else
+            "<%= trans(#{method}) %>"
+          end
+        end
+
+        alias r_t r_trans
+        #def r_trans
+        #  static = true
+        #  if @params[:text]
+        #    text = @params[:text]
+        #  elsif @params[:attr]
+        #    text = "#{node_attribute(@params[:attr])}"
+        #    static = false
+        #  else
+        #    res  = []
+        #    text = ""
+        #    @blocks.each do |b|
+        #      if b.kind_of?(String)
+        #        res  << b.inspect
+        #        text << b
+        #      elsif ['show', 'current_date'].include?(b.method)
+        #        res << expand_block(b, :trans=>true)
+        #        static = false
+        #      else
+        #        # ignore
+        #      end
+        #    end
+        #    unless static
+        #      text = res.join(' + ')
+        #    end
+        #  end
+        #  if static
+        #    _(text)
+        #  else
+        #    "<%= _(#{text}) %>"
+        #  end
+        #end
+
+
+        # show language selector
+        #def r_lang_links
+        #  if wrap_tag = @params[:wrap]
+        #    wrap_tag = Zafu::Markup.new(wrap_tag)
+        #    tag_in  = "<#{opts[:wrap]}>"
+        #    tag_out = "</#{opts[:wrap]}>"
+        #  else
+        #    tag_in = tag_out = ''
+        #  end
+        #  res = []
+        #  visitor.site.lang_list.each do |l|
+        #    if l == visitor.lang
+        #      if opts[:wrap]
+        #        res << "<#{opts[:wrap]} class='on'>#{l}" + tag_out
+        #      else
+        #        res << "<em>#{l}</em>"
+        #      end
+        #    else
+        #      if visitor.is_anon? && params[:prefix]
+        #        res << tag_in + link_to(l, params.merge(:prefix => l)) + tag_out
+        #      else
+        #        res << tag_in + link_to(l, params.merge(:lang => l)) + tag_out
+        #      end
+        #    end
+        #  end
+        #  res.join(opts[:join] || '')
+        #end
+      end
     end # I18n
   end # Use
 end # Zena

data/lib/zena/use/image_builder.rb

@@ -10,7 +10,6 @@ unless defined?(Magick)
       require 'rmagick'
     rescue LoadError
       puts "ImageMagick not found. Using dummy."
-      require 'ftools'
       # Create a dummy magick module
       module Magick
         CenterGravity = OverCompositeOp = MaxRGB = NorthGravity = SouthGravity = nil
@@ -147,7 +146,7 @@ module Zena
       end
 
       def format=(fmt)
-        return unless !dummy? && Magick.formats[fmt.upcase] =~ /w/
+        return if dummy? || !Magick.formats[fmt.upcase] =~ /w/
         @actions << Proc.new {|img| img.format = fmt.upcase; img }
       end
 

data/lib/zena/use/ml_index.rb

@@ -0,0 +1,56 @@
+module Zena
+  module Use
+    module MLIndex
+      module ModelMethods
+        def self.included(base)
+          base.alias_method_chain :rebuild_index!, :multi_lingual
+        end
+
+        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.
+
+          # Skip multi lingual indices
+          @index_langs = []
+
+          # Build std index
+          rebuild_index_without_multi_lingual!
+
+          # Skip std index
+          @skip_std_index = true
+
+          visible_versions.each do |version|
+            self.version = version
+            @properties  = version.prop
+            @index_langs = nil # force rebuild
+            property_index
+          end
+        end
+
+        # Hash used to read current values
+        def index_reader(group_name)
+          if group_name =~ /^ml_/
+            return nil if index_langs.empty?
+            super.merge(:with => {'lang' => index_langs})
+          elsif @skip_std_index
+            nil
+          else
+            super
+          end
+        end
+
+        private
+          def index_langs
+            @index_langs ||= begin
+              v_id = version.id
+              ref_lang = self.ref_lang
+              read = vhash['w'].merge(vhash['r'])
+              current_site.lang_list.select do |lang|
+                (read[lang] || read[ref_lang] || read.values.first) == v_id
+              end
+            end
+          end
+      end # ModelMethods
+    end # MLIndex
+  end # Use
+end # Zena

data/lib/zena/use/nested_attributes_alias.rb

@@ -2,7 +2,7 @@ module Zena
   module Use
     module NestedAttributesAlias
       # Lets you use nested_attributes_alias methods in forms:
-      # <%= text_field 'v_title' %>
+      # <%= text_field 'title' %>
       module ViewMethods
         class InstanceTag < ActionView::Helpers::InstanceTag
           def value(object)
@@ -177,7 +177,7 @@ module Zena
         end
 
         # Same as model method but will not take Proc type resolution. This
-        # could be used by RubyLess to resolve 'v_title' into ==> version ==> title
+        # could be used by RubyLess to resolve 'title' into ==> version ==> title
         # we will see...
         def nested_model_names_for_alias(attribute)
           attribute = attribute.to_s

data/lib/zena/use/node_name.rb

@@ -0,0 +1,94 @@
+module Zena
+  module Use
+    # This module handles the creation and maintenance of a 'node_name' and a path built from
+    # these node_names (fullpath).
+    #
+    # This module has to be included after Workflow so that v_status is properly
+    # set before 'sync_node_name' is called.
+    module NodeName
+      def self.included(base)
+        base.before_validation :sync_node_name
+        base.after_save        :rebuild_children_fullpath
+      end
+
+      private
+        # Store part of the title into the node (used when accessing the database with a
+        # console).
+        def sync_node_name
+          # Sync if we are publishing
+          if ((full_drive? && v_status == Zena::Status[:pub]) ||
+              (can_drive?  && vhash['r'][ref_lang].nil?))
+            self.node_name = title
+          end
+
+          unless node_name.blank?
+            # rebuild cached fullpath / basepath
+            rebuild_fullpath
+            rebuild_basepath
+            # we should use a full rebuild when there are corrupt values,
+            # if fullpath was blank, we have no way to find all children
+            @need_rebuild_children_fullpath = !new_record? && (fullpath_changed? || basepath_changed?) && !fullpath_was.blank?
+          end
+
+          true
+        end
+
+        def rebuild_fullpath
+          return unless new_record? || node_name_changed? || parent_id_changed? || fullpath.nil?
+          if parent = parent(false)
+            path = parent.fullpath.split('/') + [node_name]
+          else
+            path = []
+          end
+          self[:fullpath] = path.join('/')
+        end
+
+        def rebuild_basepath
+          return unless new_record? || node_name_changed? || parent_id_changed? || custom_base_changed? || basepath.nil?
+          if custom_base
+            self[:basepath] = self.fullpath
+          elsif parent = parent(false)
+            self[:basepath] = parent.basepath || ""
+          else
+            self[:basepath] = ""
+          end
+        end
+
+        def rebuild_children_fullpath
+          return true unless @need_rebuild_children_fullpath
+
+          # Update descendants
+          fullpath_new = self.fullpath
+          fullpath_new = "#{fullpath_new}/" if fullpath_was == ''
+          fullpath_re  = fullpath_changed? ? %r{\A#{self.fullpath_was}} : nil
+
+          bases = [self.basepath]
+
+          i = 0
+          batch_size = 100
+          while true
+            list  = Zena::Db.fetch_attributes(['id', 'fullpath', 'basepath', 'custom_base'], 'nodes', "fullpath LIKE #{Zena::Db.quote("#{fullpath_was}/%")} AND site_id = #{current_site.id} ORDER BY fullpath ASC LIMIT #{batch_size} OFFSET #{i * batch_size}")
+
+            break if list.empty?
+            list.each do |rec|
+              rec['fullpath'].sub!(fullpath_re, fullpath_new) if fullpath_re
+              if rec['custom_base'] == Zena::Db::TRUE_RESULT
+                rec['basepath'] = rec['fullpath']
+                bases << rec['basepath']
+              else
+                while rec['fullpath'].size <= bases.last.size
+                  bases.pop
+                end
+                rec['basepath'] = bases.last
+              end
+              id = rec.delete('id')
+              Zena::Db.execute "UPDATE nodes SET #{rec.map {|k,v| "#{Zena::Db.connection.quote_column_name(k)}=#{Zena::Db.quote(v)}"}.join(', ')} WHERE id = #{id}"
+            end
+            # 50 more
+            i += 1
+          end
+          true
+        end
+    end # NodeName
+  end # Use
+end # Zena