binary_struct 2.0.0 → 2.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 390c83f0ae9d53e2c123bfe3190fb1be90573895
+  data.tar.gz: 548e8d4c5b6ba5c17af72412fe8ed8c9e15f48f8
+SHA512:
+  metadata.gz: fc67fb8689529bb62ecbec209f2b0a14e04ef60d97a4c8c88520aaca0d754ab33f803537609ac658d57a74671bf25f216b0f1d89f1fc065306f897500fb5320d
+  data.tar.gz: 150aeaf98ef9a9b483d97fbd6f4a8fee590149da79b6b53189f219dd96b314e12870888a26f2206683a223fbf926f394a2cc75f2a4a064586f5ef5056c0267cb

data/README.md

@@ -1,10 +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)
+[![Gem Version](https://badge.fury.io/rb/binary_struct.svg)](http://badge.fury.io/rb/binary_struct)
+[![Build Status](https://travis-ci.org/ManageIQ/binary_struct.svg)](https://travis-ci.org/ManageIQ/binary_struct)
+[![Code Climate](http://img.shields.io/codeclimate/github/ManageIQ/binary_struct.svg)](https://codeclimate.com/github/ManageIQ/binary_struct)
+[![Coverage Status](http://img.shields.io/coveralls/ManageIQ/binary_struct.svg)](https://coveralls.io/r/ManageIQ/binary_struct)
+[![Dependency Status](https://gemnasium.com/ManageIQ/binary_struct.svg)](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
@@ -65,6 +65,27 @@ File.open("test.gif", "wb") { |f| f.write(header) }
 => "GIF89a\x10\x00\x10\x00\x80\x00\x00"
 ```
 
+## Note about bit and nibble formats
+
+BinaryStruct supports bit formats and nibble formats, however note that the
+underlying Ruby methods, [pack](http://ruby-doc.org/core-2.2.0/Array.html#method-i-pack)
+and [unpack](http://ruby-doc.org/core-2.2.0/String.html#method-i-unpack), support
+less than 8 bits by reading an entire byte, even if all of the bits are not used.
+
+For example,
+
+```ruby
+s = "\xFF\x00"       # binary: 1111111100000000
+s.unpack("b8b8")     # => ["11111111", "00000000"]
+s.unpack("b4b4b4b4") # => ["1111", "0000", "", ""]
+```
+
+One might expect that the latter would read 4 bits, then the next 4 bits, etc,
+yielding `["1111", "1111", "0000", "0000"]`, but that is not the case.  Instead,
+the first b4 reads a full byte's worth, then discards the unused 4 bits, and the
+same happens for the next b4.  The third and fourth b4 have nothing left to read,
+and so just return empty strings.
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/binary_struct.rb

@@ -5,16 +5,16 @@ class BinaryStruct
   SIZES = {
     'A'   => 1,   # String with trailing NULs and spaces removed
     'a'   => 1,   # String
-    'B'   => nil, # Extract bits from each character (MSB first)
-    'b'   => nil, # Extract bits from each character (LSB first)
+    'B'   => 1,   # Extract bits from each character (MSB first)
+    'b'   => 1,   # Extract bits from each character (LSB first)
     'C'   => 1,   # Extract a character as an unsigned integer
     'c'   => 1,   # Extract a character as a    signed integer
     'E'   => nil, # Treat sizeof(double) characters as a double in little-endian byte order
     'e'   => nil, # Treat sizeof(float)  characters as a float  in little-endian byte order
     'G'   => nil, # Treat sizeof(double) characters as a double in network       byte order
     'g'   => nil, # Treat sizeof(float)  characters as a float  in network       byte order
-    'H'   => nil, # Extract hex nibbles from each character (most  significant first)
-    'h'   => nil, # Extract hex nibbles from each character (least significant first)
+    'H'   => 1,   # Extract hex nibbles from each character (most  significant first)
+    'h'   => 1,   # Extract hex nibbles from each character (least significant first)
     'I'   => 4,   # Treat sizeof(int) successive characters as an unsigned native integer
     'i'   => 4,   # Treat sizeof(int) successive characters as a    signed native integer
     'L'   => 4,   # Treat 4 successive characters as an unsigned native long integer
@@ -39,7 +39,9 @@ class BinaryStruct
     'Z'   => 1,   # String with trailing NULs removed
   }
 
-  STRING_FORMATS   = %w(A a M m u)
+  STRING_FORMATS   = %w(A a B b H h M m u)
+  BIT_FORMATS      = %w(B b)
+  NIBBLE_FORMATS   = %w(H h)
   ENDIAN_FORMATS   = %w(I i L l Q q S s)
   ENDIAN_MODIFIERS = %w(> <)
   MODIFIERS        = ENDIAN_MODIFIERS
@@ -56,6 +58,7 @@ class BinaryStruct
     if value.kind_of?(self.class)
       @definition = value.definition.dup
     else
+      value = value.to_a.map(&:reverse).flatten if value.kind_of?(Hash)
       value = Array(value)
       self.class.validate_definition(value)
       @definition = value
@@ -202,7 +205,14 @@ class BinaryStruct
       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])
+      size +=
+        if BIT_FORMATS.include?(type)
+          (count / 8.0).ceil
+        elsif NIBBLE_FORMATS.include?(type)
+          (count / 2.0).ceil
+        else
+          count * SIZES[type]
+        end
     end
     size
   end

data/lib/binary_struct/version.rb

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

data/spec/binary_struct_spec.rb

@@ -1,29 +1,50 @@
 describe BinaryStruct do
   STRUCT_DEF = [
-    'Q', :quad,
-    'L', 'long',
-    'S', :short,
-    'C', nil,
+    'Q',  :quad,
+    'L',  'long',
+    'S',  :short,
+    'C',  nil,
+    'b5', :binary,
     'a0', 'none',
-    'a', nil,
+    'a',  nil,
     'a2', 'bc',
   ]
-  STRUCT_DEF_SIZE = 18
+  STRUCT_DEF_SIZE = 19
+
+  STRUCT_DEF_HASH = {
+    :quad   => 'Q',
+    'long'  => 'L',
+    :short  => 'S',
+    nil     => 'C',
+    :binary => 'b5',
+    'none'  => 'a0',
+    :unused => 'a',
+    'bc'    => 'a2',
+  }
 
   STRUCT_DEF_ASTERISK = ['a*', :word]
   STRUCT_DEF_ASTERISK_SIZE = 0 # '*' is ignored
 
   STRUCT_DEF_UNRECOGNIZED_FORMAT   = ['D', nil]
-  STRUCT_DEF_UNSUPPORTED_FORMAT    = ['B', nil]
+  STRUCT_DEF_UNSUPPORTED_FORMAT    = ['U', nil]
   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".force_encoding("ASCII-8BIT")
-  STRUCT_DECODED_HASH = {:quad=>18426034930503010560, "long"=>3683797248, :short=>18688, "bc"=>"BC", "none"=>""}
+  STRUCT_ENCODED_STR  = "\000\111\222\333\444\555\666\777\000\111\222\333\000\111\000\0320BC".force_encoding("ASCII-8BIT")
+  STRUCT_DECODED_HASH = {
+    :quad   => 18_426_034_930_503_010_560,
+    "long"  => 3_683_797_248,
+    :short  => 18_688,
+    :binary => "01011",
+    "bc"    => "BC",
+    "none"  => ""
+  }
+  STRUCT_DECODED_HASH2 = STRUCT_DECODED_HASH.merge(:unused => "0")
 
   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 Hash defintion') { expect { BinaryStruct.new(STRUCT_DEF_HASH) }.not_to raise_error }
   it '.new with another BinaryStruct' do
     s = BinaryStruct.new(STRUCT_DEF)
     s2 = BinaryStruct.new(s)
@@ -38,6 +59,7 @@ describe BinaryStruct do
 
   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 Hash defintion') { expect { BinaryStruct.new.definition = STRUCT_DEF_HASH }.not_to raise_error }
 
   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) }
@@ -55,6 +77,10 @@ describe BinaryStruct do
     expect(BinaryStruct.new(STRUCT_DEF_ASTERISK).decode("Testing")).to eq(:word => "Testing")
   end
 
+  it '#decode with Hash defintion' do
+    expect(BinaryStruct.new(STRUCT_DEF_HASH).decode(STRUCT_ENCODED_STR)).to eq(STRUCT_DECODED_HASH2)
+  end
+
   it '#decode against multiple records' do
     expect(BinaryStruct.new(STRUCT_DEF).decode(STRUCT_ENCODED_STR * 10, 10)).to eq([STRUCT_DECODED_HASH] * 10)
   end

data/spec/endian_spec.rb

@@ -1,14 +1,15 @@
 describe BinaryStruct do
   BIG_STRUCT_DEF = [
-    'Q>',  :quad,
-    'L>',  'long',
-    'S>',  :short,
-    'C',   nil,
-    'a0',  'none',
-    'a',   nil,
-    'a2',  'bc',
+    'Q>', :quad,
+    'L>', 'long',
+    'S>', :short,
+    'C',  nil,
+    'b5', :binary,
+    'a0', 'none',
+    'a',  nil,
+    'a2', 'bc',
   ]
-  BIG_STRUCT_DEF_SIZE                         = 18
+  BIG_STRUCT_DEF_SIZE                         = 19
 
   BIG_E_QUAD_STRUCT_DEF                       = ['Q>2',  :quad]
   BIG_E_QUAD_DEF_SIZE                         = 16
@@ -21,15 +22,16 @@ describe BinaryStruct do
   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',
+    'Q<', :quad,
+    'L<', 'long',
+    'S<', :short,
+    'C',  nil,
+    'b5', :binary,
+    'a0', 'none',
+    'a',  nil,
+    'a2', 'bc',
   ]
-  LIL_STRUCT_DEF_SIZE                         = 18
+  LIL_STRUCT_DEF_SIZE                         = 19
 
   LIL_E_QUAD_STRUCT_DEF                       = ['Q<2',  :quad]
   LIL_E_QUAD_DEF_SIZE                         = 16
@@ -40,18 +42,27 @@ describe BinaryStruct do
   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"}
+  END_STRUCT_ENCODED_STR         = "\000\111\222\333\444\555\666\777\000\111\222\333\000\111\000\0320BC"
+
+  LIL_ENDIAN_STRUCT_DECODED_HASH =
+    {
+      :quad   => 18_426_034_930_503_010_560,
+      "long"  => 3_683_797_248,
+      :short  => 18_688,
+      :binary => "01011",
+      "none"  => "",
+      "bc"    => "BC",
+    }
+
+  BIG_ENDIAN_STRUCT_DECODED_HASH =
+    {
+      :quad   => 20_709_143_206_541_055,
+      "long"  => 4_821_723,
+      :short  => 73,
+      :binary => "01011",
+      "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 }

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: binary_struct
 version: !ruby/object:Gem::Version
-  version: 2.0.0
-  prerelease: 
+  version: 2.1.0
 platform: ruby
 authors:
 - Oleg Barenboim
@@ -10,83 +9,70 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-18 00:00:00.000000000 Z
+date: 2015-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: ! '
+description: |2
 
   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.
-
-'
 email:
 - chessbyte@gmail.com
 - fryguy9@gmail.com
@@ -94,40 +80,39 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".rspec"
+- LICENSE.txt
+- README.md
 - 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
-- .rspec
 homepage: http://github.com/ManageIQ/binary_struct
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23.2
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: BinaryStruct is a class for dealing with binary structured data.
 test_files:
 - spec/binary_struct_spec.rb
@@ -135,4 +120,4 @@ test_files:
 - spec/endian_spec.rb
 - spec/gif_spec.rb
 - spec/spec_helper.rb
-- .rspec
+- ".rspec"