onkyo_eiscp_ruby 0.0.3 → 2.1.2

data/lib/eiscp.rb

@@ -1,9 +1,12 @@
-# Library for controlling Onkyo receivers over TCP/IP.
+# frozen_string_literal: true
 
+# Library for controlling Onkyo receivers over TCP/IP.
+#
 module EISCP
-  VERSION = '0.0.3'
+  VERSION = '2.1.2'
 end
 
-require 'eiscp/receiver'
-require 'eiscp/message'
-require 'eiscp/command'
+require_relative './eiscp/receiver'
+require_relative './eiscp/message'
+require_relative './eiscp/dictionary'
+require_relative './eiscp/parser'

data/lib/eiscp/dictionary.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative './dictionary/dictionary_generators'
+require_relative './dictionary/dictionary_helpers'
+
+module EISCP
+  # This module provides an interface to the information from the yaml file. It
+  # uses DictionaryGenerators to add commands specified by ranges in the yaml
+  # file. It uses DictionaryHelpers to convert commands and values to and from
+  # their human readable form.
+  #
+  module Dictionary
+    extend DictionaryGenerators
+    extend DictionaryHelpers
+
+    class << self
+      attr_reader :zones
+      attr_reader :modelsets
+      attr_reader :commands
+    end
+
+    DEFAULT_ZONE = 'main'
+    @yaml_file_path = File.join(__dir__, '../../eiscp-commands.yaml')
+    @commands = YAML.load(File.read(@yaml_file_path))
+    @modelsets = @commands[:modelsets]
+    @commands.delete(:modelsets)
+    @zones = @commands.map { |k, _| k }
+
+    @additions = []
+    @commands.each_key do |zone|
+      @commands[zone].each do |command|
+        command = command[0]
+        @commands[zone][command][:values].each do |value|
+          value = value[0]
+          if value.is_a? Array
+            @additions << [zone, command, value, create_range_commands(zone, command, value)]
+          elsif value.match(/^(B|T){xx}$/)
+            @additions << [zone, command, value, create_treble_bass_commands(zone, command, value)]
+          elsif value.match(/^{xx}$/)
+            @additions << [zone, command, value, create_balance_commands(zone, command, value)]
+          else
+            next
+          end
+        end
+      end
+    end
+
+    @additions.each do |zone, command, value, hash|
+      @commands[zone][command][:values].merge! hash
+    rescue StandardError
+      puts "Failed to add #{hash} to #{zone}:#{command}:#{value}"
+    end
+  end
+end

data/lib/eiscp/dictionary/dictionary_generators.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module EISCP
+  module Dictionary
+    # This module provides methods that can be used to generate command entries
+    # that are specified as ranges in the yaml file.
+    #
+    module DictionaryGenerators
+      # Creates a hash object for range commands like master-volume
+      #
+      def create_range_commands(zone, command, value)
+        case value.count
+        when 3
+          range = Range.new(value[0], value[2])
+        when 2
+          range = Range.new(*value)
+        end
+        tmp = {}
+        range.each do |number|
+          tmp.merge!(number.to_s(16).rjust(2, '0').upcase =>
+            {
+              name: number.to_s,
+              description: @commands[zone][command][:values][value][:description].gsub(/\d - \d+/, number.to_s),
+              models: @commands[zone][command][:values][value][:models]
+            })
+        end
+        tmp
+      end
+
+      # Creates hash object for treble and bass commands
+      #
+      def create_treble_bass_commands(zone, command, value)
+        tmp = {}
+        ['-A', '-8', '-6', '-4', '-2', '00', '+2', '+4', '+6', '+8', '+A'].each do |v|
+          tmp.merge!((value[0] + v.to_s) =>
+            {
+              name: value[0].downcase + v,
+              description: @commands[zone][command][:values][value[0] + '{xx}'][:description].gsub(/\(.*[\]|\)]$/, v),
+              models: @commands[zone][command][:values][value[0] + '{xx}'][:models]
+            })
+        end
+        tmp
+      end
+
+      # Creates hash object for balance commands
+      #
+      def create_balance_commands(zone, command, _value)
+        tmp = {}
+        ['-A', '-8', '-6', '-4', '-2', '00', '+2', '+4', '+6', '+8', '+A'].each do |v|
+          tmp.merge!(v.to_s =>
+            {
+              name: v.downcase,
+              description: @commands[zone][command][:values]['{xx}'][:description].gsub(/\(.*[\]|\)]$/, v),
+              models: @commands[zone][command][:values]['{xx}'][:models]
+            })
+        end
+        tmp
+      end
+    end
+  end
+end

