ax25 0.0.1

data/lib/ax25/encoder.rb

@@ -0,0 +1,3 @@
+require 'ax25/encoder/aprs_kiss'
+require 'ax25/encoder/igate_tcp'
+require 'ax25/encoder/encoder'

data/lib/ax25/frame/entity.rb

@@ -0,0 +1,10 @@
+module Ax25
+  public
+  module Entity
+    include Abstractify::Abstract
+
+    abstract :decrement_ssid, :==, :eql?, :to_s
+
+    attr_reader :callsign, :ssid
+  end
+end

data/lib/ax25/frame/frame.rb

@@ -0,0 +1,22 @@
+require 'abstractify'
+require 'ax25/frame/message'
+
+module Ax25
+  ##
+  # An APXP compatible APRS frame, excluding the path data entierly. The
+  # UnpathedFrame and all its fields are immutable.
+  #
+  # @example Comparing frames
+  #   orig_frame = Ax25.new('WI2ARD-1', 'OMG', ['WIDE2-2' 'WIDE1-1'], 'payload goes here')
+  #   diff_frame = Ax25.new('WI2ARD-1', 'OMG', ['WIDE2-2' 'WIDE1-1'], 'different payload')
+  #   assert not orig_frame.eql? diff_frame
+  public
+  module Frame
+    include Ax25::Message
+    include Abstractify::Abstract
+
+    abstract :path_agnostic_identity
+
+    attr_accessor :path
+  end
+end

data/lib/ax25/frame/hop.rb

@@ -0,0 +1,11 @@
+require 'ax25/frame/entity'
+
+module Ax25
+  public
+  module Hop
+    include Ax25::Entity
+    include Abstractify::Abstract
+
+    abstract :toggle_seen, :decrement_ssid, :==, :eql?, :to_s, :seen?
+  end
+end

data/lib/ax25/frame/immutable_entity.rb

@@ -0,0 +1,87 @@
+require 'ax25/frame/entity'
+
+module Ax25
+  public
+  class ImmutableEntity
+    include Entity
+
+    attr_reader :callsign, :ssid
+
+    public
+    def initialize(callsign, ssid, strict_callsign: true, strict_ssid: true)
+      raise ArgumentError.new("callsign can not be nil") if callsign.nil?
+
+      raise ArgumentError.new("callsign must be a String") if not callsign.kind_of? String
+      raise ArgumentError.new("ssid must be an Integer.") if (not ssid.nil?) && (not ssid.kind_of? Integer)
+
+      raise ArgumentError.new("ssid must be a value between 0 (inclusive) and 15 (inclusive): #{callsign}-#{ssid}") if (not ssid.nil?) && (ssid < 0 || ssid > 15) && (strict_ssid)
+      raise ArgumentError.new("Callsign can not be an empty string") if callsign.empty? && strict_callsign
+      raise ArgumentError.new("Callsign must only contain numebers and letters") if callsign.strip.match?(/[^a-zA-Z0-9]/) && (strict_callsign)
+
+      @callsign = callsign.strip.upcase.freeze
+      if (ssid.nil?) || (ssid.eql? 0)
+        @ssid = nil
+      else
+        @ssid = ssid
+      end
+    end
+
+    public
+    def self.from_raw(raw_hop, strict_callsign: true, strict_ssid: true)
+      raise ArgumentError.new("raw_hop can not be nil") if raw_hop.nil?
+
+      callsign = nil
+      ssid = nil
+
+      hop = raw_hop.dup
+
+      raise ArgumentError.new("Hops can only contain letters, numbers and dashes") if hop.strip.match?(/[^a-zA-Z0-9\-]/) && strict_callsign
+
+      if not hop.include? "-"
+        ssid = nil
+        callsign = hop.strip
+      else
+        split_hop = hop.strip.split("-")
+        raise ArgumentError.new("More than one hypen seen in a hop, invalid format") if split_hop.length > 2
+        raise ArgumentError.new("Hop format was not valid, hyphen placed at end or beginning of string") if split_hop.length <= 1
+        callsign = split_hop[0]
+        ssid = split_hop[1].to_i
+      end
+
+      return Ax25::ImmutableEntity.new(callsign, ssid, strict_callsign: strict_callsign, strict_ssid: strict_ssid)
+    end
+
+    public
+    def decrement_ssid
+      raise RangeError.new("SSID can not be decremented when it is currently 0 or nil") if (self.ssid.nil?) or (self.ssid <= 0)
+
+      return Ax25::ImmutableEntity.new(self.callsign, self.ssid - 1, strict_callsign: false, strict_ssid: false)
+    end
+
+    public
+    def eql?(other)
+      raise ArgumentError.new("The argument must be of type Hop (or a child class).") if not other.kind_of? Ax25::Entity
+
+      return self == other
+    end
+
+    public
+    def ==(other)
+      return false if other.nil?
+      return false if not other.respond_to? :callsign
+      return false if not other.respond_to? :ssid
+
+      return false if not self.callsign.eql? other.callsign
+      return false if not self.ssid.eql? other.ssid
+
+      return true
+    end
+
+    public
+    def to_s
+      ret_val = self.callsign.dup
+      ret_val << ("-" + self.ssid.to_s) if not self.ssid.nil?
+      return ret_val
+    end
+  end
+end

