vcdiff.rb 0.0.1

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Adam Prescott
+
+(MIT License)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,73 @@
+# VCDIFF
+
+A pure-Ruby implementation VCDIFF encoder/decoder. Aims to provide similar
+functionality to Google's [open-vcdiff](https://code.google.com/p/open-vcdiff)
+(which the [vcdiff](https://github.com/romanbsd/vcdiff) gem wraps), but without
+the C.
+
+Some important notes and to-be-implemented things:
+
+* Encoding isn't implemented yet, although the plan is to use the
+  [`bentley_mcilroy`](https://github.com/aprescott/bentley_mcilroy) gem,
+  following the same strategy as open-vcdiff. There is a question of what block
+  size to use for windows when finding common substrings.
+* The decoder can't handle custom code tables or any sort of compression flags.
+  Compression is probably a won't-fix on account of there being no compressor
+  ID standards and the RFC for VCDIFF doesn't specify one. Custom code table
+  support is desirable so every VCDIFF encoding is supported when decoding.
+* The decoder doesn't handle any window where the `VCD_TARGET` bit is set in
+  the window indicator (`Win_indicator`). As with custom code tables, it would
+  be good to have this. It's currently omitted for simplicity.
+
+Further reading:
+
+* [RFC3284](http://tools.ietf.org/html/rfc3284#section-7) — The VCDIFF Generic Differencing and Compression Data Format
+
+# Installation
+
+Add this line to your application's Gemfile:
+
+```
+gem "vcdiff.rb"
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install vcdiff.rb
+```
+
+# Usage
+
+## Encoding
+
+Not yet implemented.
+
+## Decoding
+
+```ruby
+decoder = VCDIFF::Decoder.new("path/to/dictionary_source")
+original_target = decoder.decode("path/to/delta_file")
+```
+
+# Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+The issue tracker is [on GitHub](https://github.com/aprescott/vcdiff.rb/issues).
+If you find any bugs, just open an issue.
+
+# License
+
+Copyright (c) Adam Prescott, released under the MIT license. See the license file.
+Any contributions will be assumed to be under the same terms.

data/lib/vcdiff/code_table.rb

@@ -0,0 +1,65 @@
+module VCDIFF
+  # Default code table as defined in RFC 3284 (5.6)
+  # 
+  #       TYPE      SIZE     MODE    TYPE     SIZE     MODE     INDEX
+  #      ---------------------------------------------------------------
+  #   1.  RUN         0        0     NOOP       0        0        0
+  #   2.  ADD    0, [1,17]     0     NOOP       0        0      [1,18]
+  #   3.  COPY   0, [4,18]     0     NOOP       0        0     [19,34]
+  #   4.  COPY   0, [4,18]     1     NOOP       0        0     [35,50]
+  #   5.  COPY   0, [4,18]     2     NOOP       0        0     [51,66]
+  #   6.  COPY   0, [4,18]     3     NOOP       0        0     [67,82]
+  #   7.  COPY   0, [4,18]     4     NOOP       0        0     [83,98]
+  #   8.  COPY   0, [4,18]     5     NOOP       0        0     [99,114]
+  #   9.  COPY   0, [4,18]     6     NOOP       0        0    [115,130]
+  #  10.  COPY   0, [4,18]     7     NOOP       0        0    [131,146]
+  #  11.  COPY   0, [4,18]     8     NOOP       0        0    [147,162]
+  #  12.  ADD       [1,4]      0     COPY     [4,6]      0    [163,174]
+  #  13.  ADD       [1,4]      0     COPY     [4,6]      1    [175,186]
+  #  14.  ADD       [1,4]      0     COPY     [4,6]      2    [187,198]
+  #  15.  ADD       [1,4]      0     COPY     [4,6]      3    [199,210]
+  #  16.  ADD       [1,4]      0     COPY     [4,6]      4    [211,222]
+  #  17.  ADD       [1,4]      0     COPY     [4,6]      5    [223,234]
+  #  18.  ADD       [1,4]      0     COPY       4        6    [235,238]
+  #  19.  ADD       [1,4]      0     COPY       4        7    [239,242]
+  #  20.  ADD       [1,4]      0     COPY       4        8    [243,246]
+  #  21.  COPY        4      [0,8]   ADD        1        0    [247,255]
+  #      ---------------------------------------------------------------
+  class CodeTable
+    NOOP, ADD, RUN, COPY = 0, 1, 2, 3
+
+    DEFAULT_TABLE = [
+      [RUN, 0, 0, NOOP, 0, 0],
+    ]
+    
+    (0..17).each do |n|
+      DEFAULT_TABLE << [ADD, n, 0, NOOP, 0, 0]
+    end
+    
+    (0..8).each do |mode|
+      DEFAULT_TABLE << [COPY, 0, mode, NOOP, 0, 0]
+      
+      (4..18).each do |size|
+        DEFAULT_TABLE << [COPY, size, mode, NOOP, 0, 0]
+      end
+    end
+    
+    (0..5).each do |mode|
+      (1..4).each do |add_size|
+        (4..6).each do |copy_size|
+          DEFAULT_TABLE << [ADD, add_size, 0, COPY, copy_size, mode]
+        end
+      end
+    end
+    
+    (6..8).each do |mode|
+      (1..4).each do |add_size|
+        DEFAULT_TABLE << [ADD, add_size, 0, COPY, 4, mode]
+      end
+    end
+    
+    (0..8).each do |mode|
+      DEFAULT_TABLE << [COPY, 4, mode, ADD, 1, 0]
+    end
+  end
+end

data/lib/vcdiff/integer.rb

@@ -0,0 +1,92 @@
+require "bindata"
+
+module VCDIFF
+  # As described in RFC 3284 (http://tools.ietf.org/html/rfc3284)
+  # unsigned integers are treated as a number in base 128.
+  # Each digit in this representation is encoded in the lower
+  # 7 bits of a byte. Runs of bytes b_1, b_2, b_3, ..., b_n
+  # for one integer have the most significant bit set to 1
+  # for each b_i, i = 1, ..., n-1, and set to 0 for b_n.
+  # 
+  # So 123456789 encodes to four 7-bit digits with values
+  # 58, 111, 26, 21:
+  # 
+  #     +-------------------------------------------+
+  #     | 10111010 | 11101111 | 10011010 | 00010101 |
+  #     +-------------------------------------------+
+  #       MSB+58     MSB+111    MSB+26     0+21
+  #
+  class VCDIFFInt < BinData::BasePrimitive
+    def value_to_binary_string(value)
+      bytes = []
+
+      loop do
+        # get the value of the lowest 7 bits
+        next_value = value & 0b01111111
+
+        value >>= 7
+
+        # on every byte except the first one, flip the 8th bit on
+        next_value = 0b10000000 | next_value unless bytes.empty?
+
+        bytes.unshift(next_value)
+
+        break if value == 0
+      end
+
+      bytes.pack("C*")
+    end
+
+    def read_and_return_value(io)
+      byte_values = []
+      value = 0
+
+      loop do
+        b = next_byte(io)
+        last_byte = (b[7] == 0)
+
+        byte_values << (b & 0b01111111)
+
+        break if last_byte
+      end
+
+      byte_values.reverse.each_with_index do |e, i|
+        # add byte * 128**i, since e is considered to be
+        # a number in base 128
+        value += e * (1 << (7 * i))
+      end
+
+      value
+    end
+
+    def sensible_default
+      0
+    end
+
+    # Converts a Ruby Integer into a string where each character is
+    # either 0 or 1, fully representing the bytes in the array.
+    #
+    # TODO: a non-awful method name and non-awful implementation
+    def value_to_zero_one_string
+      to_binary_s.unpack("C*").map { |e| e.to_s(2).rjust(8, "0") }.join("")
+    end
+
+    # Gives the VCDIFF integer as a regular Ruby Integer
+    def to_i
+      snapshot
+    end
+
+    private
+
+    # next byte as a fixnum
+    def next_byte(io)
+      io.readbytes(1).unpack("C")[0]
+    end
+
+    # Returns the lowest multiple of m
+    # greater than or equal to n.
+    def self.next_multiple(n, m)
+      n + (m - n % m) % m
+    end
+  end
+end

data/lib/vcdiff/records.rb

@@ -0,0 +1,90 @@
+require "bindata"
+require "vcdiff/integer"
+
+module VCDIFF
+  class VCDIFFHeader < BinData::Record
+    endian :big
+
+    # header{1,2,3,4} is "VCD\0" with the upper bits turned on for "VCD"
+    uint8 :header_v, :initial_value => 0xD6, :assert => 0xD6
+    uint8 :header_c, :initial_value => 0xC3, :assert => 0xC3
+    uint8 :header_d, :initial_value => 0xC4, :assert => 0xC4
+    uint8 :header_zero, :initial_value => 0x00, :assert => 0x00
+
+    uint8 :header_indicator, :initial_value => 0
+    uint8 :secondary_compressor_id, :onlyif => :secondary_compressor?
+    vcdiff_int :custom_codetable_length, :onlyif => :custom_codetable?
+    array :code_table_data, :type => :uint8, :onlyif => :custom_codetable?, :initial_length => :custom_codetable_length
+
+    def secondary_compressor?
+      header_indicator[0] == 1
+    end
+
+    def custom_codetable?
+      header_indicator[1] == 1
+    end
+  end
+
+  class VCDIFFDeltaEncoding < BinData::Record
+    endian :big
+
+    vcdiff_int :bytes_remaining # bytes remaining for the delta encoding
+    vcdiff_int :target_length # the size of the decoded target file
+    uint8 :delta_indicator, :initial_value => 0
+    vcdiff_int :add_run_data_length
+    vcdiff_int :instructions_length
+    vcdiff_int :copy_addresses_length
+
+    array :add_run_data, :type => :uint8, :initial_length => :add_run_data_length
+    array :instructions, :type => :uint8, :initial_length => :instructions_length
+    array :copy_address_data, :type => :uint8, :initial_length => :copy_addresses_length
+
+    # VCD_DATACOMP bit value, for unmatched ADD and RUN data
+    def data_compressed?
+      delta_indicator[0] == 1
+    end
+
+    # VCD_INSTCOMP bit value, for the delta instructions and accompanying
+    # sizes
+    def instructions_compressed?
+      delta_indicator[1] == 1
+    end
+
+    # VCD_ADDRCOMP bit value, for the addresses for the COPY instructions
+    def addresses_compressed?
+      delta_indicator[2] == 1
+    end
+  end
+
+  class VCDIFFWindow < BinData::Record
+    endian :big
+
+    uint8 :window_indicator, :initial_value => 0, :assert => lambda { !(value[0] == 1 && value[1] == 1) }
+    vcdiff_int :source_data_length, :onlyif => lambda { !compressed_only? }
+    vcdiff_int :source_data_position, :onlyif => lambda { !compressed_only? }
+    vcdiff_delta_encoding :delta_encoding
+
+    # Returns true if VCD_SOURCE is set
+    def source_data?
+      window_indicator[0] == 1
+    end
+
+    # Returns true if VCD_TARGET is set
+    def target_data?
+      window_indicator[1] == 1
+    end
+
+    # If VCD_SOURCE and VCD_TARGET are both 0, then the target file was
+    # compressed by itself.
+    def compressed_only?
+      !source_data? && !target_data?
+    end
+  end
+
+  class DeltaFile < BinData::Record
+    endian :big
+
+    vcdiff_header :header
+    rest :windows
+  end
+end

data/lib/vcdiff.rb

@@ -0,0 +1,209 @@
+require "bentley_mcilroy"
+
+require "vcdiff/integer"
+require "vcdiff/records"
+require "vcdiff/code_table"
+
+module VCDIFF
+  class Encoder
+    #### Implement me ####
+  end
+
+  class Decoder
+    attr_accessor :dictionary
+
+    def initialize(dictionary)
+      @dictionary = File.read(dictionary)
+
+      @s_near = 4
+      @s_same = 3
+
+      # all cache values initialize to 0
+      @near_cache = Array.new(@s_near, 0)
+      @same_cache = Array.new(@s_same * 256, 0)
+      @next_slot = 0
+    end
+
+    # Decodes a delta file using the dictionary given to the decoder
+    def decode(file)
+      delta_file = DeltaFile.read(File.new(file))
+
+      if delta_file.header.header_indicator != 0
+        raise NotImplementedError, "Header indicator of #{delta_file.header.header_indicator} can't be handled"
+      end
+
+      if delta_file.header.custom_codetable?
+        raise NotImplementedError, "Unable to handle a custom codetable"
+      end
+
+      # there's no simple way to determine the number of windows, since the
+      # count isn't given ahead of time, so we'll need to manually iterate
+      # through the windows
+      window_stream = StringIO.new(delta_file.windows)
+
+      target_file = ""
+
+      until window_stream.eof?
+        # reads only one window's worth of bytes from the stream
+        next_window = VCDIFFWindow.read(window_stream)
+
+        if next_window.compressed_only? || next_window.target_data?
+          raise NotImplementedError, "Can only handle VCD_SOURCE windows"
+        end
+
+        length, position = next_window.source_data_length, next_window.source_data_position
+
+        source_window = @dictionary[position, length]
+
+        target_file << process_delta_encoding(source_window, next_window.delta_encoding)
+      end
+
+      target_file
+    end
+
+    # takes a delta encoding and processes it against the source
+    # window.
+    #
+    # this corresponds to section (6) in RFC3284, which outlines
+    # processing the instructions, data and addresses arrays.
+    def process_delta_encoding(source_window, delta_encoding)
+      # to_a is needed here to unwrap the BinData::Array, which doesn't
+      # know about method calls like #shift
+      instructions      = delta_encoding.instructions.to_a
+      add_run_data      = delta_encoding.add_run_data.to_a
+      copy_address_data = delta_encoding.copy_address_data.to_a
+
+      code_table = CodeTable::DEFAULT_TABLE
+
+      # the final string for this window
+      target_window = ""
+
+      add_run_index = 0
+
+      until instructions.empty?
+        # instructions is a sequence of tupes (index, [size1], [size2]),
+        # where size1 and size2 existence depends on the instruction entry
+        # which _index_ points to.
+        index = instructions.shift
+
+        # instruction pair looked up in the code table
+        instruction = code_table[index]
+        type1, size1, mode1, type2, size2, mode2 = instruction
+
+        if type1 != CodeTable::NOOP && size1 == 0
+          instruction_size_1 = read_int(instructions)
+        else
+          instruction_size_1 = size1
+        end
+
+        if type2 != CodeTable::NOOP && size2 == 0
+          instruction_size_2 = read_int(instructions)
+        else
+          instruction_size_2 = size2
+        end
+
+        case type1
+        when CodeTable::NOOP
+          next
+        when CodeTable::RUN
+          if mode1 != 0
+            warn "Warning: RUN found with mode #{mode1} -- value will be ignored"
+          end
+
+          if instruction_size_1 == 0
+            raise ArgumentError, "File contains a RUN instruction of size 0, must be > 0"
+          end
+
+          # repeat a single character instruction_size_1 times.
+          # since add_run_data is an array of byte values, we
+          # call #[x, 1] with *n to get n copies of the byte
+          # at index x, since ary[x, 1] == [ary[x]].
+          target_window << (add_run_data[add_run_index, 1] * instruction_size_1).pack("C*")
+          add_run_index += 1
+        when CodeTable::ADD
+          if mode1 != 0
+            warn "Warning: ADD found with mode #{mode1} -- value will be ignored"
+          end
+
+          if instruction_size_1 == 0
+            raise ArgumentError, "File contains an ADD instruction of size 0, must be > 0"
+          end
+
+          target_window << (add_run_data[add_run_index, instruction_size_1]).pack("C*")
+          add_run_index += instruction_size_1
+        when CodeTable::COPY
+          # from (5.3) of RFC3284:
+          #
+          #   The address of a COPY instruction is encoded using different modes,
+          #   depending on the type of cached address used, if any.
+          #
+          #   Let "addr" be the address of a COPY instruction to be decoded and
+          #   "here" be the current location in the target data (i.e., the start of
+          #   the data about to be encoded or decoded).  Let near[j] be the jth
+          #   element in the near cache, and same[k] be the kth element in the same
+          #   cache.  Below are the possible address modes:
+          #
+          #      VCD_SELF: This mode has value 0.  The address was encoded by
+          #         itself as an integer.
+          #
+          #      VCD_HERE: This mode has value 1.  The address was encoded as the
+          #         integer value "here - addr".
+          #
+          #      Near modes: The "near modes" are in the range [2,s_near+1].  Let m
+          #         be the mode of the address encoding.  The address was encoded
+          #         as the integer value "addr - near[m-2]".
+          #
+          #      Same modes: The "same modes" are in the range
+          #         [s_near+2,s_near+s_same+1].  Let m be the mode of the encoding.
+          #         The address was encoded as a single byte b such that "addr ==
+          #         same[(m - (s_near+2))*256 + b]".
+          #
+
+          here = target_window.length - 1
+
+          case mode1
+          when 0 # VCD_SELF
+            addr = read_int(copy_address_data)
+          when 1 # VCD_HERE
+            addr = here - read_int(copy_address_data)
+          when 2..(@s_near + 1) # near modes
+            addr = read_int(copy_address_data) + @near_cache[mode1 - 2]
+          when (@s_near+2)..(@s_near+@s_same+1) # same modes
+            # address is encoded as a single byte
+            b = copy_address_data.shift
+            addr = @same_cache[(mode1 - (@s_near + 2))*256 + b]
+          else
+            raise ArgumentError, "invalid mode #{mode1}"
+          end
+
+          target_window << source_window[addr, instruction_size_1]
+
+          # now update the "near" and "same" caches.
+          if @s_near > 0
+            @near_cache[@next_slot] = addr
+            @next_slot = (@next_slot + 1) % @s_near
+          end
+
+          if @s_same > 0
+            @same_cache[addr % (@s_same * 256)] = addr
+          end
+        else
+          raise ArgumentError, "Invalid file format, instruction of #{type1} (found at index #{index}) doesn't exist"
+        end
+      end
+
+      target_window
+    end
+
+    # shifts a VCDIFF integer off the given array of bytes, modifying
+    # the array argument in-place.
+    def read_int(array)
+      # first index where the MSB = index-7 bit is 0
+      zero_msb_index = array.index { |e| e.to_i[7] == 0 }
+
+      int_bytes = array.shift(zero_msb_index + 1)
+
+      VCDIFFInt.read(int_bytes.pack("C*")).to_i
+    end
+  end
+end

data/rakefile

@@ -0,0 +1,11 @@
+require "rake"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:test) do |t|
+  t.rspec_opts = "-I test --color --format nested"
+  t.pattern = "test/**/*_spec.rb"
+  t.verbose = false
+  t.fail_on_error = true
+end
+
+task :default => :test

data/test/data/source

@@ -0,0 +1,16 @@
+some header some header some header
+some header some header some header
+some header some header some header
+some header some header some header
+some header some header some header
+some header some header some header
+
+dynamic CONTENT
+
+some footer some footer some footer
+some footer some footer some footer
+some footer some footer some footer
+some footer some footer some footer
+some footer some footer some footer
+some footer some footer some footer
+

data/test/data/target

@@ -0,0 +1,16 @@
+some header some header some header
+some header some header some header
+some header some header some header
+some header some header some header
+some header some header some header
+some header some header some header
+
+only the best dynamic content
+
+some footer some footer some footer
+some footer some footer some footer
+some footer some footer some footer
+some footer some footer some footer
+some footer some footer some footer
+some footer some footer some footer
+

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require "tempfile"
+
+require "vcdiff"

data/test/vcdiff_code_table_spec.rb

@@ -0,0 +1,9 @@
+require "test_helper"
+
+describe VCDIFF::CodeTable do
+  describe "DEFAULT_TABLE" do
+    it "has 256 entries" do
+      VCDIFF::CodeTable::DEFAULT_TABLE.length == 256
+    end
+  end
+end

data/test/vcdiff_decoder_spec.rb

@@ -0,0 +1,31 @@
+require "test_helper"
+
+describe VCDIFF::Decoder do
+  subject { VCDIFF::Decoder.new("test/data/source") }
+
+  describe "#decode" do
+    it "can decode delta files, given the source, to derive the target" do
+      subject.decode(File.new("test/data/delta")).should == File.read("test/data/target")
+    end
+
+    it "cannot handle a non-zero header indicator" do
+      # secondary compressor
+      delta = Tempfile.new("secondary_compressor_bit_set")
+      content = File.read("test/data/delta")
+      content.setbyte(4, 0x01)
+      delta.write(content)
+      delta.rewind
+
+      expect { subject.decode(delta) }.to raise_error(NotImplementedError)
+
+      # custom codetable
+      delta = Tempfile.new("custom_codetable_bit_set")
+      content = File.read("test/data/delta")
+      content.setbyte(4, 0x02)
+      delta.write(content)
+      delta.rewind
+
+      expect { subject.decode(delta) }.to raise_error(NotImplementedError)
+    end
+  end
+end

data/test/vcdiff_integer_spec.rb

@@ -0,0 +1,28 @@
+require "test_helper"
+
+KNOWN_ENCODINGS = {
+                    266478  => "100100001010000101101110",
+                    488908  => "100111011110101101001100",
+                    1311959 => "110100001000100101010111",
+                    290936  => "100100011110000001111000",
+                    1306432 => "110011111101111001000000",
+                    1318485 => "110100001011110001010101",
+                    983071  => "101111001000000000011111",
+                    918966  => "101110001000101100110110",
+                    1119947 => "110001001010110101001011",
+                    1186056 => "110010001011001000001000"
+                  }
+
+describe VCDIFF::VCDIFFInt do
+  it "converts between different representations" do
+    KNOWN_ENCODINGS.each do |int, str|
+      packed = [str].pack("B*")
+
+      i = VCDIFF::VCDIFFInt.read(packed)
+
+      i.snapshot.should == int
+      i.to_binary_s.should == packed
+      i.to_i.should == i.snapshot
+    end
+  end
+end

data/test/vcdiff_records_spec.rb

@@ -0,0 +1,33 @@
+require "test_helper"
+
+describe VCDIFF::VCDIFFHeader do
+  it "requires a valid header" do
+    # requires VCD\0 with the uppermost bits set to 1 for "V","C","D"
+    expect { VCDIFF::VCDIFFHeader.read("\xD6\xC3\xC4\x00") }.to_not raise_error(BinData::ValidityError)
+    expect { VCDIFF::VCDIFFHeader.read("\x01\x02\x03\x00") }.to raise_error(BinData::ValidityError)
+  end
+
+  describe "#secondary_compressor?" do
+    it "is true if the header_indicator has the appropriate bit set" do
+      header = VCDIFF::VCDIFFHeader.read("\xD6\xC3\xC4\x00\x01\x00\x00\x00\x00\x00\x00")
+      header.secondary_compressor?.should be_true
+      header.header_indicator[0].should == 1
+    end
+  end
+
+  describe "#custom_codetable?" do
+    it "is true if the header_indicator has the appropriate bit set" do
+      # VCD\0 + 0b10 for custom code table, plus a bunch of zeroes to have enough bytes to read
+      header = VCDIFF::VCDIFFHeader.read("\xD6\xC3\xC4\x00\x02\x00\x00\x00\x00\x00\x00")
+      header.custom_codetable?.should be_true
+      header.header_indicator[1].should == 1
+    end
+  end
+end
+
+describe VCDIFF::DeltaFile do
+  it "requires a valid header" do
+    expect { VCDIFF::DeltaFile.read("\xD6\xC3\xC4\x00") }.to_not raise_error(BinData::ValidityError)
+    expect { VCDIFF::DeltaFile.read("\x01\x02\x03\x00") }.to raise_error(BinData::ValidityError)
+  end
+end

data/vcdiff.rb.gemspec

@@ -0,0 +1,26 @@
+Gem::Specification.new do |gem|
+  gem.name          = "vcdiff.rb"
+  gem.version       = "0.0.1"
+  gem.authors       = ["Adam Prescott"]
+  gem.email         = ["adam@aprescott.com"]
+  gem.description   = "Pure-Ruby VCDIFF encoder/decoder."
+  gem.summary       = "Pure-Ruby encoder and decoder for the VCDIFF format."
+  gem.homepage      = "https://github.com/aprescott/vcdiff.rb"
+
+  gem.files         = Dir["{lib/**/*,test/**/*,*.gemspec}"] + %w[rakefile LICENSE Gemfile README.md]
+  gem.require_path  = "lib"
+
+  [
+    "bindata", "~> 1.6.0",
+    "bentley_mcilroy", ">= 0"
+  ].each_slice(2) do |name, version|
+    gem.add_runtime_dependency(name, version)
+  end
+
+  [
+    "rake", "~> 10.0.0",
+    "rspec", "~> 2.5"
+  ].each_slice(2) do |name, version|
+    gem.add_runtime_dependency(name, version)
+  end
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: vcdiff.rb
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Adam Prescott
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bindata
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+- !ruby/object:Gem::Dependency
+  name: bentley_mcilroy
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.5'
+description: Pure-Ruby VCDIFF encoder/decoder.
+email:
+- adam@aprescott.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/vcdiff.rb
+- lib/vcdiff/integer.rb
+- lib/vcdiff/records.rb
+- lib/vcdiff/code_table.rb
+- test/test_helper.rb
+- test/vcdiff_code_table_spec.rb
+- test/vcdiff_decoder_spec.rb
+- test/vcdiff_integer_spec.rb
+- test/data/delta
+- test/data/target
+- test/data/source
+- test/vcdiff_records_spec.rb
+- vcdiff.rb.gemspec
+- rakefile
+- LICENSE
+- Gemfile
+- README.md
+homepage: https://github.com/aprescott/vcdiff.rb
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Pure-Ruby encoder and decoder for the VCDIFF format.
+test_files: []