roby 0.8.0 → 3.0.0

data/lib/roby/queries.rb

@@ -0,0 +1,23 @@
+module Roby
+    # Namespace for all query and matching-related functionality
+    module Queries
+    end
+end
+
+require 'roby/queries/any'
+require 'roby/queries/none'
+require 'roby/queries/matcher_base'
+require 'roby/queries/index'
+require 'roby/queries/plan_object_matcher'
+require 'roby/queries/task_matcher'
+require 'roby/queries/event_generator_matcher'
+require 'roby/queries/task_event_generator_matcher'
+require 'roby/queries/query'
+require 'roby/queries/and_matcher'
+require 'roby/queries/not_matcher'
+require 'roby/queries/or_matcher'
+
+require 'roby/queries/localized_error_matcher'
+require 'roby/queries/code_error_matcher'
+require 'roby/queries/execution_exception_matcher'
+

data/lib/roby/queries/and_matcher.rb

@@ -0,0 +1,32 @@
+module Roby
+    module Queries
+
+    # This task combines multiple task matching predicates through a AND boolean
+    # operator. I.e. it will match if none of the underlying predicates match.
+    class AndMatcher < MatcherBase
+        # Create a new AndMatcher object combining the given predicates.
+        def initialize(*ops)
+            @ops = ops 
+        end
+
+        # Filters as much as non-matching tasks as possible out of +task_set+,
+        # based on the information in +task_index+
+        def filter(task_set, task_index)
+            result = task_set
+            for child in @ops
+                result &= child.filter(task_set, task_index)
+            end
+            result
+        end
+
+        # Add a new predicate to the combination
+        def <<(op); @ops << op end
+
+        # True if the task matches at least one of the underlying predicates
+        def ===(task)
+            @ops.all? { |op| op === task }
+        end
+    end
+
+    end
+end

data/lib/roby/queries/any.rb

@@ -0,0 +1,27 @@
+module Roby
+    module Queries
+        # Implementation of a singleton object that match any other object
+        module Any
+            # @return [Boolean] match operator, always returns true
+            def self.===(other)
+                true
+            end
+
+            class DRoby
+                def proxy(peer)
+                    Queries.any
+                end
+            end
+
+            def self.droby_dump(peer)
+                DRoby.new
+            end
+        end
+
+        # @return [Any] an object that matches anything
+        def self.any
+            Any
+        end
+    end
+end
+

data/lib/roby/queries/code_error_matcher.rb

@@ -0,0 +1,58 @@
+module Roby
+    module Queries
+        # Matcher for CodeError exceptions
+        #
+        # In addition to the LocalizedError properties, it allows to match
+        # properties on the Ruby exception that has been thrown
+        class CodeErrorMatcher < LocalizedErrorMatcher
+            attr_reader :ruby_exception_class
+            def initialize
+                super
+                @ruby_exception_class = ::Exception
+                with_model(CodeError)
+            end
+
+            # Match the underlying ruby exception
+            #
+            # @param [#===,Class] matcher an object that can match an Exception
+            #   object, usually an exception class
+            def with_ruby_exception(matcher)
+                with_original_exception(matcher)
+                @ruby_exception_class = matcher
+                self
+            end
+
+            # Match a CodeError without an original exception
+            def without_ruby_exception
+                with_ruby_exception(nil)
+            end
+
+            def ===(error)
+                return false if !super
+                ruby_exception_class === error.error
+            end
+
+            def to_s
+                description = super
+                if ruby_exception_class
+                    description.concat(".with_ruby_exception(#{ruby_exception_class})")
+                else
+                    description.concat(".without_ruby_exception")
+                end
+            end
+
+            def describe_failed_match(exception)
+                if description = super
+                    return description
+                elsif !(ruby_exception_class === exception.error)
+                    if ruby_exception_class
+                        return "the underlying exception #{exception.error} does not match the expected #{ruby_exception_class}"
+                    else
+                        return "there is an underlying exception (#{exception.error}) but the matcher expected none"
+                    end
+                end
+            end
+        end
+    end
+end
+

data/lib/roby/queries/event_generator_matcher.rb

@@ -0,0 +1,9 @@
+module Roby
+    module Queries
+        # Object that allows to describe an event generator and match it in the
+        # plan
+        class EventGeneratorMatcher < PlanObjectMatcher
+        end
+    end
+end
+

data/lib/roby/queries/execution_exception_matcher.rb

