rsmp 0.37.0 → 0.38.0

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

data/lib/rsmp/collect/state_collector.rb

@@ -35,91 +35,103 @@ module RSMP
     attr_reader :matchers
 
     # Initialize with a list of wanted statuses
-    def initialize proxy, want, options={}
-      raise ArgumentError.new("num option cannot be used") if options[:num]
-      super proxy, options
+    def initialize(proxy, want, options = {})
+      raise ArgumentError, 'num option cannot be used' if options[:num]
+
+      super(proxy, options)
       @matchers = want.map { |item| build_matcher item }
     end
 
     # Build a matcher object.
     # Sub-classes should override to use their own matcher classes.
-    def build_matcher want
+    def build_matcher(want)
       Matcher.new want
     end
 
     # Get a results
-    def matcher_result want
-      matcher = @matchers.find { |q| q.want == want}
+    def matcher_result(want)
+      matcher = @matchers.find { |q| q.want == want }
       raise unless matcher
+
       matcher.got
     end
 
     # Get an array of the last item received for each matcher
     def reached
-      @matchers.map { |matcher| matcher.got }.compact
+      @matchers.map(&:got).compact
     end
 
     # Get messages from results
     def messages
-      @matchers.map { |matcher| matcher.message }.uniq.compact
+      @matchers.map(&:message).uniq.compact
     end
 
     # Return progress as completes matchers vs. total number of matchers
     def progress
       need = @matchers.size
-      reached =  @matchers.count { |matcher| matcher.done? }
+      reached = @matchers.count(&:done?)
       { need: need, reached: reached }
     end
 
     # Are there matchers left to type_match?
     def done?
-      @matchers.all? { |matcher| matcher.done? }
+      @matchers.all?(&:done?)
     end
 
     # Get a simplified hash of matchers, with values set to either true or false,
     # indicating which matchers have been matched.
     def matcher_status
-      @matchers.map { |matcher| [matcher.want, matcher.done?] }.to_h
+      @matchers.to_h { |matcher| [matcher.want, matcher.done?] }
     end
 
     # Get a simply array of bools, showing which matchers have been matched.
     def summary
-      @matchers.map { |matcher| matcher.done? }
+      @matchers.map(&:done?)
+    end
+
+    def log_match_result(message, matched, matcher, item)
+      type = { true => 'match', false => 'mismatch' }[matched]
+      @distributor.log "#{@title.capitalize} #{message.m_id_short} collect #{type} #{matcher.want}, item #{item}",
+                       level: :debug
+    end
+
+    def handle_match_result(matched, matcher, message, item)
+      return if matched.nil?
+
+      log_match_result(message, matched, matcher, item)
+      if matched == true
+        matcher.keep message, item
+      elsif matched == false
+        matcher.forget
+      end
     end
 
-    # Check if a messages matches our criteria.
-    # Match each matcher against each item in the message
-    def perform_match message
-      return false if super(message) == false
+    def perform_match(message)
+      return false if super == false
       return unless collecting?
-      @matchers.each do |matcher|       # look through matchers
-        get_items(message).each do |item|  # look through items in message
-          matched = matcher.perform_match(item,message,@block)
-          return unless collecting?
-          if matched != nil
-            type = {true=>'match',false=>'mismatch'}[matched]
-            @distributor.log "#{@title.capitalize} #{message.m_id_short} collect #{type} #{matcher.want}, item #{item}", level: :debug
-            if matched == true
-              matcher.keep message, item
-            elsif matched == false
-              matcher.forget
-            end
-          end
+
+      @matchers.each do |matcher|
+        break unless collecting?
+
+        get_items(message).each do |item|
+          matched = matcher.perform_match(item, message, @block)
+          break unless collecting?
+
+          handle_match_result(matched, matcher, message, item)
         end
       end
     end
 
     # don't collect anything. Matcher will collect them instead
-    def keep message
-    end
+    def keep(message); end
 
     def describe
-      @matchers.map {|q| q.want.to_s }
+      @matchers.map { |q| q.want.to_s }
     end
 
     # return a string that describes the attributes that we're looking for
     def describe_matcher
-      "#{super} matching #{matcher_want_hash.to_s}"
+      "#{super} matching #{matcher_want_hash}"
     end
 
     # return a hash that describe the status of all matchers
@@ -128,33 +140,45 @@ module RSMP
       @matchers.each do |matcher|
         want = matcher.want
         if want['cCI']
-          cCI = want['cCI']
-          h[cCI] ||= {}
-          cO = h['cO']
-          n = h['n']
-          v = h['v']
-          h[cCI][cO] ||= {}
-          h[cCI][cO][n] = v
+          process_command_matcher(h, matcher, want)
         elsif want['sCI']
-          sCI = want['sCI']
-          h[sCI] ||= {}
-          n = want['n']
-          s = want['s']
-          if matcher.got && matcher.got['s']
-            h[sCI][n] = { {s=>matcher.got['s']} => matcher.done? }
-          else
-            h[sCI][n] = { s=>nil }
-          end
+          process_status_matcher(h, matcher, want)
         end
       end
       h
     end
 
