spiderfw 0.5.19 → 0.6.0

data/lib/spiderfw/widget/widget.rb

@@ -31,7 +31,20 @@ module Spider
                 @subclasses ||= []
                 @subclasses << subclass
                 super
+                # Do some magic to try and infer the widget's path, considering intermediate superclass callers
+                cnt = 0
+                s = subclass.superclass
+                while s != Spider::Widget
+                    if caller[cnt].split(':')[-1] =~ /inherited/
+                        cnt += 1
+                    end
+                    s = s.superclass
+
+                end
+                file = caller[cnt].split(':')[0]
+                subclass.instance_variable_set("@widget_path", File.dirname(file))
             end
+
             
             def attribute(name, params={})
                 # TODO: implement, this is just a placeholder
@@ -101,24 +114,21 @@ module Spider
                 @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
+                return @template_path if @template_path
+                @template_path = @widget_path
+                @template_path += '/templates' if ::File.directory?(@template_path+'/templates')
+                @template_path
             end
             
-            def default_template
-                Spider::Inflector.underscore(self.name).split('/')[-1]
+            def default_template(val=nil)
+                @default_template = val if val
+                @default_template ||= Spider::Inflector.underscore(self.name).split('/')[-1]
+                @default_template
             end
             
             def relative_url
-                template_path[template_path_parent.length+1..-1]
+                ::File.dirname(@widget_path)
             end
             
             def route_url
@@ -806,14 +816,22 @@ module Spider
             "#{self.widget_target}&_we=#{name}"+(params.map{|p| "&_wp[]=#{p}"}).join('')
         end
         
+        def widget_action_u(name, *params)
+            "#{self.widget_target}&_we=#{name}"+(params.map{|p| "&_wp%5B%5D=#{p}"}).join('')
+        end
+        
         def widget_params(params)
-            "#{self[:request][:path]}?"+params.map{ |k, v| "_w#{self[:widget][:param]}[#{k}]=#{v}"}.join('&')
+            "#{self[:request][:path]}?"+params.map{ |k, v| "_w#{self[:widget][:param]}%5B#{k}%5D=#{v}"}.join('&')
         end
         
         def widget_param(name)
             "_w#{self[:widget][:param]}[#{name}]"
         end
         
+        def widget_param_u(name)
+            "_w#{self[:widget][:param]}%5B#{name}%5D"
+        end
+        
     end
     
 end

data/lib/spiderfw.rb

@@ -1,600 +1,4 @@
-require 'spiderfw/env'
+require 'spiderfw/spider'
 
-require 'rubygems'
-require 'find'
-require 'fileutils'
-require 'pathname'
-require 'spiderfw/autoload'
-require 'spiderfw/requires'
 
