spiderfw 0.5

data/lib/spiderfw/cmd/commands/init.rb

@@ -0,0 +1,52 @@
+require 'spiderfw/create'
+
+class InitCommand < CmdParse::Command
+
+
+    def initialize
+        super( 'init', true, true )
+        @short_desc = _("Create a working dir for development or installation")
+#        @description = _("")
+
+        app = CmdParse::Command.new( 'app', false )
+        app.short_desc = _("Create a new application")
+        app.options = CmdParse::OptionParserWrapper.new do |opt|
+            opt.on("--path", 
+                   _("The path where to create the app (defaults to the app folder under the current path)"),
+                   "-p"){ |path|
+                @path = path
+            }
+            opt.on("--module", _("The module name; by default, the app name will be camelized"), "-m"){ |module_name|
+                @module_name = module_name
+            }
+        end
+        app.set_execution_block do |names|
+            @path ||= Dir.pwd+'/apps'
+            names.each do |name|
+                Spider::Create.app(name, @path, @module_name)
+                puts "Created app #{name} at #{@path}/#{name}" if ($verbose)
+            end
+        end
+        self.add_command(app, false)
+        
+        install = CmdParse::Command.new('install', false)
+        install.short_desc = _("Create an installation")
+        install.options = CmdParse::OptionParserWrapper.new do |opt|
+            opt.on("--path", 
+                   _("The path where to create the installation (defaults to the path)"),
+                   "-p"){ |path|
+                @path = path
+            }
+        end
+        install.set_execution_block do |installs|
+            @path ||= Dir.pwd
+            installs.each do |inst|
+                Spider::Create.install(inst, @path)
+            end
+        end
+        self.add_command(install, false)
+
+
+    end
+
+end

data/lib/spiderfw/cmd/commands/model.rb

