vivlio-pdf 0.2.0

data/README.ja.md

@@ -0,0 +1,127 @@
+# vivlio-pdf
+
+CSS 組版による PDF 生成を Ruby から行う gem です。
+
+[English README is here](./README.md)
+
+ローカルの Chrome/Chromium を CDP / [ferrum](https://github.com/rubycdp/ferrum) 経由で起動し、同梱の [Vivliostyle Viewer](https://github.com/vivliostyle/vivliostyle.js) を使って CSS Paged Media(柱・ノンブル・目次リーダー・PDF しおり) に対応した印刷用PDFを出力します。
+
+Node.js には依存せず、Ruby 単体で動作します。
+
+## 必要環境
+
+- Ruby >= 3.1
+- Chrome / Chromium (ローカルにインストール済みであること)
+- macOS / Linux (Windows はパスの `file://` URL 化が未対応)
+
+## インストール
+
+```ruby
+# Gemfile
+gem 'vivlio-pdf', github: 'takahashim/vivlio-pdf'
+```
+
+## 使い方
+
+```ruby
+require 'vivlio/pdf'
+
+# 単発変換
+begin
+  result = Vivlio::PDF.print(
+    source: 'book/OEBPS/package.opf', # HTML / 展開済みEPUBのOPF / webpub manifest
+    output: 'book.pdf',
+    outline: :toc,                    # :toc(既定) / :headings / :none
+    metadata: { title: 'Vivliostyleで技術書をかこう！', author: 'takahashim' }
+  )
+rescue Vivlio::PDF::Error => e
+  # 変換の失敗はすべてこの派生（TimeoutError / RenderError など）で届きます。
+  # ブラウザ駆動の内部例外(Ferrum)がそのまま漏れてくることはありません。
+  abort e.message
+end
+
+result.pages      #=> 120
+result.bookmarks  #=> 79（PDF に実際に入ったしおりの数）
+result.warnings   #=> []（目次が読めなかった等、変換は続行した問題）
+result.to_s       #=> "book.pdf"（文字列としても振る舞う）
+
+# 複数変換(ブラウザを使い回す)
+Vivlio::PDF::Printer.open do |printer|
+  printer.print(source: 'a.html', output: 'a.pdf', style: 'print.css')
+  printer.print(source: 'b.html', output: 'b.pdf')
+end
+```
+
+#### 主なオプション
+
+- `browser_path:` Chrome 実行ファイルのパス(省略時は自動検出)
+- `viewer:` 同梱以外の Vivliostyle Viewer(パスまたは `Viewer` オブジェクト)
+- `timeout:` レンダリング待ちの上限秒(既定 300)
+- `process_timeout:` Chrome 起動待ちの上限秒(既定 30)
+- `style:` 追加スタイルシートのパス(複数可)
+- `book_mode:` 目次/spine をたどって全体を読む(既定: OPF/manifest なら true)
+
+## 構成
+
+- `Printer`: ブラウザを保有し、変換全体を差配する
+- `Viewer`: Viewer の所在と、文書を開く URL の組み立て
+- `Source`: 変換対象の文書 (HTML / OPF / manifest)
+- `Session`: 開かれた1文書用のセッション。描画完了待ち・目次取得・PDF化などに使用
+- `Outline::{Toc,Headings,None}`: しおりの生成
+- `TocItem`: 目次の木構造 (値オブジェクト)
+- `Metadata`: 文書情報辞書に書く値 (値オブジェクト)
+- `Document`: 出力 PDF。hexapdf でしおり・メタデータを書き込む
+- `Result`: 変換結果(パス・ページ数・しおり数)
+
+## PDF しおりの仕組み
+
+`outline: :toc` では vivliostyle-cli と同じ方式を使います。
+
+印刷前に目次リンクを DOM に表示して Chromium に名前付きデスティネーションを埋め込ませ、`coreViewer.getTOC()` の木構造から [hexapdf](https://hexapdf.gettalong.org/) で /Outlines を構築します。
+ページ番号の計算は行いません。
+
+## ライセンス
+
+AGPL-3.0-or-later。詳細は [LICENSE](./LICENSE.txt) を参照してください。
+
+- `vendor/viewer/` には [@vivliostyle/viewer](https://www.npmjs.com/package/@vivliostyle/viewer)(AGPL-3.0)を同梱しています。
+  対応するソースコードは[vivliostyle/vivliostyle.js](https://github.com/vivliostyle/vivliostyle.js)の該当バージョンタグから入手できます。
+- 依存gemのライセンスは ferrum は MIT、hexapdf は AGPL-3.0 です。
+
+※ 本 gem で生成した PDF は AGPL の対象外です(ソフトウェア自体の配布・ネットワーク提供時のみ義務が発生します)
+
+## 同梱している Viewer のバージョン
+
+同梱中のバージョンは `vendor/viewer/package.json` に記録されており、実行時は
+`Vivlio::PDF::Viewer.default.version` で参照できます。
+
+Viewer は依存ではなく同梱物なので、gem のバージョンを固定すれば紙面が固定されます。
+本のリポジトリで `Gemfile.lock` を維持していれば、あとから組み直しても同じ PDF が得られます。
+入稿前に `bundle update` しないでください。
+
+Viewer が変わるとページ送りが変わることがあります。テストが通っても変わります。
+そのため本 gem では、Viewer の更新を含むリリースは patch では出しません(最低でも minor)。
+
+別のバージョンを使いたい場合は、gem を待たずに差し替えられます。
+
+```ruby
+Vivlio::PDF.print(source: 'book.opf', output: 'book.pdf',
+                  viewer: '/path/to/vivliostyle-viewer')
+```
+
+## Viewer の更新方法
+
+```console
+$ rake "viewer:update[2.45.0]"
+```
+
+バージョンは同梱の `package.json` から読むので、他に更新すべき箇所はありません。
+ソースマップは同梱しません(実行時に不要で、他のファイルの合計より大きいため)。
+Viewer の TypeScript を読みたいときは、npm の tarball から
+`vendor/viewer/js/` に手で置いてください。`.gitignore` で除外してあります。
+
+新しいリリースは GitHub Actions が週次で検出し、更新用のプルリクエストを起票します
+(`.github/workflows/update-viewer.yml`)。自動マージはしません。
+`test/test_viewer_behavior.rb` は Viewer の挙動を固定したテストで、
+ここが落ちている場合は不具合ではなく Viewer 側の挙動が変わったことを意味します。
+回避策を外せるようになった可能性があるので、内容を確認してください。

data/README.md

@@ -0,0 +1,126 @@
+# vivlio-pdf
+
+CSS typesetting from Ruby: a gem that renders print-quality PDFs.
+
+[日本語版 README はこちら](./README.ja.md)
+
+It drives a local Chrome/Chromium over CDP via [ferrum](https://github.com/rubycdp/ferrum), loading documents into the bundled [Vivliostyle Viewer](https://github.com/vivliostyle/vivliostyle.js) to produce PDFs with full CSS Paged Media support — running heads, page numbers, TOC leaders, and PDF bookmarks.
+
+No Node.js required; it runs on Ruby alone.
+
+## Requirements
+
+- Ruby >= 3.1
+- Chrome / Chromium (installed locally)
+- macOS / Linux (Windows is not supported: paths are not converted to `file://` URLs correctly)
+
+## Installation
+
+```ruby
+# Gemfile
+gem 'vivlio-pdf', github: 'takahashim/vivlio-pdf'
+```
+
+## Usage
+
+```ruby
+require 'vivlio/pdf'
+
+# One-shot conversion
+begin
+  result = Vivlio::PDF.print(
+    source: 'book/OEBPS/package.opf', # HTML / OPF of an unzipped EPUB / webpub manifest
+    output: 'book.pdf',
+    outline: :toc,                    # :toc (default) / :headings / :none
+    metadata: { title: 'Writing Books with Vivliostyle', author: 'takahashim' }
+  )
+rescue Vivlio::PDF::Error => e
+  # Every conversion failure arrives as a subclass of this
+  # (TimeoutError, RenderError, and so on). The browser-driving
+  # internals (Ferrum) never leak their own exceptions.
+  abort e.message
+end
+
+result.pages      #=> 120
+result.bookmarks  #=> 79 (bookmarks actually present in the PDF)
+result.warnings   #=> [] (problems the conversion survived, e.g. an unreadable TOC)
+result.to_s       #=> "book.pdf" (also acts as a string)
+
+# Several conversions, reusing one browser
+Vivlio::PDF::Printer.open do |printer|
+  printer.print(source: 'a.html', output: 'a.pdf', style: 'print.css')
+  printer.print(source: 'b.html', output: 'b.pdf')
+end
+```
+
+#### Main options
+
+- `browser_path:` path to the Chrome executable (auto-detected when omitted)
+- `viewer:` a Vivliostyle Viewer other than the bundled one (a path or a `Viewer` object)
+- `timeout:` upper limit in seconds to wait for rendering (default 300)
+- `process_timeout:` upper limit in seconds to wait for Chrome to start (default 30)
+- `style:` additional stylesheet path(s)
+- `book_mode:` follow the TOC/spine and read the whole publication (default: true for OPF/manifest)
+
+## Architecture
+
+- `Printer`: owns the browser and orchestrates conversions
+- `Viewer`: locates the viewer and builds the URL that opens a document
+- `Source`: the document to convert (HTML / OPF / manifest)
+- `Session`: one open document; waits for rendering, reads the TOC, prints to PDF
+- `Outline::{Toc,Headings,None}`: bookmark generation strategies
+- `TocItem`: the TOC tree (value object)
+- `Metadata`: values written into the document information dictionary (value object)
+- `Document`: the output PDF; writes bookmarks and metadata via hexapdf
+- `Result`: the outcome of a conversion (path, page count, bookmark count)
+
+## How PDF bookmarks work
+
+With `outline: :toc`, the same approach as vivliostyle-cli is used.
+
+Before printing, the TOC links are made visible in the DOM so that Chromium embeds named destinations for them; the tree from `coreViewer.getTOC()` is then written as `/Outlines` with [hexapdf](https://hexapdf.gettalong.org/).
+No page numbers are computed.
+
+## License
+
+AGPL-3.0-or-later. See [LICENSE](./LICENSE.txt) for details.
+
+- `vendor/viewer/` bundles [@vivliostyle/viewer](https://www.npmjs.com/package/@vivliostyle/viewer) (AGPL-3.0).
+  The corresponding source code is available from the matching version tag of [vivliostyle/vivliostyle.js](https://github.com/vivliostyle/vivliostyle.js).
+- Dependency licenses: ferrum is MIT, hexapdf is AGPL-3.0.
+
+Note: PDFs produced with this gem are not subject to the AGPL. The obligations apply only to distributing the software itself or offering it over a network.
+
+## The bundled viewer version
+
+The bundled version is recorded in `vendor/viewer/package.json` and can be read at run time via `Vivlio::PDF::Viewer.default.version`.
+
+The viewer is vendored, not a dependency, so pinning the gem version pins your page layout.
+As long as your book's repository keeps its `Gemfile.lock`, rebuilding later produces the same PDF.
+Do not `bundle update` right before going to press.
+
+A viewer change can move lines between pages — even when every test passes.
+For that reason, a release that updates the viewer is never a patch release (minor at minimum).
+
+To use a different viewer version without waiting for a gem release:
+
+```ruby
+Vivlio::PDF.print(source: 'book.opf', output: 'book.pdf',
+                  viewer: '/path/to/vivliostyle-viewer')
+```
+
+## Updating the viewer
+
+```console
+$ rake "viewer:update[2.45.0]"
+```
+
+The version is read from the bundled `package.json`, so nothing else needs to be kept in step.
+Source maps are not vendored (they are unused at run time and larger than everything else combined).
+To read the viewer's TypeScript, place the map into `vendor/viewer/js/` by hand from the npm tarball; `.gitignore` keeps it out of the way.
+
+A GitHub Actions workflow checks for new releases weekly and opens an update pull request
+(`.github/workflows/update-viewer.yml`). It never merges automatically.
+`test/test_viewer_behavior.rb` pins the viewer's behaviour: a failure there is not a bug —
+it means the viewer's behaviour changed, possibly in a way that lets a workaround be
+removed, so read what it found.

data/lib/vivlio/pdf/document.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'hexapdf'
+
+module Vivlio
+  module PDF
+    # A PDF file on disk, opened for post-processing.
+    #
+    # Everything here happens after Chromium has printed: only the document
+    # information dictionary and the bookmark outline are touched. Page
+    # positions are never computed -- outline entries point at the named
+    # destinations Chromium already embedded for in-document link targets.
+    class Document
+      # Saves only when the block returns normally: a conversion that raises
+      # half way through leaves the file as Chromium printed it rather than
+      # committing whichever edits happened to be applied first.
+      def self.open(path, &block)
+        document = new(path)
+        return document unless block
+
+        result = block.call(document)
+        document.save
+        result
+      end
+
+      def initialize(path)
+        @path = path
+        @pdf = HexaPDF::Document.open(path)
+        @dirty = false
+      end
+
+      attr_reader :path
+
+      def page_count
+        @pdf.pages.count
+      end
+
+      # Bookmarks actually present, counted from the PDF itself so the number
+      # is right whether we wrote them or Chromium did. Asking HexaPDF for the
+      # outline would create one, so a document without bookmarks is answered
+      # without touching it.
+      def bookmark_count
+        return 0 unless @pdf.catalog.key?(:Outlines)
+
+        @pdf.outline.each_item.count
+      end
+
+      def metadata=(metadata)
+        metadata.write_to(@pdf.trailer.info)
+        @dirty = true
+      end
+
+      # +entries+ is a TocItem forest; nested items become nested bookmarks.
+      def outline=(entries)
+        return if entries.empty?
+
+        add_bookmarks(entries, @pdf.outline)
+        @dirty = true
+      end
+
+      def save
+        return false unless @dirty
+
+        @pdf.write(@path, optimize: true)
+        @dirty = false
+        true
+      end
+
+      private
+
+      def add_bookmarks(entries, parent)
+        entries.each do |entry|
+          bookmark = parent.add_item(entry.label, destination: destination_for(entry))
+          add_bookmarks(entry.children, bookmark)
+        end
+      end
+
+      # Prefer the named destination Chromium created for the anchor; fall back
+      # to the first page so an entry never dangles if the anchor was missing
+      # from the DOM at print time.
+      def destination_for(entry)
+        return first_page_destination unless entry.id
+        return entry.id if @pdf.destinations.resolve(entry.id)
+
+        first_page_destination
+      end
+
+      def first_page_destination
+        [@pdf.pages[0], :Fit]
+      end
+    end
+  end
+end

data/lib/vivlio/pdf/local_file.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Vivlio
+  module PDF
+    # A file on disk the browser will be pointed at: a path that exists, and
+    # the file:// URL naming it.
+    #
+    # Everything the viewer loads -- the document, its stylesheets, the
+    # viewer's own index.html -- is one of these. +kind+ only names the thing
+    # in the error raised when it is missing.
+    class LocalFile
+      attr_reader :path, :url
+
+      def self.coerce(value)
+        value.is_a?(self) ? value : new(value)
+      end
+
+      def initialize(path, kind: 'file')
+        @path = File.expand_path(path.to_s)
+        raise Error, "#{kind} not found: #{@path}" unless File.exist?(@path)
+
+        @url = file_url(@path)
+        freeze
+      end
+
+      def to_s
+        path
+      end
+
+      private
+
+      # Each segment is escaped separately so that the separators survive.
+      def file_url(absolute)
+        "file://#{absolute.split('/').map { |segment| URI.encode_uri_component(segment) }.join('/')}"
+      end
+    end
+  end
+end

data/lib/vivlio/pdf/metadata.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Vivlio
+  module PDF
+    # Values written into the PDF document information dictionary.
+    class Metadata
+      FIELDS = { title: :Title, author: :Author, subject: :Subject,
+                 keywords: :Keywords, creator: :Creator,
+                 creation_date: :CreationDate }.freeze
+
+      attr_reader :title, :author, :subject, :keywords, :creator, :creation_date
+
+      # Accepts a Metadata, a Hash of the fields above, or nil.
+      def self.coerce(value)
+        case value
+        when Metadata then value
+        when nil then new
+        when Hash then new(**value)
+        else raise ArgumentError, "cannot coerce #{value.class} into Metadata"
+        end
+      end
+
+      def initialize(title: nil, author: nil, subject: nil, keywords: nil,
+                     creator: nil, creation_date: nil)
+        @title = title
+        @author = author
+        @subject = subject
+        @keywords = keywords
+        @creator = creator
+        @creation_date = creation_date
+        freeze
+      end
+
+      def to_h
+        FIELDS.keys.to_h { |name| [name, public_send(name)] }.compact
+      end
+
+      # True when there is nothing to write, i.e. no reason to rewrite the PDF
+      # for metadata alone.
+      def empty?
+        to_h.empty?
+      end
+
+      # Names what produced the PDF, unless the caller named it themselves.
+      # Deciding that string is Printer's job: only it knows which viewer
+      # actually did the rendering.
+      def with_creator(creator)
+        return self if @creator
+
+        Metadata.new(**to_h, creator: creator)
+      end
+
+      # +info+ is a HexaPDF document information dictionary.
+      def write_to(info)
+        FIELDS.each do |name, key|
+          value = public_send(name)
+          info[key] = value if value
+        end
+        info
+      end
+    end
+  end
+end

data/lib/vivlio/pdf/outline.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Vivlio
+  module PDF
+    # How PDF bookmarks are produced. Each strategy answers two questions:
+    # whether Chromium should build the outline itself while printing, and
+    # which TOC entries (if any) we write afterwards with HexaPDF.
+    module Outline
+      # Accepts a Strategy, a mode name, or a boolean for callers who think of
+      # bookmarks as something they simply turn on or off.
+      def self.resolve(mode)
+        case mode
+        when Strategy then mode
+        when :toc, 'toc', nil, true then Toc.new
+        when :headings, 'headings' then Headings.new
+        when :none, 'none', false then None.new
+        else raise ArgumentError, "unknown outline mode: #{mode.inspect}"
+        end
+      end
+
+      class Strategy
+        # Set Page.printToPDF's generateDocumentOutline.
+        def chromium_generated?
+          false
+        end
+
+        # TocItems to write into the PDF after printing.
+        def entries(_session)
+          []
+        end
+
+        def to_s
+          self.class.name.split('::').last.downcase
+        end
+      end
+
+      # Bookmarks mirroring the publication's own table of contents, resolved
+      # through the named destinations Chromium embeds for the TOC links.
+      class Toc < Strategy
+        def entries(session)
+          session.toc
+        end
+      end
+
+      # Bookmarks Chromium derives from the h1-h6 outline. Cheaper, but the
+      # depth cannot be controlled.
+      class Headings < Strategy
+        def chromium_generated?
+          true
+        end
+      end
+
+      class None < Strategy
+      end
+    end
+  end
+end

data/lib/vivlio/pdf/printer.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'ferrum'
+
+module Vivlio
+  module PDF
+    # Renders documents to PDF through a browser running the Vivliostyle Viewer.
+    #
+    # A Printer owns one browser instance. Reuse it across conversions and
+    # close it when done, or use the block form which closes it for you:
+    #
+    #   Vivlio::PDF::Printer.open do |printer|
+    #     printer.print(source: 'a.html', output: 'a.pdf')
+    #     printer.print(source: 'b.html', output: 'b.pdf')
+    #   end
+    class Printer
+      DEFAULT_TIMEOUT = 300
+
+      # How long to wait for Chrome to boot and report its websocket URL. This
+      # is Ferrum's :process_timeout, separate from :timeout above -- the latter
+      # bounds rendering, this one bounds startup. Ferrum defaults it to 10s,
+      # which a loaded CI runner occasionally overruns; 30s absorbs that.
+      DEFAULT_PROCESS_TIMEOUT = 30
+
+      # Chromium refuses XHR against file:// without this, and the viewer
+      # fetches the source document that way. Build-tool usage only.
+      BROWSER_OPTIONS = { 'allow-file-access-from-files' => nil }.freeze
+
+      # The optional keywords of .new and of #print: the option surface
+      # Vivlio::PDF.print routes and validates against. Spelled out rather
+      # than derived from the signatures, because these are public API and a
+      # parameter rename should not quietly become an API change. A unit test
+      # fails if either signature drifts away from its list.
+      SETUP_OPTIONS = %i[viewer browser_path timeout process_timeout].freeze
+      PRINT_OPTIONS = %i[outline metadata book_mode style].freeze
+
+      # What one pass through the viewer produced, besides the PDF bytes.
+      Rendering = Struct.new(:entries, :warnings)
+
+      attr_reader :viewer, :timeout
+
+      def self.open(**options)
+        printer = new(**options)
+        return printer unless block_given?
+
+        begin
+          yield printer
+        ensure
+          printer.close
+        end
+      end
+
+      def initialize(viewer: nil, browser_path: nil, timeout: DEFAULT_TIMEOUT,
+                     process_timeout: DEFAULT_PROCESS_TIMEOUT)
+        @viewer = Viewer.coerce(viewer)
+        @timeout = timeout
+        @process_timeout = process_timeout
+        @browser_path = browser_path
+      end
+
+      # Renders +source+ and writes a PDF to +output+, returning a Result.
+      def print(source:, output:, outline: :toc, metadata: nil, book_mode: nil, style: nil)
+        source = Source.coerce(source)
+        strategy = Outline.resolve(outline)
+        metadata = Metadata.coerce(metadata)
+        book_mode = source.publication? if book_mode.nil?
+        url = @viewer.url_for(source, book_mode: book_mode, style: style)
+
+        StagedFile.write(output) do |staged|
+          rendering = render(url, strategy, staged)
+          pages, bookmarks = finalize(staged, metadata: metadata, entries: rendering.entries)
+          Result.new(path: output, pages: pages, bookmarks: bookmarks,
+                     outline: rendering.entries, warnings: rendering.warnings)
+        end
+      end
+
+      def browser
+        @browser ||= PDF.translate_browser_errors do
+          Ferrum::Browser.new(
+            headless: true,
+            timeout: @timeout,
+            process_timeout: @process_timeout,
+            browser_path: @browser_path,
+            browser_options: BROWSER_OPTIONS
+          )
+        end
+      end
+
+      def close
+        PDF.translate_browser_errors { @browser&.quit }
+        @browser = nil
+      end
+
+      private
+
+      # Lays the document out and writes the printed bytes to +staged+.
+      def render(url, strategy, staged)
+        with_session(url) do |session|
+          entries = strategy.entries(session)
+          File.binwrite(staged, session.to_pdf(generate_outline: strategy.chromium_generated?))
+          Rendering.new(entries, session.warnings)
+        end
+      end
+
+      def with_session(url)
+        page = PDF.translate_browser_errors { browser.create_page }
+        session = Session.open(page, url, timeout: @timeout)
+        begin
+          yield session
+        ensure
+          session.close
+        end
+      end
+
+      # Applies metadata and bookmarks, and reports what the finished PDF holds.
+      def finalize(output, metadata:, entries:)
+        Document.open(output) do |document|
+          document.metadata = metadata.with_creator(creator) unless metadata.empty?
+          document.outline = entries
+          [document.page_count, document.bookmark_count]
+        end
+      end
+
+      # How the PDF says it was made. The viewer version is read off the viewer
+      # actually in use, so it stays true when a caller supplies their own.
+      def creator
+        "vivlio-pdf #{VERSION} (Vivliostyle Viewer #{@viewer.version || 'unknown'})"
+      end
+    end
+  end
+end

data/lib/vivlio/pdf/result.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Vivlio
+  module PDF
+    # The outcome of one conversion.
+    #
+    # Behaves like the output path in string contexts, so callers that only
+    # care where the file landed can keep treating the return value as one.
+    class Result
+      # +outline+ is the table of contents we read from the viewer, empty when
+      # the bookmarks came from Chromium instead. +bookmarks+ counts what the
+      # PDF really contains, so it holds for every outline mode.
+      attr_reader :path, :pages, :bookmarks, :outline, :warnings
+
+      def initialize(path:, pages:, bookmarks:, outline: [], warnings: [])
+        @path = path.to_s
+        @pages = pages
+        @bookmarks = bookmarks
+        @outline = outline.freeze
+        @warnings = warnings.freeze
+        freeze
+      end
+
+      def size
+        File.size(path)
+      end
+
+      def to_s
+        path
+      end
+      alias to_str to_s
+
+      def inspect
+        "#<#{self.class} #{path.inspect} pages=#{pages} bookmarks=#{bookmarks}>"
+      end
+    end
+  end
+end