@@ -0,0 +1,165 @@
+module Roby
+    module Queries
+        # Object that allows to specify generalized matches on a Roby::ExecutionException
+        # object
+        class ExecutionExceptionMatcher
+            # An object that will be used to match the actual (Ruby) exception
+            # @return [LocalizedErrorMatcher]
+            attr_reader :exception_matcher
+            # An object that will be used to match the exception origin
+            # @return [Array<#===,TaskMatcher>]
+            attr_reader :involved_tasks_matchers
+
+            def initialize
+                @exception_matcher = LocalizedErrorMatcher.new
+                @involved_tasks_matchers = Array.new
+                @expected_edges = nil
+                @handled = nil
+            end
+
+            def handled(flag = true)
+                @handled = flag
+                self
+            end
+
+            def not_handled
+                handled(false)
+            end
+
+            # Sets the exception matcher object
+            def with_exception(exception_matcher)
+                @exception_matcher = exception_matcher
+                self
+            end
+
+            # (see LocalizedErrorMatcher#with_model)
+            def with_model(exception_model)
+                exception_matcher.with_model(exception_model)
+                self
+            end
+
+            # (see LocalizedErrorMatcher#with_origin)
+            def with_origin(plan_object_matcher)
+                exception_matcher.with_origin(plan_object_matcher)
+                self
+            end
+
+            # (see LocalizedErrorMatcher#fatal)
+            def fatal
+                exception_matcher.fatal
+                self
+            end
+
+            def with_empty_trace
+                @expected_edges = Set.new
+                self
+            end
+
+            # Match the exception trace
+            #
+            # The trace is a representation of the exception's propagation
+            # during Roby's exception propagation phase. This verifies that the
+            # graph contains the edges specified by its argument
+            #
+            # @overload with_trace(*edges)
+            #   @param [Array<Task>] edges specify the edges of the propagation
+            #     graph two-by-two, source then sink
+            #
+            #     @example match a graph with (source0, sink0), (source0, sink1) edges
+            #       with_trace(source0, sink0, source0, sink1)
+            #
+            # @overload with_trace(edges)
+            #   @param [Hash] edges specify edges as a mapping. Edges that share
+            #     the same source must be specified as source=>[sink0, sink1]
+            #
+            #     @example match a graph with (source0, sink0), (source0, sink1) edges
+            #       with_trace(source0 => [sink0, sink1])
+            #
+            def with_trace(*edges)
+                if edges.first.kind_of?(Hash)
+                    edges = edges.first.to_a.flat_map do |source, targets|
+                        Array(targets).flat_map { |t| [source, t] }
+                    end
+                end
+                @expected_edges = edges.each_slice(2).map { |a, b| [a, b, nil] }.to_set
+                self
+            end
+
+            # Matched exceptions must have a task in their trace that matches
+            # the given task matcher
+            #
+            # @param [TaskMatcher] task_matcher
+            def involving(task_matcher)
+                involved_tasks_matchers << origin_matcher
+                self
+            end
+
+            def to_s
+                PP.pp(self, "")
+            end
+
+            def pretty_print(pp)
+                pp.text "ExecutionException("
+                exception_matcher.pretty_print(pp)
+                pp.text ")"
+                if !involved_tasks_matchers.empty?
+                    pp.text ".involving("
+                    pp.nest(2) do
+                        involved_tasks_matchers.each do |m|
+                            pp.breakable
+                            m.pretty_print(pp)
+                        end
+                    end
+                    pp.text ")"
+                end
+                if @expected_edges
+                    pp.text ".with_trace("
+                    pp.nest(2) do
+                        @expected_edges.each do |a, b, _|
+                            pp.breakable
+                            pp.text "#{a} => #{b}"
+                        end
+                    end
+                    pp.text ")"
+                end
+                if !@handled.nil?
+                    if @handled
+                        pp.text ".handled"
+                    else
+                        pp.text ".not_handled"
+                    end
+                end
+            end
+
+            # @return [Boolean] true if the given execution exception object
+            #   matches self, false otherwise
+            def ===(exception)
+                if !exception.respond_to?(:to_execution_exception)
+                    return false
+                end
+                exception = exception.to_execution_exception
+                exception_matcher === exception.exception &&
+                    involved_tasks_matchers.all? { |m| exception.trace.any? { |t| m === t } } &&
+                    (!@expected_edges || (@expected_edges == exception.trace.each_edge.to_set)) &&
+                    (@handled.nil? || !(@handled ^ exception.handled?))
+            end
+
+            def describe_failed_match(exception)
+                if !(exception_matcher === exception.exception)
+                    return exception_matcher.describe_failed_match(exception.exception)
+                elsif missing_involved_task = involved_tasks_matchers.find { |m| exception.trace.none? { |t| m === t } }
+                    return "#{missing_involved_task} cannot be found in the exception trace\n  #{exception.trace.map(&:to_s).join("\n  ")}"
+                end
+            end
+
+            def matches_task?(task)
+                involved_tasks_matchers.all? { |m| m === task } &&
+                    exception_matcher.matches_task?(task)
+            end
+
+            def to_execution_exception_matcher
+                self
+            end
+        end
+    end
+end

