raintron 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a6b1d170c35f358a45bf58c160ce9f152df7eeeb34b94e493fd7a34ab2adbbc9
+  data.tar.gz: bfe651149441d068ee3b4aee2eee117e5ab060efbb18700a441daca3e466d046
+SHA512:
+  metadata.gz: 3a2ce70b82026b74d7aed41899b35fdd3f78af7b61f88d094bc8d428f4423b73da96e1d244f71e50ef1a7df58c583698f293af3098ec3082f6facbdb8a832b35
+  data.tar.gz: 47dbe0916121d40a47734ebfe0a7b0aff18cf63046d32f6e0708867b5474044f89bf5c06834db474fe208fc9fea71d1976c94e96325112886ffd9d84f9b441be

data/bin/bump

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Bumps the minor version, like 1.0.5 to 1.1.0, or with --patch the patch version, like 1.0.5 to 1.0.6, and names the
+# changelog's Unreleased changes after it, then runs bundle update, so Gemfile.lock has it too, and commits the version,
+# the changelog and Gemfile.lock (when git tracks it) as "Release v1.1.0", leaving any other changes out of it.
+#   bin/bump
+#   bin/bump --patch
+#   bin/bump -p
+
+Dir.chdir(File.expand_path('..', __dir__))
+path = 'lib/version.rb'
+source = File.read(path)
+version = source[/VERSION = '(\d+\.\d+\.\d+)'/, 1] or abort("There's no VERSION like '1.2.3' in #{path}")
+
+major, minor, patch = version.split('.').map(&:to_i)
+bumped = "#{major}.#{minor + 1}.0"
+bumped = "#{major}.#{minor}.#{patch + 1}" if ARGV.intersect?(%w[--patch -p])
+File.write(path, source.sub("VERSION = '#{version}'", "VERSION = '#{bumped}'"))
+puts "Bumped #{version} to #{bumped}"
+
+changelog = File.read('CHANGELOG.md')
+released = changelog.sub(/^## Unreleased$/, "## #{bumped}")
+File.write('CHANGELOG.md', released)
+files = [path]
+files << 'Gemfile.lock' unless `git ls-files Gemfile.lock`.empty?
+files << 'CHANGELOG.md' unless released == changelog
+
+system('bundle', 'update', '--all', exception: true)
+system('git', 'commit', '-m', "Release v#{bumped}", '--', *files, exception: true)

data/bin/raintron

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'cli/cli'
+
+Raintron::CLI.run(ARGV)

data/lib/app_config/app_config.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Raintron
+  # Reads a consuming app's own config/config.yaml so bin/desktop and `raintron press`
+  # stay in sync with whatever `rain server` actually uses, instead of hardcoding
+  # host/port separately from the app's real configuration.
+  module AppConfig
+    DEFAULT_HOST = '127.0.0.1'
+    DEFAULT_PORT = 4133
+
+    def self.host(app_root: Dir.pwd)
+      read(app_root).fetch('host', DEFAULT_HOST)
+    end
+
+    def self.port(app_root: Dir.pwd)
+      read(app_root).fetch('port', DEFAULT_PORT)
+    end
+
+    # "hidden" for a window without a title bar, on macOS, which the page takes the place of; see WindowChrome.
+    def self.titlebar(app_root: Dir.pwd)
+      read(app_root).fetch('titlebar', 'native')
+    end
+
+    def self.read(app_root)
+      path = File.join(app_root, 'config', 'config.yaml')
+      return {} unless File.exist?(path)
+
+      YAML.safe_load_file(path) || {}
+    end
+  end
+end

data/lib/cli/cli.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'trees'
+require_relative '../raintron'
+require_relative '../generator/generator'
+require_relative '../commands/install'
+require_relative '../commands/press'
+require_relative '../commands/doctor'
+require_relative '../commands/icons'
+
+module Raintron
+  # `trees`' Trie#match requires the ENTIRE args array to be consumed by one defined
+  # path -- it has no concept of trailing/optional args at all (verified directly
+  # against ~/dev/trees/lib/trie.rb's #full_match, which fails the whole match if any
+  # token is left over). So trees is used only to route the bare verb (a single
+  # token); everything after it is handed to the command UNSPLIT, and each command
+  # uses OptionParser#parse (non-destructive) to separate its own flags from any
+  # positional argument -- OptionParser knows which flags consume a following value
+  # (e.g. `--width 900` is two tokens), which a naive "starts with -" split does not.
+  module CLI
+    extend Trees
+
+    class << self
+      attr_accessor :argv
+    end
+
+    line('install') do
+      summary { 'Wire desktop-app capability into the current Raindeer app.' }
+      execute { Commands::Install.run(argv: CLI.argv) }
+    end
+
+    line('press') do
+      summary { 'Pack the app into a native executable with Tebako.' }
+      execute { Commands::Press.run(argv: CLI.argv) }
+    end
+
+    line('icons') do
+      summary { 'Regenerate app icons (.icns/.ico/.png).' }
+      execute { Commands::Icons.run(argv: CLI.argv) }
+    end
+
+    line('doctor') do
+      summary { 'Check native toolkit prerequisites for webview_ruby.' }
+      execute { Commands::Doctor.run }
+    end
+
+    singleton_class.send(:alias_method, :dispatch, :run)
+
+    def self.run(argv)
+      return usage if argv.empty?
+
+      verb, *rest = argv
+      self.argv = rest
+
+      dispatch([verb]) || unknown_command(verb)
+    end
+
+    def self.usage
+      warn 'usage: raintron <install|press|icons|doctor> [options]'
+      exit(1)
+    end
+
+    def self.unknown_command(verb)
+      warn "raintron: unknown command #{verb.inspect}"
+      warn 'Available commands: install, press, icons, doctor'
+      exit(1)
+    end
+  end
+end

data/lib/commands/doctor.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'stringio'
+require_relative '../preflight/preflight'
+
+module Raintron
+  module Commands
+    # Runs the native-toolkit preflight check on demand, with explicit pass/fail
+    # framing (Preflight.check! itself only warns on failure and is silent on
+    # success, since it's designed to run quietly at Gemfile-eval time).
+    class Doctor
+      def self.run
+        new.run
+      end
+
+      def run
+        warnings = capture_warnings { Preflight.check! }
+
+        if warnings.empty?
+          puts 'raintron doctor: OK -- native toolkit prerequisites for webview_ruby look good.'
+        else
+          warnings.each { |warning| warn warning }
+          exit(1)
+        end
+      end
+
+      private
+
+      def capture_warnings
+        original = $stderr
+        $stderr = StringIO.new
+        yield
+        $stderr.string.split("\n\n").reject(&:empty?)
+      ensure
+        $stderr = original
+      end
+    end
+  end
+end

data/lib/commands/icons.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Raintron
+  module Commands
+    # Regenerates icons standalone (without the rest of `raintron install`), e.g.
+    # after swapping in a new source logo.
+    class Icons
+      def self.run(argv: [])
+        new.run(argv:)
+      end
+
+      def run(argv:)
+        options, positional = parse(argv)
+        name = positional.first || options[:name] || File.basename(Dir.pwd)
+
+        paths = IconGenerator.generate(output_dir: 'icons', basename: name, source: options[:source])
+        puts "Wrote #{paths.values.join(', ')}"
+      end
+
+      private
+
+      def parse(argv)
+        options = {}
+        positional = OptionParser.new do |parser|
+          parser.on('--name NAME') { |value| options[:name] = value }
+          parser.on('--source PATH') { |value| options[:source] = value }
+        end.parse(argv)
+        [options, positional]
+      end
+    end
+  end
+end

data/lib/commands/install.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'fileutils'
+
+module Raintron
+  module Commands
+    # Wires desktop-app capability into the raindeer app in the current directory:
+    # bin/desktop, a macOS .app bundle, icons, and a Tebako packing CI workflow.
+    # Idempotent -- re-running skips files that already exist unless --force.
+    class Install
+      DEFAULT_WIDTH = 900
+      DEFAULT_HEIGHT = 600
+
+      def self.run(argv: [])
+        new.run(argv:)
+      end
+
+      def run(argv:)
+        options, positional = parse(argv)
+        app_name = resolve_app_name(options, positional)
+        bundle_dir = "#{camelize(app_name)}.app"
+        force = options[:force] || false
+
+        generator = Generator.new(force:)
+        render_templates(generator:, app_name:, bundle_dir:, options:)
+        install_icons(app_name:, bundle_dir:, source: options[:icon], force:)
+        insert_gemfile_guard!
+
+        puts "raintron installed. Run `bundle exec bin/desktop` to launch #{app_name}."
+      end
+
+      private
+
+      # OptionParser#parse (non-destructive) returns the leftover non-option
+      # arguments -- e.g. a bare app name -- rather than raising or discarding them,
+      # unlike a naive "does this token start with -" split (which mishandles any
+      # flag that takes a following value, like `--width 900`).
+      def parse(argv)
+        options = {}
+        positional = OptionParser.new do |parser|
+          parser.on('--name NAME') { |value| options[:name] = value }
+          parser.on('--width N', Integer) { |value| options[:width] = value }
+          parser.on('--height N', Integer) { |value| options[:height] = value }
+          parser.on('--bundle-id ID') { |value| options[:bundle_id] = value }
+          parser.on('--icon PATH') { |value| options[:icon] = value }
+          parser.on('--force') { options[:force] = true }
+        end.parse(argv)
+        [options, positional]
+      end
+
+      def resolve_app_name(options, positional)
+        name = positional.first || options[:name] || default_name
+        return name unless positional.empty? && options[:name].nil? && $stdin.tty?
+
+        prompt_for_name(name)
+      end
+
+      def render_templates(generator:, app_name:, bundle_dir:, options:)
+        bundle_id = options[:bundle_id] || "dev.local.#{app_name}"
+        width = options[:width] || DEFAULT_WIDTH
+        height = options[:height] || DEFAULT_HEIGHT
+
+        generator.render('bin/desktop.erb', 'bin/desktop', app_name:, width:, height:)
+        generator.render('app/Contents/Info.plist.erb', "#{bundle_dir}/Contents/Info.plist", app_name:, bundle_id:)
+        generator.render('app/Contents/MacOS/launch.erb', "#{bundle_dir}/Contents/MacOS/launch", {})
+        generator.render('icons/app.desktop.erb', "icons/#{app_name}.desktop", app_name:)
+        generator.render('github/workflows/build.yml.erb', '.github/workflows/build.yml',
+                         app_name:, ruby_version: detect_ruby_version)
+      end
+
+      def default_name
+        File.basename(Dir.pwd)
+      end
+
+      def prompt_for_name(default)
+        print "App name [#{default}]: "
+        input = $stdin.gets&.strip
+        input.nil? || input.empty? ? default : input
+      end
+
+      def camelize(name)
+        name.split(/[-_]/).map { |part| part[0].upcase + part[1..].to_s }.join
+      end
+
+      def detect_ruby_version
+        File.read('.ruby-version').strip
+      rescue Errno::ENOENT
+        RUBY_VERSION
+      end
+
+      def install_icons(app_name:, bundle_dir:, source:, force:)
+        icons_dir = File.join(Dir.pwd, 'icons')
+        icns_path = File.join(icons_dir, "#{app_name}.icns")
+
+        if File.exist?(icns_path) && !force
+          warn "skip icons/#{app_name}.icns (already exists; pass --force to overwrite)"
+        else
+          IconGenerator.generate(output_dir: icons_dir, basename: app_name, source:)
+        end
+
+        resources_dir = "#{bundle_dir}/Contents/Resources"
+        FileUtils.mkdir_p(resources_dir)
+        FileUtils.cp(icns_path, File.join(resources_dir, 'AppIcon.icns'))
+      end
+
+      # Inserts a self-contained toolkit check into the consuming app's Gemfile.
+      #
+      # This can NOT be a `require 'preflight/preflight'` delegating to Raintron's own
+      # Preflight module, however appealing that would be for keeping the check in one
+      # place -- verified directly by running this end-to-end: Bundler evaluates the
+      # Gemfile DSL top-to-bottom to build the dependency list BEFORE it resolves and
+      # activates any gem (including one declared later in the very same Gemfile), so
+      # a `require` of another Gemfile-declared gem's code fails every single time,
+      # not just occasionally. The logic is duplicated here as inline text instead;
+      # `raintron doctor` and this snippet can drift, but a working duplicate beats a
+      # DRY snippet that breaks every subsequent `bundle` command.
+      #
+      # Inserted AFTER any leading comment block (magic comments like
+      # `# frozen_string_literal: true` only take effect before the first real line
+      # of code -- verified directly: prepending code above one silently disables it
+      # for the rest of the file), never before it.
+      def insert_gemfile_guard!
+        path = 'Gemfile'
+        return unless File.exist?(path)
+
+        guard = <<~RUBY
+          case RbConfig::CONFIG['host_os']
+          when /darwin/
+            unless system('xcrun --find clang++', out: File::NULL, err: File::NULL)
+              warn 'warning: webview_ruby needs the Xcode Command Line Tools to compile its native ' \\
+                   "extension. Install them with: xcode-select --install"
+            end
+          when /linux/
+            unless system('pkg-config --exists gtk+-3.0 webkit2gtk-4.0', out: File::NULL, err: File::NULL)
+              warn 'warning: webview_ruby needs GTK3 + WebKit2GTK development headers to compile its ' \\
+                   'native extension, e.g.: sudo apt-get install -y build-essential libgtk-3-dev libwebkit2gtk-4.0-dev'
+            end
+          end
+
+        RUBY
+        content = File.read(path)
+        return if content.include?(guard)
+
+        lines = content.lines
+        insert_at = lines.index { |line| !line.start_with?('#') && !line.strip.empty? } || lines.size
+        new_content = (lines[0...insert_at] + [guard] + lines[insert_at..]).join
+
+        File.write(path, new_content)
+      end
+    end
+  end
+end

data/lib/commands/press.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'fileutils'
+
+module Raintron
+  module Commands
+    # Wraps `tebako press` with sensible defaults, so consumers don't need to
+    # memorize its flags. Validated this session against a real pressed build that
+    # boots and serves HTTP 200.
+    class Press
+      DEFAULT_OUTPUT_DIR = 'dist'
+
+      def self.run(argv: [])
+        new.run(argv:)
+      end
+
+      def run(argv:)
+        options = parse(argv)
+
+        abort_unless_tebako_available!
+        abort_unless_entry_point_exists!
+
+        ruby_version = options[:ruby] || detect_ruby_version
+        output = options[:output] || default_output
+
+        FileUtils.mkdir_p(File.dirname(output))
+
+        command = [
+          'tebako', 'press',
+          '-r', '.',
+          '-e', 'bin/desktop',
+          '-o', output,
+          '-R', ruby_version,
+          '--format', 'dwarfs'
+        ]
+
+        warn_if_windows
+
+        puts "$ #{command.join(' ')}"
+        exit(1) unless system(*command)
+      end
+
+      private
+
+      def parse(argv)
+        options = {}
+        OptionParser.new do |parser|
+          parser.on('-R VERSION', '--ruby VERSION') { |value| options[:ruby] = value }
+          parser.on('-o PATH', '--output PATH') { |value| options[:output] = value }
+        end.parse(argv)
+        options
+      end
+
+      def abort_unless_tebako_available!
+        return if system('which tebako', out: File::NULL, err: File::NULL)
+
+        warn 'tebako is not on PATH. Install it first: https://tebako.org/install.sh'
+        exit(1)
+      end
+
+      def abort_unless_entry_point_exists!
+        return if File.exist?('bin/desktop')
+
+        warn 'bin/desktop not found. Run `raintron install` first.'
+        exit(1)
+      end
+
+      def detect_ruby_version
+        return File.read('.ruby-version').strip if File.exist?('.ruby-version')
+        return tool_versions_ruby if File.exist?('.tool-versions')
+
+        RUBY_VERSION
+      rescue Errno::ENOENT
+        RUBY_VERSION
+      end
+
+      def tool_versions_ruby
+        line = File.readlines('.tool-versions').find { |l| l.start_with?('ruby ') }
+        line ? line.split[1] : RUBY_VERSION
+      end
+
+      def default_output
+        app_name = File.basename(Dir.pwd)
+        os = case RbConfig::CONFIG['host_os']
+             when /darwin/ then 'macos'
+             when /linux/ then 'linux'
+             when /mswin|mingw|cygwin/ then 'windows'
+             else RbConfig::CONFIG['host_os']
+             end
+        ext = os == 'windows' ? '.exe' : ''
+        File.join(DEFAULT_OUTPUT_DIR, "#{app_name}-#{os}#{ext}")
+      end
+
+      def warn_if_windows
+        return unless RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+
+        warn 'warning: Tebako\'s Windows release leg is still "in flight" upstream, and ' \
+             "webview_ruby's own native-extension build fails under Windows' MinGW toolchain " \
+             '(its Edge backend needs C++/WinRT headers only MSVC + the Windows SDK provide). ' \
+             'This press is not expected to succeed yet.'
+      end
+    end
+  end
+end

data/lib/generator/generator.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'fileutils'
+
+module Raintron
+  # Renders raintron's ERB templates into a consuming app's directory. Skips files
+  # that already exist (so re-running `raintron install` is safe) unless force: true.
+  class Generator
+    TEMPLATES_ROOT = File.expand_path('../../templates', __dir__)
+
+    def initialize(destination_root: Dir.pwd, force: false, templates_root: TEMPLATES_ROOT)
+      @destination_root = destination_root
+      @force = force
+      @templates_root = templates_root
+    end
+
+    # template_path: path under templates/, WITH the .erb suffix (e.g. 'bin/desktop.erb').
+    # destination_path: path under destination_root, WITHOUT .erb (e.g. 'bin/desktop').
+    # Returns the written path, or nil if skipped.
+    def render(template_path, destination_path, vars = {})
+      source = File.join(@templates_root, template_path)
+      dest = File.join(@destination_root, destination_path)
+
+      if File.exist?(dest) && !@force
+        warn "skip #{destination_path} (already exists; pass --force to overwrite)"
+        return nil
+      end
+
+      content = ERB.new(File.read(source), trim_mode: '-').result_with_hash(vars)
+
+      FileUtils.mkdir_p(File.dirname(dest))
+      File.write(dest, content)
+      File.chmod(0o755, dest) if File.executable?(source)
+
+      dest
+    end
+  end
+end

data/lib/icons/icns_writer.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Raintron
+  # Apple .icns container -- replaces shelling out to `iconutil`. Format: magic "icns"
+  # + big-endian u32 total length, then chunks of (4-byte OSType + big-endian u32
+  # chunk length INCLUDING this 8-byte header + a raw PNG payload). Modern macOS
+  # accepts PNG payloads in these slots (cited: Wikipedia's Apple Icon Image Format
+  # page, hexbase.dev, mdsteele/rust-icns, Pillow's IcnsImagePlugin -- there's no
+  # official public Apple spec).
+  #
+  # This exact type/size table replicates `iconutil -c icns`'s own .iconset mapping.
+  # An earlier draft omitted the icp4/icp5 @1x slots (16px/32px); a real regression
+  # (electron-builder#9940) shows that omission renders broken/scrambled icons in
+  # Finder list view and Trash at small sizes, so they're included here deliberately.
+  module IcnsWriter
+    SIZE_MAP = [
+      ['icp4', 16],  # 16@1x
+      ['ic11', 32],  # 16@2x
+      ['icp5', 32],  # 32@1x
+      ['ic12', 64],  # 32@2x
+      ['ic07', 128], # 128@1x
+      ['ic13', 256], # 128@2x
+      ['ic08', 256], # 256@1x
+      ['ic14', 512], # 256@2x
+      ['ic09', 512], # 512@1x
+      ['ic10', 1024] # 512@2x
+    ].freeze
+
+    # pngs_by_size: { pixel_size => png_bytes }
+    def self.encode(pngs_by_size:)
+      body = String.new(encoding: Encoding::BINARY)
+      SIZE_MAP.each do |type, size|
+        png = pngs_by_size.fetch(size)
+        body << type.b
+        body << [8 + png.bytesize].pack('N')
+        body << png
+      end
+
+      'icns'.b + [8 + body.bytesize].pack('N') + body
+    end
+  end
+end

data/lib/icons/ico_writer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Raintron
+  # Windows .ico container. Vista+ PNG-compressed ICONDIRENTRYs -- valid since Windows
+  # Vista, verified this session by building one and confirming `file` reports a
+  # well-formed multi-size icon resource.
+  module IcoWriter
+    DEFAULT_SIZES = [16, 24, 32, 48, 64, 128, 256].freeze
+
+    # entries: [{ size: Integer, png: String }, ...]
+    def self.encode(entries:)
+      header = [0, 1, entries.size].pack('v3')
+      offset = header.bytesize + (16 * entries.size)
+      directory = String.new(encoding: Encoding::BINARY)
+      data = String.new(encoding: Encoding::BINARY)
+
+      entries.each do |entry|
+        size = entry.fetch(:size)
+        png = entry.fetch(:png)
+        wh = size < 256 ? size : 0 # 0 means 256, per the ICO spec
+        directory << [wh, wh, 0, 0, 1, 32, png.bytesize, offset].pack('C4v2V2')
+        data << png
+        offset += png.bytesize
+      end
+
+      header + directory + data
+    end
+  end
+end

data/lib/icons/icon_generator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative 'png_writer'
+require_relative 'png_decoder'
+require_relative 'resampler'
+require_relative 'renderer'
+require_relative 'ico_writer'
+require_relative 'icns_writer'
+
+module Raintron
+  # Orchestrates the icon writers: renders (or decodes+resizes) every distinct pixel
+  # size any format needs exactly once, then hands the result to each format's writer.
+  class IconGenerator
+    # The union of every size IcnsWriter, IcoWriter, and the single Linux PNG need.
+    ALL_SIZES = [16, 24, 32, 48, 64, 128, 256, 512, 1024].freeze
+    LINUX_PNG_SIZE = 512
+
+    def self.generate(output_dir:, basename: 'icon', source: nil, **render_opts)
+      new(source:, **render_opts).write_all(dir: output_dir, basename:)
+    end
+
+    def initialize(source: nil, background: [0, 152, 252, 255], foreground: [255, 255, 255, 255], shape: :circle)
+      @source = source
+      @background = background
+      @foreground = foreground
+      @shape = shape
+    end
+
+    def write_all(dir:, basename: 'icon')
+      FileUtils.mkdir_p(dir)
+      pngs = rendered_pngs
+
+      paths = {}
+
+      paths[:icns] = File.join(dir, "#{basename}.icns")
+      File.binwrite(paths[:icns], IcnsWriter.encode(pngs_by_size: pngs))
+
+      paths[:ico] = File.join(dir, "#{basename}.ico")
+      entries = IcoWriter::DEFAULT_SIZES.map { |size| { size:, png: pngs.fetch(size) } }
+      File.binwrite(paths[:ico], IcoWriter.encode(entries:))
+
+      paths[:png] = File.join(dir, "#{basename}.png")
+      File.binwrite(paths[:png], pngs.fetch(LINUX_PNG_SIZE))
+
+      paths
+    end
+
+    private
+
+    def rendered_pngs
+      @rendered_pngs ||= ALL_SIZES.to_h { |size| [size, PngWriter.encode(width: size, height: size, rgba: rgba_for(size))] }
+    end
+
+    def rgba_for(size)
+      return Renderer.render(size:, background: @background, foreground: @foreground, shape: @shape) unless @source
+
+      Resampler.resize(rgba: decoded_source[:rgba], src_w: decoded_source[:width], src_h: decoded_source[:height],
+                       dst_w: size, dst_h: size)
+    end
+
+    def decoded_source
+      @decoded_source ||= PngDecoder.decode(File.binread(@source))
+    end
+  end
+end