bindery-cli 0.1.1 → 0.2.1

data/lib/bindery/builder.rb

@@ -9,9 +9,10 @@ module Bindery
   class Builder
     class BuildError < Bindery::Error; end
 
-    def initialize(book, project_root: Project.root!)
+    def initialize(book, project_root: Project.root!, verbose: false)
       @book = book
       @project_root = project_root
+      @verbose = verbose
     end
 
     # 返回 true/false 表示是否成功；详细错误信息可通过 #last_error 获取
@@ -33,8 +34,10 @@ module Bindery
         FileUtils.mkdir_p(out_dir)
         out_path = out_dir + "#{@book.id}.epub"
 
+        # 按内容中最顶层的标题级别拆分：h1=书名 / h2=卷 / h3=章
+        split_level = top_heading_level(merged)
         cmd = ["pandoc", merged.to_s, "-o", out_path.to_s,
-               "--metadata-file", meta_file.to_s, "--toc"]
+               "--metadata-file", meta_file.to_s, "--toc", "--split-level", split_level.to_s]
 
         css = Project.templates_dir(@project_root) + "style.css"
         cmd += ["--css", css.to_s] if css.file?
@@ -42,6 +45,7 @@ module Bindery
         cover = @book.cover_path
         cmd += ["--epub-cover-image", cover.to_s] if cover
 
+        puts "  $ #{cmd.join(' ')}" if @verbose
         run(cmd)
       end
     rescue Bindery::Error => e
@@ -53,6 +57,16 @@ module Bindery
       @last_error
     end
 
+    # 运行 epubcheck 校验单个 epub，返回 [成功?, 输出]
+    def epubcheck(path)
+      unless system("epubcheck", "--version", out: File::NULL, err: File::NULL)
+        return [false, "未安装 epubcheck（参考 https://github.com/w3c/epubcheck/releases）"]
+      end
+
+      stdout, stderr, status = Open3.capture3("epubcheck", path.to_s)
+      [status.success?, stderr.empty? ? stdout : stderr]
+    end
+
     private
 
     def ensure_pandoc!
@@ -72,15 +86,32 @@ module Bindery
       path
     end
 
