spiderfw 0.5.13 → 0.5.14

data/lib/spiderfw/templates/template.rb

@@ -24,6 +24,8 @@ module Spider
         attr_accessor :widgets, :compiled, :id_path
         attr_accessor :request, :response, :owner, :owner_class, :definer_class
         attr_accessor :mode # :widget, ...
+        attr_accessor :assets
+        attr_accessor :runtime_overrides
         attr_reader :overrides, :path, :subtemplates, :widgets
         
         @@registered = {}
@@ -117,6 +119,42 @@ module Spider
                 Spider.find_resource(:views, path, cur_path, owner_classes, search_paths)
             end
             
+            def define_named_asset(name, assets, options={})
+                @named_assets ||= {}
+                @named_assets[name] = { :assets => assets, :options => options }
+            end
+            
+            def named_assets
+                @named_assets || {}
+            end
+            
+            def define_runtime_asset(name, &proc)
+                @runtime_assets ||= {}
+                @runtime_assets[name] = proc
+            end
+            
+            def runtime_assets
+                @runtime_assets || {}
+            end
+            
+            def get_named_asset(name)
+                res = []
+                ass = self.named_assets[name] 
+                raise "Named asset #{name} is not defined" unless ass
+                deps = ass[:options][:depends] if ass[:options]
+                deps = [deps] if deps && !deps.is_a?(Array)
+                if deps
+                    deps.each do |dep|
+                        res += get_named_asset(dep)
+                    end
+                end
+                ass[:assets].each do |a|
+                    attributes = a[3] || {}
+                    res << {:type => a[0], :src => a[1], :app => a[2]}.merge(attributes)
+                end
+                res
+            end
+            
             # An array of possible override tags.
             # Overrides may be used when placing a widget in a template, or when including another template.
             # All except tpl:content may have the _search_ attribute, that is a CSS or XPath expression specifing
@@ -158,6 +196,20 @@ module Spider
                 @@overrides
             end
             
+            def parse_asset_element(el)
+                h = {}
+                el.attributes.to_hash.each do |k, v|
+                    h[k.to_sym] = v
+                end
+                h
+                # end
+                # {
+                #     :type => el.get_attribute('type'),
+                #     :src => el.get_attribute('src'),
+                #     :attributes => el.attributes.to_hash
+                # }
+            end
+            
         end
         
         # Returns the class override_tags
@@ -169,6 +221,7 @@ module Spider
             @path = path
             @widgets = {}
             @subtemplates = {}
+            @widget_templates = []
             @subtemplate_owners = {}
             @id_path = []
             @assets = []
@@ -177,6 +230,7 @@ module Spider
             @overrides = []
             @widgets_overrides = {}
             @widget_procs = {}
+            @runtime_overrides = []
         end
         
         # Sets the scene.
@@ -191,6 +245,16 @@ module Spider
             @path = real_path(path) if path
 #            debug("TEMPLATE LOADING #{@path}")
             cache_path = @path.sub(Spider.paths[:root], 'ROOT').sub(Spider.paths[:spider], 'SPIDER')
+            unless @runtime_overrides.empty?
+                cache_path_dir = File.dirname(cache_path)
+                cache_path_file = File.basename(cache_path, '.shtml')
+                suffix = @runtime_overrides.map{ |ro| ro[0].to_s }.sort.join('+')
+                cache_path = cache_path_dir+'/'+cache_path_file+'+'+suffix+'.shtml'
+                @runtime_overrides.each do |ro|
+                    @overrides += ro[1]
+                    @dependencies << ro[2]
+                end
+            end
             @compiled = self.class.cache.fetch(cache_path) do
                 compile(:mode => @mode)
             end
@@ -200,49 +264,122 @@ module Spider
         def compile(options={})
             compiled = CompiledTemplate.new
             compiled.source_path = @path
-            root = get_el(@path)
+            doc = open(@path){ |f| Hpricot.XML(f) }
+            root = get_el(doc)
             el = process_tags(root)
             @overrides.each{ |o| apply_override(root, o) } if (@overrides)
             root.search('tpl:placeholder').remove # remove empty placeholders
