somfy_sdn 2.1.5 → 2.2.0

data/lib/sdn/cli/simulator.rb

@@ -1,8 +1,26 @@
+# frozen_string_literal: true
+
 module SDN
   module CLI
     class Simulator
       class MockMotor
-        attr_accessor :address, :node_type, :label, :ips, :position_pulses, :up_limit, :down_limit, :groups, :network_lock_priority, :lock_priority, :ir_channels
+        attr_accessor :address,
+                      :node_type,
+                      :label,
+                      :ips,
+                      :position_pulses,
+                      :up_limit,
+                      :down_limit,
+                      :groups,
+                      :network_lock_priority,
+                      :lock_priority,
+                      :ir_channels
+
+        ALLOWED_MOVE_TYPES = %i[up_limit
+                                down_limit
+                                ip
+                                position_pulses
+                                position_percent].freeze
 
         def initialize(client)
           @client = client
@@ -20,56 +38,67 @@ module SDN
             @client.receive do |message|
               SDN.logger.info "Received #{message.inspect}"
               next unless message.is_a?(Message::ILT2::MasterControl) ||
-                message.dest == address ||
-                message.dest == BROADCAST_ADDRESS
-          
+                          message.dest == address ||
+                          message.dest == BROADCAST_ADDRESS
+
               case message
               when Message::GetGroupAddr
-                next nack(message) unless (1..16).include?(message.group_index)
+                next nack(message) unless (1..16).cover?(message.group_index)
+
                 respond(message.src, Message::PostGroupAddr.new(message.group_index, groups[message.group_index - 1]))
               when Message::GetMotorIP
-                next nack(message) unless (1..16).include?(message.ip)
-                respond(message.src, Message::PostMotorIP.new(message.ip, ips[message.ip - 1], to_percent(ips[message.ip - 1])))
+                next nack(message) unless (1..16).cover?(message.ip)
+
+                respond(message.src,
+                        Message::PostMotorIP.new(message.ip, ips[message.ip - 1], to_percent(ips[message.ip - 1])))
               when Message::GetMotorLimits
                 respond(message.src, Message::PostMotorLimits.new(up_limit, down_limit))
               when Message::GetMotorPosition
                 respond(message.src, Message::PostMotorPosition.new(
-                  position_pulses,
-                  to_percent(position_pulses),
-                  ips.index(position_pulses)&.+(1)
-                ))
-              when Message::GetNodeAddr; respond(message.src, Message::PostNodeAddr.new)
-              when Message::GetNodeLabel; respond(message.src, Message::PostNodeLabel.new(label))
-              when Message::ILT2::GetIRConfig; respond(message.src, Message::ILT2::PostIRConfig.new(ir_channels))
-              when Message::ILT2::GetLockStatus; respond(message.src, Message::ILT2::PostLockStatus.new(lock_priority))
-              when Message::ILT2::GetMotorIP; respond(message.src, Message::ILT2::PostMotorIP.new(message.ip, ips[message.ip - 1]))
-              when Message::ILT2::GetMotorPosition; respond(message.src, Message::ILT2::PostMotorPosition.new(position_pulses, to_percent(position_pulses)))
-              when Message::ILT2::GetMotorSettings; respond(message.src, Message::ILT2::PostMotorSettings.new(down_limit))
-              when Message::ILT2::SetIRConfig; self.ir_channels = message.channels
-              when Message::ILT2::SetLockStatus; self.lock_priority = message.priority
+                                       position_pulses,
+                                       to_percent(position_pulses),
+                                       ips.index(position_pulses)&.+(1)
+                                     ))
+              when Message::GetNodeAddr then respond(message.src, Message::PostNodeAddr.new)
+              when Message::GetNodeLabel then respond(message.src, Message::PostNodeLabel.new(label))
+              when Message::ILT2::GetIRConfig then respond(message.src, Message::ILT2::PostIRConfig.new(ir_channels))
+              when Message::ILT2::GetLockStatus then respond(message.src,
+                                                             Message::ILT2::PostLockStatus.new(lock_priority))
+              when Message::ILT2::GetMotorIP
+                respond(message.src, Message::ILT2::PostMotorIP.new(message.ip, ips[message.ip - 1]))
+              when Message::ILT2::GetMotorPosition
+                respond(message.src, Message::ILT2::PostMotorPosition.new(position_pulses, to_percent(position_pulses)))
+              when Message::ILT2::GetMotorSettings
+                respond(message.src, Message::ILT2::PostMotorSettings.new(down_limit))
+              when Message::ILT2::SetIRConfig then self.ir_channels = message.channels
+              when Message::ILT2::SetLockStatus then self.lock_priority = message.priority
               when Message::ILT2::SetMotorIP
