zena 1.2.1 → 1.2.2

data/bricks/grid/lib/bricks/grid.rb

@@ -50,15 +50,16 @@ module Bricks
         table, error = get_table_from_json(node.prop[attribute])
 
         res = prefix + error.to_s
-        uuid = UUIDTools::UUID.random_create.to_s.gsub('-','')
+        uuid = UUIDTools::UUID.random_create.to_s.gsub('-','')[0..6]
         msg = opts[:msg] || _('type to edit')
-        res << "<table id='grid#{uuid}' data-a='node[#{attribute}]' data-msg='#{msg}' class='grid'>\n<tr>"
+        res << "<table id='grid#{uuid}' data-a='node[#{attribute}]' data-msg='#{msg}' class='grid'>"
         if node.can_write? && !opts[:no_edit]
-          js_data << "Grid.make($('grid#{uuid}'));"
+          js_data << "Grid.make('grid#{uuid}');"
         end
 
 
         if table[1][0]
+          res << "\n<tr>"
           table[1][0].each do |heading|
             res << "<th>#{ heading }</th>"
           end

data/bricks/tags/lib/bricks/tags.rb

@@ -1,15 +1,9 @@
 module Bricks
   module Tags
-    class StringHash
-      include RubyLess
-      safe_context [:[], String] => String
-      safe_method :keys => [String]
-    end
-
     def self.included(base)
       base.after_save    :update_tags
       base.safe_context  :tags => ['Link']
-      base.safe_method   :tag_list => String, :tag => String, :tagged => StringHash, :tag_names => [String]
+      base.safe_method   :tag_list => String, :tag => String, :tagged => ::StringHash, :tag_names => [String]
 
       base.class_eval <<-END
         include Bricks::Tags::InstanceMethods

data/bricks/zena/zena/migrate/20120605091558_add_ssl_login_to_site.rb

@@ -0,0 +1,7 @@
+class AddSslLoginToSite < ActiveRecord::Migration
+  def self.up
+  end
+
+  def self.down
+  end
+end

data/bricks/zena/zena/migrate/20120630123551_add_auto_publish_to_group.rb

@@ -0,0 +1,9 @@
+class AddAutoPublishToGroup < ActiveRecord::Migration
+  def self.up
+    add_column :groups, :auto_publish, :boolean
+  end
+
+  def self.down
+    remove_column :groups, :auto_publish
+  end
+end

data/config/bricks.yml

@@ -5,7 +5,7 @@ test:
   captcha:     ON
   acls:        ON
   grid:        ON
-  static:      OFF
+  fs_skin:     OFF
   sphinx:      OFF
   worker:      OFF
   uv:          OFF
@@ -37,7 +37,7 @@ development:
   captcha:  ON
   grid:     ON
   acls:     ON
-  static:   OFF
+  fs_skin:  ON
   sphinx:
     switch: OFF
     activate_if:
@@ -74,7 +74,7 @@ production:
   captcha:  ON
   grid:     ON
   acls:     ON
-  static:   OFF
+  fs_skin:  ON
   single:   OFF
   sphinx:
     switch: OFF

data/config/gems.yml

@@ -18,12 +18,11 @@ gem_plugin:     # upload progress
 simple_xlsx_writer:    # spreadsheet
   lib:          'simple_xlsx'
 
-querybuilder:   '= 1.1.0'
+querybuilder:   '= 1.1.3'
 yamltest:       '= 0.7.0'
 rubyless:       '= 0.8.6'
-property:       '= 2.2.0'
+property:       '= 2.3.2'
 versions:       '= 0.3.1'
-zafu:           '= 0.8.6'
 
 jeweler:
 

data/lib/tasks/zena.rake

@@ -19,7 +19,7 @@ def symlink_assets(from, to)
   #        we could create a symlink in the sites dir to 'shared' -> /var/zena/current/public
   #        and then symlink with "#{host_path}/public/#{dir}" -> "../shared/public/#{dir}"
   #        OR we could symlink /var/zena/current/...
-  ['calendar', 'images', 'javascripts', 'stylesheets'].each do |dir|
+  ['static', 'calendar', 'images', 'javascripts', 'stylesheets'].each do |dir|
     File.unlink("#{to}/public/#{dir}") if File.symlink?("#{to}/public/#{dir}")
     if File.exist?("#{to}/public/#{dir}")
       if File.directory?("#{to}/public/#{dir}")
@@ -355,23 +355,27 @@ namespace :zena do
 
   desc 'Rebuild index for all sites or site defined by HOST param.'
   task :rebuild_index => :environment do
+    # Make sure all bricks are loaded before executing the index rebuild
+    Zena::Use.upgrade_class('Site')
+  
     include Zena::Acts::Secure
     if ENV['HOST']
       sites = [Site.find_by_host(ENV['HOST'])]
     else
       sites = Site.all
     end
+    
     sites.each do |site|
+      Thread.current[:visitor] = site.any_admin
+      
       if ENV['WORKER'] == 'false' || RAILS_ENV == 'test'
         # We avoid SiteWorker by passing nodes.
-        Thread.current[:visitor] = site.any_admin
         nodes = Node.find(:all,
           :conditions => ['site_id = ?', site.id]
         )
         site.rebuild_index(secure_result(nodes))
       else
         # We try to use the site worker.
-        Thread.current[:visitor] = site.any_admin
         site.rebuild_index
       end
     end

data/lib/zafu.rb

@@ -0,0 +1,7 @@
+require 'zafu/all'
+
+if defined?(ActionView)
+  require 'zafu/handler'
+  ActionView::Template.register_template_handler(:zafu, Zafu::Handler)
+  ActionView::Template.register_template_handler(:html, Zafu::Handler)
+end

data/lib/zafu/all.rb

@@ -0,0 +1,21 @@
+require 'zafu/parsing_rules'
+require 'zafu/process/ajax'
+require 'zafu/process/html'
+require 'zafu/process/ruby_less_processing'
+require 'zafu/process/context'
+require 'zafu/process/conditional'
+require 'zafu/process/forms'
+require 'zafu/security'
+
+module Zafu
+  All = [
+    Zafu::ParsingRules,
+    Zafu::Process::HTML,
+    Zafu::Process::Context,
+    Zafu::Process::Conditional,
+    Zafu::Process::RubyLessProcessing,
+    Zafu::Process::Ajax,
+    Zafu::Process::Forms,
+    Zafu::Security,
+  ]
+end

data/lib/zafu/compiler.rb

@@ -0,0 +1,7 @@
+require 'zafu/parser'
+require 'zafu/node_context'
+require 'zafu/all'
+
+module Zafu
+  Compiler = Zafu.parser_with_rules(Zafu::All)
+end

data/lib/zafu/controller_methods.rb

