hexdump 0.3.0 → 1.0.0

data/lib/hexdump/numeric/decimal.rb

@@ -0,0 +1,56 @@
+require 'hexdump/format_string'
+
+module Hexdump
+  module Numeric
+    #
+    # @api private
+    #
+    # @since 1.0.0
+    #
+    class Decimal < FormatString
+
+      INT_SIZE_TO_WIDTH = {
+        1 => 3,  # 0xff.to_s(10).length
+        2 => 5,  # 0xffff.to_s(10).length
+        4 => 10, # 0xffffffff.to_s(10).length
+        8 => 20  # 0xffffffffffffffff.to_s(10).length
+      }
+
+      FLOAT_SIZE_TO_WIDTH = {
+        4 => 15,
+        8 => 24
+      }
+
+      # @return [Integer]
+      attr_reader :width
+
+      #
+      # Initializes the decimal format.
+      #
+      # @param [Type:Int, Type::UInt, Type::Float] type
+      #
+      def initialize(type)
+        widths = case type
+                 when Type::Float then FLOAT_SIZE_TO_WIDTH
+                 else                  INT_SIZE_TO_WIDTH
+                 end
+
+        @width = widths.fetch(type.size) do
+          raise(NotImplementedError,"type #{type} with unsupported size #{type.size}")
+        end
+
+        case type
+        when Type::Float
+          super("% #{@width}g"); @width += 1
+        else
+          if type.signed?
+            super("% #{@width}d"); @width += 1
+          else
+            super("%#{@width}d")
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/hexdump/numeric/exceptions.rb

@@ -0,0 +1,11 @@
+module Hexdump
+  module Numeric
+    #
+    # @api private
+    #
+    # @since 1.0.0
+    #
+    class IncompatibleTypeError < TypeError
+    end
+  end
+end

data/lib/hexdump/numeric/hexadecimal.rb

@@ -0,0 +1,59 @@
+require 'hexdump/format_string'
+
+module Hexdump
+  module Numeric
+    #
+    # @api private
+    #
+    # @since 1.0.0
+    #
+    class Hexadecimal < FormatString
+
+      INT_SIZE_TO_WIDTH = {
+        1 => 2, # 0xff.to_s(16).length
+        2 => 4, # 0xffff.to_s(16).length
+        4 => 8, # 0xffffffff.to_s(16).length
+        8 => 16 # 0xffffffffffffffff.to_s(16).length
+      }
+
+      FLOAT_WIDTH = 20
+
+      # @return [Integer]
+      attr_reader :width
+
+      #
+      # Initializes the hexadecimal format.
+      #
+      # @param [Type::Int, Type::UInt, Type::Float] type
+      #
+      def initialize(type)
+        case type
+        when Type::Float
+          if RUBY_ENGINE == 'jruby'
+            # XXX: https://github.com/jruby/jruby/issues/5122
+            begin
+              "%a" % 1.0
+            rescue ArgumentError
+              raise(NotImplementedError,"jruby #{RUBY_ENGINE_VERSION} does not support the \"%a\" format string")
+            end
+          end
+
+          # NOTE: jruby does not currently support the %a format string
+          @width = FLOAT_WIDTH
+          super("% #{@width}a"); @width += 1
+        else
+          @width = INT_SIZE_TO_WIDTH.fetch(type.size) do
+            raise(NotImplementedError,"type #{type} with unsupported size #{type.size}")
+          end
+
+          if type.signed?
+            super("% .#{@width}x"); @width += 1
+          else
+            super("%.#{@width}x")
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/hexdump/numeric/octal.rb

@@ -0,0 +1,55 @@
+require 'hexdump/numeric/exceptions'
+require 'hexdump/format_string'
+
+module Hexdump
+  module Numeric
+    #
+    # @api private
+    #
+    # @since 1.0.0
+    #
+    class Octal < FormatString
+
+      SIZE_TO_WIDTH = {
+        1 => 3,  # 0xff.to_s(7).length
+        2 => 6,  # 0xffff.to_s(7).length
+        4 => 11, # 0xffffffff.to_s(7).length
+        8 => 22  # 0xffffffffffffffff.to_s(7).length
+      }
+
+      # @return [Integer]
+      attr_reader :width
+
+      #
+      # Initializes the octal format.
+      #
+      # @param [Type::Int, Type::UInt] type
+      #
+      # @raise [NotImplementedError]
+      #
+      # @raise [IncompatibleTypeError]
+      #
+      # @raise [TypeError]
+      #
+      def initialize(type)
+        case type
+        when Type::Int, Type::UInt
+          @width = SIZE_TO_WIDTH.fetch(type.size) do
+            raise(NotImplementedError,"type #{type} with unsupported size #{type.size}")
+          end
+
+          if type.signed?
+            super("% .#{@width}o"); @width += 1
+          else
+            super("%.#{@width}o")
+          end
+        when Type::Float
+          raise(IncompatibleTypeError,"cannot format floating-point numbers in octal")
+        else
+          raise(TypeError,"unsupported type: #{type.inspect}")
+        end
+      end
+
+    end
+  end
+end

