sip2-ruby 0.1.0

data/lib/sip2/message/base_message.rb

@@ -0,0 +1,135 @@
+require 'dry-struct'
+require 'sip2/types'
+require 'sip2/fields'
+module Sip2
+
+  module Message
+    class BaseMessage < Dry::Struct
+
+      SEQUENCE_NUMBER_FORMAT = Sip2::FIELDS.fetch(:sequence_number).fetch(:format)
+      CHECKSUM_CODE = Sip2::FIELDS.fetch(:checksum).fetch(:code)
+
+      schema schema.strict
+
+      transform_keys(&:to_sym)
+
+      class << self
+
+        def ordered_fields
+          @ordered_fields
+        end
+
+        def delimited_fields
+          @delimited_fields ||=
+            (@required_delimited_fields + @optional_delimited_fields)
+              .sort_by { |field| Sip2::FIELDS[field][:code] }
+        end
+
+      end
+
+      def fields
+        self.class.fields
+      end
+
+      def ordered_fields
+        self.class.ordered_fields
+      end
+
+      def delimited_fields
+        self.class.delimited_fields
+      end
+
+      def format_field(field_name)
+        field_info = Sip2::FIELDS.fetch(field_name)
+        attribute_name = field_info.fetch(:name, field_name)
+        format = field_info.fetch(:format)
+
+        if self.attributes.key?(attribute_name)
+          format.call(self[attribute_name])
+        else
+          ""
+        end
+      end
+
+      def checksum(msg)
+        # Add each character as an unsigned binary number
+        sum = msg.codepoints.sum
+
+        # Take the lower 16 bits of the total
+        sum16 = sum & 0xFFFF
+
+        # Perform a 2's complement
+        comp2 = (sum16 ^ 0xFFFF) + 1
+
+        # The checksum field is the result represented by four hex digits
+        sprintf("%04X", comp2)
+      end
+
+      def checksum_field(message, checksum_encoder: nil)
+        msg =
+          if checksum_encoder
+            checksum_encoder.call(message)
+          else
+            message
+          end
+        CHECKSUM_CODE + checksum(msg + CHECKSUM_CODE)
+      end
+
+      def sequence_number_field
+        if attributes.has_key?(:sequence_number)
+          SEQUENCE_NUMBER_FORMAT.call(self[:sequence_number])
+        else
+          ""
+        end
+      end
+
+      def error_detection_fields(message, **checksum_options)
+        if attributes.has_key?(:checksum)
+          sequence_number = sequence_number_field
+          sequence_number + checksum_field(message + sequence_number, **checksum_options)
+        else
+          ""
+        end
+      end
+
+      def format_unexpected_field(code:, value:)
+        sprintf("%s%s|", code, value)
+      end
+
+      def format_unexpected_fields
+
+        if self.attributes.key?(:unexpected_fields)
+          Array(self[:unexpected_fields])
+            .map { |f| format_unexpected_field(**f) }
+            .join
+        else
+          ""
+        end
+      end
+
+      def encode(add_error_detection: true, checksum_encoder: nil, strip_extra_fields: false)
+        message = sprintf(
+          "%<code>s%<ordered_fields>s%<delimited_fields>s%<unexpected_fields>s",
+          code: self.class::CODE,
+          ordered_fields:
+            ordered_fields.map { |f| format_field(f) }.join,
+          delimited_fields:
+            delimited_fields.map { |f| format_field(f) }.join,
+          unexpected_fields:
+            if strip_extra_fields then "" else format_unexpected_fields end
+        )
+        error_detection =
+          if add_error_detection 
+            error_detection_fields(message, checksum_encoder: checksum_encoder)
+          else
+            ""
+          end
+        sprintf("%s%s\r", message, error_detection)
+      end
+
+      def to_s
+        encode
+      end
+    end
+  end
+end

data/lib/sip2/message/unknown_message.rb

@@ -0,0 +1,26 @@
+require 'dry-struct'
+require 'sip2/types'
+module Sip2
+
+  module Message
+    class UnknownMessage < Dry::Struct
+
+      schema schema.strict
+
+      transform_keys(&:to_sym)
+
+      attribute :message_code, Types::String.constrained(format: /^[A-Za-z0-9]{2,2}$/)
+      attribute :message_name, Types::String.default("Unknown Message".freeze)
+      attribute :message_data, Types::String
+
+      def encode
+        to_s
+      end
+
+      def to_s
+        sprintf("%s%s\r", message_code, message_data)
+      end
+
+    end
+  end
+end

data/lib/sip2/message.rb