+            owner_class = @owner ? @owner.class : @owner_class
+            @assets += owner_class.assets if owner_class
             res =  root.children ? root.children_of_type('tpl:asset') : []
             res_init = ""
             res.each do |r|
+                @assets << Spider::Template.parse_asset_element(r)
                 r.set_attribute('class', 'to_delete')
-                pr = parse_asset(r.get_attribute('type'), r.get_attribute('src'), r.attributes.to_hash)
-                assets << pr
-                res_init += "@assets << { 
-                    :type => :#{pr[:type]}, 
-                    :src => '#{pr[:src]}',
-                    :path => '#{pr[:path]}',
-                    :if => '#{pr[:if]}'
-                }\n"
             end
+            new_assets = []
+            @assets.each do |ass|
+                a = parse_asset(ass[:type], ass[:src], ass)
+                new_assets += a
+            end
+            @assets = new_assets
             root.search('.to_delete').remove
+            root.search('tpl:assets').each do |ass|
+                if wattr = ass.get_attribute('widgets')
+                    widgets = []
+                    wattr.split(/,\s*/).each do |w|
+                        w_templates = nil
+                        if w =~ /(\.+)\((.+)\)/
+                            w = $1
+                            w_templates = $2.split('|')
+                        end
+                        klass = Spider::Template.get_registered_class(w)
+                        w_templates ||= [klass.default_template]
+                        w_templates.each do |wt| 
+                            t = klass.load_template(wt)
+                            add_widget_template(t, klass)
+                        end
+                    end
+                elsif sattr = ass.get_attribute('src')
+                    sattr.split(/,\s*/).each do |s|
+                        s_template = Spider::Template.new(s)
+                        s_template.owner = @owner
+                        s_template.definer_class = @definer_class
+                        s_template.load(s)
+                        @assets = s_template.assets + @assets
+                    end
+                end
+            end
+            root.search('tpl:assets').remove
             root_block = TemplateBlocks.parse_element(root, self.class.allowed_blocks, self)
+            if doc.children && doc.children[0].is_a?(Hpricot::DocType)
+                root_block.doctype = doc.children[0]
+            end
             options[:root] = true
             options[:owner] = @owner
             options[:owner_class] = @owner_class || @owner.class
             options[:template_path] = @path
+            options[:template] = self
             compiled.block = root_block.compile(options)
             subtemplates.each do |id, sub|
                 sub.owner_class = @subtemplate_owners[id]
-                compiled.subtemplates[id] = sub.compile(options.merge({:mode => :widget})) # FIXME! :mode => :widget is wrong,
-                # it's just a quick kludge
+                compiled.subtemplates[id] = sub.compile(options.merge({:mode => :widget})) # FIXME! :mode => :widget is wrong, it's just a quick kludge
+                @assets += compiled.subtemplates[id].assets
+            end
+            @widget_templates.each do |wt|
+                wt.mode = :widget
+                wt.load
+                # sub_c = sub.compile(options.merge({:mode => :widget}))
+                @assets = wt.compiled.assets + @assets
+            end            
+            
+            seen = {}
+            # @assets.each_index do |i|
+            #     ass = @assets[i]
+            #     if ass[:name]
+            # end
+            @assets.each do |ass|
+                next if seen[ass.inspect]
+                res_init += "@assets << #{ass.inspect}\n"
+                # res_init += "@assets << {
+                #     :type => :#{ass[:type]}, 
+                #     :src => '#{ass[:src]}',
+                #     :path => '#{ass[:path]}',
+                #     :if => '#{ass[:if]}'"
+                # res_init += ",\n :compiled => '#{ass[:compressed]}'" if ass[:compressed]
+                # res_init += "}\n"
+                seen[ass.inspect] = true
             end
             compiled.block.init_code = res_init + compiled.block.init_code
             compiled.devel_info["source.xml"] = root.to_html
+            compiled.assets = @assets + assets
             return compiled
         end
         
         # Processes an asset. Returns an hash with :type, :src, :path.
         def parse_asset(type, src, attributes={})
             # FIXME: use Spider.find_asset ?