-                next nack(message) unless (1..16).include?(message.ip)
+                next nack(message) unless (1..16).cover?(message.ip)
+
                 ips[message.ip - 1] = message.value
                 ack(message)
               when Message::ILT2::SetMotorPosition
                 next nack(message) unless down_limit
 
                 self.position_pulses = case message.target_type
-                when :up_limit; 0
-                when :down_limit; down_limit
-                when :ip
-                  next nack(message) unless (1..16).include?(message.target)
-                  next nack(message) unless ips[message.target]
-                  ips[message.target]
-                when :position_pulses
-                  next nack(message) if message.target - 1 > down_limit
-                  message.target - 1
-                when :jog_up_pulses; [0, position_pulses - message.target].max
-                when :jog_down_pulses; [down_limit, position_pulses + message.target].min
-                when :position_percent
-                  next nack(message) if message.target > 100
-                  to_pulses(message.target.to_f)
-                end
+                                       when :up_limit then 0
+                                       when :down_limit then down_limit
+                                       when :ip
+                                         next nack(message) unless (1..16).cover?(message.target)
+                                         next nack(message) unless ips[message.target]
+
+                                         ips[message.target]
+                                       when :position_pulses
+                                         next nack(message) if message.target - 1 > down_limit
+
+                                         message.target - 1
+                                       when :jog_up_pulses then [0, position_pulses - message.target].max
+                                       when :jog_down_pulses then [down_limit, position_pulses + message.target].min
+                                       when :position_percent
+                                         next nack(message) if message.target > 100
+
+                                         to_pulses(message.target.to_f)
+                                       end
                 ack(message)
               when Message::ILT2::SetMotorSettings
                 if message.down_limit != 0
@@ -78,29 +107,33 @@ module SDN
                 end
               when Message::MoveTo
                 next nack(message) unless down_limit
-                next nack(message) unless %I{up_limit down_limit ip position_pulses position_percent}.include?(message.target_type)
-                
+                next nack(message) unless ALLOWED_MOVE_TYPES.include?(message.target_type)
+
                 self.position_pulses = case message.target_type
-                when :up_limit; 0
-                when :down_limit; down_limit;
-                when :ip
-                  next nack(message) unless (1..16).include?(message.target)
-                  next nack(message) unless ips[message.target - 1]
-                  ips[message.target - 1]
-                when :position_pulses
-                  next nack(message) if message.target > down_limit
-                  message.target
-                when :position_percent
-                  next nack(message) if message.target > 100
-                  to_pulses(message.target)
-                end
+                                       when :up_limit then 0
+                                       when :down_limit then down_limit
+                                       when :ip
+                                         next nack(message) unless (1..16).cover?(message.target)
+                                         next nack(message) unless ips[message.target - 1]
+
+                                         ips[message.target - 1]
+                                       when :position_pulses
+                                         next nack(message) if message.target > down_limit
+
+                                         message.target
+                                       when :position_percent
+                                         next nack(message) if message.target > 100
+
+                                         to_pulses(message.target)
+                                       end
                 ack(message)
               when Message::SetGroupAddr
-                next nack(message) unless (1..16).include?(message.group_index)
-                groups[message.group_index - 1] = message.group_address == [0, 0, 0] ? nil : message.group_address
+                next nack(message) unless (1..16).cover?(message.group_index)
+
+                groups[message.group_index - 1] = (message.group_address == [0, 0, 0]) ? nil : message.group_address
                 ack(message)
               when Message::SetMotorIP
-                next nack(message) unless (1..16).include?(message.ip) || message.type == :distribute
+                next nack(message) unless (1..16).cover?(message.ip) || message.type == :distribute
 
                 case message.type
                 when :delete