@@ -0,0 +1,58 @@
+require 'zafu/node_context'
+
+module Zafu
+  module ControllerMethods
+    def self.included(base)
+      base.helper Common
+      if RAILS_ENV == 'development'
+        base.class_eval do
+          def render_for_file_with_rebuild(template_path, status = nil, layout = nil, locals = {}) #:nodoc:
+            path = template_path.respond_to?(:path_without_format_and_extension) ? template_path.path_without_format_and_extension : template_path
+            logger.info("Rendering #{path}" + (status ? " (#{status})" : '')) if logger
+            # if params[:rebuild] == 'true'
+              t = self.view_paths.find_template(template_path, 'html')
+              t.previously_last_modified = nil
+            # end
+            render_for_text @template.render(:file => template_path, :locals => locals, :layout => layout), status
+          end
+          alias_method_chain :render_for_file, :rebuild
+        end
+      end
+    end
+
+    def zafu_node(name, klass)
+      zafu_context[:node] = Zafu::NodeContext.new(name, klass)
+    end
+
+    module Common
+      def zafu_context
+        @zafu_context ||= {}
+      end
+
+      # Quote for html attributes (field quote). There might be a better rails alternative to this.
+      def fquote(text)
+        text.to_s.gsub("'",''')
+      end
+
+      # This method should return the template for a given 'src' and
+      # 'base_path'.
+      def get_template_text(path, base_path, opts={})
+        [path, "#{base_path}/#{path}"].each do |p|
+          begin
+            t = self.view_paths.find_template(p, 'html') # FIXME: format ?
+          rescue ActionView::MissingTemplate
+            t = nil
+          end
+          return [t.source, t.path, t.base_path] if t
+        end
+        nil
+      end
+
+      def template_url_for_asset(opts)
+        opts[:src]
+      end
+    end # Common
+
+    include Common
+  end
+end

data/lib/zafu/handler.rb

@@ -0,0 +1,57 @@
+require 'zafu/parser'
+require 'zafu/markup'
+require 'zafu/node_context'
+require 'zafu/template'
+
+module Zafu
+  class Handler < ActionView::TemplateHandler
+    include ActionView::TemplateHandlers::Compilable
+
+    def compile(template)
+      @template = template
+      helper   = Thread.current[:view]
+      if !helper.respond_to?(:zafu_context)
+        raise Exception.new("Please add \"include Zafu::ControllerMethods\" into your ApplicationController for zafu to work properly.")
+      end
+      ast = Zafu::Template.new(template, self)
+      context = helper.zafu_context.merge(:helper => helper)
+      context[:node] ||= get_zafu_node_from_view(helper)
+      rb = ast.to_ruby('@output_buffer', context)
+      ";@erb = %q{#{ast.to_erb(context)}};#{rb}"
+    end
+
+    def get_template_text(path, base_path)
+      if path == @template.path && base_path.nil?
+        [@template.source, @template.path, @template.base_path]
+      else
+        Thread.current[:view].get_template_text(path, base_path)
+      end
+    end
+
+    private
+      def get_zafu_node_from_view(view)
+        controller = view.controller
+        if controller.class.to_s =~ /\A([A-Z]\w+?)s?[A-Z]/
+          ivar = "@#{$1.downcase}"
+          if var = controller.instance_variable_get(ivar.to_sym)
+            name  = ivar
+            klass = var.class
+          elsif var = controller.instance_variable_get(ivar + 's')
+            name = ivar + 's'
+            klass = [var.first.class]
+          end
+          return Zafu::NodeContext.new(name, klass) if name
+        end
+        raise Exception.new("Could not guess main instance variable from request parameters, please add something like \"zafu_node('@var_name', Page)\" in your action.")
+      end
+  end
+end
+
+class ActionView::Template
+  attr_reader :view
+  def render_template_with_zafu(view, local_assigns = {})
+    Thread.current[:view] = view
+    render_template_without_zafu(view, local_assigns)
+  end
+  alias_method_chain :render_template, :zafu
+end

data/lib/zafu/info.rb

@@ -0,0 +1,4 @@
+module Zafu
+  VERSION = '0.8.7'
+end
+

data/lib/zafu/markup.rb

@@ -0,0 +1,309 @@
+require 'zafu/ordered_hash'
+
+module Zafu
+  # A Markup object is used to hold information on the tag used (<li>), it's parameters (.. class='xxx') and
+  # indentation.
+  class Markup
+    EMPTY_TAGS   = %w{meta input link img}
+    STEAL_PARAMS = {
+      'link'   => [:href, :charset, :rel, :type, :media, :rev, :target],
+      'a'      => [:title, :onclick, :target],
+      'script' => [:type, :charset, :defer],
+      :other   => [:class, :id, :style],
+    }
+
+    # Tag used ("li" for example). The tag can be nil (no tag).
+    attr_accessor :tag
+    # Tag parameters (.. class='xxx' id='yyy')
+    attr_accessor :params
+    # Dynamic tag parameters that should not be escaped. For example: (.. class='<%= @node.klass %>')
+    attr_accessor :dyn_params
+    # Ensure wrap is not called more then once unless this attribute has been reset in between
+    attr_accessor :done
+    # Space to insert before tag
+    attr_accessor :space_before
+    # Space to insert after tag
+    attr_accessor :space_after
+    # Keys to remove from zafu and use for the tag itself
+    attr_writer   :steal_keys
+
+    class << self
+
+      # Parse parameters into a hash. This parsing supports multiple values for one key by creating additional keys:
+      # <tag do='hello' or='goodbye' or='gotohell'> creates the hash {:do=>'hello', :or=>'goodbye', :or1=>'gotohell'}
+      def parse_params(text)
+        return OrderedHash.new unless text
+        return text if text.kind_of?(Hash)
+        params = OrderedHash.new
+        rest = text.strip
+        while (rest != '')
+          if rest =~ /(.+?)=/
+            key = $1.strip.to_sym
+            rest = rest[$&.length..-1].strip
+            if rest =~ /('|")(|[^\1]*?[^\\])\1/
+              rest = rest[$&.length..-1].strip
+              key_counter = 1
+              while params[key]
+                key = "#{key}#{key_counter}".to_sym
+                key_counter += 1
+              end
+
+              if $1 == "'"
+                params[key] = $2.gsub("\\'", "'")
+              else
+                params[key] = $2.gsub('\\"', '"')
+              end
+            else
+              # error, bad format, return found params.
+              break
+            end
+          else
+            # error, bad format
+            break
+          end
+        end
+        params
+      end
+    end
+
+    def initialize(tag, params = nil)
+      @done       = false
+      @tag        = tag
+      if params
+        self.params = params
+      else
+        @params = OrderedHash.new
+      end
+      @dyn_params = OrderedHash.new
+    end
+
+    # Set params either using a string (like "alt='time passes' class='zen'")
+    def params=(p)
+      if p.kind_of?(Hash)
+        @params = p
+      else
+        @params = Markup.parse_params(p)
+      end
+    end
+
+    # Another way to set dynamic params (the argument must be a hash).
+    def dyn_params=(h)
+      set_dyn_params(h)
+    end
+
+    # Steal html parameters from an existing hash (the stolen parameters are removed
+    # from the argument)
+    def steal_html_params_from(p)
+      p.delete_if do |k,v|
+        if steal_keys.include?(k) || k =~ /^data-/
+          @params[k] = v
+          true
+        else
+          false
+        end
+      end
+    end
+
+    # Compile dynamic parameters as ERB. A parameter is considered dynamic if it
+    # contains the string eval "#{...}"
+    def compile_params(helper)
+      @params.each do |key, value|
+        if value =~ /^(.*)\#\{(.*)\}(.*)$/
+          @params.delete(key)
+          if $1 == '' && $3 == ''
+            code = RubyLess.translate(helper, $2)
+            if code.literal
+              append_dyn_param(key, helper.form_quote(code.literal.to_s))
+            else
+              append_dyn_param(key, "<%= #{code} %>")
+            end
+          else
+            code = RubyLess.translate_string(helper, value)
+            if code.literal
+              append_dyn_param(key, helper.form_quote(code.literal.to_s))
+            else
+              append_dyn_param(key, "<%= #{code} %>")
+            end
+          end
+        end
+      end
+    end
+
+    # Set dynamic html parameters.
+    def set_dyn_params(hash)
+      hash.each do |k,v|
+        set_dyn_param(k, v)
+      end
+    end
+
+    # Set dynamic html parameters.
+    def set_dyn_param(key, value)
+      @params.delete(key)
+      @dyn_params[key] = value
+    end
+
+    # Set static html parameters.
+    def set_params(hash)
+      hash.each do |k,v|
+        set_param(k, v)
+      end
+    end
+
+    # Set static html parameters.
+    def set_param(key, value)
+      @dyn_params.delete(key)
+      @params[key] = value
+    end
+
+    def prepend_param(key, value)
+      if prev_value = @dyn_params[key]
+        @dyn_params[key] = "#{value} #{prev_value}"
+      elsif prev_value = @params[key]
+        @params[key] = "#{value} #{prev_value}"
+      else
+        @params[key] = value
+      end
+    end
+
+    def append_param(key, value)
+      if prev_value = @dyn_params[key]
+        @dyn_params[key] = "#{prev_value} #{value}"
+      elsif prev_value = @params[key]
+        @params[key] = "#{prev_value} #{value}"
+      else
+        @params[key] = value
+      end
+    end
+
+    def prepend_dyn_param(key, value, conditional = false)
+      spacer = conditional ? '' : ' '
+      if prev_value = @params.delete(key)
+        @dyn_params[key] = "#{value}#{spacer}#{prev_value}"
+      elsif prev_value = @dyn_params[key]
+        @dyn_params[key] = "#{value}#{spacer}#{prev_value}"
+      else
+        @dyn_params[key] = value
+      end
+    end
+
+    def append_attribute(text_to_append)
+      (@append ||= '') << text_to_append
+    end
+
+    def append_dyn_param(key, value, conditional = false)
+      spacer = conditional ? '' : ' '
+      if prev_value = @params.delete(key)
+        @dyn_params[key] = "#{prev_value}#{spacer}#{value}"
+      elsif prev_value = @dyn_params[key]
+        @dyn_params[key] = "#{prev_value}#{spacer}#{value}"
+      else
+        @dyn_params[key] = value
+      end
+    end
+
+    # Define the DOM id from a node context
+    def set_id(erb_id)
+      params[:id] = nil
+      dyn_params[:id] = erb_id
+    end
+
+    # Return true if the given key exists in params or dyn_params.
+    def has_param?(key)
+      params[key] || dyn_params[key]
+    end
+
+    # Duplicate markup and make sure params and dyn_params are duplicated as well.
+    def dup
+      markup = super
+      markup.instance_variable_set(:@params, @params.dup)
+      markup.instance_variable_set(:@dyn_params, @dyn_params.dup)
+      markup.instance_variable_set(:@pre_wrap, @pre_wrap.dup) if @pre_wrap
+      markup
+    end
+
+    # Store some text to insert at the beggining of the tag content on wrap. Inserted
+    # elements are indexed in a hash but only values are shown.
+    def pre_wrap
+      @pre_wrap ||= {}
+    end
+
+    # Wrap the given text with our tag. If 'append' is not empty, append the text
+    # after the tag parameters: <li class='foo'[APPEND HERE]>text</li>.
+    def wrap(text)
+      return text if @done
+
+      text = "#{@pre_wrap.values}#{text}" if @pre_wrap
+
+      if dyn_params[:id]
+        @tag ||= 'div'
+      end
+
+      if @tag
+        if text.blank? && EMPTY_TAGS.include?(@tag)
+          res = "#{@pre_wrap}<#{@tag}#{params_to_html}#{@append}/>"
+        else
+          res = "<#{@tag}#{params_to_html}#{@append}>#{text}</#{@tag}>"
+        end
+      else
+        res = text
+      end
+      @done = true
+
+      (@space_before || '') + res + (@space_after || '')
+    end
+
+    def to_s
+      wrap(nil)
+    end
+
+    def steal_keys
+      @steal_keys || (STEAL_PARAMS[@tag] || []) + STEAL_PARAMS[:other]
+    end
+
+    private
+    if RAILS_ENV == 'test'
+      def params_to_html
+        para = []
+        keys = @dyn_params.keys
+
+        @params.each do |k, v|
+          next if keys.include?(k)
+
+          if !v.to_s.include?("'")
+            para << " #{k}='#{v}'"
+          else
+            para << " #{k}=\"#{v.to_s.gsub('"','\"')}\"" # TODO: do this work in all cases ?
+          end
+        end
+
+        keys.each do |k|
+          para << " #{k}='#{@dyn_params[k]}'"
+        end
+
+        para
+      end
+    else
+      def params_to_html
+        para = []
+        keys = @dyn_params.keys
+
+        @params.each do |k,v|
+          next if keys.include?(k)
+
+          if !v.to_s.include?("'")
+            para << " #{k}='#{v}'"
+          else
+            para << " #{k}=\"#{v.to_s.gsub('"','\"')}\"" # TODO: do this work in all cases ?
+          end
+        end
+
+        @dyn_params.each do |k,v|
+          para << " #{k}='#{v}'"
+        end
+
+        para
+      end
+    end
+
+  end
+end