chunky_bacon 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 79373a42eb29eb28f1fdf188d7837fd3c97e5cebc5a2419cf0edbfe93535acfc
+  data.tar.gz: c13f00849c79d15e17094dfdd316c8ca00aa50e8d9673c0c71b381ce59d56edc
+SHA512:
+  metadata.gz: 45360a618e747dbfb441d77fc29f5505354537947bfda4b3783d1dfcc27488e452fbfc102bf1a4874d9586f4a434b99ad70e73db3dc6ac1eb78137b27722e6b3
+  data.tar.gz: 873db5d5a4e07063229ff494b9d97f336c5fd4eeb3fe42d36104571037039c2edcf3f5e51a175b428fed11082a56abb33598409f01cb9b0798d7265406b79e2b

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## 0.1.0
+
+- The course's helpers on a computer: `install_gem`, `show_image`,
+  `show_pdf`, `download_file`, `show_browser` (with a small built-in server),
+  `mock_get`, `show_irb`, `show_files`, `run_tests`; `show_three` and
+  `show_shoes` explain what to do instead.
+- `chunkybacon` shows Chunky; `chunkybacon run [FILE]` runs a program with
+  the helpers loaded.
+- In the course page (ruby.wasm) the page's own helpers stay.
+- Code MIT; the fox drawing (`lib/chunky_bacon/fox.txt`) CC BY-SA 4.0.
+- Also installable as `chunkybacon` and `chunky-bacon` (alias gems).

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andi Idogawa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/LICENSE-ASSETS

