rsmp 0.37.0 → 0.39.0

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,17 @@
 module RSMP
-  # Match a specific status response or update
+  # Match a specific status
   class StatusMatcher < Matcher
-    # Match a status value against a matcher
-    def match? item
+    def match_code(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']
+
+      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 +19,11 @@ module RSMP
       end
       true
     end
+
+    def match(item)
+      return nil unless match_code(item)
+
+      match_value?(item)
+    end
   end
-end
+end

data/lib/rsmp/{alarm_state.rb → component/alarm_state.rb}

@@ -1,17 +1,13 @@
 module RSMP
-
   # The state of an alarm on a component.
   # The alarm state is for a particular alarm code,
   # a component typically have an alarm state for each
   # alarm code that is defined for the component type.
-
   class AlarmState
     attr_reader :component_id, :code, :acknowledged, :suspended, :active, :timestamp, :category, :priority, :rvs
 
-    def self.create_from_message component, message
-      self.new(
-        component: component,
-        code: message.attribute("aCId"),
+    def self.create_from_message(component, message)
+      options = {
         timestamp: RSMP::Clock.parse(message.attribute('aTs')),
         acknowledged: message.attribute('ack') == 'Acknowledged',
         suspended: message.attribute('aS') == 'Suspended',
@@ -19,22 +15,21 @@ module RSMP
         category: message.attribute('cat'),
         priority: message.attribute('pri').to_i,
         rvs: message.attribute('rvs')
-      )
+      }
+      new(component: component, code: message.attribute('aCId'), **options)
     end
 
-    def initialize component:, code:, 
-        suspended: false, acknowledged: false, active: false, timestamp: nil,
-        category: 'D', priority: 2, rvs: []
+    def initialize(component:, code:, **options)
       @component = component
       @component_id = component.c_id
       @code = code
-      @suspended = !!suspended
-      @acknowledged = !!acknowledged 
-      @active = !!active
-      @timestamp =  timestamp
-      @category = category || 'D'
-      @priority = priority || 2
-      @rvs = rvs
+      @suspended = options[:suspended] == true
+      @acknowledged = options[:acknowledged] == true
+      @active = options[:active] == true
+      @timestamp = options[:timestamp]
+      @category = options[:category] || 'D'
+      @priority = options[:priority] || 2
+      @rvs = options[:rvs] || []
     end
 
     def to_hash
@@ -52,19 +47,22 @@ module RSMP
     end
 
     def acknowledge
-      change, @acknowledged = !@acknowledged, true
+      change = !@acknowledged
+      @acknowledged = true
       update_timestamp if change
       change
     end
 
     def suspend
-      change, @suspended = !@suspended, true
+      change = !@suspended
+      @suspended = true
       update_timestamp if change
       change
     end
 
     def resume
-      change, @suspended = @suspended, false
+      change = @suspended
+      @suspended = false
       update_timestamp if change
       change
     end
@@ -73,29 +71,33 @@ module RSMP
     # is when it's activated. See:
     # https://rsmp-nordic.org/rsmp_specifications/core/3.2.0/applicability/basic_structure.html#alarm-status
     def activate
-      change, @active, @acknowledged = !@active, true, false
+      change = !@active
+      @active = true
+      @acknowledged = false
       update_timestamp if change
       change
     end
 
     def deactivate
-      change, @active = @active, false
+      change = @active
+      @active = false
       update_timestamp if change
       change
     end
-    
+
     def update_timestamp
       @timestamp = @component.now
     end
 
-    def differ_from_message? message
-      return true if RSMP::Clock.to_s(@timestamp) != message.attribute('aTs')
-      return true if message.attribute('ack') && @acknowledged != (message.attribute('ack').downcase == 'acknowledged')
-      return true if message.attribute('sS') && @suspended != (message.attribute('sS').downcase == 'suspended')
-      return true if message.attribute('aS') && @active != (message.attribute('aS').downcase == 'active')
-      return true if message.attribute('cat') && @category != message.attribute('cat')
-      return true if message.attribute('pri') && @priority != message.attribute('pri').to_i
-      #return true @rvs = message.attribute('rvs')
+    def differ_from_message?(message)
+      return true if timestamp_differs?(message)
+      return true if acknowledgment_differs?(message)
+      return true if suspension_differs?(message)
+      return true if activity_differs?(message)
+      return true if category_differs?(message)
+      return true if priority_differs?(message)
+
+      # return true @rvs = message.attribute('rvs')
       false
     end
 
@@ -103,20 +105,20 @@ module RSMP
       @timestamp = nil
     end
 
-    def older_message? message
-      return false if @timestamp == nil
+    def older_message?(message)
+      return false if @timestamp.nil?
+
       RSMP::Clock.parse(message.attribute('aTs')) < @timestamp
     end
 
     # update from rsmp message
     # component id, alarm code and specialization are not updated
-    def update_from_message message
+    def update_from_message(message)
       unless differ_from_message? message
-        raise RepeatedAlarmError.new("no changes from previous alarm #{message.m_id_short}")
-      end
-      if older_message? message
-        raise TimestampError.new("timestamp is earlier than previous alarm #{message.m_id_short}")
+        raise RepeatedAlarmError,
+              "no changes from previous alarm #{message.m_id_short}"
       end
+      raise TimestampError, "timestamp is earlier than previous alarm #{message.m_id_short}" if older_message? message
     ensure
       @timestamp = RSMP::Clock.parse message.attribute('aTs')
       @acknowledged = message.attribute('ack') == 'True'
@@ -126,5 +128,41 @@ module RSMP
       @priority = message.attribute('pri').to_i
       @rvs = message.attribute('rvs')
     end
+
+    private
+
+    def timestamp_differs?(message)
+      RSMP::Clock.to_s(@timestamp) != message.attribute('aTs')
+    end
+
+    def acknowledgment_differs?(message)
+      return false unless message.attribute('ack')
+
+      @acknowledged != (message.attribute('ack').downcase == 'acknowledged')
+    end
+
+    def suspension_differs?(message)
+      return false unless message.attribute('sS')
+
+      @suspended != (message.attribute('sS').downcase == 'suspended')
+    end
+
+    def activity_differs?(message)
+      return false unless message.attribute('aS')
+
+      @active != (message.attribute('aS').downcase == 'active')
+    end
+
+    def category_differs?(message)
+      return false unless message.attribute('cat')
+
+      @category != message.attribute('cat')
+    end
+
+    def priority_differs?(message)
+      return false unless message.attribute('pri')
+
+      @priority != message.attribute('pri').to_i
+    end
   end
 end

data/lib/rsmp/{component.rb → component/component.rb}

@@ -1,19 +1,19 @@
 module RSMP
   # RSMP component
   class Component < ComponentBase
-    def initialize node:, id:, ntsOId: nil, xNId: nil, grouped: false
+    def initialize(node:, id:, ntsoid: nil, xnid: nil, grouped: false)
       super
     end
 
-    def handle_command command_code, arg
-      raise UnknownCommand.new "Command #{command_code} not implemented by #{self.class}"
+    def handle_command(command_code, _arg)
+      raise UnknownCommand, "Command #{command_code} not implemented by #{self.class}"
     end
 
-    def get_status status_code, status_name=nil, options={}
-      raise UnknownStatus.new "Status #{status_code}/#{status_name} not implemented by #{self.class}"
+    def get_status(status_code, status_name = nil, _options = {})
+      raise UnknownStatus, "Status #{status_code}/#{status_name} not implemented by #{self.class}"
     end
 
-    def acknowledge_alarm alarm_code
+    def acknowledge_alarm(alarm_code)
       alarm = get_alarm_state alarm_code
       if alarm.acknowledge
         log "Acknowledging alarm #{alarm_code}", level: :info
@@ -23,17 +23,17 @@ module RSMP
       end
     end
 
-    def suspend_alarm alarm_code
+    def suspend_alarm(alarm_code)
       alarm = get_alarm_state alarm_code
       if alarm.suspend
         log "Suspending alarm #{alarm_code}", level: :info
         @node.alarm_suspended_or_resumed alarm
       else
         log "Alarm #{alarm_code} already suspended", level: :info
-      end       
+      end
     end
 
-    def resume_alarm alarm_code
+    def resume_alarm(alarm_code)
       alarm = get_alarm_state alarm_code
       if alarm.resume
         log "Resuming alarm #{alarm_code}", level: :info
@@ -43,22 +43,22 @@ module RSMP
       end
     end
 
-    def activate_alarm alarm_code
+    def activate_alarm(alarm_code)
       alarm = get_alarm_state alarm_code
       return unless alarm.activate
+
       log "Activating alarm #{alarm_code}", level: :info
       @node.alarm_activated_or_deactivated alarm
     end
 
-    def deactivate_alarm alarm_code
+    def deactivate_alarm(alarm_code)
       alarm = get_alarm_state alarm_code
       return unless alarm.deactivate
+
       log "Deactivating alarm #{alarm_code}", level: :info
       @node.alarm_activated_or_deactivated alarm
     end
 
-    def status_updates_sent
-    end
-    
+    def status_updates_sent; end
   end
-end
+end