roby 0.8.0 → 3.0.0

data/bin/roby

@@ -1,210 +1,51 @@
 #! /usr/bin/env ruby
 
-APP_DIR  = Dir.pwd
-
-require 'optparse'
-require 'ostruct'
-require 'fileutils'
-require 'yaml'
-require 'find'
-
 require 'roby'
-
-MODES = %w{init robot}
-config = OpenStruct.new
-parser = OptionParser.new do |opt|
-    opt.banner = "Usage: roby mode [options]"
-    opt.on_tail('-h', '--help', 'this help message') do
-	if !config.mode
-	    global_help(opt)
-	end
-	STDERR.puts opt
-	exit
+require 'roby/cli/main'
+
+# Reset the interrupt handler to the default. An ignored handler is inherited,
+# so this makes sure that the Roby app is based on the handler's expected state
+trap('INT', 'DEFAULT')
+
+if ARGV.first
+    command_name = ARGV.first.tr('-', '_')
+    if Roby::CLI::Main.commands.has_key?(command_name)
+        begin
+            Roby::CLI::Main.start(ARGV)
+            exit 0
+        rescue Roby::CLI::CLIException => e
+            STDERR.puts Roby.color(e.message, :red)
+            exit 1
+        end
     end
 end
 
-def global_help(opt)
-    opt.separator ""
-    opt.separator "  Available modes:"
-    opt.separator "    init   creates new roby application, or adds the files needed by plugins"
-    opt.separator "    robot  creates a new robot type in this application"
-    opt.separator ""
-    opt.separator "  roby <mode> --help displays mode-specific help"
-    opt.separator ""
-    opt.separator "  Global options"
-end
-
-def mode_init(opt, config)
-    config.enabled_plugins = []
+ORIGINAL_ARGV = ARGV.dup
+mode = ARGV.shift
 
-    opt.banner = "Usage: roby [global options] init [options]"
-    opt.separator ""
-    opt.separator "  Creates an application template in the current directory, or"
-    opt.separator "  installs the files needed by a specific plugin in an already"
-    opt.separator "  existing application"
-    opt.separator ""
-    opt.separator "  Available options"
-    known_plugins = Roby.app.available_plugins.map { |name, _, _| name }
-    opt.on('-p', '--plugin NAME,NAME', Array, "install the files needed by the given plugins. Known plugins are: #{known_plugins.join(", ")}") do |new_plugins|
-	new_plugins.each do |name|
-	    if !known_plugins.include?(name)
-		STDERR.puts "unknown plugin #{name}. Known plugins are #{known_plugins}"
-	    end
-	    config.enabled_plugins << name
-	end
-    end
+KNOWN_MODES = Hash[
+    "gen" => "generate new Roby models / objects within a Roby appplication directory",
+    "run" => "start a Roby instance",
+    "shell" => "connect to a running Roby instance with a shell",
+    "test" => "run tests for this Roby app",
+    "autotest" => "run tests for this Roby app continuously",
+    "quit" => "ask a running Roby application to quit",
+    "restart" => "restart a running Roby application",
 
-    opt.separator ""
-    opt.separator "  Global options"
-end
-def mode_robot(opt, config)
-    opt.banner = "Usage: roby [global options] robot NAME"
-    opt.separator ""
-    opt.separator "  Creates the template for a new robot type"
-    opt.separator ""
-    opt.separator "  Global options"
-end
+    "init" => "create a new Roby app",
+    "add-robot" => "deprecated, use roby gen robot instead"
+]
 
-remaining = []
-parser.order(ARGV) do |arg|
-    if !config.mode
-	begin
-	    send("mode_#{arg}", parser, config)
-	    config.mode = arg
-	rescue NoMethodError
-	    STDERR.puts "Invalid mode of operation '#{arg}'. Valid modes are: #{MODES.join(", ")}"
-	    STDERR.puts parser
-	    exit(1)
-	end
-    else
-	remaining << arg
+if !mode || !KNOWN_MODES.has_key?(mode)
+    if mode
+        STDERR.puts "unknown mode #{mode}"
     end