data/lib/roby/queries/index.rb

@@ -0,0 +1,165 @@
+module Roby
+    module Queries
+    # Maintains a set of tasks as classified sets, speeding up query operations.
+    #
+    # @see {Roby::Plan#task_index} {Roby::Queries::Query}
+    class Index
+        # A model => Set map of the tasks for each model
+        attr_reader :by_model
+        # A state => Set map of tasks given their state. The state is
+        # a symbol in [:pending, :starting, :running, :finishing,
+        # :finished]
+        attr_reader :by_predicate
+        # A peer => Set map of tasks given their owner.
+        attr_reader :by_owner
+        # Tasks that are locally owned
+        attr_reader :self_owned
+
+        STATE_PREDICATES = [:pending?, :starting?, :running?, :finished?, :success?, :failed?].to_set
+        PREDICATES = STATE_PREDICATES.dup
+
+        def initialize
+            @by_model = Hash.new do |h, k|
+                set = Set.new
+                set.compare_by_identity
+                h[k] = set
+            end
+            @by_predicate = Hash.new
+            @by_predicate.compare_by_identity
+            STATE_PREDICATES.each do |state_name|
+                set = Set.new
+                set.compare_by_identity
+                by_predicate[state_name] = set
+            end
+            @self_owned = Set.new
+            @self_owned.compare_by_identity
+            @by_owner = Hash.new
+            @by_owner.compare_by_identity
+        end
+
+        def merge(source)
+            source.by_model.each do |model, set|
+                by_model[model].merge(set)
+            end
+            source.by_predicate.each do |state, set|
+                by_predicate[state].merge(set)
+            end
+            self_owned.merge(source.self_owned)
+            source.by_owner.each do |owner, set|
+                (by_owner[owner] ||= Set.new).merge(set)
+            end
+        end
+
+        def initialize_copy(source)
+            super
+
+            @by_model = Hash.new { |h, k| h[k] = Set.new }
+            source.by_model.each do |model, set|
+                by_model[model] = set.dup
+            end
+
+            @by_predicate = Hash.new
+            source.by_predicate.each do |state, set|
+                by_predicate[state] = set.dup
+            end
+
+            @self_owned = source.self_owned.dup
+
+            @by_owner = Hash.new
+            source.by_owner.each do |owner, set|
+                by_owner[owner] = set.dup
+            end
+        end
+
+        def clear
+            @by_model.clear
+            @by_predicate.each_value(&:clear)
+            @by_owner.clear
+            @self_owned.clear
+        end
+
+        # Add a new task to this index
+        def add(task)
+            for klass in task.model.ancestors
+                by_model[klass] << task
+            end
+            for pred in PREDICATES
+                if task.send(pred)
+                    by_predicate[pred] << task
+                end
+            end
+            if task.self_owned?
+                self_owned << task
+            end
+            for owner in task.owners
+                add_owner(task, owner)
+            end
+        end
+
+        # Updates the index to reflect that +new_owner+ now owns +task+
+        def add_owner(task, new_owner)
+            if task.self_owned?
+                self_owned << task
+            end
+            (by_owner[new_owner] ||= Set.new) << task
+        end
+
+        # Updates the index to reflect that +peer+ no more owns +task+
+        def remove_owner(task, peer)
+            if set = by_owner[peer]
+                set.delete(task)
+                if set.empty?
+                    by_owner.delete(peer)
+                end
+            end
+            if !task.self_owned?
+                self_owned.delete(task)
+            end
+        end
+
+        # Updates the index to reflect a change of state for +task+
+        def set_state(task, new_state)
+            for state in STATE_PREDICATES
+                by_predicate[state].delete(task)
+            end
+            add_state(task, new_state)
+        end
+
+        def add_state(task, new_state)
+            add_predicate(task, new_state)
+        end
+
+        def remove_state(task, state)
+            remove_predicate(task, state)
+        end
+
+        def add_predicate(task, predicate)
+            by_predicate[predicate] << task
+        end
+
+        def remove_predicate(task, predicate)
+            by_predicate[predicate].delete(task)
+        end
+
+
+        # Remove all references of +task+ from the index.
+        def remove(task)
+            for klass in task.model.ancestors
+                set = by_model[klass]
+                set.delete(task)
+                if set.empty?
+                    by_model.delete(klass)
+                end
+            end
+            for state_set in by_predicate
+                state_set.last.delete(task)
+            end
+            self_owned.delete(task)
+            for owner in task.owners
+                remove_owner(task, owner)
+            end
+        end
+    end
+    end
+end
+