@@ -122,7 +155,8 @@ module SDN
                   end
                 when :distribute
                   next nack(message) unless down_limit
-                  next nack(message) unless (1..15).include?(message.value)
+                  next nack(message) unless (1..15).cover?(message.value)
+
                   span = down_limit / (message.value + 1)
                   current = 0
                   (0...message.value).each do |ip|
@@ -134,8 +168,8 @@ module SDN
                   ack(message)
                 end
               when Message::SetMotorLimits
-                next nack(message) unless [:up, :down].include?(message.target)
-                next nack(message) unless [:jog_pulses].include?(message.type)
+                next nack(message) unless Message::SetMotorLimits::TARGET.key?(message.target)
+                next nack(message) unless message.type == :jog_pulses
 
                 self.up_limit ||= 0
                 self.down_limit ||= 0
@@ -150,27 +184,30 @@ module SDN
                   self.position_pulses += message.value if message.target == :down
                 end
                 ack(message)
-              when Message::SetNodeLabel; self.label = message.label; ack(message)
+              when Message::SetNodeLabel then self.label = message.label
+                                              ack(message)
               end
             end
           end
         end
 
         def to_percent(pulses)
-          pulses && down_limit ? 100.0 * pulses / down_limit : nil
+          (pulses && down_limit) ? 100.0 * pulses / down_limit : nil
         end
 
         def to_pulses(percent)
-          percent && down_limit ? down_limit * percent / 100 : nil
+          (percent && down_limit) ? down_limit * percent / 100 : nil
         end
 
         def ack(message)
           return unless message.ack_requested
+
           respond(Message::Ack.new(message.dest))
         end
 
-        def nack(message, error_code = nil)
+        def nack(message, _error_code = nil)
           return unless message.ack_requested
+
           respond(Message::Nack.new(message.dest))
         end
 
@@ -178,14 +215,11 @@ module SDN
           message.src = address
           message.node_type = node_type
           message.dest = dest
-          SDN.logger.info "Sending #{message.inspect}"
           @client.send(message)
         end
       end
 
-      def initialize(port, address = nil)
-        sdn = Client.new(port)
-
+      def initialize(sdn, address = nil)
         motor = MockMotor.new(sdn)
         motor.address = Message.parse_address(address) if address
         motor.node_type = :lt50

data/lib/sdn/client.rb

@@ -1,33 +1,42 @@
-require 'io/wait'
+# frozen_string_literal: true
+
+require "io/wait"
 
 module SDN
   class Client
+    attr_writer :trace
+
     def initialize(port)
       uri = URI.parse(port)
       @io = if uri.scheme == "tcp"
-        require 'socket'
-        TCPSocket.new(uri.host, uri.port)
-      elsif uri.scheme == "telnet" || uri.scheme == "rfc2217"
-        require 'net/telnet/rfc2217'
-        Net::Telnet::RFC2217.new(host: uri.host,
-         port: uri.port || 23,
-         baud: 4800,
-         data_bits: 8,
-         parity: :odd,
-         stop_bits: 1)
-      elsif port == "/dev/ptmx"
-        require 'pty'
-        io, slave = PTY.open
-        puts "Slave PTY available at #{slave.path}"
-        io
-      else
-        require 'ccutrer-serialport'
-        CCutrer::SerialPort.new(port, baud: 4800, data_bits: 8, parity: :odd, stop_bits: 1)
-      end
-      @buffer = ""
+              require "socket"
+              TCPSocket.new(uri.host, uri.port)
+            elsif uri.scheme == "telnet" || uri.scheme == "rfc2217"
+              require "net/telnet/rfc2217"
+              Net::Telnet::RFC2217.new(host: uri.host,
+                                       port: uri.port || 23,
+                                       baud: 4800,
+                                       data_bits: 8,
+                                       parity: :odd,
+                                       stop_bits: 1)
+            elsif port == "/dev/ptmx"
+              require "pty"
+              io, slave = PTY.open
+              puts "Slave PTY available at #{slave.path}"
+              io
+            else
+              require "ccutrer-serialport"
+              CCutrer::SerialPort.new(port, baud: 4800, data_bits: 8, parity: :odd, stop_bits: 1)
+            end
+      @buffer = +""
+    end
+
+    def trace?
+      @trace
     end
 
     def send(message)