+            type = type.to_sym if type
             ass = {:type => type}
-            if (attributes['app'])
-                owner_class = Spider.apps_by_path[attributes['app']]
+            if attributes[:name]
+                named = Spider::Template.get_named_asset(attributes[:name])
+                raise "Can't find named asset #{attributes[:name]}" unless named
+                return named.map{ |nmdass| 
+                    parse_asset(nmdass[:type], nmdass[:src], nmdass)
+                }.flatten
+            end
+            if attributes[:app] == :runtime
+                ass[:runtime] = src
+                return [ass]
+            end
+            if attributes[:app]
+                owner_class = attributes[:app]
+                owner_class = Spider.apps_by_path[owner_class] unless owner_class.is_a?(Module)
             else
                 owner_class = (@owner ? @owner.class : @owner_class )
             end
+            ass[:app] = owner_class.app 
+            # FIXME! @definer_class is not correct for Spider::HomeController
             raise "Asset type not given for #{src}" unless type
             res = Spider.find_resource(type.to_sym, src, @path, [owner_class, @definer_class])
             controller = nil
@@ -252,15 +389,18 @@ module Spider
                 controller = owner_class
             end
             ass[:path] = res.path if res
+            base_url = nil
             if controller.respond_to?(:pub_url)
                 if src[0].chr == '/'
                     # strips the app path from the src. FIXME: should probably be done somewhere else
                     src = src[(2+controller.app.relative_path.length)..-1]
                 end
-                ass[:src] = controller.pub_url + '/' + src
+                base_url = controller.pub_url+'/'
+                
             else
-                ass[:src] = src
+                base_url = ''
             end
+            ass[:src] = base_url + src
             ass_info = self.class.asset_types[type]
             if (ass_info && ass_info[:processor])
                 processor = TemplateAssets.const_get(ass_info[:processor])
@@ -269,14 +409,29 @@ module Spider
             if attributes['sp:if']
                 ass[:if] = Spider::TemplateBlocks::Block.vars_to_scene(attributes['sp:if']).gsub("'", "\\'") 
             end
-            return ass
+            if attributes[:compressed]
+                compressed_res = Spider.find_resource(type.to_sym, attributes[:compressed], @path, [owner_class, @definer_class])
+                ass[:compressed_path] = compressed_res.path
+                ass[:compressed] = base_url+attributes[:compressed]
+            end
+            [:gettext, :media, :if_ie_lte].each do |key|
+                ass[key] = attributes[key] if attributes.key?(key)
+            end
+            return [ass]
         end
         
         # Returns the root node of the template at given path.
         # Will apply overrides and process extends and inclusions.
-        def get_el(path=nil)
-            path ||= @path
-            doc = open(path){ |f| Hpricot.XML(f) }
+        def get_el(path_or_doc=nil)
+            path = nil
+            doc = nil
+            if path_or_doc.is_a?(Hpricot::Doc)
+                doc = path_or_doc
+            else
+                path = path_or_doc
+                path ||= @path
+                doc = open(path){ |f| Hpricot.XML(f) }
+            end
             root = doc.root
             overrides = []
             orig_overrides = @overrides
@@ -304,21 +459,26 @@ module Spider
                     ext_app = ext_widget.app
                 elsif ext_app
                     ext_app = Spider.apps_by_path[ext_app]
-                    ext_owner = ext_widget
+                    ext_owner = ext_app
                 end
                 ext_search_paths = nil
                 if (ext_owner && ext_owner.respond_to?(:template_paths))
                     ext_search_paths = ext_owner.template_paths
                 end 
                 ext = self.class.real_path(ext_src, @path, ext_owner, ext_search_paths)
-                assets = root.children ? root.children_of_type('tpl:asset') : []
+                assets = []
+                if root.children
+                    assets = root.children_of_type('tpl:asset')
+                    assets += root.children_of_type('tpl:assets')
+                end
                 @dependencies << ext
                 tpl = Template.new(ext)
                 root = get_el(ext)
                 root.children_of_type('tpl:asset').each do |ass|
                     ass_src = ass.get_attribute('src')