@@ -0,0 +1,13 @@
+The assets of chunky_bacon - the drawing of Chunky, the fox, in
+lib/chunky_bacon/fox.txt - are licensed under the Creative Commons
+Attribution-ShareAlike 4.0 International License (CC BY-SA 4.0):
+https://creativecommons.org/licenses/by-sa/4.0/
+
+Copyright (c) 2026 Andi Idogawa. Chunky is the mascot of the Ruby course
+"Ruby lernen mit Chunky Bacon" (https://github.com/Largo/chunkybacon).
+
+You may share and adapt the drawing, also commercially, as long as you give
+credit (name the course and Andi Idogawa, link the license) and share
+adaptations under the same license.
+
+The code of chunky_bacon is licensed under the MIT License (LICENSE).

data/README.md

@@ -0,0 +1,55 @@
+# chunky_bacon
+
+The companion gem of **[Ruby lernen mit Chunky Bacon](https://github.com/Largo/chunkybacon)**,
+an interactive Ruby course that runs in the browser.
+
+In the course, notebook cells and the workshop have helpers like `show_image`,
+`show_browser` and `download_file`. This gem gives your own computer the same
+helpers, so a program you wrote in the course runs unchanged with plain Ruby.
+
+```sh
+gem install chunky_bacon     # or: gem install chunkybacon - the same gem
+chunkybacon                  # Chunky shouts
+chunkybacon run              # runs main.rb with the helpers loaded
+chunkybacon run spiel.rb     # ... or another file
+```
+
+In your own code:
+
+```ruby
+require "chunky_bacon"
+
+require "chunky_png"
+image = ChunkyPNG::Image.new(64, 64, ChunkyPNG::Color.rgb(232, 114, 42))
+show_image image             # saves chunky-image-1.png and opens it
+```
+
+## The helpers
+
+What the course page showed below the cell becomes a file in the program's
+folder, opened in your system's viewer. Status lines go to stderr, so they
+never mix with your program's output.
+
+| Helper | On your computer |
+|---|---|
+| `install_gem "name"` | installs the gem unless it is there, and activates it |
+| `show_image image` | saves `chunky-image-N.png` (ChunkyPNG image, PNG bytes or a path) and opens it |
+| `show_pdf pdf` | saves `chunky-document-N.pdf` (Prawn/HexaPDF document, bytes or a path) and opens it |
+| `download_file data, "name"` | saves the data as `name` in the program's folder |
+| `show_browser App, "/path"` | starts the Rack app (Sinatra, Roda, ...) on 127.0.0.1 and opens it; after the program's last line the server runs on until Ctrl+C |
+| `mock_get App, "/path"` | `[status, body]` without any server |
+| `show_irb` | an IRB session; `exit` returns to the program |
+| `show_files` | lists the files in the program's folder |
+| `run_tests` | runs the Minitest tests defined so far |
+| `show_three`, `show_shoes` | explain how to do it on a computer (they need the course page for now) |
+
+`CHUNKYBACON_OPEN=0` stops the viewer and the browser from opening (CI, a
+machine without a desktop); the files are saved either way. Inside the course
+page the gem keeps the page's own helpers and only adds the fox.
+
+## License
+
+The code is MIT ([LICENSE](LICENSE)). The drawing of Chunky, the fox
+(`lib/chunky_bacon/fox.txt`), is CC BY-SA 4.0 like the course's other content
+([LICENSE-ASSETS](LICENSE-ASSETS)). The course's lesson texts are not part of
+this gem.

data/exe/chunkybacon

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/chunky_bacon"
+require_relative "../lib/chunky_bacon/cli"
+
+begin
+  exit ChunkyBacon::CLI.new.call(ARGV)
+rescue Interrupt
+  exit 130
+end

data/lib/chunky_bacon/cli.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module ChunkyBacon
+  # The `chunkybacon` command.
+  class CLI
+    HELP = <<~TEXT
+      Usage: chunkybacon [command]
+
+        (no command)        Chunky shouts
+        run [FILE] [ARGS]   runs FILE (main.rb if not given) with the course's
+                            helpers loaded - show_image, show_browser,
+                            download_file, ... - like the workshop's Run button
+        version             the version of chunky_bacon
+        help                this text
+
+      The course: https://github.com/Largo/chunkybacon
+    TEXT
+
+    def initialize(out: $stdout, err: $stderr)
+      @out = out
+      @err = err
+    end
+
+    # the exit status
+    def call(args)
+      command, *rest = args
+      case command
+      when nil
+        ChunkyBacon.shout(@out)
+        0
+      when "run"
+        run(rest)
+      when "version", "--version", "-v"
+        @out.puts VERSION
+        0
+      when "help", "--help", "-h"
+        @out.puts HELP
+        0
+      else
+        @err.puts "chunkybacon: unknown command #{command.inspect}\n\n#{HELP}"
+        1
+      end
+    end
+
+    private
+
+    # In a child Ruby, so the program has the terminal - input for gets,
+    # Ctrl+C - and its exit status is the command's.
+    def run(args)
+      file = args.first || "main.rb"
+      unless File.file?(file)
+        others = Dir["*.rb"].sort
+        hint = others.empty? ? "" : " - there is #{others.join(", ")}: chunkybacon run #{others.first}"
+        @err.puts "chunkybacon: no #{file} here#{hint}"
+        return 1
+      end
+      lib = File.expand_path("..", __dir__)
+      system(RbConfig.ruby, "-I", lib, "-r", "chunky_bacon", file, *args.drop(1))
+      $?.exitstatus || 1
+    end
+  end
+end

data/lib/chunky_bacon/fox.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ChunkyBacon
+  # Chunky, the course's fox, holding up a strip of bacon and shouting - the
+  # same original character as the site's mascot (html/assets/chunky.svg),
+  # in plain ASCII so any terminal shows it. The drawing is fox.txt next to
+  # this file; like the course's other content it is licensed CC BY-SA 4.0
+  # (LICENSE-ASSETS), while this code is MIT.
+  FOX = File.read(File.expand_path("fox.txt", __dir__), encoding: "UTF-8").gsub("\r\n", "\n").freeze
+
+  # Puts the fox on +io+ (the terminal unless told otherwise).
+  def self.shout(io = $stdout)
+    io.puts FOX
+    nil
+  end
+end

data/lib/chunky_bacon/fox.txt

@@ -0,0 +1,10 @@
+        /\          /\
+       /  \________/  \        \   |   /
+      |    ^      ^    |     CHUNKY BACON!
+      |      ____      |       /   |   \
+.~~~~. \     \__/     /
+|~~~~|--\____________/
+'~~~~'    |          |\__
+          |          |   \
+          |__________|  ~~'
+            |      |

data/lib/chunky_bacon/helpers.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module ChunkyBacon
+  class << self
+    # Servers started by show_browser keep the program alive after its last
+    # line, until Ctrl+C - as the mini browser stayed below the cell. Tests
+    # switch this off.
+    attr_writer :keep_serving
+
+    def keep_serving
+      @keep_serving.nil? ? true : @keep_serving
+    end
+
+    def servers
+      @servers ||= []
+    end
+
+    # Status lines (where a file went, which address a server has) go to
+    # stderr, so they never mix with what the program itself puts.
+    def say(message)
+      $stderr.puts "[chunky] #{message}"
+    end
+
+    # "chunky-image-1.png", "chunky-image-2.png", ... per run of the program
+    def next_file(stem, extension)
+      @counters ||= Hash.new(0)
+      @counters[stem] += 1
+      File.join(output_dir, "#{stem}-#{@counters[stem]}.#{extension}")
+    end
+
+    def save(path, bytes)
+      File.binwrite(path, bytes)
+      say "saved #{relative(path)} (#{bytes.bytesize} B)"
+      path
+    end
+
+    def relative(path)
+      path = File.expand_path(path)
+      base = File.expand_path(output_dir) + File::SEPARATOR
+      path.start_with?(base) ? path.delete_prefix(base) : path
+    end
+
+    def serve_until_interrupt
+      return if servers.empty? || !keep_serving
+
+      say "the server keeps running - Ctrl+C stops it"
+      servers.each(&:join)
+    rescue Interrupt
+      $stderr.puts
+    end
+  end
+
+  # The course's notebook helpers, for a program on a computer. Same names,
+  # arguments and defaults as on the course page (html/main.rb); what showed
+  # below the cell there is a file in the program's folder here, opened in
+  # the system's viewer.
+  module Helpers
+    private
+
+    # Installs a gem now, unless it is installed already, and activates it -
+    # afterwards `require` finds it. true when it is there.
+    def install_gem(name)
+      name = name.to_s
+      begin
+        gem name
+        return true
+      rescue Gem::LoadError
+        nil # not installed yet
+      end
+      if defined?(Bundler) && ENV["BUNDLE_GEMFILE"]
+        ChunkyBacon.say "this program runs under Bundler: add gem \"#{name}\" to its Gemfile and run bundle install"
+        return false
+      end
+      ChunkyBacon.say "installing #{name} ..."
+      Gem.install(name)
+      Gem::Specification.reset
+      gem name
+      true
+    rescue Gem::Exception, SystemCallError => e
+      ChunkyBacon.say "#{name} could not be installed: #{e.message}"
+      false
+    end
+
+    # A picture: a ChunkyPNG image (anything with to_blob or to_data_url),
+    # PNG bytes, or the path of an image file.
+    def show_image(image)
+      # a path: text without the PNG signature or NUL bytes, naming a file
+      if image.is_a?(String) && !image.b.start_with?("\x89PNG".b) && !image.include?("\0") && File.file?(image)
+        ChunkyBacon::Opener.open(File.expand_path(image))
+        return nil
+      end
+      bytes = if image.respond_to?(:to_blob)
+                image.to_blob
+              elsif image.respond_to?(:to_data_url)
+                image.to_data_url.split(",", 2).last.unpack1("m0")
+              else
+                image.to_s.b
+              end
+      path = ChunkyBacon.save(ChunkyBacon.next_file("chunky-image", "png"), bytes)
+      ChunkyBacon::Opener.open(path)
+      nil
+    end
+
+    # A PDF: a file's path, a Prawn::Document or HexaPDF::Document/Composer,
+    # or the PDF itself as a String.
+    def show_pdf(pdf)
+      pdf = pdf.document if defined?(HexaPDF::Composer) && pdf.is_a?(HexaPDF::Composer)
+      if pdf.is_a?(String) && !pdf.b.start_with?("%PDF")
+        ChunkyBacon::Opener.open(File.expand_path(pdf))
+        return nil
+      end
+      bytes = if pdf.is_a?(String)
+                pdf
+              elsif pdf.respond_to?(:render)
+                pdf.render
+              else
+                StringIO.new("".b).tap { |io| pdf.write(io) }.string
+              end
+      path = ChunkyBacon.save(ChunkyBacon.next_file("chunky-document", "pdf"), bytes)
+      ChunkyBacon::Opener.open(path)
+      nil
+    end
+
+    # What the page offered as a download: the data saved as +name+ in the
+    # program's folder. download_file "notizen.txt" names a file that is
+    # there already.
+    def download_file(data, name = nil)
+      if name.nil?
+        path = File.expand_path(data.to_s, ChunkyBacon.output_dir)
+        raise Errno::ENOENT, data.to_s unless File.file?(path)
+
+        ChunkyBacon.say "#{ChunkyBacon.relative(path)} is ready (#{File.size(path)} B)"
+        return nil
+      end
+      data = data.to_blob if data.respond_to?(:to_blob)
+      ChunkyBacon.save(File.expand_path(name.to_s, ChunkyBacon.output_dir), data.to_s.b)
+      nil
+    end
+
+    # Starts the Rack app (a Sinatra/Roda class or anything with #call) on
+    # this computer and opens it in the browser. The program goes on; once
+    # it has finished, the server keeps running until Ctrl+C.
+    def show_browser(app, path = "/")
+      server = ChunkyBacon::Server.new(app).start
+      if ChunkyBacon.servers.empty? && ChunkyBacon.keep_serving
+        at_exit { ChunkyBacon.serve_until_interrupt }
+      end
+      ChunkyBacon.servers << server
+      ChunkyBacon.say "#{app.respond_to?(:name) && app.name ? app.name : "the app"} runs at #{server.url(path)}"
+      ChunkyBacon::Opener.open(server.url(path))
+      nil
+    end
+
+    # A GET against a Rack app without any server, for experiments and
+    # checks:  status, body = mock_get(MyApp, "/hello")
+    def mock_get(app, path)
+      status, _headers, body = ChunkyBacon::RackEnv.call(app, ChunkyBacon::RackEnv.for(path))
+      [status, body]
+    end
+
+    # An IRB session, here and now (at the top level, like the page's fresh
+    # one). `exit` ends it, and the program carries on.
+    def show_irb
+      require "irb"
+      TOPLEVEL_BINDING.irb
+      nil
+    end
+
+    # The files in the program's folder, as the page's file explorer showed
+    # the simulated ones.
+    def show_files
+      base = ChunkyBacon.output_dir
+      puts "#{File.basename(File.expand_path(base))}/"
+      entries = Dir.glob("**/*", base: base).reject { |p| p.split("/").any? { |part| part.start_with?(".") } }.sort
+      entries.first(200).each do |entry|
+        depth = entry.count("/")
+        full = File.join(base, entry)
+        name = File.basename(entry)
+        puts File.directory?(full) ? "#{"  " * (depth + 1)}#{name}/" : "#{"  " * (depth + 1)}#{name}  (#{File.size(full)} B)"
+      end
+      puts "  ... #{entries.size - 200} more" if entries.size > 200
+      nil
+    end
+
+    # Runs the Minitest tests defined so far and clears them, like the page.
+    # (In a file of its own, `require "minitest/autorun"` does the same.)
+    def run_tests
+      require "minitest"
+      result = Minitest.run([])
+      Minitest::Runnable.runnables.clear
+      result
+    end
+
+    def show_three(*)
+      raise ChunkyBacon::NotHere, "show_three needs the course page for now - three-rb draws with three.js " \
+                                  "in the browser. On your computer, three-rb's own examples show the way."
+    end
+
+    def show_shoes(**, &)
+      raise ChunkyBacon::NotHere, "On your computer, Shoes apps run with Scarpe: gem install scarpe, put " \
+                                  "Shoes.app do ... end in a file and start it with: scarpe app.rb"
+    end
+  end
+end
+
+module Kernel
+  include ChunkyBacon::Helpers
+end

data/lib/chunky_bacon/opener.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ChunkyBacon
+  # Opens a file or a URL with whatever the system uses for it - the image
+  # viewer, the PDF reader, the browser. CHUNKYBACON_OPEN=0 turns it off
+  # (tests, CI, a machine without a desktop); the file is saved either way.
+  module Opener
+    def self.enabled?
+      ENV["CHUNKYBACON_OPEN"] != "0"
+    end
+
+    # true when a viewer was started
+    def self.open(target)
+      return false unless enabled?
+
+      pid = Process.spawn(*command(target.to_s), out: File::NULL, err: File::NULL)
+      Process.detach(pid)
+      true
+    rescue SystemCallError
+      false
+    end
+
+    def self.command(target)
+      if Gem.win_platform?
+        # `start` is a cmd built-in; its first quoted argument is a window
+        # title. cmd reads & | < > ^ as operators unless escaped - Ruby only
+        # quotes an argument that has a space, and inside quotes the escape
+        # would be taken literally.
+        target = target.gsub(/[&|<>^]/) { |c| "^#{c}" } unless target.include?(" ")
+        ["cmd", "/c", "start", "", target]
+      elsif RUBY_PLATFORM.include?("darwin")
+        ["open", target]
+      else
+        ["xdg-open", target]
+      end
+    end
+  end
+end

data/lib/chunky_bacon/rack_env.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module ChunkyBacon
+  # Rack environments without a Rack server - what mock_get hands an app,
+  # and what ChunkyBacon::Server builds from a real HTTP request. Mirrors the
+  # course page's RackPlayground (html/rack_playground.rb), so an app answers
+  # here as it does in the lesson.
+  module RackEnv
+    # "speisekarte", "/a?b=1", "http://localhost/x" -> "/speisekarte" etc.
+    def self.normalize(path)
+      "/" + path.to_s.sub(%r{\Ahttps?://[^/]*}, "").sub(%r{\A/+}, "")
+    end
+
+    def self.for(path, method: "GET", headers: {}, body: "", host: "localhost", port: 80)
+      path, query = normalize(path).split("?", 2)
+      env = {
+        "REQUEST_METHOD" => method.to_s.upcase,
+        "SCRIPT_NAME" => "",
+        "PATH_INFO" => path,
+        "QUERY_STRING" => query.to_s,
+        "SERVER_NAME" => host,
+        "SERVER_PORT" => port.to_s,
+        "HTTP_HOST" => port.to_i == 80 ? host : "#{host}:#{port}",
+        "SERVER_PROTOCOL" => "HTTP/1.1",
+        "rack.url_scheme" => "http",
+        "rack.input" => StringIO.new(body.to_s.b),
+        "rack.errors" => $stderr
+      }
+      headers.each do |name, value|
+        key = name.to_s.upcase.tr("-", "_")
+        case key
+        when "CONTENT_TYPE", "CONTENT_LENGTH" then env[key] = value.to_s
+        else env["HTTP_#{key}"] = value.to_s
+        end
+      end
+      env
+    end
+
+    # Calls the app; returns [status, headers, body as one String].
+    def self.call(app, env)
+      status, headers, body = app.call(env)
+      chunks = []
+      body.each { |chunk| chunks << chunk.to_s }
+      body.close if body.respond_to?(:close)
+      [status.to_i, headers.respond_to?(:to_h) ? headers.to_h : headers, chunks.join]
+    end
+  end
+end

data/lib/chunky_bacon/server.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module ChunkyBacon
+  # The smallest web server that lets a browser click through a Rack app -
+  # what show_browser starts on a computer, where the lesson page had its
+  # mini browser. One app, 127.0.0.1 only (nothing outside this computer
+  # reaches it), one request at a time, no keep-alive. For a real app, use a
+  # real server: rackup with puma, falcon, webrick.
+  class Server
+    REASONS = { 200 => "OK", 201 => "Created", 204 => "No Content", 301 => "Moved Permanently",
+                302 => "Found", 303 => "See Other", 304 => "Not Modified", 400 => "Bad Request",
+                401 => "Unauthorized", 403 => "Forbidden", 404 => "Not Found",
+                405 => "Method Not Allowed", 422 => "Unprocessable Content",
+                500 => "Internal Server Error" }.freeze
+
+    attr_reader :app, :port
+
+    # port 0: whichever port is free
+    def initialize(app, port: 0)
+      @app = app
+      @tcp = TCPServer.new("127.0.0.1", port)
+      @port = @tcp.addr[1]
+    end
+
+    def url(path = "/")
+      "http://127.0.0.1:#{port}#{RackEnv.normalize(path)}"
+    end
+
+    def start
+      @thread = Thread.new do
+        loop { handle(@tcp.accept) }
+      rescue IOError, Errno::EBADF
+        nil # stopped
+      end
+      self
+    end
+
+    def join
+      @thread&.join
+    end
+
+    def stop
+      @tcp.close unless @tcp.closed?
+      @thread&.join(1)
+      nil
+    end
+
+    private
+
+    def handle(socket)
+      line = socket.gets
+      return if line.nil?
+
+      method, target = line.split(" ", 3)
+      headers = {}
+      while (header = socket.gets) && !header.strip.empty?
+        name, value = header.split(":", 2)
+        headers[name.strip.downcase] = value.to_s.strip
+      end
+      body = headers["content-length"] ? socket.read(headers["content-length"].to_i).to_s : ""
+      env = RackEnv.for(target, method: method, headers: headers, body: body, host: "127.0.0.1", port: port)
+      status, response_headers, response_body = respond(env)
+      write(socket, status, response_headers, response_body)
+    rescue IOError, SystemCallError
+      nil # the browser went away
+    ensure
+      socket.close unless socket.closed?
+    end
+
+    # The app's answer - an error in the app becomes a 500 page that names
+    # it, like the error below a cell.
+    def respond(env)
+      RackEnv.call(app, env)
+    rescue StandardError => e
+      warn "#{e.class}: #{e.message}"
+      [500, { "content-type" => "text/plain; charset=utf-8" }, "#{e.class}: #{e.message}\n"]
+    end
+
+    def write(socket, status, headers, body)
+      socket.write("HTTP/1.1 #{status} #{REASONS.fetch(status, "Status")}\r\n")
+      headers.each do |name, value|
+        next if %w[connection content-length transfer-encoding].include?(name.to_s.downcase)
+
+        Array(value).each { |v| v.to_s.split("\n").each { |part| socket.write("#{name}: #{part}\r\n") } }
+      end
+      socket.write("content-length: #{body.bytesize}\r\nconnection: close\r\n\r\n")
+      socket.write(body)
+    end
+  end
+end

data/lib/chunky_bacon/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ChunkyBacon
+  VERSION = "0.1.0"
+end

data/lib/chunky_bacon.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# chunky_bacon: the companion gem of "Ruby lernen mit Chunky Bacon", the Ruby
+# course that runs in the browser (https://github.com/Largo/chunkybacon).
+#
+# On your own computer, `require "chunky_bacon"` gives a program the helpers
+# the course's notebook cells and workshop have - show_image, show_browser,
+# download_file and friends - so a program written in the browser runs
+# unchanged with plain Ruby (or with `chunkybacon run`, which loads them for
+# you). In the browser the page brings its own helpers; there the gem only
+# adds the fox.
+require_relative "chunky_bacon/version"
+require_relative "chunky_bacon/fox"
+
+module ChunkyBacon
+  # A helper that needs the browser (for now), called on a computer.
+  class NotHere < StandardError; end
+
+  class << self
+    # true inside the course's page (ruby.wasm), false on a computer
+    def browser?
+      RUBY_PLATFORM.start_with?("wasm")
+    end
+
+    # where show_image, show_pdf and download_file put their files: the
+    # folder the program runs in, like the downloads below a cell
+    attr_writer :output_dir
+
+    def output_dir
+      @output_dir || Dir.pwd
+    end
+  end
+end
+
+unless ChunkyBacon.browser?
+  require_relative "chunky_bacon/opener"
+  require_relative "chunky_bacon/rack_env"
+  require_relative "chunky_bacon/server"
+  require_relative "chunky_bacon/helpers"
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: chunky_bacon
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andi Idogawa
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: The companion gem of "Ruby lernen mit Chunky Bacon", an interactive Ruby
+  course that runs in the browser. require "chunky_bacon" gives a program the course's
+  helpers - show_image, show_pdf, show_browser, download_file, mock_get, show_irb,
+  show_files, run_tests, install_gem - so code written in the course runs unchanged
+  with plain Ruby; `chunkybacon run` starts a program with them loaded. Pure Ruby,
+  no dependencies.
+email:
+- web@idogawa.com
+executables:
+- chunkybacon
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- LICENSE-ASSETS
+- README.md
+- exe/chunkybacon
+- lib/chunky_bacon.rb
+- lib/chunky_bacon/cli.rb
+- lib/chunky_bacon/fox.rb
+- lib/chunky_bacon/fox.txt
+- lib/chunky_bacon/helpers.rb
+- lib/chunky_bacon/opener.rb
+- lib/chunky_bacon/rack_env.rb
+- lib/chunky_bacon/server.rb
+- lib/chunky_bacon/version.rb
+homepage: https://github.com/Largo/chunkybacon
+licenses:
+- MIT
+- CC-BY-SA-4.0
+metadata:
+  homepage_uri: https://github.com/Largo/chunkybacon
+  source_code_uri: https://github.com/Largo/chunkybacon/tree/main/gem/chunky_bacon
+  changelog_uri: https://github.com/Largo/chunkybacon/blob/main/gem/chunky_bacon/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: The Chunky Bacon Ruby course's helpers on your own computer - and a fox that
+  shouts.
+test_files: []