+      SDN.logger.debug("Sending #{message.inspect}")
       @io.write(message.serialize)
     end
 
@@ -42,6 +51,7 @@ module SDN
         messages = transact(message)
         next if messages.empty?
         next unless message.class.expected_response?(messages.first)
+
         return messages.first
       end
     end
@@ -63,7 +73,7 @@ module SDN
           eofs = 0
           begin
             block = @io.read_nonblock(64 * 1024)
-            SDN.logger.debug "read #{block.unpack("H*").first.gsub(/\h{2}/, "\\0 ")}"
+            SDN.logger.debug("Read #{block.unpack1("H*").gsub(/\h{2}/, "\\0 ")}") if trace?
             @buffer.concat(block)
             next
           rescue IO::WaitReadable, EOFError => e
@@ -77,8 +87,10 @@ module SDN
             wait = @buffer.empty? ? timeout : WAIT_TIME
             if @io.wait_readable(wait).nil?
               # timed out; just discard everything
-              SDN.logger.debug "discarding #{@buffer.unpack("H*").first.gsub(/\h{2}/, "\\0 ")} due to timeout"
-              @buffer = ""
+              unless @buffer.empty?
+                SDN.logger.debug "Discarding #{@buffer.unpack1("H*").gsub(/\h{2}/, "\\0 ")} due to timeout"
+              end
+              @buffer = +""
               return messages if timeout
             end
 
@@ -86,6 +98,8 @@ module SDN
           end
           next
         end
+
+        SDN.logger.debug("Received message #{message.inspect}")
         if block_given?
           yield message
         else

data/lib/sdn/message/control.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module SDN
   class Message
     class Lock < Message
       MSG = 0x06
       PARAMS_LENGTH = 5
-      TARGET_TYPE = { current: 0, up_limit: 1, down_limit: 2, ip: 4, unlock: 5, position_percent: 7 }
+      TARGET_TYPE = { current: 0, up_limit: 1, down_limit: 2, ip: 4, unlock: 5, position_percent: 7 }.freeze
 
       attr_reader :target_type, :target, :priority
 
@@ -16,12 +18,16 @@ module SDN
       end
 
       def target_type=(value)
-        raise ArgumentError, "target_type must be one of :current, :up_limit, :down_limit, :ip, :unlock, or :position_percent" unless TARGET_TYPE.keys.include?(value)
+        unless TARGET_TYPE.key?(value)
+          raise ArgumentError,
+                "target_type must be one of :current, :up_limit, :down_limit, :ip, :unlock, or :position_percent"
+        end
+
         @target_type = value
       end
 
       def target=(value)
-        @target = value&. & 0xffff
+        @target = value&.& 0xffff
       end
 
       def priority=(value)
@@ -37,7 +43,8 @@ module SDN
       end
 
       def params
-        transform_param(TARGET_TYPE[target_type]) + from_number(target, 2) + transform_param(priority) + transform_param(0)
+        transform_param(TARGET_TYPE[target_type]) + from_number(target,
+                                                                2) + transform_param(priority) + transform_param(0)
       end
     end
 
@@ -56,29 +63,38 @@ module SDN
         self.direction = direction
         self.duration = duration
         self.speed = speed
-     end
-
-     def parse(params)
-       super
-       self.direction = DIRECTION.invert[to_number(params[0])]
-       duration = to_number(params[1])
-       duration = nil if duration == 0
-       self.duration = duration
-       self.speed = SPEED.invert[to_number(params[3])]
-     end
-
-     def direction=(value)
-        raise ArgumentError, "direction must be one of :down, :up, or :cancel (#{value})" unless DIRECTION.keys.include?(value)
+      end
+
+      def parse(params)
+        super
+        self.direction = DIRECTION.invert[to_number(params[0])]
+        duration = to_number(params[1])
+        duration = nil if duration.zero?
+        self.duration = duration
+        self.speed = SPEED.invert[to_number(params[3])]
+      end
+
+      def direction=(value)
+        unless DIRECTION.key?(value)
+          raise ArgumentError,
+                "direction must be one of :down, :up, or :cancel (#{value})"
+        end
+
         @direction = value