-                    unless ass_src[0].chr == '/'
-                        ass.set_attribute('src', "/#{ext_app.relative_path}/#{ass_src}")
+                    if ass_src && ass_src[0].chr != '/'
+                        # ass.set_attribute('src', "/#{ext_app.relative_path}/#{ass_src}")
+                        ass.set_attribute('app', ext_app.relative_path)
                     end
                 end
                 @overrides += orig_overrides
@@ -328,15 +488,33 @@ module Spider
                     end
                 end
             else
+                assets_html = ""
                 root.search('tpl:include').each do |incl|
-                    src = real_path(incl.get_attribute('src'))
+                    resource = Spider.find_resource(:views, incl.get_attribute('src'), File.dirname(@path), [@owner.class, @definer_class])
+                    src = resource.path
                     @dependencies << src
                     incl_el = self.get_el(src)
                     assets = incl_el.children ? incl_el.children_of_type('tpl:asset') : []
-                    assets_html = ""
-                    assets.each{ |ass| assets_html += ass.to_html }
-                    incl.swap(assets_html+self.get_el(src).to_html)
+                    assets.each{ |ass| 
+                        ass.set_attribute('class', 'to_delete')
+                        ass_src = ass.get_attribute('src')
+                        if ass_src && ass_src[0].chr != '/'
+                            # ass.set_attribute('src', "/#{resource.definer.relative_path}/#{ass_src}")
+                            ass.set_attribute('app', resource.definer.relative_path)
+                        end
+                        assets_html += ass.to_html 
+                    }
+                    if incl_el.children
+                        incl_el.children_of_type('tpl:assets').each do |asss|
+                            assets_html += asss.to_html
+                        end
+                    end
+                    incl_el.search('.to_delete').remove
+                    incl.swap(incl_el.to_html)
                 end
+                
+                root.search('.to_delete').remove
+                root.innerHTML = assets_html + root.innerHTML
             end
             return root
         end
@@ -501,6 +679,11 @@ module Spider
             @subtemplate_owners[id] = owner
         end
         
+        def add_widget_template(template, owner_class)
+            template.owner_class = owner_class
+            @widget_templates << template
+        end
+        
         
         def load_subtemplate(id) # :nodoc:
             load unless loaded?
@@ -520,7 +703,6 @@ module Spider
                     else
                         ov.remove_attribute('widget')
                     end
- #                   debugger
                     @widgets_overrides[first] ||= []
                     @widgets_overrides[first] << ov
                 else
@@ -530,7 +712,6 @@ module Spider
         end
         
         def overrides_for(widget_id)
-#            debugger
             @widgets_overrides[widget_id] || []
         end
         
@@ -550,8 +731,13 @@ module Spider
             elsif (override.name == 'tpl:content')
                 found = el.search("tpl:placeholder[@name='#{override.get_attribute('name')}']")
             else
-                found = [el]
+                if ['sp:pass', 'tpl:pass', 'sp:template'].include?(el.name)
+                    found = el.children.select{ |child| child.is_a?(Hpricot::Elem) }
+                else
+                    found = [el]
+                end
             end
+            
             if (override.name == 'tpl:delete')
                 found.remove
             else
@@ -584,27 +770,27 @@ module Spider
         end
         
         # Template assets.
-        def assets
+        def conditional_assets
             res = []
             @assets.each do |ass|
                  # FIXME: is this the best place to check if? Maybe it's better to do it when printing resources?
-                res << ass unless !ass[:if].empty? && !@scene.instance_eval(ass[:if])
+                res << ass unless ass[:if] && !ass[:if].empty? && !@scene.instance_eval(ass[:if])
             end
             return res
         end
         