@@ -0,0 +1,131 @@
+class ModelCommand < CmdParse::Command
+
+
+    def initialize
+        super( 'model', true, true )
+        @short_desc = _("Manage models")
+        @apps = []
+        @force = false
+
+        sync_cmd = CmdParse::Command.new( 'sync', false )
+        sync_cmd.short_desc = _("Sync models")
+        sync_cmd.options = CmdParse::OptionParserWrapper.new do |opt|
+            opt.on("--force", _("Force syncing"), "-f"){ |f|
+                @force = true
+            }
+            opt.on("--drop-columns", _("Drop unused columns"), "-d"){ |d| @drop = true}
+            opt.on("--drop-tables [PREFIX]", _("Drop unused tables")){ |dt|
+                dt = true if dt == '*'
+                @drop_tables = dt
+            }
+            opt.on("--update-sequences", _("Update current sequences to max db value"), "-s"){ |s|
+                @update_sequences = true
+            }
+            opt.on("--non-managed", _("Process also non managed models"), "-m"){ |m| @non_managed = true}
+            opt.on("--no-fk-constraints", _("Don't create foreign key constraints"), "-c"){ |c| @no_fkc = true }
+        end
+        
+        sync_cmd.set_execution_block do |req_models|
+            require 'spiderfw'
+            require 'spiderfw/model/mappers/db_mapper'
+            req_models || []
+            unsafe_fields = {}
+            req_models = Spider.apps.values if (req_models.empty?)
+            req_models.each do |model_or_app|
+                models = []
+                mod = model_or_app.is_a?(Module) ? model_or_app : const_get_full(model_or_app)
+                if (mod.is_a?(Module) && mod.include?(Spider::App))
+                    mod.models.each do |m|
+                        unless @non_managed || m < Spider::Model::Managed
+                            Spider.logger.warn("Skipping #{m} because it's non managed (use -m to override)")
+                            next
+                        end
+                        models << m
+                    end
+                elsif (mod.subclass_of?(Spider::Model::BaseModel))
+                    if @non_managed || mod < Spider::Model::Managed
+                        models << mod
+                    else
+                        Spider.logger.warn("Skipping #{mod} because it's non managed (use -m to override)")
+                    end
+                    
+                end
+                models.each do |model|
+                    begin
+                        Spider::Model.sync_schema(model, @force, 
+                        :drop_fields => @drop, :update_sequences => @update_sequences, :no_foreign_key_constraints => @no_fkc)
+                    rescue Spider::Model::Mappers::SchemaSyncUnsafeConversion => exc
+                        unsafe_fields[model] = exc.fields
+                    end 
+                end
+                if (@drop_tables)
+                    begin
+                        Spider::Model.sync_schema(mod, false, :no_sync => true, :drop_tables => @drop_tables)
+                    rescue Spider::Model::Mappers::SchemaSyncUnsafeConversion => exc
+                        puts _("The following tables are about to be dropped: \n%s") % exc.fields.join(', ')
+                        puts _("Continue? yes/NO: ")
+                        r = STDIN.gets.chomp.downcase
+                        yes_chr = _("yes")[0].chr
+                        no_chr = _("no")[0].chr
+                        if (r == _("yes") || (yes_chr != no_chr && r == yes_chr)) 
+                            Spider::Model.sync_schema(mod, true, :no_sync => true, :drop_tables => @drop_tables)
+                        end
+                    end
+                        
+                        
+                end
+            end
+            unless unsafe_fields.empty?
+                puts _("Unable to modify the following fields:")
+                puts unsafe_fields.inspect
+                puts _("(use -f to force)")
+            end
+        end
+        self.add_command(sync_cmd)
+        
+        dump_cmd = CmdParse::Command.new( 'dump', false )
+        dump_cmd.short_desc = _("Dump models")
+        dump_cmd.options = CmdParse::OptionParserWrapper.new do |opt|
+            opt.on("--force", _("Overwrite existing files"), "-f"){ |f|
+                @force = true
+            }
+            opt.on("--path [PATH]", _("Specify dump path"), "-p"){ |p|
+                @dump_path = p
+            }
+        end
+        dump_cmd.set_execution_block do |req_models|
+            require 'spiderfw'
+            req_models || []
+            req_models.each do |model_or_app|
+                models = []
+                mod = model_or_app.is_a?(Module) ? model_or_app : const_get_full(model_or_app)
+                if (mod.is_a?(Module) && mod.include?(Spider::App))
+                    mod.models.each do |m|
+                        models << m
+                    end
+                elsif (mod.subclass_of?(Spider::Model::BaseModel))
+                    models << mod if @non_managed || mod < Spider::Model::Managed
+                end
+                Spider.logger.warn("Nothing to do") if models.empty?
+                models.each do |model|
+                    dest = @dump_path || model.app.models_path
+                    FileUtils.mkdir_p(dest)
+                    file_name = "#{model.short_name}.rb"
+                    path = "#{dest}/#{file_name}"
+                    if (File.exist?(path) && !@force)
+                        Spider.logger.warn("File #{path} exists, skipping #{model}")
+                        next
+                    end
+                    code = model.to_code
+                    File.open(path, "w") do |f|
+                        f << code
+                    end
+                end
+            end
+        end
+        self.add_command(dump_cmd)
+
+
+    end
+
+end

data/lib/spiderfw/cmd/commands/setup.rb