data/lib/eiscp/dictionary/dictionary_helpers.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module EISCP
+  module Dictionary
+    # This module provides methods to get information from the Dictionary about
+    # commands, values, zones, and models.
+    #
+    module DictionaryHelpers
+      # Return the zone that includes the given command
+      def zone_from_command(command)
+        @zones.each do |zone|
+          @commands[zone].each_pair do |k, _|
+            return zone if command == k
+          end
+        end
+        nil
+      end
+
+      # Return the human readable name of a command
+      def command_to_name(command)
+        command = command.upcase
+        begin
+          zone = zone_from_command(command)
+          @commands[zone][command][:name]
+        rescue StandardError
+          nil
+        end
+      end
+
+      # Return the command from a given command name
+      def command_name_to_command(name, command_zone = nil)
+        if command_zone.nil?
+
+          @zones.each do |zone|
+            @commands[zone].each_pair do |command, attrs|
+              return command if attrs[:name] == name
+            end
+          end
+          nil
+
+        else
+
+          @commands[command_zone].each_pair do |command, attrs|
+            return command if attrs[:name] == name
+          end
+          nil
+
+        end
+      end
+
+      # Return a value name from a command and a value
+      def command_value_to_value_name(command, value)
+        zone = zone_from_command(command)
+        command_value = @commands[zone][command][:values][value][:name]
+        if command_value.class == String
+          command_value
+        elsif command_value.class == Array
+          command_value.first
+        end
+      rescue StandardError
+        nil
+      end
+
+      # Return a value from a command and value name
+      def command_value_name_to_value(command, value_name)
+        zone = zone_from_command(command)
+        @commands[zone][command][:values].each_pair do |k, v|
+          if v[:name].class == String
+            return k if v[:name] == value_name.to_s
+          elsif v[:name].class == Array
+            return k if v[:name].first == value_name.to_s
+          end
+        end
+        return nil
+      rescue StandardError
+        nil
+      end
+
+      # Return a command description from a command name and zone
+      def description_from_command_name(name, zone)
+        @commands[zone].each_pair do |command, attrs|
+          return @commands[zone][command][:description] if attrs[:name] == name
+        end
+        nil
+      end
+
+      # Return a command description from a command
+      def description_from_command(command)
+        zone = zone_from_command(command)
+        @commands[zone][command][:description]
+      end
+
+      # Return a value description from a command and value
+      def description_from_command_value(command, value)
+        zone = zone_from_command(command)
+        @commands[zone][command][:values].select do |k, v|
+          return v[:description] if k == value
+        end
+        nil
+      end
+
+      # Return a list of commands compatible with a given model
+      def list_compatible_commands(modelstring)
+        sets = []
+        @modelsets.each_pair do |set, array|
+          sets << set if array.include? modelstring
+        end
+        sets
+      end
+
+      # Checks to see if the command is in the Dictionary
+      #
+      def known_command?(command)
+        zone = zone_from_command(command)
+        @commands[zone].include? command
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/eiscp/message.rb

@@ -1,99 +1,123 @@
+# frozen_string_literal: true
+
+require_relative './dictionary'
+require_relative './parser'
+
 module EISCP
+  # The EISCP::Message class is used to handle commands and responses.
+  #
+  # Messages can be parsed directly from raw data or created with values:
+  #   receiver = Receiver.new
+  #
+  #   command = EISCP::Message.new('PWR', 'QSTN')
+  #   response = EISCP::Parser.parse(receiver.send_recv(command))
+  #
   class Message
-
     # EISCP header
     attr_accessor :header
-    MAGIC = "ISCP"
+    # ISCP "magic" indicates the start of an eISCP message.
+    MAGIC = 'ISCP'
+    # eISCP header size, fixed length.
     HEADER_SIZE = 16
-    ISCP_VERSION = "\x01"
+    # ISCP protocol version.
+    ISCP_VERSION = 1
+    # Reserved for future protocol updates.
     RESERVED = "\x00\x00\x00"
 