-        # Assets for the template and contained widgets.
-        def all_assets
-            res = [] 
-            seen = {}
-            @widgets.each do |id, w|
-#                next if seen[w.class]
-                seen[w.class] = true
-                res += w.assets
-            end
-            res += assets
-            return res
-        end
+#         # Assets for the template and contained widgets.
+#         def all_assets
+#             res = [] 
+#             seen = {}
+#             @widgets.each do |id, w|
+# #                next if seen[w.class]
+#                 seen[w.class] = true
+#                 res += w.assets
+#             end
+#             res += assets
+#             return res
+#         end
         
         def with_widget(path, &proc)
             first, rest = path.split('/', 2)
@@ -623,14 +809,61 @@ module Spider
                 widget.instance_eval(wp[:proc])
             end
         end
-            
+        
+        def inspect
+            "#<#{self.class}:#{self.object_id} #{@path}>"
+        end
+        
+        ExpressionOutputRegexp = /\{?\{\s([^\s].*?)\s\}\}?/
+        GettextRegexp = /_\(([^\)]+)?\)(\s%\s([^\s,]+(?:,\s*\S+\s*)?))?/
+        ERBRegexp = /(<%(.+)?%>)/
+        SceneVarRegexp = /@(\w[\w\d_]+)/
+        
+        def self.scan_text(text)
+            text = text.gsub(/\302\240/, ' ') # remove annoying fake space
+            scanner = ::StringScanner.new(text)
+            pos = 0
+            c = ""
+            while scanner.scan_until(Regexp.union(ExpressionOutputRegexp, GettextRegexp, ERBRegexp))
+                t = scanner.pre_match[pos..-1]
+                pos = scanner.pos
+                yield :plain, t, t if t && t.length > 0
+                case scanner.matched
+                when ExpressionOutputRegexp
+                    if scanner.matched[1].chr == '{'
+                        yield :escaped_expr, $1, scanner.matched
+                    else
+                        yield :expr, $1, scanner.matched
+                    end
+                when GettextRegexp
+                    gt = [$1]
+                    gt << $3 if $2 # interpolated vars
+                    yield :gettext, gt, scanner.matched
+                when ERBRegexp
+                    yield :erb, $1, scanner.matched
+                end
+            end
+            yield :plain, scanner.rest, scanner.rest
+        end
+        
+        def self.scan_scene_vars(str)
+            scanner = ::StringScanner.new(str)
+            pos = 0
+            while scanner.scan_until(SceneVarRegexp)
+                text = scanner.pre_match[pos..-1]
+                yield :plain, text, text if text &&  text.length > 0
+                pos = scanner.pos
+                yield :var, scanner.matched[1..-1]
+            end
+            yield :plain, scanner.rest
+        end
         
     end
     
     # Class holding compiled template code.
     
     class CompiledTemplate
-        attr_accessor :block, :source_path, :cache_path, :subtemplates, :devel_info
+        attr_accessor :block, :source_path, :cache_path, :subtemplates, :devel_info, :assets
         
         
         def initialize()

data/lib/spiderfw/templates/template_blocks.rb

@@ -20,8 +20,13 @@ module Spider
                 block = :TagIf
             elsif !skip_attributes && el.has_attribute?('sp:attr-if')
                 block = :AttrIf
-            elsif !skip_attributes && (el.has_attribute?('sp:each') || el.has_attribute?('sp:each_index'))
+            elsif !skip_attributes && (el.has_attribute?('sp:each') || el.has_attribute?('sp:each_index') \
+                                    || el.has_attribute?('sp:each_pair') || el.has_attribute?('sp:each_with_index'))
                 block = :Each
+            elsif el.name == 'tpl:output'
+                block = :Output
+            elsif el.name == 'tpl:output-assets'
+                block = :LayoutAssets    
             elsif el.name == 'sp:render'
                 block = :Render
             elsif el.name == 'sp:run'
@@ -77,6 +82,7 @@ module Spider
         
         class Block
             attr_reader :el, :template, :allowed_blocks
+            attr_accessor :doctype
             
             def initialize(el, template=nil, allowed_blocks=nil)
                 @el = el
@@ -107,55 +113,40 @@ module Spider
             
             def self.vars_to_scene(str, container='self')
                 res = ""
