nmea_plus 1.0.2 → 1.0.3

data/gem/lib/nmea_plus/ais_message_factory.rb

@@ -1,17 +0,0 @@
-
-require_relative 'message_factory'
-
-require_relative 'message/ais/vdm'
-
-module NMEAPlus
-  class AISMessageFactory < MessageFactory
-    def self.parent_module
-      "AIS"
-    end
-
-    def self.alternate_data_type(data_type)
-      # match last 3 digits (get rid of talker)
-      data_type[2..4]
-    end
-  end
-end

data/gem/lib/nmea_plus/message/base.rb

@@ -1,172 +0,0 @@
-
-class Class
-  # make our own shortcut syntax for message attributes
-  def field_reader(name, field_num, formatter = nil)
-    if formatter.nil?
-      self.class_eval("def #{name};@fields[#{field_num}];end")
-    else
-      self.class_eval("def #{name};#{formatter}(@fields[#{field_num}]);end")
-    end
-  end
-end
-
-module NMEAPlus
-  module Message
-    class Base
-      attr_accessor :prefix
-      attr_reader :payload
-      attr_reader :fields
-      attr_accessor :checksum
-      attr_accessor :interpreted_data_type
-      attr_accessor :next_part
-
-      field_reader :data_type, 0, nil
-
-      def original
-        "#{prefix}#{payload}*#{checksum}"
-      end
-
-      def payload=(val)
-        @payload = val
-        @fields = val.split(',', -1)
-      end
-
-      def checksum_ok?
-        calculated_checksum.upcase == checksum.upcase
-      end
-
-      def all_checksums_ok?
-        return false unless checksum_ok?
-        return true if @next_part.nil?
-        @next_part.all_checksums_ok?
-      end
-
-      def calculated_checksum
-        "%02x" % @payload.each_byte.map(&:ord).reduce(:^)
-      end
-
-      # many messages override these fields
-      def total_messages
-        1
-      end
-
-      # sequence number
-      def message_number
-        1
-      end
-
-      # create a linked list (O(n) implementation; message parts assumed to be < 10) of message parts
-      def add_message_part(msg)
-        if @next_part.nil?
-          @next_part = msg
-        else
-          @next_part.add_message_part(msg)
-        end
-      end
-
-      def all_messages_received?
-        total_messages == highest_contiguous_index
-      end
-
-      def highest_contiguous_index
-        _highest_contiguous_index(0)
-      end
-
-      def _highest_contiguous_index(last_index)
-        mn = message_number # just in case this is expensive to compute
-        return last_index if mn - last_index != 1      # indicating a skip or restart
-        return mn if @next_part.nil?                   # indicating we're the last message
-        @next_part._highest_contiguous_index(mn)       # recurse down
-      end
-
-      ######################### Conversion functions
-
-      # convert DDMM.MMM to single decimal value.
-      # sign_letter can be N,S,E,W
-      def _degrees_minutes_to_decimal(dm_string, sign_letter = "")
-        return nil if dm_string.nil? || dm_string.empty?
-        r = /(\d+)(\d{2}\.\d+)/  # (some number of digits) (2 digits for minutes).(decimal minutes)
-        m = r.match(dm_string)
-        raw = m.values_at(1)[0].to_f + (m.values_at(2)[0].to_f / 60)
-        _nsew_signed_float(raw, sign_letter)
-      end
-
-      # Use cardinal directions to assign positive or negative to mixed_val
-      # mixed_val can be string or float
-      # Of possible directions NSEW (sign_letter) treat N/E as + and S/W as -
-      def _nsew_signed_float(mixed_val, sign_letter = "")
-        value = mixed_val.to_f
-        value *= -1 if !sign_letter.empty? && "SW".include?(sign_letter.upcase)
-        value
-      end
-
-      # integer or nil
-      def _integer(field)
-        return nil if field.nil? || field.empty?
-        field.to_i
-      end
-
-      # float or nil
-      def _float(field)
-        return nil if field.nil? || field.empty?
-        field.to_f
-      end
-
-      # string or nil
-      def _string(field)
-        return nil if field.nil? || field.empty?
-        field
-      end
-
-      # hex to int or nil
-      def _hex_to_integer(field)
-        return nil if field.nil? || field.empty?
-        field.hex
-      end
-
-      # utc time or nil (HHMMSS or HHMMSS.SS)
-      def _utctime_hms(field)
-        return nil if field.nil? || field.empty?
-        re_format = /(\d{2})(\d{2})(\d{2}(\.\d+)?)/
-        now = Time.now
-        begin
-          hms = re_format.match(field)
-          Time.new(now.year, now.month, now.day, hms[1].to_i, hms[2].to_i, hms[3].to_f)
-        rescue
-          nil
-        end
-      end
-
-      # time interval or nil (HHMMSS or HHMMSS.SS)
-      def _interval_hms(field)
-        return nil if field.nil? || field.empty?
-        re_format = /(\d{2})(\d{2})(\d{2}(\.\d+)?)/
-        begin
-          hms = re_format.match(field)
-          Time.new(0, 0, 0, hms[1].to_i, hms[2].to_i, hms[3].to_f)
-        rescue
-          nil
-        end
-      end
-
-      def _utc_date_time(d_field, t_field)
-        return nil if t_field.nil? || t_field.empty?
-        return nil if d_field.nil? || d_field.empty?
-
-        # get formats and time
-        time_format = /(\d{2})(\d{2})(\d{2}(\.\d+)?)/
-        date_format = /(\d{2})(\d{2})(\d{2})/
-
-        # crunch numbers
-        begin
-          dmy = date_format.match(d_field)
-          hms = time_format.match(t_field)
-          Time.new(2000 + dmy[3].to_i, dmy[2].to_i, dmy[1].to_i, hms[1].to_i, hms[2].to_i, hms[3].to_f)
-        rescue
-          nil
-        end
-      end
-
-    end
-  end
-end

