data_inspect 0.0.1 → 0.0.3

data/bin/data_inspect

@@ -1,5 +1,212 @@
 #!/usr/bin/env ruby
 
 require 'data_inspect'
+require 'awesome_print'
+
+
+
+
+
+def main
+
+  options = ARGV
+  filename = options.first
+  options = get_options
+
+  if options[:verbose]
+    puts "Version #{DataInspect.version}"
+    ap options
+    puts "\n\n"
+  end
+
+
+
+
+
+  
+  DataInspect.readfile(filename) do |reader|
+
+
+    # Seek the reader.
+    if options[:offset] > 0
+      reader.seek options[:offset]
+    end
+
+    offset = options[:offset]
+
+    counter = 0
+
+    care_about_limit = options[:limit] >= 0
+    
+    values_to_display = {}
+
+
+
+    while (!reader.atEOS?) && !(care_about_limit && (counter >= options[:limit]))
+      
+      result = next_value_and_size(reader, options)
+      value = result[0]
+
+      # puts "#{offset}: #{value}"
+      values_to_display[offset] = value
+
+      offset  += result[1] 
+      counter += 1
+    end
+
+    # Technically incorrect, as offset is 1 word too far in advance. But this oversight is acceptable.
+    max_length_offset = Math.log10(offset).to_i + 1
+
+    # Display the values
+    values_to_display.each do |offset, value|
+      display_offset = pad_with_spaces(offset.to_s, max_length_offset + 1)
+      puts "#{display_offset}: #{value}"
+    end
+
+
+  end
+
+
+
+
+end
+
+# Returns an array of size 2,
+# first element is the returned value
+# second element is the size
+# The value is a string or object that converts to a string, to display.
+def next_value_and_size(reader, options)
+
+
+  size = options[:size]
+
+  # data types:
+  #   unsinged_int, singed_int, float, double
+  #   ascii (coming soon), utf8 (coming soon)
+
+  case options[:data_type]
+  when :unsigned_int
+    value = reader.next_unsigned_int(size, options[:byte_order])
+    value = display_in_base(value, options[:unsigned_int_display_base], size)
+  when :signed_int
+    value = reader.next_signed_int(size, options[:byte_order])
+  when :float
+    value = reader.next_ieee_single_precision_float(options[:byte_order])
+    size = 4
+  when :double
+    value = reader.next_ieee_double_precision_float(options[:byte_order])
+    size = 8
+  end
+  
+  return [value, size]
+
+end
+
+
+
+def get_options
+
+  options = {}
+
+  # index 0 is the filename. 
+  arg_options = ARGV.slice(1, ARGV.size)
+
+  boolean_flags = ['h', 'b', 'v']
+
+  # Populate 'flat' options hash.
+  flat_options = {}
+
+  while (arg_options.size > 0)
+
+    flag_string = consume_array_element(arg_options)
+    flag = flag_string[1,flag_string.size]
+
+    if boolean_flags.include? flag
+      flat_options[flag] = true
+    else
+      value = consume_array_element(arg_options)
+      flat_options[flag] = value
+    end
+
+  end
+
+
+  # Expand 'flat' options to more useful hash.
+  
+  # :unsigned_int_display_base
+
+  options[:unsigned_int_display_base] = 10
+
+  if flat_options['h']
+    options[:unsigned_int_display_base] = 16
+  end
+  
+  if flat_options['b']
+    options[:unsigned_int_display_base] = 2
+  end
+
+  # :offset
+  options[:offset] = flat_options['o'] || '0'
+  options[:offset] = options[:offset].to_i
+
+  # :limit
+  options[:limit] = flat_options['l'] || '-1'
+  options[:limit] = options[:limit].to_i
+
+  # :size
+  options[:size] = flat_options['s'] || '1'
+  options[:size] = options[:size].to_i
+
+  # :byte_order
+  options[:byte_order] = flat_options['bo'] || 'not_applicable'
+  options[:byte_order] = options[:byte_order].to_sym  # need this to be in symbol form.
+
+  # :data_type
+  options[:data_type] = flat_options['f'] || 'unsigned_int'
+  options[:data_type] = options[:data_type].to_sym
+
+  # :verbose
+  options[:verbose] = flat_options['v']
+
+  return options
+
+end
+
+
+# Requires the array must have at least one element.
+def consume_array_element(array)
+  array.slice!(0, 1)[0]
+end
+
+# If base is a power of 2, will pad with 0 to fill up to
+# size in bytes
+def display_in_base(value, base, size)
+  str = value.to_s(base)
+  if Math.log2(base) % 1 == 0.0   # If base is power of 2.
+    expected_bits = size * 8
+    coverage_of_digit = Math.log2(base)
+    expected_digits = expected_bits / coverage_of_digit
+    str = pad_with_zeros(str, expected_digits)
+  end
+  str
+end
+
+
+
+def pad_with_zeros(str, max_len)
+  pad_with_character(str, '0', max_len)
+end
+
+def pad_with_spaces(str, max_len)
+  pad_with_character(str, ' ', max_len)
+end
+
+def pad_with_character(str, char, max_len)
+  difference = max_len - str.size
+  char * difference + str
+end
+
+main
+
+
 
