zena 0.15.2 → 0.16.0

data/lib/zena/use/i18n.rb

@@ -136,7 +136,10 @@ module Zena
         include Common
 
         def self.included(base)
-          base.before_filter { FastGettext.text_domain = 'zena' }
+          FastGettext.add_text_domain 'zena', :path => "#{Zena::ROOT}/locale"
+          base.prepend_before_filter { FastGettext.text_domain = 'zena' }
+          base.before_filter :set_lang, :check_lang
+          base.after_filter  :set_encoding
         end
 
         # Choose best language to display content.

data/lib/zena/use/node_query_finders.rb

@@ -193,7 +193,7 @@ class NodeQuery < QueryBuilder
     end
 
     def map_literal(value, env = :sql)
-      if value =~ /(.*?)\[(visitor|param):(\w+)\](.*)/
+      if value =~ /(.*?)\[(visitor|param|node):(\w+)\](.*)/
         val_start = $1 == '' ? '' : "#{$1.inspect} +"
         val_end   = $4 == '' ? '' : "+ #{$4.inspect}"
         case $2
@@ -201,6 +201,9 @@ class NodeQuery < QueryBuilder
           value = env == :sql ? insert_bind("#{val_start}Node.zafu_attribute(visitor.contact, #{$3.inspect})#{val_end}") : nil
         when 'param'
           value = env == :sql ? insert_bind("#{val_start}params[:#{$3}].to_s#{val_end}") : "params[:#{$3}]"
+        when 'node'
+          @uses_node_name = true
+          value = env == :sql ? insert_bind("#{val_start}#{@node_name}.safe_read(#{$3.inspect}).to_s#{val_end}") : "#{@node_name}.safe_read(#{$3.inspect})"
         end
       else
         value = env == :sql ? quote(value) : nil
@@ -470,11 +473,12 @@ module Zena
 
         # Find related nodes.
         # See Node#build_find for details on the options available.
-        def find(count, rel)
+        # TODO: replace with rubyless translate ? Is this thing really used anyway ?
+        def find(count, rel, opts = {})
           rel = [rel] if rel.kind_of?(String)
 
-          if rel.size == 1 && self.class.zafu_known_contexts[rel.first]
-            self.send(rel.first)
+          if !opts[:skip_rubyless] && rel.size == 1 && type = RubyLess::SafeClass.safe_method_type_for(self.class, [rel.first])
+            self.send(type[:method])
           else
             query = Node.build_find(count, rel, :node_name => 'self')
             if query.valid?

data/lib/zena/use/refactor.rb

@@ -1,30 +1,17 @@
 module Zena
   module Use
     module Refactor
-      module Common
 
+      module Common
         # TODO: test
         def lang
-          visitor.lang
+          @lang ||= visitor.lang
         end
       end # Common
 
       module ControllerMethods
         include Common
 
-        # TODO: test
-        def visitor
-          @visitor ||= returning(User.make_visitor(:host => request.host, :id => session[:user])) do |user|
-            if session[:user] != user[:id]
-              # changed user (login/logout)
-              session[:user] = user[:id]
-            end
-            if user.is_anon?
-              user.ip = request.headers['REMOTE_ADDR']
-            end
-          end
-        end
-
         # Read the parameters and add errors to the object if it is considered spam. Save it otherwize.
         def save_if_not_spam(obj, params)
           # do nothing (overwritten by plugins like zena_captcha)
@@ -34,9 +21,8 @@ module Zena
       end # ControllerMethods
 
       module ViewMethods
-        include Common
 
-        # TODO: use Rails native helper.
+        include Common
 
         # Quote for html values (input tag, alt attribute, etc)
         def fquote(text)
@@ -175,7 +161,7 @@ ENDTXT
           obj = opts[:node] || @node
           trad_list = []
           (obj.traductions || []).each do |ed|
-            trad_list << "<span#{ ed.lang == lang ? " class='current'" : ''}>" + link_to( _(ed[:lang]), zen_path(obj,:lang=>ed[:lang])) + "</span>"
+            trad_list << "<span#{ ed.lang == visitor.lang ? " class='current'" : ''}>" + link_to( _(ed[:lang]), zen_path(obj,:lang=>ed[:lang])) + "</span>"
           end
           trad_list
         end