-                scanner = ::StringScanner.new(str)
-                pos = 0
-                while scanner.scan_until(/@(\w[\w\d_]+)/)
-                    text = scanner.pre_match[pos..-1]
-                    pos = scanner.pos
-                    res += text
-                    res += "#{container}[:#{scanner.matched[1..-1]}]"
+                Spider::Template.scan_scene_vars(str) do |type, val|
+                    case type
+                    when :plain
+                        res += val
+                    when :var
+                        res += "#{container}[:#{val}]"
+                    end
                 end
-                res += scanner.rest
-                return res
+                res
             end
             
             def vars_to_scene(str, container='self')
                 self.class.vars_to_scene(str, container)
             end
             
-            def scan_vars(str, &block)
-                res = ""
-                scanner = ::StringScanner.new(str)
-                pos = 0
-                while scanner.scan_until(/\{ ([^}]+) \}/)
-                    text = scanner.pre_match[pos..-1]
-                    pos = scanner.pos
-                    yield text, scanner.matched[2..-3]
-                end
-                return scanner.rest
-            end
-            
             def compile_text(str)
                 res = ""
-                scanner = ::StringScanner.new(str)
-                pos = 0
-                var_regexp = /\{ ([^}]+) \}/
-                while scanner.scan_until(Regexp.union(var_regexp, GettextRegexp))
-                    text = scanner.pre_match[pos..-1]
-                    pos = scanner.pos
-                    case scanner.matched
-                    when var_regexp
-                         res += text+"'+("+vars_to_scene(scanner.matched[2..-3])+").to_s+'"
-                    when GettextRegexp
-                        res += "'\n$out << _('#{escape_text($1)}')"
-                        if $2
-                            res += " #{vars_to_scene($2)}" 
+                Spider::Template.scan_text(str) do |type, val, full|
+                    case type
+                    when :plain
+                        res += escape_text(val)
+                    when :escaped_expr
+                        res += full
+                    when :expr
+                        res += "'+("+vars_to_scene(val)+").to_s+'"
+                    when :gettext
+                        res += "'\n$out << _('#{escape_text(val[0])}')"
+                        if val[1]
+                            res += " #{vars_to_scene(val[1])}" 
                         end
                         res += "\n$out << '"
                     end
                 end
-                res += scanner.rest
-                return res
+                res
             end
             
             
@@ -215,4 +206,7 @@ require 'spiderfw/templates/blocks/widget'
 require 'spiderfw/templates/blocks/run'
 require 'spiderfw/templates/blocks/debugger'
 require 'spiderfw/templates/blocks/parent_context'
+require 'spiderfw/templates/blocks/output'
+require 'spiderfw/templates/blocks/layout_assets'
+
 

data/lib/spiderfw/utils/events/event_source.rb

@@ -0,0 +1,54 @@
+module Spider
+    
+    module EventSource
+        
+        def self.included(klass)
+            klass.extend(ClassMethods)
+        end
+        
+        module ClassMethods
+            
+            def inherited(sub)
+                if @event_handlers
+                    @event_handlers.each do |event_name, arr|
+                        arr.each do |proc|
+                            sub.on(event_name, &proc)
+                        end
+                    end
+                end
+                super
+            end
+        
+            def on(event_name, &proc)
+                @event_handlers ||= {}
+                @event_handlers[event_name] ||= []
+                @event_handlers[event_name] << proc
+            end
+        
+            def trigger(event_name, *params)
+                return unless @event_handlers && @event_handlers[event_name]
+                @event_handlers[event_name].each do |h|
+                    h.call(*params)
+                end
+            end
+            
+        end
+        
+        def on(event_name, *params)
+            @event_handlers ||= {}
+            @event_handlers[event_name] ||= []
+            debugger unless proc
+            @event_handlers[event_name] << proc
+        end
+        
+        def trigger(event_name, *params)
+            self.class.trigger(event_name, *([self]+params))
+            return unless @event_handlers && @event_handlers[event_name]
+            @event_handlers[event_name].each do |h|
+                h.call(*params)
+            end
+        end
+        
+    end
+    
+end