-puts DataInspect.hi

data/lib/data_inspect.rb

@@ -1,9 +1,134 @@
 
 class DataInspect
-  def self.hi
-    puts "Hi from DataInspect!!"
-    return 512
+
+  def self.version
+    '0.0.3'
+  end
+
+
+  def self.readfile(filename)
+    reader = Reader.new(filename)
+    yield reader
   end
+
 end
 
 
+class Reader
+
+  @@unpack_formats = {
+    unsigned_int: {
+      1 => { not_applicable: 'C' },
+      2 => { big_endian: 'n', little_endian: 'v' },
+      4 => { big_endian: 'N', little_endian: 'V' }
+    },
+
+    signed_int: {
+      1 => { not_applicable: 'c' }
+    },
+
+    ieee_single_precision_float: {
+      4 => { big_endian: 'g', little_endian: 'e' }
+    },
+
+    ieee_double_precision_float: {
+      8 => { big_endian: 'G', little_endian: 'E' }
+    }
+
+  }
+
+  def initialize(filename)
+    @file = File.open(filename, 'rb')
+  end
+
+  def each_byte
+    offset = 0
+    @file.each_byte do |byte|
+      yield byte, offset
+      offset += 1
+    end
+  end
+
+  # optional parameter size is the number of bytes to read.
+  # returns a string, representing the binary data.
+  def next_byte(size=1)
+    @file.read(size)
+  end
+
+  def next_unsigned_int(size=1, byte_order=:not_applicable)
+    unpack_format = format(:unsigned_int, size, byte_order)
+    unpack(size, unpack_format)
+  end
+
+  # Ruby doesn't do this for us automatically so we
+  # have to add our own code (UnsignedToSignedInteger class).
+  def next_signed_int(size, byte_order)
+    unsigned_value = next_unsigned_int(size, byte_order)
+    UnsignedToSignedInteger.toSignedInteger(unsigned_value, size)
+  end
+ 
+  # Next IEEE single-precision floating point number
+  # (4 bytes)
+  def next_ieee_single_precision_float(byte_order)
+    size = 4
+    unpack_format = format(:ieee_single_precision_float, size, byte_order)
+    unpack(size, unpack_format)
+  end
+
+
+  # Next IEEE double-precision floating point number
+  # (8 bytes)
+  def next_ieee_double_precision_float(byte_order)
+    size = 8
+    unpack_format = format(:ieee_double_precision_float, size, byte_order)
+    unpack(size, unpack_format)
+  end
+
+  # If the file is at the end of stream.
+  def atEOS?
+    @file.eof?
+  end
+
+  # Seek to a given offset in the file.
+  def seek(offset)
+    @file.seek(offset)
+  end
+
+  private
+
+  # returns the String.unpack format string given the 
+  #   parameter details (data type, size, and byte order).
+  # byte_order is not required when size (bytes) is 1.
+  # size defaults to 1.
+  def format(type, size=1, byte_order=:not_applicable)
+    @@unpack_formats[type][size][byte_order]
+  end
+
+  # Consumes 'size' bytes from the file,
+  # uses String.unpack() to interpret that data,
+  # using the given unpack format string.
+  def unpack(size, unpack_format)
+    @file.read(size).unpack(unpack_format)[0]
+  end
+
+end
+
+class UnsignedToSignedInteger
+
+  # Size is in bytes, and should be 1, 2 or 4.
+  def self.toSignedInteger(unsigned_value, size)
+    subtrahend = 2 ** (size * 8)
+
+    puts "subtrahend is #{subtrahend}."
+
+    max_value = 2 ** (size * 8 - 1) - 1
+    puts "max value is #{max_value}"
+
+    result = unsigned_value
+    result -= subtrahend if (unsigned_value > max_value)
+
+    return result
+  end
+
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: data_inspect
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors: