imsg-grep 0.1.2-darwin

data/lib/imsg-grep/apple/keyed_archive.rb

@@ -0,0 +1,105 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# NSKeyedArchive decoder for unpacking Apple's keyed archive format from binary plists
+
+require "json"
+require "base64"
+require_relative "bplist"
+
+class KeyedArchive
+  attr_reader :data
+
+  class BinaryString < String
+    def initialize(s) = super(s).force_encoding("BINARY")
+    def to_json(...) = Base64.strict_encode64(self).to_json(...)
+  end
+
+  def self.unarchive(...) = new(...).unarchive
+  def self.json(...) = new(...).json
+
+  def initialize(data)
+    return unless data
+    return if data[0, 4] == "\x08\x08\x11\x00" # DigitalTouchBalloonProvider row; another format, ignore
+    raise "no bplist: #{data}" unless data.start_with?("bplist")
+    @data = BPList.parse data
+  end
+
+  def unarchive
+    return unless @data # initialize failed
+    top  = @data["$top"] or raise "no top"
+    root = top["root"] or raise "no root"
+    objs = @data["$objects"] or raise "no objects"
+    decode_objects dereference_uids(root, objs)
+  end
+
+  def json = unarchive&.to_json
+
+  private
+
+  def dereference_uids(obj, objects, visited = Set.new, depth = 0)
+    # Prevent infinite recursion
+    raise "Maximum recursion depth exceeded" if depth > 1000
+    case obj
+    when Hash
+      if obj.size == 1 && obj.has_key?("CF$UID")
+        # This is a UID reference, expand it
+        uid = obj["CF$UID"]
+        return obj if visited.include?(uid) # Prevent infinite recursion
+        return obj if uid >= objects.length || uid < 0
+
+        visited.add(uid)
+        result = dereference_uids(objects[uid], objects, visited, depth + 1)
+        visited.delete(uid)
+        return result
+      else
+        # Regular hash, expand all values
+        result = {}
+        obj.each { |k, v| result[k] = dereference_uids(v, objects, visited, depth + 1) }
+        return result
+      end
+    when Array
+      obj.map { |item| dereference_uids(item, objects, visited, depth + 1) }
+    else
+      obj
+    end
+  end
+
+  def decode_objects(obj)
+    case obj
+    when Hash
+      case obj.dig("$class", "$classname")
+      in "NSArray" if obj.key? "NS.objects"
+        obj["NS.objects"].map { |item| decode_objects(item) }
+
+      in "NSDictionary" if obj.key?("NS.keys") && obj.key?("NS.objects")
+        obj["NS.keys"].zip(obj["NS.objects"].map{ decode_objects it }).to_h
+
+      in "NSURL" if obj["NS.base"] == "$null" && obj["NS.relative"]
+        obj["NS.relative"]
+      else
+        obj.transform_values { decode_objects it }
+      end
+
+    when Array  then obj.map { |item| decode_objects(item) }
+    when "$null" then nil  # Transform $null strings to actual null
+
+    when String # Transform binary data to Base64 ; detect if string is binary (ASCII-8BIT) or invalid UTF-8
+      case
+      when obj.encoding == Encoding::BINARY then BinaryString.new(obj)
+      when obj.force_encoding('UTF-8').valid_encoding? then obj
+      else BinaryString.new(obj)
+      end
+
+    else obj
+    end
+  end
+
+end
+
+
+if __FILE__ == $0
+  input = $stdin.read
+  out = KeyedArchive.unarchive(input)
+  puts JSON.pretty_generate(out)
+end

data/lib/imsg-grep/dev/print_query.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# Query result formatter that prints SQL results in Very Nice tables
+
+require "io/console"
+
+module Print
+  @term_width = IO.console.winsize[1]
+  @term_width -= 3 if ENV["TERM_PROGRAM"] == "zed" # safe zone for https://github.com/zed-industries/zed/issues/43629
+
+  def self.c256(c, s) = "\e[38;5;#{c}m#{s}\e[39m"
+  def self.mark(s) = "\e[38;5;178m#{s}\e[39m"
+  def self.sep(s) = "\e[30m#{s}\e[39m"
+  def self.clr = "\e[0m"
+
+  def self.query(q, *args, title: nil, db: Messages.db)
+    table db.execute2(q, *args), title:
+  end
+
+  def self.table(table, title: nil)
+    bg1 = "\e[48;5;4m"
+    bga = ["\e[48;5;235m", "\e[48;5;238m"]
+    bg = ->{ bg1 ? (bg1.tap{bg1=nil}) : bga.rotate!.first }
+
+
+    # puts "\n#{'=' * 80}"
+    hrow, *rows = table
+    # max lengths for each col, but capping the header rows at 5 so big headers with short content don't take up space
+    lens = [hrow.map{it[0,5]}].concat(rows).transpose.map{|col|col.map{it.to_s.size}.max||0}
+    # is each column number? used for aligning them right
+    nums = rows.transpose.map{|col| col.compact.all?{ Numeric===it }}
+    hex  = rows.transpose.map{|col| col.compact.all?{ String===it && it !~ /\H/ }}
+    hex.zip(0..).each{|h,i| lens[i] = 20 if h } #  hex cols start short
+
+    # available term width for all cols excluding separators
+    colsw = @term_width - hrow.size + 1
+    # max width per col; start with an even col width then redistribute next
+    maxcw = colsw / hrow.size
+
+    # begin redistributing
+    bigs = lens
+    taken = 0
+    while true
+      smalls, bigs = bigs.partition{ it <= maxcw } # partition cols under/at max col width
+      break if bigs.empty? || smalls.empty?        # can't redistribute if all on either side
+      taken += smalls.sum                          # accumulate used up width
+      maxcw = (colsw - taken) / bigs.size          # max for remaining bigs: split even
+    end
+    lens.map!{ [it, maxcw].min }
+
+    # expand col header width while fits; those we capped earlier
+    trunc_headers = lens.zip(hrow.map{it.size}, 0..).filter_map{|l,hl,i| [i,hl] if l<hl } # [col index, full header length]
+    while lens.sum < colsw && trunc_headers.any? # while still fits and any left to widen
+      i, hl = trunc_headers.first                # take first
+      next trunc_headers.shift if lens[i] >= hl  # drop and nove on if wide enough
+      lens[i] += 1                               # widen
+      trunc_headers.rotate!                      # move on to next index
+    end
+
+    total_width = lens.sum + hrow.size - 1 # full width table will take
+
+    row_count = "(#{rows.size} row#{?s if rows.size != 1})"
+    title = [title, row_count].join(" ")
+    puts "\e[48;5;18m" + title.ljust(total_width) + "\e[49m"
+
+    lines = table.map do |row|
+      line = row.zip(lens, nums).map do |val, len, num|
+        just = ->s{ s.send(num ? :rjust : :ljust, len) }
+        next c256(244, just[?∅]) if val.nil?  # special handling for nil
+        next c256(112, just["1"]) if val == 1 # color 1 bool true
+        next c256(9, just["0"]) if val == 0   # color 0 bool false
+        s ||= val.to_s
+        s = s.gsub(/\p{Extended_Pictographic}/, "•").gsub(/\R/, "␍").gsub(/\t/, ' ') # remove emojis, nl, tabs (better chance of not mangling columns)
+        s = s[0, len-1] + mark(?›) if s.size > len # ellipsis
+        just[s]
+      end
+      bg[] + line*sep(?│) + clr
+    end
+    puts lines
+    puts "\e[48;5;18m" + row_count.ljust(total_width) + "\e[49m"
+    puts
+  end
+
+end

data/lib/imsg-grep/dev/timer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Simple timer for profiling with lap times and progress bars
+module Timer
+  # Initialize timer state
+  def self.start
+    @t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    @last_lap = @t0
+    @total_time = 0.0
+    @laps = []
+  end
+
+  # Record lap time with message
+  def self.lap(msg)
+    now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    lap_time = (now - @last_lap) * 1000
+    @total_time += lap_time
+    line = "%5.0fms / %5.0fms: #{msg}" % [lap_time, @total_time]
+    $stderr.puts line
+    @laps << { msg: msg, time: lap_time, line: line, line_num: @laps.size }
+    @last_lap = now
+  end
+
+  # Display final timing report with bars and percentages
+  def self.finish
+    max_lap_time = @laps.map { |lap| lap[:time] }.max
+    longest_line = @laps.map { |lap| lap[:line].length }.max
+    start_col = longest_line + 3
+    @laps.reverse.each do |lap|
+      pct = "%4.1f" % (lap[:time] / @total_time * 100)
+      bar_length = (lap[:time] / max_lap_time * 20).round
+      bar = "█" * bar_length + "░" * (20 - bar_length)
+      padding = " " * [0, start_col - lap[:line].length].max
+      $stderr.print "\e[#{@laps.size - lap[:line_num]}A\r#{lap[:line]}#{padding}#{bar} #{pct}%\e[#{@laps.size - lap[:line_num]}B\r"
+    end
+    $stderr.puts
+  end
+end

