binary_struct 1.0.1 → 2.0.0

data/.rspec

@@ -1,2 +1,3 @@
 --color
---format progress
+--warnings
+--require spec_helper

data/README.md

@@ -1,8 +1,10 @@
 # BinaryStruct
 
+[![Gem Version](https://badge.fury.io/rb/binary_struct.png)](http://badge.fury.io/rb/binary_struct)
 [![Build Status](https://travis-ci.org/ManageIQ/binary_struct.png)](https://travis-ci.org/ManageIQ/binary_struct)
 [![Code Climate](https://codeclimate.com/github/ManageIQ/binary_struct.png)](https://codeclimate.com/github/ManageIQ/binary_struct)
 [![Coverage Status](https://coveralls.io/repos/ManageIQ/binary_struct/badge.png?branch=master)](https://coveralls.io/r/ManageIQ/binary_struct)
+[![Dependency Status](https://gemnasium.com/ManageIQ/binary_struct.png)](https://gemnasium.com/ManageIQ/binary_struct)
 
 BinaryStruct is a class for dealing with binary structured data.  It simplifies
 expressing what the binary structure looks like, with the ability to name the

data/lib/binary_struct/version.rb

@@ -1,3 +1,3 @@
 class BinaryStruct
-  VERSION = "1.0.1"
+  VERSION = "2.0.0"
 end

data/lib/binary_struct.rb

@@ -39,7 +39,10 @@ class BinaryStruct
     'Z'   => 1,   # String with trailing NULs removed
   }
 
-  STRING_FORMATS = %w{A a M m u}
+  STRING_FORMATS   = %w(A a M m u)
+  ENDIAN_FORMATS   = %w(I i L l Q q S s)
+  ENDIAN_MODIFIERS = %w(> <)
+  MODIFIERS        = ENDIAN_MODIFIERS
 
   def initialize(definition = nil)
     self.definition = definition unless definition.nil?
@@ -152,8 +155,14 @@ class BinaryStruct
     raise "definition must be an array of format/name pairs" if definition.empty? || definition.length % 2 != 0
     definition.each_slice(2) do |format, _|
       type, count = format[0, 1], format[1..-1]
+      modifier, modcount = count[0, 1], count[1..-1]
       validate_definition_entry_type(type)
-      validate_definition_entry_count(count)
+      if valid_definition_entry_modifier?(modifier)
+        validate_definition_endian_modifier(modifier, type)
+        validate_definition_entry_count(modcount)
+      else
+        validate_definition_entry_count(count)
+      end
     end
   end
 
@@ -174,14 +183,28 @@ class BinaryStruct
     raise "unsupported count: #{count}" if count < 0
   end
 
+  def self.valid_definition_entry_modifier?(modifier)
+    MODIFIERS.include? modifier
+  end
+
+  def self.validate_definition_endian_modifier(modifier, type)
+    if ENDIAN_MODIFIERS.include? modifier
+      raise "unsupported type attribute #{type} for endian modifier #{modifier}" unless ENDIAN_FORMATS.include? type
+      return true
+    end
+    false
+  end
+
   def self.get_size(definition)
     size = 0
     definition.each_slice(2) do |format, _|
-      type, count = format[0, 1], format[1..-1]
+      type, count        = format[0, 1], format[1..-1]
+      modifier, modcount = count[0, 1], count[1..-1]
+      count = modcount if valid_definition_entry_modifier?(modifier)
       count = count.empty? ? 1 : count.to_i
       size += (count * SIZES[type])
     end
-    return size
+    size
   end
 
   def self.prep_decode(definition)

data/spec/binary_struct_spec.rb

@@ -1,7 +1,3 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-
-require 'binary_struct'
-
 describe BinaryStruct do
   STRUCT_DEF = [
     'Q', :quad,
@@ -22,89 +18,90 @@ describe BinaryStruct do
   STRUCT_DEF_UNSUPPORTED_COUNT_NEG = ['a-1', nil]
   STRUCT_DEF_UNSUPPORTED_COUNT_INV = ['aX', nil]
 
-  STRUCT_ENCODED_STR  = "\000\111\222\333\444\555\666\777\000\111\222\333\000\111\0000BC"
+  STRUCT_ENCODED_STR  = "\000\111\222\333\444\555\666\777\000\111\222\333\000\111\0000BC".force_encoding("ASCII-8BIT")
   STRUCT_DECODED_HASH = {:quad=>18426034930503010560, "long"=>3683797248, :short=>18688, "bc"=>"BC", "none"=>""}
 
-  it('.new') { lambda { BinaryStruct.new }.should_not raise_error }
-  it('.new with definition') { lambda { BinaryStruct.new(STRUCT_DEF) }.should_not raise_error }
-  it('.new with definition with *') { lambda { BinaryStruct.new(STRUCT_DEF_ASTERISK) }.should_not raise_error }
+  it('.new') { expect { BinaryStruct.new }.not_to raise_error }
+  it('.new with definition') { expect { BinaryStruct.new(STRUCT_DEF) }.not_to raise_error }
+  it('.new with definition with *') { expect { BinaryStruct.new(STRUCT_DEF_ASTERISK) }.not_to raise_error }
   it '.new with another BinaryStruct' do
     s = BinaryStruct.new(STRUCT_DEF)
     s2 = BinaryStruct.new(s)
-    s2.should == s
-    s2.should_not equal(s)
+    expect(s2).to eq(s)
+    expect(s2).not_to equal(s)
   end
 
-  it('.new with unrecognized format')        { lambda { BinaryStruct.new(STRUCT_DEF_UNRECOGNIZED_FORMAT) }.should   raise_error(RuntimeError) }
-  it('.new with unsupported format')         { lambda { BinaryStruct.new(STRUCT_DEF_UNSUPPORTED_FORMAT) }.should    raise_error(RuntimeError) }
-  it('.new with unsupported negative count') { lambda { BinaryStruct.new(STRUCT_DEF_UNSUPPORTED_COUNT_NEG) }.should raise_error(RuntimeError) }
-  it('.new with unsupported invalid count')  { lambda { BinaryStruct.new(STRUCT_DEF_UNSUPPORTED_COUNT_INV) }.should raise_error(RuntimeError) }
+  it('.new with unrecognized format')        { expect { BinaryStruct.new(STRUCT_DEF_UNRECOGNIZED_FORMAT) }.to   raise_error(RuntimeError) }
+  it('.new with unsupported format')         { expect { BinaryStruct.new(STRUCT_DEF_UNSUPPORTED_FORMAT) }.to    raise_error(RuntimeError) }
+  it('.new with unsupported negative count') { expect { BinaryStruct.new(STRUCT_DEF_UNSUPPORTED_COUNT_NEG) }.to raise_error(RuntimeError) }
+  it('.new with unsupported invalid count')  { expect { BinaryStruct.new(STRUCT_DEF_UNSUPPORTED_COUNT_INV) }.to raise_error(RuntimeError) }
 
-  it('#definition=') { lambda { BinaryStruct.new.definition = STRUCT_DEF }.should_not raise_error }
-  it('#definition= with definition with *') { lambda { BinaryStruct.new.definition = STRUCT_DEF_ASTERISK }.should_not raise_error }
+  it('#definition=') { expect { BinaryStruct.new.definition = STRUCT_DEF }.not_to raise_error }
+  it('#definition= with definition with *') { expect { BinaryStruct.new.definition = STRUCT_DEF_ASTERISK }.not_to raise_error }
 
-  it('#definition= with unrecognized format')        { lambda { BinaryStruct.new.definition = STRUCT_DEF_UNRECOGNIZED_FORMAT }.should   raise_error(RuntimeError) }
-  it('#definition= with unsupported format')         { lambda { BinaryStruct.new.definition = STRUCT_DEF_UNSUPPORTED_FORMAT }.should    raise_error(RuntimeError) }
-  it('#definition= with unsupported negative count') { lambda { BinaryStruct.new.definition = STRUCT_DEF_UNSUPPORTED_COUNT_NEG }.should raise_error(RuntimeError) }
-  it('#definition= with unsupported invalid count')  { lambda { BinaryStruct.new.definition = STRUCT_DEF_UNSUPPORTED_COUNT_INV }.should raise_error(RuntimeError) }
+  it('#definition= with unrecognized format')        { expect { BinaryStruct.new.definition = STRUCT_DEF_UNRECOGNIZED_FORMAT }.to   raise_error(RuntimeError) }
+  it('#definition= with unsupported format')         { expect { BinaryStruct.new.definition = STRUCT_DEF_UNSUPPORTED_FORMAT }.to    raise_error(RuntimeError) }
+  it('#definition= with unsupported negative count') { expect { BinaryStruct.new.definition = STRUCT_DEF_UNSUPPORTED_COUNT_NEG }.to raise_error(RuntimeError) }
+  it('#definition= with unsupported invalid count')  { expect { BinaryStruct.new.definition = STRUCT_DEF_UNSUPPORTED_COUNT_INV }.to raise_error(RuntimeError) }
 
-  it('#size') { BinaryStruct.new(STRUCT_DEF).size.should == STRUCT_DEF_SIZE }
-  it('#size with definition with *') { BinaryStruct.new(STRUCT_DEF_ASTERISK).size.should == STRUCT_DEF_ASTERISK_SIZE }
+  it('#size') { expect(BinaryStruct.new(STRUCT_DEF).size).to eq(STRUCT_DEF_SIZE) }
+  it('#size with definition with *') { expect(BinaryStruct.new(STRUCT_DEF_ASTERISK).size).to eq(STRUCT_DEF_ASTERISK_SIZE) }
 
   it '#decode' do
-    BinaryStruct.new(STRUCT_DEF).decode(STRUCT_ENCODED_STR).should == STRUCT_DECODED_HASH
+    expect(BinaryStruct.new(STRUCT_DEF).decode(STRUCT_ENCODED_STR)).to eq(STRUCT_DECODED_HASH)
   end
 
   it '#decode with definition with *' do
-    BinaryStruct.new(STRUCT_DEF_ASTERISK).decode("Testing").should == {:word => "Testing"}
+    expect(BinaryStruct.new(STRUCT_DEF_ASTERISK).decode("Testing")).to eq(:word => "Testing")
   end
 
   it '#decode against multiple records' do
-    BinaryStruct.new(STRUCT_DEF).decode(STRUCT_ENCODED_STR * 10, 10).should == [STRUCT_DECODED_HASH] * 10
+    expect(BinaryStruct.new(STRUCT_DEF).decode(STRUCT_ENCODED_STR * 10, 10)).to eq([STRUCT_DECODED_HASH] * 10)
   end
 
   it '#encode' do
-    BinaryStruct.new(STRUCT_DEF).encode(STRUCT_DECODED_HASH).should == STRUCT_ENCODED_STR
+    expect(BinaryStruct.new(STRUCT_DEF).encode(STRUCT_DECODED_HASH)).to eq(STRUCT_ENCODED_STR.force_encoding("ASCII-8BIT"))
   end
 
   it '#encode with definition with *' do
-    BinaryStruct.new(STRUCT_DEF_ASTERISK).encode({:word => "Testing"}).should == "Testing"
+    expect(BinaryStruct.new(STRUCT_DEF_ASTERISK).encode(:word => "Testing")).to eq("Testing")
   end
 
   it '#encode against multiple records' do
-    BinaryStruct.new(STRUCT_DEF).encode([STRUCT_DECODED_HASH] * 10).should == (STRUCT_ENCODED_STR * 10)
+    s = BinaryStruct.new(STRUCT_DEF).encode([STRUCT_DECODED_HASH] * 10)
+    expect(s).to eq(STRUCT_ENCODED_STR.force_encoding("ASCII-8BIT") * 10)
   end
 
   it '#== against another BinaryStruct' do
-    BinaryStruct.new(STRUCT_DEF).should     == BinaryStruct.new(STRUCT_DEF)
-    BinaryStruct.new(STRUCT_DEF).should_not == BinaryStruct.new(STRUCT_DEF_ASTERISK)
+    expect(BinaryStruct.new(STRUCT_DEF)).to     eq(BinaryStruct.new(STRUCT_DEF))
+    expect(BinaryStruct.new(STRUCT_DEF)).not_to eq(BinaryStruct.new(STRUCT_DEF_ASTERISK))
   end
 
   it '#each will iterate over definition' do
     dup_def = []
     BinaryStruct.new(STRUCT_DEF).each { |field, name| dup_def << field << name }
-    dup_def.should == STRUCT_DEF
+    expect(dup_def).to eq(STRUCT_DEF)
   end
 
   context "old style methods" do
     after(:each) { BinaryStruct.clear_structs_by_definition_cache }
 
     it '#sizeof' do
-      BinaryStruct.sizeof(STRUCT_DEF).should == STRUCT_DEF_SIZE
+      expect(BinaryStruct.sizeof(STRUCT_DEF)).to eq(STRUCT_DEF_SIZE)
       # Do it twice for consistency reasons
-      BinaryStruct.sizeof(STRUCT_DEF).should == STRUCT_DEF_SIZE
+      expect(BinaryStruct.sizeof(STRUCT_DEF)).to eq(STRUCT_DEF_SIZE)
     end
 
     it '#decode' do
-      BinaryStruct.decode(STRUCT_ENCODED_STR, STRUCT_DEF).should == STRUCT_DECODED_HASH
+      expect(BinaryStruct.decode(STRUCT_ENCODED_STR, STRUCT_DEF)).to eq(STRUCT_DECODED_HASH)
       # Do it twice for consistency reasons
-      BinaryStruct.decode(STRUCT_ENCODED_STR, STRUCT_DEF).should == STRUCT_DECODED_HASH
+      expect(BinaryStruct.decode(STRUCT_ENCODED_STR, STRUCT_DEF)).to eq(STRUCT_DECODED_HASH)
     end
 
     it '#encode' do
-      BinaryStruct.encode(STRUCT_DECODED_HASH, STRUCT_DEF).should == STRUCT_ENCODED_STR
+      expect(BinaryStruct.encode(STRUCT_DECODED_HASH, STRUCT_DEF)).to eq(STRUCT_ENCODED_STR.force_encoding("ASCII-8BIT"))
       # Do it twice for consistency reasons
-      BinaryStruct.encode(STRUCT_DECODED_HASH, STRUCT_DEF).should == STRUCT_ENCODED_STR
+      expect(BinaryStruct.encode(STRUCT_DECODED_HASH, STRUCT_DEF)).to eq(STRUCT_ENCODED_STR.force_encoding("ASCII-8BIT"))
     end
   end
-end
+end

data/spec/endian_spec.rb

@@ -0,0 +1,192 @@
+describe BinaryStruct do
+  BIG_STRUCT_DEF = [
+    'Q>',  :quad,
+    'L>',  'long',
+    'S>',  :short,
+    'C',   nil,
+    'a0',  'none',
+    'a',   nil,
+    'a2',  'bc',
+  ]
+  BIG_STRUCT_DEF_SIZE                         = 18
+
+  BIG_E_QUAD_STRUCT_DEF                       = ['Q>2',  :quad]
+  BIG_E_QUAD_DEF_SIZE                         = 16
+
+  BIG_STRUCT_DEF_STAR                         = ['i>*', :word]
+  BIG_STRUCT_DEF_STAR_SIZE                    = 0 # '*' is ignored
+
+  BIG_STRUCT_DEF_UNRECOG_ENDIAN_FMT           = ['Y>', nil]
+  BIG_STRUCT_DEF_UNSUPPORTED_ENDIAN_ATTRIBUTE = ['A>', nil]
+  BIG_STRUCT_DEF_INVALID_ENDIAN_MODIFIER      = ['Q_', nil]
+
+  LIL_STRUCT_DEF = [
+    'Q<',  :quad,
+    'L<',  'long',
+    'S<',  :short,
+    'C',   nil,
+    'a0',  'none',
+    'a',   nil,
+    'a2',  'bc',
+  ]
+  LIL_STRUCT_DEF_SIZE                         = 18
+
+  LIL_E_QUAD_STRUCT_DEF                       = ['Q<2',  :quad]
+  LIL_E_QUAD_DEF_SIZE                         = 16
+
+  LIL_STRUCT_DEF_STAR                         = ['i<*', :word]
+  LIL_STRUCT_DEF_STAR_SIZE                    = 0 # '*' is ignored
+
+  LIL_STRUCT_DEF_UNRECOG_ENDIAN_FMT           = ['Y<', nil]
+  LIL_STRUCT_DEF_UNSUPPORTED_ENDIAN_ATTRIBUTE = ['A<', nil]
+
+  END_STRUCT_ENCODED_STR         = "\000\111\222\333\444\555\666\777\000\111\222\333\000\111\0000BC"
+
+  LIL_ENDIAN_STRUCT_DECODED_HASH = {:quad  => 18_426_034_930_503_010_560,
+                                    "long" => 3_683_797_248,
+                                    :short => 18_688,
+                                    "bc"   => "BC",
+                                    "none" => ""}
+  BIG_ENDIAN_STRUCT_DECODED_HASH = {:quad  => 20_709_143_206_541_055,
+                                    "long" => 4_821_723,
+                                    :short => 73,
+                                    "none" => "",
+                                    "bc"   => "BC"}
+
+  it('.new') { expect { BinaryStruct.new }.not_to raise_error }
+  it('.new with big definition') { expect { BinaryStruct.new(BIG_STRUCT_DEF) }.not_to raise_error }
+  it('.new with little definition') { expect { BinaryStruct.new(LIL_STRUCT_DEF) }.not_to raise_error }
+  it('.new with big definition with *') { expect { BinaryStruct.new(BIG_STRUCT_DEF_STAR) }.not_to raise_error }
+  it('.new with little definition with *') { expect { BinaryStruct.new(LIL_STRUCT_DEF_STAR) }.not_to raise_error }
+  it '.new with another big endian BinaryStruct' do
+    s = BinaryStruct.new(BIG_STRUCT_DEF)
+    s2 = BinaryStruct.new(s)
+    expect(s2).to eq(s)
+    expect(s2).not_to equal(s)
+  end
+
+  it '.new with another little endian BinaryStruct' do
+    s = BinaryStruct.new(LIL_STRUCT_DEF)
+    s2 = BinaryStruct.new(s)
+    expect(s2).to eq(s)
+    expect(s2).not_to equal(s)
+  end
+
+  it '.new big endian BinaryStruct with a little endian one' do
+    s = BinaryStruct.new(BIG_STRUCT_DEF)
+    s2 = BinaryStruct.new(LIL_STRUCT_DEF)
+    expect(s2).not_to eq(s)
+    expect(s2).not_to equal(s)
+  end
+
+  it('.new with unrecognized big e format') do
+    expect { BinaryStruct.new(BIG_STRUCT_DEF_UNRECOG_ENDIAN_FMT) }
+      .to raise_error(RuntimeError)
+  end
+
+  it('.new with unsupported big e attribute') do
+    expect { BinaryStruct.new(BIG_STRUCT_DEF_UNSUPPORTED_ENDIAN_ATTRIBUTE) }
+      .to raise_error(RuntimeError)
+  end
+
+  it('.new with invalid endian modifier') do
+    expect { BinaryStruct.new(BIG_STRUCT_DEF_INVALID_ENDIAN_MODIFIER) }
+      .to raise_error(RuntimeError)
+  end
+
+  it('.new with unrecognized little e format') do
+    expect { BinaryStruct.new(LIL_STRUCT_DEF_UNRECOG_ENDIAN_FMT) }
+      .to raise_error(RuntimeError)
+  end
+
+  it('.new with unsupported little e attribute') do
+    expect { BinaryStruct.new(LIL_STRUCT_DEF_UNSUPPORTED_ENDIAN_ATTRIBUTE) }
+      .to raise_error(RuntimeError)
+  end
+
+  it('#definition= with definition with *') do
+    expect { BinaryStruct.new.definition = BIG_STRUCT_DEF_STAR }
+      .not_to raise_error
+  end
+
+  it('#definition= with unrecognized big e format') do
+    expect { BinaryStruct.new.definition = BIG_STRUCT_DEF_UNRECOG_ENDIAN_FMT }
+      .to raise_error(RuntimeError)
+  end
+  it('#definition= with unsupported big e attribute') do
+    expect { BinaryStruct.new.definition = BIG_STRUCT_DEF_UNSUPPORTED_ENDIAN_ATTRIBUTE }
+      .to raise_error(RuntimeError)
+  end
+  it('#definition= with unrecognized little e format') do
+    expect { BinaryStruct.new.definition = LIL_STRUCT_DEF_UNRECOG_ENDIAN_FMT }
+      .to raise_error(RuntimeError)
+  end
+  it('#definition= with unsupported little e attribute') do
+    expect { BinaryStruct.new.definition = LIL_STRUCT_DEF_UNSUPPORTED_ENDIAN_ATTRIBUTE }
+      .to raise_error(RuntimeError)
+  end
+
+  it('#size') { expect(BinaryStruct.new(BIG_STRUCT_DEF).size).to eq(BIG_STRUCT_DEF_SIZE) }
+  it('#size') { expect(BinaryStruct.new(LIL_STRUCT_DEF).size).to eq(LIL_STRUCT_DEF_SIZE) }
+  it('#size with definition with *') { expect(BinaryStruct.new(BIG_STRUCT_DEF_STAR).size).to eq(BIG_STRUCT_DEF_STAR_SIZE) }
+  it('#size with definition with *') { expect(BinaryStruct.new(LIL_STRUCT_DEF_STAR).size).to eq(LIL_STRUCT_DEF_STAR_SIZE) }
+
+  it '#decode with different endian definitions' do
+    expect(BinaryStruct.new(BIG_STRUCT_DEF).decode(END_STRUCT_ENCODED_STR))
+      .not_to equal(BinaryStruct.new(LIL_STRUCT_DEF).decode(END_STRUCT_ENCODED_STR))
+  end
+  it '#encode with different endian definitions' do
+    big    = BinaryStruct.new(BIG_STRUCT_DEF).encode(BIG_ENDIAN_STRUCT_DECODED_HASH)
+    little = BinaryStruct.new(LIL_STRUCT_DEF).encode(LIL_ENDIAN_STRUCT_DECODED_HASH)
+    expect(big).not_to equal(little)
+  end
+
+  it '#decode little endian struct' do
+    expect(BinaryStruct.new(LIL_STRUCT_DEF).decode(END_STRUCT_ENCODED_STR)).to eq(LIL_ENDIAN_STRUCT_DECODED_HASH)
+  end
+  it '#decode big endian struct' do
+    expect(BinaryStruct.new(BIG_STRUCT_DEF).decode(END_STRUCT_ENCODED_STR)).to eq(BIG_ENDIAN_STRUCT_DECODED_HASH)
+  end
+
+  it '#== against another little endian BinaryStruct' do
+    expect(BinaryStruct.new(LIL_STRUCT_DEF)).to     eq(BinaryStruct.new(LIL_STRUCT_DEF))
+  end
+  it '#== big endian against another little endian BinaryStruct' do
+    expect(BinaryStruct.new(BIG_STRUCT_DEF)).not_to eq(BinaryStruct.new(LIL_STRUCT_DEF))
+  end
+  it '#== against another big endian BinaryStruct' do
+    expect(BinaryStruct.new(BIG_STRUCT_DEF)).to     eq(BinaryStruct.new(BIG_STRUCT_DEF))
+  end
+
+  it '#each will iterate over definition' do
+    dup_def = []
+    BinaryStruct.new(BIG_STRUCT_DEF).each { |field, name| dup_def << field << name }
+    expect(dup_def).to eq(BIG_STRUCT_DEF)
+  end
+
+  it '#each will iterate over definition' do
+    dup_def = []
+    BinaryStruct.new(LIL_STRUCT_DEF).each { |field, name| dup_def << field << name }
+    expect(dup_def).to eq(LIL_STRUCT_DEF)
+  end
+
+  context "old style methods" do
+    after(:each) { BinaryStruct.clear_structs_by_definition_cache }
+
+    it '#sizeof' do
+      expect(BinaryStruct.sizeof(BIG_STRUCT_DEF)).to eq(BIG_STRUCT_DEF_SIZE)
+    end
+    # Do it twice for consistency reasons
+    it '#sizeof' do
+      expect(BinaryStruct.sizeof(BIG_STRUCT_DEF)).to eq(BIG_STRUCT_DEF_SIZE)
+    end
+
+    it '#sizeof' do
+      expect(BinaryStruct.sizeof(LIL_STRUCT_DEF)).to eq(LIL_STRUCT_DEF_SIZE)
+    end
+    # Do it twice for consistency reasons
+    it '#sizeof' do
+      expect(BinaryStruct.sizeof(LIL_STRUCT_DEF)).to eq(LIL_STRUCT_DEF_SIZE)
+    end
+  end
+end

data/spec/gif_spec.rb

@@ -1,7 +1,3 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
-
-require 'binary_struct'
-
 describe BinaryStruct do
   let(:gif_header) do
     BinaryStruct.new([
@@ -16,23 +12,24 @@ describe BinaryStruct do
   end
 
   it "read a gif header" do
-    filename = File.join(File.dirname(__FILE__), %w{data test.gif})
-
-    header_size = gif_header.size
-    header = File.open(filename, "rb") { |f| f.read(header_size) }
-    gif_header.decode(header).should == {
+    filename = File.join(File.dirname(__FILE__), %w(data test.gif))
+    decoded_header_hash = {
       :magic              => "GIF",
       :version            => "89a",
       :width              => 16,
       :height             => 16,
       :flags              => "\x80",
       :bg_color_index     => 0,
-      :pixel_aspect_ratio => 0
+      :pixel_aspect_ratio => 0,
     }
+    encoded_header = gif_header.encode(decoded_header_hash)
+    header_size = gif_header.size
+    header = File.open(filename, "rb") { |f| f.read(header_size) }
+    expect(encoded_header).to eq(header)
   end
 
   it "write a gif header" do
-    header = gif_header.encode({
+    header = gif_header.encode(
       :magic              => "GIF",
       :version            => "89a",
       :width              => 16,
@@ -40,8 +37,8 @@ describe BinaryStruct do
       :flags              => "\x80",
       :bg_color_index     => 0,
       :pixel_aspect_ratio => 0
-    })
+    )
 
-    header.should == "GIF89a\x10\x00\x10\x00\x80\x00\x00"
+    expect(header).to eq("GIF89a\x10\x00\x10\x00\x80\x00\x00".force_encoding("ASCII-8BIT"))
   end
-end
+end

data/spec/spec_helper.rb

@@ -1,19 +1,85 @@
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# Require this file using `require "spec_helper"` to ensure that it is only
-# loaded once.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, make a
+# separate helper file that requires this one and then use it only in the specs
+# that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
   config.run_all_when_everything_filtered = true
 
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  # config.profile_examples = 10
+
   # Run specs in random order to surface order dependencies. If you find an
   # order dependency and want to debug it, you can fix the order by providing
   # the seed, which is printed after each run.
   #     --seed 1234
-  config.order = 'random'
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+    expectations.syntax = :expect
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+    mocks.syntax = :expect
+
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended.
+    mocks.verify_partial_doubles = true
+  end
+end
+
+begin
+  require 'coveralls'
+  Coveralls.wear!
+rescue LoadError
 end
 
-require 'coveralls'
-Coveralls.wear!
+require 'binary_struct'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: binary_struct
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-18 00:00:00.000000000 Z
+date: 2014-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -51,7 +51,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -59,7 +59,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
@@ -94,20 +94,16 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- Gemfile
-- LICENSE.txt
-- README.md
-- Rakefile
-- binary_struct.gemspec
 - lib/binary_struct.rb
 - lib/binary_struct/version.rb
+- README.md
+- LICENSE.txt
 - spec/binary_struct_spec.rb
 - spec/data/test.gif
+- spec/endian_spec.rb
 - spec/gif_spec.rb
 - spec/spec_helper.rb
-- travis.yml
+- .rspec
 homepage: http://github.com/ManageIQ/binary_struct
 licenses:
 - MIT
@@ -120,27 +116,23 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
-      segments:
-      - 0
-      hash: 944965749837137154
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 944965749837137154
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23.2
 signing_key: 
 specification_version: 3
 summary: BinaryStruct is a class for dealing with binary structured data.
 test_files:
 - spec/binary_struct_spec.rb
 - spec/data/test.gif
+- spec/endian_spec.rb
 - spec/gif_spec.rb
 - spec/spec_helper.rb
+- .rspec

data/.gitignore

@@ -1,17 +0,0 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp

data/Gemfile

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in binary_struct.gemspec
-gemspec

data/Rakefile

@@ -1,6 +0,0 @@
-require "bundler/gem_tasks"
-
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new('spec')
-task :test => :spec
-task :default => :spec

data/binary_struct.gemspec

@@ -1,30 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'binary_struct/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = "binary_struct"
-  spec.version       = BinaryStruct::VERSION
-  spec.authors       = ["Oleg Barenboim", "Jason Frey"]
-  spec.email         = ["chessbyte@gmail.com", "fryguy9@gmail.com"]
-  spec.description   = %q{
-BinaryStruct is a class for dealing with binary structured data.  It simplifies
-expressing what the binary structure looks like, with the ability to name the
-parts.  Given this definition, it is easy to encode/decode the binary structure
-from/to a Hash.
-}
-  spec.summary       = %q{BinaryStruct is a class for dealing with binary structured data.}
-  spec.homepage      = "http://github.com/ManageIQ/binary_struct"
-  spec.license       = "MIT"
-
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
-  spec.add_development_dependency "coveralls"
-end

data/travis.yml

@@ -1,9 +0,0 @@
-language: ruby
-rvm:
-  - "1.8.7"
-  - "1.9.2"
-  - "1.9.3"
-  - jruby-18mode # JRuby in 1.8 mode
-  - jruby-19mode # JRuby in 1.9 mode
-  - rbx-18mode
-  - rbx-19mode