roby 0.8.0 → 3.0.0

data/lib/roby/app/cucumber/helpers.rb

@@ -0,0 +1,280 @@
+require 'utilrb/hash/map_value'
+
+module Roby
+    module App
+        # Module with helpers to be used in cucumber specifications
+        module CucumberHelpers
+            # Exception raised when a unit that cannot be interpreted is
+            # encountered
+            class InvalidUnit < ArgumentError; end
+
+            # Exception raised when two arguments should have the same set of
+            # names but one has a name that the reference does not
+            class MissingArgument < ArgumentError; end
+
+            # Exception raised when two arguments should have the same set of
+            # names but one has a name that the reference does not
+            class UnexpectedArgument < ArgumentError; end
+
+            # Exception raised by {.parse_arguments_respectively} when one uses
+            # the explicit and implicit syntaxes at the same time
+            class MixingOrderAndNames < ArgumentError; end
+
+            # Parsing of a set of quantities, in the form
+            #
+            #   x=VAL, y=VAL and z=VAL
+            #
+            # The value can be specified as a numerical value with unit, in
+            # which case the value is converted into the corresponding SI unit,
+            # as e.g.
+            #
+            #   yaw=10deg
+            #
+            # will be converted to
+            #
+            #   Hash[yaw: 0.1745] # 10 degrees in radians
+            def self.parse_arguments(raw_arguments, expected = Hash.new, strict: true)
+                hash = parse_argument_text_to_hash(raw_arguments)
+                parse_hash_numerical_values(hash, expected, strict: strict)
+            end
+
+            def self.parse_hash_numerical_values(hash, expected = Hash.new, strict: true)
+                hash.map_value do |key, value|
+                    expected_quantity = expected[key]
+                    if strict && !expected_quantity
+                        raise UnexpectedArgument, "unexpected argument found #{key}"
+                    elsif value.kind_of?(Hash)
+                        parse_hash_numerical_values(value, expected_quantity || Hash.new, strict: strict)
+                    elsif value_with_unit = try_numerical_value_with_unit(value)
+                        if expected_quantity
+                            validate_unit(key, *value_with_unit, expected_quantity)
+                        end
+                        apply_unit(*value_with_unit)
+                    elsif expected_quantity
+                        raise InvalidUnit, "expected #{key}=#{value} to be a #{expected_quantity}, but it got no unit"
+                    else
+                        begin
+                            Integer(value)
+                        rescue ArgumentError
+                            begin
+                                Float(value)
+                            rescue ArgumentError
+                                value
+                            end
+                        end
+                    end
+                end
+            end
+
+            class UnexpectedArgument < ArgumentError; end
+            class InvalidSyntax < ArgumentError; end
+
+            def self.validate_unit(name, value, unit, quantity)
+                if quantity == :length
+                    if unit != 'm'
+                        raise InvalidUnit, "expected a length in place of #{name}=#{value}#{unit}"
+                    end
+                elsif quantity == :angle
+                    if unit != 'deg'
+                        raise InvalidUnit, "expected an angle in place of #{name}=#{value}#{unit}"
+                    end
+                elsif quantity == :time
+                    if !%w{h min s}.include?(unit)
+                        raise InvalidUnit, "expected a time in place of #{name}=#{value}#{unit}"
+                    end
+                else raise ArgumentError, "unknown quantity definition '#{quantity}', expected one of :length, :angle or :time"
+                end
+            end
+
+            def self.parse_argument_text_to_hash(raw_arguments)
+                current = Hash.new
+                stack   = Array.new
+                scanner = StringScanner.new(raw_arguments)
+                while !scanner.eos?
+                    arg_name = scanner.scan_until(/=/)
+                    if !arg_name
+                        raise InvalidSyntax, "expected to find '=' in #{raw_arguments}\n#{" " * (24 + scanner.pos)}^"
+                    end
+                    arg_name = arg_name[0, arg_name.size - 1].to_sym
+
+                    if scanner.peek(1) == '{'
+                        scanner.getch
+                        stack << current
+                        current[arg_name] = (child = Hash.new)
+                        current = child
+                    else
+                        match = scanner.scan_until(/(\s*,\s*|\s+and\s+|\s*}\s*)/)
+                        if match && (scanner[1].strip == '}')
+                            current[arg_name] = match[0, match.size - scanner[1].size]
+
+                            begin
+                                current = stack.pop
+                                if !current
+                                    raise InvalidSyntax, "unbalanced closed hash"
+                                end
+                            end while scanner.scan(/\s*}\s*/)
+
+                            if !scanner.eos? && !scanner.scan(/\s*,\s*|\s+and\s+/)
+                                raise InvalidSyntax, "expected comma or 'and' after }"
+                            end
+                        elsif match
+                            current[arg_name] = match[0, match.size - scanner[1].size]
+                        else
+                            current[arg_name] = scanner.rest
+                            scanner.terminate
+                        end
+                    end
+                end
+                if !stack.empty?
+                    raise InvalidSyntax, "expected closing } at the end of string"
+                end
+                current
+            end
+
+            # Parsing of a set of quantities that follow another already given
+            # set
+            #
+            # @example pose with tolerance
+            #   the pose x=10m and y=20m with tolerance 1m and 1m
+            #
+            def self.parse_arguments_respectively(reference, raw_arguments, expected = Hash.new, strict: true)
+                arguments = Hash.new
+                has_implicit, has_explicit = false, false
+                raw_arguments = raw_arguments.split(/(?:, | and )/)
+
+                # Same value for all keys
+                if raw_arguments.size == 1 && (raw_arguments.first !~ /=/)
+                    arg_value = raw_arguments.first
+
+                    if strict
+                        reference.each do |key|
+                            if !expected[key]
+                                raise UnexpectedArgument, "unexpected argument found #{key}"
+                            end
+                        end
+                    end
+
+                    if value_with_unit = try_numerical_value_with_unit(arg_value)
+                        reference.each do |key|
+                            if expectation = expected[key]
+                                validate_unit(key, *value_with_unit, expectation)
+                            end
+                        end
+                        arg_value = apply_unit(*value_with_unit)
+                    else
+                        reference.each do |key|
+                            is_numeric = Float(arg_value) rescue nil
+                            if expectation = expected[key]
+                                if is_numeric
+                                    raise InvalidUnit, "expected #{key}=#{arg_value} to be a #{expectation}, but it got no unit"
+                                else
+                                    raise InvalidUnit, "expected #{key}=#{arg_value} to be a #{expectation}, but it is not even a number"
+                                end
+                            end
+                        end
+                    end
+                    reference.each do |key|
+                        arguments[key] = arg_value
+                    end
+                    return arguments
+                end
+
+                raw_arguments.each_with_index do |arg, arg_i|
+                    arg_name, arg_value = arg.split('=')
+
+                    if arg_value
+                        if has_implicit
+                            raise MixingOrderAndNames, "cannot mix order-based syntax and explicit names"
+                        end
+                        has_explicit = true
+                    else
+                        if has_explicit
+                            raise MixingOrderAndNames, "cannot mix order-based syntax and explicit names"
+                        end
+                        arg_name, arg_value = reference[arg_i], arg_name
+                        if !arg_name
+                            raise UnexpectedArgument, "too many implicit values given, expected #{reference.size} (#{reference.join(", ")})"
+                        end
+                        has_implicit = true
+                    end
+
+                    expected_quantity = expected[arg_name.to_sym]
+                    if strict && !expected_quantity
+                        raise UnexpectedArgument, "unexpected argument found #{arg_name}"
+                    elsif value_with_unit = try_numerical_value_with_unit(arg_value)
+                        if expected_quantity
+                            validate_unit(arg_name, *value_with_unit, expected_quantity)
+                        end
+                        arg_value = apply_unit(*value_with_unit)
+                    elsif expected_quantity
+                        raise InvalidUnit, "expected #{arg_name}=#{arg_value} to be a #{expected_quantity}"
+                    end
+                    if !reference.include?(arg_name.to_sym)
+                        raise UnexpectedArgument, "got '#{arg_name}' but was expecting one of #{reference.map(&:to_s).sort.join(", ")}"
+                    end
+                    arguments[arg_name.to_sym] = arg_value
+                end
+
+                if arguments.keys.to_set != reference.to_set
+                    missing = reference.to_set - arguments.keys
+                    raise MissingArgument, "missing #{missing.size} argument(s) (for #{missing.map(&:to_s).sort.join(", ")})"
+                end
+                arguments
+            end
+
+            # Parses a numerical value, possibly with a unit, in which case it
+            # is converted to the corresponding "natural" unit (e.g. meters,
+            # seconds, ...)
+            #
+            # @return [(Float,String)] the normalized value and the unit
+            def self.parse_numerical_value(text, expected_quantity = nil)
+                value, unit = try_numerical_value_with_unit(text)
+                if unit
+                    if expected_quantity
+                        validate_unit(nil, value, unit, expected_quantity)
+                    end
+                    return apply_unit(value, unit), unit
+                elsif expected_quantity
+                    raise InvalidUnit, "expected a #{expected_quantity}, but got #{text}"
+                else
+                    Float(text)
+                end
+            end
+
+            # @api private
+            #
+            # Helper that identifies a value which looks like a numerical value
+            # with unit and returns it as (numeric, unit)
+            #
+            # @return [(Numeric,String),nil]
+            def self.try_numerical_value_with_unit(string)
+                if string =~ /^(-?\.\d+|-?\d+(?:\.\d+)?)([^\d\.]\w*)$/
+                    return Float($1), $2
+                end
+            end
+
+            # @api private
+            #
+            # Helper that converts a value with unit into the corresponding
+            # normalized value (e.g. degrees to radians)
+            #
+            # @raise InvalidUnit if the unit parameter is unknown
+            def self.apply_unit(value, unit)
+                if unit == 'deg'
+                    value * Math::PI / 180
+                elsif unit == 'm'
+                    value
+                elsif unit == 'h'
+                    value * 3600
+                elsif unit == 'min'
+                    value * 60
+                elsif unit == 's'
+                    value
+                else
+                    raise InvalidUnit, "unknown unit #{unit}, known units are deg, m (meters), h (hour), min (minute) and s (seconds)"
+                end
+            end
+        end
+    end
+end
+

