trick_bag 0.56.0 → 0.57.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d4818c34b17f75700285ef836328c5dd0a543862
-  data.tar.gz: 081c5c721ca498f42bcc05031e2f4ddac2d73ac8
+  metadata.gz: 012936fb2a08c5a0cf646ecf9e8895f8cb122aab
+  data.tar.gz: 11402a3ba146571b4648829b922db87aca0b62bd
 SHA512:
-  metadata.gz: 088282d53b429a5657106ac4e1e94988a47468db31018e812c20479c3545995baa8f474d1d45ceaa1ee018f6af2930d58f215004994cf65a6790900b2a9186e3
-  data.tar.gz: 7487f2e3e6d233af9c420797d092aab6c0a96a0d56b2a7479d70a12f02da0cbf80c3c5045a9e272d7cb2f09f987b66ac88b3720e2a48b2a561ad40bbca8136aa
+  metadata.gz: 416fdc0e04db515bcec0a0462308165a49e4b5c8a6c250c8624ec2bcd00811da27fd784cabecb72830e1cd90d5492aad495f22ab4e54439544097511f9519735
+  data.tar.gz: ef625fb8bee7da8734ba483071f64c24d5b3c7abb3ca6a2a05c767b1d32f733e59ce7d5d3e07cc87a48d74843c5cdb8e6857b22bc2220f30c6ff4e7b8c80f11a

data/RELEASE_NOTES.md

@@ -1,3 +1,8 @@
+## v0.57.0
+
+* Removed most class methods from Bitmap and put them in new BitMapping module.
+
+
 ## v0.56.0
 
 * Added Bitmap class/support.

data/lib/trick_bag/numeric/bit_mapping.rb

@@ -0,0 +1,124 @@
+module TrickBag
+module Numeric
+
+
+# Provides methods for converting between the various representations
+# of a bitmap: number, binary encoded string, array, and sparse array.
+#
+# Where an array is used to represent bits, the first element (#0) will be the
+# high bit and the last element will be the low (1's column) bit.
+module BitMapping
+
+  module_function
+
+  # Converts from a binary string to a number, e.g. "\x01\x00" => 256
+  def binary_string_to_number(string)
+    string = string.clone.force_encoding(Encoding::ASCII_8BIT)
+    string.bytes.inject(0) do |number, byte|
+      number * 256 + byte.ord
+    end
+  end
+
+
+  # Converts a number to a binary encoded string, e.g. 256 => "\x01\x00"
+  def number_to_binary_string(number, min_length = 0)
+    assert_non_negative(number)
+    binary_string = ''.force_encoding(Encoding::ASCII_8BIT)
+
+    while number > 0
+      byte_value = number & 0xFF
+      binary_string << byte_value
+      number >>= 8
+    end
+
+    binary_string.reverse.rjust(min_length, "\x00")
+  end
+
+
+  # Converts a number to an array of place values, e.g. 9 => [8, 0, 0, 1]
+  def number_to_place_value_array(number)
+    assert_non_negative(number)
+    array = []
+    bit_value = 1
+    while number > 0
+      array << ((number & 1 == 1) ? bit_value : 0)
+      number >>= 1
+      bit_value <<= 1
+    end
+    array.reverse
+  end
+
+
+  # Converts from a value array to a number, e.g. [8, 0, 0, 1] => 9
+  def place_value_array_to_number(place_value_array)
+    place_value_array.inject(&:+)
+  end
+
+
+  # Converts a number to an array of bit values, e.g. 9 => [1, 0, 0, 1]
+  def number_to_bit_array(number)
+    assert_non_negative(number)
+    array = []
+    while number > 0
+      array << (number & 1)
+      number >>= 1
+    end
+    array.reverse
+  end
+
+
+  # Converts an array of bit values, e.g. [1, 0, 0, 1], to a number, e.g. 9
+  def bit_array_to_number(bit_array)
+    return nil if bit_array.empty?
+    multiplier = 1
+    bit_array.reverse.inject(0) do |result, n|
+      result += n * multiplier
+      multiplier *= 2
+      result
+    end
+  end
+
+
+  # Converts a number to a sparse array containing bit positions that are set/true/1.
+  # Note that these are bit positions, e.g. 76543210, and not bit column values
+  # such as 128/64/32/16/8/4/2/1.
+  def number_to_set_bit_positions_array(number)
+    assert_non_negative(number)
+    array = []
+    position = 0
+    while number > 0
+      array << position if number & 1 == 1
+      position += 1
+      number >>= 1
+    end
+    array
+  end
+
+
+  # Converts an array of bit position numbers to a numeric value, e.g. [0, 2] => 5
+  def set_bit_position_array_to_number(position_array)
+    return nil if position_array.empty?
+    position_array.inject(0) do |result, n|
+      result += 2 ** n
+    end
+  end
+
+
+  # Converts a binary string to an array of bit values, e.g. "\x0C" => [1, 1, 0, 0]
+  def binary_string_to_bit_array(string)
+    number = binary_string_to_number(string)
+    number_to_bit_array(number)
+  end
+
+
+  # If number is negative, raises an ArgumentError; else does nothing.
+  def assert_non_negative(number)
+    unless number.is_a?(Integer) && number >= 0
+      raise ArgumentError.new(
+          "Parameter must be a nonnegative Integer (Fixnum, Bignum) " +
+          "but is #{number.inspect} (a #{number.class})")
+    end
+  end
+end
+end
+end

data/lib/trick_bag/numeric/bitmap.rb

@@ -1,14 +1,15 @@
 require 'forwardable'
+require_relative 'bit_mapping'
 
 module TrickBag
 module Numeric
 
 
-# Provides class methods for converting between the various representations
-# of a bitmap: number, binary encoded string, array, and sparse array.
-#
-# An instance can be created that will hold on to bitmap data and be used
+# Instances of this class can be created that will hold on to bitmap data and be used
 # to test bits and convert to other formats.
+#
+# Where an array is used to represent bits, the first element (#0) will be the
+# high bit and the last element will be the low (1's column) bit.
 class Bitmap
 
   extend Forwardable
@@ -16,12 +17,14 @@ class Bitmap
   # This is the internal representation of the bitmap value:
   attr_reader :number
 
+  # Some instance methods can be delegated to this number:
   [:&, :|, :^, :hash].each do |method_name|
     def_delegator :@number, method_name
   end
 
+  # Set a new value to number, validating first that it is nonnegative.
   def number=(new_number)
-    self.assert_nonnegative(new_number)
+    self.assert_non_negative(new_number)
     @number = new_number
   end
 
@@ -35,162 +38,58 @@ class Bitmap
   private_class_method :new
 
 
-  # Class methods for converting between representations:
-
-  # Converts from a binary string to a number, e.g. "\x01\x00" => 256
-  def self.binary_string_to_number(string)
-    string = string.clone.force_encoding(Encoding::ASCII_8BIT)
-    string.bytes.inject(0) do |number, byte|
-      number * 256 + byte.ord
-    end
-  end
-
-
-  # Converts a number to a binary encoded string, e.g. 256 => "\x01\x00"
-  def self.number_to_binary_string(number, min_length = 0)
-    assert_nonnegative(number)
-    binary_string = ''.force_encoding(Encoding::ASCII_8BIT)
-
-    while number > 0
-      byte_value = number & 0xFF
-      binary_string << byte_value
-      number >>= 8
-    end
-
-    binary_string.reverse.rjust(min_length, "\x00")
-  end
-
-
-  # Converts a number to an array of place values, e.g. 9 => [8, 0, 0, 1]
-  def self.number_to_value_array(number)
-    assert_nonnegative(number)
-    array = []
-    bit_value = 1
-    while number > 0
-      array << ((number & 1 == 1) ? bit_value : 0)
-      number >>= 1
-      bit_value <<= 1
-    end
-    array.reverse
-  end
-
-
-  # Converts from a value array to a number, e.g. [8, 0, 0, 1] => 9
-  def self.value_array_to_number(value_array)
-    value_array.inject(&:+)
-  end
-
-
-  # Converts a number to an array of bit values, e.g. 9 => [1, 0, 0, 1]
-  def self.number_to_bit_array(number)
-    assert_nonnegative(number)
-    array = []
-    while number > 0
-      array << (number & 1)
-      number >>= 1
-    end
-    array.reverse
-  end
-
-
-  # Converts an array of bit values, e.g. [1, 0, 0, 1], to a number, e.g. 9
-  def self.bit_array_to_number(bit_array)
-    return nil if bit_array.empty?
-    multiplier = 1
-    bit_array.inject(0) do |result, n|
-      result += n * multiplier
-      multiplier *= 2
-      result
-    end
-  end
-
-
-  # Converts a number to a sparse array containing bit positions that are set/true/1.
-  # Note that these are bit positions, e.g. 76543210, and not bit column values
-  # such as 128/64/32/16/8/4/2/1.
-  def self.number_to_set_bit_positions_array(number)
-    assert_nonnegative(number)
-    array = []
-    position = 0
-    while number > 0
-      array << position if number & 1 == 1
-      position += 1
-      number >>= 1
-    end
-    array
-  end
-
-
-  # Converts an array of bit position numbers to a numeric value, e.g. [0, 2] => 5
-  def self.set_bit_position_array_to_number(position_array)
-    return nil if position_array.empty?
-    position_array.inject(0) do |result, n|
-      result += 2 ** n
-    end
-  end
-
-
-  def self.binary_string_to_bit_value_array(string)
-    number = binary_string_to_number(string)
-    number_to_bit_array(number)
-  end
-
   # Class methods to create instances from the various representation types
-  # handled in the class methods above:
+  # handled in the BitMapping module's methods.
 
+  # Creates an instance from a nonnegative number.
   def self.from_number(number)
     new(number)
   end
 
+  # Creates an instance from a binary string (e.g. "\x0C").
   def self.from_binary_string(string)
-    new(binary_string_to_number(string))
+    new(BitMapping.binary_string_to_number(string))
   end
 
-  def self.from_value_array(array)
-    new(value_array_to_number(array))
+  # Creates an instance from a value array (e.g. [8, 0, 0, 1])
+  def self.from_place_value_array(array)
+    new(BitMapping.place_value_array_to_number(array))
   end
 
+  # Creates an instance from a bit array (e.g. [1, 0, 0, 1])
   def self.from_bit_array(array)
-    new(bit_array_to_number(array))
+    new(BitMapping.bit_array_to_number(array))
   end
 
+  # Creates an instance from an array of positions for the bits that are set (e.g. [0, 3])
   def self.from_set_bit_position_array(array)
-    new(set_bit_position_array_to_number(array))
-  end
-
-  def self.from_number(number)
-    new(number)
-  end
-
-
-  def self.assert_nonnegative(number)
-    unless number.is_a?(Integer) && number >= 0
-      raise ArgumentError.new(
-          "Parameter must be a nonnegative Integer (Fixnum, Bignum) " +
-          "but is #{number.inspect} (a #{number.class})")
-    end
+    new(BitMapping.set_bit_position_array_to_number(array))
   end
 
+  # Instance methods to convert the data to the various representation types:
 
+  # Returns the instance's value as a binary string (e.g. "\x0C")
   def to_binary_string(min_length = 0)
-    self.class.number_to_binary_string(number, min_length)
+    BitMapping.number_to_binary_string(number, min_length)
   end
 
-  def to_value_array
-    self.class.number_to_value_array(number)
+  # Returns the instance's value as an array of bit column values (e.g. [8, 0, 0, 1])
+  def to_place_value_array
+    BitMapping.number_to_place_value_array(number)
   end
 
+  # Returns the instance's value as an array of bit column place values (e.g. [8, 0, 0, 1])
   def to_bit_array
-    self.class.number_to_bit_array(number)
+    BitMapping.number_to_bit_array(number)
   end
 
+  # Returns the instance's value as an array of positions for the bits that are set (e.g. [0, 3])
   def to_set_bit_position_array
-    self.class.number_to_set_bit_positions_array(number)
+    BitMapping.number_to_set_bit_positions_array(number)
   end
 
-
   def initialize(number)
-    self.class.assert_nonnegative(number)
+    BitMapping.assert_non_negative(number)
     @number = number
   end
 
@@ -200,5 +99,3 @@ class Bitmap
 end
 end
 end
-
-

data/lib/trick_bag/version.rb

@@ -1,3 +1,3 @@
 module TrickBag
-  VERSION = "0.56.0"
+  VERSION = "0.57.0"
 end

data/spec/trick_bag/numeric/bit_mapping_spec.rb

@@ -0,0 +1,142 @@
+require_relative '../../spec_helper'
+
+require 'trick_bag/numeric/bit_mapping'
+
+module TrickBag
+module Numeric
+
+
+describe BitMapping do
+
+
+  context '.binary_string_to_number' do
+
+    it 'computes byte values correctly' do
+      expect(BitMapping.binary_string_to_number("\xFF")).to eq(255)
+      expect(BitMapping.binary_string_to_number("\x0D")).to eq(13)
+    end
+
+    it 'considers the left-most byte most significant' do
+      expect(BitMapping.binary_string_to_number("\x01\x00")).to eq(256)
+    end
+
+    # Unspecified encoding results in UTF-8 anyway, but this makes it explicit:
+    it 'correctly handles non-ASCII_8BIT strings' do
+      expect(BitMapping.binary_string_to_number("\x01\x00".force_encoding(Encoding::UTF_8))).to eq(256)
+    end
+  end
+end
+
+
+context '.number_to_binary_string' do
+
+  specify '256 => "\x01\00"' do
+    expect(BitMapping.number_to_binary_string(256)).to eq("\x01\x00")
+  end
+
+  specify 'a negative number should result in an error' do
+    expect { BitMapping.number_to_binary_string(-1) }.to raise_error(ArgumentError)
+  end
+
+  specify 'when requested, zero padding will left pad with zeros' do
+    expect(BitMapping.number_to_binary_string(256, 8)).to eq("#{"\x00" * 6}\x01\x00")
+  end
+end
+
+
+context '.number_to_place_value_array' do
+
+  specify '9 => [8, 0, 0, 1]' do
+    expect(BitMapping.number_to_place_value_array(9)).to eq([8, 0, 0, 1])
+  end
+
+  specify '256 => [256] + ([0] * 8)' do
+    expect(BitMapping.number_to_place_value_array(256)).to eq([256] + [0] * 8)
+  end
+
+  specify 'a negative number should result in an error' do
+    expect { BitMapping.number_to_place_value_array(-1) }.to raise_error(ArgumentError)
+  end
+end
+
+context '.place_value_array_to_number' do
+
+  specify '[8, 0, 0, 1] => 9' do
+    expect(BitMapping.place_value_array_to_number([8, 0, 0, 1])).to eq(9)
+  end
+
+  specify '[] => nil' do
+    expect(BitMapping.place_value_array_to_number([])).to eq(nil)
+  end
+end
+
+context '.bit_array_to_number' do
+
+  specify '[1, 1, 0, 1] => 13' do
+    expect(BitMapping.bit_array_to_number([1, 1, 0, 1])).to eq(13)
+  end
+
+  specify '[] => nil' do
+    expect(BitMapping.bit_array_to_number([])).to eq(nil)
+  end
+end
+
+
+context '.number_to_bit_array' do
+
+  specify '13 => [1, 1, 0, 1]' do
+    expect(BitMapping.number_to_bit_array(13)).to eq([1, 1, 0, 1])
+  end
+
+  specify '256 => [1] + ([0] * 8)' do
+    expect(BitMapping.number_to_bit_array(256)).to eq([1] + [0] * 8)
+  end
+
+  specify 'a negative number should result in an error' do
+    expect { BitMapping.number_to_bit_array(-1) }.to raise_error(ArgumentError)
+  end
+end
+
+
+context '.binary_string_to_bit_array' do
+  it 'computes byte values correctly' do
+    expect(BitMapping.binary_string_to_bit_array("\xFF")).to eq([1] * 8)
+    expect(BitMapping.binary_string_to_bit_array("\x0D")).to eq([1, 1, 0, 1])
+  end
+
+  it 'considers the left-most byte most significant' do
+    expect(BitMapping.binary_string_to_bit_array("\x01\x00")).to eq([1] + [0] * 8)
+  end
+
+  # Unspecified encoding results in UTF-8 anyway, but this makes it explicit:
+  it 'correctly handles non-ASCII_8BIT strings' do
+    actual = BitMapping.binary_string_to_bit_array("\x01\x00".force_encoding(Encoding::UTF_8))
+    expect(actual).to eq([1] + [0] * 8)
+  end
+end
+
+
+context '.number_to_set_bit_positions_array' do
+
+  specify '9 => [0, 3]' do
+    expect(BitMapping.number_to_set_bit_positions_array(9)).to eq([0, 3])
+  end
+
+  specify 'a negative number should result in an error' do
+    expect { BitMapping.number_to_set_bit_positions_array(-1) }.to raise_error(ArgumentError)
+  end
+end
+
+
+context '.set_bit_position_array_to_number' do
+
+  specify '[0, 8] => 256' do
+    expect(BitMapping.set_bit_position_array_to_number([0, 8])).to eq(257)
+  end
+
+  specify '[] => nil' do
+    expect(BitMapping.set_bit_position_array_to_number([])).to eq(nil)
+  end
+end
+end
+end

data/spec/trick_bag/numeric/bitmap_spec.rb

@@ -6,141 +6,11 @@ module TrickBag
 module Numeric
 
 
-  describe Bitmap do
+describe Bitmap do
 
 
-    specify 'the constructor should not permit being explicitly called outside the class' do
-      expect(-> { Bitmap.new }).to raise_error
-    end
-
-
-    context '.binary_string_to_number' do
-
-      it 'computes byte values correctly' do
-        expect(Bitmap.binary_string_to_number("\xFF")).to eq(255)
-        expect(Bitmap.binary_string_to_number("\x0D")).to eq(13)
-      end
-
-      it 'considers the left-most byte most significant' do
-        expect(Bitmap.binary_string_to_number("\x01\x00")).to eq(256)
-      end
-
-      # Unspecified encoding results in UTF-8 anyway, but this makes it explicit:
-      it 'correctly handles non-ASCII_8BIT strings' do
-        expect(Bitmap.binary_string_to_number("\x01\x00".force_encoding(Encoding::UTF_8))).to eq(256)
-      end
-    end
-  end
-
-
-  context '.number_to_binary_string' do
-
-    specify '256 => "\x01\00"' do
-      expect(Bitmap.number_to_binary_string(256)).to eq("\x01\x00")
-    end
-
-    specify 'a negative number should result in an error' do
-      expect { Bitmap.number_to_binary_string(-1) }.to raise_error(ArgumentError)
-    end
-
-    specify 'when requested, zero padding will left pad with zeros' do
-      expect(Bitmap.number_to_binary_string(256, 8)).to eq("#{"\x00" * 6}\x01\x00")
-    end
-  end
-
-
-  context '.number_to_value_array' do
-
-    specify '9 => [8, 0, 0, 1]' do
-      expect(Bitmap.number_to_value_array(9)).to eq([8, 0, 0, 1])
-    end
-
-    specify '256 => [256] + ([0] * 8)' do
-      expect(Bitmap.number_to_value_array(256)).to eq([256] + [0] * 8)
-    end
-
-    specify 'a negative number should result in an error' do
-      expect { Bitmap.number_to_value_array(-1) }.to raise_error(ArgumentError)
-    end
-  end
-
-  context '.value_array_to_number' do
-
-    specify '[8, 0, 0, 1] => 9' do
-      expect(Bitmap.value_array_to_number([8, 0, 0, 1])).to eq(9)
-    end
-
-    specify '[] => nil' do
-      expect(Bitmap.value_array_to_number([])).to eq(nil)
-    end
-  end
-
-  context '.bit_array_to_number' do
-
-    specify '[1, 0, 0, 1] => 9' do
-      expect(Bitmap.bit_array_to_number([1, 0, 0, 1])).to eq(9)
-    end
-
-    specify '[] => nil' do
-      expect(Bitmap.bit_array_to_number([])).to eq(nil)
-    end
-  end
-
-
-  context '.number_to_bit_array' do
-
-    specify '9 => [1, 0, 0, 1]' do
-      expect(Bitmap.number_to_bit_array(9)).to eq([1, 0, 0, 1])
-    end
-
-    specify '256 => [1] + ([0] * 8)' do
-      expect(Bitmap.number_to_bit_array(256)).to eq([1] + [0] * 8)
-    end
-
-    specify 'a negative number should result in an error' do
-      expect { Bitmap.number_to_bit_array(-1) }.to raise_error(ArgumentError)
-    end
-  end
-
-
-  context '.binary_string_to_bit_value_array' do
-    it 'computes byte values correctly' do
-      expect(Bitmap.binary_string_to_bit_value_array("\xFF")).to eq([1] * 8)
-      expect(Bitmap.binary_string_to_bit_value_array("\x0D")).to eq([1,1,0,1])
-    end
-
-    it 'considers the left-most byte most significant' do
-      expect(Bitmap.binary_string_to_bit_value_array("\x01\x00")).to eq([1] + [0] * 8)
-    end
-
-    # Unspecified encoding results in UTF-8 anyway, but this makes it explicit:
-    it 'correctly handles non-ASCII_8BIT strings' do
-      expect(Bitmap.binary_string_to_bit_value_array("\x01\x00".force_encoding(Encoding::UTF_8))).to eq([1] + [0] * 8)
-    end
-  end
-
-
-  context '.number_to_set_bit_positions_array' do
-
-    specify '9 => [0, 3]' do
-      expect(Bitmap.number_to_set_bit_positions_array(9)).to eq([0, 3])
-    end
-
-    specify 'a negative number should result in an error' do
-      expect { Bitmap.number_to_set_bit_positions_array(-1) }.to raise_error(ArgumentError)
-    end
-  end
-
-
-  context '.set_bit_position_array_to_number' do
-
-    specify '[0, 8] => 256' do
-      expect(Bitmap.set_bit_position_array_to_number([0, 8])).to eq(257)
-    end
-
-    specify '[] => nil' do
-      expect(Bitmap.set_bit_position_array_to_number([])).to eq(nil)
-    end
+  specify 'the constructor should not permit being explicitly called outside the class' do
+    expect(-> { Bitmap.new }).to raise_error
   end
 
 
