pure_jpeg 0.3.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c252d678f3b8c916a2430b802569dc5099a19636359e9864637ed9fe01c90a3
-  data.tar.gz: 8feec524d8c41ca74be1e9bc47cf41b762cb14dc3500dc03c9240680d5877933
+  metadata.gz: 81f59b74746cbb7c575aa22e250667b8b126a542613833f2e45b57685fed02c0
+  data.tar.gz: 87fb8c2b6dd5035d93c4326a37fac8e43ade2af88f92a3dd1f7761960f675126
 SHA512:
-  metadata.gz: c8d26b4d4bed6da87f048036b06bc80eddd6c7ff8318032fb9cfccc15f5aea961e62fefe9965dde33c3d33cea5b611b4c2f6cb2397efa2f43effd8eb456fcf93
-  data.tar.gz: 63a9fe6bdf1136c8ea6c8e38a6b6641e6be2975fef4fea9394f0b48de22b01862996a87557b5c0bf7d7915020630f08c9285ebf8b8e8482f38f228c31b2d08e7
+  metadata.gz: 930f8db2b6ab86080c115e77f56e0918853e455dbcd18129daa5aaca77715df198a502010ae218275799e8b364f115232e11139ffcb42ca981c57478ef12b45b
+  data.tar.gz: 54c50b3a2316c6fa0b9db38fcabdd589bcc17d2edfeff653a28ec4054a72c2b5615eef5fd9f123fb31ce56448864495f49942bf63c4536d00c21fd4e7a6eb4f2

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.4.0
+
+Performance:
+
+- Faster Huffman coding and decoding, with scan references resolved once per scan
+- Combined quantization and zigzag passes, including direct reconstruction from progressive coefficient buffers
+- Color encoding downsamples chroma two rows at a time instead of allocating full-resolution chroma images
+- Block-based `RawSource` construction avoids allocating pixels that would immediately be replaced
+- Measured encode/decode times reduced by roughly 12–28% on Ruby 4.0.2 with YJIT; baseline decode allocations fell from 76,994 to 114 on the bundled 1024x1024 benchmark
+- Encoding array storage allocated for that image fell from 29.4 MB to 12.6 MB, with encoded bytes and decoded pixels preserved in equivalence checks
+
+Compatibility and testing:
+
+- Experimental Spinel compatibility, tested at revision `7f08abd9`, with benchmarks and a `rake test:spinel` proof-of-concept runner
+- Spinel currently passes seven of the eight selected RawSource tests; the remaining test fails because `respond_to?` is unavailable on its pixel struct. See `test/SPINEL.md` for details
+- Added regression tests for quantization rounding, progressive coefficient offsets, and chroma downsampling edges
+- Updated performance comparisons for CRuby, TruffleRuby, JRuby, and Spinel
+
 ## 0.3.3
 
 New features:

data/README.md

