spiderfw 0.5

data/lib/spiderfw/config/configuration.rb

@@ -0,0 +1,281 @@
+require 'yaml'
+
+
+module Spider
+    
+    class Configuration
+        attr_accessor :options, :current_set, :hash_key
+        @@options = {}
+        @@lang_aliases = {}
+        
+        def initialize(prefix='')
+            prefix = prefix[1..prefix.length-1] if (prefix[0..0] == '.')
+            @prefix = prefix
+            @options = @@options
+            if prefix != ''
+                cur = ''
+                @options = prefix.split('.').inject(@options) do |o, part|
+                    cur += '.' unless cur.empty?; cur += part
+                    config_option(cur, '__auto__') unless o[part]
+                    #raise ConfigurationException.new(:invalid_option), _("%s is not a configuration option") % cur unless o[part]
+                    o[part]
+                end
+            end
+            @sets = {}
+            @current_set = 'default'
+            @sets['default'] = self
+            @values = {}
+            @hash_key = nil
+        end
+        
+        def global_options
+            @@options
+        end
+        
+        def conf_alias(name, aliases=nil)
+            if (aliases)
+                aliases.each do |locale, translated|
+                    @@lang_aliases[locale] ||= {}
+                    @@lang_aliases[locale][translated] = name
+                end
+            elsif (name.is_a?(Hash))
+                name.each do |locale, aliases|
+                    @@lang_aliases[locale] ||= {}
+                    aliases.each do |name, translated|
+                        @@lang_aliases[locale][translated] = name
+                    end
+                end
+            end
+        end
+
+        
+        def []=(key, val)
+            key = translate_key(key)
+            config_option(key, "__auto__") unless @options[key]
+            #raise ConfigurationException.new(:invalid_option), _("%s is not a configuration option") % key unless @options && @options[key]
+            process = @options[key][:params][:process]
+            val = process.call(val) if (process)
+            first, rest = key.split('.', 2)
+            @values[key] = val
+            action = @options[key][:params][:action]
+            action.call(val) if (action)
+        end
+        
+        def sub_conf(name)
+            @values[name] ||= Configuration.new(@prefix+".#{name}")
+        end
+        
+        def translate_key(key)
+            if (!@options[key])
+                locale = Spider.locale
+                locale = $1 if locale =~ /^([^@\.]+)[@\.].+/
+                a = @@lang_aliases[locale][key] if @@lang_aliases[locale]
+                return a.to_s if a
+            end
+            return key.to_s
+        end
+        
+        def set(key, val)
+            first, rest = key.split('.', 2)
+            if rest
+                first = translate_key(first)
+                begin
+                    sub_conf(first).configure(rest, val)
+                rescue ConfigurationException # raise only top level exception
+                    raise ConfigurationException.new(:invalid_option), _("%s is not a configuration option") % key
+                end
+            else
+                key = translate_key(key)
+                config_option(key, '__auto__') unless @options[key]
+                if val.is_a?(Hash)
+                    if (@options[key][:params] && @options[key][:params][:type] == :conf)
+                        @values[key] ||= Configuration.new(@prefix+".#{key}") # FIXME: needed?
+                        val.each do |h_key, h_val|
+                            self[key][h_key] = Configuration.new(@prefix+".#{key}.x")
+                            self[key][h_key].hash_key = h_key
+                            h_val.each { |k, v| self[key][h_key].set(k, v) }
+                        end
+                    elsif (!@options[key][:params] || @options[key][:params][:type] != Hash) # sub conf
+                        @values[key] ||= Configuration.new(@prefix+".#{key}")
+                        val.each { |k, v| self[key][k.to_s] = v }
+                    else
+                        self[key] = val
+                    end
+                else
+                    val = convert_val(@options[key][:params][:type], val) if (@options[key][:params][:type])
+                    self[key] = val
+                end
+            end
+        end
+        alias :configure :set
+        
+        def convert_val(type, val)
+            case type.name
+            when 'String'
+                val = val.to_s
+            when 'Symbol'
+                val = val.to_sym
+            when 'Fixnum'
+                val = val.to_i
+            when 'Float'
+                val = val.to_f
+            end
+            return val
+        end
+        
+        
+        def [](key)
+            key = translate_key(key)
+            val = @values[key]
+            
+            if (val.nil? && @options[key] && @options[key][:params][:default])
+                default = @options[key][:params][:default]
+                val = default
+                if (default.class == Proc)
+                    val = @hash_key ? default.call(@hash_key) : default.call
+                end
+            end
+            return val
+        end
+        
+        def each
+            @values.each do |key, val|
+                if (val.class == Configuration)
+                    val.each do |k, v|
+                        yield key+'.'+k, v
+                    end
+                else
+                    yield key, val
+                end
+            end
+        end
+        
+        # Sets an allowed configuration option
+        # Possible params are:
+        # -:default     the default value for the option; if it is a proc, it will be called
+        # -:choiches    an array of allowed values
+        # -:type        parameter type; can be one of int, string, bool
+        def config_option(name, description, params={}, &proc)
+            name = name.to_s
+            if (params.empty? && description.is_a?(Hash))
+                params = description
+                description = ''
+            end
+            o = @options
+            params[:action] ||= proc if proc
+            first, rest = name.split('.', 2)
+            while (rest)
+                o = (o[first] ||= {})
+                first, rest = rest.split('.', 2)
+            end
+            o[first] = {:description => description, :params => params}
+        end
+        
+
+        
+        def get(key)
+            key = key.to_s
+            first, rest = key.split('.', 2)
+            if rest
+                first = translate_key(first)
+                v = sub_conf(first)
+                if (@values[first].is_a?(Configuration))
+                    return @values[first].config(rest)
+                elsif (@values[first].is_a?(Hash) || @values[first].is_a?(Array))
+                    return @values[first][rest]
+                end
+            else
+                key = translate_key(key)
+                self[key]
+            end
+        end
+        
+        # FIXME: temporarely allows old behaviour 
+        def config(key=nil)
+            return self unless key
+            get(key)
+        end
+        
+        def create_prefix(name)
+            first, rest = name.split('.', 2)
+            @options[first] ||= {}
+            v = sub_conf(first)
+            v.create_prefix(rest) if rest
+        end
+        
+        def configure_set(name, values)
+            s = (@sets[name] ||= Configuration.new(@prefix))
+            s.options = @options
+            values.each do |k, v|
+                s.configure(k, v)
+            end
+        end
+        
+        def include_set(name)
+            return if (self == @sets[name])
+            ( @sets[name] ||= Configuration.new(@prefix) ).each do |key, val|
+                configure(key, val)
+            end
+            @sets[name] = self
+        end
+        
+        def set_included?(name)
+            @sets[name] == self
+        end
+
+            
+        def load_yaml(file)
+            y = YAML::load_file(file)
+            raise ConfigurationException.new(:yaml), "Can't parse configuration file #{file}" unless y
+            y.each do |key, val|
+                case key
+                when /set (.+)/
+                    configure_set($1, val)
+                else
+                    configure(key, val)
+                end
+            end
+        end
+        
+        def to_yaml
+            to_hash.to_yaml
+        end
+        
+        def to_hash
+            h = {}
+            @values.each do |k, v|
+                v = v.to_hash if v.is_a?(self.class)
+                next if v.class == Class
+                h[k] = v
+            end
+            return h
+        end
+        
+    end
+    
+    class ConfigurationException < Exception
+        attr_reader :type
+        
+        def initialize(type)
+            @type = type
+            super
+        end
+        
+    end    
+    
+    # Spider
+    @configuration = Configuration.new
+    class <<self
+        attr_reader :configuration
+        alias :config :configuration
+        alias :conf :configuration
+    end
+    def self.config_option(*params)
+        @configuration.config_option(*params)
+    end
+    def self.conf_alias(name, al=nil)
+        @configuration.conf_alias(name, al)
+    end
+    
+    
+end

