hexdump 0.3.0 → 1.0.1

data/lib/hexdump/type.rb

@@ -0,0 +1,233 @@
+module Hexdump
+  #
+  # @api private
+  #
+  # @since 1.0.0
+  #
+  class Type
+
+    # The endian-ness of the type.
+    #
+    # @return [:little, :big, nil]
+    attr_reader :endian
+
+    # The size in bytes of the type.
+    #
+    # @return [1, 2, 4, 8]
+    attr_reader :size
+
+    #
+    # Initializes the type.
+    #
+    # @param [1, 2, 4, 8] size
+    #   The type's size in bytes.
+    #
+    # @param [:little, :big, nil] endian
+    #   The endianness of the type. `nil` indicates the type has no endianness.
+    #
+    # @param [Boolean] signed
+    #   Indicates whether the type is signed or unsigned.
+    #
+    # @raise [ArgumentError]
+    #   Invalid `endian:` or `size:` values.
+    #
+    def initialize(size: , endian: nil, signed: )
+      @endian = endian
+      @size   = size
+      @signed = signed
+    end
+
+    # 
+    # Whether the type is signed.
+    #
+    # @return [Boolean]
+    #
+    def signed?
+      @signed
+    end
+
+    # 
+    # Whether the type is unsigned.
+    #
+    # @return [Boolean]
+    #
+    def unsigned?
+      !@signed
+    end
+
+    # The native endian-ness.
+    NATIVE_ENDIAN = if [0x1].pack('I') == [0x1].pack('N')
+                      :big
+                    else
+                      :little
+                    end
+
+    #
+    # Represents a signed integer type.
+    #
+    class Int < self
+
+      #
+      # Initializes the int type.
+      #
+      # @param [:little, :big] endian (NATIVE_ENDIAN)
+      #   The endian-ness of the int type.
+      #
+      def initialize(endian: NATIVE_ENDIAN, **kwargs)
+        super(signed: true, endian: endian, **kwargs)
+      end
+
+    end
+
+    class Int8 < Int
+
+      #
+      # @see Int#initialize
+      #
+      def initialize(**kwargs)
+        super(size: 1, endian: nil, **kwargs)
+      end
+
+    end
+
+    class Int16 < Int
+
+      #
+      # @see Int#initialize
+      #
+      def initialize(**kwargs)
+        super(size: 2, **kwargs)
+      end
+
+    end
+
+    class Int32 < Int
+
+      #
+      # @see Int#initialize
+      #
+      def initialize(**kwargs)
+        super(size: 4, **kwargs)
+      end
+
+    end
+
+    class Int64 < Int
+
+      #
+      # @see Int#initialize
+      #
+      def initialize(**kwargs)
+        super(size: 8, **kwargs)
+      end
+
+    end
+
+    #
+    # Represents a unsigned integer type.
+    #
+    class UInt < self
+
+      #
+      # Initializes the uint type.
+      #
+      # @param [:little, :big] endian (NATIVE_ENDIAN)
+      #   The endian-ness of the uint type.
+      #
+      def initialize(endian: NATIVE_ENDIAN, **kwargs)
+        super(signed: false, endian: endian, **kwargs)
+      end
+
+    end
+
+    class UInt8 < UInt
+
+      #
+      # @see UInt#initialize
+      #
+      def initialize(**kwargs)
+        super(size: 1, endian: nil, **kwargs)
+      end
+
+    end
+
+    class UInt16 < UInt
+
+      #
+      # @see UInt#initialize
+      #
+      def initialize(**kwargs)
+        super(size: 2, **kwargs)
+      end
+
+    end
+
+    class UInt32 < UInt
+
+      #
+      # @see UInt#initialize
+      #
+      def initialize(**kwargs)
+        super(size: 4, **kwargs)
+      end
+
+    end
+
+    class UInt64 < UInt
+
+      #
+      # @see UInt#initialize
+      #
+      def initialize(**kwargs)
+        super(size: 8, **kwargs)
+      end
+
+    end
+
+    #
+    # Represents a single-byte character.
+    #
+    class Char < Int8
+    end
+
+    #
+    # Represents a single-byte unsigned character.
+    #
+    class UChar < UInt8
+    end
+
+    #
+    # Represents a floating point type.
+    #
+    class Float < self
+
+      #
+      # Initializes the float type.
+      #
+      # @param [:little, :big] endian (NATIVE_ENDIAN)
+      #   The endian-ness of the float type.
+      #
+      def initialize(endian: NATIVE_ENDIAN, **kwargs)
+        super(signed: true, endian: endian, **kwargs)
+      end
+
+    end
+
+    class Float32 < Float
+
+      def initialize(**kwargs)
+        super(size: 4, **kwargs)
+      end
+
+    end
+
+    class Float64 < Float
+
+      def initialize(**kwargs)
+        super(size: 8, **kwargs)
+      end
+
+    end
+
+  end
+end