@@ -190,11 +176,13 @@ ENDTXT
 
         # This lets helpers render partials
         # TODO: make sure this is the best way to handle this problem.
+
         def render_to_string(*args)
-          @controller ||= begin
+          controller ||= begin
              # ==> this means render_to_string uses a view with everything ApplicationController has...
             ApplicationController.new.instance_eval do
               class << self
+                public :render, :render_to_string
                 attr_accessor :request, :response, :params
               end
 
@@ -209,7 +197,7 @@ ENDTXT
             end
           end
 
-          @controller.send(:render_to_string, *args)
+          controller.render(*args)
         end
 
       end # ViewMethods

data/lib/zena/use/relations.rb

@@ -80,6 +80,7 @@ module Zena
 
         # Return an array of accessor methods for the matched relation alias.
         def relation_alias(match)
+          return nil if match[0] == 'parent_id'
           role     = match[1]
           field    = match[2]
 

data/lib/zena/use/rendering.rb

@@ -13,6 +13,7 @@ module Zena
       module ControllerMethods
         def self.included(base)
           base.send(:helper_attr, :js_data)
+          base.send(:layout, false)
         end
 
         def js_data
@@ -94,11 +95,11 @@ module Zena
           params.delete(:mode)
 
           if opts[:format] != 'html'
-            content_type  = (EXT_TO_TYPE[opts[:format]] || ['application/octet-stream'])[0]
+            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' && ((ENABLE_LATEX && data =~ /\A% (latex)\n/) || (ENABLE_FOP && data =~ /\A<\?(xml)/))
+            if opts[:format] == 'pdf' && ((Zena::ENABLE_LATEX && data =~ /\A% (latex)\n/) || (Zena::ENABLE_FOP && data =~ /\A<\?(xml)/))
               rendering_egine = $1 == 'xml' ? 'fop' : $1
               # 1. find cached PDF. If found, send data.
               if @node[:user_id] == visitor[:id]
@@ -252,6 +253,7 @@ module Zena
 
         # TODO: test
         def popup_layout
+          js_data << "var is_editor = true;"
           template_url(:mode=>'+popupLayout')
         end
 

data/lib/zena/use/search.rb

@@ -0,0 +1,52 @@
+module Zena
+  module Use
+    module Search
+      module NodeClassMethods
+        # Return a hash to do a fulltext query.
+        def match_query(query, opts={})
+          node = opts.delete(:node)
+          if query == '.' && node
+            return opts.merge(
+              :conditions => ["parent_id = ?",node[:id]],
+              :order  => 'name ASC' )
+          elsif !query.blank?
+            if Zena::Db.adapter == 'mysql' && RAILS_ENV != 'test'
+              match  = sanitize_sql(["MATCH (vs.title,vs.text,vs.summary) AGAINST (?) OR nodes.name LIKE ?", query, "#{opts[:name_query] || query.url_name}%"])
+              select = sanitize_sql(["nodes.*, MATCH (vs.title,vs.text,vs.summary) AGAINST (?) + (5 * (nodes.name LIKE ?)) AS score", query, "#{query}%"])
+            else
+              match = sanitize_sql(["nodes.name LIKE ?", "#{query}%"])
+              select = "nodes.*, #{match} AS score"
+            end
+
+            return opts.merge(
+              :select => select,
+              :joins  => "INNER JOIN versions AS vs ON vs.node_id = nodes.id AND vs.status >= #{Zena::Status[:pub]}",
+              :conditions => match,
+              :group      => "nodes.id",
+              :order  => "score DESC, zip ASC")
+          else
+            # error
+            return opts.merge(:conditions => '0')
+          end
+        end
+
+        def search_records(query, opts={})
+          with = opts[:with] || {}
+          with[:site_id] = current_site.id
+          if offset = opts[:offset]
+            limit = opts[:limit] || 20
+            Node.find(:all, match_query(query).merge(:offset => offset, :limit => limit))
+          else
+            if per_page = opts[:per_page]
+              page = opts[:page].to_i
+              page = 1 if page < 1
+              search_records(query, :offset => (page - 1) * per_page, :limit => per_page)
+            else
+              Node.find(:all, match_query(query, opts))
+            end
+          end
+        end
+      end # NodeClassMethods
+    end # Search
+  end # Use
+end # Zena