data/lib/spiderfw/config/options/spider.rb

@@ -0,0 +1,122 @@
+module Spider
+
+    config_option('runmode', "production, test, devel", :default => 'devel', :choices => ['production', 'test', 'devel'],
+        :action => Proc.new{ |option| Spider.runmode = option unless Spider.runmode || $SPIDER_RUNMODE}
+    )
+    
+    # Storage
+    # config_option('storage.type', '')
+    # config_option('storage.url', '')
+    
+    # Web server
+    config_option 'http.server', _("The internal server to use"), {
+        :default => 'mongrel'
+    }
+    config_option 'webserver.show_traces', _("Whether to show the stack trace on error"), {
+        :default => Proc.new{ ['test', 'devel'].include?(Spider.config.get('runmode')) ? true : false  }
+    }
+    config_option 'webserver.reload_sources', _("Reload application and spider sources on each request"), {
+        :default => Proc.new{ Spider.config.get('runmode') == 'devel' ? true : false }
+    }
+    config_option 'webserver.port', _("Port to use for the http server"), :default => 8080
+    config_option 'webserver.force_threads', _("Force threading on non-threaded adapters"),
+        :default => Proc.new{ RUBY_VERSION_PARTS[1] == '8' ? true : false }
+    # Client
+    config_option 'client.text_editor', _("The text editor installed on the client")
+    
+    # Templates
+    config_option 'template.cache.disable', _("Refresh template cache every time"), { :default => false }
+    config_option 'template.cache.reload_on_restart', _("Refresh template cache when server restarts"), { :default => true }
+    config_option 'template.cache.no_check', _("Never recompile templates"), { :default => true }
+    config_option 'template.cache.check_files', _("Check on every request if templates are changed"), { :default => true }
+    
+    
+    #config_option 'template.safe', _("Run templates in safe mode"), { :default => false }
+    
+    # Model
+    
+    config_option 'storage.db.pool.size', _("How many connections to open to a db"), :default => 5
+    config_option 'storage.db.pool.timeout', _("Timout in seconds to obtain a connection"), :default => 5
+    config_option 'storage.db.pool.retry', _("How many times to retry acquiring a connection"), :default => 5
+    
+    config_option 'storage.db.replace_debug_vars', _("Replace bound variables in debug sql"), {
+        :default => Proc.new{ Spider.config.get('runmode') == 'devel' ? true : false }
+    }
+    
+    config_option 'storages', _("A list of named storages"), :type => :conf
+    config_option 'storages.x.url', _("Connection url to the storage"), :type => String, :required => true
+    config_option 'storages.x.encoding', _("Encoding the DB uses"), :type => String
+    
+    config_option 'debugger.start', _("Start the debugger")
+    config_option 'profiling.enable', _("Enable on-request profiling")
+    config_option 'request.mutex', _("Respond to requests sequentially"), :default => false
+    
+    config_option 'locale', _("The locale to use") do |val|
+        Spider.locale = Locale.new(val)
+    end
+    config_option 'i18n.rails_path', _("Path where rails-style locales are found"), :default => lambda{ Spider.paths[:root]+'/locales' }
+    config_option 'i18n.default_locale', _("Fallback locale"), :default => 'en'
+ 
+    config_option 'runner.sleep', _("Sleep time for the periodic runner"), :default => 10
+    
+    config_option 'session.store', _("Where to store the session"), :default => 'file', :choices => ['memory', 'file', 'memcached']
+    config_option('session.life', _("Lifetime in seconds of the sessions"), :default => 3600, :type => Fixnum)
+    config_option('session.purge_check', _("Number of seconds to wait before session purge check"), :default => 10, :type => Fixnum)
+    config_option 'session.file.path', _("The folder where to store file sessions"), :default => lambda{ return Spider.paths[:var]+'/sessions' }
+    
+    config_option 'shared_store.type', _("Which shared store to use"), :default => 'memory'
+    
+    config_option 'http.nonce_life', _("Life in seconds of HTTP Digest Authentication nonces"), :type => Fixnum, :default => 60
+    # TODO: implement in webrick/others, check if has a performance gain
+    config_option 'http.auto_headers', _("Automatically send headers on first output (breaks the debugger)"), :default => true
+    config_option 'http.seize_stdout', _("Redirect standard output to the browser"), :default => false
+    config_option 'http.proxy_mapping', _("If the request is proxyied, the urls used to reach spider, with the corresponding paths called by the proxy"),
+        :type => Hash
+    config_option 'http.charset', _("The charset to use for http requests"), :default => 'UTF-8'
+    
+    config_option 'debug.console.level', _("Level of debug output to console"), :default => :INFO,
+        :process => lambda{ |opt| opt && opt != 'false' ? opt.to_s.upcase.to_sym : false }
+    config_option 'log.errors', _("Log errors to file"), :default => true
+    config_option 'log.debug.level', _("Log level to use for debug file (false for no debug)"), :default => false,
+        :choices => [false, :DEBUG, :INFO],
+        :process => lambda{ |opt| opt && opt != 'false' ? opt.to_s.upcase.to_sym : false }
+    config_option 'log.rotate.age', _("Number of old log files to keep, OR frequency of rotation (daily, weekly or monthly)"), :default => 'daily'
+    config_option 'log.rotate.size', _("Maximum logfile size (only applies when log.rotate.age is a number)"), :default => 1048576
+#                    :process => lambda{ |v| v.upcase }
+
+
+    config_option 'orgs', _("A list of organizations"), :type => :conf
+    config_option 'orgs.x.name', _("Descriptive name of the organization")
+    config_option 'orgs.x.country_code', _("Country code of the organization")
+    config_option 'orgs.x.state', _("State of the organization")
+    config_option 'orgs.x.city', _("Name of the city")
+    config_option 'orgs.x.common_name', _("Common name (e.g. domain) of the organization")
+    config_option 'orgs.x.email', _("Main e-mail address of the organization")
+    config_option 'orgs.x.auto_from_email', _("Email address used as 'From' for automatic e-mails"),
+        :default => lambda{ |name| Spider.conf.get("orgs.#{name}.email") }
+    config_option 'orgs.x.organizational_unit', _("Organizational Unit (e.g. department)")
+    config_option 'orgs.x.pub_key', _("Path to the public key (defaults to config/certs/org_name/public.pem)"),
+        :default => lambda{ |name| Spider.paths[:certs]+'/'+name+'/public.pem'}
+    config_option 'orgs.x.cert', _("Path to the certificate (defaults to config/certs/org_name/cert.pem)"),
+        :default => lambda{ |name| Spider.paths[:certs]+'/'+name+'/cert.pem'}
+    config_option 'orgs.x.private_key', _("Path to the private key (defaults to config/certs/org_name/private/key.pem)"),
+        :default => lambda{ |name| Spider.paths[:certs]+'/'+name+'/private/key.pem'}
+
+    conf_alias 'it_IT' => {
+        'orgs' => 'organizzazioni',
+        'name' => 'nome',
+        'country_code' => 'codice_nazione',
+        'city' => 'comune',
+        'state' => 'provincia',
+        'organizational_unit' => 'unita_organizzativa'
+    }
+    
+    config_option 'site.admin.name', _("Name of the site administrator")
+    config_option 'site.admin.email', _("Email of the site administrator")
+    
+    config_option 'devel.trace.extended', _("Use ruby-debug to provide extended traces"), :default => true
+    config_option 'devel.trace.show_locals', _("Show locals in debug traces"), :default => true
+    config_option 'devel.trace.show_instance_variables', _("Show locals in debug traces"), :default => true
+    
+    
+end

data/lib/spiderfw/controller/app_controller.rb

@@ -0,0 +1,14 @@
+require 'spiderfw/controller/mixins/static_content'
+
+module Spider
+
+    class AppController < Controller
+        # FIXME: should extend PageController, but there are some circular dependencies to sort out.
+        include Visual
+        include StaticContent
+        include WidgetHelper
+
+
+    end
+
+end