-end
-
-module Roby
-    class Installer
-	# The directory in which we are installing
-	attr_reader :app_dir
-
-	# The configuration hash saved in config/roby.yml
-	attr_reader :config
-
-	def config_path; File.join(app_dir, 'config', 'roby.yml') end
-	def installed_plugins; config['plugins'] || [] end
-
-	def check_plugins(plugins)
-	    if name = plugins.find { |name| !Roby.app.defined_plugin?(name) }
-		known_plugins = Roby.app.available_plugins.map { |name, _| name }
-		raise ArgumentError, "unknown plugin #{name}. Available plugins are #{known_plugins.join(", ")}"
-	    end
-	end
-
-	def initialize(app_dir)
-	    @app_dir = File.expand_path(app_dir)
-
-	    # Read the application configuration from config/roby.yml if the file exists,
-	    @config = if File.file?(config_path)
-			  YAML.load_file(config_path)
-		      else
-			  Hash['plugins', []]
-		      end
-	    check_plugins(config['plugins'])
-	end
-
-	def save_config
-	    File.open(config_path, 'w') do |io|
-		io << YAML.dump(config)
-	    end
-	end
-
-	# Install the template files for a core Roby application and the provided
-	# plugins
-	def install(plugins)
-	    check_plugins(plugins)
-	    install_dir(plugins) do |file|
-		next if file =~ /ROBOT/
-		file
-	    end
-
-	    config['plugins'] |= plugins
-	    save_config
-	end
-
-	# Installs the template files for a new robot named +name+
-	def robot(name)
-	    install_dir(installed_plugins) do |file|
-		next if file !~ /ROBOT/
-		file.gsub /ROBOT/, name
-	    end
-	end
-
-	# Copies the template files into the application directory, without erasing
-	# already existing files. +plugins+ is the list of plugins we should copy
-	# files from
-	def install_dir(plugins = [], &filter)
-	    Installer.copy_tree(File.join(Roby::ROBY_ROOT_DIR, 'app'), app_dir, &filter)
-	    plugins.each do |enabled_name|
-		plugin_desc = Roby.app.available_plugins.find { |name, dir, _, _| enabled_name == name }
-
-		plugin_app_dir = File.join(plugin_desc[1], 'app')
-		next unless File.directory?(plugin_app_dir)
-		Installer.copy_tree(plugin_app_dir, app_dir, &filter)
-	    end
-	end
-
-	# Copy all files that are in +basedir+ into +destdir+. If a block is given,
-	# it is called with each file relative path. The block must then return the
-	# destination name, or nil if the file is to be skipped.
-	def self.copy_tree(basedir, destdir)
-	    basedir = File.expand_path(basedir)
-	    destdir = File.expand_path(destdir)
-
-	    Find.find(basedir) do |file|
-		relative = file.gsub /#{Regexp.quote("#{basedir}")}\/?/, ''
-		relative = yield(relative) if block_given?
-		# The block can return nil if the file shouldn't be installed
-		next unless relative
-
-		destfile = File.join(destdir, relative)
-		if File.directory?(file)
-		    if !File.exists?(destfile)
-			puts "creating #{relative}/"
-			Dir.mkdir destfile
-		    elsif !File.directory?(destfile)
-			STDERR.puts "#{destfile} exists but it is not a directory"
-			exit(1)
-		    end
-		else
-		    if !File.exists?(destfile)
-			FileUtils.cp file, destfile
-			puts "creating #{relative}"
-		    elsif !File.file?(destfile)
-			STDERR.puts "#{destfile} exists but it is not a file"
-			exit(1)
-		    end
-		end
-	    end
-	end
+    max_mode_length = KNOWN_MODES.keys.map(&:length).max
+    format = "%-#{max_mode_length}s %s"
+    KNOWN_MODES.each do |mode_name, mode_description|
+        STDERR.puts(format % [mode_name, mode_description])
     end
+    exit 1
 end
 
-if !config.mode
-    global_help(parser)
-    STDERR.puts parser
-    exit
-end
-
-installer = Roby::Installer.new(APP_DIR)
-if config.mode == 'init'
-    installer.install(config.enabled_plugins)
-
-elsif config.mode == 'robot'
-    unless robotname = remaining.shift
-	STDERR.puts "No robot name given on command line"
-	STDERR.puts parser
-	exit(1)
-    end
-
-    installer.robot(robotname)
-end
-
+require "roby/app/scripts/#{mode}"

data/bin/roby-display

@@ -0,0 +1,14 @@
+#! /usr/bin/env ruby
+
+begin
+    require 'roby/cli/display'
+    Roby::CLI::Display.start(ARGV)
+    exit 0
+rescue Interrupt
+    Roby.info "Interrupted by user"
+    exit 1
+rescue Exception => e
+    Roby.log_exception_with_backtrace(e, Roby, :warn)
+    exit 1
+end
+

data/bin/roby-log

@@ -1,178 +1,5 @@
 #! /usr/bin/env ruby