@@ -0,0 +1,54 @@
+require 'spiderfw/setup/setup_task'
+
+class SetupCommand < CmdParse::Command
+
+
+    def initialize
+        super( 'setup', false, true )
+        @short_desc = _("Setup an application")
+#        @description = _("")
+        @apps = []
+        
+        self.options = CmdParse::OptionParserWrapper.new do |opt|
+            # TODO
+            opt.on("--from [VERSION]", _("Assume a specific version is installed"), "-f"){ |from|
+                @from = Gem::Version.new(from)
+            }
+            opt.on("--to [VERSION]", _("Setup to a specific version"), "-t"){ |to|
+                @to = Gem::Version.new(to)
+            }
+            opt.on("--all", _("Setup all active apps")){ |all|
+                @all = true
+            }
+        end
+
+        set_execution_block do |apps|
+            require 'spiderfw'
+            apps = Spider.apps.keys if @all
+            if (apps.length > 1) && (@to || @from)
+                raise "Can't use --from or --to with multiple apps"
+            end
+            apps.each do |name|
+                Spider.load_app(name) unless Spider.apps[name]
+                app = Spider.apps[name]
+                path = app.setup_path
+                current = @from || app.installed_version
+                new_version = @to || app.version
+                next unless File.exist?(path)
+                Dir.entries(path).sort.each do |entry|
+                    next if (entry[0].chr == '.')
+                    task = Spider::SetupTask.load("#{path}/#{entry}")
+                    next unless task
+                    next if current && task.version < current
+                    next if new_version && task.version > new_version
+                    Spider.logger.info("Running setup task #{path+'/'+entry}")
+                    task.up
+                end
+                app.installed_version = app.version
+            end 
+        end
+
+
+    end
+
+end

data/lib/spiderfw/cmd/commands/test.rb

@@ -0,0 +1,61 @@
+class TestCommand < CmdParse::Command
+
+
+    def initialize
+        super( 'test', true, true )
+        @short_desc = _("Manage tests")
+#        @description = _("")
+        @apps = []
+
+        run_cmd = CmdParse::Command.new( 'run', false )
+        run_cmd.short_desc = _("Run tests")
+        # run.options = CmdParse::OptionParserWrapper.new do |opt|
+        #     opt.on("--app", 
+        #            _("Run tests only for an app"),
+        #            "-a"){ |app|
+        #         @apps << app
+        #     }
+        # end
+        run_cmd.set_execution_block do |apps|
+            require 'test/unit/collector/dir'
+            require 'test/unit'
+            apps = Spider.apps.keys if (!apps || apps.length < 1)
+            collector = Test::Unit::Collector::Dir.new()
+            apps.each do |name|
+                next unless File.exist?(Spider.apps[name].test_path)
+                collector.collect(Spider.apps[name].test_path)
+            end
+        end
+        self.add_command(run_cmd)
+        
+        self_cmd = CmdParse::Command.new('self', false)
+        self_cmd.short_desc = _("Run framework tests")
+        self_cmd.options = CmdParse::OptionParserWrapper.new do |opt|
+            opt.on("--files", _("Run only files containing the given string (or strings, comma separated)"), "-f"){ |f|
+                @files = f
+            }
+        end
+        self_cmd.set_execution_block do
+            require 'test/unit/collector/dir'
+            require 'test/unit'
+            $SPIDER_RUNMODE = 'test'
+            require 'spiderfw'
+            test_env = "#{$SPIDER_PATH}/test"
+#            Dir.cwd(test_env)
+            $:.push(test_env)
+            apps = Spider.find_apps_in_folder("#{test_env}/apps")
+            Spider.apps.clear
+
+            apps.each{ |app| Spider.load_app_at_path app }
+
+            Spider._test_setup
+            collector = Test::Unit::Collector::Dir.new()
+            collector.collect("#{test_env}/tests")
+            Spider._test_teardown
+        end
+        self.add_command(self_cmd)
+
+
+    end
+
+end

data/lib/spiderfw/cmd/commands/webserver.rb

