rsmp 0.35.2 → 0.38.0

data/lib/rsmp/collect/collector.rb

@@ -1,18 +1,21 @@
 module RSMP
-
   # Collects messages from a distributor.
   # Can filter by message type, componet and direction.
   # Wakes up the once the desired number of messages has been collected.
   class Collector
     include Receiver
+    include Status
+    include Reporting
+    include Logging
+
     attr_reader :condition, :messages, :status, :error, :task, :m_id
 
-    def initialize distributor, options={}
+    def initialize(distributor, options = {})
       initialize_receiver distributor, filter: options[:filter]
       @options = {
         cancel: {
           schema_error: true,
-          disconnect: false,
+          disconnect: false
         }
       }.deep_merge options
       @timeout = options[:timeout]
@@ -20,34 +23,31 @@ module RSMP
       @m_id = options[:m_id]
       @condition = Async::Notification.new
       make_title options[:title]
-      
+
       if task
         @task = task
-      else
-         # if distributor is a Proxy, or some other object that implements task(),
-         # then try to get the task that way
-        if distributor.respond_to? 'task'
-          @task = distributor.task
-        end
+      elsif distributor.respond_to? 'task'
+        # if distributor is a Proxy, or some other object that implements task(),
+        # then try to get the task that way
+        @task = distributor.task
       end
       reset
     end
 
-    def make_title title
-      if title
-        @title = title
-      elsif @filter
-        @title = [@filter.type].flatten.join('/')
-      else
-        @title = ""
-      end
+    def make_title(title)
+      @title = if title
+                 title
+               elsif @filter
+                 [@filter.type].flatten.join('/')
+               else
+                 ''
+               end
     end
 
-    def use_task task
+    def use_task(task)
       @task = task
     end
 
-    # Clear all matcher results
     def reset
       @messages = []
       @error = nil
@@ -56,65 +56,31 @@ module RSMP
 
     # Inspect formatter that shows the message we have collected
     def inspect
-      "#<#{self.class.name}:#{self.object_id}, #{inspector(:@messages)}>"
-    end
-
-    # Is collection active?
-    def collecting?
-      @status == :collecting
-    end
-
-    # Is collection complete?
-    def ok?
-      @status == :ok
-    end
-
-    # Has collection timed out?
-    def timeout?
-      @status == :timeout
-    end
-
-    # Is collection ready to start?
-    def ready?
-      @status == :ready
-    end
-
-    # Has collection been cancelled?
-    def cancelled?
-      @status == :cancelled
-    end
-
-    # Want ingoing messages?
-    def ingoing?
-      @ingoing == true
-    end
-
-    # Want outgoing messages?
-    def outgoing?
-      @outgoing == true
+      "#<#{self.class.name}:#{object_id}, #{inspector(:@messages)}>"
     end
 
     # if an errors caused collection to abort, then raise it
     # return self, so this can be tucked on to calls that return a collector
     def ok!
       raise @error if @error
+
       self
     end
 
     # Collect message
     # Will return once all messages have been collected, or timeout is reached
-    def collect &block
-      start &block
+    def collect(&)
+      start(&)
       wait
       @status
     ensure
-      @distributor.remove_receiver self if @distributor
+      @distributor&.remove_receiver self
     end
 
     # Collect message
     # Returns the collected messages, or raise an exception in case of a time out.
-    def collect! &block
-      collect(&block)
+    def collect!(&)
+      collect(&)
       ok!
       @messages
     end
@@ -141,40 +107,44 @@ module RSMP
     def wait!
       wait
       raise @error if timeout?
+
       @messages
     end
 
     # Start collection and return immediately
     # You can later use wait() to wait for completion
-    def start &block
-      raise RuntimeError.new("Can't start collectimng unless ready (currently #{@status})") unless ready?
+    def start(&block)
+      raise "Can't start collectimng unless ready (currently #{@status})" unless ready?
+
       @block = block
-      raise ArgumentError.new("Num, timeout or block must be provided") unless @num || @timeout || @block
+      raise ArgumentError, 'Num, timeout or block must be provided' unless @num || @timeout || @block
+
       reset
       @status = :collecting
       log_start
-      @distributor.add_receiver self if @distributor
+      @distributor&.add_receiver self
     end
 
     # Check if we receive a NotAck related to initiating request, identified by @m_id.
-    def reject_not_ack message
+    def reject_not_ack(message)
       return unless @m_id
