bitz 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b36def536acce5c5af37285db45e3b0444b2b3890c2aa9d7545125c26845eef
-  data.tar.gz: df6bbbf2e16954e338829eb063e1d3a580d98bed6099dda029313d5e0b393ad2
+  metadata.gz: c1e3269dd93770fce52222c370e51af1cc2e4273042a57c3bf5f9414728fe4ed
+  data.tar.gz: 66c36eca3388687c6c6cfdf17c7c65c655f0091ce991eafe3300adc7e8a82696
 SHA512:
-  metadata.gz: e065f3bedf8d3ca9c942e4aa71d36e4c4c538faad62b1b85c05b118f22cf72c1581fda586f144e0f7df6f41c3854262a70f2b9018cc72230edbec70ae55cf90e
-  data.tar.gz: 3852e5dde0f66a80aabd687210ad0522089f00239930d2e42ce95a9f58ae7bde4b8b6ae6030a6944516b85d0921e50eec40aab8306737e14ae8e6eb77feef23c
+  metadata.gz: cbc7891242609a62513b84274b061ce56d31e35e50b28fadd8eaff9c4e8e54a553e3fa68965cee9afe97f1caff837b949b6d3cdc67ae50067d311c67283eef12
+  data.tar.gz: 10bb83437c2a7a37312c21f459c9326d954358173289cc639c405d5299c965764b5bca5fa7cdb4abf6af978db43a84eea79cf8302d9b43c7d3f69738f7467426

data/README.md

@@ -6,7 +6,7 @@ A pure Ruby, JIT-friendly dynamic bitset implementation
 
 - **Dynamic resizing**: Automatically grows buffer as needed when setting bits
 - **Memory efficient**: Uses packed byte arrays for optimal memory usage
-- **Ruby-idiomatic**: Standard operators (`&`, `|`, `!`) and method chaining support
+- **Ruby-idiomatic**: Standard operators (`&`, `|`, `~`) and method chaining support
 - **0-indexed**: Bit positions start from 0, following standard conventions
 
 ## Installation
@@ -127,7 +127,7 @@ intersection_result = set1 & set2
 # set1 and set2 are unchanged
 
 # Complement/NOT (creates new bitset with all bits flipped)
-complement_result = !set1
+complement_result = ~set1
 # complement_result has all bits flipped - bits 0, 3, 4, 5, ..., 63 are set
 # set1 is unchanged
 ```
@@ -174,7 +174,7 @@ copy.set?(5)       # => true (copy has original's bits)
 
 - `|(other)` - Union operator (returns new bitset)
 - `&(other)` - Intersection operator (returns new bitset)
-- `!` - Complement/NOT operator (returns new bitset with all bits flipped)
+- `~` - Complement/NOT operator (returns new bitset with all bits flipped)
 
 ### Copying
 

data/lib/bitz/set.rb

@@ -168,7 +168,7 @@ module Bitz
     # The original bitset is not modified.
     #
     # @return [Bitz::Set] a new bitset with all bits flipped
-    def !
+    def ~
       dup.toggle_all
     end
 
@@ -213,6 +213,93 @@ module Bitz
       }
     end
 
+    # Returns an ASCII art representation of the bitset.
+    # Displays bit indices (in hexadecimal) on top and bit values on bottom in a table format.
+    # Groups bits by bytes (8 bits) with visual separators.
+    #
+    # @param width [Integer] number of bits to display per row (default: 64)
+    # @param start [Integer] starting bit position to display (default: 0)
+    # @return [String] formatted ASCII art table
+    # @example
+    #   bitset = Bitz::Set.new(16)
+    #   bitset.set(1)
+    #   bitset.set(5)
+    #   bitset.set(10)
+    #   puts bitset.to_ascii(width: 16)
+    #   # Output:
+    #   # Bit Index: |  0  1  2  3  4  5  6  7 |  8  9  a  b  c  d  e  f |
+    #   # Bit Value: |  0  1  0  0  0  1  0  0 |  0  0  1  0  0  0  0  0 |
+    #   #            +------------------------+------------------------+
+    def to_ascii width: 64, start: 0
+      lines = []
+      end_bit = [start + width, capacity].min
+      total_bits = end_bit - start
+
+      return "Empty bitset\n" if total_bits <= 0
+
+      # Calculate number of byte groups
+      byte_groups = (total_bits + 7) / 8
+
+      # Build index line
+      index_line = "Bit Index: "
+      value_line = "Bit Value: "
+      border_line = "           "
+
+      byte_groups.times do |group|
+        group_start = start + (group * 8)
+        group_end = [group_start + 8, end_bit].min
+
+        index_line += "|"
+        value_line += "|"
+        border_line += "+"
+
+        (group_start...group_end).each do |bit_pos|
+          index_line += sprintf("%3x", bit_pos)
+          value_line += sprintf("%3d", set?(bit_pos) ? 1 : 0)
+          border_line += "---"
+        end
+
+        # Pad incomplete byte groups
+        if group_end - group_start < 8
+          padding = 8 - (group_end - group_start)
+          index_line += "   " * padding
+          value_line += "   " * padding
+          border_line += "---" * padding
+        end
+
+        index_line += " "
+        value_line += " "
+        border_line += "-"
+      end
+
+      index_line += "|\n"
+      value_line += "|\n"
+      border_line += "+\n"
+
+      lines << index_line
+      lines << value_line
+      lines << border_line
+
+      # Handle multi-row output for large bitsets
+      if end_bit < capacity && width < capacity
+        remaining = capacity - end_bit
+        if remaining > 0
+          lines << to_ascii(width: width, start: end_bit)
+        end
+      end
+
+      lines.join
+    end
+
+    # Ruby's pp library integration.
+    # Called by pp when pretty printing this object.
+    #
+    # @param pp [PP] the pretty printer object
+    # @return [void]
+    def pretty_print pp
+      pp.text(to_ascii(width: 32))
+    end
+
     # Compares this bitset with another for equality.
     # Returns false if the bitsets have different capacities.
     # Otherwise compares all bytes for exact equality.

data/lib/bitz/version.rb

@@ -1,3 +1,3 @@
 module Bitz
-  VERSION = "1.0.0"
+  VERSION = "2.0.0"
 end

data/test/bitz_set_test.rb

@@ -411,11 +411,11 @@ class BitzSetTest < Minitest::Test
     assert_equal 3, result.count # bits 1, 2, 3 are set
   end
 
-  def test_bang_basic
+  def test_tilde_basic
     @set.set(5)
     @set.set(10)
 
-    result = !@set
+    result = ~@set
 
     # Original bitset unchanged
     assert @set.set?(5)
@@ -432,8 +432,8 @@ class BitzSetTest < Minitest::Test
     assert_equal 62, result.count # 64 - 2 set bits
   end
 
-  def test_bang_empty_set
-    result = !@set
+  def test_tilde_empty_set
+    result = ~@set
 
     # Original bitset unchanged (empty)
     assert_equal 0, @set.count
@@ -443,10 +443,10 @@ class BitzSetTest < Minitest::Test
     assert_equal 64, result.count
   end
 
-  def test_bang_full_set
+  def test_tilde_full_set
     @set.set_all
 
-    result = !@set
+    result = ~@set
 
     # Original bitset unchanged (full)
     assert_equal 64, @set.count
@@ -456,20 +456,20 @@ class BitzSetTest < Minitest::Test
     assert_equal 0, result.count
   end
 
-  def test_bang_returns_new_instance
-    result = !@set
+  def test_tilde_returns_new_instance
+    result = ~@set
 
     refute_same @set, result
     assert_instance_of Bitz::Set, result
     assert_equal @set.capacity, result.capacity
   end
 
-  def test_bang_double_negation
+  def test_tilde_double_negation
     @set.set(5)
     @set.set(10)
     @set.set(20)
 
-    result = !!@set
+    result = ~~@set
 
     # Double negation should restore original
     assert result.set?(5)
@@ -484,12 +484,12 @@ class BitzSetTest < Minitest::Test
     assert_equal 3, @set.count
   end
 
-  def test_bang_specific_capacity
+  def test_tilde_specific_capacity
     small_set = Bitz::Set.new(16)
     small_set.set(3)
     small_set.set(7)
 
-    result = !small_set
+    result = ~small_set
 
     # Check capacity preserved
     assert_equal 16, result.capacity
@@ -719,4 +719,169 @@ class BitzSetTest < Minitest::Test
     copy.set(30)
     refute_equal @set, copy
   end
+
+  def test_to_ascii_basic
+    @set.set(1)
+    @set.set(5)
+    @set.set(10)
+
+    output = @set.to_ascii(width: 16)
+
+    # Should contain bit indices
+    assert_match(/Bit Index:/, output)
+    assert_match(/Bit Value:/, output)
+
+    # Should contain specific bit positions
+    assert_match(/\s+1\s+/, output)
+    assert_match(/\s+5\s+/, output)
+    assert_match(/\s+10\s+/, output)
+
+    # Should have proper formatting with separators
+    assert_match(/\|/, output)
+    assert_match(/\+/, output)
+  end
+
+  def test_to_ascii_empty_set
+    output = @set.to_ascii(width: 16)
+
+    # Should show all zeros in the value line
+    lines = output.split("\n")
+    value_line = lines.find { |line| line.start_with?("Bit Value:") }
+
+    # Should contain only 0s in the value line (no 1s)
+    assert_match(/0/, value_line)
+    refute_match(/\|\s+[^0\s]/, value_line) # No non-zero values between separators
+
+    assert_match(/Bit Index:/, output)
+    assert_match(/Bit Value:/, output)
+  end
+
+  def test_to_ascii_full_set
+    small_set = Bitz::Set.new(16)
+    small_set.set_all
+
+    output = small_set.to_ascii(width: 16)
+
+    # Should show all ones for a full set
+    lines = output.split("\n")
+    value_line = lines.find { |line| line.start_with?("Bit Value:") }
+
+    # Count the 1s in the value line (look for the pattern "  1")
+    ones_count = value_line.scan(/\s+1(?=\s|\|)/).length
+    assert_equal 16, ones_count
+  end
+
+  def test_to_ascii_custom_width
+    @set.set(2)
+    @set.set(10)
+    @set.set(18)
+
+    # Test with 8-bit width
+    output = @set.to_ascii(width: 8)
+    lines = output.split("\n")
+
+    # Should have multiple rows for bits beyond width
+    assert_operator lines.length, :>, 3
+
+    # First row should contain bits 0-7
+    assert_match(/\s+2\s+/, lines[0])
+    refute_match(/\s+a\s+/, lines[0])  # 10 in hex should not be in first row
+  end
+
+  def test_to_ascii_start_offset
+    @set.set(10)
+    @set.set(15)
+    @set.set(20)
+
+    # Start from bit 8
+    output = @set.to_ascii(width: 16, start: 8)
+
+    # Should contain bits 8-23 (in hex: 8, a=10, f=15, 14=20)
+    assert_match(/\s+a\s+/, output)  # 10 in hex
+    assert_match(/\s+f\s+/, output)  # 15 in hex
+    assert_match(/\s+14\s+/, output) # 20 in hex
+
+    # Should not contain bits 0-7 in the index line
+    lines = output.split("\n")
+    index_line = lines[0]
+    refute_match(/\|\s+0\s+/, index_line)
+    refute_match(/\|\s+7\s+/, index_line)
+  end
+
+  def test_to_ascii_byte_grouping
+    @set.set(7)  # End of first byte
+    @set.set(8)  # Start of second byte
+
+    output = @set.to_ascii(width: 16)
+
+    # Should have proper byte separators
+    separators = output.scan(/\|/).length
+    assert_operator separators, :>, 2 # At least opening and closing separators
+
+    # Should group by 8-bit boundaries
+    lines = output.split("\n")
+    index_line = lines[0]
+
+    # Should have bit 7 and 8 in different groups visually
+    assert_match(/\s+7\s+.*\|\s+8\s+/, index_line)
+  end
+
+  def test_to_ascii_large_indices
+    large_set = Bitz::Set.new(128)
+    large_set.set(100)
+    large_set.set(127)
+
+    output = large_set.to_ascii(width: 32, start: 96)
+
+    # Should handle 2-digit hex indices correctly (100 = 0x64, 127 = 0x7f)
+    assert_match(/64/, output) # 100 in hex
+    assert_match(/7f/, output) # 127 in hex
+
+    # Should maintain alignment
+    lines = output.split("\n")
+    index_line = lines[0]
+    value_line = lines[1]
+
+    # Lines should be similar length (within a few chars for borders)
+    assert_in_delta index_line.length, value_line.length, 5
+  end
+
+  def test_to_ascii_edge_cases
+    # Single bit set
+    single_set = Bitz::Set.new(8)
+    single_set.set(0)
+
+    output = single_set.to_ascii(width: 8)
+    assert_match(/Bit Index:/, output)
+    assert_match(/Bit Value:/, output)
+
+    # Empty range
+    empty_output = @set.to_ascii(width: 0)
+    assert_equal "Empty bitset\n", empty_output
+
+    # Start beyond capacity
+    beyond_output = @set.to_ascii(start: 1000)
+    assert_equal "Empty bitset\n", beyond_output
+  end
+
+  def test_pp_integration
+    require 'pp'
+    require 'stringio'
+
+    @set.set(1)
+    @set.set(5)
+    @set.set(10)
+
+    # Capture pp output
+    output = StringIO.new
+    PP.pp(@set, output)
+    result = output.string
+
+    # Should contain the ASCII art format
+    assert_match(/Bit Index:/, result)
+    assert_match(/Bit Value:/, result)
+    assert_match(/\s+1\s+/, result)  # 1 in hex is still 1
+    assert_match(/\s+5\s+/, result)  # 5 in hex is still 5
+    assert_match(/\s+a\s+/, result)  # 10 in hex is 'a'
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitz
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Aaron Patterson