+    private
+
+    def process_command_matcher(hash, _matcher, want)
+      cci = want['cCI']
+      hash[cci] ||= {}
+      co = want['cO']
+      n = want['n']
+      v = want['v']
+      hash[cci][co] ||= {}
+      hash[cci][co][n] = v
+    end
+
+    def process_status_matcher(hash, matcher, want)
+      sci = want['sCI']
+      hash[sci] ||= {}
+      n = want['n']
+      s = want['s']
+      hash[sci][n] = if matcher.got && matcher.got['s']
+                       { { s => matcher.got['s'] } => matcher.done? }
+                     else
+                       { s => nil }
+                     end
+    end
+
+    public
+
     # return a string that describe how many many messages have been collected
     def describe_progress
       num_matchers = @matchers.size
-      num_matched =  @matchers.count { |matcher| matcher.done? }
-      ".. Matched #{num_matched}/#{num_matchers} with #{progress_hash.to_s}"
+      num_matched =  @matchers.count(&:done?)
+      ".. Matched #{num_matched}/#{num_matchers} with #{progress_hash}"
     end
 
     def matcher_want_hash
@@ -162,44 +186,59 @@ module RSMP
       @matchers.each do |matcher|
         item = matcher.want
         if item['cCI']
-          cCI = item['cCI']
-          h[cCI] ||= {}
-          cO = item['cO']
-          h[cCI][cO] ||= {}
-          n = item['n']
-          v = item['v']
-          h[cCI][cO][n] = v || :any
+          add_command_want_to_hash(h, item)
         elsif item['sCI']
-          sCI = item['sCI']
-          h[sCI] ||= {}
-          n = item['n']
-          s = item['s']
-          h[sCI][n] = s || :any
+          add_status_want_to_hash(h, item)
         end
       end
       h
     end
 
-    # return a hash that describe the end result
+    def add_command_want_to_hash(hash, item)
+      cci = item['cCI']
+      hash[cci] ||= {}
+      co = item['cO']
+      hash[cci][co] ||= {}
+      n = item['n']
+      v = item['v']
+      hash[cci][co][n] = v || :any
+    end
+
+    def add_status_want_to_hash(hash, item)
+      sci = item['sCI']
+      hash[sci] ||= {}
+      n = item['n']
+      s = item['s']
+      hash[sci][n] = s || :any
+    end
+
+    def add_command_result(hash, want, got)
+      cci = want['cCI']
+      hash[cci] ||= {}
+      co = want['cO']
+      hash[cci][co] ||= {}
+      n = want['n']
+      v = got ? got['v'] : nil
+      hash[cci][co][n] = v
+    end
+
+    def add_status_result(hash, want, got)
+      sci = want['sCI']
+      hash[sci] ||= {}
+      n = want['n']
+      s = got ? got['s'] : nil
+      hash[sci][n] = s
+    end
+
     def matcher_got_hash
       h = {}
       @matchers.each do |matcher|
         want = matcher.want
         got = matcher.got
         if want['cCI']
-          cCI = want['cCI']
-          h[cCI] ||= {}
-          cO = want['cO']
-          h[cCI][cO] ||= {}
-          n = want['n']
-          v = got ? got['v'] : nil
-          h[cCI][cO][n] = v
+          add_command_result(h, want, got)
         elsif want['sCI']
-          sCI = want['sCI']
-          h[sCI] ||= {}
-          n = want['n']
-          s = got ? got['s'] : nil
-          h[sCI][n] = s
+          add_status_result(h, want, got)
         end
       end
       h
@@ -207,7 +246,7 @@ module RSMP
 
     # log when we end collecting
     def log_complete
-      @distributor.log "#{identifier}: Completed with #{matcher_got_hash.to_s}", level: :collect
+      @distributor.log "#{identifier}: Completed with #{matcher_got_hash}", level: :collect
     end
   end
 end

data/lib/rsmp/collect/status_collector.rb

@@ -1,24 +1,24 @@
 module RSMP
   # Base class for waiting for status updates or responses
   class StatusCollector < StateCollector
-    def initialize proxy, want, options={}
+    def initialize(proxy, want, options = {})
       type = []
       type << 'StatusUpdate' unless options[:updates] == false
       type << 'StatusResponse' unless options[:reponses] == false
 
-      super proxy, want, options.merge(
+      super(proxy, want, options.merge(
         title: 'status response',
         filter: RSMP::Filter.new(ingoing: true, outgoing: false, type: type)
-      )
+      ))
     end
 
-    def build_matcher want
+    def build_matcher(want)
       RSMP::StatusMatcher.new want
     end
 
     # Get items, in our case status values
-    def get_items message
+    def get_items(message)
       message.attributes['sS'] || []
     end
   end
-end
+end

data/lib/rsmp/collect/status_matcher.rb

@@ -1,12 +1,16 @@
 module RSMP
-  # Match a specific status response or update
   class StatusMatcher < Matcher
-    # Match a status value against a matcher
-    def match? item
-      return nil if @want['sCI'] && @want['sCI'] != item['sCI']
-      return nil if @want['cO'] && @want['cO'] != item['cO']
-      return nil if @want['n'] && @want['n'] != item['n']
+    def match_code?(item)
+      return false if @want['sCI'] && @want['sCI'] != item['sCI']
+      return false if @want['cO'] && @want['cO'] != item['cO']
+      return false if @want['n'] && @want['n'] != item['n']
+
+      true
+    end
+
+    def match_value?(item)
       return false if @want['q'] && @want['q'] != item['q']
+
       if @want['s'].is_a? Regexp
         return false if item['s'] !~ @want['s']
       elsif @want['s']
@@ -14,5 +18,11 @@ module RSMP
       end
       true
     end
+
+    def match?(item)
+      return nil unless match_code?(item)
+
+      match_value?(item)
+    end
   end
-end
+end