-      if message.is_a?(MessageNotAck)
-        if message.attribute('oMId') == @m_id
-          m_id_short = RSMP::Message.shorten_m_id @m_id, 8
-          cancel RSMP::MessageRejected.new("#{@title} #{m_id_short} was rejected with '#{message.attribute('rea')}'")
-          @distributor.log "#{identifier}: cancelled due to a NotAck", level: :debug
-          true
-        end
-      end
+
+      return unless message.is_a?(MessageNotAck)
+      return unless message.attribute('oMId') == @m_id
+
+      m_id_short = RSMP::Message.shorten_m_id @m_id, 8
+      cancel RSMP::MessageRejected.new("#{@title} #{m_id_short} was rejected with '#{message.attribute('rea')}'")
+      @distributor.log "#{identifier}: cancelled due to a NotAck", level: :debug
+      true
     end
 
-    # Handle message. and return true when we're done collecting
-    def receive message
+    # Handle message and return true if we're done collecting
+    def receive(message)
       raise ArgumentError unless message
       unless ready? || collecting?
-        raise RuntimeError.new("can't process message when status is :#{@status}, title: #{@title}, desc: #{describe}") 
+        raise "can't process message when status is :#{@status}, title: #{@title}, desc: #{describe}"
       end
+
       if perform_match message
         if done?
           complete
@@ -185,17 +155,17 @@ module RSMP
       @status
     end
 
-    def describe
-    end
+    def describe; end
 
     # Match message against our collection criteria
-    def perform_match message
+    def perform_match(message)
       return false if reject_not_ack(message)
       return false unless acceptable?(message)
-      #@distributor.log "#{identifier}: Looking at #{message.type} #{message.m_id_short}", level: :collect
+
       if @block
         status = [@block.call(message)].flatten
         return unless collecting?
+
         keep message if status.include?(:keep)
       else
         keep message
@@ -227,9 +197,8 @@ module RSMP
       @condition.signal
     end
 
-    # An error occured upstream.
-    # Check if we should cancel.
-    def receive_error error, options={}
+    # Handle upstream error
+    def receive_error(error, options = {})
       case error
       when RSMP::SchemaError
         receive_schema_error error, options
@@ -239,93 +208,43 @@ module RSMP
     end
 
     # Cancel if we received e schema error for a message type we're collecting
-    def receive_schema_error error, options
-      return unless @options.dig(:cancel,:schema_error)
+    def receive_schema_error(error, options)
+      return unless @options.dig(:cancel, :schema_error)
+
       message = options[:message]
       return unless message
+
       klass = message.class.name.split('::').last
-      return unless @filter&.type == nil || [@filter&.type].flatten.include?(klass)
+      return unless @filter&.type.nil? || [@filter&.type].flatten.include?(klass)
+
       @distributor.log "#{identifier}: cancelled due to schema error in #{klass} #{message.m_id_short}", level: :debug
       cancel error
     end
 
-    # Cancel if we received e notificaiton about a disconnect
-    def receive_disconnect error, options
-      return unless @options.dig(:cancel,:disconnect)
-      @distributor.log "#{identifier}: cancelled due to a connection error: #{error.to_s}", level: :debug
+    # Cancel if we received e notifiction about a disconnect
+    def receive_disconnect(error, _options)
+      return unless @options.dig(:cancel, :disconnect)
+
+      @distributor.log "#{identifier}: cancelled due to a connection error: #{error}", level: :debug
       cancel error
     end
 
     # Abort collection
-    def cancel error=nil
+    def cancel(error = nil)
       @error = error
       @status = :cancelled
       do_stop
     end
 
     # Store a message in the result array
-    def keep message
+    def keep(message)
       @messages << message
     end
 
     # Check a message against our match criteria
     # Return true if there's a match, false if not
-    def acceptable? message
-      @filter == nil || @filter.accept?(message)
+    def acceptable?(message)
+      @filter.nil? || @filter.accept?(message)
     end
-
-    # return a string describing the types of messages we're collecting
-    def describe_types
-      [@filter&.type].flatten.join('/')
-    end
-
-    # return a string that describes whe number of messages, and type of message we're collecting
-    def describe_num_and_type
-      if @num && @num > 1
-        "#{@num} #{describe_types}s"
-      else
-        describe_types
-      end
-    end
-
-    # return a string that describes the attributes that we're looking for
-    def describe_matcher
-      h = {component: @filter&.component}.compact
-      if h.empty?
-        describe_num_and_type
-      else
-        "#{describe_num_and_type} #{h}"
-      end
-    end
-
-    # Build a string describing how how progress reached before timeout
-    def describe_progress
-      str = "#{@title.capitalize} #{identifier} "
-      str << "in response to #{@m_id} " if @m_id
-      str << "timed out after #{@timeout}s, "
-      str << "reaching #{@messages.size}/#{@num}"
-      str
-    end
-
-    # log when we start collecting
-    def log_start
-      @distributor.log "#{identifier}: Waiting for #{describe_matcher}".strip, level: :collect
-    end
-
-    # log current progress
-    def log_incomplete
-      @distributor.log "#{identifier}: #{describe_progress}", level: :collect
-    end
-
-    # log when we end collecting
-    def log_complete
-      @distributor.log "#{identifier}: Done", level: :collect
-    end
-
-    # get a short id in hex format, identifying ourself
-    def identifier
-      "Collect #{self.object_id.to_s(16)}"
-    end
-
   end