-
-    # ISCP attrs
-    attr_accessor :start
-    attr_accessor :unit_type
-    attr_accessor :command
-    attr_accessor :parameter
-    attr_reader   :iscp_message
-
-
-    # REGEX
-    REGEX = /(?<start>!)?(?<unit_type>(\d|x))?(?<command>[A-Z]{3})\s?(?<parameter>.*)(?<end>\x1A)?/
-
-    def initialize(command, parameter, unit_type = "1", start = "!")
-      if unit_type == nil
-        @unit_type = "1"
-      else
-        @unit_type = unit_type
-      end
-      if start == nil
-        @start = "!"
-      else
-        @start = start
+    # ISCP Start character, usually "!"
+    attr_reader :start
+    # ISCP Unit Type character, usually "1"
+    attr_reader :unit_type
+    # ISCP Command
+    attr_reader :command
+    # Human readable command name
+    attr_reader :command_name
+    # Command description
+    attr_reader :command_description
+    # ISCP Command Value
+    attr_reader :value
+    # Human readable value name
+    attr_reader :value_name
+    # Value description
+    attr_reader :value_description
+    # ISCP Zone
+    attr_reader :zone
+    # Differentiates parsed messages from command messages
+    attr_reader :parsed
+
+    # Terminator character for eISCP packets
+    attr_reader :terminator
+
+    # Create an ISCP message
+    # @param [String] command three-character length ISCP command
+    # @param [String] value variable length ISCP command value
+    # @param [String] unit_type_character override default unit type character, optional
+    # @param [String] start_character override default start character, optional
+    def initialize(command: nil, value: nil, terminator: "\r\n", unit_type: '1', start: '!')
+      unless Dictionary.known_command?(command)
+        # STDERR.puts "Unknown command #{command}"
       end
-      @command = command
-      @parameter = parameter
-      @iscp_message = [ @start, @unit_type, @command, @parameter ].inject(:+)
-      @header = { :magic => MAGIC, 
-                  :header_size => HEADER_SIZE, 
-                  :data_size => @iscp_message.length,
-                  :version => ISCP_VERSION, 
-                  :reserved => RESERVED 
-      }
-    end
-
 
-    # Check if two messages send the same command
-    def ==(message_object)
-      self.iscp_message == message_object.iscp_message ? true : false
-    end
-    # Identifies message format, calls appropriate parse function
-    # returns Message object.
+      raise 'No value specified.' if value.nil?
 
-    def self.parse(string)
-      case string
-      when /^ISCP/
-        parse_eiscp_string(string)
-      when REGEX
-        parse_iscp_message(string)
-      else
-        puts "Not a valid ISCP or EISCP message."
+      @command = command
+      @value = value
+      @terminator = terminator
+      @unit_type = unit_type
+      @start = start
+      @header = { magic: MAGIC,
+                  header_size: HEADER_SIZE,
+                  data_size: to_iscp.length,
+                  version: ISCP_VERSION,
+                  reserved: RESERVED }
+      begin
+        get_human_readable_attrs
+      rescue StandardError
+        # STDERR.puts"Couldn't get all human readable attrs"
       end
     end
 
-
-
-    # ISCP Message string parser
-
-    def self.parse_iscp_message(msg_string)
-      match = msg_string.match(REGEX)
-      Message.new(match[:command], match[:parameter], match[:unit_type], match[:start])
-    end
-
-    #parse eiscp_message string 
-    def self.parse_eiscp_string(eiscp_message_string)
-      array = eiscp_message_string.unpack("A4NNAa3A*")
-      iscp_message = Message.parse_iscp_message(array[5])
-      packet = Message.new(iscp_message.command, iscp_message.parameter, iscp_message.unit_type, iscp_message.start)
-      packet.header = { 
-        :magic => array[0],
-        :header_size => array[1],
-        :data_size => array[2],
-        :version => array[3],
-        :reserved => array[4]
-      }   
-      return packet
+    # Check if two messages are equivalent comparing their ISCP messages.
+    #
+    def ==(other)
+      to_iscp == other.to_iscp
     end
 
     # Return ISCP Message string
+    #
     def to_iscp
-      return "#{@start + @unit_type + @command + @parameter}"
+      (@start + @unit_type + @command + @value).to_s
     end
 
     # Return EISCP Message string
+    #
     def to_eiscp
-      return [ @header[:magic], @header[:header_size], @header[:data_size], @header[:version], @header[:reserved], @iscp_message.to_s ].pack("A4NNAa3A*")
+      [
+        @header[:magic],
+        @header[:header_size].to_i,
+        @header[:data_size].to_i,
+        @header[:version].to_i,
+        @header[:reserved],
+        to_iscp.to_s,
+        @terminator
+      ].pack('A4NNCa3A*A*')
+    end
+
+    # Return human readable description.
+    #
+    def to_s
+      "#{@zone} - #{@command_name}:#{@value_name}"
     end
 
+    private
+
+    # Retrieves human readable attributes from the yaml file via Dictionary
+    def get_human_readable_attrs
+      @zone = Dictionary.zone_from_command(@command)
+      @command_name = Dictionary.command_to_name(@command)
+      @command_description = Dictionary.description_from_command(@command)
+      @value_name = Dictionary.command_value_to_value_name(@command, @value)
+      @value_description = Dictionary.description_from_command_value(@command, @value)
+    end
   end
 end