raintron 0.1.0

data/lib/icons/png_decoder.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+module Raintron
+  # Decodes a PNG into raw RGBA bytes, for the "bring your own logo" path. Pure Ruby,
+  # stdlib Zlib only. Scoped to what a real-world logo export needs: 8-bit RGB/RGBA,
+  # non-interlaced. Anything else (16-bit, palette, Adam7 interlacing, or a non-PNG
+  # file entirely -- including JPEG, whose decode is not feasibly zero-dependency)
+  # raises Raintron::UnsupportedSourceError with a clear message rather than silently
+  # producing a wrong image.
+  module PngDecoder
+    SIGNATURE = "\x89PNG\r\n\x1a\n".b
+    JPEG_MAGIC = "\xff\xd8\xff".b
+
+    def self.decode(bytes)
+      raise_unless_png!(bytes)
+
+      chunks = read_chunks(bytes)
+      ihdr = chunks.find { |type, _| type == 'IHDR' }
+      raise Raintron::UnsupportedSourceError, 'PNG has no IHDR chunk' unless ihdr
+
+      width, height, channels = decode_ihdr(ihdr[1])
+
+      idat = chunks.select { |type, _| type == 'IDAT' }.map { |_, data| data }.join
+      raw = Zlib::Inflate.inflate(idat)
+
+      { width:, height:, rgba: unfilter(raw:, width:, height:, channels:) }
+    end
+
+    def self.raise_unless_png!(bytes)
+      return if bytes.byteslice(0, 8) == SIGNATURE
+
+      if bytes.byteslice(0, 3) == JPEG_MAGIC
+        raise Raintron::UnsupportedSourceError,
+              'JPEG sources are not supported (decoding JPEG is not feasible without a real dependency). ' \
+              'Convert your logo to PNG first, then pass that.'
+      end
+
+      raise Raintron::UnsupportedSourceError, 'not a PNG file -- convert your logo to PNG first, then pass that.'
+    end
+
+    def self.decode_ihdr(ihdr_data)
+      width, height, bit_depth, color_type, _compression, _filter, interlace = ihdr_data.unpack('N2C5')
+
+      unless bit_depth == 8 && [2, 6].include?(color_type) && interlace.zero?
+        raise Raintron::UnsupportedSourceError,
+              "unsupported PNG (bit depth #{bit_depth}, color type #{color_type}, interlace #{interlace}) -- " \
+              'only 8-bit RGB or RGBA, non-interlaced PNGs are supported. Convert your source image first ' \
+              '(e.g. re-export as a plain 8-bit PNG).'
+      end
+
+      [width, height, color_type == 6 ? 4 : 3]
+    end
+
+    def self.read_chunks(bytes)
+      chunks = []
+      offset = 8
+      while offset < bytes.bytesize
+        length = bytes.byteslice(offset, 4).unpack1('N')
+        type = bytes.byteslice(offset + 4, 4)
+        data = bytes.byteslice(offset + 8, length)
+        chunks << [type, data]
+        offset += 8 + length + 4 # + 4 for the CRC we don't verify
+        break if type == 'IEND'
+      end
+      chunks
+    end
+
+    # Reverses PNG's per-scanline filtering (None/Sub/Up/Average/Paeth -- filter types
+    # 0-4) to recover raw pixel bytes, then expands RGB to RGBA if needed so every
+    # other module in this gem can assume 4 bytes/pixel.
+    def self.unfilter(raw:, width:, height:, channels:)
+      stride = width * channels
+      prior = Array.new(stride, 0)
+      out = Array.new(height * stride)
+      pos = 0
+
+      height.times do |row|
+        filter_type = raw.getbyte(pos)
+        pos += 1
+        current = raw.byteslice(pos, stride).bytes
+        pos += stride
+
+        recon = reconstruct_row(filter_type:, current:, prior:, bpp: channels, stride:)
+        out[row * stride, stride] = recon
+        prior = recon
+      end
+
+      to_rgba(out, channels)
+    end
+
+    def self.reconstruct_row(filter_type:, current:, prior:, bpp:, stride:)
+      recon = Array.new(stride)
+      stride.times do |index|
+        left = index >= bpp ? recon[index - bpp] : 0
+        above = prior[index]
+        corner = index >= bpp ? prior[index - bpp] : 0
+        recon[index] = (current[index] + predictor(filter_type, left, above, corner)) & 0xff
+      end
+      recon
+    end
+
+    def self.predictor(filter_type, left, above, corner)
+      case filter_type
+      when 0 then 0
+      when 1 then left
+      when 2 then above
+      when 3 then (left + above) / 2
+      when 4 then paeth(left, above, corner)
+      else raise Raintron::UnsupportedSourceError, "unsupported PNG filter type #{filter_type}"
+      end
+    end
+
+    def self.paeth(left, above, corner)
+      base = left + above - corner
+      diff_left = (base - left).abs
+      diff_above = (base - above).abs
+      diff_corner = (base - corner).abs
+
+      return left if diff_left <= diff_above && diff_left <= diff_corner
+      return above if diff_above <= diff_corner
+
+      corner
+    end
+
+    def self.to_rgba(bytes_array, channels)
+      return bytes_array.pack('C*') if channels == 4
+
+      rgba = String.new(encoding: Encoding::BINARY)
+      bytes_array.each_slice(3) { |r, g, b| rgba << [r, g, b, 255].pack('C4') }
+      rgba
+    end
+
+    private_class_method :raise_unless_png!, :decode_ihdr, :read_chunks, :unfilter, :reconstruct_row, :predictor,
+                         :paeth, :to_rgba
+  end
+end