+    # 返回合并后内容中最顶层的标题级别（1..6），无标题时返回 1
+    def top_heading_level(merged)
+      level = nil
+      merged.each_line do |line|
+        next unless line =~ /^(\#{1,6})\s/
+
+        l = Regexp.last_match(1).length
+        level = l if level.nil? || l < level
+      end
+      level || 1
+    end
+
     def write_pandoc_metadata(tmp_dir, meta)
+      config = Project.config(@project_root)
       pandoc_meta = {
         "title"     => meta["title"] || @book.id,
         "author"    => meta["author"] || "佚名",
-        "lang"      => meta["lang"] || "zh-CN",
-        "rights"    => meta["rights"] || "公共领域",
-        "publisher" => meta["publisher"] || "再读经典",
+        "lang"      => meta["lang"] || config["lang"] || "zh-CN",
+        "rights"    => meta["rights"] || config["rights"] || "公共领域",
+        "publisher" => meta["publisher"] || config["publisher"] || "再读经典",
       }
       pandoc_meta["date"] = meta["dynasty"] if meta["dynasty"] && !meta["dynasty"].to_s.empty?
+      # 可选元数据：ISBN / 译者 / 分类，映射到 Pandoc 识别的字段
+      pandoc_meta["identifier"] = meta["isbn"] if meta["isbn"] && !meta["isbn"].to_s.empty?
+      pandoc_meta["contributor"] = meta["translator"] if meta["translator"] && !meta["translator"].to_s.empty?
+      pandoc_meta["subject"] = meta["category"] if meta["category"] && !meta["category"].to_s.empty?
 
       path = Pathname.new(tmp_dir) + "metadata.yaml"
       path.write(pandoc_meta.to_yaml)

data/lib/bindery/cli.rb

@@ -1,8 +1,10 @@
 require "optparse"
+require "fileutils"
+require "rbconfig"
 
 module Bindery
   # 命令行入口：解析子命令并分发
-  # 支持: new / generate(g) / build / status / version / help
+  # 支持: init / new book / build / clean / validate / watch / serve / status / version / help
   class CLI
     def self.start(argv)
       new.run(argv)
@@ -11,12 +13,26 @@ module Bindery
     def run(argv)
       command, *rest = argv
       case command
+      when "init"
+        cmd_init(rest)
       when "new"
         cmd_new(rest)
-      when "generate", "g"
-        cmd_generate(rest)
       when "build"
         cmd_build(rest)
+      when "clean"
+        cmd_clean(rest)
+      when "validate"
+        cmd_validate(rest)
+      when "cover"
+        cmd_cover(rest)
+      when "rename"
+        cmd_rename(rest)
+      when "watch"
+        cmd_watch(rest)
+      when "serve"
+        cmd_serve(rest)
+      when "web"
+        cmd_web(rest)
       when "status"
         cmd_status(rest)
       when "version", "-v", "--version"
@@ -38,74 +54,183 @@ module Bindery
 
     private
 
-    # ---------- bindery new <项目名> ----------
-    def cmd_new(args)
-      name = args.first
-      if name.nil? || name.empty?
-        warn "用法: bindery new <项目名>"
+    # ---------- bindery init ----------
+    def cmd_init(args)
+      unless args.empty?
+        warn "用法: bindery init（不接受参数）"
         exit 1
       end
-      Generators::ProjectGenerator.call(name)
+      Generators::ProjectGenerator.call
     end
 
-    # ---------- bindery generate book <id> <title> [选项] ----------
-    def cmd_generate(args)
+    # ---------- bindery new book|chapter|volume ... ----------
+    def cmd_new(args)
       type, *rest = args
       case type
       when "book"
-        cmd_generate_book(rest)
+        cmd_new_book(rest)
+      when "chapter"
+        cmd_new_chapter(rest)
+      when "volume"
+        cmd_new_volume(rest)
       when nil
-        warn "用法: bindery generate book <id> <书名> [--author NAME] [--dynasty 朝代] [--category 分类]"
+        warn "用法: bindery new book <书名> [chapter <章数>] [选项]"
+        warn "      bindery new chapter <book-id> <数量>"
+        warn "      bindery new volume <book-id> <卷名> [--chapters N]"
         exit 1
       else
-        warn "未知的生成器类型: #{type}（目前只支持 book）"
+        warn "未知的生成器类型: #{type}（支持 book / chapter / volume）"
         exit 1
       end
     end
 
-    def cmd_generate_book(args)
-      options = { author: "佚名", dynasty: "", category: "" }
+    # ---------- bindery new chapter <book-id> <数量> ----------
+    def cmd_new_chapter(args)
+      book_id, count = args
+      if book_id.nil? || count.nil?
+        warn "用法: bindery new chapter <book-id> <数量>"
+        exit 1
+      end
+      Generators::ChapterGenerator.call(book_id, count)
+    end
+
+    # ---------- bindery new volume <book-id> <卷名> [--chapters N] ----------
+    def cmd_new_volume(args)
+      options = { chapters: 0 }
+      parser = OptionParser.new do |o|
+        o.on("--chapters N", Integer) { |v| options[:chapters] = v }
+      end
+      positional = parser.parse(args)
+      book_id, volume_name = positional
+      if book_id.nil? || volume_name.nil?
+        warn "用法: bindery new volume <book-id> <卷名> [--chapters N]"
+        exit 1
+      end
+      Generators::VolumeGenerator.call(book_id, volume_name, chapters: options[:chapters])
+    end
+
+    # ---------- bindery cover <book-id> ----------
+    def cmd_cover(args)
+      id = args.first
+      if id.nil?
+        warn "用法: bindery cover <book-id>"
+        exit 1
+      end
+      project_root = Project.root!
+      book = Bindery::Book.find(id, project_root)
+      path = Bindery::Cover.generate(book)
+      puts "已生成封面: #{path}"
+    end
+
+    # ---------- bindery rename chapters <book-id> ----------
+    def cmd_rename(args)
+      type, book_id = args
+      if type != "chapters" || book_id.nil?
+        warn "用法: bindery rename chapters <book-id>"
+        exit 1
+      end
+      project_root = Project.root!
+      book = Bindery::Book.find(book_id, project_root)
+      count = Bindery::Renamer.rename_chapters(book)
+      puts "重命名完成：更新 #{count} 个文件"
+    end
+
+    def cmd_new_book(args)
+      options = { author: "佚名", dynasty: "", category: "", translator: "", isbn: "", id: nil, cover: false }
       parser = OptionParser.new do |o|
         o.on("--author NAME") { |v| options[:author] = v }
         o.on("--dynasty NAME") { |v| options[:dynasty] = v }
         o.on("--category NAME") { |v| options[:category] = v }
+        o.on("--translator NAME") { |v| options[:translator] = v }
+        o.on("--isbn ISBN") { |v| options[:isbn] = v }
+        o.on("--id ID") { |v| options[:id] = v }
+        o.on("--cover") { options[:cover] = true }
       end
       positional = parser.parse(args)
-      id, title = positional
-      if id.nil? || title.nil?
-        warn "用法: bindery generate book <id> <书名> [--author NAME] [--dynasty 朝代] [--category 分类]"
+      title = positional.first
+      if title.nil? || title.empty?
+        warn "用法: bindery new book <书名> [chapter <章数>] [--cover] [--author NAME] [--dynasty 朝代] [--category 分类] [--translator 译者] [--isbn ISBN] [--id ID]"
         exit 1
       end
 
+      # 可选组合参数：bindery new book <书名> chapter <章数>
+      # 语义：总共 N 章（默认已含第一章，所以再补 N-1 章）
+      chapters = nil
+      unless positional[1].nil?
+        if positional[1] == "chapter"
+          chapters = positional[2].to_i
+          unless chapters.positive?
+            warn "章节数必须是正整数"
+            exit 1
+          end
+        else
+          warn "未知参数: #{positional[1]}"
+          exit 1
+        end
+      end
+
+      id = options[:id] || Generators::BookGenerator.auto_id(title)
       Generators::BookGenerator.call(
         id, title,
-        author: options[:author], dynasty: options[:dynasty], category: options[:category]
+        author: options[:author], dynasty: options[:dynasty], category: options[:category],
+        translator: options[:translator], isbn: options[:isbn]
       )
+      Generators::ChapterGenerator.call(id, chapters - 1) if chapters && chapters > 1
+      Bindery::Cover.generate(Bindery::Book.find(id)) if options[:cover]
     end
 
-    # ---------- bindery build [<id>] [--all] ----------
+    # ---------- bindery build [<id>] [--all] [--check] [--dry-run] [--verbose] ----------
     def cmd_build(args)
-      options = { all: false }
+      options = { all: false, check: false, dry_run: false, verbose: false, epubcheck: false }
       parser = OptionParser.new do |o|
         o.on("--all") { options[:all] = true }
+        o.on("--check") { options[:check] = true }
+        o.on("--dry-run") { options[:dry_run] = true }
+        o.on("--verbose") { options[:verbose] = true }
+        o.on("--epubcheck") { options[:epubcheck] = true }
       end
       positional = parser.parse(args)
 
       project_root = Project.root!
       books = options[:all] ? Bindery::Book.all(project_root) : [book_from_arg(positional.first, project_root)]
 
+      if options[:check]
+        # 仅做构建前校验，不实际调用 Pandoc
+        exit 1 unless check_books(books, project_root)
+        return
+      end
+
       if books.empty?
         warn "books/ 目录下没有任何书籍"
+        # 即使没有书也重建索引，保证 books.json 存在（供 CI / 静态站读取）
+        Index.rebuild(project_root)
+        puts "" if options[:all]
+        puts "完成：成功 0 本，失败 0 本" if options[:all]
+        return
+      end
+
+      if options[:dry_run]
+        books.each do |book|
+          puts "[#{book.id}] 将构建 → #{book.epub_output(project_root)}（#{book.chapters.size} 个章节）"
+        end
         return
       end
 
       success = 0
       failure = 0
       books.each do |book|
-        builder = Builder.new(book, project_root: project_root)
+        builder = Builder.new(book, project_root: project_root, verbose: options[:verbose])
         if builder.build_epub
           puts "✅ [#{book.id}] epub 构建成功"
           success += 1
+          if options[:epubcheck]
+            ok, msg = builder.epubcheck(book.epub_output(project_root))
+            if ok
+              puts "   ✅ epubcheck 通过"
+            else
+              puts "   ⚠️ epubcheck 未通过：#{msg.lines.first&.strip}"
+            end
+          end
         else
           puts "❌ [#{book.id}] epub 构建失败"
           puts "   #{builder.last_error}"
@@ -126,6 +251,158 @@ module Bindery
       Bindery::Book.find(id, project_root)
     end
 
+    # ---------- bindery clean [--all] ----------
+    def cmd_clean(args)
+      options = { all: false }
+      parser = OptionParser.new do |o|
+        o.on("--all") { options[:all] = true }
+      end
+      parser.parse(args)
+
+      project_root = Project.root!
+      epub_dir = Project.output_dir(project_root) + "epub"
+      count = 0
+      if epub_dir.directory?
+        epub_dir.children.each do |f|
+          FileUtils.rm_rf(f)
+          count += 1
+        end
+      end
+
+      if options[:all]
+        index = Project.index_file(project_root)
+        if index.file?
+          index.delete
+          count += 1
+        end
+      end
+
+      puts "清理完成：移除 #{count} 项"
+    end
+
+    # ---------- bindery validate [<id>] [--all] ----------
+    def cmd_validate(args)
+      options = { all: false }
+      parser = OptionParser.new do |o|
+        o.on("--all") { options[:all] = true }
+      end
+      positional = parser.parse(args)
+
+      project_root = Project.root!
+      books = options[:all] ? Bindery::Book.all(project_root) : [book_from_arg(positional.first, project_root)]
+      exit 1 unless check_books(books, project_root)
+    end
+
+    # 校验并打印结果，返回是否全部通过（供 validate 与 build --check 共用）
+    def check_books(books, project_root)
+      return true if books.empty?
+
+      ok = true
+      books.each do |book|
+        issues = Bindery::Validator.check(book, project_root: project_root)
+        warns  = Bindery::Validator.warnings(book, project_root: project_root)
+        if issues.empty?
+          puts "✅ [#{book.id}] 校验通过"
+          warns.each { |w| puts "   ⚠️ #{w}" }
+        else
+          ok = false
+          puts "❌ [#{book.id}] 发现问题："
+          issues.each { |i| puts "   - #{i}" }
+          warns.each { |w| puts "   ⚠️ #{w}" }
+        end
+      end
+      ok
+    end
+
+    # ---------- bindery watch [--interval SECONDS] ----------
+    def cmd_watch(args)
+      options = { interval: 2.0 }
+      parser = OptionParser.new do |o|
+        o.on("--interval SECONDS", Float) { |v| options[:interval] = v }
+      end
+      parser.parse(args)
+
+      project_root = Project.root!
+      puts "监听 books/ 变化，检测到改动会自动重建全部书籍（Ctrl-C 退出）..."
+      previous = books_fingerprint(project_root)
+      loop do
+        sleep options[:interval]
+        current = books_fingerprint(project_root)
+        next if current == previous
+
+        previous = current
+        puts "\n[#{Time.now.strftime('%H:%M:%S')}] 检测到变化，重新构建..."
+        cmd_build(["--all"])
+      end
+    rescue Interrupt
+      puts "\n已停止监听"
+    end
+
+    def books_fingerprint(project_root)
+      books_dir = Project.books_dir(project_root)
+      return nil unless books_dir.directory?
+
+      sig = []
+      Pathname.glob(books_dir + "**" + "*").each do |f|
+        sig << [f.to_s, f.mtime.to_f, f.size] if f.file?
+      end
+      sig.hash
+    end
+
+    # ---------- bindery serve [--port N] [--host H] ----------
+    def cmd_serve(args)
+      options = { port: 8000, host: "127.0.0.1" }
+      parser = OptionParser.new do |o|
+        o.on("--port N", Integer) { |v| options[:port] = v }
+        o.on("--host H") { |v| options[:host] = v }
+      end
+      parser.parse(args)
+
+      project_root = Project.root!
+      Index.rebuild(project_root) # 确保书库索引是最新的
+      Bindery::Server.new(project_root, host: options[:host], port: options[:port]).start
+    end
+
+    # ---------- bindery web [--port N] [--host H] ----------
+    def cmd_web(args)
+      options = { port: 8000, host: "127.0.0.1" }
+      parser = OptionParser.new do |o|
+        o.on("--port N", Integer) { |v| options[:port] = v }
+        o.on("--host H") { |v| options[:host] = v }
+      end
+      parser.parse(args)
+
+      project_root = Project.root!
+      Index.rebuild(project_root)
+
+      url = "http://#{options[:host]}:#{options[:port]}/cover"
+      server = Bindery::Server.new(project_root, host: options[:host], port: options[:port])
+      thread = Thread.new do
+        begin
+          server.start
+        rescue StandardError => e
+          warn "服务启动失败: #{e.message}"
+        end
+      end
+      sleep 0.5 # 等服务就绪
+      open_browser(url)
+      puts "封面生成器已打开: #{url}（Ctrl-C 退出）"
+      thread.join
+    rescue Interrupt
+      puts "\n已退出"
+    end
+
+    def open_browser(url)
+      case RbConfig::CONFIG["host_os"]
+      when /darwin/
+        system("open", url)
+      when /mswin|mingw|cygwin/
+        system("cmd", "/c", "start", "", url)
+      else
+        system("xdg-open", url)
+      end
+    end
+
     # ---------- bindery status ----------
     def cmd_status(_args)
       project_root = Project.root!
@@ -135,16 +412,18 @@ module Bindery
         return
       end
 
-      printf("%-16s %-16s %-8s %-6s\n", "书籍ID", "标题", "章节数", "EPUB")
-      puts "-" * 50
+      printf("%-16s %-16s %-6s %-4s %-6s %-16s\n", "书籍ID", "标题", "章节数", "封面", "EPUB", "构建时间")
+      puts "-" * 66
       books.each do |book|
         printf(
-          "%-16s %-16s %-8d %-6s\n",
+          "%-16s %-16s %-6d %-4s %-6s %-16s\n",
           book.id, book.title, book.chapters.size,
-          book.built?(project_root) ? "✅" : "—"
+          book.cover? ? "✅" : "—",
+          book.built?(project_root) ? "✅" : "—",
+          book.built_at(project_root)&.strftime("%m-%d %H:%M") || "—"
         )
       end
-      puts "-" * 50
+      puts "-" * 66
       puts "共 #{books.size} 本书"
     end
 
@@ -153,12 +432,27 @@ module Bindery
         bindery #{Bindery::VERSION} — 再读经典项目脚手架工具
 
         用法:
-          bindery new <项目名>                              创建新项目
-          bindery generate book <id> <书名> [选项]           为项目生成一本新书
-            简写: bindery g book <id> <书名>
-            选项: --author NAME  --dynasty 朝代  --category 分类
+          bindery init                                      在当前目录初始化项目
+          bindery new book <书名> [chapter <章数>] [选项]    新建一本书（ID 自动生成）
+            可组合: chapter <章数> 一并批量创建章节（N = 正文章节数，封面/目录不计入）
+            选项: --id ID（可选） --author NAME  --dynasty 朝代  --category 分类
+                  --translator 译者  --isbn ISBN  --cover 自动生成封面
+          bindery new chapter <book-id> <数量>               批量创建章节（编号自动接续）
+          bindery new volume <book-id> <卷名> [--chapters N] 新建卷（平铺 md，h2=卷名/h3=章名）
+          bindery cover <book-id>                           自动生成装饰性封面
+          bindery rename chapters <book-id>                 按标题自动更新章节文件名
           bindery build <id>                                构建单本书的 epub
           bindery build --all                               批量构建所有书
+          bindery build <id> --check                        构建前校验（不实际构建）
+          bindery build <id> --dry-run                      仅打印将构建的目标
+          bindery build <id> --verbose                      打印 pandoc 命令
+          bindery build <id> --epubcheck                    构建后用 epubcheck 校验
+          bindery validate <id>                             校验单本书
+          bindery validate --all                            校验所有书
+          bindery clean [--all]                             清理构建产物（--all 连 books.json 一起删）
+          bindery watch [--interval 秒]                      监听 books/ 自动重建
+          bindery serve [--port N] [--host H]                启动本地书库站点
+          bindery web [--port N]                             打开 Web 封面生成器
           bindery status                                     查看所有书籍状态
           bindery version                                    查看版本号
       HELP

data/lib/bindery/cover.rb

@@ -0,0 +1,135 @@
+require "zlib"
+require "digest"
+
+module Bindery
+  # 纯 Ruby 生成装饰性封面 PNG：配色由书名稳定派生，不含文字（文字渲染需要字体光栅化，超出标准库能力）
+  module Cover
+    WIDTH  = 600
+    HEIGHT = 960
+
+    module_function
+
+    # 为书籍生成 cover.png，并把 metadata.yaml 的 cover 字段指向它；返回文件路径
+    def generate(book)
+      png = encode_png(WIDTH, HEIGHT, build_pixels(WIDTH, HEIGHT, book.title))
+      path = book.dir + "cover.png"
+      path.binwrite(png)
+      update_metadata_cover(book)
+      path
+    end
+
+    def update_metadata_cover(book)
+      meta_file = book.metadata_file
+      return unless meta_file.file?
+
+      text = meta_file.read
+      text = if text =~ /^cover:.*$/
+               text.sub(/^cover:.*$/, "cover: cover.png")
+             else
+               text.chomp + "\ncover: cover.png\n"
+             end
+      meta_file.write(text)
+    end
+
+    # 逐像素生成 RGB 位图，返回行数组（每行是一串 RGB 字节）
+    def build_pixels(width, height, title)
+      hue = Digest::MD5.hexdigest(title).to_i(16) % 360
+      top    = hsl_to_rgb(hue, 0.45, 0.92)
+      bottom = hsl_to_rgb(hue, 0.60, 0.28)
+      accent = hsl_to_rgb((hue + 40) % 360, 0.55, 0.50)
+      frame  = hsl_to_rgb(hue, 0.50, 0.18)
+
+      margin = 44
+      thickness = 4
+
+      (0...height).map do |y|
+        t = y.to_f / (height - 1)
+        base = lerp(top, bottom, t)
+        row = (+"").b
+        (0...width).each do |x|
+          c =
+            if border?(x, y, width, height, margin, thickness)
+              frame
+            elsif ring?(x, y, width, height)
+              accent
+            else
+              base
+            end
+          row << c.pack("C3")
+        end
+        row
+      end
+    end
+
+    def border?(x, y, w, h, margin, thickness)
+      in_x = x >= margin && x < w - margin
+      in_y = y >= margin && y < h - margin
+      return false unless in_x && in_y
+
+      near_x = (x - margin).abs < thickness || (x - (w - margin - 1)).abs < thickness
+      near_y = (y - margin).abs < thickness || (y - (h - margin - 1)).abs < thickness
+      near_x || near_y
+    end
+
+    # 居中的方框纹样（外方框 + 内镂空）
+    def ring?(x, y, w, h)
+      cx = w / 2
+      cy = h / 2
+      outer = 220
+      inner = 150
+      dx = (x - cx).abs
+      dy = (y - cy).abs
+      in_outer = dx <= outer / 2 && dy <= outer / 2
+      in_inner = dx <= inner / 2 && dy <= inner / 2
+      in_outer && !in_inner
+    end
+
+    def lerp(c1, c2, t)
+      [
+        c1[0] + (c2[0] - c1[0]) * t,
+        c1[1] + (c2[1] - c1[1]) * t,
+        c1[2] + (c2[2] - c1[2]) * t,
+      ].map(&:round)
+    end
+
+    def hsl_to_rgb(h, s, l)
+      h = (h % 360) / 360.0
+      if s.zero?
+        r = g = b = l
+      else
+        q = l < 0.5 ? l * (1 + s) : l + s - l * s
+        p = 2 * l - q
+        r = hue_to_rgb(p, q, h + 1 / 3.0)
+        g = hue_to_rgb(p, q, h)
+        b = hue_to_rgb(p, q, h - 1 / 3.0)
+      end
+      [(r * 255).round, (g * 255).round, (b * 255).round]
+    end
+
+    def hue_to_rgb(p, q, t)
+      t += 1 if t.negative?
+      t -= 1 if t > 1
+      if t < 1 / 6.0
+        p + (q - p) * 6 * t
+      elsif t < 1 / 2.0
+        q
+      elsif t < 2 / 3.0
+        p + (q - p) * (2 / 3.0 - t) * 6
+      else
+        p
+      end
+    end
+
+    def encode_png(width, height, rows)
+      sig = "\x89PNG\r\n\x1a\n".b
+      ihdr = [width, height, 8, 2, 0, 0, 0].pack("N2C5")
+      raw = rows.map { |row| "\x00".b + row }.join
+      idat = Zlib::Deflate.deflate(raw, 9)
+      sig + chunk("IHDR", ihdr) + chunk("IDAT", idat) + chunk("IEND", "")
+    end
+
+    def chunk(type, data)
+      [data.bytesize].pack("N") + type + data + [Zlib.crc32(type + data)].pack("N")
+    end
+  end
+end