ruby_everywhere 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19938d7ab43425ebeb6a729c9dff31fa1c301aea0b72b08638483a1e2e1e5313
-  data.tar.gz: b493f9396d3b2f7b84d2b9434ab232ef21294df373b8c432d2c1aac811c9ac98
+  metadata.gz: 6445e84081e08a1d5c545054c0a7dc6ef2e4b05338aff54ea68dc4c48d6b6c60
+  data.tar.gz: 2a057925b0ee3266c294046b0be24cb1c0d3fa4b8a82e179b88425cd6afa7e91
 SHA512:
-  metadata.gz: fd4d9e03d266ee568170e60b663034c519db76941e2f91057dcc88cbb2250f71dae01668049a0af35edbd7464d468903c0027d97664da150b67529d62f7974a7
-  data.tar.gz: 6bb5a9afbe5d330f6a5bf7be303e728626b8df04476c9b5f3931ef0ed2d71ba9bf5507a1c54b99f0e11d7305c1acdbb2cb68f7bb43d7f46967dbf6746c5400e0
+  metadata.gz: 1e8528cf2ac3b62191795709e23ee708d1c706672b8fc5d5f2beec6c3455d1a092b71498a086d67506e9c8175efcad1ad2f5c22df0b5d7dbe0f130a3aba8600e
+  data.tar.gz: ff1a73eeaabf7d7b839b092b3482c4a06511a6793133b6133f9671ad17d883092877b608fa8db04c9709a419d38c73f905e44dca32d952c992121a18c9e05aa1

data/lib/everywhere/cli.rb

@@ -5,6 +5,7 @@ require_relative "../everywhere"
 require_relative "framework"
 require_relative "commands/build"
 require_relative "commands/dev"
+require_relative "commands/icon"
 require_relative "commands/doctor"
 require_relative "commands/install"
 require_relative "commands/release"
@@ -33,6 +34,7 @@ module Everywhere
     register "install", Commands::Install
     register "dev",     Commands::Dev
     register "build",   Commands::Build
+    register "icon",    Commands::Icon
     register "release", Commands::Release
 
     register "platform login",       Commands::PlatformLogin

data/lib/everywhere/commands/build.rb

@@ -6,6 +6,7 @@ require "tmpdir"
 require "shellwords"
 require_relative "../shellout"
 require_relative "../png"
+require_relative "../icon"
 require_relative "../paths"
 
 module Everywhere