-     end
+      end
+
+      def duration=(value)
+        if value && (value < 0x0a || value > 0xff)
+          raise ArgumentError,
+                "duration must be in range 0x0a to 0xff (#{value})"
+        end
 
-     def duration=(value)
-        raise ArgumentError, "duration must be in range 0x0a to 0xff (#{value})" if value && (value < 0x0a || value > 0xff)
         @duration = value
-     end
+      end
+
+      def speed=(value)
+        raise ArgumentError, "speed must be one of :up, :down, or :slow (#{value})" unless SPEED.key?(value)
 
-     def speed=(value)
-        raise ArgumentError, "speed must be one of :up, :down, or :slow (#{value})" unless SPEED.keys.include?(value)
         @speed = speed
       end
 
@@ -93,7 +109,12 @@ module SDN
     class MoveOf < Message
       MSG = 0x04
       PARAMS_LENGTH = 4
-      TARGET_TYPE = { next_ip: 0x00, previous_ip: 0x01, jog_down_pulses: 0x02, jog_up_pulses: 0x03, jog_down_ms: 0x04, jog_up_ms: 0x05 }
+      TARGET_TYPE = { next_ip: 0x00,
+                      previous_ip: 0x01,
+                      jog_down_pulses: 0x02,
+                      jog_up_pulses: 0x03,
+                      jog_down_ms: 0x04,
+                      jog_up_ms: 0x05 }.freeze
 
       attr_reader :target_type, :target
 
@@ -108,12 +129,16 @@ module SDN
         super
         self.target_type = TARGET_TYPE.invert[to_number(params[0])]
         target = to_number(params[1..2], nillable: true)
-        target *= 10 if %I{jog_down_ms jog_up_ms}.include?(target_type)
+        target *= 10 if %I[jog_down_ms jog_up_ms].include?(target_type)
         self.target = target
       end
 
       def target_type=(value)
-        raise ArgumentError, "target_type must be one of :next_ip, :previous_ip, :jog_down_pulses, :jog_up_pulses, :jog_down_ms, :jog_up_ms" unless value.nil? || TARGET_TYPE.keys.include?(value)
+        unless value.nil? || TARGET_TYPE.key?(value)
+          raise ArgumentError, "target_type must be one of :next_ip, :previous_ip, " \
+                               ":jog_down_pulses, :jog_up_pulses, :jog_down_ms, :jog_up_ms"
+        end
+
         @target_type = value
       end
 
@@ -124,7 +149,7 @@ module SDN
 
       def params
         param = target || 0xffff
-        param /= 10 if %I{jog_down_ms jog_up_ms}.include?(target_type)
+        param /= 10 if %I[jog_down_ms jog_up_ms].include?(target_type)
         transform_param(TARGET_TYPE[target_type]) + from_number(param, 2) + transform_param(0)
       end
     end
@@ -138,7 +163,7 @@ module SDN
 
       attr_reader :target_type, :target, :speed
 
-      def initialize(dest= nil, target_type = :down_limit, target = nil, speed = :up, **kwargs)
+      def initialize(dest = nil, target_type = :down_limit, target = nil, speed = :up, **kwargs)
         kwargs[:dest] ||= dest
         super(**kwargs)
         self.target_type = target_type
@@ -154,7 +179,11 @@ module SDN
       end
 
       def target_type=(value)
-        raise ArgumentError, "target_type must be one of :down_limit, :up_limit, :ip, :position_pulses, or :position_percent" unless TARGET_TYPE.keys.include?(value)
+        unless TARGET_TYPE.key?(value)
+          raise ArgumentError,
+                "target_type must be one of :down_limit, :up_limit, :ip, :position_pulses, or :position_percent"
+        end
+
         @target_type = value
       end
 
@@ -164,7 +193,8 @@ module SDN
       end
 
       def speed=(value)
-        raise ArgumentError, "speed must be one of :up, :down, or :slow" unless SPEED.keys.include?(value)
+        raise ArgumentError, "speed must be one of :up, :down, or :slow" unless SPEED.key?(value)
+
         @speed = value
       end
 