data/lib/hexdump/types.rb

@@ -0,0 +1,108 @@
+require_relative 'type'
+
+module Hexdump
+  #
+  # @api private
+  #
+  # @since 1.0.0
+  #
+  TYPES = {
+    char:  Type::Char.new,
+    uchar: Type::UChar.new,
+
+    int8:  Type::Int8.new,
+    uint8: Type::UInt8.new,
+
+    int16:     Type::Int16.new,
+    int16_le:  Type::Int16.new(endian: :little),
+    int16_be:  Type::Int16.new(endian: :big),
+    int16_ne:  Type::Int16.new(endian: :big),
+
+    uint16:    Type::UInt16.new,
+    uint16_le: Type::UInt16.new(endian: :little),
+    uint16_be: Type::UInt16.new(endian: :big),
+    uint16_ne: Type::UInt16.new(endian: :big),
+
+    int32:     Type::Int32.new,
+    int32_le:  Type::Int32.new(endian: :little),
+    int32_be:  Type::Int32.new(endian: :big),
+    int32_ne:  Type::Int32.new(endian: :big),
+
+    uint32:    Type::UInt32.new,
+    uint32_le: Type::UInt32.new(endian: :little),
+    uint32_be: Type::UInt32.new(endian: :big),
+    uint32_ne: Type::UInt32.new(endian: :big),
+
+    int64:        Type::Int64.new,
+    int64_le:     Type::Int64.new(endian: :little),
+    int64_be:     Type::Int64.new(endian: :big),
+    int64_ne:     Type::Int64.new(endian: :big),
+
+    uint64:       Type::UInt64.new,
+    uint64_le:    Type::UInt64.new(endian: :little),
+    uint64_be:    Type::UInt64.new(endian: :big),
+    uint64_ne:    Type::UInt64.new(endian: :big),
+
+    float32:    Type::Float32.new,
+    float32_le: Type::Float32.new(endian: :little),
+    float32_be: Type::Float32.new(endian: :big),
+    float32_ne: Type::Float32.new(endian: :big),
+
+    float64:    Type::Float64.new,
+    float64_le: Type::Float64.new(endian: :little),
+    float64_be: Type::Float64.new(endian: :big),
+    float64_ne: Type::Float64.new(endian: :big),
+  }
+
+  TYPES[:byte]   = TYPES[:uint8]
+
+  TYPES[:short]    = TYPES[:int16]
+  TYPES[:short_le] = TYPES[:int16_le]
+  TYPES[:short_be] = TYPES[:int16_be]
+  TYPES[:short_ne] = TYPES[:int16_ne]
+
+  TYPES[:ushort]    = TYPES[:uint16]
+  TYPES[:ushort_le] = TYPES[:uint16_le]
+  TYPES[:ushort_be] = TYPES[:uint16_be]
+  TYPES[:ushort_ne] = TYPES[:uint16_ne]
+
+  TYPES[:int]    = TYPES[:int32]
+  TYPES[:int_le] = TYPES[:int32_le]
+  TYPES[:int_be] = TYPES[:int32_be]
+  TYPES[:int_ne] = TYPES[:int32_ne]
+
+  TYPES[:uint]    = TYPES[:uint32]
+  TYPES[:uint_le] = TYPES[:uint32_le]
+  TYPES[:uint_be] = TYPES[:uint32_be]
+  TYPES[:uint_ne] = TYPES[:uint32_ne]
+
+  TYPES[:long]    = TYPES[:int64]
+  TYPES[:long_le] = TYPES[:int64_le]
+  TYPES[:long_be] = TYPES[:int64_be]
+  TYPES[:long_ne] = TYPES[:int64_ne]
+
+  TYPES[:ulong]    = TYPES[:uint64]
+  TYPES[:ulong_le] = TYPES[:uint64_le]
+  TYPES[:ulong_be] = TYPES[:uint64_be]
+  TYPES[:ulong_ne] = TYPES[:uint64_ne]
+
+  TYPES[:long_long]    = TYPES[:int64]
+  TYPES[:long_long_le] = TYPES[:int64_le]
+  TYPES[:long_long_be] = TYPES[:int64_be]
+  TYPES[:long_long_ne] = TYPES[:int64_ne]
+
+  TYPES[:ulong_long]    = TYPES[:uint64]
+  TYPES[:ulong_long_le] = TYPES[:uint64_le]
+  TYPES[:ulong_long_be] = TYPES[:uint64_be]
+  TYPES[:ulong_long_ne] = TYPES[:uint64_ne]
+
+  TYPES[:float]    = TYPES[:float32]
+  TYPES[:float_le] = TYPES[:float32_le]
+  TYPES[:float_be] = TYPES[:float32_be]
+  TYPES[:float_ne] = TYPES[:float32_ne]
+
+  TYPES[:double]    = TYPES[:float64]
+  TYPES[:double_le] = TYPES[:float64_le]
+  TYPES[:double_be] = TYPES[:float64_be]
+  TYPES[:double_ne] = TYPES[:float64_ne]
+end

