rsmp 0.37.0 → 0.38.0

data/lib/rsmp/collect/alarm_collector.rb

@@ -1,20 +1,26 @@
 module RSMP
   # Class for waiting for specific command responses
   class AlarmCollector < Collector
-    def initialize proxy,options={}
+    def initialize(proxy, options = {})
       @matcher = options[:matcher] || {}
-      super proxy, options.merge(
+      super(proxy, options.merge(
         filter: RSMP::Filter.new(ingoing: true, outgoing: false, type: 'Alarm'),
-        title:'alarm'
-      )
+        title: 'alarm'
+      ))
     end
 
-    # match alarm attributes
-    def acceptable? message
-      return false if super(message) == false
+    def acceptable?(message)
+      return false if super == false
+      return false unless fixed_attributes_match?(message)
+      return false unless rvs_attributes_match?(message)
 
-      # match fixed attributes
-      %w{cId aCId aSp ack aS sS cat pri}.each do |key|
+      true
+    end
+
+    private
+
+    def fixed_attributes_match?(message)
+      %w[cId aCId aSp ack aS sS cat pri].each do |key|
         want = @matcher[key]
         got = message.attribute(key)
         case want
@@ -24,26 +30,28 @@ module RSMP
           return false if got != want
         end
       end
+      true
+    end
 
-      # match rvs items
-      if @matcher['rvs']
-        matcher_rvs = @matcher['rvs']
-        message_rvs = message.attributes['rvs']
-        return false unless message_rvs
-        return false unless matcher_rvs.all? do |matcher_item|
-          return false unless message_rvs.any? do |message_item|
-            next message_item['n'] == matcher_item['n'] && message_item['v'] == matcher_item['v']
-          end
-          next true
+    def rvs_attributes_match?(message)
+      return true unless @matcher['rvs']
+
+      matcher_rvs = @matcher['rvs']
+      message_rvs = message.attributes['rvs']
+      return false unless message_rvs
+
+      matcher_rvs.all? do |matcher_item|
+        message_rvs.any? do |message_item|
+          message_item['n'] == matcher_item['n'] && message_item['v'] == matcher_item['v']
         end
       end
-      true
     end
 
+    public
+
     # return a string that describes what we're collecting
     def describe_matcher
-      "#{describe_num_and_type} #{ {component: @options[:component]}.merge(@matcher).compact }"
+      "#{describe_num_and_type} #{{ component: @options[:component] }.merge(@matcher).compact}"
     end
-
   end
-end
+end

data/lib/rsmp/collect/alarm_matcher.rb

@@ -1,9 +1,9 @@
 module RSMP
   # Match a specific alarm
   class AlarmMatcher < Matcher
-    # Match an alarm value against a matcher
-    def match? item
+    def match?(item)
       return false if @want['n'] && @want['n'] != item['n']
+
       if @want['v'].is_a? Regexp
         return false if item['v'] !~ @want['v']
       elsif @want['v']
@@ -12,4 +12,4 @@ module RSMP
       true
     end
   end
-end
+end

data/lib/rsmp/collect/collector/logging.rb

@@ -0,0 +1,17 @@
+module RSMP
+  class Collector
+    module Logging
+      def log_start
+        @distributor.log "#{identifier}: Waiting for #{describe_matcher}".strip, level: :collect
+      end
+
+      def log_incomplete
+        @distributor.log "#{identifier}: #{describe_progress}", level: :collect
+      end
+
+      def log_complete
+        @distributor.log "#{identifier}: Done", level: :collect
+      end
+    end
+  end
+end

data/lib/rsmp/collect/collector/reporting.rb

@@ -0,0 +1,44 @@
+module RSMP
+  class Collector
+    # Progress reporting and description methods for collectors
+    module Reporting
+      # 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 far 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
+
+      # get a short id in hex format, identifying ourself
+      def identifier
+        "Collect #{object_id.to_s(16)}"
+      end
+    end
+  end
+end

data/lib/rsmp/collect/collector/status.rb

@@ -0,0 +1,34 @@
+module RSMP
+  class Collector
+    # Status predicate methods for collectors
+    module Status
+      def collecting?
+        @status == :collecting
+      end
+
+      def ok?
+        @status == :ok
+      end
+
+      def timeout?
+        @status == :timeout
+      end
+
+      def ready?
+        @status == :ready
+      end
+
+      def cancelled?
+        @status == :cancelled
+      end
+
+      def ingoing?
+        @ingoing == true
+      end
+
+      def outgoing?
+        @outgoing == true
+      end
+    end
+  end
+end

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