intel_hex 0.5.4 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5381c2e993a9780fae3696528452bdae7b18060816785d296bd67be92096a65c
-  data.tar.gz: b8c0e7c5b88c78eaeef8a0844a9e7b76d84731f2411aed1a367c9bc41087fda0
+  metadata.gz: 83a3051dc1f9299c66c10ad6923c8289253290f04fd306e424de9d4a07abb3f6
+  data.tar.gz: 271722ed6d1d13d773d37ba0bf13cb1b992a3d61419ac7f39fc5e5b3c779392b
 SHA512:
-  metadata.gz: 861c2a89ca8bcbd03e883835ab5d4343ab7e6e210e4338388fd26f21c4f50f7ed0a213b8c13f1c69fc10ad6f512d6a0e9dedd874337cedf2afdd4167d9bc12a5
-  data.tar.gz: 194a5fd15404d29af5379e4d201761967f173359dfeb3d152df21d9d042b968ad10d6b42af61c61958eec056490f7e0b9227ac614c402d563ea9f2822f5f7e91
+  metadata.gz: 6f5fb271d154af4ec43772b3c26c4250e3d6066521e58134fffd73dd138bb741d528f98a341fbd8bae1f3803ede52d21c8db86f0f0a8998177f2678fa05afaf8
+  data.tar.gz: 45020b875360c1a2f92955aa835c440d3049a13d2a291a9520681b294c7ffda203628a9b07685009734290bf6264e227c91c2dd7056f3a49ddd377acbeb79af1

data/README.md

@@ -1,5 +1,6 @@
 # An Intel hex file parser, for Ruby
 