data/lib/icons/png_writer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+module Raintron
+  # Encodes raw RGBA pixel bytes as a PNG. Stdlib Zlib only -- no image library.
+  module PngWriter
+    SIGNATURE = "\x89PNG\r\n\x1a\n".b
+
+    # rgba: binary String, width*height*4 bytes, row-major top-to-bottom, R,G,B,A.
+    def self.encode(width:, height:, rgba:)
+      ihdr = [width, height, 8, 6, 0, 0, 0].pack('N2C5')
+      idat = Zlib::Deflate.deflate(filter_scanlines(width:, height:, rgba:), Zlib::BEST_COMPRESSION)
+
+      SIGNATURE + chunk('IHDR', ihdr) + chunk('IDAT', idat) + chunk('IEND', ''.b)
+    end
+
+    # Filter type 0 (None) on every scanline: PNG requires a 1-byte filter-type prefix
+    # per row even when no filtering is applied.
+    def self.filter_scanlines(width:, height:, rgba:)
+      row_bytes = width * 4
+      raw = String.new(encoding: Encoding::BINARY)
+      height.times do |y|
+        raw << "\x00".b
+        raw << rgba.byteslice(y * row_bytes, row_bytes)
+      end
+      raw
+    end
+
+    def self.chunk(type, data)
+      type_and_data = type.b + data.b
+      [data.bytesize].pack('N') + type_and_data + [Zlib.crc32(type_and_data)].pack('N')
+    end
+
+    private_class_method :filter_scanlines, :chunk
+  end
+end

data/lib/icons/renderer.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Raintron
+  # Procedural placeholder icon (no source image): a shape rendered directly at each
+  # target size, so no resizing is ever needed for this path.
+  module Renderer
+    def self.render(size:, background: [0, 152, 252, 255], foreground: [255, 255, 255, 255], shape: :circle)
+      background_bytes = background.pack('C4')
+      foreground_bytes = foreground.pack('C4')
+
+      rgba = String.new(encoding: Encoding::BINARY)
+      size.times do |row|
+        size.times do |col|
+          rgba << (inside?(shape, col, row, size) ? foreground_bytes : background_bytes)
+        end
+      end
+      rgba
+    end
+
+    def self.inside?(shape, col, row, size)
+      center = (size - 1) / 2.0
+
+      case shape
+      when :circle
+        radius = size * 0.32
+        dcol = col - center
+        drow = row - center
+        ((dcol * dcol) + (drow * drow)) <= (radius * radius)
+      when :square
+        half = size * 0.32
+        (col - center).abs <= half && (row - center).abs <= half
+      else
+        raise ArgumentError, "unknown shape: #{shape.inspect}"
+      end
+    end
+
+    private_class_method :inside?
+  end
+end