@@ -122,15 +123,40 @@ module Everywhere
         end
         UI.step("app icon: #{icon_source ? icon_source.sub("#{config.root}/", "") : "placeholder"}")
 
+        # macOS renders icons literally — no OS-applied rounding or margins — so
+        # a full-bleed square looks wrong next to native apps. Bake the Big Sur
+        # look (inset + squircle) into a shaped 1024px master and use it for
+        # both the compiled Dock icon and the bundle .icns. work/ is torn down
+        # when the .app is assembled.
+        work = Dir.mktmpdir("everywhere-icon")
+        macos_icon = icon_source
+        if icon_source
+          shaped = File.join(work, "AppIcon-macos.png")
+          if Everywhere::Icon.macos_master(icon_source, shaped)
+            macos_icon = shaped
+          else
+            UI.warn "couldn't read #{File.basename(icon_source)} (unusual PNG flavor) — using it unshaped"
+          end
+        end
+
         # Tauri bakes icons/icon.png into the shell binary and sets it as the
         # Dock icon at runtime (stomping the bundle's icns after launch), so the
-        # shell must be COMPILED with the app's icon. Swap it in for the build,
-        # restore the placeholder after; touch build.rs so tauri-build re-embeds.
+        # shell must be COMPILED with the app's icon. Swap in the shaped master
+        # for the build, restore the placeholder after; touch build.rs so
+        # tauri-build re-embeds.
         shell_icon = File.join(shell_dir, "icons", "icon.png")
         placeholder_backup = "#{shell_icon}.placeholder"
         if icon_source
           FileUtils.cp(shell_icon, placeholder_backup) unless File.exist?(placeholder_backup)
-          unless Everywhere::PNG.ensure_rgba(icon_source, shell_icon)
+          # The shaped master is already RGBA; fall back to raw RGBA conversion
+          # if shaping failed, and to the placeholder if even that fails.
+          dock_ok = if macos_icon == icon_source
+                      Everywhere::PNG.ensure_rgba(icon_source, shell_icon)
+                    else
+                      FileUtils.cp(macos_icon, shell_icon)
+                      true
+                    end
+          unless dock_ok
             UI.warn "couldn't convert #{File.basename(icon_source)} to RGBA (unusual PNG flavor) — Dock icon will use the placeholder after launch"
             FileUtils.cp(placeholder_backup, shell_icon)
           end
@@ -138,17 +164,18 @@ module Everywhere
         end
 
         UI.step("building shell #{UI.dim("(cargo release)")}")
+        target_dir = Everywhere::Paths.cargo_target_dir
         begin
-          Shellout.run!({}, "cargo", "build", "--release", chdir: shell_dir)
+          Shellout.run!({ "CARGO_TARGET_DIR" => target_dir }, "cargo", "build", "--release", chdir: shell_dir)
         ensure
           if icon_source && File.exist?(placeholder_backup)
             FileUtils.mv(placeholder_backup, shell_icon)
             FileUtils.touch(File.join(shell_dir, "build.rs"))
           end
         end
-        shell_bin = Dir[File.join(shell_dir, "target/release/*")]
+        shell_bin = Dir[File.join(target_dir, "release/*")]
                     .find { |f| File.file?(f) && File.executable?(f) && !f.end_with?(".d") }
-        UI.die!("couldn't find release shell binary in #{shell_dir}/target/release") unless shell_bin
+        UI.die!("couldn't find release shell binary in #{target_dir}/release") unless shell_bin
 
         app_dir = File.join(dist_dir, "#{app_name}.app")
         macos = File.join(app_dir, "Contents", "MacOS")
@@ -170,7 +197,7 @@ module Everywhere
             UI.warn "splash #{splash} not found — using the default splash"
           end
         end
-        icns = make_icns(icon_source || File.join(shell_dir, "icons", "icon.png"), resources)
+        icns = make_icns(macos_icon || File.join(shell_dir, "icons", "icon.png"), resources)
         File.write(File.join(app_dir, "Contents", "Info.plist"),
                    info_plist(app_name, exe_name, icns, config.bundle_id, config.version))
 
@@ -184,24 +211,19 @@ module Everywhere
         Shellout.run?("/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister -f #{app_dir.shellescape} 2>/dev/null")
 
         UI.success("app bundle: #{app_dir.sub("#{Dir.pwd}/", "")} #{UI.dim("(open it!)")}")
+      ensure
+        FileUtils.remove_entry(work) if work && File.directory?(work)
       end
 
-      # macOS ships everything needed to make an .icns from a png.
+      # Write Resources/AppIcon.icns from a (shaped) PNG. Pure Ruby — no sips or
+      # iconutil — so it produces the same icns on any build host.
       def make_icns(png, resources_dir)
         return nil unless File.exist?(png)
 
-        require "shellwords"
-        Dir.mktmpdir do |tmp|
-          iconset = File.join(tmp, "App.iconset")
-          FileUtils.mkdir_p(iconset)
-          [16, 32, 128, 256, 512].each do |size|
-            [[size, "icon_#{size}x#{size}.png"], [size * 2, "icon_#{size}x#{size}@2x.png"]].each do |px, name|
-              Shellout.run?("sips -z #{px} #{px} #{png.shellescape} --out #{File.join(iconset, name).shellescape} >/dev/null 2>&1")
-            end
-          end
-          out = File.join(resources_dir, "AppIcon.icns")
-          return "AppIcon" if Shellout.run?("iconutil -c icns #{iconset.shellescape} -o #{out.shellescape} >/dev/null 2>&1")
-        end
+        out = File.join(resources_dir, "AppIcon.icns")
+        Everywhere::Icon.write_icns(png, out) ? "AppIcon" : nil
+      rescue StandardError => e
+        UI.warn "icon generation failed (#{e.message}) — bundling without a custom icon"
         nil
       end
 

data/lib/everywhere/commands/dev.rb

@@ -33,7 +33,8 @@ module Everywhere
 
         dev_url = "http://127.0.0.1:#{port}#{config.entry_path}"
         UI.step("opening desktop shell → #{UI.cyan(dev_url)}")
-        Shellout.run!({ "NATIVE_DEV_URL" => dev_url, "NATIVE_CONFIG" => config.to_shell_json },
+        Shellout.run!({ "NATIVE_DEV_URL" => dev_url, "NATIVE_CONFIG" => config.to_shell_json,
+                        "CARGO_TARGET_DIR" => Everywhere::Paths.cargo_target_dir },
                       "cargo", "run", chdir: shell_dir)
       ensure
         if server_pid

data/lib/everywhere/commands/icon.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+require "fileutils"
+require_relative "../icon"
+require_relative "../config"
+require_relative "../ui"
+
+module Everywhere
+  module Commands
+    # Generate platform-native app icons from a single source PNG — the same
+    # pipeline `every build` uses, exposed on its own for previewing and CI.
+    class Icon < Dry::CLI::Command
+      desc "Generate macOS (.icns), Windows (.ico) and Linux icons from a source PNG"
+
+      argument :source, required: false, desc: "Source PNG (default: app.icon / icon.png from everywhere.yml)"
+      option :root,   default: ".",     desc: "App root directory (to resolve the default icon)"
+      option :output, default: nil,     desc: "Output directory (default: dist/icons)"
+
+      def call(source: nil, root: ".", output: nil, **)
+        root_path = File.expand_path(root)
+        source ||= default_source(root_path)
+        UI.die!("no source PNG — pass one or set app.icon in everywhere.yml") unless source
+        UI.die!("source PNG not found: #{source}") unless File.exist?(source)
+
+        out = File.expand_path(output || File.join(root_path, "dist", "icons"))
+        FileUtils.mkdir_p(out)
+        UI.step("generating icons from #{File.basename(source)} → #{out.sub("#{Dir.pwd}/", "")}")
+
+        master = File.join(out, "AppIcon-macos.png")
+        unless Everywhere::Icon.macos_master(source, master)
+          UI.die!("couldn't read #{File.basename(source)} — expected an 8-bit RGB/RGBA PNG")
+        end
+        UI.ok("macOS master  #{rel(master, out)} #{UI.dim("(inset + squircle, 1024px)")}")
+
+        Everywhere::Icon.write_icns(master, File.join(out, "AppIcon.icns"))
+        UI.ok("macOS icon    AppIcon.icns")
+
+        Everywhere::Icon.write_ico(source, File.join(out, "icon.ico"))
+        UI.ok("Windows icon  icon.ico")
+
+        pngs = Everywhere::Icon.write_png_set(source, File.join(out, "linux"))
+        UI.ok("Linux icons   linux/ #{UI.dim("(#{pngs.size} sizes)")}")
+
+        UI.success("icons written to #{out.sub("#{Dir.pwd}/", "")}")
+      end
+
+      private
+
+      def rel(path, base)
+        path.sub("#{base}/", "")
+      end
+
+      def default_source(root_path)
+        Everywhere::Config.load(root_path).icon
+      rescue StandardError
+        default = File.join(root_path, "icon.png")
+        File.exist?(default) ? default : nil
+      end
+    end
+  end
+end

data/lib/everywhere/icon.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "raster"
+
+module Everywhere
+  # Turns one source PNG into platform-native app icons — no Tauri, no sips, no
+  # iconutil, no ImageMagick. Pure Ruby, so it runs the same locally and on the
+  # cloud build runners.
+  #
+  # The important part is macОS shaping. macOS renders an .icns *literally*: it
+  # does not round the corners or add margins the way iOS does. A full-bleed
+  # square PNG therefore shows up as a hard square, out of place next to every
+  # native app. So we bake the platform's look into the artwork ourselves —
+  # inset the icon to the Big Sur grid (~824px inside a 1024px canvas) and clip
+  # it to a superellipse ("squircle") with transparent corners.
+  #
+  # Windows (.ico) and Linux (hicolor PNGs) don't get the squircle — those
+  # desktops present square icons — so they're generated straight from the
+  # full-bleed source.
+  module Icon
+    # Big Sur icon-grid geometry, all as fractions of the 1024px canvas so it
+    # scales to any master size.
+    CANVAS       = 1024
+    INSET        = 0.8047 # icon body is 824/1024 of the canvas
+    CORNER_RATIO = 0.2237 # corner radius as a fraction of the body's side
+    EXPONENT     = 5.0    # superellipse power — the iOS/macOS "squircle" corner
+
+    # .icns type codes -> pixel size. Mirrors what `iconutil` emits from a
+    # standard .iconset (retina variants included), so the result is
+    # indistinguishable from an Apple-toolchain icns.
+    ICNS_TYPES = [
+      ["icp4", 16], ["icp5", 32], ["ic07", 128], ["ic08", 256], ["ic09", 512],
+      ["ic11", 32], ["ic12", 64], ["ic13", 256], ["ic14", 512], ["ic10", 1024]
+    ].freeze
+
+    ICO_SIZES   = [16, 32, 48, 64, 128, 256].freeze
+    LINUX_SIZES = [16, 32, 48, 64, 128, 256, 512].freeze
+
+    module_function
+
+    # Write a macOS-shaped 1024px RGBA master PNG (padding + squircle) from a
+    # source PNG. Returns true, or false if the source PNG can't be read.
+    def macos_master(source, dest, canvas: CANVAS)
+      raster = Raster.decode_png(source) or return false
+
+      body = (canvas * INSET).round
+      offset = (canvas - body) / 2
+
+      # Fit the artwork inside the body square preserving aspect ratio (square
+      # sources fill it exactly; non-square ones are centred, not stretched).
+      fit = [body.to_f / raster.width, body.to_f / raster.height].min
+      sw = (raster.width * fit).round.clamp(1, body)
+      sh = (raster.height * fit).round.clamp(1, body)
+      scaled = raster.resample(sw, sh)
+
+      out = Raster.transparent(canvas, canvas)
+      out.paste!(scaled, offset + (body - sw) / 2, offset + (body - sh) / 2)
+
+      centre = canvas / 2.0
+      half = body / 2.0
+      radius = [body * CORNER_RATIO, half].min
+      straight = half - radius # half-extent of the straight edges
+      out.mask_region!(offset, offset, offset + body, offset + body) do |x, y|
+        squircle_coverage(x, y, centre, half, straight, radius, EXPONENT)
+      end
+
+      out.write_png(dest)
+      true
+    end
+
+    # Build a macOS .icns from an already-shaped master PNG (ideally 1024px).
+    # Returns true on success.
+    def write_icns(master_png, dest)
+      master = Raster.decode_png(master_png) or return false
+
+      body = ICNS_TYPES.map do |type, size|
+        png = sized_png(master, size)
+        type.b + [png.bytesize + 8].pack("N") + png
+      end.join
+
+      File.binwrite(dest, "icns".b + [body.bytesize + 8].pack("N") + body)
+      true
+    end
+
+    # Build a Windows .ico (PNG-compressed entries, Vista+) from a full-bleed
+    # source PNG. Returns true on success.
+    def write_ico(source, dest, sizes: ICO_SIZES)
+      master = Raster.decode_png(source) or return false
+
+      images = sizes.map { |s| [s, sized_png(master, s)] }
+      offset = 6 + images.size * 16
+      entries = +"".b
+      blob = +"".b
+      images.each do |size, png|
+        dim = size >= 256 ? 0 : size # 0 means 256 in the ICONDIRENTRY
+        entries << [dim, dim, 0, 0, 1, 32, png.bytesize, offset].pack("CCCCvvVV")
+        blob << png
+        offset += png.bytesize
+      end
+
+      header = [0, 1, images.size].pack("vvv") # reserved, type=icon, count
+      File.binwrite(dest, header + entries + blob)
+      true
+    end
+
+    # Write a set of square PNGs (Linux/desktop use) named "<size>x<size>.png"
+    # into dest_dir from a full-bleed source. Returns the written paths.
+    def write_png_set(source, dest_dir, sizes: LINUX_SIZES)
+      master = Raster.decode_png(source) or return []
+
+      FileUtils.mkdir_p(dest_dir)
+      sizes.map do |size|
+        path = File.join(dest_dir, "#{size}x#{size}.png")
+        File.binwrite(path, sized_png(master, size))
+        path
+      end
+    end
+
+    # PNG bytes of `master` at `size`x`size` (no-op resample when already sized).
+    def sized_png(master, size)
+      (size == master.width && size == master.height ? master : master.resample(size, size)).encode_png
+    end
+
+    # Coverage (0.0..1.0) of pixel (x, y) by the squircle: a rounded rectangle
+    # with continuous (superelliptical) corners. Interior pixels return 1.0,
+    # exterior 0.0, and boundary pixels are antialiased by 4x4 supersampling.
+    def squircle_coverage(x, y, centre, half, straight, radius, exponent)
+      c0 = squircle_inside?(x,     y,     centre, half, straight, radius, exponent)
+      c1 = squircle_inside?(x + 1, y,     centre, half, straight, radius, exponent)
+      c2 = squircle_inside?(x,     y + 1, centre, half, straight, radius, exponent)
+      c3 = squircle_inside?(x + 1, y + 1, centre, half, straight, radius, exponent)
+      return 1.0 if c0 && c1 && c2 && c3
+      return 0.0 unless c0 || c1 || c2 || c3
+
+      hit = 0
+      4.times do |i|
+        4.times do |j|
+          hit += 1 if squircle_inside?(x + (i + 0.5) / 4.0, y + (j + 0.5) / 4.0,
+                                       centre, half, straight, radius, exponent)
+        end
+      end
+      hit / 16.0
+    end
+
+    # Is the continuous point (sx, sy) inside the squircle? Straight edges up to
+    # `straight` from centre, superelliptical corners of `radius` beyond that.
+    def squircle_inside?(sx, sy, centre, half, straight, radius, exponent)
+      u = (sx - centre).abs
+      v = (sy - centre).abs
+      return false if u > half || v > half
+      return true if u <= straight || v <= straight
+
+      du = (u - straight) / radius
+      dv = (v - straight) / radius
+      (du**exponent) + (dv**exponent) <= 1.0
+    end
+  end
+end

data/lib/everywhere/paths.rb

@@ -31,5 +31,18 @@ module Everywhere
       shell_dir or UI.die!("couldn't find the bundled shell at #{bundled_shell_dir}; " \
                            "reinstall ruby_everywhere or pass --shell-dir")
     end
+
+    # Per-user cache dir. Keeps heavy build state out of the gem and the app.
+    def cache_dir
+      File.expand_path(ENV["RUBYEVERYWHERE_HOME"] || "~/.rubyeverywhere")
+    end
+
+    # Where cargo writes the shell's build output (CARGO_TARGET_DIR). Redirected
+    # here so cargo never dumps a multi-GB target/ into the installed gem, and so
+    # the shell compiles warm across projects — the shell source is identical for
+    # everyone, so one shared target dir is safe to reuse.
+    def cargo_target_dir
+      File.join(cache_dir, "shell-target")
+    end
   end
 end

data/lib/everywhere/png.rb

@@ -39,6 +39,60 @@ module Everywhere
       true
     end
 
+    # Decode an 8-bit RGB/RGBA PNG to a flat RGBA pixel buffer. Returns
+    # [width, height, bytes] (bytes = width*height*4, no per-scanline filter
+    # byte) or nil for flavors we don't handle (palette, 16-bit, interlaced,
+    # grayscale). This is the pixel gateway the Raster/Icon generators build on.
+    def decode_rgba(path)
+      data = File.binread(path)
+      return nil unless data.start_with?(SIGNATURE)
+
+      chunks = read_chunks(data)
+      ihdr = chunks.find { |type, _| type == "IHDR" }&.last or return nil
+      width, height, depth, color, _comp, _filter, interlace = ihdr.unpack("NNC5")
+      return nil unless depth == 8 && interlace.zero?
+      return nil unless color == 2 || color == 6 # RGB or RGBA
+
+      bpp = color == 6 ? 4 : 3
+      raw = Zlib::Inflate.inflate(chunks.select { |t, _| t == "IDAT" }.map(&:last).join)
+      stride = width * bpp
+      prev = "\0".b * stride
+      out = String.new(capacity: width * height * 4)
+
+      height.times do |y|
+        filter = raw.getbyte(y * (stride + 1))
+        line = raw.byteslice(y * (stride + 1) + 1, stride).dup
+        unfilter!(line, prev, filter, bpp)
+        if bpp == 4
+          out << line
+        else
+          x = 0
+          while x < width
+            out << line.byteslice(x * 3, 3) << "\xFF".b
+            x += 1
+          end
+        end
+        prev = line
+      end
+      [width, height, out]
+    end
+
+    # Encode a flat RGBA pixel buffer to PNG bytes (filter 0, single IDAT).
+    def encode_rgba(width, height, rgba)
+      stride = width * 4
+      raw = String.new(capacity: (stride + 1) * height)
+      height.times do |y|
+        raw << "\0".b # filter: None
+        raw << rgba.byteslice(y * stride, stride)
+      end
+
+      out = SIGNATURE.dup
+      out << chunk("IHDR", [width, height, 8, 6, 0, 0, 0].pack("NNC5"))
+      out << chunk("IDAT", Zlib::Deflate.deflate(raw, Zlib::BEST_COMPRESSION))
+      out << chunk("IEND", "")
+      out
+    end
+
     def read_chunks(data)
       chunks = []
       pos = 8

data/lib/everywhere/raster.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require_relative "png"
+
+module Everywhere
+  # A mutable RGBA raster and the handful of pixel operations the icon
+  # generator needs — decode/encode PNG, high-quality resampling, pasting, and
+  # a superellipse ("squircle") alpha mask. Pure Ruby (zlib only): no
+  # ImageMagick, no sips, no Tauri. Works the same on any OS the CLI runs on.
+  #
+  # Pixels are stored as a flat 8-bit RGBA byte string (row-major, 4 bytes per
+  # pixel). Resampling is a separable area/box filter done in *premultiplied*
+  # alpha so transparent regions never bleed their colour into opaque edges.
+  class Raster
+    attr_reader :width, :height, :pixels
+
+    def initialize(width, height, pixels = nil)
+      @width = width
+      @height = height
+      @pixels = pixels || ("\x00".b * (width * height * 4))
+    end
+
+    # A fully transparent canvas.
+    def self.transparent(width, height)
+      new(width, height)
+    end
+
+    # Decode a PNG file into a Raster, or nil if it's a flavor PNG.decode_rgba
+    # can't read (palette, 16-bit, interlaced, grayscale).
+    def self.decode_png(path)
+      width, height, bytes = PNG.decode_rgba(path)
+      return nil unless width
+
+      new(width, height, bytes)
+    end
+
+    def encode_png
+      PNG.encode_rgba(width, height, pixels)
+    end
+
+    def write_png(path)
+      File.binwrite(path, encode_png)
+    end
+
+    # Resample to a new size with a separable area filter. Great for the
+    # downscales an icon set is made of; degrades gracefully on upscale.
+    def resample(new_width, new_height)
+      return self if new_width == width && new_height == height
+
+      # Premultiplied float channels: pr = r * (a/255), etc.
+      pr = Array.new(width * height)
+      pg = Array.new(width * height)
+      pb = Array.new(width * height)
+      pa = Array.new(width * height)
+      i = 0
+      (width * height).times do |p|
+        a = pixels.getbyte(i + 3)
+        af = a / 255.0
+        pr[p] = pixels.getbyte(i) * af
+        pg[p] = pixels.getbyte(i + 1) * af
+        pb[p] = pixels.getbyte(i + 2) * af
+        pa[p] = a.to_f
+        i += 4
+      end
+
+      # Horizontal pass (width -> new_width), then vertical (height -> new_height).
+      wx = self.class.axis_weights(width, new_width)
+      hr = resample_axis(pr, width, height, new_width, wx, rows: true)
+      hg = resample_axis(pg, width, height, new_width, wx, rows: true)
+      hb = resample_axis(pb, width, height, new_width, wx, rows: true)
+      ha = resample_axis(pa, width, height, new_width, wx, rows: true)
+
+      wy = self.class.axis_weights(height, new_height)
+      vr = resample_axis(hr, new_width, height, new_height, wy, rows: false)
+      vg = resample_axis(hg, new_width, height, new_height, wy, rows: false)
+      vb = resample_axis(hb, new_width, height, new_height, wy, rows: false)
+      va = resample_axis(ha, new_width, height, new_height, wy, rows: false)
+
+      out = String.new(capacity: new_width * new_height * 4)
+      (new_width * new_height).times do |p|
+        a = va[p]
+        if a <= 0.001
+          out << "\x00\x00\x00\x00".b
+        else
+          out << [
+            (vr[p] * 255.0 / a).round.clamp(0, 255),
+            (vg[p] * 255.0 / a).round.clamp(0, 255),
+            (vb[p] * 255.0 / a).round.clamp(0, 255),
+            a.round.clamp(0, 255)
+          ].pack("C4")
+        end
+      end
+      self.class.new(new_width, new_height, out)
+    end
+
+    # Copy src into this raster with its top-left at (ox, oy), replacing pixels
+    # (the canvas is transparent underneath, so a plain copy is the composite).
+    def paste!(src, ox, oy)
+      row = src.width * 4
+      src.height.times do |y|
+        dst_index = ((oy + y) * width + ox) * 4
+        pixels[dst_index, row] = src.pixels.byteslice(y * row, row)
+      end
+      self
+    end
+
+    # Multiply the alpha channel of every pixel in [x0, x1) x [y0, y1) by the
+    # coverage the block returns for pixel (x, y) — a value in 0.0..1.0.
+    # Pixels outside the range keep their (already transparent) alpha.
+    def mask_region!(x0, y0, x1, y1)
+      y0.upto(y1 - 1) do |y|
+        base = y * width
+        x0.upto(x1 - 1) do |x|
+          cov = yield(x, y)
+          next if cov >= 1.0
+
+          idx = (base + x) * 4 + 3
+          a = pixels.getbyte(idx)
+          next if a.zero?
+
+          pixels.setbyte(idx, cov <= 0.0 ? 0 : (a * cov).round)
+        end
+      end
+      self
+    end
+
+    # For each output index along an axis of `n_out` pixels, the list of
+    # [input_index, weight] contributions, where weights sum to 1 (area filter:
+    # each output pixel is the average of the input pixels it overlaps).
+    def self.axis_weights(n_in, n_out)
+      scale = n_in.to_f / n_out
+      Array.new(n_out) do |i|
+        start = i * scale
+        finish = [start + scale, n_in.to_f].min # float slop can push this past n_in
+        weights = []
+        k = [start.floor, 0].max
+        while k < finish && k < n_in
+          lo = [k.to_f, start].max
+          hi = [k + 1.0, finish].min
+          overlap = hi - lo
+          weights << [k, overlap / scale] if overlap > 0
+          k += 1
+        end
+        weights
+      end
+    end
+
+    private
+
+    # Resample one float channel along a single axis. `rows: true` resizes each
+    # row from `n_in` to `n_out` columns; `rows: false` resizes each column.
+    def resample_axis(src, in_w, in_h, n_out, weights, rows:)
+      if rows
+        out = Array.new(n_out * in_h, 0.0)
+        in_h.times do |y|
+          src_base = y * in_w
+          out_base = y * n_out
+          n_out.times do |o|
+            acc = 0.0
+            weights[o].each { |k, wt| acc += src[src_base + k] * wt }
+            out[out_base + o] = acc
+          end
+        end
+        out
+      else
+        out = Array.new(in_w * n_out, 0.0)
+        in_w.times do |x|
+          n_out.times do |o|
+            acc = 0.0
+            weights[o].each { |k, wt| acc += src[k * in_w + x] * wt }
+            out[o * in_w + x] = acc
+          end
+        end
+        out
+      end
+    end
+  end
+end

data/lib/everywhere/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Everywhere
-  VERSION = "0.1.1"
+  VERSION = "0.1.3"
 
   # Version of the vendored @rubyeverywhere/bridge JS this gem ships. Tracks
   # bridge/package.json — bump it whenever lib/everywhere/javascript/bridge.js is

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_everywhere
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Andrea Fomera
@@ -55,6 +55,7 @@ files:
 - lib/everywhere/commands/build.rb
 - lib/everywhere/commands/dev.rb
 - lib/everywhere/commands/doctor.rb
+- lib/everywhere/commands/icon.rb
 - lib/everywhere/commands/install.rb
 - lib/everywhere/commands/platform/auth_status.rb
 - lib/everywhere/commands/platform/build.rb
@@ -65,6 +66,7 @@ files:
 - lib/everywhere/config.rb
 - lib/everywhere/database.rb
 - lib/everywhere/framework.rb
+- lib/everywhere/icon.rb
 - lib/everywhere/ignore.rb
 - lib/everywhere/javascript/bridge.js
 - lib/everywhere/paths.rb
@@ -72,6 +74,7 @@ files:
 - lib/everywhere/platform/credentials.rb
 - lib/everywhere/platform/snapshot.rb
 - lib/everywhere/png.rb
+- lib/everywhere/raster.rb
 - lib/everywhere/receipt.rb
 - lib/everywhere/shellout.rb
 - lib/everywhere/ui.rb