@@ -6,7 +6,7 @@
 
 Convert PNG or other pixel data to JPEG. Or the other way! Implements baseline JPEG encoding (DCT, Huffman, 4:2:0 chroma subsampling) and decodes both baseline and progressive JPEGs. Exposes a variety of encoding options to adjust parts of the JPEG pipeline not normally available (I needed this to recreate the JPEG compression styles of older digital cameras - don't ask..)
 
-It works on CRuby 3.0+, TruffleRuby 33.0, and JRuby 10.0. There's *almost* 100% test coverage - I need to find some "broken" JPEGs to do the rest (hit me up if you have any sources..)
+It works on CRuby 3.0+, TruffleRuby 33.0, JRuby 10.0, and [Spinel](https://github.com/matz/spinel) (tested at `7f08abd9`). There's *almost* 100% test coverage - I need to find some "broken" JPEGs to do the rest (hit me up if you have any sources..)
 
 > [!NOTE]
 > Rubyists might find the [AI Disclosure](#ai-disclosure) section below of interest.
@@ -205,15 +205,17 @@ Possible future improvements: ICC profile rendering/conversion.
 
 ## Performance
 
-On a 1024x1024 image (Apple M5, 5 runs after warmup):
+On the bundled 1024x1024 images (Apple M5, median of 15 runs after 20 seconds of warmup per operation):
 
-| Operation | CRuby 4.0.2 (YJIT) | TruffleRuby 33.0.1 |
-|-----------|---------------------|---------------------|
-| Encode (color, q85) | ~0.16s | ~0.08s |
-| Decode (baseline) | ~0.14s | ~0.05s |
-| Decode (progressive) | ~0.18s | ~0.09s |
+| Operation | CRuby 4.0.2 (YJIT) | TruffleRuby 34.0.1 | JRuby 9.4.14.0 | Spinel (`7f08abd9`) |
+|-----------|-------------------|-------------------|---------------|--------------------|
+| Encode (color, q85) | ~0.131s | ~0.088s | ~0.577s | ~0.104s |
+| Decode (baseline) | ~0.112s | ~0.027s | ~0.554s | ~0.078s |
+| Decode (progressive) | ~0.140s | ~0.037s | ~0.617s | ~0.092s |
 
-The encoder and decoder use an integer-scaled AAN (Arai-Agui-Nakajima) DCT with fixed-point arithmetic throughout — no Float operations in the hot path. Color space conversion uses fixed-point integer math, and pixel data is stored as packed integers to avoid per-pixel object allocation. TruffleRuby's Graal JIT compiler can optimize these tight integer loops particularly well, resulting in 2-3x faster performance once warmed up.
+Inputs were loaded before timing, and encoded output was returned in memory; file I/O and PNG loading are excluded. Runtimes were benchmarked sequentially. JRuby used its default JIT on OpenJDK 21.0.10. Spinel was measured separately with the same inputs and timing protocol, using a portable harness with PNG pixels preloaded; its encoded JPEG and decoded pixels matched CRuby byte-for-byte. Results vary with image content, garbage collection, and JIT warmup.
+
+The encoder and decoder use an integer-scaled AAN (Arai-Agui-Nakajima) DCT with fixed-point arithmetic throughout — no Float operations in the hot path. Color space conversion uses fixed-point integer math, and pixel data is stored as packed integers to avoid per-pixel object allocation. TruffleRuby's Graal JIT compiler can optimize these tight integer loops particularly well once warmed up.
 
 ## Example scripts
 

data/lib/pure_jpeg/decoder.rb

@@ -78,9 +78,13 @@ module PureJPEG
 
       # Reusable buffers
       zigzag = Array.new(64, 0)
-      raster = Array.new(64, 0)
       dequant = Array.new(64, 0)
 
+      scan_components = jfif.scan_components.map do |sc|
+        comp, dc_tab, ac_tab = resolve_scan_references!(sc, comp_info, dc_tables, ac_tables)
+        [sc, comp, dc_tab, ac_tab, fetch_quant_table!(jfif, comp), channels[comp.id]]
+      end
+
       mcus_y.times do |mcu_row|
         mcus_x.times do |mcu_col|
           # Handle restart interval
@@ -89,19 +93,14 @@ module PureJPEG
             prev_dc.clear
           end
 
-          jfif.scan_components.each do |sc|
-            comp, dc_tab, ac_tab = resolve_scan_references!(sc, comp_info, dc_tables, ac_tables)
-            qt = fetch_quant_table!(jfif, comp)
-            ch = channels[comp.id]
-
+          scan_components.each do |sc, comp, dc_tab, ac_tab, qt, ch|
             comp.v_sampling.times do |bv|
               comp.h_sampling.times do |bh|
                 # Decode one 8x8 block
                 decode_block(reader, dc_tab, ac_tab, prev_dc, sc.id, zigzag)
 
                 # Inverse pipeline: unzigzag -> dequantize -> IDCT -> level shift
-                Zigzag.unreorder!(zigzag, raster)
-                Quantization.dequantize!(raster, qt, dequant)
+                Quantization.dequantize_zigzag!(zigzag, qt, dequant)
                 DCT.inverse!(dequant)
 
                 # Write block into channel buffer
@@ -191,7 +190,7 @@ module PureJPEG
         end
       end
 
-      # Reconstruct: unzigzag, dequantize, IDCT, write to channel buffers
+      # Reconstruct: unzigzag/dequantize, IDCT, write to channel buffers
       padded_w = mcus_x * mcu_px_w
       padded_h = mcus_y * mcu_px_h
       channels = {}
@@ -201,8 +200,6 @@ module PureJPEG
         channels[c.id] = { data: Array.new(ch_w * ch_h, 0), width: ch_w, height: ch_h }
       end
 
-      zigzag = Array.new(64, 0)
-      raster = Array.new(64, 0)
       dequant = Array.new(64, 0)
 
       jfif.components.each do |c|
@@ -214,10 +211,7 @@ module PureJPEG
         by_count.times do |block_y|
           bx_count.times do |block_x|
             offset = (block_y * bx_count + block_x) * 64
-            64.times { |i| zigzag[i] = coeff_buf[offset + i] }
-
-            Zigzag.unreorder!(zigzag, raster)
-            Quantization.dequantize!(raster, qt, dequant)
+            Quantization.dequantize_zigzag!(coeff_buf, qt, dequant, offset)
             DCT.inverse!(dequant)
             write_block(dequant, ch[:data], ch[:width], block_x * 8, block_y * 8)
           end
@@ -279,6 +273,11 @@ module PureJPEG
       prev_dc = Hash.new(0)
       mcu_count = 0
 
+      scan_components = scan.components.map do |sc|
+        comp, dc_tab = resolve_scan_references!(sc, comp_info, dc_tables, ac_tables, require_ac: false)
+        [sc, comp, dc_tab, coeffs[comp.id], comp_blocks[comp.id][0]]
+      end
+
       mcus_y.times do |mcu_row|
         mcus_x.times do |mcu_col|
           if restart_interval > 0 && mcu_count > 0 && (mcu_count % restart_interval) == 0
@@ -286,11 +285,7 @@ module PureJPEG
             prev_dc.clear
           end
 
-          scan.components.each do |sc|
-            comp, dc_tab = resolve_scan_references!(sc, comp_info, dc_tables, ac_tables, require_ac: false)
-            coeff_buf = coeffs[comp.id]
-            bx_count = comp_blocks[comp.id][0]
-
+          scan_components.each do |sc, comp, dc_tab, coeff_buf, bx_count|
             comp.v_sampling.times do |bv|
               comp.h_sampling.times do |bh|
                 block_x = mcu_col * comp.h_sampling + bh
@@ -312,7 +307,7 @@ module PureJPEG
     end
 
     def prog_dc_first(reader, dc_tab, prev_dc, coeff_buf, offset, al)
-      cat = dc_tab.decode(reader)
+      cat = dc_tab.decode_symbol(reader)
       diff = reader.receive_extend(cat)
       dc_val = prev_dc + diff
       coeff_buf[offset] = dc_val << al
@@ -328,7 +323,7 @@ module PureJPEG
 
       k = ss
       while k <= se
-        symbol = ac_tab.decode(reader)
+        symbol = ac_tab.decode_symbol(reader)
         run = (symbol >> 4) & 0x0F
         size = symbol & 0x0F
 
@@ -364,7 +359,7 @@ module PureJPEG
 
       k = ss
       while k <= se
-        symbol = ac_tab.decode(reader)
+        symbol = ac_tab.decode_symbol(reader)
         r = (symbol >> 4) & 0x0F
         s = symbol & 0x0F
 
@@ -417,7 +412,7 @@ module PureJPEG
 
     def decode_block(reader, dc_tab, ac_tab, prev_dc, comp_id, out)
       # DC coefficient
-      dc_cat = dc_tab.decode(reader)
+      dc_cat = dc_tab.decode_symbol(reader)
       dc_diff = reader.receive_extend(dc_cat)
       dc_val = prev_dc[comp_id] + dc_diff
       prev_dc[comp_id] = dc_val
@@ -426,7 +421,7 @@ module PureJPEG
       # AC coefficients
       i = 1
       while i < 64
-        symbol = ac_tab.decode(reader)
+        symbol = ac_tab.decode_symbol(reader)
         if symbol == 0x00 # EOB
           while i < 64
             out[i] = 0

data/lib/pure_jpeg/encoder.rb

@@ -146,11 +146,9 @@ module PureJPEG
                              lum_dc_bits, lum_dc_values, lum_ac_bits, lum_ac_values)
       else
         chr_qtable = build_chr_qtable
-        y_data, cb_data, cr_data = extract_ycbcr(width, height)
+        y_data, cb_sub, cr_sub = extract_ycbcr420(width, height)
         sub_w = (width + 1) / 2
         sub_h = (height + 1) / 2
-        cb_sub = downsample(cb_data, width, height, sub_w, sub_h)
-        cr_sub = downsample(cr_data, width, height, sub_w, sub_h)
 
         lum_dc_bits, lum_dc_values, lum_ac_bits, lum_ac_values,
           chr_dc_bits, chr_dc_values, chr_ac_bits, chr_ac_values =
@@ -215,13 +213,12 @@ module PureJPEG
       padded_h = (height + 7) & ~7
 
       block = Array.new(64, 0)
-      qbuf  = Array.new(64, 0)
       zbuf  = Array.new(64, 0)
 
       (0...padded_h).step(8) do |by|
         (0...padded_w).step(8) do |bx|
           extract_block_into(y_data, width, height, bx, by, block)
-          yield transform_block(block, qbuf, zbuf, qtable)
+          yield transform_block(block, zbuf, qtable)
         end
       end
     end
@@ -285,28 +282,27 @@ module PureJPEG
       mcu_h = (height + 15) & ~15
 
       block = Array.new(64, 0)
-      qbuf  = Array.new(64, 0)
       zbuf  = Array.new(64, 0)
 
       (0...mcu_h).step(16) do |my|
         (0...mcu_w).step(16) do |mx|
           extract_block_into(y_data, width, height, mx, my, block)
-          yield :y, transform_block(block, qbuf, zbuf, lum_qt)
+          yield :y, transform_block(block, zbuf, lum_qt)
 
           extract_block_into(y_data, width, height, mx + 8, my, block)
-          yield :y, transform_block(block, qbuf, zbuf, lum_qt)
+          yield :y, transform_block(block, zbuf, lum_qt)
 
           extract_block_into(y_data, width, height, mx, my + 8, block)
-          yield :y, transform_block(block, qbuf, zbuf, lum_qt)
+          yield :y, transform_block(block, zbuf, lum_qt)
 
           extract_block_into(y_data, width, height, mx + 8, my + 8, block)
-          yield :y, transform_block(block, qbuf, zbuf, lum_qt)
+          yield :y, transform_block(block, zbuf, lum_qt)
 
           extract_block_into(cb_sub, sub_w, sub_h, mx >> 1, my >> 1, block)
-          yield :cb, transform_block(block, qbuf, zbuf, chr_qt)
+          yield :cb, transform_block(block, zbuf, chr_qt)
 
           extract_block_into(cr_sub, sub_w, sub_h, mx >> 1, my >> 1, block)
-          yield :cr, transform_block(block, qbuf, zbuf, chr_qt)
+          yield :cr, transform_block(block, zbuf, chr_qt)
         end
       end
     end
@@ -331,10 +327,9 @@ module PureJPEG
 
     # --- Shared block pipeline (all buffers pre-allocated) ---
 
-    def transform_block(block, qbuf, zbuf, qtable)
+    def transform_block(block, zbuf, qtable)
       DCT.forward!(block)
-      Quantization.quantize!(block, qtable, qbuf)
-      Zigzag.reorder!(qbuf, zbuf)
+      Quantization.quantize_zigzag!(block, qtable, zbuf)
       zbuf
     end
 
@@ -392,61 +387,65 @@ module PureJPEG
       luminance
     end
 
-    def extract_ycbcr(width, height)
-      size = width * height
-      y_data  = Array.new(size)
-      cb_data = Array.new(size)
-      cr_data = Array.new(size)
+    # Convert RGB in raster order, downsampling chroma after every two rows.
+    # Keeping only two full-resolution chroma rows avoids two image-sized arrays.
+    def extract_ycbcr420(width, height)
+      y_data = Array.new(width * height)
+      sub_w = (width + 1) / 2
+      sub_h = (height + 1) / 2
+      cb_sub = Array.new(sub_w * sub_h)
+      cr_sub = Array.new(sub_w * sub_h)
+      cb_rows = Array.new(width * 2)
+      cr_rows = Array.new(width * 2)
 
       if source.respond_to?(:packed_pixels)
         packed = source.packed_pixels
         r_shift, g_shift, b_shift = packed_shifts
-        i = 0
-        size.times do
-          color = packed[i]
-          r = (color >> r_shift) & 0xFF
-          g = (color >> g_shift) & 0xFF
-          b = (color >> b_shift) & 0xFF
-          y_data[i]  = clamp255((FP_Y_R * r + FP_Y_G * g + FP_Y_B * b + FP_HALF) >> 16)
-          cb_data[i] = clamp255((FP_CB_R * r + FP_CB_G * g + FP_CB_B * b + FP_128 + FP_HALF) >> 16)
-          cr_data[i] = clamp255((FP_CR_R * r + FP_CR_G * g + FP_CR_B * b + FP_128 + FP_HALF) >> 16)
-          i += 1
-        end
-      else
-        height.times do |py|
-          row = py * width
+      end
+
+      height.times do |py|
+        row = py * width
+        chroma_row = (py & 1) * width
+        if packed
+          width.times do |px|
+            color = packed[row + px]
+            r = (color >> r_shift) & 0xFF
+            g = (color >> g_shift) & 0xFF
+            b = (color >> b_shift) & 0xFF
+            y_data[row + px] = clamp255((FP_Y_R * r + FP_Y_G * g + FP_Y_B * b + FP_HALF) >> 16)
+            cb_rows[chroma_row + px] = clamp255((FP_CB_R * r + FP_CB_G * g + FP_CB_B * b + FP_128 + FP_HALF) >> 16)
+            cr_rows[chroma_row + px] = clamp255((FP_CR_R * r + FP_CR_G * g + FP_CR_B * b + FP_128 + FP_HALF) >> 16)
+          end
+        else
           width.times do |px|
             pixel = source[px, py]
             r = pixel.r; g = pixel.g; b = pixel.b
-            i = row + px
-            y_data[i]  = clamp255((FP_Y_R * r + FP_Y_G * g + FP_Y_B * b + FP_HALF) >> 16)
-            cb_data[i] = clamp255((FP_CB_R * r + FP_CB_G * g + FP_CB_B * b + FP_128 + FP_HALF) >> 16)
-            cr_data[i] = clamp255((FP_CR_R * r + FP_CR_G * g + FP_CR_B * b + FP_128 + FP_HALF) >> 16)
+            y_data[row + px] = clamp255((FP_Y_R * r + FP_Y_G * g + FP_Y_B * b + FP_HALF) >> 16)
+            cb_rows[chroma_row + px] = clamp255((FP_CB_R * r + FP_CB_G * g + FP_CB_B * b + FP_128 + FP_HALF) >> 16)
+            cr_rows[chroma_row + px] = clamp255((FP_CR_R * r + FP_CR_G * g + FP_CR_B * b + FP_128 + FP_HALF) >> 16)
           end
         end
+
+        if py.odd? || py == height - 1
+          # For odd image heights, use row zero twice at the bottom edge.
+          downsample_chroma_rows(cb_rows, cr_rows, width, chroma_row,
+                                 cb_sub, cr_sub, sub_w, (py >> 1) * sub_w)
+        end
       end
 
-      [y_data, cb_data, cr_data]
+      [y_data, cb_sub, cr_sub]
     end
 
-    def downsample(data, src_w, src_h, dst_w, dst_h)
-      out = Array.new(dst_w * dst_h)
-      max_x = src_w - 1
-      max_y = src_h - 1
-      dst_h.times do |dy|
-        sy = dy << 1
-        y1 = sy < max_y ? sy + 1 : max_y
-        row0 = sy * src_w
-        row1 = y1 * src_w
-        dst_row = dy * dst_w
-        dst_w.times do |dx|
-          sx = dx << 1
-          x1 = sx < max_x ? sx + 1 : max_x
-          out[dst_row + dx] = ((data[row0 + sx] + data[row0 + x1] +
-                                data[row1 + sx] + data[row1 + x1]) >> 2)
-        end
+    def downsample_chroma_rows(cb_rows, cr_rows, width, row1, cb_sub, cr_sub, sub_w, dst_row)
+      max_x = width - 1
+      sub_w.times do |dx|
+        sx = dx << 1
+        x1 = sx < max_x ? sx + 1 : max_x
+        cb_sub[dst_row + dx] = (cb_rows[sx] + cb_rows[x1] +
+                                cb_rows[row1 + sx] + cb_rows[row1 + x1]) >> 2
+        cr_sub[dst_row + dx] = (cr_rows[sx] + cr_rows[x1] +
+                                cr_rows[row1 + sx] + cr_rows[row1 + x1]) >> 2
       end
-      out
     end
 
     # Extract an 8x8 block into a pre-allocated array, level-shifted by -128.

data/lib/pure_jpeg/huffman/decoder.rb

@@ -25,13 +25,15 @@ module PureJPEG
       end
 
       # Decode one Huffman symbol from the bit reader.
-      def decode(reader)
+      def decode_symbol(reader)
         code = 0
-        1.upto(16) do |len|
+        len = 1
+        while len <= 16
           code = (code << 1) | reader.read_bit
           if @max_code[len] >= 0 && code <= @max_code[len]
             return @values[@val_ptr[len] + code - @min_code[len]]
           end
+          len += 1
         end
         raise PureJPEG::DecodeError, "Invalid Huffman code"
       end

data/lib/pure_jpeg/huffman/encoder.rb

@@ -6,14 +6,7 @@ module PureJPEG
       # Return the Huffman category (bit length) for a value.
       # Avoids Array allocation compared to the combined category_and_bits.
       def self.category(value)
-        return 0 if value == 0
-        v = value.abs
-        cat = 0
-        while v > 0
-          cat += 1
-          v >>= 1
-        end
-        cat
+        value.abs.bit_length
       end
 
       # Return the extra bits to encode for a value with the given category.
@@ -50,6 +43,7 @@ module PureJPEG
         end
 
         yield 0x00, 0 if last_nonzero < 63
+        nil
       end
 
       def self.each_ac_symbol(zigzag)
@@ -85,12 +79,12 @@ module PureJPEG
       end
 
       def encode_ac(zigzag, writer)
-        self.class.each_ac_item(zigzag) do |symbol, value|
+        PureJPEG::Huffman::Encoder.each_ac_item(zigzag) do |symbol, value|
           code, length = @ac_table[symbol]
           writer.write_bits(code, length)
           next if symbol == 0x00 || symbol == 0xF0
 
-          cat = self.class.category(value)
+          cat = symbol & 0x0F
           writer.write_bits(self.class.value_bits(value, cat), cat)
         end
       end

data/lib/pure_jpeg/quantization.rb

@@ -58,5 +58,33 @@ module PureJPEG
       64.times { |i| out[i] = block[i] * table[i] }
       out
     end
+
+    # Quantize raster-order coefficients directly into zigzag order.
+    def self.quantize_zigzag!(block, table, out)
+      order = Zigzag::ORDER
+      i = 0
+      while i < 64
+        j = order[i]
+        v = block[j]; t = table[j]
+        out[i] = if v >= 0
+                   (v + (t >> 1)) / t
+                 else
+                   -((-v + (t >> 1)) / t)
+                 end
+        i += 1
+      end
+      out
+    end
+
+    # Dequantize zigzag coefficients directly into raster order. The offset
+    # allows progressive decoding to read from its full coefficient buffer.
+    def self.dequantize_zigzag!(block, table, out, offset = 0)
+      order = Zigzag::ORDER
+      64.times do |i|
+        j = order[i]
+        out[j] = block[offset + i] * table[j]
+      end
+      out
+    end
   end
 end

data/lib/pure_jpeg/source/raw_source.rb

@@ -27,15 +27,16 @@ module PureJPEG
       def initialize(width, height, &block)
         @width = width
         @height = height
-        @pixels = Array.new(width * height) { Pixel.new(0, 0, 0) }
-
         if block
+          @pixels = Array.new(width * height)
           height.times do |y|
             width.times do |x|
               r, g, b = block.call(x, y)
               @pixels[y * width + x] = Pixel.new(r, g, b)
             end
           end
+        else
+          @pixels = Array.new(width * height) { Pixel.new(0, 0, 0) }
         end
       end
 

data/lib/pure_jpeg/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PureJPEG
-  VERSION = "0.3.3"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pure_jpeg
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.0
 platform: ruby
 authors:
 - Peter Cooper