data/lib/zena/use/test_helper.rb

@@ -1,26 +1,30 @@
+require "authlogic/test_case"
 require 'hpricot'
+
 module Zena
   module Use
     module TestHelper
-      # Set the current site used for testing (mostly to generate ids)
-      def test_site(site_name)
-        $_test_site = site_name
-      end
+      include Zena::Use::Upload::UploadedFile
 
       # Set visitor for unit testing
-      def login(name='anon', site_name = nil)
-        if site_name
-          @visitor = User.make_visitor(:user => name.to_s, :pass => name.to_s, :host => sites_host(site_name))
-        else
-          # find first matching site
-          site = Site.find(:first, :select=>"sites.*, sites.name = '#{site_name}' AS site_ok", :from => "sites, users",
-                         :conditions=>["users.site_id = sites.id AND users.id = ?", users_id(name)], :order => "site_ok DESC")
-          @visitor = User.make_visitor(:site => site, :id => users_id(name))
+      def login(fixture)
+        user =  users(fixture)
+        Thread.current[:visitor] = user = users(fixture)
+        user.ip = '10.0.0.44'
+        $_test_site = user.site.name
+        ::I18n.locale = user.lang
+      end
+
+      # Show object's errors
+      def err(obj)
+        obj.errors.each_error do |er,msg|
+          puts "[#{er}] #{msg}"
         end
+      end
 
-        $_test_site = visitor.site.name
-        @visitor.ip = '10.0.0.127'
-        ::I18n.locale = @visitor.lang
+      # Set the current site used for testing (mostly to generate ids)
+      def test_site(site_name)
+        $_test_site = site_name
       end
 
       def set_date(node_syms, opts = {})
@@ -83,7 +87,7 @@ module Zena
       end
 
       # taken from http://manuals.rubyonrails.com/read/chapter/28#page237 with some modifications
-      def uploaded_file(fname, content_type="application/octet-stream", filename=nil)
+      def uploaded_fixture(fname, content_type="application/octet-stream", filename=nil)
         path = File.join(FILE_FIXTURES_PATH, fname)
         filename ||= File.basename(path)
         # simulate small files with StringIO
@@ -94,42 +98,37 @@ module Zena
           t = Tempfile.new(fname)
           FileUtils.copy_file(path, t.path)
         end
-        (class << t; self; end;).class_eval do
-          alias local_path path if defined?(:path)
-          define_method(:original_filename) { filename }
-          define_method(:content_type) { content_type }
-        end
-        return t
+        uploaded_file(t, filename, content_type)
       end
 
       # JPEG helper
       def uploaded_jpg(fname, filename=nil)
-        uploaded_file(fname, 'image/jpeg', filename)
+        uploaded_fixture(fname, 'image/jpeg', filename)
       end
 
       # PDF helper
       def uploaded_pdf(fname, filename=nil)
-        uploaded_file(fname, 'application/pdf', filename)
+        uploaded_fixture(fname, 'application/pdf', filename)
       end
 
       # TEXT helper
       def uploaded_text(fname, filename=nil)
-        uploaded_file(fname, 'text/plain', filename)
+        uploaded_fixture(fname, 'text/plain', filename)
       end
 
       # PNG helper
       def uploaded_png(fname, filename=nil)
-        uploaded_file(fname, 'image/png', filename)
+        uploaded_fixture(fname, 'image/png', filename)
       end
 
       # TGZ helper
       def uploaded_archive(fname, filename=nil)
-        uploaded_file(fname, 'application/x-gzip', filename)
+        uploaded_fixture(fname, 'application/x-gzip', filename)
       end
 
       # ZIP helper
       def uploaded_zip(fname, filename=nil)