-require 'roby'
-require 'optparse'
-
-def usage
-    STDERR.puts <<-EOU
-roby-log mode [options]
-where the following modes are accepted:
-    list-servers    lists the log servers available
-    upgrade-format  upgrades an event log from an old format to the current one
-    rebuild-index   rebuilds the index file for the given event log
-    stats	    displays statistics about the given event log
-    replay	    displays data saved in logged files
-    display	    displays live data received from log servers
-    help	    this help message
-
-Call roby-log mode --help for more information about each mode
-    EOU
-end
-
-STDOUT.sync = true
-
-SERVER_LIST_TIMEOUT = 5
-SERVER_LIST_POLL = 0.1
-case mode = ARGV.shift
-when "list-servers"
-    DRb.start_service "druby://:0"
-
-    require 'roby/log/server'
-    puts "Finding available servers ... (#{SERVER_LIST_TIMEOUT} seconds)"
-
-    broadcast = if ARGV.empty? then ['localhost']
-		else ARGV
-		end
-
-    Roby::Log::Server.enable_discovery broadcast
-
-    begin
-	end_time = Time.now + SERVER_LIST_TIMEOUT
-	known_servers = []
-	while end_time > Time.now
-	    sleep(SERVER_LIST_POLL)
-	    Roby::Log::Server.available_servers.each do |server|
-		next if known_servers.include?(server)
-		known_servers << server
-
-		remote = Roby::Log::Client.new(server)
-		puts "#{server.__drburi}:"
-		remote.streams.each do |s|
-		    puts "  #{s.name} [#{s.type}]"
-		end
-	    end
-	end
-    rescue Interrupt
-    end
-    exit(0)
-
-when "upgrade-format"
-    require 'roby/log/file'
-    Roby::Log::FileLogger.to_new_format(ARGV[0])
-    exit(0)
-
-when "rebuild-index"
-    require 'roby/log/file'
-
-    Roby::Log::Logfile.open(ARGV[0]) do |logfile|
-	logfile.rebuild_index
-    end
-    exit(0)
-
-when "stats"
-    require 'roby/log/file'
-    require 'roby/log/timings'
-
-    filename = if ARGV[0] == "--csv"
-		   do_csv = true
-		   ARGV[1]
-               elsif ARGV[0] == "--help"
-                   puts "roby-log stats [--csv]"
-                   puts "  displays statistics about the execution timings"
-                   puts "  if the --csv option is given, a table with all"
-                   puts "  the timings is output on stdout instead"
-                   exit(0)
-               else
-		   ARGV[0]
-	       end
-    io = Roby::Log.open(filename)
-
-    cycle_count = io.index_data.size
-    timespan    = io.range
-    puts "#{cycle_count} cycles between #{timespan.first.to_hms} and #{timespan.last.to_hms}"
-    cpu_time = io.index_data.inject(0) { |old, info| old + info[:cpu_time] } / 1000
-    real_time = timespan.last - timespan.first
-    ratio = cpu_time / real_time
-    puts "Time: %.2fs CPU / %.2fs real (%i%% CPU use)" % [cpu_time, real_time, ratio * 100]
-
-    if io.index_data.first.has_key?(:event_count)
-	min, max = nil
-	event_count = io.index_data.inject(0) do |total, cycle_info|
-	    count = cycle_info[:event_count]
-	    min = count if !min || min > count
-	    max = count if !max || max < count
-	    total + count
-	end
-	puts "#{event_count} events, #{event_count / cycle_count} events/cycle (min: #{min}, max: #{max})"
-    else
-	puts "event count unavailable, please rebuild the index"
-    end
-
-    timings = Roby::Log::Timings.new(io)
-    if do_csv
-	timings.display(false)
-    else
-	timings.stats
-    end
-    exit(0)
-
-when "replay"
-    require 'roby/log/gui/replay'
-    app  = Qt::Application.new(ARGV)
-
-    main = Replay.setup(ARGV) do |main, parser, remaining|
-	if remaining.empty?
-	    if main.log_dir
-		streams = Roby.app.data_streams(main.log_dir)
-		streams.each do |stream|
-		    stream.open
-		    main.add_stream(stream)
-		end
-	    end
-	else
-	    remaining.each do |file|
-                if !File.exists?(file)
-		    STDERR.puts "WARN: #{file} does not exist"
-		elsif streams = Roby.app.data_streams_of([file])
-		    streams.each do |s|
-			s.open
-			main.add_stream(s)
-		    end
-		else
-		    STDERR.puts "WARN: unknown file type for #{file}"
-		end
-	    end
-	end
-    end
-
-    main.setup
-    begin
-	app.exec
-    rescue
-	STDERR.puts $!.full_message
-    end
-
-when "display"
-    require 'roby/log/gui/runtime'
-    DRb.start_service "druby://:0"
-    Roby::Log::Server.logger.level = Logger::DEBUG
-
-    broadcast = if ARGV.empty? then ['localhost']
-		else ARGV
-		end
-
-    a = Qt::Application.new([])
-    w = RuntimeDisplay.new(broadcast, Roby::Log::Server::RING_PORT, 5)
-    w.show
-    a.exec
-    exit(0)
-
-when "help"
-    usage
-    exit(0)
-
-else
-    STDERR.puts "no such mode of operation #{mode}"
-    usage
-    exit(1)
-end
+require 'roby/cli/log'
 
+Roby::CLI::Log.start(ARGV)
+exit 0

data/doc/guide/{src → attic}/abstraction/achieve_with.page

@@ -1,7 +1,7 @@
 ---
 title: Achieving event commands with tasks
 sort_info: 400
---- name:content pipeline:tags,markdown,blocks
+---
 
 * the achieve\_with operator
 * semantics of it