zena 1.2.1 → 1.2.2

data/bricks/static/lib/bricks/static.rb

@@ -1,151 +0,0 @@
-module Bricks
-  module Static
-    ELEM = "([a-zA-Z_]+)"
-    ELEM_REGEXP = %r{^#{ELEM}$}
-    SECURE_PATH_REGEXP = %r{^[a-zA-Z_/]+$}
-    STATIC_SKIN_REGEXP = %r{^#{ELEM}-#{ELEM}$}
-    ZAFU_URL_REGEXP    = %r{^\$#{ELEM}-#{ELEM}/(.+)$}
-    BRICK_NAME_REGEXP = %r{^#{RAILS_ROOT}/bricks/#{ELEM}/zena/skins$}
-
-    module ControllerMethods
-      def self.included(base)
-        base.alias_method_chain :get_template_text, :static
-        base.alias_method_chain :template_url_for_asset, :static
-        base.alias_method_chain :get_best_template, :static
-      end
-
-      def get_template_text_with_static(path, section_id = nil)
-        if path =~ ZAFU_URL_REGEXP
-          brick_name, skin_name, path = $1, $2, $3
-          text_from_static(brick_name, skin_name, path)
-        elsif section_id.nil? && @static_brick_name && @static_skin_name
-          text_from_static(@static_brick_name, @static_skin_name, path)
-        else
-          get_template_text_without_static(path, section_id)
-        end
-      end
-
-      def template_url_for_asset_with_static(opts)
-        # TODO
-        template_url_for_asset_without_static(opts)
-      end
-
-      def get_best_template_with_static(kpaths, format, mode, skin)
-        return get_best_template_without_static(kpaths, format, mode, skin) unless static = skin.z_static
-        if idx_template = IdxTemplate.first(
-           :conditions => ["tkpath IN (?) AND format = ? AND mode #{mode ? '=' : 'IS'} ? AND (skin_id = ? OR static = ?) AND site_id = ?",
-              kpaths, format, mode, skin.id, static, skin.site_id],
-            :order     => "length(tkpath) DESC, skin_id DESC"
-          )
-          if idx_template.path.nil?
-            template = secure(Template) { Template.find(idx_template.node_id) }
-            get_best_template_without_static(kpaths, format, mode, skin, template)
-          elsif static =~ STATIC_SKIN_REGEXP
-            @static_brick_name, @static_skin_name = $1, $2
-            if idx_template.path =~ SECURE_PATH_REGEXP
-              zafu_url = "$#{@static_brick_name}-#{@static_skin_name}/#{idx_template.path}"
-              template = Template.new
-              template.tkpath = idx_template.tkpath
-              [zafu_url, template]
-            end
-          end
-        end
-      end
-
-      # TODO
-      # Asset resolution: route = /static/static-blog/img/style.css
-      # ===> static brick ==> brick path
-      # ===> blog/img/style.css ==> brick path/zena/skins/  blog/img/style.css
-      # Cache in public directory
-      # FIXME: clear_cache should erase /home/static
-
-      private
-        def text_from_static(brick_name, skin_name, path)
-          if path =~ SECURE_PATH_REGEXP
-            abs_path = File.join(
-              RAILS_ROOT, 'bricks', brick_name,
-              'zena', 'skins', skin_name, path + '.zafu')
-            File.exist?(abs_path) ? File.read(abs_path) : nil
-          end
-        end
-    end # ControllerMethods
-
-    module SkinMethods
-      def self.included(base)
-        base.property do |p|
-          p.string 'z_static'
-        end
-
-        base.validate :validate_z_static
-      end
-
-      private
-        def validate_z_static
-          if !(z_static.nil? || z_static =~ STATIC_SKIN_REGEXP)
-            errors.add(:z_static, _('invalid'))
-          end
-          true
-        end
-    end # SkinMethods
-
-    module SiteMethods
-      def self.included(base)
-        base.alias_method_chain :rebuild_index, :static
-      end
-
-      def rebuild_index_with_static(nodes = nil, page = nil, page_count = nil)    if !page
-          Zena::SiteWorker.perform(self, :rebuild_static_index, nil)
-        end
-        rebuild_index_without_static(nodes, page, page_count)
-      end
-
-      def rebuild_static_index
-        Zena::Db.execute "DELETE FROM idx_templates WHERE node_id IS NULL AND site_id = #{id}"
-        Bricks.paths_for('zena/skins').each do |p|
-          if p =~ BRICK_NAME_REGEXP
-            brick_name = $1
-            list = []
-            Dir.foreach(p) do |skin_name|
-              if skin_name =~ ELEM_REGEXP
-                build_static_index(brick_name, skin_name, "#{p}/#{skin_name}")
-              end
-            end
-          end
-        end
-      end
-
-      private
-        def build_static_index(brick_name, skin_name, path)
-          # path = absolute path
-          # 1. Find all templates
-          Dir.foreach(path) do |elem|
-            next if elem =~ /^\./
-            elem_path = File.join(path, elem)
-            if File.directory?(elem_path)
-              build_static_index(brick_name, skin_name, elem_path)
-            elsif elem =~ Template::MODE_FORMAT_FROM_TITLE
-              # 2. Get klass, mode, format
-              klass    = $1
-              mode     = $4.blank? ? nil : $4
-              format   = $6 || 'html'
-              idx_path = elem_path[%r{^#{RAILS_ROOT}/bricks/#{brick_name}/zena/skins/#{skin_name}/(.+)\.zafu$}, 1]
-              # 3. Get kpath
-              if idx_path && vclass = VirtualClass[klass]
-                tkpath = vclass.kpath
-
-                # 4. insert idx_template entry (kpath, site_id, mode, format, path relative to bricks/brick/zena/skins/skin_name)
-                IdxTemplate.create(
-                  :tkpath  => tkpath,
-                  :mode    => mode,
-                  :format  => format,
-                  :site_id => id,
-                  :static  => "#{brick_name}-#{skin_name}",
-                  :path    => idx_path
-                )
-              end
-            end
-          end
-        end
-    end # SiteMethods
-  end # Static
-end # Bricks

data/bricks/static/zena/init.rb

@@ -1 +0,0 @@
-Zena.use Bricks::Static

data/bricks/static/zena/migrate/20110702010330_add_static_to_idx_templates.rb

@@ -1,12 +0,0 @@
-class AddStaticToIdxTemplates < ActiveRecord::Migration
-  def self.up
-    add_column :idx_templates, :static, :string, :limit => 30
-    add_column :idx_templates, :path, :string, :limit => 300
-    add_index  :idx_templates, [:static], :name => "index_idx_templates_on_static"
-  end
-
-  def self.down
-    remove_index  :idx_templates, :name => "index_idx_templates_on_static"
-    remove_column :idx_templates, :static
-  end
-end

data/bricks/static/zena/test/unit/static_test.rb

@@ -1,33 +0,0 @@
-require File.dirname(__FILE__) + '/../../../../../test/test_helper'
-
-class StaticTest < Zena::Unit::TestCase
-
-  context 'A Skin' do
-    setup do
-      login(:lion)
-    end
-
-    subject do
-      secure(Node) { nodes(:wikiSkin) }
-    end
-
-    should 'have z_static prop' do
-      subject.z_static = 'foo'
-      assert_equal 'foo', subject.prop['z_static']
-    end
-
-    should 'allow brick-skin values' do
-      assert subject.update_attributes(:z_static => 'static-blog')
-    end
-
-    should 'allow nil values' do
-      assert subject.update_attributes(:z_static => 'static-blog')
-      assert subject.update_attributes(:z_static => nil)
-    end
-
-    should 'not allow any value' do
-      assert !subject.update_attributes(:z_static => '../foo-/bar/..')
-      assert_equal 'invalid', subject.errors[:z_static]
-    end
-  end # A Skin
-end

data/lib/zena/parser/zafu_rules.rb

@@ -1,244 +0,0 @@
-=begin
-FIXME: remove if tests pass.
-=end
-module Zena
-  module Parser
-
-    module ZafuRules
-      attr_reader :context
-      # This callback is run just after the block is initialized (Parser#initialize).
-      def start(mode)
-        # html_tag
-        @html_tag = @options.delete(:html_tag)
-        @html_tag_params = parse_params(@options.delete(:html_tag_params))
-
-        # end_tag
-        @end_tag = @html_tag || @options.delete(:end_do) || @options.delete(:end_tag) || "r:#{@method}"
-        @end_tag_count  = 1
-
-        # code indentation
-        @space_before = @options[:space_before]
-        @options.delete(:space_before)
-
-        # form capture (input, select, textarea, form)
-        @options[:form] ||= true if @method == 'form'
-
-        # puts "[#{@space_before}(#{@method})#{@space_after}]"
-        if @params =~ /\A([^>]*?)do\s*=('|")([^\2]*?[^\\])\2([^>]*)\Z/
-          #puts $~.to_a.inspect
-          # we have a sub 'do'
-          @params = parse_params($1)
-          @sub_do = $3 # this is used by replace_with
-
-          opts = {:method=>$3, :params=>$4}
-
-          # the matching zafu tag will be parsed by the last 'do', we must inform it to halt properly :
-          opts[:end_do] = @end_tag
-
-          sub = make(:void, opts)
-          @space_after = sub.instance_variable_get(:@space_after)
-          sub.instance_variable_set(:@space_after,"")
-        else
-          @params = parse_params(@params)
-        end
-
-        # set name used for include/replace from html_tag if not allready set by superclass
-        @name = @options[:name] || @params[:name] || @params[:id] || @html_tag_params[:id]
-
-        if !@html_tag && (@html_tag = @params.delete(:tag))
-          # get html tag parameters from @params
-          @html_tag_params = {}
-          [:class, :id].each do |k|
-            next unless @params[k]
-            @html_tag_params[k] = @params.delete(k)
-          end
-        end
-
-        if @method == 'include'
-          include_template
-        elsif mode == :tag && !sub
-          scan_tag
-        elsif !sub
-          enter(mode)
-        end
-      end
-
-      # Dummy method. We only insert the error here so that 'r_include' can be overwriten
-      # to enable recursion.
-      def r_include
-        parser_error("missing 'template' attribute", 'include')
-      end
-
-
-      def before_parse(text)
-        text.gsub('<%', '&lt;%').gsub('%>', '%&gt;')
-      end
-
-      # scan rules
-      def scan
-        # puts "SCAN(#{@method}): [#{@text}]"
-        if @text =~ /\A([^<]*?)(^ *|)</m
-          flush $1
-          eat $2
-          if @text[1..1] == '/'
-            store $2
-            scan_close_tag
-          elsif @text[0..3] == '<!--'
-            scan_html_comment(:space_before=> $2)
-          elsif @text[0..8] == '<![CDATA['
-            flush '<![CDATA['
-          else
-            scan_tag(:space_before=> $2)
-          end
-        else
-          # no more tags
-          flush
-        end
-      end
-
-      def scan_close_tag
-        if @text =~ /\A<\/([^>]+)>( *\n+|)/m
-          # puts "CLOSE:[#{$&}]}" # ztag
-          # closing tag
-          if $1 == @end_tag
-            @end_tag_count -= 1
-            if @end_tag_count == 0
-              if @end_tag == 'script'
-                flush $& # keep closing tag
-              else
-                eat $&
-              end
-              @space_after = $2
-              leave
-            else
-              # keep the tag (false alert)
-              flush $&
-            end
-          elsif $1[0..1] == 'r:'
-            # /rtag
-            eat $&
-            if $1 != @end_tag
-              # error bad closing rtag
-              store "<span class='parser_error'>#{$&.gsub('<', '&lt;').gsub('>','&gt;')} should be &lt;/#{@end_tag}&gt;</span>"
-            end
-            leave
-          else
-            # other html tag closing
-            flush $&
-          end
-        else
-          # error
-          flush
-        end
-      end
-
-      def scan_html_comment(opts={})
-        if @text =~ /\A<!--\|(.*?)-->/m
-          # zafu html escaped
-          eat $&
-          @text = opts[:space_before] + $1 + @text
-        elsif @text =~ /\A<!--.*?-->/m
-          # html comment
-          flush $&
-        else
-          # error
-          flush
-        end
-      end
-
-      def scan_tag(opts={})
-        # puts "TAG(#{@method}): [#{@text}]"
-        if @text =~ /\A<r:([\w_]+)([^>]*?)(\/?)>/
-          # puts "RTAG:#{$~.to_a.inspect}" # ztag
-          eat $&
-          opts.merge!(:method=>$1, :params=>$2)
-          opts.merge!(:text=>'') if $3 != ''
-          make(:void, opts)
-        #elsif @text =~ /\A<(\w+)([^>]*?)do\s*=('([^>]*?[^\\]|)'|"([^>]*?[^\\]|)")([^>]*?)(\/?)>/
-        elsif @text =~ /\A<(\w+)([^>]*?)do\s*=('|")([^\3]*?[^\\])\3([^>]*?)(\/?)>/
-          #puts "DO:#{$~.to_a.inspect}" # do tag
-          eat $&
-          opts.merge!(:method=> $4, :html_tag=>$1, :html_tag_params=>$2, :params=>$5)
-          opts.merge!(:text=>'') if $6 != ''
-          make(:void, opts)
-        elsif @options[:form] && @text =~ /\A<(input|select|textarea|form)([^>]*?)(\/?)>/
-          eat $&
-          method = $1 == 'form' ? 'form_tag' : $1 # <form> ==> r_form_tag, <r:form> ==> r_form
-          opts.merge!(:method=>method, :params=>$2)
-          opts.merge!(:text=>'') if $3 != ''
-          opts.merge!(:end_tag=>'form') if method == 'form_tag'
-          make(:void, opts)
-        elsif @text =~ /\A<(\w+)([^>]*?)id\s*=('[^>]*?[^\\]'|"[^>]*?[^\\]")([^>]*?)(\/?)>/
-          #puts "ID:#{$~.to_a.inspect}" # id tag
-          eat $&
-          opts.merge!(:method=>'void', :html_tag=>$1, :params=>{:id => $3[1..-2]}, :html_tag_params=>"#{$2}id=#{$3}#{$4}")
-          opts.merge!(:text=>'') if $5 != ''
-          make(:void, opts)
-        elsif @end_tag && @text =~ /\A<#{@end_tag}([^>]*?)(\/?)>/
-          #puts "SAME:#{$~.to_a.inspect}" # simple html tag same as end_tag
-          flush $&
-          @end_tag_count += 1 unless $2 == '/'
-        elsif @text =~ /\A<(link|img|script)/
-          #puts "HTML:[#{$&}]" # html
-          make(:asset)
-        elsif @text =~ /\A<style>/
-          flush $&
-          make(:style)
-        elsif @text =~ /\A[^>]*?>/
-          # html tag
-          #puts "OTHER:[#{$&}]"
-          store opts[:space_before]
-          flush $&
-        else
-          # never closed tag
-          flush
-        end
-      end
-
-      def scan_asset
-        # puts "ASSET(#{object_id}) [#{@text}]"
-        if @text =~ /\A<(\w*)([^>]*?)(\/?)>/
-          eat $&
-          @method = 'rename_asset'
-          @html_tag = @end_tag = $1
-          closed = ($3 != '')
-          @params = parse_params($2)
-          if closed
-            leave(:asset)
-          elsif @html_tag == 'script'
-            enter(:void)
-          else
-            enter(:inside_asset)
-          end
-        else
-          # error
-          @method = 'void'
-          flush
-        end
-      end
-
-      def scan_inside_asset
-        if @text =~ /\A(.*?)<\/#{@end_tag}>/m
-          flush $&
-          leave(:asset)
-        else
-          # never ending asset
-          flush
-        end
-      end
-
-      def scan_style
-        if @text =~ /\A(.*?)<\/style>/m
-          flush $&
-          @method = 'rename_asset'
-          @html_tag = 'style'
-          leave(:style)
-        else
-          # error
-          @method = 'void'
-          flush
-        end
-      end
-    end # ZafuRules
-  end # Parser
-end # Zena

data/lib/zena/parser/zafu_tags.rb

@@ -1,198 +0,0 @@
-# This should be removed (it is used by zazen but I do not know why)
-module Zena
-  module Parser
-    module ZafuTags
-      attr_accessor :html_tag, :html_tag_params, :name, :sub_do
-
-      # Replace the 'original' element in the included template with our new version.
-      def replace_with(new_obj)
-        super
-        html_tag_params    = new_obj.html_tag_params
-        [:class, :id].each do |sym|
-          html_tag_params[sym] = new_obj.params[sym] if new_obj.params.include?(sym)
-        end
-        @html_tag = new_obj.html_tag || @html_tag
-        @html_tag_params.merge!(html_tag_params)
-        if new_obj.params[:method]
-          @method   = new_obj.params[:method] if new_obj.params[:method]
-        elsif new_obj.sub_do
-          @method = 'void'
-        end
-      end
-
-      # Pass the caller's 'html_tag' and 'html_tag_params' to the included part.
-      def include_part(obj)
-        obj.html_tag = @html_tag || obj.html_tag
-        obj.html_tag_params = !@html_tag_params.empty? ? @html_tag_params : obj.html_tag_params
-        @html_tag = nil
-        @html_tag_params = {}
-        super(obj)
-      end
-
-      def empty?
-        super && @html_tag_params == {} && @html_tag.nil?
-      end
-
-      def before_render
-        return unless super
-        @html_tag_done = false
-        unless @html_tag
-          if @html_tag = @params.delete(:tag)
-            @html_tag_params = {}
-            [:id, :class].each do |k|
-              next unless @params[k]
-              @html_tag_params[k] = @params.delete(k)
-            end
-          end
-        end
-        # [each] is run many times with different roles. Some of these change html_tag_params.
-        @html_tag_params_bak = @html_tag_params.dup
-        true
-      end
-
-      def after_render(text)
-        res = render_html_tag(super)
-        @html_tag_params = @html_tag_params_bak
-        res
-      end
-
-      def inspect
-        @html_tag_done = false
-        res = super
-        if @html_tag
-          if res =~ /\A\[(\w+)(.*)\/\]\Z/m
-            res = "[#{$1}#{$2}]<#{@html_tag}/>[/#{$1}]"
-          elsif res =~ /\A\[([^\]]+)\](.*)\[\/(\w+)\]\Z/m
-            res = "[#{$1}]#{render_html_tag($2)}[/#{$3}]"
-          end
-        end
-        res
-      end
-
-      def params_to_html(params)
-        para = []
-        params.each do |k,v|
-          if v.kind_of?(Array)
-            # Array is used to indicate that the code is already escaped.
-            para << " #{k}=#{v}"
-          elsif !v.to_s.include?("'")
-            para << " #{k}='#{v}'"
-          else
-            para << " #{k}=\"#{v.to_s.gsub('"','\"')}\"" # TODO: do this work in all cases ?
-          end
-        end
-        # puts para.inspect
-        para.sort.join('')
-      end
-
-      def render_html_tag(text,*append)
-        append ||= []
-        return text if @html_tag_done
-        if @html_tag
-          if text.blank? && ['meta','input'].include?(@html_tag)
-            res = "<#{@html_tag}#{params_to_html(@html_tag_params || {})}#{append.join('')}/>"
-          else
-            res = "<#{@html_tag}#{params_to_html(@html_tag_params || {})}#{append.join('')}>#{text}</#{@html_tag}>"
-          end
-        else
-          res = text
-        end
-        @html_tag_done = true
-        return res if @context && @context[:only] && !@context[:only].include?(:string)
-        (@space_before || '') + res + (@space_after || '')
-      end
-
-      def r_ignore
-        @html_tag_done = true
-        ''
-      end
-
-      alias r_ r_ignore
-
-      def r_rename_asset
-        return expand_with unless @html_tag
-        case @html_tag
-        when 'link'
-          key = :href
-          if @params[:rel].downcase == 'stylesheet'
-            type = :stylesheet
-          else
-            type = :link
-          end
-        when 'style'
-          @html_tag_done = true
-          return expand_with.gsub(/url\(('|")(.*?)\1\)/) do
-            if $2[0..6] == 'http://'
-              $&
-            else
-              quote   = $1
-              new_src = @options[:helper].send(:template_url_for_asset, :base_path => @options[:base_path], :src => $2)
-              "url(#{quote}#{new_src}#{quote})"
-            end
-          end
-        else
-          key = :src
-          type = @html_tag.to_sym
-        end
-
-        src = @params[key]
-        if src && src[0..0] != '/' && src[0..6] != 'http://'
-          @params[key] = @options[:helper].send(:template_url_for_asset, :src => src, :base_path => @options[:base_path], :type => type) || @params[key]
-        end
-
-        res   = "<#{@html_tag}#{params_to_html(@params)}"
-        @html_tag_done = true
-        inner = expand_with
-        if inner == ''
-          res + "/>"
-        else
-          res + ">#{inner}"
-        end
-      end
-
-      def r_form
-        res   = "<#{@html_tag}#{params_to_html(@params)}"
-        @html_tag_done = true
-        inner = expand_with
-        if inner == ''
-          res + "/>"
-        else
-          res + ">#{inner}"
-        end
-      end
-
-      def r_select
-        res   = "<#{@html_tag}#{params_to_html(@params)}"
-        @html_tag_done = true
-        inner = expand_with
-        if inner == ''
-          res + "></#{@html_tag}>"
-        else
-          res + ">#{inner}"
-        end
-      end
-
-      def r_input
-        res   = "<#{@html_tag}#{params_to_html(@params)}"
-        @html_tag_done = true
-        inner = expand_with
-        if inner == ''
-          res + "/>"
-        else
-          res + ">#{inner}"
-        end
-      end
-
-      def r_textarea
-        res   = "<#{@html_tag}#{params_to_html(@params)}"
-        @html_tag_done = true
-        inner = expand_with
-        if inner == ''
-          res + "/>"
-        else
-          res + ">#{inner}"
-        end
-      end
-    end # ZafuTags
-  end # Parser
-end # Zena