spiderfw 0.5

data/lib/spiderfw/widget/widget.rb

@@ -0,0 +1,671 @@
+require 'spiderfw/controller/page_controller'
+require 'spiderfw/templates/template'
+require 'spiderfw/controller/mixins/visual'
+require 'spiderfw/widget/widget_attributes'
+require 'spiderfw/controller/mixins/http_mixin'
+require 'spiderfw/widget/widget_plugin'
+
+module Spider
+    
+    class Widget < PageController
+        include HTTPMixin
+        
+        attr_accessor :parent
+        attr_accessor :request, :scene, :widgets, :template, :id, :id_path, :containing_template, :is_target, :target_mode
+        attr_reader :attributes, :widget_attributes, :css_classes, :widgets_runtime_content
+        attr_accessor :active
+        
+        @@common_attributes = {
+            :id => {}
+        }
+        
+        class << self
+            attr_reader :attributes, :scene_attributes
+            cattr_reader :tag_name, :plugins
+            
+            def inherited(subclass)
+                subclass.instance_variable_set(:@attributes, attributes.clone)
+                subclass.instance_variable_set(:@scene_attributes, @scene_attributes.clone) if @scene_attributes
+            end
+            
+            def attribute(name, params={})
+                # TODO: implement, this is just a placeholder
+                @attributes ||= @@common_attributes.clone
+                @attributes[name] = params
+            end
+            
+            def attributes
+                @attributes ||= @@common_attributes.clone
+            end
+            
+            def attribute?(name)
+                @attributes[name.to_sym]
+            end
+            
+            def i_attribute(name, params={})
+                params[:instance_attr] = true
+                params[:set_var] = true
+                attribute(name, params)
+            end
+            
+            def is_attribute(name, params={})
+                params[:instance_attr] = true
+                i_attribute(name, params)
+                attr_to_scene(name)
+            end
+            
+            def i_attr_accessor(name, params={})
+                params[:instance_attr] = true
+                i_attribute(name, params)
+                attr_accessor(name)
+            end
+            
+            def is_attr_accessor(name, params={})
+                params[:instance_attr] = true
+                is_attribute(name, params)
+                attr_accessor(name)
+            end
+            
+            def attr_to_scene(*names)
+                @scene_attributes ||= []
+                names.each{ |name| @scene_attributes << name }
+            end
+            
+            def tag(name)
+                self.app.register_tag(name, self)
+                @tag_name ||= name
+            end
+            
+            def register_tag(name)
+                Spider::Template.register(name, self)
+            end
+            
+            def scene_elements(*list)
+                @scene_elements ||= []
+                @scene_elements += list
+            end
+            
+            def get_scene_elements
+                @scene_elements
+            end
+            
+            def template_path_parent(val=nil)
+                # FIXME: damn! find a better way!
+                @template_path_parent = val if val
+                return @template_path_parent || app.path+'/widgets'
+            end
+            
+            def template_path
+                p = template_path_parent+'/'+Inflector.underscore(self.to_s.split('::')[-1])
+                return p+'/templates' if (File.exist?(p+'/templates'))
+                return p
+            end
+            
+            def default_template
+                Spider::Inflector.underscore(self.name).split('/')[-1]
+            end
+            
+            def relative_url
+                template_path[template_path_parent.length+1..-1]
+            end
+            
+            def route_url
+                Spider::ControllerMixins::HTTPMixin.reverse_proxy_mapping('/'+self.app.route_url+'/w/'+relative_url)
+            end
+            
+            def pub_url
+                return self.app.pub_url
+                w = self
+                # FIXME! this is a quick hack to make extended templates work
+                # but what we need is a better method to handle asset ownership
+                #
+                # Is it needed anymore?
+                # w = w.superclass while w.superclass != Spider::Widget && w.superclass.subclass_of?(Spider::Widget)
+                w.route_url+'/pub'
+            end
+            
+            def pub_path
+                self.app.pub_path
+            end
+            
+            def runtime_content_tags
+                ['sp:attribute']
+            end
+            
+            def parse_content_xml(xml)
+                return ["", []] if !xml || xml.strip.empty?
+                return parse_content(Hpricot(xml))
+            end
+            
+            # Parses widget content at compile time.
+            # Must return a pair consisting of:
+            # - runtime content XML
+            # - an array of overrides (as Hpricot nodes)
+            def parse_content(doc)
+                overrides = []
+                plugins = []
+                to_del = []
+                doc.root.each_child do |child|
+                    if child.respond_to?(:name)
+                        namespace, short_name = child.name.split(':', 2)
+                        if (namespace == 'tpl' && (Spider::Template.override_tags.include?(short_name) || self.override_tags.include?(child.name)))
+                            overrides << child unless child.is_a?(Hpricot::BogusETag)
+                        end
+                        if (child.name == 'sp:plugin')
+                            plugins << child
+                        end
+                    end
+                end
+                overrides.each do |ovr|
+                    parse_override(ovr)
+                end
+                Hpricot::Elements[*overrides].remove
+                plugins.each do |plugin|
+                    name = plugin['name']
+                    mod = self.plugin(name)
+                    next unless mod
+                    overrides += mod.get_overrides
+                end
+                return [doc.to_s, overrides]
+            end
+            
+            # This method is called on each override node found. The widget must return the node,
+            # modifying it if needed.
+            def parse_override(el)
+                return el
+            end
+            
+            # An array of custom tags that will be processed at compile time by the widget.
+            def override_tags
+                return []
+            end
+            
+            def add_plugin(name, mod)
+                @plugins ||= {}
+                @plugins[name] = mod
+            end
+            
+            def plugin(name)
+                return nil unless @plugins
+                @plugins[name]
+            end
+            
+        end
+        
+        i_attribute :use_template
+        attribute :"sp:target-only"
+        attribute :class
+        
+        def initialize(request, response, scene=nil)
+            super
+            @widgets = {}
+            @attributes = WidgetAttributes.new(self)
+            @id_path = []
+            @widget_attributes = {}
+            locale = @request.locale.language
+            include_js = [
+                '/js/jquery/jquery-1.3.2.js', '/js/inheritance.js', '/js/spider.js', '/js/jquery/plugins/jquery.query-2.1.6.js',
+                '/js/jquery/jquery-ui/development-bundle/ui/jquery-ui-1.7.2.custom.js', #'/js/jquery/jquery-ui/development-bundle/ui/jquery-ui-1.7.2.custom.min.js'
+                "/js/jquery/jquery-ui/development-bundle/ui/i18n/ui.datepicker-#{locale}.js", '/js/jquery/plugins/jquery.form.js'
+            ]
+            include_css = [
+                '/css/spider.css', '/js/jquery/jquery-ui/css/smoothness/jquery-ui-1.7.2.custom.css', 
+            ]
+            @assets = []
+            include_js.each{ |js| @assets << {:type => :js, :src => Spider::Components.pub_url+js, :path => Spider::Components.pub_path+js}}
+            include_css.each{ |css| @assets << {:type => :css, :src => Spider::Components.pub_url+css, :path => Spider::Components.pub_path+css}}
+            
+            @use_template ||= self.class.default_template
+            @css_classes = []
+            @widgets_runtime_content = {}
+            @widget_procs = {}
+        end
+        
+        def full_id
+            @id_path.join('-')
+        end
+        
+        def local_id
+            @id_path.last
+        end
+        
+        def attributes=(hash)
+            hash = {} unless hash
+            hash.each do |k, v|
+                @attributes[k] = v
+            end
+        end
+        
+        def route_widget
+            return nil
+        end
+        
+        def widget_target=(target)
+            @widget_target = target
+        end
+        
+        def widget_request_path
+            p = @request.path
+            i = p.index(@_action) if @_action && !@_action.empty?
+            p = p[0..i-2] if i
+            p = p.sub(/\/+$/, '')
+            return p
+        end
+        
+        def before(action='')
+            Spider.logger.debug("Widget #{self} before(#{action})")
+            widget_init(action)
+            init_widgets unless @init_widgets_done
+            super
+        end
+        
+        def widget_before(action='')
+            return unless active?
+            Spider.logger.debug("Widget #{self} widget_before(#{action})")
+            widget_init(action)
+            prepare
+            @before_done = true
+        end
+        
+        
+        def active?
+            return @active unless @active.nil?
+            @active = (!@request.params['_wt'] || @target_mode)
+        end
+        
+        def before_done?
+            @before_done
+        end
+        
+        # Loads the template and sets the widget attributes
+        def widget_init(action='')
+            action ||= ''
+            if (@request.params['_wa'] && @request.params['_wa'][full_id])
+                action = @request.params['_wa'][full_id]
+            end
+            @_action = action
+            @_action_local, @_action_rest = action.split('/', 2)
+            unless @template
+                @template = load_template(@use_template)
+            end
+            @id ||= @attributes[:id]
+            @template.id_path = @id_path
+            @template.mode = :widget
+            required_groups = {}
+            self.class.attributes.each do |k, params|
+                if (params[:required])
+                    if (params[:required] == true && !@attributes[k])
+                        raise ArgumentError, "Attribute #{k} is required by widget #{self}"
+                    else
+                        if (!@attributes[k] && required_groups[params[:required]] != false)
+                            required_groups[params[:required]] ||= []
+                            required_groups[params[:required]] << k
+                        else
+                            required_groups[params[:required]] = false
+                        end
+                    end 
+                end
+            end
+            required_groups.each do |group_name, attributes|
+                next if attributes == false
+                raise ArgumentError, "Widget #{self} requires attribute #{attributes.join(' or ')} to be set"
+            end
+            if (@attributes[:class])
+                @css_classes += @attributes[:class].split(/\s+/)
+            end
+        end
+        
+        # Recursively instantiates the subwidgets.
+        def prepare(action='')
+            init_widgets unless @init_widgets_done
+            set_widget_attributes
+            prepare_widgets
+            @template.assets.each do |res|
+                res = res.clone
+                @assets << res
+            end
+        end
+        
+        # Instantiates this widget's own subwidgets.
+        def init_widgets
+            if (self.class.scene_attributes)
+                self.class.scene_attributes.each do |name|
+                    @scene[name] = instance_variable_get("@#{name}")
+                end
+            end
+            template.request = @request
+            template.response = @response
+            @template.init(@scene)
+            @template.widgets.each do |name, w|
+                add_widget(w)
+            end
+            @widgets.each do |id, w| 
+                w.parent = self
+            end
+            @init_widgets_done = true
+        end
+        
+        def set_widget_attributes
+            @widget_attributes.each do |w_id, a|
+                w_id_parts = w_id.to_s.split('.', 2)
+                if (w_id_parts[1])
+                    w_id = w_id_parts[0]
+                    sub_w = w_id_parts[1]
+                end
+                w_id = w_id.to_sym
+                if (@widgets[w_id])
+                    if (sub_w)
+                        @widgets[w_id].widget_attributes[sub_w] = a
+                    else
+                        # FIXME: what if there are a 'name' and a 'value' attributes?
+                        if (a[:name] && a[:value])
+                            @widgets[w_id].attributes[a[:name].to_sym] = a[:value]
+                        else
+                            a.each{ |key, value| @widgets[w_id].attributes[key] = value}
+                        end
+                    end
+                end
+            end
+        end
+        
+        # Runs widget_before on all subwidgets.
+        def prepare_widgets
+            r = route_widget
+            @widgets.each do |id, w|
+                if (r && r[0].to_sym == id)
+                    act = r[1]
+                end
+                act ||= ''
+                w.widget_before(act)
+            end
+        end
+        
+        
+        def run(action='')
+            @widgets.each do |wname, w|
+                w.run
+            end
+            if (@parent)
+                @parent.after_widget(@id.to_sym)
+            end
+            @did_run = true
+        end
+        
+        def did_run?
+            @did_run
+        end
+        
+        def run?
+            @is_target || (!@target_mode && !attributes[:"sp:target_only"])
+        end
+        
+        def init_widget_done?
+            @init_widget_done
+        end
+        
+        def index
+            run
+            render
+        end
+        
+        def render
+            prepare_scene(@scene)
+            @template.render(@scene) unless @target_mode && !@is_target
+        end
+        
+        def execute(action='', *params)
+            Spider.logger.debug("Widget #{self} executing #{action}")
+            widget_execute = @request.params['_we']
+            if (@is_target)
+                if (widget_execute)
+                    super(widget_execute, *params)
+                else
+                    run
+                    render
+                end
+            elsif (@widget_target)
+                first, rest = @widget_target.split('/', 2)
+                @_widget = find_widget(first)
+                @_widget.target_mode = true
+                @_widget.widget_target = rest
+                @_widget.is_target = true unless rest
+                @_widget.set_action(widget_execute)
+                @_widget.before(rest, *params)
+                @_widget.execute(rest, *params)
+            else
+                super
+            end
+        end
+                        
+        def try_rescue(exc)
+            if (exc.is_a?(NotFound))
+                error("Widget path not found: #{exc.path}")
+            else
+                raise exc
+            end
+        end
+        
+        def params
+            p = @request.params['_w']
+            return {} unless p
+            @id_path.each do |id| 
+                p = p[id.to_s]
+                return {} unless p
+            end
+            return p
+        end
+        
+        def session(container=@request.session, klass=Hash)
+            s = (container['_w'] ||= klass.new)
+            @id_path[0..-2].each{ |id| s = (s[id] ||= klass.new) }
+            s = (s[@id_path[-1]] ||= klass.new)
+            return s
+        end
+        
+        def flash
+            s = session(@request.session.flash, Spider::FlashHash)
+            return s
+        end
+        
+        def transient_session
+            return session(@request.session.transient, Spider::TransientHash)
+        end
+        
+        def create_widget(klass, id,  *params)
+            obj = klass.new(*params)
+            obj.id = id
+            add_widget(obj)
+            return obj
+        end
+        
+        def add_widget(widget)
+            widget.id_path = @id_path + [widget.id]
+            widget.parent = self
+            widget.active = true if @is_target || @active
+            @widgets[widget.id.to_sym] = widget
+            if (@widgets_runtime_content[widget.id.to_sym])
+                @widgets_runtime_content[widget.id.to_sym].each do |content|
+                    if (content[:widget])
+                        first, rest = content[:widget].split('/', 2)
+                        content[:widget] = rest
+                        widget.widgets_runtime_content[first.to_sym] ||= [] 
+                        widget.widgets_runtime_content[first.to_sym] << content
+                    else
+                        next if (content[:params] && !check_subwidget_conditions(widget, content[:params]))
+                        widget.parse_runtime_content_xml(content[:xml])
+                    end
+                end
+            end
+            if (@widget_procs[widget.id.to_sym])
+                @widget_procs[widget.id.to_sym].each do |wp|
+                    if (wp[:target])
+                        widget.with_widget(wp[:target], &wp[:proc])
+                    else
+                        widget.instance_eval(&wp[:proc])
+                    end
+                end
+            end
+        end
+        
+        def check_subwidget_conditions
+            return false
+        end
+            
+        
+        def parse_runtime_content_xml(xml, src_path=nil)
+            parse_runtime_content(Hpricot(xml), src_path)
+        end
+        
+        def parse_runtime_content(doc, src_path=nil)
+            # doc.search('sp:plugin').each do |plugin|
+            #     name = plugin['name']
+            #     mod = self.class.plugin(name)
+            #     next unless mod
+            #     (class <<self; self; end).instance_eval do
+            #         debugger
+            #         include mod
+            #     end
+            #     shadow = (class <<self; self; end)
+            #     
+            #     debugger
+            #     a = 3
+            # end
+            attributes = doc.search('sp:attribute')
+            attributes.each do |a|
+                name = a.attributes['name'].to_sym
+                kvs = a.children_of_type('sp:value')
+                if (kvs.length > 0)
+                    value = {}
+                    kvs.each do |kv|
+                        key = kv.attributes['key']
+                        val = kv.innerText
+                        value[key] = val
+                    end
+                else
+                    value = a.attributes['value']
+                end
+                if (w = a.attributes['widget'])
+                    @widget_attributes[w] = {:name => name, :value => value}
+                else
+                    @attributes[name] = value
+                end
+            end
+            attributes.remove
+            doc.search('sp:runtime-content').each do |cont|
+                w = cont.attributes['widget']
+                first, rest = w.split('/', 2)
+                params = nil
+                if (first =~ /(.+)\[(.+)\]/)
+                    params = {}
+                    parts = $2.split(',')
+                    parts.each do |p|
+                        key, val = p.split('=')
+                        params[key] = val
+                    end
+                end
+                if (w)
+                    @widgets_runtime_content[first.to_sym] ||= []
+                    @widgets_runtime_content[first.to_sym] << {
+                        :widget => rest,
+                        :xml => "<sp:widget-content>#{cont.innerHTML}</sp:widget-content>",
+                        :params => params
+                    }
+                end
+            end
+            doc.search('sp:runtime-content').remove
+            doc.search('sp:use-template').each do |templ|
+                if (templ.attributes['app'])
+                    owner = Spider.apps_by_path[templ.attributes['app']]
+                else
+                    owner = self
+                end
+                @template = load_template(templ.attributes['src'], nil, owner)
+            end
+            return doc
+        end
+        
+        
+        def assets
+            res = @assets.clone + widget_assets
+            return res
+        end
+        
+        def widget_assets
+            res = []
+            @widgets.each do |id, w|
+                res += w.assets
+            end
+            return res
+        end
+
+        
+        def owner_controller
+            w = self
+            while (w.is_a?(Widget) && w.template && w.template.owner)
+                return nil unless w.containing_template
+                w = w.containing_template.owner
+            end
+            return w
+        end
+        
+        def prepare_scene(scene)
+            scene = super
+            if (self.class.scene_attributes) # Repeat for new instance variables
+                self.class.scene_attributes.each do |name|
+                    @scene[name] = instance_variable_get("@#{name}")
+                end
+            end
+            # FIXME: owner_controller should be (almost) always defined
+            scene.controller[:request_path] = owner_controller.request_path if owner_controller
+            scene.widget[:request_path] = widget_request_path
+            scene.widget[:target_only] = attributes[:"sp:target-only"]
+            scene.widget[:is_target] = @is_target
+            scene.widget[:is_running] = run?
+            if (@parent && @parent.respond_to?(:scene) && @parent.scene)
+                scene._parent = @parent.scene
+            end
+            scene.extend(WidgetScene)
+            return scene
+        end
+        
+        def css_class
+            return @css_class if @css_class
+            supers = self.class.ancestors.select{ |c| c != Spider::Widget && c.subclass_of?(Spider::Widget)}
+            @css_class = Inflector.underscore(supers.join('/')).gsub('_', '-').gsub('/', ' ').split(' ').uniq.join(' ')
+        end
+        
+        def css_model_class(model)
+            "model-#{model.name.gsub('::', '-')}"
+        end
+        
+        def inspect
+            super + ", id: #{@id}"
+        end
+        
+        def to_s
+            super + ", id: #{@id}"
+        end
+        
+        def find_widget(name)
+            @widgets[name.to_sym] || super
+        end
+        
+        # FIXME: is the same in template. Refactor out.
+        def with_widget(path, &proc)
+            first, rest = path.split('/', 2)
+            @widget_procs[first.to_sym] ||= []
+            @widget_procs[first.to_sym] << {:target => rest, :proc => proc }
+        end
+            
+        
+    end
+    
+    module WidgetScene
+        
+        def widget_action(name, *params)
+            "#{self[:request][:path]}?_wt=#{self[:widget][:id_path].join('/')}&_we=#{name}"+(params.map{|p| "&_wp[]=#{p}"}).join('')
+        end
+        
+    end
+    
+end