@@ -154,12 +24,12 @@ module Numeric
       expect(Bitmap.from_binary_string("\x01\x00").number).to eq(256)
     end
 
-    specify 'from_value_array' do
-      expect(Bitmap.from_value_array([8, 0, 0, 1]).number).to eq(9)
+    specify 'from_place_value_array' do
+      expect(Bitmap.from_place_value_array([8, 0, 0, 1]).number).to eq(9)
     end
 
     specify 'from_bit_array' do
-      expect(Bitmap.from_bit_array([1, 0, 0, 1]).number).to eq(9)
+      expect(Bitmap.from_bit_array([1, 1, 0, 1]).number).to eq(13)
     end
 
     specify 'from_set_bit_position_array' do
@@ -167,6 +37,7 @@ module Numeric
     end
   end
 
+
   context 'test output methods' do
 
     specify 'to_binary_string' do
@@ -174,10 +45,9 @@ module Numeric
       expect(bitmap.to_binary_string).to eq("\x01\x02")
     end
 
-    specify 'to_value_array' do
+    specify 'to_place_value_array' do
       bitmap = Bitmap.from_number(258)
-      # expect(bitmap.to_value_array).to eq([0, 2, 0, 0, 0, 0, 0, 0, 256])
-      expect(bitmap.to_value_array).to eq([256, 0, 0, 0, 0, 0, 0, 2, 0])
+      expect(bitmap.to_place_value_array).to eq([256, 0, 0, 0, 0, 0, 0, 2, 0])
     end
 
     specify 'to_bit_array' do
@@ -204,7 +74,6 @@ module Numeric
     specify '3 ^ 2 => 1' do
       expect(Bitmap.from_number(3) ^ 2).to eq(1)
     end
-
   end
 
   context 'hash, ==' do
@@ -220,6 +89,6 @@ module Numeric
       expect(Bitmap.from_number(1234).hash).to eq(Bitmap.from_number(1234).hash)
     end
   end
-  end
 end
-
+end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trick_bag
 version: !ruby/object:Gem::Version
-  version: 0.56.0
+  version: 0.57.0
 platform: ruby
 authors:
 - Keith Bennett
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-15 00:00:00.000000000 Z
+date: 2015-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: os
@@ -110,6 +110,7 @@ files:
 - lib/trick_bag/io/temp_files.rb
 - lib/trick_bag/io/text_mode_status_updater.rb
 - lib/trick_bag/meta/classes.rb
+- lib/trick_bag/numeric/bit_mapping.rb
 - lib/trick_bag/numeric/bitmap.rb
 - lib/trick_bag/numeric/multi_counter.rb
 - lib/trick_bag/numeric/start_and_max.rb
@@ -138,6 +139,7 @@ files:
 - spec/trick_bag/io/temp_files_spec.rb
 - spec/trick_bag/io/text_mode_status_updater_spec.rb
 - spec/trick_bag/meta/classes_spec.rb
+- spec/trick_bag/numeric/bit_mapping_spec.rb
 - spec/trick_bag/numeric/bitmap_spec.rb
 - spec/trick_bag/numeric/multi_counter_spec.rb
 - spec/trick_bag/numeric/start_and_max_spec.rb
@@ -190,6 +192,7 @@ test_files:
 - spec/trick_bag/io/temp_files_spec.rb
 - spec/trick_bag/io/text_mode_status_updater_spec.rb
 - spec/trick_bag/meta/classes_spec.rb
+- spec/trick_bag/numeric/bit_mapping_spec.rb
 - spec/trick_bag/numeric/bitmap_spec.rb
 - spec/trick_bag/numeric/multi_counter_spec.rb
 - spec/trick_bag/numeric/start_and_max_spec.rb