@@ -0,0 +1,95 @@
+require 'sip2/fields'
+require 'sip2/messages'
+require 'sip2/message/base_message'
+require 'sip2/message/unknown_message'
+
+module Sip2
+  module Message
+
+    BY_CODE = {}
+    BY_SYMBOL = {}
+
+    def self.[](code)
+      BY_CODE[code]
+    end
+
+    def self.from_hash(data)
+      code = data.fetch(:message_code) { data.fetch("message_code") }
+      klass = self[code] || UnknownMessage
+      klass.new(data)
+    end
+
+    MESSAGES.each do |msg|
+
+      code = msg.fetch(:code)
+      name = msg.fetch(:name)
+      symbol = msg.fetch(:symbol)
+
+      class_name = symbol.to_s.split("_").map(&:capitalize).join
+
+      ordered_fields = msg.fetch(:ordered_fields)
+      required_delimited_fields = msg.fetch(:required_delimited_fields)
+      optional_delimited_fields = msg.fetch(:optional_delimited_fields)
+
+      struct = Class.new(Sip2::Message::BaseMessage) do
+        self::CODE = code
+        self::NAME = name
+
+        attribute :message_code, Types::String.constrained(eql: code).default(code)
+        attribute :message_name, Types::String.constrained(eql: name).default(name)
+
+        @ordered_fields = ordered_fields
+        @required_delimited_fields = required_delimited_fields
+        @optional_delimited_fields = optional_delimited_fields
+
+        (ordered_fields + required_delimited_fields).each do |field_name|
+          field_info = Sip2::FIELDS.fetch(field_name)
+          attribute_name = field_info.fetch(:name, field_name)
+          field_type = field_info.fetch(:type)
+          if field_type.is_a?(Hash)
+            attribute attribute_name do
+              field_type.each do |subfield_name,subfield_type|
+                attribute subfield_name, subfield_type
+              end
+            end
+          else
+            attribute attribute_name, field_type
+          end
+        end
+
+        optional_delimited_fields.each do |field_name|
+          field_info = Sip2::FIELDS.fetch(field_name)
+          field_type = field_info.fetch(:type)
+          if field_type.is_a?(Hash)
+            attribute? field_name do
+              field_type.each do |subfield_name,subfield_type|
+                attribute subfield_name, subfield_type
+              end
+            end
+          else
+            attribute? field_name, field_type
+          end
+        end
+
+        attribute? :unexpected_fields, Types::Array do
+          attribute :code, Types::String
+          attribute :value, Types::String
+        end
+
+        unless [:request_asc_resend, :request_sc_resend].include?(symbol)
+          attribute? :sequence_number, Types::Integer.constrained(included_in: 0..9)
+        end
+        attribute? :checksum, Types::String.constrained(format: /^[0-9A-Fa-f]{4,4}$/)
+
+      end
+
+      BY_CODE[code] = struct
+      BY_SYMBOL[symbol] = struct
+      Message.const_set(class_name, struct)
+
+    end
+
+    BY_CODE.freeze
+    BY_SYMBOL.freeze
+  end
+end

data/lib/sip2/message_parser_rules.rb

@@ -0,0 +1,122 @@
+require 'parslet'
+require 'sip2/field_parser_rules'
+require 'sip2/messages'
+
+module Sip2
+  module MessageParserRules
+    include Parslet
+
+    include Sip2::FieldParserRules
+
+    rule(:newline) { str("\n") }
+
+    rule(:empty_hash) {
+      str("").as(:empty_hash)
+    }
+
+    rule(:no_ordered_fields) {
+      empty_hash.as(:ordered_fields)
+    }
+
+    rule(:no_delimited_fields) {
+      empty_hash.as(:delimited_fields)
+    }
+
+    rule(:error_detection) {
+      ( (sequence_number >> checksum) | empty_hash ).as(:error_detection)
+    }
+
+    rule(:checksum_only) {
+      ( checksum | empty_hash ).as(:error_detection)
+    }
+
+    rule(:unexpected_field) {
+      (
+        any_field_identifier.as(:code) >>
+        any_valid.repeat.as(:str).as(:value) >>
+        pipe
+      )
+    }
+
+    rule(:unexpected_fields) {
+      unexpected_field.as(:unexpected_fields).as(:merge_repeat_to_array)
+    }
+
+    rule(:known_message_id) {
+      Sip2::MESSAGES_BY_CODE.keys.map { |s| str(s) }.inject { |res,a| res | a }
+    }
+
+    # A *command identifier* is defined as "two ASCII-characters". Theoretically
+    # that means any ASCII-character except for the NULL-character (which is
+    # disallowed) and carriage return (which might only be used as message
+    # terminator).
+    #
+    # However, all existing messages have two digit identifiers. It is highly
+    # unlikely that punctuation will be used as command identifiers. For
+    # simplicity we reduce the accepted character range to digits and letters.
+    #
+    rule(:unknown_message_id) {
+      known_message_id.absent? >> match["0-9A-Za-z"].repeat(2,2).as(:str)
+    }
+
+    MESSAGES.each do |msg|
+      ordered = msg.fetch(:ordered_fields)
+      required_delimited = msg.fetch(:required_delimited_fields)
+      optional_delimited = msg.fetch(:optional_delimited_fields)
+      unexpected_delimited = [ :unexpected_fields ]
+      delimited = required_delimited + optional_delimited + unexpected_delimited
+
+      rule(msg[:symbol]) {
+        str(msg[:code]).as(:str).as(:message_code).as(:message_identifiers) >>
+        (
+          if ordered.any?
+            ordered
+              .map { |f| self.send(f) }
+              .reduce { |res,atom| res >> atom }
+          else
+            empty_hash
+          end
+        ).as(:ordered_fields) >>
+        (
+          if delimited.any?
+            delimited
+              .map { |f| self.send(f) }
+              .reduce { |res,atom| res | atom }
+              .repeat.as(:merge_repeat)
+          else
+            empty_hash
+          end
+        ).as(:delimited_fields) >>
+        (
+          if [:request_sc_resend, :request_asc_resend].include?(msg[:symbol])
+            checksum_only
+          else
+            error_detection
+          end
+        ) >>
+        eom
+      }
+    end
+
+    rule(:unknown_message_data) {
+      (eom.absent? >> any).repeat.as(:str) >> eom
+    }
+
+    # Messages with unknown ID:s should be accepted and ignored
+    rule(:unknown_message) {
+      unknown_message_id.as(:message_code) >>
+      unknown_message_data.as(:message_data)
+    }
+
+    rule(:known_message) {
+      MESSAGES
+        .map { |msg| self.send(msg[:symbol]) }
+        .reduce { |res,atom| res | atom }
+    }
+
+    rule(:messages) {
+      (( known_message | unknown_message) >> newline.maybe).repeat
+    }
+
+  end
+end