-        uploaded_file(fname, 'application/zip', filename)
+        uploaded_fixture(fname, 'application/zip', filename)
       end
 
       def file_path(filename, mode = 'full', content_id = nil)

data/lib/zena/use/upload.rb

@@ -0,0 +1,188 @@
+require 'uri'
+require 'net/http'
+require 'uuidtools'
+
+module Zena
+  module Use
+    module Upload
+      def self.has_network?
+        response = nil
+        Net::HTTP.new('example.com', '80').start do |http|
+          response = http.head('/')
+        end
+        response.kind_of? Net::HTTPSuccess
+      rescue
+        false
+      end
+
+      module UploadedFile
+        protected
+          def uploaded_file(file, filename = nil, content_type = nil)
+            (class << file; self; end;).class_eval do
+              alias local_path path if respond_to?(:path)  # FIXME: do we need this ?
+              define_method(:original_filename) { filename }
+              define_method(:content_type) { content_type }
+            end
+            file
+          end
+      end # UploadedFile
+
+      module ControllerMethods
+        include UploadedFile
+        protected
+          include ActionView::Helpers::NumberHelper # number_to_human_size
+          def get_attachment
+            att, error = nil, nil
+            if !params['attachment_url'].blank?
+              att, error = fetch_uri(params['attachment_url'])
+            else
+              att = params['attachment']
+            end
+            yield(att, error) if block_given?
+            [att, error]
+          end
+
+        private
+          def fetch_uri(uri_str, max_file_size = 10)
+            max_file_size = max_file_size * 1024 * 1024 # Mo
+
+            # first check head
+            response, error = fetch_response(uri_str, :head)
+            return [nil, error] unless response
+            if response['Content-Length'].nil?
+              return [nil, 'unknown size: cannot fetch url']
+            elsif response['Content-Length'].to_i > max_file_size
+              return [nil, 'size (%s) too big to fetch url' % number_to_human_size(response['Content-Length'].to_i)]
+            end
+
+            # Size is ok, get content
+            response, error = fetch_response(uri_str, :body)
+            return [nil, error] unless response
+
+            tmpf = Tempfile.new('fetch_uri')
+            File.open(tmpf.path, 'wb') do |file|
+              file.write(response.body)
+            end
+            if content_disposition = response['Content-Disposition']
+              original_filename = content_disposition[/filename\s*=\s*('|")(.+)\1/,2]
+            else
+              original_filename = uri_str.split('/').last
+            end
+
+            [uploaded_file(tmpf, original_filename, response['Content-Type'])]
+          end
+
+          def fetch_response(uri_str, type = :body, limit = 10)
+            return [nil, 'too many redirects'] if limit == 0
+            response = nil
+            uri = URI.parse(URI.escape(uri_str))
+            return [nil, 'invalid url'] unless uri.kind_of?(URI::HTTP)
+            Net::HTTP.new(uri.host, uri.port).start do |http|
+              if type == :body
+                response = http.request_get(uri.request_uri)
+              else
+                response = http.head(uri.request_uri)
+              end
+            end
+
+            case response
+            when Net::HTTPSuccess
+              response
+            when Net::HTTPRedirection
+              redirect = response['location']
+              port = (uri.scheme == 'http' && uri.port == 80) ? '' : ":#{uri.port}"
+              redirect = "#{uri.scheme}://#{uri.host}#{port}/#{redirect}" unless redirect =~ /\A\w+:\/\//
+              fetch_response(redirect, type, limit - 1)
+            else
+              [nil, 'not found']
+            end
+          rescue URI::InvalidURIError
+            [nil, 'invalid url']
+          end
+
+          def render_get_uf
+            @uuid = params[:uuid]
+            render :inline => "<%= link_to_function(_('cancel'), \"['file', 'upload_field'].each(Element.toggle);$('upload_field').innerHTML = '';\")%><%= upload_field %>"
+          end
+
+          def render_upload_progress
+            # When using the mod_upload_progress module, this is never hit:
+            # <Location /upload_progress>
+            #   ReportUploads On
+            # </Location>
+            #
+            # When using Mongrel: mimic apache2 mod_upload_progress
+            #
+            # if (!found) {
+            #   response = apr_psprintf(r->pool, "new Object({ 'state' : 'starting' })");
+            # } else if (err_status >= HTTP_BAD_REQUEST  ) {
+            #   response = apr_psprintf(r->pool, "new Object({ 'state' : 'error', 'status' : %d })", err_status);
+            # } else if (done) {
+            #   response = apr_psprintf(r->pool, "new Object({ 'state' : 'done' })");
+            # } else if ( length == 0 && received == 0 ) {
+            #   response = apr_psprintf(r->pool, "new Object({ 'state' : 'starting' })");
+            # } else {
+            #   response = apr_psprintf(r->pool, "new Object({ 'state' : 'uploading', 'received' : %d, 'size' : %d, 'speed' : %d  })", received, length, speed);
+            # }
+            render :update do |page|
+              begin
+                @status = Mongrel::Uploads.check(params[:"X-Progress-ID"])
+                if @status
+                  if @status[:received] != @status[:size]
+                    page << "new Object({ 'state' : 'uploading', 'received' : #{@status[:received]}, 'size' : #{@status[:size]} })"
+                  else
+                    page << "new Object({ 'state' : 'done' })"
+                  end
+                else
+                  #page << "new Object({ 'state' : 'done' })"
+                end
+              rescue NameError
+                page << "new Object({ 'state' : 'upload in progress..' })"
+              end
+            end
+          end
+      end # ControllerMethods
+
+      module ViewMethods
+        UPLOAD_KEY = defined?(Mongrel) ? 'upload_id' : "X-Progress-ID"
+        def upload_form_tag(url_opts, html_opts = {})
+          @uuid = UUIDTools::UUID.random_create.to_s.gsub('-','')
+          html_opts.reverse_merge!(:multipart => true, :id => "UploadForm#{@uuid}")
+          if html_opts[:multipart]
+            html_opts[:onsubmit] = "submitUploadForm('#{html_opts[:id]}', '#{@uuid}');"
+            url_opts[UPLOAD_KEY] = @uuid
+          end
+          if block_given?
+            form_tag( url_opts, html_opts ) do |f|
+              yield(f)
+            end
+          else
+            form_tag( url_opts, html_opts )
+          end
+        end
+
+        def upload_field(opts = {})
+          case opts[:type]
+          when :onclick
+            link = link_to_remote(_("change"), :update=>'upload_field', :url => get_uf_documents_path(:uuid => @uuid), :method => :get, :complete=>"['file', 'upload_field'].each(Element.toggle);")
+            <<-TXT
+<label for='attachment'>#{_('file')}</label>
+<div id="file" class='toggle_div'>#{link}</div>
+<div id="upload_field" class='toggle_div' style='display:none;'></div>
+TXT
+          else
+            attach_file_id, attach_url_id = "af#{@uuid}", "au#{@uuid}"
+            onchange = %Q{onchange="Zena.get_filename(this,'node_v_title'); $('node_v_title').focus(); $('node_v_title').select();"}
+            <<-TXT
+<div id='#{attach_file_id}' class='attach'><label for='attachment' onclick=\"['#{attach_file_id}', '#{attach_url_id}'].each(Element.toggle);\">#{_('file')} / <span class='off'>#{_('url')}</span></label>
+<input  style='line-height:1.5em;' id="attachment#{@uuid}" name="attachment" #{onchange} class='file' type="file" /></div>
+
+<div id='#{attach_url_id}' class='attach' style='display:none;'><label for='url' onclick=\"['#{attach_file_id}', '#{attach_url_id}'].each(Element.toggle);\"><span class='off'>#{_('file')}</span> / #{_('url')}</label>
+<input  style='line-height:1.5em;' size='30' id='attachment_url' type='text' #{onchange} name='attachment_url'/><br/></div>
+TXT
+          end
+        end
+      end # ViewMethods
+    end # Upload
+  end # Use
+end # Zena