data/lib/hexdump/numeric.rb

@@ -0,0 +1,5 @@
+require 'hexdump/numeric/binary'
+require 'hexdump/numeric/octal'
+require 'hexdump/numeric/decimal'
+require 'hexdump/numeric/hexadecimal'
+require 'hexdump/numeric/char_or_int'

data/lib/hexdump/reader.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+require 'hexdump/type'
+
+module Hexdump
+  #
+  # @api private
+  #
+  # @since 1.0.0
+  #
+  class Reader
+
+    # The type to decode the data as.
+    #
+    # @return [Type]
+    attr_reader :type
+
+    # Controls whether to offset N number of bytes before starting to read data.
+    #
+    # @return [Integer, nil]
+    attr_reader :offset
+
+    # Controls control many bytes to read.
+    #
+    # @return [Integer, nil]
+    attr_reader :length
+
+    #
+    # Initializes the reader.
+    #
+    # @param [Type] type
+    #   The type to decode the data as.
+    #
+    # @param [Integer, nil] offset
+    #   Controls whether to offset N number of bytes before starting to read data.
+    #
+    # @param [Integer, nil] length
+    #   Controls control many bytes to read.
+    #
+    # @param [Boolean] zero_pad
+    #   Controls whether the remaining data will be padded with zeros.
+    #
+    def initialize(type, offset: nil, length: nil, zero_pad: false)
+      @type     = type
+      @offset   = offset
+      @length   = length
+      @zero_pad = zero_pad
+    end
+
+    def zero_pad?
+      @zero_pad
+    end
+
+    #
+    # Reads each byte from the given data.
+    #
+    # @yield [byte]
+    #
+    # @yieldparam [Integer] byte
+    #
+    # @return [Enumerator]
+    #
+    # @raise [ArgumentError]
+    #
+    def each_byte(data)
+      return enum_for(__method__,data) unless block_given?
+
+      unless data.respond_to?(:each_byte)
+        raise(ArgumentError,"the given data must respond to #each_byte")
+      end
+
+      count = 0
+
+      data.each_byte do |b|
+        count += 1
+
+        # offset the first @offset number of bytes
+        if @offset.nil? || count > @offset
+          yield b
+        end
+
+        # stop reading after @length number of bytes
+        break if @length && count >= @length
+      end
+    end
+
+    #
+    # Reads each string of the same number of bytes as the {#type}'s
+    # {Type#size size}.
+    #
+    # @param [#each_byte] data
+    #
+    # @yield [slice]
+    #
+    # @yieldparam [String] slice
+    #
+    # @raise [ArgumentError]
+    #
+    def each_slice(data)
+      return enum_for(__method__,data) unless block_given?
+
+      unless data.respond_to?(:each_byte)
+        raise(ArgumentError,"the given data must respond to #each_byte")
+      end
+
+      count = 0
+
+      if @type.size == 1
+        each_byte(data) do |b|
+          yield b.chr
+        end
+      else
+        buffer = String.new("\0" * @type.size, capacity: @type.size,
+                                               encoding: Encoding::BINARY)
+        index  = 0
+
+        each_byte(data) do |b|
+          buffer[index] = b.chr(Encoding::BINARY)
+          index += 1
+
+          if index >= @type.size
+            yield buffer.dup
+            index = 0
+          end
+        end
+
+        if index > 0
+          if @zero_pad
+            # zero pad the rest of the buffer
+            (index..(@type.size - 1)).each do |i|
+              buffer[i] = "\0"
+            end
+
+            yield buffer
+          else
+            # yield the reamining partial buffer
+            yield buffer[0,index]
+          end
+        end
+      end
+    end
+
+    #
+    # @param [#each_byte] data
+    #
+    # @yield [raw, uint]
+    #
+    # @yieldparam [String] raw
+    #
+    # @yieldparam [Integer, nil] uint
+    #
+    # @return [Enumerator]
+    #
+    # @raise [ArgumentError]
+    #
+    def each_uint(data,&block)
+      return enum_for(__method__,data) unless block_given?
+
+      unless data.respond_to?(:each_byte)
+        raise(ArgumentError,"the given data must respond to #each_byte")
+      end
+
+      if @type.size == 1
+        each_byte(data) do |b|
+          yield b.chr, b
+        end
+      else
+        pack_format = case @type.size
+                      when 1
+                        'c'
+                      when 2
+                        case @type.endian
+                        when :little then 'S<'
+                        when :big    then 'S>'
+                        else
+                          raise(TypeError,"unsupported endian #{@type.endian} for #{@type.name}")
+                        end
+                      when 4
+                        case @type.endian
+                        when :little then 'L<'
+                        when :big    then 'L>'
+                        else
+                          raise(TypeError,"unsupported endian #{@type.endian} for #{@type.name}")
+                        end
+                      when 8
+                        case @type.endian
+                        when :little then 'Q<'
+                        when :big    then 'Q>'
+                        else
+                          raise(TypeError,"unsupported endian #{@type.endian} for #{@type.name}")
+                        end
+                      else
+                        raise(TypeError,"unsupported type size #{@type.size} for #{@type.name}")
+                      end
+
+        each_slice(data) do |slice|
+          yield slice, slice.unpack1(pack_format)
+        end
+      end
+    end
+
+    #
+    # @param [#each_byte] data
+    #
+    # @yield [raw, int]
+    #
+    # @yieldparam [String] raw
+    #
+    # @yieldparam [Integer, nil] int
+    #
+    # @return [Enumerator]
+    #
+    def each_int(data)
+      return enum_for(__method__,data) unless block_given?
+
+      pack_format = case @type.size
+                    when 1
+                      'c'
+                    when 2
+                      case @type.endian
+                      when :little then 's<'
+                      when :big    then 's>'
+                      else
+                        raise(TypeError,"unsupported endian #{@type.endian} for #{@type.name}")
+                      end
+                    when 4
+                      case @type.endian
+                      when :little then 'l<'
+                      when :big    then 'l>'
+                      else
+                        raise(TypeError,"unsupported endian #{@type.endian} for #{@type.name}")
+                      end
+                    when 8
+                      case @type.endian
+                      when :little then 'q<'
+                      when :big    then 'q>'
+                      else
+                        raise(TypeError,"unsupported endian #{@type.endian} for #{@type.name}")
+                      end
+                    else
+                      raise(TypeError,"unsupported type size #{@type.size} for #{@type.name}")
+                    end
+
+      each_slice(data) do |slice|
+        yield slice, slice.unpack1(pack_format)
+      end
+    end
+
+    #
+    # @param [#each_byte] data
+    #
+    # @yield [raw, float]
+    #
+    # @yieldparam [String] raw
+    #
+    # @yieldparam [Float, nil] float
+    #
+    # @return [Enumerator]
+    #
+    def each_float(data)
+      return enum_for(__method__,data) unless block_given?
+
+      pack_format = case @type.endian
+                    when :little
+                      case @type.size
+                      when 4 then 'e'
+                      when 8 then 'E'
+                      else
+                        raise(TypeError,"unsupported type size #{@type.size} for #{@type.name}")
+                      end
+                    when :big
+                      case @type.size
+                      when 4 then 'g'
+                      when 8 then 'G'
+                      else
+                        raise(TypeError,"unsupported type size #{@type.size} for #{@type.name}")
+                      end
+                    else
+                      raise(TypeError,"unsupported endian #{@type.endian} for #{@type.name}")
+                    end
+
+      each_slice(data) do |slice|
+        yield slice, slice.unpack1(pack_format)
+      end
+    end
+
+    #
+    # @param [#each_byte] data
+    #
+    # @yield [raw, value]
+    #
+    # @yieldparam [String] raw
+    #
+    # @yieldparam [Integer, Float, nil] value
+    #
+    # @return [Enumerator]
+    #
+    def each(data,&block)
+      return enum_for(__method__,data) unless block
+
+      case @type
+      when Type::UInt
+        each_uint(data,&block)
+      when Type::Float
+        each_float(data,&block)
+      when Type::Int
+        each_int(data,&block)
+      else
+        raise(TypeError,"unsupported type: #{@type.inspect}")
+      end
+    end
+
+  end
+end