data/lib/icons/resampler.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Raintron
+  # Pure-arithmetic area-averaging (box) resize -- no image library. Used only for
+  # the "bring your own logo" path (the no-source placeholder path renders each size
+  # directly, so it never needs to resize anything).
+  module Resampler
+    def self.resize(rgba:, src_w:, src_h:, dst_w:, dst_h:)
+      return rgba if src_w == dst_w && src_h == dst_h
+
+      out = String.new(encoding: Encoding::BINARY)
+      dst_h.times do |dst_y|
+        y0 = (dst_y * src_h) / dst_h
+        y1 = [((dst_y + 1) * src_h) / dst_h, y0 + 1].max
+        dst_w.times do |dst_x|
+          x0 = (dst_x * src_w) / dst_w
+          x1 = [((dst_x + 1) * src_w) / dst_w, x0 + 1].max
+          out << average_box(rgba:, src_w:, x_range: x0...x1, y_range: y0...y1)
+        end
+      end
+      out
+    end
+
+    def self.average_box(rgba:, src_w:, x_range:, y_range:)
+      sums = [0, 0, 0, 0]
+      count = 0
+      y_range.each do |y|
+        x_range.each do |x|
+          index = ((y * src_w) + x) * 4
+          4.times { |channel| sums[channel] += rgba.getbyte(index + channel) }
+          count += 1
+        end
+      end
+      sums.map { |sum| (sum / count.to_f).round }.pack('C4')
+    end
+
+    private_class_method :average_box
+  end
+end

data/lib/launcher/launcher.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Raintron
+  # Opens a Raindeer app in a native desktop window. The server runs as a real forked
+  # child process, not a Thread inside this same process: webview_ruby's native run
+  # loop holds Ruby's GVL for as long as the window is open, which would starve a
+  # Thread-based server; a separate OS process sidesteps that entirely. `fork` (never
+  # Process.spawn of a separate script path) is mandatory once packed by Tebako, since
+  # a resolvable script path for a second process to exec doesn't exist inside a
+  # packed image -- the whole app lives in a single executable.
+  #
+  # The window opens straight away, on Raindown's rain cloud while the server boots:
+  # loading.html, self-contained and opened as a data: URL, as nothing's serving yet,
+  # with the app's URL as its fragment. The page polls that URL itself and switches to
+  # the app once it answers -- polling can't happen here, since the window's run loop
+  # holds the GVL from the moment it opens.
+  class Launcher
+    LOADING_PAGE = File.expand_path('loading.html', __dir__)
+    PARENT_CHECK_SECONDS = 0.5
+
+    def initialize(title:, size: [900, 600], host: '127.0.0.1', port: 4133, app_root: Dir.pwd, &server_block)
+      @title = title
+      @width, @height = size
+      @host = host
+      @port = port
+      @app_root = app_root
+      @server_block = server_block
+    end
+
+    def run
+      start_server
+      open_window
+    ensure
+      stop_server
+    end
+
+    # Public (and independently callable) so the server half can be exercised
+    # headlessly in tests, with no window and no webview_ruby involved at all.
+    def start_server
+      # Set before fork, unconditionally (not just when packed): the child inherits
+      # it via fork's memory copy, and Shims::PwdOverride uses it to answer Dir.pwd
+      # correctly regardless of what directory bin/desktop was actually launched from.
+      ENV['RAINTRON_APP_ROOT'] ||= @app_root
+      @pid = fork do
+        stop_with_parent(Process.ppid)
+        Raintron::Shims.apply!(packed: Raintron.packed?)
+        @server_block.call
+      end
+    end
+
+    # Base64, not percent-encoding, so the page's own # characters (its colours) can't
+    # be read as the start of the fragment.
+    def loading_url
+      "data:text/html;charset=utf-8;base64,#{[File.read(LOADING_PAGE)].pack('m0')}#http://#{@host}:#{@port}/"
+    end
+
+    def open_window
+      # Required only here, only in the parent, only after fork: macOS's Cocoa/WebKit
+      # frameworks (which this pulls in) are not fork-safe, so the child must never
+      # have loaded them.
+      require 'webview_ruby'
+
+      webview = WebviewRuby::Webview.new
+      webview.set_title(@title)
+      webview.set_size(@width, @height)
+      hide_titlebar(webview) if AppConfig.titlebar(app_root: @app_root) == 'hidden'
+      webview.navigate(loading_url)
+      webview.run
+      webview.destroy
+    end
+
+    def stop_server
+      return unless @pid
+
+      Process.kill('TERM', @pid)
+      Process.wait(@pid)
+    rescue Errno::ESRCH, Errno::ECHILD
+      nil
+    end
+
+    private
+
+    # The server stops itself once the window's process is gone. On macOS that process ends in [NSApp terminate:] when
+    # its window closes, which exits without returning to Ruby, so #run's ensure never stops the server; this covers
+    # that, and a crash or a kill of the window's process too.
+    def stop_with_parent(parent)
+      Thread.new do
+        sleep PARENT_CHECK_SECONDS while Process.ppid == parent
+        exit!
+      end
+    end
+
+    def hide_titlebar(webview)
+      require_relative '../window_chrome/window_chrome'
+      WindowChrome.hide_titlebar(webview)
+    end
+  end
+end