data/lib/roby/app/cucumber/world.rb

@@ -0,0 +1,32 @@
+require 'roby/app/cucumber'
+
+module Roby
+    module App
+        module Cucumber
+            module World
+                attr_reader :roby_controller
+
+                def roby_world_initialize
+                    @roby_controller = Controller.new
+                end
+
+                def self.extend_object(world)
+                    super
+                    world.roby_world_initialize
+                end
+            end
+        end
+    end
+end
+
+After do |scenario|
+    if kind_of?(Roby::App::Cucumber::World)
+        if roby_controller.roby_running?
+            if !roby_controller.roby_connected? # failed to connect, kill forcefully
+                roby_controller.roby_kill
+            else
+                roby_controller.roby_stop
+            end
+        end
+    end
+end

data/lib/roby/app/debug.rb

@@ -0,0 +1,136 @@
+require 'stackprof'
+require 'rbtrace'
+require 'objspace'
+
+module Roby
+    module App
+        # A command library that allows to control StackProf to profile a Roby
+        # application
+        class Debug < Roby::Interface::CommandLibrary
+            # Start profiling
+            #
+            # @param [Boolean] one_shot automatically stop and save after cycles
+            #   cycles, or one cycle if cycles is nil
+            # @param [Integer] cycles a number of cycles after which the
+            #   profiling is stopped and saved
+            # @param [String] path the path into which results should be saved
+            # @param [Symbol] mode one of :cpu, :wall or :object
+            # @param [Integer] interval the sampling interval in microseconds
+            #   for :cpu and :wall (defaults to 1000, that is 1ms), and the
+            #   sampling rate in objects allocated for :object (defaults to 1)
+            # @param [Boolean] raw whether the dump should include raw samples,
+            #   needed e.g. for flamegraph generation
+            def stackprof_start(one_shot: false, cycles: nil, mode: :cpu, interval: nil, raw: false)
+                interval ||= if mode == :object then 1
+                             else 1000
+                             end
+                StackProf.start(mode: mode, interval: interval, raw: raw)
+
+                if one_shot && !cycles
+                    cycles = 1
+                end
+
+                if cycles
+                    remaining_cycles = cycles
+                    @cycle_counter_handler = execution_engine.at_cycle_begin do
+                        remaining_cycles -= 1
+                        if remaining_cycles == 0
+                            execution_engine.at_cycle_end(once: true) do
+                                remaining_cycles = cycles
+                                StackProf.stop
+                                path = stackprof_save
+                                app.notify "profiling", 'INFO', "results saved in #{path} after #{cycles} cycles"
+                                if one_shot
+                                    app.notify "profiling", 'INFO', "stopped"
+                                    execution_engine.remove_propagation_handler(@cycle_counter_handler)
+                                    @cycle_counter_handler = nil
+                                else
+                                    StackProf.start(mode: mode, interval: interval)
+                                end
+                            end
+                        end
+                    end
+                    nil
+                end
+            end
+            command 'stackprof_start', "start profiling",
+                one_shot: "if true, saves and stops profiling after a certain number of cycles",
+                cycles: "a number of cycles after which profiling results are saved, and if one_shot is true, profiling is stopped",
+                path: "the directory under which the results should be saved",
+                mode: "sampling mode, one of :cpu, :wall or :object",
+                interval: "sampling interval. Either microseconds for :cpu and :wall (defaults to 1000, that is 1ms), or a number of objects for :object (defaults to one)",
+                raw: "whether the profile should include raw samples, needed for e.g. flamegraph generation"
+
+            def stackprof_active?
+                !!@cycle_counter_handler
+            end
+            command 'stackprof_active?', "whether stackprof profiling has been started",
+
+            # Stop profiling
+            #
+            # This does not save the results, call {#save} for this
+            def stackprof_stop
+                StackProf.stop
+                if @cycle_counter_handler
+                    execution_engine.remove_propagation_handler(@cycle_counter_handler)
+                    @cycle_counter_handler = nil
+                end
+            end
+            command 'stackprof_stop', "stops profiling. This does not save the results to disk, call #save explicitely for that"
+
+            # @api private
+            #
+            # The filename that is used by default in {#save}. It is relative to
+            # {#path}
+            #
+            # It is a time tag (down to the milliseconds) followed by the
+            # sampling mode and a .dump extension
+            def default_path(prefix)
+                path = File.join(app.log_dir, 'debug')
+                time = Time.now.strftime("%Y-%m-%d.%H%M%S.%3N")
+                File.join(path, "#{prefix}-#{time}.dump")
+            end
+
+            # Save the current profiling results into the path given to {#start} 
+            #
+            # @param [String]
+            def stackprof_save(path: default_path('stackprof-%s'))
+                if results = StackProf.results
+                    path = path % [results[:mode]]
+                    FileUtils.mkdir_p(File.dirname(path))
+                    File.open(path, 'wb') do |f|
+                        f.write Marshal.dump(results)
+                    end
+                    path
+                end
+            end
+            command 'stackprof_save', "saves the profiling results under the path specified in #start, by default is log_dir/stackprof"
+
+            # Perform a memory dump
+            def memdump(path: default_path('memdump'), run_gc: true)
+                FileUtils.mkdir_p File.dirname(path)
+                File.open(path, 'wb') do |io|
+                    GC.start(full_mark: true, immediate_sweep: true) if run_gc
+                    ObjectSpace.dump_all(output: io)
+                end
+                path
+            end
+            command 'memdump', 'save a dump of the whole memory space',
+                path: "the file path where it should be saved, defaults to an automatically-generated file name in the debug/ subdirectory of the app's log directory"
+
+            # Enable or disable allocation traces for {#memdump}
+            def trace_allocations(enable)
+                if enable
+                    ObjectSpace.trace_object_allocations_start
+                else
+                    ObjectSpace.trace_object_allocations_stop
+                    ObjectSpace.trace_object_allocations_clear
+                end
+            end
+            command 'trace_allocations', 'whether location where allocations happen should be traced',
+                enable: 'enable (true) or disable (false)'
+        end
+        Roby::Interface::Interface.subcommand 'debug', Debug, "debug-related commands"
+    end
+end
+

data/lib/roby/app/gen.rb

@@ -0,0 +1,2 @@
+require 'roby/app/gen_base'
+require 'roby/app/gen_model_class'