data/lib/sdn/message/get.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SDN
   class Message
     class GetGroupAddr < Message
@@ -18,7 +20,8 @@ module SDN
       end
 
       def group_index=(value)
-        raise ArgumentError, "group_index is out of range" unless (1..16).include?(value)
+        raise ArgumentError, "group_index is out of range" unless (1..16).cover?(value)
+
         @group_index = value
       end
 
@@ -49,7 +52,8 @@ module SDN
       end
 
       def ip=(value)
-        raise ArgumentError, "invalid IP #{value} (should be 1-16)" unless (1..16).include?(value)
+        raise ArgumentError, "invalid IP #{value} (should be 1-16)" unless (1..16).cover?(value)
+
         @ip = value
       end
 

data/lib/sdn/message/helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SDN
   class Message
     module Helpers
@@ -6,39 +8,39 @@ module SDN
       end
 
       def print_address(addr_bytes)
-        "%02X.%02X.%02X" % addr_bytes
+        format("%02X.%02X.%02X", *addr_bytes)
       end
 
-      def is_group_address?(addr_bytes)
+      def group_address?(addr_bytes)
         addr_bytes[0..1] == [1, 1]
       end
 
       def node_type_from_number(number)
         case number
-        when 1; :st50ilt2
-        when 2; :st30
-        when 6; :glydea
-        when 7; :st50ac
-        when 8; :st50dc
-        when 0x70; :lt50
+        when 1 then :st50ilt2
+        when 2 then :st30
+        when 6 then :glydea
+        when 7 then :st50ac
+        when 8 then :st50dc
+        when 0x70 then :lt50
         else; number
         end
       end
 
       def node_type_to_number(type)
         case type
-        when :st50ilt2; 1
-        when :st30; 2
-        when :glydea; 6
-        when :st50ac; 7
-        when :st50dc; 8
-        when :lt50; 0x70
+        when :st50ilt2 then 1
+        when :st30 then 2
+        when :glydea then 6
+        when :st50ac then 7
+        when :st50dc then 8
+        when :lt50 then 0x70
         else; type
         end
       end
 
       def node_type_to_string(type)
-        type.is_a?(Integer) ? "%02xh" % type : type.inspect
+        type.is_a?(Integer) ? format("%02xh", type) : type.inspect
       end
 
       def transform_param(param)
@@ -52,28 +54,27 @@ module SDN
       end
 
       def from_number(number, bytes = 1)
-        number ||= 1 ** (bytes * 8) - 1
+        number ||= (1**(bytes * 8)) - 1
         number = number.to_i
-        bytes.times.inject([]) do |res, _|
-          res << (0xff - number & 0xff)
+        bytes.times.each_with_object([]) do |_, res|
+          res << ((0xff - number) & 0xff)
           number >>= 8
-          res
         end
       end
 
       def to_string(param)
         chars = param.map { |b| 0xff - b }
-        chars.pack("C*").sub(/\0+$/, '').strip
+        chars.pack("C*").sub(/\0+$/, "").strip
       end
 
       def from_string(string, bytes)
         chars = string.bytes
-        chars = chars[0...bytes].fill(' '.ord, chars.length, bytes - chars.length)
+        chars = chars[0...bytes].fill(" ".ord, chars.length, bytes - chars.length)
         chars.map { |b| 0xff - b }
       end
 
       def checksum(bytes)
-        result = bytes.inject(&:+)
+        result = bytes.sum
         [result >> 8, result & 0xff]
       end
     end

data/lib/sdn/message/ilt2/get.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SDN
   class Message
     module ILT2
@@ -22,15 +24,16 @@ module SDN
         end
 
         def ip=(value)
-          raise ArgumentError, "invalid IP #{value} (should be 1-16)" unless (1..16).include?(value)
+          raise ArgumentError, "invalid IP #{value} (should be 1-16)" unless (1..16).cover?(value)
+
           @ip = value
         end
-  
+
         def parse(params)
           super
           self.ip = to_number(params[0]) + 1
         end
-  
+
         def params
           transform_param(@ip - 1)
         end