-require 'spiderfw/version'
-
-
-module Spider
-    
-    class << self
-        # Everything here must be thread safe!!!
-        
-        # An instance of the shared logger.
-        attr_reader :logger
-        # An hash of registered Spider::App, indexed by name.
-        attr_reader :apps
-        # An hash of registred Spider::App modules, indexed by path.
-        attr_reader :apps_by_path
-        # An hash of registred Spider::App modules, indexed by short name (name without namespace).
-        attr_reader :apps_by_short_name
-        # The current runmode (test, devel or production).
-        attr_reader :runmode
-        # An hash of runtime paths.
-        # :root::           The base runtime path.
-        # :apps::           Apps folder.
-        # :core_apps::      Spider apps folder.
-        # :config::         Config folder.
-        # :views::          Runtime views folder.
-        # :var::            Var folder. Must be writable. Contains cache, logs, and other files written by the server.
-        # :data::           Data folder. Holds static and dynamic files. Some subdirs may have to be writable.
-        # :certs::          Certificates folder.
-        # ::tmp::           Temp folder. Must be writable.
-        # ::log::           Log location.
-        attr_reader :paths
-        # Current Home
-        attr_reader :home
-        # Registered resource types
-        attr_reader :resource_types
-        # Main site
-        attr_accessor :site
-        
-        # Initializes the runtime environment. This method is called when spider is required. Apps may implement
-        # an app_init method, that will be called after Spider::init is done.
-        def init(force=false)
-            return if @init_done && !force
-            @paths = {}
-            @apps_to_load = []
-            @apps ||= {}
-            @apps_by_path ||= {}
-            @apps_by_short_name ||= {}
-            @loaded_apps = {}
-            @root = $SPIDER_RUN_PATH
-            @home = Home.new(@root)
-            Locale.default = Spider.conf.get('i18n.default_locale')
-            @resource_types = {}
-            register_resource_type(:views, :extensions => ['shtml'])
-            setup_paths(@root)
-            all_apps = find_all_apps
-            all_apps.each do |path|
-                opts = File.join(path, 'config/options.rb')
-                require opts if File.exist?(opts)
-            end
-            @runmode = nil
-            self.runmode = $SPIDER_RUNMODE if $SPIDER_RUNMODE
-            load_configuration File.join($SPIDER_PATH, 'config')
-            load_configuration File.join(@root, 'config')
-            start_loggers
-#            @controller = Controller
-            @paths[:spider] = $SPIDER_PATH
-
-            if ($SPIDER_CONFIG_SETS)
-                $SPIDER_CONFIG_SETS.each{ |set| @configuration.include_set(set) }
-            end
-            init_file = File.join($SPIDER_RUN_PATH, 'init.rb')
-            if File.exist?(init_file)
-                @home.instance_eval(File.read(init_file), init_file)
-            end
-            @logger.close(STDERR)
-            @logger.open(STDERR, Spider.conf.get('debug.console.level')) if Spider.conf.get('debug.console.level')
-            GetText::LocalePath.memoize_clear # since new paths have been added to GetText
-            @apps.each do |name, mod|
-                GetText.bindtextdomain(mod.short_name) if File.directory?(mod.path+'/po')
-                mod.app_init if mod.respond_to?(:app_init)
-            end
-            @init_done=true
-        end
-        
-        # 
-        # def stop
-        #     @apps.each do |name, mod|
-        #         mod.app_stop if mod.respond_to?(:app_stop)
-        #     end
-        # end
-
-
-        # Invoked before a server is started. Apps may implement the app_startup method, that will be called.
-        def startup
-            unless File.exists?(File.join(Spider.paths[:root], 'init.rb'))
-                raise "The server must be started from the root directory"
-            end
-            if (Spider.conf.get('template.cache.reload_on_restart'))
-                FileUtils.touch("#{Spider.paths[:tmp]}/templates_reload.txt")
-            end
-            if domain = Spider.conf.get('site.domain')
-                ssl_port = Spider.conf.get('site.ssl') ? Spider.conf.get('site.ssl_port') : nil
-                Spider.site = Site.new(domain, Spider.conf.get('site.port'), ssl_port)
-            elsif File.exists?(Site.cache_file)
-                Spider.site = Site.load_cache
-            end
-            if (Spider.conf.get('request.mutex'))
-                mutex_requests!
-            end
-            @apps.each do |name, mod|
-                mod.app_startup if mod.respond_to?(:app_startup)
-            end
-            @startup_done = true
-        end
-        
-        def startup_done?
-            @startup_done
-        end
-        
-        # Invoked when a server is shutdown. Apps may implement the app_shutdown method, that will be called.        
-        def shutdown
-            return unless Thread.current == Thread.main
-            Debugger.post_mortem = false if Object.const_defined?(:Debugger) && Debugger.post_mortem?
-            @apps.each do |name, mod|
-                mod.app_shutdown if mod.respond_to?(:app_shutdown)
-            end
-        end
-        
-        def current
-            Spider::Request.current
-        end
-        
-        def request_started
-            @request_mutex.lock if (@request_mutex)
-            Spider::Request.current = {
-                :_start => Time.now
-            }
-        end
-        
-        def request_finished
-            # Spider.logger.info("Done in #{(Time.now - Spider::Request.current[:_start])*1000}ms")
-            Spider::Request.reset_current
-            @request_mutex.unlock if (@request_mutex)
-        end
-        
-        def mutex_requests!
-            @request_mutex = Mutex.new
-        end
-        
-        def request_mutex
-            @request_mutex
-        end
-        
-        def request_mutex=(val)
-            @request_mutex = val
-        end
-        
-        
-        # Closes any open loggers, and opens new ones based on configured settings.
-        def start_loggers
-            @logger = Spider::Logger
-            @logger.close_all
-            @logger.open(STDERR, Spider.conf.get('debug.console.level')) if Spider.conf.get('debug.console.level')
-            begin
-                FileUtils.mkpath(@paths[:log]) unless File.exist?(@paths[:log])
-            rescue => exc
-                @logger.error("Unable to create log folder")
-            end
-            if (File.exist?(@paths[:log]))
-                @logger.open(File.join(@paths[:log], 'error.log'), :ERROR) if Spider.conf.get('log.errors')
-                if (Spider.conf.get('log.debug.level'))
-                    @logger.open(File.join(@paths[:log], 'debug.log'), Spider.conf.get('log.debug.level'))
-                end
-            end
-            $LOG = @logger
-        end
-        
-        # Sets the default paths (see #paths).
-        def setup_paths(root)
-            @paths[:root] = root
-            @paths[:apps] = File.join(root, 'apps')
-            @paths[:core_apps] = File.join($SPIDER_PATH, 'apps')
-            @paths[:config] = File.join(root, 'config')
-            @paths[:layouts] = File.join(root, 'layouts')
-            @paths[:var] = File.join(root, 'var')
-            @paths[:certs] = File.join(@paths[:config], 'certs')
-            @paths[:tmp] = File.join(root, 'tmp')
-            @paths[:data] = File.join(root, 'data')
-            @paths[:log] = File.join(@paths[:var], 'log')
-        end
-        
-        # Finds an app by name, looking in paths[:apps] and paths[:core_apps]. Returns the found path.
-        def find_app(name)
-            path = nil
-            [@paths[:apps], @paths[:core_apps]].each do |base|
-                test = File.join(base, name)
-                if File.exist?(File.join(test, '_init.rb'))
-                    path = test
-                    break
-                end
-            end
-            return path
-        end
-        
-        def find_apps(name)
-            [@paths[:apps], @paths[:core_apps]].each do |base|
-                test = File.join(base, name)
-                if File.exist?(test)
-                    return find_apps_in_folder(test)
-                end
-            end
-        end
-        
-        def load_app(name)
-            paths = find_apps(name)
-            paths.each do |path|
-                load_app_at_path(path)
-            end
-        end
-        
-        def load_app_at_path(path)
-            return if @loaded_apps[path]
-            relative_path = path
-            if path.index(Spider.paths[:root])
-                home = Pathname.new(Spider.paths[:root])
-                pname = Pathname.new(path)
-                relative_path = pname.relative_path_from(home).to_s
-            end
-            @loaded_apps[path] = true
-            last_name = File.basename(path)
-            app_files = ['_init.rb', last_name+'.rb', 'cmd.rb']
-            app_files.each{ |f| require File.join(relative_path, f) if File.exist?(File.join(path, f)) }
-            GetText::LocalePath.add_default_rule(File.join(path, "data/locale/%{lang}/LC_MESSAGES/%{name}.mo"))
-        end
-        
-        def load_apps(*l)
-            l.each do |app|
-                load_app(app)
-            end
-        end
-        
-        def load_all_apps
-            find_all_apps.each do |path|
-                load_app_at_path(path)
-            end
-        end
-        
-        def find_all_apps
-            app_paths = []
-            Find.find(@paths[:core_apps], @paths[:apps]) do |path|
-                if (File.basename(path) == '_init.rb')
-                    app_paths << File.dirname(path)
-                    Find.prune
-                elsif File.exist?(File.join(path, '_init.rb'))
-                    app_paths << path
-                    Find.prune
-                end
-            end
-            return app_paths
-        end
-        
-        def find_apps_in_folder(path)
-            return unless File.directory?(path)
-            return [path] if File.exist?(File.join(path, '_init.rb'))
-            found = []
-            Dir.new(path).each do |f|
-                next if f[0].chr == '.'
-                found_path = File.join(path, f)
-                if File.exist?(File.join(found_path, '/_init.rb'))
-                    found << found_path
-                else
-                    found += find_apps_in_folder(found_path)
-                end
-            end
-            return found
-        end
-        
-        def add_app(mod)
-            @apps[mod.name] = mod
-            @apps_by_path[mod.relative_path] = mod
-            @apps_by_short_name[mod.short_name] = mod
-        end
-        
-        def app?(path_or_name)
-            return true if @apps_by_path[path_or_name]
-            return true if @apps_by_short_name[path_or_name]
-            return false
-        end
-        
-        def load_configuration(path)
-            return unless File.directory?(path)
-            opts = File.join(path, 'options.rb')
-            require opts if File.exist?(opts)
-            Dir.new(path).each do |f|
-                f.untaint # FIXME: security parse
-                case f
-                when /^\./
-                    next
-                when /\.(yaml|yml)$/
-                    begin
-                        @configuration.load_yaml(File.join(path, f))
-                    rescue ConfigurationException => exc
-                        if (exc.type == :yaml)
-                            @logger.error("Configuration file #{path+f} is not valid YAML")
-                        else
-                            raise
-                        end
-                    end
-                end
-            end
-        end
-        
-        # Returns the default controller.
-        def controller
-            require 'spiderfw/controller/spider_controller'
-            SpiderController
-        end
-        
-        # Sets routes on the #controller for the given apps.
-        def route_apps(*apps)
-            options = {}
-            if apps[-1].is_a?(Hash)
-                options = apps.pop
-            end
-            @route_apps = apps.empty? ? true : apps
-            if (@route_apps)
-                apps_to_route = @route_apps == true ? self.apps.values : @route_apps.map{ |name| self.apps[name] }
-            end
-            if options[:except]
-                apps_to_route.reject{ |app| options[:except].include?(app) }
-            end
-            if (apps_to_route)
-                apps_to_route.each{ |app| @home.controller.route_app(app) }
-            end
-        end
-        
-        # Adds a resource type
-        # name must be a symbol, extensions an array of extensions (strings, without the dot) for this resource.
-        # Options may be:
-        # :extensions   an array of possible extensions. If given, find_resource will try appending the extensions
-        #               when looking for the file.
-        # :path         the path of the resource relative to resource root; if not given, name will be used.
-        # 
-        def register_resource_type(name, options={})
-            @resource_types[name] = {
-                :extensions => options[:extensions],
-                :path => options[:path] || name.to_s
-            }
-        end
-        
-        def path
-            $SPIDER_PATH
-        end
-        
-        def relative_path
-            '/spider'
-        end
-        
-        # Returns the full path of a resource.
-        # resource_type may be :views, or any other type registered with #register_resource_type
-        # path is the path of the resource, relative to the resource folder
-        # cur_path, if provided, is the current working path
-        # owner_class, if provided, must respond to *app*
-        # 
-        # Will look for the resource in the runtime root first, than in the
-        # app's :"#{resource_type}_path", and finally in the spider folder.
-        def find_resource(resource_type, path, cur_path=nil, owner_classes=nil, search_paths=[])
-            owner_classes = [owner_classes] unless owner_classes.is_a?(Enumerable)
-            # FIXME: security check for allowed paths?
-            def first_found(extensions, path)
-                extensions.each do |ext|
-                    full = path
-                    full += '.'+ext if ext
-                    return full if (File.exist?(full))
-                end
-                return nil
-            end
-            
-            search_paths ||= []
-            owner_classes.each do |owner_class| # FIXME: refactor
-                next if owner_class.is_a?(Spider::Home) # home is already checked for other owner_classes
-                                                        # FIXME: maybe it shouldn't get here?
-                owner_class = nil if owner_class == NilClass
-                resource_config = @resource_types[resource_type]
-                raise "Unknown resource type #{resource_type}" unless resource_config
-                resource_rel_path = resource_config[:path]
-                extensions = [nil] + resource_config[:extensions]
-                path.strip!
-                if (path[0..3] == 'ROOT')
-                    path.sub!(/^ROOT/, Spider.paths[:root])
-                    return Resource.new(path, @home)
-                elsif (path[0..5] == 'SPIDER')
-                    path.sub!(/^SPIDER/, $SPIDER_PATH)
-                    return Resource.new(path, self)
-                elsif (cur_path)
-                    if (path[0..1] == './')
-                        return Resource.new(first_found(extensions, cur_path+path[1..-1]), owner_class)
-                    elsif (path[0..1] == '../')
-                        return Resource.new(first_found(extensions, File.dirname(cur_path)+path[2..-1]), owner_class)
-                    end
-                end
-                app = nil
-                path_app = nil
-                if (path[0].chr == '/')
-                    first_part = path[1..-1].split('/')[0]
-                    Spider.apps_by_path.each do |p, a|
-                        if path.index(p+'/') == 1 # FIXME: might not be correct
-                        #if first_part == p
-                            path_app = a
-                            path = path[p.length+2..-1]
-                            break
-                        end
-                    end
-                    app = path_app
-                elsif owner_class <= Spider::App
-                    app = owner_class
-                else
-                    app = owner_class.app if (owner_class && owner_class.app)
-                end
-                return Resource.new(cur_path+'/'+path, owner_class) if cur_path && File.exist?(cur_path+'/'+path) # !app
-                raise "Can't find owner app for resource #{path}" unless app
-                search_locations = resource_search_locations(resource_type, app)
-                search_paths.each do |p|
-                    p = [p, owner_class] unless p.is_a?(Array)
-                    search_locations << p
-                end
-                search_locations.each do |p|
-                    found = first_found(extensions, p[0]+'/'+path)
-                    next if found == cur_path
-                    definer = path_app || p[1]
-                    return Resource.new(found, definer) if found
-                end
-            end
-            return Resource.new(path)
-        end
-        
-        def resource_search_locations(resource_type, app=nil)
-            resource_config = @resource_types[resource_type]
-            resource_rel_path = resource_config[:path]
-            app_rel_path = app && app.respond_to?(:relative_path) ? app.relative_path : nil
-            root_search = File.join(Spider.paths[:root], resource_rel_path)
-            root_search = File.join(root_search, app_rel_path) if app_rel_path
-            # unless cur_path && cur_path == File.join(root_search, path)
-            search_locations = [[root_search, @home]]
-            # end
-            if app
-                if app.respond_to?("#{resource_type}_path")
-                    search_locations << [app.send("#{resource_type}_path"), app]
-                else
-                    search_locations << [File.join(app.path, resource_rel_path), app]
-                end
-            end
-            spider_path = File.join($SPIDER_PATH, resource_rel_path)
-            search_locations << [spider_path, self]
-            search_locations
-        end
-        
-        def list_resources(resource_type, owner_class=nil, start=nil, search_paths = [])
-            app = nil
-            if owner_class <= Spider::App
-                app = owner_class
-            else
-                app = owner_class.app if (owner_class && owner_class.app)
-            end
-            search_locations = resource_search_locations(resource_type, app)
-            resource_config = @resource_types[resource_type]
-            extensions = resource_config[:extensions]
-            search_paths.each do |p|
-                p = [p, owner_class] unless p.is_a?(Array)
-                search_locations << p
-            end
-            res = []
-            search_locations.reverse.each do |p|
-                pname = Pathname.new(p[0])
-                base = p[0]
-                base = File.join(base, start) if start
-                extensions.each do |ext|
-                    Dir.glob(File.join(base, "*.#{ext}")).each do |f|
-                        res << (Pathname.new(f).relative_path_from(pname)).to_s
-                    end
-                end
-            end
-            res.uniq
-            
-        end
-        
-        def find_resource_path(resource_type, path, cur_path=nil, owner_classes=nil, search_paths=[])
-            res = find_resource(resource_type, path, cur_path, owner_classes, search_paths)
-            return res ? res.path : nil
-        end
-        
-        
-        # Source file management
-
-        def sources_in_dir(path)
-            loaded = []
-            $".each do |file|
-                basename = File.basename(file)
-                next if (basename == 'spider.rb' || basename == 'options.rb')
-                if (file[0..path.length-1] == path)
-                   loaded.push(file)
-                else
-                    $:.each do |dir|
-                        file_path = File.join(dir, file)
-                        if (file_path =~ /^#{path}/)  # FileTest.exists?(file_path) && 
-                            loaded.push(file_path)
-                        end
-                    end
-                end
-            end
-            return loaded
-        end
-
-        def reload_sources_in_dir(dir)
-            self.sources_in_dir(dir).each do |file|
-                load(file)
-            end
-        end
-
-        def reload_sources
-            logger.debug("Reloading sources")
-            crit = Thread.critical
-            Thread.critical = true
-            $".each do |file|
-                if file =~ /^(#{$SPIDER_RUN_PATH}|apps)/ 
-                 #   logger.debug("RELOADING #{file}")
-                    load(file)
-                else
-                #    logger.debug("SKIPPING #{file}")
-                end
-            end
-            Thread.critical = crit
-        end
-        
-        def runmode=(mode)
-            raise "Can't change runmode" if @runmode
-            @runmode = mode
-            @configuration.include_set(mode)
-            if mode == 'devel' || File.exists?(File.join($SPIDER_RUN_PATH,'tmp', 'debug.txt'))
-                init_debug
-            end
-            if (mode != 'production')
-                Spider.paths[:var] = File.join(Spider.paths[:var], mode)
-            end
-        end
-        
-        def init_debug
-            begin
-                require 'ruby-debug'
-                if File.exists?(File.join($SPIDER_RUN_PATH,'tmp', 'debug.txt'))
-                    Debugger.wait_connection = true
-                    Debugger.start_remote
-                    File.delete(File.join($SPIDER_RUN_PATH,'tmp', 'debug.txt'))
-                else
-                    Debugger.start
-                end
-            rescue LoadError, RuntimeError; end
-        end
-        
-        def locale
-            Locale.current[0]
-        end
-        
-        def i18n(l = self.locale)
-            Spider::I18n.provider(l)
-        end
-        
-        def test_setup
-        end
-        
-        def test_teardown
-        end
-        
-        def _test_setup
-            @apps.each do |name, mod|
-                mod.test_setup if mod.respond_to?(:test_setup)
-            end
-        end
-        
-        def _test_teardown
-            @apps.each do |name, mod|
-                mod.test_teardown if mod.respond_to?(:test_teardown)
-            end
-        end
-        
-    end
-    
-end
-
-# load instead of require for reload_sources to work correctly
-load 'spiderfw/config/options/spider.rb'
 Spider::init()