-See the [Wikipedia page on Intel HEX](https://en.wikipedia.org/wiki/Intel_HEX).
+[![rspec test status](https://github.com/jeremycole/intel_hex/actions/workflows/rspec.yml/badge.svg)](https://github.com/jeremycole/intel_hex/actions/workflows/rspec.yml)
+[![rubocop style check status](https://github.com/jeremycole/intel_hex/actions/workflows/rubocop.yml/badge.svg)](https://github.com/jeremycole/intel_hex/actions/workflows/rubocop.yml)
 
-[![Build Status](https://travis-ci.org/jeremycole/intel_hex.svg?branch=master)](https://travis-ci.org/jeremycole/intel_hex)
+See the [Wikipedia page on Intel HEX](https://en.wikipedia.org/wiki/Intel_HEX).

data/bin/intel_hex_reader

@@ -1,36 +1,37 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'optparse'
-require 'intel_hex'
-require 'pp'
+require "optparse"
+require "intel_hex"
 
 @options = {
   file: nil,
 }
 
 OptionParser.new do |opts|
-  opts.on('--help', 'Print this help.') do
+  opts.on("--help", "Print this help.") do
     puts
     puts opts
     puts
     exit
   end
-  opts.on('-f', '--filename=FILE', 'Load the specified file.') do |o|
+  opts.on("-f", "--filename=FILE", "Load the specified file.") do |o|
     @options[:file] = o
   end
 end.parse!
 
-raise 'No file specified' unless @options[:file]
+raise "No file specified" unless @options[:file]
 
 intel_hex_file = IntelHex::FileReader.new(@options[:file])
 
 intel_hex_file.each_record do |record|
-  puts 'Record type=%-4s offset=%-4d length=%-4d checksum=%-4d %s' % [
+  puts format(
+    "Record type=%-4s offset=%-4d length=%-4d checksum=%-4d %s%s",
     record.type,
     record.offset,
     record.length,
     record.checksum,
-    record.value_s,
-  ]
+    record.value ? "#{record.type}=" : "",
+    record.value_s
+  )
 end

data/lib/intel_hex/file_reader.rb

@@ -6,16 +6,12 @@ module IntelHex
       @filename = filename
       @address_base = 0
       @address_mask = 0xffff
-      @esa = 0
-      @ssa = 0
-      @ela = 0
-      @sla = 0
     end
 
     def each_record
-      return to_enum(:each_record) unless block_given?
+      return enum_for(:each_record) unless block_given?
 
-      file = File.open(@filename, 'r')
+      file = File.open(@filename, "r")
 
       begin
         file.each_line do |line|
@@ -29,22 +25,20 @@ module IntelHex
     end
 
     def each_byte_with_address
-      return to_enum(:each_byte_with_address) unless block_given?
+      return enum_for(:each_byte_with_address) unless block_given?
 
       each_record do |record|
         case record.type
         when :data
           record.each_byte_with_address do |byte, offset|
-            yield byte, (@address_base + offset) & @address_mask
+            yield byte, (@address_base + (offset & 0xffff)) & @address_mask
           end
         when :esa
-          @esa = record.esa
-          @address_base = @esa << 4   # bits 4..19 of address
-          @address_mask = 0xfffff     # 20 bit address size
+          @address_base = record.value << 4   # bits 4..19 of address
+          @address_mask = 0xfffff             # 20 bit address size
         when :ela
-          @ela = record.ela
-          @address_base = @ela << 16  # bits 16..31 of address
-          @address_mask = 0xffffffff  # 32 bit address size
+          @address_base = record.value << 16  # bits 16..31 of address
+          @address_mask = 0xffffffff          # 32 bit address size
         end
       end
 

data/lib/intel_hex/record/data.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module IntelHex
+  class Record
+    class Data < Record
+      def self.type_id
+        0
+      end
+
+      def self.type_name
+        :data
+      end
+
+      def self.type_data_length
+        (1..255)
+      end
+
+      def value
+        data
+      end
+
+      def value_s
+        data_string = data.map { |b| format("%02x", b) }.join(" ")
+
+        "[#{data_string}]"
+      end
+    end
+
+    def self.data(data = [])
+      record = Data.new
+      record.data = data
+      record
+    end
+
+    register_type(Data)
+  end
+end

data/lib/intel_hex/record/ela.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "intel_hex/record/value_record_uint16"
+
+module IntelHex
+  class Record
+    class Ela < ValueRecordUint16
+      def self.type_id
+        4
+      end
+
+      def self.type_name
+        :ela
+      end
+    end
+
+    def self.ela(value = nil)
+      record = Ela.new
+      record.value = value if value
+      record
+    end
+
+    register_type(Ela)
+  end
+end

data/lib/intel_hex/record/eof.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module IntelHex
+  class Record
+    class Eof < Record
+      def self.type_id
+        1
+      end
+
+      def self.type_name
+        :eof
+      end
+
+      def self.type_data_length
+        0
+      end
+    end
+
+    def self.eof
+      Eof.new
+    end
+
+    register_type(Eof)
+  end
+end

data/lib/intel_hex/record/esa.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "intel_hex/record/value_record_uint16"
+
+module IntelHex
+  class Record
+    class Esa < ValueRecordUint16
+      def self.type_id
+        2
+      end
+
+      def self.type_name
+        :esa
+      end
+    end
+
+    def self.esa(value = nil)
+      record = Esa.new
+      record.value = value if value
+      record
+    end
+
+    register_type(Esa)
+  end
+end

data/lib/intel_hex/record/sla.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "intel_hex/record/value_record_uint32"
+
+module IntelHex
+  class Record
+    class Sla < ValueRecordUint32
+      def self.type_id
+        5
+      end
+
+      def self.type_name
+        :sla
+      end
+    end
+
+    def self.sla(value = nil)
+      record = Sla.new
+      record.value = value if value
+      record
+    end
+
+    register_type(Sla)
+  end
+end

data/lib/intel_hex/record/ssa.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "intel_hex/record/value_record_uint32"
+
+module IntelHex
+  class Record
+    class Ssa < ValueRecordUint32
+      def self.type_id
+        3
+      end
+
+      def self.type_name
+        :ssa
+      end
+    end
+
+    def self.ssa(value = nil)
+      record = Ssa.new
+      record.value = value if value
+      record
+    end
+
+    register_type(Ssa)
+  end
+end

data/lib/intel_hex/record/value_record_uint16.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module IntelHex
+  class Record
+    class ValueRecordUint16 < Record
+      def self.type_data_length
+        2
+      end
+
+      # Retrieve the 16-bit unsigned integer value from the record.
+      def value
+        (data[0] << 8) | data[1]
+      end
+
+      # Store a 32-bit unsigned integer value in the record.
+      def value=(value)
+        data[0..1] = [
+          (value & 0xff00) >> 8,
+          value & 0x00ff,
+        ]
+        @length = data.size
+        @checksum = recalculate_checksum
+      end
+    end
+  end
+end

data/lib/intel_hex/record/value_record_uint32.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module IntelHex
+  class Record
+    class ValueRecordUint32 < Record
+      def self.type_data_length
+        4
+      end
+
+      # Retrieve the 32-bit unsigned integer value from the record.
+      def value
+        (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3]
+      end
+
+      # Store a 32-bit unsigned integer value in the record.
+      def value=(value)
+        data[0..3] = [
+          (value & 0xff000000) >> 24,
+          (value & 0x00ff0000) >> 16,
+          (value & 0x0000ff00) >> 8,
+          value & 0x000000ff,
+        ]
+        @length = data.size
+        @checksum = recalculate_checksum
+      end
+    end
+  end
+end

data/lib/intel_hex/record.rb

@@ -4,90 +4,74 @@ module IntelHex
   class MisformattedFileError < RuntimeError; end
 
   class ValidationError < StandardError; end
+
   class InvalidTypeError < ValidationError; end
+
   class InvalidLengthError < ValidationError; end
+
   class InvalidOffsetError < ValidationError; end
+
   class InvalidDataError < ValidationError; end
+
   class InvalidChecksumError < ValidationError; end
 
   class Record
-    TYPES = %i[
-      data
-      eof
-      esa
-      ssa
-      ela
-      sla
-    ].freeze
+    class << self
+      def register_type(type)
+        @type_by_id ||= {}
+        @type_by_name ||= {}
 
-    TYPE_MAP = TYPES.each_with_index.each_with_object({}) { |(k, i), h| h[k] = i }
+        raise "Type name #{type.type_name} is not a symbol" unless type.type_name.is_a?(Symbol)
+        raise "Type name #{type.type_name} redefined" if @type_by_name.include?(type.type_name)
+        raise "Type id #{type.type_id} redefined" if @type_by_id.include?(type.type_id)
 
-    TYPE_DATA_LENGTH = {
-      data: (1..255),
-      eof: 0,
-      esa: 2,
-      ssa: 4,
-      ela: 2,
-      sla: 4,
-    }.freeze
+        @type_by_id[type.type_id] = @type_by_name[type.type_name] = type
+      end
 
-    def self.parse(line)
-      raise MisformattedFileError, 'Expected \':\' at start of line' unless line[0] == ':'
-      raise MisformattedFileError, 'Line length incorrect' unless line.size >= (1 + 2 + 4 + 2)
+      attr_reader :type_by_id, :type_by_name
 
-      length = line[1..2].to_i(16)
-      data_end = (9 + length * 2)
+      def type_id
+        raise NotImplementedError
+      end
 
-      offset = line[3..6].to_i(16)
-      type = TYPES[line[7..8].to_i(16)]
-      data = line[9...data_end].split('').each_slice(2).map { |a| a.join.to_i(16) }
-      checksum = line[data_end..(data_end + 2)].to_i(16)
+      def type_name
+        raise NotImplementedError
+      end
 
-      Record.new(type, length, offset, data, checksum, line: line, validate: true)
-    end
+      def type_data_length
+        raise NotImplementedError
+      end
 
-    def self.data(data)
-      record = Record.new(:data)
-      record.data = data
-      record
-    end
+      def parse(line)
+        raise MisformattedFileError, "Expected ':' at start of line" unless line[0] == ":"
+        raise MisformattedFileError, "Line length incorrect" unless line.size >= (1 + 2 + 4 + 2)
 
-    def self.eof
-      Record.new(:eof)
-    end
+        length = line[1..2].to_i(16)
+        data_end = (9 + (length * 2))
 
-    def self.type_with_value(type, value)
-      record = Record.new(type)
-      record.send((type.to_s + '=').to_sym, value)
-      record
-    end
+        offset = line[3..6].to_i(16)
+        type_id = line[7..8].to_i(16)
+        data = line[9...data_end].chars.each_slice(2).map { |a| a.join.to_i(16) }
+        checksum = line[data_end..(data_end + 2)].to_i(16)
 
-    def self.esa(value)
-      type_with_value(:esa, value)
-    end
+        raise InvalidTypeError, "Unknown type #{type_id}" unless type_by_id.include?(type_id)
 
-    def self.ssa(value)
-      type_with_value(:ssa, value)
-    end
+        type = type_by_id[type_id]
+        type.new(length, offset, data, checksum, line: line, validate: true)
+      end
 
-    def self.ela(value)
-      type_with_value(:ela, value)
-    end
+      def inherited(subclass)
+        super
 
-    def self.sla(value)
-      type_with_value(:sla, value)
+        subclass.instance_eval { public_class_method :new }
+      end
     end
 
-    attr_reader :length
-    attr_reader :offset
-    attr_reader :type
-    attr_reader :data
-    attr_reader :checksum
-    attr_reader :line
+    private_class_method :new
+
+    attr_reader :length, :offset, :data, :checksum, :line
 
-    # rubocop:disable Metrics/ParameterLists
-    def initialize(type, length = 0, offset = 0, data = [], checksum = nil, line: nil, validate: false)
-      @type = type
+    def initialize(length = 0, offset = 0, data = [], checksum = nil, line: nil, validate: false)
       @length = length
       @offset = offset
       @data = data
@@ -97,36 +81,67 @@ module IntelHex
 
       self.validate if validate
     end
-    # rubocop:enable Metrics/ParameterLists
 
-    def data_s
-      '[' + data.map { |b| '%02x' % b }.join(' ') + ']'
+    def type_id
+      self.class.type_id
     end
 
-    def value_s
-      return '' if type == :eof
+    def type_name
+      self.class.type_name
+    end
+
+    alias type type_name
+
+    def type_data_length
+      self.class.type_data_length
+    end
+
+    def data=(value)
+      raise InvalidDataError, "Incorrect data type" unless value.is_a?(Array)
+      raise InvalidLengthError, "Data length #{value.size} too large" unless value.size <= 255
+
+      @data = value
+      @length = data.size
+      @checksum = recalculate_checksum
+    end
 
-      "#{type}=#{type == :data ? data_s : send(type)}"
+    def value
+      nil
+    end
+
+    def value_s
+      value.to_s
     end
 
     def to_s
-      "#<#{self.class.name} type=#{type} offset=#{offset} length=#{length} #{value_s}>"
+      type_value = value ? "#{type}=#{value_s}" : ""
+      "#<#{self.class.name} type=#{type_name} offset=#{offset} length=#{length} #{type_value}>"
+    end
+
+    def to_h
+      {
+        type: type,
+        offset: offset,
+        length: length,
+        checksum: checksum,
+      }.merge({ type => value })
     end
 
     def to_ascii
-      ':%02X%04X%02X%s%02X' % [
+      format(
+        ":%02X%04X%02X%s%02X",
         length,
         offset,
-        TYPE_MAP[type],
-        data.map { |b| '%02X' % b }.join,
-        checksum,
-      ]
+        type_id,
+        data.map { |b| format("%02X", b) }.join,
+        checksum
+      )
     end
 
     def calculate_checksum
       return @calculated_checksum if @calculated_checksum
 
-      sum = length + ((offset & 0xff00) >> 8) + (offset & 0x00ff) + TYPE_MAP[type]
+      sum = length + ((offset & 0xff00) >> 8) + (offset & 0x00ff) + type_id
       sum += data.sum
 
       @calculated_checksum = (((sum & 0xff) ^ 0xff) + 1) & 0xff
@@ -145,35 +160,28 @@ module IntelHex
     end
 
     def validate
-      validate_type
       validate_length
       validate_offset
       validate_data
       validate_checksum
     end
 
-    def validate_type
-      return if TYPE_MAP.include?(type)
-
-      raise InvalidTypeError, "Type #{type} is invalid"
-    end
-
     def validate_offset
       raise InvalidOffsetError, "Offset #{offset} is negative" unless offset >= 0
       raise InvalidOffsetError, "Offset #{offset} is too large" unless offset < 2**16
     end
 
     def validate_length
-      valid_length = TYPE_DATA_LENGTH[type]
-
-      case valid_length
+      case type_data_length
       when Integer
-        return if length == valid_length
+        return if length == type_data_length
       when Range
-        return if valid_length.include?(length)
+        return if type_data_length.include?(length)
+      else
+        raise InvalidTypeError, "Length for type #{type} is unhandled by validation"
       end
 
-      raise InvalidLengthError, "Length for type #{type} must be #{valid_length}; #{length} given"
+      raise InvalidLengthError, "Length for type #{type} must be #{type_data_length}; #{length} given"
     end
 
     def validate_data
@@ -189,7 +197,7 @@ module IntelHex
     end
 
     def each_byte_with_address
-      return Enumerator.new(self, :each_byte_with_address) unless block_given?
+      return enum_for(:each_byte_with_address) unless block_given?
 
       data.each_with_index do |byte, i|
         yield byte, offset + i
@@ -197,52 +205,12 @@ module IntelHex
 
       nil
     end
-
-    def data=(value)
-      raise 'Incorrect data type' unless value.is_a?(Array)
-      raise InvalidLengthError, "Data length #{value.size} too large" unless value.size <= 255
-
-      @data = value
-      @length = data.size
-      @checksum = recalculate_checksum
-    end
-
-    def data_to_uint16(offset = 0)
-      (data[offset + 0] << 8) | data[offset + 1]
-    end
-
-    def uint16_to_data(value, offset = 0)
-      data[(offset...(offset + 2))] = [
-        (value & 0xff00) >> 8,
-        value & 0x00ff,
-      ]
-      @length = data.size
-      @checksum = recalculate_checksum
-    end
-
-    def data_to_uint32(offset = 0)
-      (data[offset + 0] << 24) | (data[offset + 1] << 16) | (data[offset + 2] << 8) | data[offset + 3]
-    end
-
-    def uint32_to_data(value, offset = 0)
-      data[(offset...(offset + 4))] = [
-        (value & 0xff000000) >> 24,
-        (value & 0x00ff0000) >> 16,
-        (value & 0x0000ff00) >> 8,
-        value & 0x000000ff,
-      ]
-      @length = data.size
-      @checksum = recalculate_checksum
-    end
-
-    alias esa data_to_uint16
-    alias ssa data_to_uint32
-    alias ela data_to_uint16
-    alias sla data_to_uint32
-
-    alias esa= uint16_to_data
-    alias ssa= uint32_to_data
-    alias ela= uint16_to_data
-    alias sla= uint32_to_data
   end
 end
+
+require "intel_hex/record/data"
+require "intel_hex/record/eof"
+require "intel_hex/record/esa"
+require "intel_hex/record/ssa"
+require "intel_hex/record/ela"
+require "intel_hex/record/sla"

data/lib/intel_hex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module IntelHex
-  VERSION = '0.5.4'
+  VERSION = "0.6.0"
 end

data/lib/intel_hex.rb

@@ -3,6 +3,6 @@
 module IntelHex
 end
 
-require 'intel_hex/version'
-require 'intel_hex/record'
-require 'intel_hex/file_reader'
+require "intel_hex/version"
+require "intel_hex/record"
+require "intel_hex/file_reader"

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: intel_hex
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.6.0
 platform: ruby
 authors:
 - Jeremy Cole
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-15 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+date: 2024-11-01 00:00:00.000000000 Z
+dependencies: []
 description: An Intel hex file parser for (e.g. AVR) working with firmware files
 email: jeremy@jcole.us
 executables:
@@ -37,12 +23,21 @@ files:
 - lib/intel_hex.rb
 - lib/intel_hex/file_reader.rb
 - lib/intel_hex/record.rb
+- lib/intel_hex/record/data.rb
+- lib/intel_hex/record/ela.rb
+- lib/intel_hex/record/eof.rb
+- lib/intel_hex/record/esa.rb
+- lib/intel_hex/record/sla.rb
+- lib/intel_hex/record/ssa.rb
+- lib/intel_hex/record/value_record_uint16.rb
+- lib/intel_hex/record/value_record_uint32.rb
 - lib/intel_hex/version.rb
 homepage: https://github.com/jeremycole/intel_hex
 licenses:
 - BSD-3-Clause
-metadata: {}
-post_install_message: 
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -50,15 +45,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.0'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.5.16
+signing_key:
 specification_version: 4
 summary: Parser for Intel hex files
 test_files: []