data/gem/lib/nmea_plus/message_factory.rb

@@ -1,68 +0,0 @@
-
-module NMEAPlus
-
-  # meant to be extended.  Creates message classes with a common prefix and variable suffix
-  class MessageFactory
-
-    # factory class must be extended
-    def self.parent_module
-      "FIXME_parent_module"
-    end
-
-    # a way to override the data_type (e.g. __AAM) with GPAAM to get a match
-    # whatever factory extends this class should override this method
-    def self.alternate_data_type(data_type)
-      data_type # in basic implementation, there is no alternative.
-    end
-
-    # check whether a given object exists.  this will work for all consts but shhhhhhhhh
-    def self.message_class_exists?(class_identifier)
-      Object::const_get(class_identifier)
-      return true
-    rescue ::NameError
-      return false
-    end
-
-    # shortcut for the full name to a message class
-    def self.message_class_name(data_type)
-      "NMEAPlus::Message::#{self.parent_module}::#{data_type}"
-    end
-
-    # use the actual type if we have it, else try an alternate (and let it fail there)
-    def self.best_match_for_data_type(data_type)
-      return data_type if self.message_class_exists?(self.message_class_name(data_type))
-      self.alternate_data_type(data_type)
-    end
-
-    # get a message class through reflection
-    def self.dynamically_get_message_object(class_identifier)
-      Object::const_get(class_identifier).new
-    rescue ::NameError => e
-      raise ::NameError, "Couldn't instantiate a #{class_identifier} object: #{e}"
-    end
-
-    # Choose what class to create, and create it based on the first of the (unsplitted) fields
-    #
-    def self.create(message_prefix, fields, checksum)
-      # get the data type and adjust it if necessary (e.g. support for NMEA standard sentences like __AAM)
-      data_type = fields.split(',', 2)[0].upcase  # assumed to be 'GPGGA', etc
-      interpreted_type = self.best_match_for_data_type(data_type)
-      class_name = self.message_class_name(interpreted_type)
-
-      # create message and make sure it's the right type
-      message = self.dynamically_get_message_object(class_name)
-      unless message.is_a? NMEAPlus::Message::Base
-        fail ArgumentError, "Undefined message type #{data_type} (classname #{class_name})"
-      end
-
-      # assign its data and return it
-      message.checksum = checksum
-      message.payload = fields
-      message.prefix = message_prefix
-      message.interpreted_data_type = interpreted_type
-      message
-    end
-
-  end
-
-end