-end
+end

data/lib/rsmp/collect/command_matcher.rb

@@ -1,16 +1,29 @@
 module RSMP
-  # Match a specific command responses
+  # Class for matching a command
   class CommandMatcher < Matcher
-    # Match a return value item against a matcher
-    def match? item
+    def match_code?(item)
       return nil if @want['cCI'] && @want['cCI'] != item['cCI']
       return nil if @want['n'] && @want['n'] != item['n']
+
+      true
+    end
+
+    def match_value?(item)
+      return true unless @want['v']
+
       if @want['v'].is_a? Regexp
-        return false if @want['v'] && item['v'] !~ @want['v']
-      else
-        return false if @want['v'] && item['v'] != @want['v']
+        return false if item['v'] !~ @want['v']
+      elsif item['v'] != @want['v']
+        return false
       end
       true
     end
+
+    def match?(item)
+      code_match = match_code?(item)
+      return code_match if code_match.nil?
+
+      match_value?(item)
+    end
   end
 end

data/lib/rsmp/collect/command_response_collector.rb

@@ -1,20 +1,20 @@
 module RSMP
   # Class for waiting for specific command responses
   class CommandResponseCollector < StateCollector
-    def initialize proxy, want, options={}
-      super proxy, want, options.merge(
+    def initialize(proxy, want, options = {})
+      super(proxy, want, options.merge(
         filter: RSMP::Filter.new(ingoing: true, outgoing: false, type: 'CommandResponse'),
-        title:'command response'
-      )
+        title: 'command response'
+      ))
     end
 
-    def build_matcher want
+    def build_matcher(want)
       CommandMatcher.new want
     end
 
     # Get items, in our case the return values
-    def get_items message
+    def get_items(message)
       message.attributes['rvs'] || []
     end
   end
-end
+end

data/lib/rsmp/collect/distributor.rb

@@ -1,13 +1,12 @@
-# Distributes messages to receivers
-
 module RSMP
+  # Class which distributes messages to receivers
   module Distributor
     attr_reader :receivers
 
     include Inspect
 
     def inspect
-      "#<#{self.class.name}:#{self.object_id}, #{inspector(:@receivers)}>"
+      "#<#{self.class.name}:#{object_id}, #{inspector(:@receivers)}>"
     end
 
     def initialize_distributor
@@ -16,12 +15,13 @@ module RSMP
       @deferred_messages = []
     end
 
-    def clear_deferred_distribution &block
+    def clear_deferred_distribution
       @deferred_messages = []
     end
 
-    def with_deferred_distribution &block
-      was, @defer_distribution = @defer_distribution, true
+    def with_deferred_distribution
+      was = @defer_distribution
+      @defer_distribution = true
       yield
       distribute_queued
     ensure
@@ -35,18 +35,21 @@ module RSMP
       @deferred_messages = []
     end
 
-    def add_receiver receiver
+    def add_receiver(receiver)
       raise ArgumentError unless receiver
+
       @receivers << receiver unless @receivers.include? receiver
     end
 
-    def remove_receiver receiver
+    def remove_receiver(receiver)
       raise ArgumentError unless receiver
+
       @receivers.delete receiver
     end
 
-    def distribute message
+    def distribute(message)
       raise ArgumentError unless message
+
       if @defer_distribution
         @deferred_messages << message
       else
@@ -54,11 +57,11 @@ module RSMP
       end
     end
 
-    def distribute_immediately message
+    def distribute_immediately(message)
       @receivers.each { |receiver| receiver.receive message }
     end
 
-    def distribute_error error, options={}
+    def distribute_error(error, options = {})
       @receivers.each { |receiver| receiver.receive_error error, options }
     end
   end

data/lib/rsmp/collect/filter.rb

@@ -1,12 +1,10 @@
 module RSMP
-
   # Filter messages based on type, direction and component id.
   # Used by Collectors.
   class Filter