@@ -0,0 +1,93 @@
+require 'spiderfw/http/http'
+
+class WebServerCommand < CmdParse::Command
+
+
+    def initialize
+        super( 'webserver', true, true )
+        @short_desc = _("Manage internal webserver")
+#        @description = _("")
+        
+        servers = {
+            'webrick' => :WEBrick,
+            'mongrel' => :Mongrel,
+            'thin' => :Thin
+        }
+
+        # start
+        start = CmdParse::Command.new( 'start', false )
+        start.short_desc = "Start web server"
+        start.options = CmdParse::OptionParserWrapper.new do |opt|
+            opt.on("--port N", _("The port the webserver should listen on"), "-p") { |port|
+                @port = port
+            }
+            opt.on("--server name", _("Which webserver to use; the choices are 'webrick', 'mongrel' and 'thin'"), "-s"){ |server_name|
+                raise CmdParse::InvalidArgumentError, _("The webserver %s is not supported") % server_name unless servers[server_name]
+                @server_name = server_name
+            }
+            opt.on("--daemonize", _("Detach server process"), "-d"){ @daemonize = true }
+            opt.on("--cgi", _("Serve each request spawning a CGI subprocess. Useful in developement."), "-c"){
+                @cgi = true
+            }
+            opt.on("--ssl [PORT]", _("Listen to SSL requests"), "-S"){ |port|
+                @ssl = port || 443
+            }
+            opt.on("--cert CERT", _("SSL certificate")){ |cert| @ssl_cert = cert }
+            opt.on("--key key", _("SSL private key")){ |key| @ssl_key = key }
+        end
+        start.set_execution_block do |args|
+            require 'spiderfw'
+            raise "Can't use cgi mode with SSL" if @ssl && @cgi
+            @port ||= Spider.conf.get('webserver.port')
+            @server_name ||= Spider.conf.get('http.server')
+            puts _("Using webserver %s") % @server_name if $verbose
+            puts _("Listening on port %s") % @port if $verbose
+            server = Spider::HTTP.const_get(servers[@server_name]).new
+            ssl_server = nil
+            start = lambda{
+                Spider.startup
+                
+                thread = Thread.new do
+                    server.start(:port => @port, :cgi => @cgi)
+                end
+                if (@ssl)
+                    @ssl_cert ||= Spider.conf.get('orgs.default.cert')
+                    @ssl_key ||= Spider.conf.get('orgs.default.private_key')
+                    ssl_thread = Thread.new do
+                        ssl_server = Spider::HTTP.const_get(servers[@server_name]).new
+                        ssl_server.start(:port => @ssl, :ssl => true, :ssl_cert => @ssl_cert, :ssl_private_key => @ssl_key)
+                    end
+                end
+                do_shutdown = lambda{
+                    server.shutdown
+                    ssl_server.shutdown if ssl_server
+                    Spider.shutdown
+                }
+                trap('TERM', &do_shutdown)
+                trap('INT', &do_shutdown)
+                
+                thread.join
+                ssl_thread.join if ssl_thread
+            }
+            if (@daemonize)
+                forked = Spider.fork do
+                    File.new(Spider.paths[:var]+'/run/server.pid', w) do |f|
+                        f.write(Process.pid)
+                    end
+                    $0 = 'spider-server'
+                    start.call
+                    @runner.join
+                end
+                Process.detach(forked)
+            else
+                start.call
+            end
+        end
+        self.add_command( start )
+
+        # stop
+
+
+    end
+
+end

data/lib/spiderfw/config/configurable.rb

@@ -0,0 +1,38 @@
+require 'spiderfw/config/configuration'
+
+module Spider
+
+    module Configurable
+#        @@configuration = $configuration ? $configuration : Configuration.new
+
+        def self.included receiver
+            receiver.class_eval do
+                @configuration = $configuration ? $configuration : Configuration.new
+                def self.configuration_prefix(prefix)
+                    @configuration.create_prefix(prefix)
+                    @configuration = @configuration[prefix]
+                end
+                
+                 # FIXME: doesn't use the prefix?
+                 def self.config_option(name, description, params={})
+                     Spider.configuration.config_option(name, description, params)
+                 end
+                 
+                 def self.conf_alias(name, aliases=nil)
+                     Spider.configuration.conf_alias(name, aliases)
+                 end
+        
+                 def self.config_include_set(name)
+                     @configuration.include_set(name)
+                 end
+
+             end
+        end
+
+        def config_include_set(name)
+            Spider.configuration.include_set(name)
+        end
+
+    end
+
+end