data/lib/imsg-grep/images/imaginator.rb

@@ -0,0 +1,135 @@
+require "io/console"
+require "concurrent-ruby"
+require_relative "img2png"
+
+module Imaginator
+  begin
+    require_relative "img2png"
+    EXTENSION_AVAILABLE = true
+  rescue LoadError
+    EXTENSION_AVAILABLE = false
+  end
+
+  extend self
+
+  class Image
+    Fit = Data.define :w, :h, :c, :r, :pad_h, :pad_w
+
+    def initialize(path) = @path = path
+    def dimensions       = @img.dimensions
+    def release          = @img.release
+
+    def load
+      return unless File.exist? @path
+      # @img ||= Img2png::Image.new path: @path # do the the IO in swift, turns out not any faster
+      @img ||= Img2png::Image.new data: IO.binread(@path)
+      self
+    end
+
+    def png_transform w:, h:, pad_h:nil, pad_w:nil
+      pad = pad_h || pad_w
+      pad_w ||= w if pad
+      pad_h ||= h if pad
+      @img.convert fit_w:w, fit_h:h, box_w:pad_w, box_h:pad_h
+    end
+
+    def fit_cols target_cols
+      w_cell, h_cell = Imaginator.cell_size
+      w_img,  h_img  = dimensions
+      w = target_cols * w_cell # target width in px
+      h = w / w_img * h_img    # target height in px
+      r = (h / h_cell).ceil    # target rows
+      Fit.new w:w.floor, h:h.floor, c:target_cols, r:r, pad_h:(r*h_cell), pad_w:w
+    end
+
+    def fit_rows target_rows
+      w_cell, h_cell = Imaginator.cell_size
+      w_img,  h_img  = dimensions
+      h = target_rows * h_cell # target height in px
+      w = h / h_img * w_img    # target width in px
+      c = (w / w_cell).ceil    # target cols
+      Fit.new w:w.floor, h:h.floor, c:c, r:target_rows, pad_w:(c*w_cell), pad_h:h
+    end
+
+    def fit cols, rows
+      cfit = fit_cols(cols)
+      rfit = fit_rows(rows)
+      smol = [cfit, rfit].sort_by { [it.w, it.h] }.first
+      # ^ they're proportional so whichever smallest is the one containable in both dimensions
+      [smol, cfit:, rfit:]
+    end
+
+  end
+
+
+  def term_seq(seq, end_marker)
+    t = ->{ Process.clock_gettime Process::CLOCK_MONOTONIC }
+    buf = ""
+    IO.console.raw do |tty|
+      tty << seq
+      tty.flush
+      timeout = t.() + 0.1
+      loop do
+        buf << tty.read_nonblock(1)
+        break if buf.end_with? end_marker
+      rescue IO::WaitReadable
+        break if t.() > timeout
+        IO.select([tty], nil, nil, 0.01)
+      end
+    end
+    buf
+  end
+
+  def term_features = @term_features ||= (term_seq("\e]1337;Capabilities\e\\", ?\a) =~ /Capabilities=([A-Za-z0-9]*)/ and $1.scan(/[A-Z][a-z]?\d*/))
+  def iterm_images? = @iterm_images  ||= term_features&.include?(?F)
+  def kitty_images? = @kitty_images  ||= term_seq("\e_Gi=31,s=1,v=1,a=q,t=d,f=24;AAAA\e\\", "\e\\") == "\e_Gi=31;OK\e\\"
+
+  def cell_size # [cell width px, cell height px] (Floats)
+    @cell_size ||= case
+    when iterm = term_seq("\e]1337;ReportCellSize\e\\", ?\a)[/ReportCellSize=(.*)\e/, 1]
+      iterm.split(?;).map{ Float it }.then{ |h, w, s| s ||= 1; [w*s, h*s] } # multiply by retina scale factor
+    when csi16t = term_seq("\e[16t", ?t)[/\e\[6;(\d+;\d+)t/, 1] # ghostty
+      csi16t.split(?;).map{ Float it }.reverse
+    # else calc from TIOCGWINSZ or CSI14/18t, but this is enough for iterm, ghostty
+    end
+  end
+
+  def term_image_protocol
+    return @term_image_protocol unless @term_image_protocol.nil?
+    @term_image_protocol = case
+    when ENV["TERM_PROGRAM"] == "Apple_Terminal" then false # it echoes back the kitty query and I don't wanna figure out how not to
+    when iterm_images? then :iterm # has to go before kitty as iterm responds ok to kitty query but can't render them
+    when kitty_images? then :kitty # you're a kitty! yes you are! and you're sitting there! hi, kitty!
+    else false
+    end
+  end
+
+  def image_tooling? = !!(EXTENSION_AVAILABLE && term_image_protocol && cell_size)
+
+  def iterm_print_image data:, r:nil, c:nil, io:$stdout
+    head = "\e]1337;"
+    io << head << "MultipartFile=inline=1;preserveAspectRatio=1"
+    io << ";width="  << c if c
+    io << ";height=" << r if r
+    io << ?\a
+    data = [data].pack("m0")
+    (0...data.size).step(200).each{ io << head << "FilePart=" << data[it, 200] << ?\a }
+    io << head << "FileEnd" << ?\a
+  end
+
+  def kitty_print_image data:, r:nil, c:nil, io:$stdout
+    io << "\e_Gf=100,a=T,t=d"
+    io << ",c=" << c if c
+    io << ",r=" << r if r
+    io << ?; << [data].pack("m0") << "\e\\"
+  end
+
+  def print_image(...)
+    return unless image_tooling?
+    case term_image_protocol
+    when :iterm then iterm_print_image(...)
+    when :kitty then kitty_print_image(...)
+    end
+  end
+
+end

data/lib/imsg-grep/images/img2png.rb

@@ -0,0 +1,84 @@
+require "ffi"
+
+module Img2png
+  extend FFI::Library
+  ffi_lib "#{__dir__}/img2png.dylib"
+
+  attach_function :img2png_load_path, [:string, :pointer, :pointer], :pointer, blocking: true
+  attach_function :img2png_load,      [:pointer, :int, :pointer, :pointer], :pointer, blocking: true
+  attach_function :img2png_convert,   [:pointer, :int, :int, :int, :int, :pointer, :pointer], :bool, blocking: true
+  attach_function :img2png_release,   [:pointer], :void
+  attach_function :img2png_free,      [:pointer], :void
+
+  class Image
+    def initialize(path:nil, data:nil)
+      [path, data].compact.size == 1 or raise ArgumentError, "One of path: or data: must be specified"
+      out_w = FFI::MemoryPointer.new(:int)
+      out_h = FFI::MemoryPointer.new(:int)
+
+      @handle = case
+      when data then Img2png.img2png_load(data, data.bytesize, out_w, out_h)
+      when path then Img2png.img2png_load_path(path, out_w, out_h)
+      end
+      raise "Failed to load image" if @handle.null?
+
+      @width  = out_w.read_int
+      @height = out_h.read_int
+    end
+
+    def dimensions = [@width, @height]
+
+    def convert(fit_w: nil, fit_h: nil, box_w: nil, box_h: nil)
+      out_data = FFI::MemoryPointer.new(:pointer)
+      out_len  = FFI::MemoryPointer.new(:int)
+
+      success = Img2png.img2png_convert(
+        @handle,
+        fit_w || 0, fit_h || 0,
+        box_w || 0, box_h || 0,
+        out_data, out_len
+      )
+
+      return nil unless success
+
+      ptr = out_data.read_pointer
+      len = out_len.read_int
+      result = ptr.read_bytes(len)
+      Img2png.img2png_free(ptr)
+      result
+    end
+
+    def release
+      Img2png.img2png_release(@handle) unless @handle.null?
+      @handle = FFI::Pointer::NULL
+    end
+
+    def self.finalize(handle)
+      proc { Img2png.img2png_release(handle) unless handle.null? }
+    end
+  end
+end
+
+# # Usage examples
+# input = File.binread("x.heic")
+
+# # Load once, use multiple times
+# img = Img2png::Image.new(input)
+
+# # Get dimensions
+# p img.dimensions  # => [4032, 3024]
+
+# # Convert without scaling
+# png = img.convert
+# File.binwrite("output.png", png)
+
+# # Fit to 800x600
+# png = img.convert(fit_w: 800, fit_h: 600)
+# File.binwrite("fitted.png", png)
+
+# # Fit to 800x600 and box in 1024x768
+# png = img.convert(fit_w: 800, fit_h: 600, box_w: 1024, box_h: 768)
+# File.binwrite("boxed.png", png)
+
+# # Manual cleanup (or let GC handle it)
+# img.release