-
     attr_reader :ingoing, :outgoing, :type, :component
 
-    def initialize ingoing:true, outgoing:true, type:nil, component:nil
+    def initialize(ingoing: true, outgoing: true, type: nil, component: nil)
       @ingoing = ingoing
       @outgoing = outgoing
       @type = type ? [type].flatten : nil
@@ -14,23 +12,41 @@ module RSMP
     end
 
     # Check a message against our match criteria
-    # Return true if there's a match, false if not
-    def accept? message
+    def accept?(message)
+      return false unless direction_matches?(message)
+      return false unless type_matches?(message)
+      return false unless component_matches?(message)
+
+      true
+    end
+
+    private
+
+    def direction_matches?(message)
       return false if message.direction == :in && @ingoing == false
       return false if message.direction == :out && @outgoing == false
-      if @type
-        unless message.is_a?(MessageNotAck)
-          return false unless @type.include? message.type
-        end
-      end
-      if @component
-        return false if message.attributes['cId'] && message.attributes['cId'] != @component
-      end
+
       true
     end
 
-    def reject? message
+    def type_matches?(message)
+      return true unless @type
+      return true if message.is_a?(MessageNotAck)
+
+      @type.include?(message.type)
+    end
+
+    def component_matches?(message)
+      return true unless @component
+      return true unless message.attributes['cId']
+
+      message.attributes['cId'] == @component
+    end
+
+    public
+
+    def reject?(message)
       !accept?(message)
     end
   end
-end
+end

data/lib/rsmp/collect/matcher.rb

@@ -1,10 +1,9 @@
 module RSMP
-
   # Class that matches a single status or command item
   class Matcher
     attr_reader :want, :got, :message
 
-    def initialize want
+    def initialize(want)
       @want = want
       @got = nil
       @message = nil
@@ -17,18 +16,16 @@ module RSMP
 
     # Check an item and set @done to true if it matches
     # Store the item and corresponding message if there's a positive or negative match
-    def perform_match item, message, block
+    def perform_match(item, _message, block)
       matched = match? item
-      if matched != nil
-        if block
-          status = block.call(nil,item)
-          matched = status if status == true || status == false
-        end
+      if !matched.nil? && block
+        status = block.call(nil, item)
+        matched = status if [true, false].include?(status)
       end
       matched
     end
 
-    def keep message, item
+    def keep(message, item)
       @message = message
       @got = item
     end
@@ -38,7 +35,6 @@ module RSMP
       @got = nil
     end
 
-    def match? item
-    end
+    def match?(item); end
   end
 end

data/lib/rsmp/collect/queue.rb

@@ -7,7 +7,7 @@ module RSMP
 
     attr_reader :messages
 
-    def initialize distributor, filter: nil, task:
+    def initialize(distributor, task:, filter: nil)
       initialize_receiver distributor, filter: filter
       @condition = Async::Notification.new
       @task = task
@@ -18,7 +18,7 @@ module RSMP
       @messages = []
     end
 
-    def wait_for_message timeout: nil
+    def wait_for_message(timeout: nil)
       if @messages.empty?
         if timeout
           @task.with_timeout(timeout) { @condition.wait }
@@ -31,9 +31,9 @@ module RSMP
       raise RSMP::TimeoutError
     end
 
-    def handle_message message
+    def handle_message(message)
       @messages << message
       @condition.signal
     end
   end
-end
+end

data/lib/rsmp/collect/receiver.rb

@@ -1,12 +1,12 @@
 # Receives items from a Distributor, as long as it's
 # installed as a receiver.
-# Optionally can filter mesage using a Filter.
+# Optionally filter mesage using a Filter.
 
 module RSMP
   module Receiver
     include Inspect
 
-    def initialize_receiver distributor, filter: nil
+    def initialize_receiver(distributor, filter: nil)
       @distributor = distributor
       @filter = filter
     end
@@ -19,22 +19,20 @@ module RSMP
       @distributor.remove_receiver(self)
     end
 
-    def receive message
-      handle_message(message) if accept_message?(message) 
+    def receive(message)
+      handle_message(message) if accept_message?(message)
     end
 
-    def receive_error error, options={}
-    end
+    def receive_error(error, options = {}); end
 
-    def accept_message? message
-      @filter == nil || @filter.accept?(message)
+    def accept_message?(message)
+      @filter.nil? || @filter.accept?(message)
     end
 
-    def reject_message? message
+    def reject_message?(message)
       !accept_message?(message)
     end
 
-    def handle_message message
-    end
+    def handle_message(message); end
   end
-end
+end