data/lib/hexdump/version.rb

@@ -1,4 +1,4 @@
 module Hexdump
   # hexdump version
-  VERSION = '0.3.0'
+  VERSION = '1.0.1'
 end

data/lib/hexdump.rb

@@ -1,3 +1,14 @@
-require 'hexdump/hexdump'
-require 'hexdump/core_ext'
-require 'hexdump/version'
+require_relative 'hexdump/module_methods'
+require_relative 'hexdump/core_ext'
+require_relative 'hexdump/version'
+
+module Hexdump
+  extend ModuleMethods
+
+  #
+  # @see hexdump
+  #
+  def self.dump(data,**kwargs)
+    hexdump(data,**kwargs)
+  end
+end

data/spec/chars_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'hexdump/chars'
+
+describe Hexdump::Chars do
+  describe "#initialize" do
+    it "must default #encoding to nil" do
+      expect(subject.encoding).to be(nil)
+    end
+
+    context "when given nil" do
+      subject { described_class.new(nil) }
+
+      it "must set #encoding to nil" do
+        expect(subject.encoding).to be(nil)
+      end
+    end
+
+    context "when given an Encoding object" do
+      let(:encoding) { Encoding::UTF_8 }
+
+      subject { described_class.new(encoding) }
+
+      it "must set #encoding to the Encoding object" do
+        expect(subject.encoding).to be(encoding)
+      end
+    end
+  end
+
+  describe "#scrub" do
+    context "when the string only contains printable ASCII characters" do
+      let(:string)   { "hello" }
+
+      it "must return the string unchanged" do
+        expect(subject.scrub(string)).to eq(string)
+      end
+    end
+
+    context "when the string contains unprintable ASCII characters" do
+      let(:ascii) { (0..255).map(&:chr).join }
+
+      it "must replace non-printable ASCII characters with a '.'" do
+        expect(subject.scrub(ascii)).to eq(ascii.gsub(/[^\x20-\x7e]/,'.'))
+      end
+    end
+
+    context "#encoding is set" do
+      let(:encoding) { Encoding::UTF_8 }
+      let(:string)   { "hello"         }
+
+      subject { described_class.new(encoding) }
+
+      it "must convert the string to the #encoding" do
+        expect((subject.scrub(string)).encoding).to eq(encoding)
+      end
+
+      context "when the string contains an invalid byte-sequence" do
+        let(:invalid_bytes) { "\x80\x81"           }
+        let(:string)        { "A#{invalid_bytes}B" }
+
+        it "must replace any invalid byte sequencnes with a '.'" do
+          expect(subject.scrub(string)).to eq("A..B")
+        end
+      end
+
+      context "when the string contains unprintable characters" do
+        let(:codepoint) { 888                     }
+        let(:char)      { codepoint.chr(encoding) }
+        let(:string)    { "A#{char}B"             }
+
+        it "must replace unprintable characters with a '.'" do
+          expect(subject.scrub(string)).to eq("A.B")
+        end
+      end
+    end
+  end
+end

data/spec/core_ext_spec.rb

@@ -2,19 +2,23 @@ require 'spec_helper'
 require 'hexdump/core_ext'
 
 describe "Hexdump core_ext" do
-  it "should include Hexdump into String" do
-    expect(String).to include(Hexdump)
+  it "should include Hexdump::Mixin into String" do
+    expect(String).to include(Hexdump::Mixin)
   end
 
-  it "should include Hexdump into StringIO" do
-    expect(StringIO).to include(Hexdump)
+  it "should include Hexdump::Mixin into StringIO" do
+    expect(StringIO).to include(Hexdump::Mixin)
   end
 
-  it "should include Hexdump into IO" do
-    expect(IO).to include(Hexdump)
+  it "should include Hexdump::Mixin into IO" do
+    expect(IO).to include(Hexdump::Mixin)
   end
 
   it "should define File.hexdump" do
     expect(File).to respond_to(:hexdump)
   end
+
+  it "should include Hexdump::ModuleMethods into ::Kernel" do
+    expect(Kernel).to include(Hexdump::ModuleMethods)
+  end
 end

data/spec/format_string_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'hexdump/format_string'
+
+describe Hexdump::FormatString do
+  let(:fmt) { "%x" }
+
+  subject { described_class.new(fmt) }
+
+  describe "#%" do
+    let(:value) { 255 }
+
+    it "must format the given value" do
+      expect(subject % value).to eq(fmt % value)
+    end
+  end
+
+  describe "#to_s" do
+    it "must return the format string" do
+      expect(subject.to_s).to eq(fmt)
+    end
+  end
+end