data/lib/ax25/frame/immutable_frame.rb

@@ -0,0 +1,50 @@
+require 'ax25/frame/immutable_message'
+require 'ax25/frame/frame'
+
+module Ax25
+  public
+  class ImmutableFrame < Ax25::ImmutableMessage
+    include Frame
+
+    protected
+    def initialize(source, destination, path, payload)
+      raise ArgumentError.new("path argument can not be nil") if path.nil?
+      raise ArgumentError.new("path argument must be a Path, but found: " + path.class.to_s) if not path.kind_of? Ax25::Path
+
+      super(source, destination, payload)
+
+      @path = path
+    end
+
+    public
+    def eql?(other)
+      raise ArgumentError.new("The argument can not be a UnpathedFrame or a PathAgnosticFrame") if ((other.instance_of? ImmutableMessage) || (other.instance_of? PathAgnosticImmutableFrame))
+      raise ArgumentError.new("The argument must be of type Frame (or a child class).") if not other.kind_of? Frame
+
+      return self == other
+    end
+
+    public
+    def ==(other)
+      return false if not super(other)
+
+      return false if not other.respond_to? :path
+
+      if self.path.eql? other.path
+         return true
+      else
+        return false
+      end
+    end
+
+    public
+    def hash
+      return [super, self.path].hash
+    end
+
+    public
+    def path_agnostic_identity
+      return PathAgnosticImmutableFrame.new(self.source, self.destination, self.path, self.payload)
+    end
+  end
+end

data/lib/ax25/frame/immutable_hop.rb

@@ -0,0 +1,93 @@
+require 'ax25/frame/hop'
+require 'ax25/frame/immutable_entity'
+
+module Ax25
+  public
+  class ImmutableHop < Ax25::ImmutableEntity
+    include Hop
+
+    public
+    def initialize(callsign, ssid, seen, strict_callsign: true, strict_ssid: true)
+
+      raise ArgumentError.new("seen can not be nil") if seen.nil?
+      raise ArgumentError.new("seen must be a Boolean") if not (!!seen == seen)
+
+      super(callsign, ssid, strict_callsign: strict_callsign, strict_ssid: strict_ssid)
+
+      @seen = seen
+    end
+
+    public
+    def self.from_raw(raw_hop, strict_callsign: true, strict_ssid: true)
+      raise ArgumentError.new("raw_hop can not be nil") if raw_hop.nil?
+
+      callsign = nil
+      ssid = nil
+      seen = nil
+
+      hop = raw_hop.dup
+      if hop[-1].eql? "*"
+        seen = true
+        hop = hop[0..-2]
+      else
+        seen = false
+      end
+
+      raise ArgumentError.new("Hops can only contain letters, numbers and dashes. Hop: #{hop.to_s}") if hop.strip.match?(/[^a-zA-Z0-9\-]/) && strict_callsign
+
+      if not hop.include? "-"
+        ssid = nil
+        callsign = hop.strip
+      else
+        split_hop = hop.strip.split("-")
+        raise ArgumentError.new("More than one hypen seen in a hop, invalid format") if split_hop.length > 2
+        raise ArgumentError.new("Hop format was not valid, hyphen placed at end or beginning of string") if split_hop.length <= 1
+        callsign = split_hop[0]
+        ssid = split_hop[1].to_i
+      end
+
+      return Ax25::ImmutableHop.new(callsign, ssid, seen, strict_callsign: strict_callsign, strict_ssid: strict_ssid)
+    end
+
+    public
+    def seen?
+      return @seen
+    end
+
+    public
+    def toggle_seen
+      return Ax25::ImmutableHop.new(self.callsign, self.ssid, !self.seen?, strict_callsign: false, strict_ssid: false)
+    end
+
+    public
+    def decrement_ssid
+      raise RangeError.new("SSID can not be decremented when it is currently 0 or nil") if (self.ssid.nil?) or (self.ssid <= 0)
+
+      return Ax25::ImmutableHop.new(self.callsign, self.ssid - 1, self.seen?, strict_callsign: false, strict_ssid: false)
+    end
+
+    public
+    def eql?(other)
+      raise ArgumentError.new("The argument must be of type Hop (or a child class).") if not other.kind_of? Ax25::Hop
+
+      return self == other
+    end
+
+    public
+    def ==(other)
+      return false if !super(other)
+
+      return false if not other.respond_to? :seen?
+      return false if not self.seen?.eql? other.seen?
+
+      return true
+    end
+
+    public
+    def to_s
+      ret_val = super.dup
+      ret_val << "*" if self.seen?
+      return ret_val
+    end
+  end
+end

data/lib/ax25/frame/immutable_message.rb

@@ -0,0 +1,84 @@
+require 'ax25/frame/message'
+
+module Ax25
+  ##
+  # An APXP compatible APRS frame, excluding the path data entierly. The
+  # UnpathedFrame and all its fields are immutable.
+  #
+  # @example Comparing frames
+  #   orig_frame = Ax25.new('WI2ARD-1', 'OMG', ['WIDE2-2' 'WIDE1-1'], 'payload goes here')
+  #   diff_frame = Ax25.new('WI2ARD-1', 'OMG', ['WIDE2-2' 'WIDE1-1'], 'different payload')
+  #   assert not orig_frame.eql? diff_frame
+  public
+  class ImmutableMessage
+    include Message
+
+    ##
+    # Creates a new frame, all fields are duplicated but and immutable. All
+    # fields are validated.
+    #
+    # @param source [Ax25::Entity] The source callsign for the frame. Must be a
+    #    non-null string of non-zero length with only letters, numbers and
+    #    dashes. Will be converted uppercase.
+    # @param destination [Ax25::Entity] The destination callsign for the frame. Must
+    #    be a non-null string of non-zero length with only letters, numbers,
+    #    and dashes. Will be converted to uppercase.
+    # @param payload [String] The payload of the frame. Must be a non-null
+    #    string of non-zero length.
+    protected
+    def initialize(source, destination, payload)
+      raise ArgumentError.new("source argument can not be nil") if source.nil?
+      raise ArgumentError.new("destination argument can not be nil") if destination.nil?
+      raise ArgumentError.new("payload argument can not be nil") if payload.nil?
+
+      raise ArgumentError.new("source argument must be a Entity, but found: " + source.class.to_s) if not source.kind_of? Ax25::Entity
+      raise ArgumentError.new("destination argument must be a Entity, but found: " + source.class.to_s) if not destination.kind_of? Ax25::Entity
+      raise ArgumentError.new("payload argument must be a string, but found: " + source.class.to_s) if not payload.kind_of? String
+
+      # The following both duplicate/clone the argument and convert it to uppercase
+      @source = source
+      @destination = destination
+      @payload = payload.dup.freeze
+    end
+
+    public
+    def path_agnostic_eql?(other)
+      raise ArgumentError.new("The argument must be either an ImmutableMessage or a PathAgnosticFrame") if not ((other.instance_of? Ax25::ImmutableMessage) || (other.instance_of? Ax25::PathAgnosticImmutableFrame))
+
+      return self.path_agnostic_equality? other
+    end
+
+    public
+    def path_agnostic_equality?(other)
+      return false if (not other.respond_to? :source) ||
+                      (not other.respond_to? :destination) ||
+                      (not other.respond_to? :payload)
+
+      if (self.source.eql? other.source) && (self.destination.eql? other.destination) && (self.payload.eql? other.payload)
+         return true
+      else
+        return false
+      end
+    end
+
+    public
+    def path_agnostic_hash
+      return [self.source, self.destination, self.payload].hash
+    end
+
+    public
+    def ==(other)
+      return self.path_agnostic_equality? other
+    end
+
+    public
+    def eql?(other)
+      self.path_agnostic_eql? other
+    end
+
+    public
+    def hash
+      return self.path_agnostic_hash
+    end
+  end
+end

data/lib/ax25/frame/immutable_path.rb

@@ -0,0 +1,124 @@
+require 'ax25/frame/hop'
+require 'ax25/frame/path'
+
+module Ax25
+  public
+  class ImmutablePath
+
+    include Path
+
+    protected
+    def initialize(*hops)
+      @path_array = []
+      last_seen = true
+      hops.each do |hop|
+        raise ArgumentError.new("All arguments must not be nil: #{hops.to_s}") if (hop.nil?)
+        raise ArgumentError.new("All arguments must be of type Hop: #{hops.class.to_s}") if not hop.kind_of? Ax25::Hop
+        last_seen = false if not hop.seen?
+        @path_array << hop
+      end
+
+      @path_array.freeze
+      freeze
+    end
+
+    public
+    def self.from_raw(raw_path, strict_callsign: true, strict_ssid: true)
+      raise ArgumentError.new("raw_path can not be nil") if raw_path.nil?
+
+      if raw_path.kind_of? String
+        if raw_path.include? ","
+          raise ArgumentError.new("raw_path is too short") if raw_path.length < 3
+          raw_path = raw_path.split(",")
+        else
+          raise ArgumentError.new("raw_path is too short") if raw_path.length < 1
+          raw_path = [raw_path]
+        end
+      end
+
+      raise ArgumentError.new("raw_path must be array-like") if not raw_path.respond_to? :[]
+
+      new_path_array = []
+      raw_path.each do |hop|
+        if hop.kind_of? Ax25::Hop
+          new_hop = hop
+        else
+          new_hop = Ax25::ImmutableHop.from_raw(hop, strict_callsign: strict_callsign, strict_ssid: strict_ssid)
+        end
+        new_path_array << new_hop
+      end
+
+      return Ax25::ImmutablePath.new(*new_path_array)
+    end
+
+    public
+    def each
+      @path_array.each do |hop|
+        yield(hop)
+      end
+    end
+
+    public
+    def [](idx)
+      return @path_array[idx].dup.freeze
+    end
+
+    public
+    def length
+      return @path_array.length
+    end
+
+    public
+    def empty?
+      return @path_array.empty?
+    end
+
+    public
+    def eql?(other)
+      raise ArgumentError.new("The argument must be of type Path (or a child class).") if not other.kind_of? Path
+
+      return self == other
+    end
+
+    public
+    def ==(other)
+      return false if not other.respond_to? :[]
+      return false if not other.respond_to? :length
+      return false if not self.length.eql? other.length
+
+      (0..self.length - 1).each do |idx|
+        return false if not self[idx].eql? other[idx]
+      end
+
+      return true
+    end
+
+    public
+    def to_s
+      return @path_array.join(',')
+    end
+
+    public
+    def to_string_array
+      return @path_array.map {|e| e.to_s}
+    end
+
+    public
+    def to_array
+      return @path_array.dup
+    end
+
+    public
+    def unseen_hops
+        @path_array.select { |hop| !hop.seen  }
+    end
+
+    public
+    def seen_hops
+        @path_array.select { |hop| hop.seen  }
+    end
+
+    public
+    EMPTY_PATH = ImmutablePath.new().freeze
+  end
+end

data/lib/ax25/frame/message.rb

@@ -0,0 +1,21 @@
+require 'abstractify'
+
+module Ax25
+  ##
+  # An APXP compatible APRS frame, excluding the path data entierly. The
+  # UnpathedFrame and all its fields are immutable.
+  #
+  # @example Comparing frames
+  #   orig_frame = Ax25.new('WI2ARD-1', 'OMG', ['WIDE2-2' 'WIDE1-1'], 'payload goes here')
+  #   diff_frame = Ax25.new('WI2ARD-1', 'OMG', ['WIDE2-2' 'WIDE1-1'], 'different payload')
+  #   assert not orig_frame.eql? diff_frame
+  public
+  module Message
+
+    include Abstractify::Abstract
+
+    abstract :path_agnostic_eql?, :path_agnostic_equality?, :path_agnostic_hash, :==, :eql?, :hash
+
+    attr_accessor :source, :destination, :payload
+  end
+end

data/lib/ax25/frame/path.rb

@@ -0,0 +1,8 @@
+module Ax25
+  public
+  module Path
+    include Abstractify::Abstract
+
+    abstract :each, :[], :length, :eql?, :==, :to_s, :to_string_array, :to_array, :empty?
+  end
+end

data/lib/ax25/frame/path_agnostic_immutable_frame.rb

@@ -0,0 +1,31 @@
+require 'ax25/frame/immutable_frame'
+
+module Ax25
+  private
+  class PathAgnosticImmutableFrame < ImmutableFrame
+    protected
+    def initialize(source, destination, path, payload)
+      super(source, destination, path, payload)
+    end
+
+    public
+    def eql?(other)
+      return self.path_agnostic_eql? other
+    end
+
+    public
+    def ==(other)
+      return self.path_agnostic_equality? other
+    end
+
+    public
+    def hash
+      return self.path_agnostic_hash
+    end
+
+    public
+    def path_agnostic_identity
+      return self
+    end
+  end
+end

data/lib/ax25/frame.rb

@@ -0,0 +1,11 @@
+require 'ax25/frame/immutable_frame'
+require 'ax25/frame/entity'
+require 'ax25/frame/immutable_entity'
+require 'ax25/frame/hop'
+require 'ax25/frame/immutable_hop'
+require 'ax25/frame/path'
+require 'ax25/frame/immutable_path'
+require 'ax25/frame/immutable_message'
+require 'ax25/frame/path_agnostic_immutable_frame'
+require 'ax25/frame/message'
+require 'ax25/frame/frame'

data/lib/ax25.rb

@@ -0,0 +1,3 @@
+require 'ax25/encoder'
+require 'ax25/frame'
+require 'ax25/app_info'