mirzam 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 982e3a0d7e8a664d623a46d033b9efe1aff80bc29544d4cf2d4b2d3534233cff
+  data.tar.gz: c278c0925fc080cb1d87e123222df7f86ce5e61162352541b2cb6ed8be0bb244
+SHA512:
+  metadata.gz: 027753a83045073c87d38c4e81aacca24bc8a7d15354b3a040c069d1624b0fde2fab10625edd2fc9f73a29139ad1d085aaff6368d8fa1bb9de05b2bde9831884
+  data.tar.gz: '01009d02036ad5bbe29e8d2c87baa0fc68cdb2fe7c7b51c3071eddeb66bdaa701ba7f4336193902d6bf0f187cefa5b657ffb482a1d2dff462c56436b37451301'

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0 - 2026-09-20
+
+- Initial release.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yudai Takada
+
+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/README.md

@@ -0,0 +1,38 @@
+# Mirzam
+
+Deterministic 1200×630 OGP image generation from Markdown front matter. It
+provides default, minimal, and feature templates, title fitting, and a SHA256
+sidecar cache for batch builds.
+
+## Installation
+
+```sh
+gem install mirzam
+```
+
+## Usage
+
+```sh
+mirzam render --input content/posts/hello.md --out public/ogp/hello.png
+mirzam render --input content/posts/hello.json --out public/ogp/hello.png
+mirzam render --title "Hello" --author noxdea --size 1200x630 --out hello.png
+mirzam batch "content/posts/**/*.md" --out-dir public/ogp
+mirzam templates
+```
+
+Front matter requires `title`; JSON input uses the same metadata keys.
+`author`, `date`, `tags`, `accent`, and `ogp.template` are optional. The Ruby
+API is `Mirzam.render(title: "Hello")`.
+The same batch command is available through [`action.yml`](action.yml).
+
+## Development
+
+Run `rake spec` and `gem build --strict mirzam.gemspec`.
+
+## Contributing
+
+Bug reports and pull requests are welcome at https://github.com/noxdea/mirzam.
+
+## License
+
+MIT.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/action.yml

@@ -0,0 +1,45 @@
+name: Mirzam OGP
+description: Generate deterministic OGP images from Markdown front matter
+inputs:
+  pattern:
+    description: Glob of Markdown files
+    required: true
+  out-dir:
+    description: Output directory
+    required: false
+    default: public/ogp
+  template:
+    description: Template name or Ruby file
+    required: false
+    default: default
+  theme:
+    description: dark, light, high_contrast, or a token file
+    required: false
+    default: dark
+  force:
+    description: Ignore sidecar hashes
+    required: false
+    default: 'false'
+runs:
+  using: composite
+  steps:
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@984c0c890880bbf811283d6f09c4607c62d210a4 # v1.323.0
+      with:
+        ruby-version: '3.3'
+    - name: Install Mirzam
+      shell: bash
+      run: gem install mirzam --no-document # zizmor: ignore[adhoc-packages]
+    - name: Render OGP images
+      shell: bash
+      env:
+        MIRZAM_PATTERN: ${{ inputs.pattern }}
+        MIRZAM_OUT_DIR: ${{ inputs.out-dir }}
+        MIRZAM_TEMPLATE: ${{ inputs.template }}
+        MIRZAM_THEME: ${{ inputs.theme }}
+        MIRZAM_FORCE: ${{ inputs.force }}
+      run: |
+        args=(batch "$MIRZAM_PATTERN" --out-dir "$MIRZAM_OUT_DIR" --template "$MIRZAM_TEMPLATE")
+        [[ "$MIRZAM_THEME" != dark ]] && args+=(--theme "$MIRZAM_THEME")
+        [[ "$MIRZAM_FORCE" == true ]] && args+=(--force)
+        mirzam "${args[@]}"

data/assets/fonts/OFL.txt

@@ -0,0 +1,93 @@
+Copyright (c) 2011, Matthew Desmond (http://www.madtype.com | mattdesmond@gmail.com),with Reserved Font Name Abel.
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

data/exe/mirzam

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "mirzam"
+exit Mirzam::CLI.run(ARGV)

data/lib/mirzam/version.rb

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

data/lib/mirzam.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+require "date"
+require "digest"
+require "fileutils"
+require "json"
+require "optparse"
+require "pathname"
+require "yaml"
+require "zlib"
+require "zaniah"
+begin
+  require "auva"
+rescue LoadError
+end
+require_relative "mirzam/version"
+
+module Mirzam
+  class Error < StandardError; end
+  Source = Data.define(:title, :author, :date, :tags, :description, :accent, :template, :logo, :avatar) do
+    def self.from(hash)
+      raise Error, "metadata must be a mapping" unless hash.is_a?(Hash)
+      values = hash.transform_keys(&:to_sym)
+      ogp = values[:ogp].is_a?(Hash) ? values[:ogp].transform_keys(&:to_sym) : {}
+      new(title: values.fetch(:title).to_s, author: values[:author]&.to_s,
+        date: values[:date]&.to_s, tags: Array(values[:tags]).map(&:to_s),
+        description: values[:description]&.to_s, accent: values[:accent] || ogp[:accent],
+        template: (values[:template] || ogp[:template])&.to_sym,
+        logo: (values[:logo] || ogp[:logo])&.to_s, avatar: (values[:avatar] || ogp[:avatar])&.to_s)
+    rescue KeyError
+      raise Error, "front matter requires title"
+    end
+  end
+
+  module FrontMatter
+    module_function
+
+    def parse(text)
+      text = text.to_s.delete_prefix("\uFEFF")
+      return Source.from(title: text.to_s) unless text.start_with?("---")
+      closing = text.match(/^---\s*$\n?/, 3)
+      raise Error, "front matter is not closed" unless closing
+      header = text[4...closing.begin(0)]
+      values = YAML.safe_load(header, permitted_classes: [Date, Time], aliases: false) || {}
+      raise Error, "front matter must be a mapping" unless values.is_a?(Hash)
+      Source.from(values)
+    rescue Psych::Exception => error
+      line = error.respond_to?(:line) ? error.line : nil
+      raise Error, "invalid front matter#{line ? " at line #{line}" : ""}: #{error.message}"
+    end
+
+    def read(path)
+      parse(File.read(path, encoding: "UTF-8"))
+    rescue Errno::ENOENT
+      raise Error, "input file not found: #{path}"
+    end
+  end
+
+  module Input
+    module_function
+
+    def read(path)
+      source = File.read(path, encoding: "UTF-8").delete_prefix("\uFEFF")
+      metadata = File.extname(path).downcase == ".json" ? Source.from(JSON.parse(source)) : FrontMatter.parse(source)
+      base = File.dirname(File.expand_path(path))
+      metadata.with(logo: resolve_asset(metadata.logo, base), avatar: resolve_asset(metadata.avatar, base))
+    rescue Errno::ENOENT
+      raise Error, "input file not found: #{path}"
+    rescue JSON::ParserError => error
+      raise Error, "invalid JSON: #{error.message}"
+    end
+
+    def resolve_asset(value, base)
+      return value unless value && !value.empty? && !Pathname.new(value).absolute?
+      File.expand_path(value, base)
+    rescue ArgumentError
+      value
+    end
+    private_class_method :resolve_asset
+  end
+
+  module Sizing
+    SIZES = [64, 56, 48, 42, 36].freeze
+    module_function
+
+    def fit_size(text, max_width:, max_height:, typesetter: nil)
+      return SIZES.last unless typesetter
+      SIZES.find do |size|
+        paragraph = typesetter.layout_paragraph(text.to_s, width: max_width, size: size,
+          wrap: :word, kinsoku: :hanging)
+        paragraph.height <= max_height
+      end || SIZES.last
+    end
+  end
+
+  module Templates
+    class Default
+      SIZE = [1200, 630].freeze
+      PADDING = 72
+
+      def initialize(theme: Zaniah::Theme.dark, accent: nil)
+        @theme = theme
+        @accent = accent ? Zaniah::Color.parse(accent) : theme.colors.accent
+      end
+
+      def call(source, renderer)
+        size = renderer.fit_size(source.title, max_width: SIZE[0] - PADDING * 2, max_height: 300)
+        root = Zaniah::Div.new.flex_col.p(PADDING).gap(20).bg(@theme.colors.background)
+          .child(brand(source))
+          .child(Zaniah::Text.new(source.author ? "#{source.author} · #{source.date}" : "",
+            size: 20, color: @accent))
+          .child(Zaniah::Text.new(source.title, size: size, color: @theme.colors.text))
+          .child(Zaniah::Text.new(source.tags.empty? ? "" : source.tags.map { |tag| "##{tag}" }.join("  "),
+            size: 18, color: @theme.colors.text_muted))
+        root
+      end
+
+      private
+
+      def brand(source)
+        path = source.avatar || source.logo
+        return Zaniah::Div.new.h(1) unless path && File.file?(path)
+        Zaniah::Image.new(path).style(width: 64, height: 64)
+      rescue StandardError
+        Zaniah::Div.new.h(1)
+      end
+    end
+
+    class Minimal < Default
+      def call(source, renderer)
+        size = renderer.fit_size(source.title, max_width: 1056, max_height: 420)
+        Zaniah::Div.new.flex_col.justify_center.p(72).bg(@theme.colors.background)
+          .child(Zaniah::Text.new(source.title, size: size, color: @theme.colors.text))
+      end
+    end
+
+    class Feature < Default
+      def call(source, renderer)
+        Default.new(theme: @theme, accent: source.accent || @accent).call(source, renderer)
+          .child(Zaniah::Text.new(source.description.to_s, size: 16, color: @theme.colors.text_muted))
+      end
+    end
+
+    module_function
+
+    def resolve(name, theme: Zaniah::Theme.dark)
+      if name.to_s.end_with?(".rb") && File.file?(name.to_s)
+        path = File.expand_path(name.to_s)
+        value = eval(File.read(path, encoding: "UTF-8"), TOPLEVEL_BINDING, path, 1)
+        return value if value.respond_to?(:call)
+        raise Error, "template file must return a callable"
+      end
+      case name.to_s
+      when "default" then Default.new(theme: theme)
+      when "minimal" then Minimal.new(theme: theme)
+      when "feature" then Feature.new(theme: theme)
+      else raise Error, "unknown template: #{name}"
+      end
+    end
+  end
+
+  class Renderer
+    SIZE = [1200, 630].freeze
+    FONTS = Dir[File.expand_path("../assets/fonts/*.{ttf,otf}", __dir__)].freeze
+
+    attr_reader :typesetter
+
+    def initialize(theme: Zaniah::Theme.dark, width: SIZE[0], height: SIZE[1], font_dir: nil)
+      @theme, @width, @height, @font_dir = theme, width, height, font_dir
+      @font_db = Zaniah::TextSystem::FontDB.new(paths: font_dir ? Array(font_dir) : FONTS)
+      @font = @font_db.find(family: theme.typography.font_sans)
+      @text_system = Zaniah::TextSystem::Renderer.new(font: @font, font_db: @font_db)
+      @typesetter = Zaniah::TextSystem::Typesetter.new(font: @font, font_db: @font_db)
+    rescue StandardError
+      @font_db = @font = @text_system = @typesetter = nil
+    end
+
+    def fit_size(text, max_width:, max_height:)
+      return Sizing.fit_size(text, max_width: max_width, max_height: max_height, typesetter: @typesetter) if @typesetter
+      Sizing::SIZES.last
+    end
+
+    def cache_key
+      [@width, @height, @font_dir, @theme.inspect].join("\0")
+    end
+
+    def render(source, template: Templates::Default.new(theme: @theme))
+      app = Zaniah::App.new
+      window = app.open_window(backend: :headless, width: @width, height: @height)
+      app.global(:theme, @theme)
+      window.text_system = @text_system if @text_system
+      window.draw { template.call(source, self) }
+      window.tick
+      device = window.device
+      Zaniah::PNG.encode(device.width.to_i, device.height.to_i, device.pixels)
+    ensure
+      window&.close
+    end
+  end
+
+  class Batch
+    def initialize(renderer: Renderer.new, template: :default)
+      @renderer, @template = renderer, template
+    end
+
+    def render(paths, out_dir:, force: false)
+      FileUtils.mkdir_p(out_dir)
+      paths.sort.filter_map do |path|
+        source = Input.read(path)
+        destination = File.join(out_dir, "#{File.basename(path, ".*")}.png")
+        template_path = @template.to_s
+        template_signature = File.file?(template_path) ? File.binread(template_path) : @template.to_s
+        signature = Digest::SHA256.hexdigest(File.binread(path) + template_signature + @renderer.cache_key)
+        state_path = "#{destination}.json"
+        next if !force && File.file?(destination) && File.file?(state_path) && File.read(state_path).include?(signature)
+        png = @renderer.render(source, template: Templates.resolve(source.template || @template))
+        File.binwrite(destination, png)
+        File.write(state_path, "{\"sha256\":\"#{signature}\"}\n")
+        destination
+      end
+    end
+  end
+
+  module_function
+
+  def theme(value)
+    return value if value.respond_to?(:colors)
+    return Auva.load(value) if defined?(Auva) && File.file?(value.to_s)
+    return Auva.builtin(value) if defined?(Auva)
+    Zaniah::Theme.public_send(value.to_s)
+  rescue NoMethodError
+    raise Error, "unknown theme: #{value}"
+  end
+
+  def render(title:, author: nil, date: nil, tags: [], description: nil, accent: nil, logo: nil, avatar: nil,
+    template: :default, theme: :dark, width: 1200, height: 630, font_dir: nil)
+    source = Source.new(title: title.to_s, author: author&.to_s, date: date&.to_s,
+      tags: Array(tags).map(&:to_s), description: description&.to_s, accent: accent, template: template.to_sym,
+      logo: logo&.to_s, avatar: avatar&.to_s)
+    selected_theme = theme(theme)
+    Renderer.new(theme: selected_theme, width: width, height: height, font_dir: font_dir)
+      .render(source, template: Templates.resolve(template, theme: selected_theme))
+  end
+
+  class CLI
+    def self.run(argv, out: $stdout, err: $stderr)
+      command = %w[render batch templates preview].include?(argv.first) ? argv.shift : "render"
+      case command
+      when "templates"
+        out.puts %w[default minimal feature]
+        return 0
+      when "render", "preview" then render(argv)
+      when "batch" then batch(argv)
+      end
+    rescue OptionParser::ParseError, KeyError, Error => error
+      err.puts "mirzam: #{error.message}"
+      1
+    end
+
+    def self.render(argv)
+      options = {title: nil, author: nil, logo: nil, avatar: nil, out: nil, input: nil, template: :default, theme: :dark, width: 1200, height: 630, font_dir: nil}
+      OptionParser.new do |opts|
+        opts.on("--input PATH") { |v| options[:input] = v }
+        opts.on("--title TITLE") { |v| options[:title] = v }
+        opts.on("--author NAME") { |v| options[:author] = v }
+        opts.on("--logo PATH") { |v| options[:logo] = v }
+        opts.on("--avatar PATH") { |v| options[:avatar] = v }
+        opts.on("--out PATH") { |v| options[:out] = v }
+        opts.on("--template NAME") { |v| options[:template] = v.end_with?(".rb") ? v : v.to_sym }
+        opts.on("--theme NAME") { |v| options[:theme] = v }
+        opts.on("--size SIZE") { |v| options[:width], options[:height] = v.split("x", 2).map { |part| Integer(part, 10) } }
+        opts.on("--font-dir PATH") { |v| options[:font_dir] = v }
+      end.parse!(argv)
+      source = options[:input] ? Input.read(options[:input]) : Source.from(title: options[:title] || argv.fetch(0),
+        author: options[:author], logo: options[:logo], avatar: options[:avatar])
+      selected_theme = Mirzam.theme(options[:theme])
+      selected_template = source.template || options[:template]
+      png = Renderer.new(theme: selected_theme, width: options[:width], height: options[:height], font_dir: options[:font_dir])
+        .render(source, template: Templates.resolve(selected_template, theme: selected_theme))
+      File.binwrite(options[:out] || "mirzam.png", png)
+      0
+    end
+    private_class_method :render
+
+    def self.batch(argv)
+      options = {out_dir: "public/ogp", template: :default, force: false, theme: :dark, width: 1200, height: 630, font_dir: nil}
+      OptionParser.new do |opts|
+        opts.on("--out-dir DIR") { |v| options[:out_dir] = v }
+        opts.on("--template NAME") { |v| options[:template] = v.end_with?(".rb") ? v : v.to_sym }
+        opts.on("--theme NAME") { |v| options[:theme] = v }
+        opts.on("--size SIZE") { |v| options[:width], options[:height] = v.split("x", 2).map { |part| Integer(part, 10) } }
+        opts.on("--font-dir PATH") { |v| options[:font_dir] = v }
+        opts.on("--force") { options[:force] = true }
+      end.parse!(argv)
+      paths = argv.flat_map { |pattern| Dir[pattern] }
+      renderer = Renderer.new(theme: Mirzam.theme(options[:theme]), width: options[:width], height: options[:height], font_dir: options[:font_dir])
+      Batch.new(renderer: renderer, template: options[:template]).render(paths, out_dir: options[:out_dir], force: options[:force])
+      0
+    end
+    private_class_method :batch
+  end
+end

data/sig/mirzam.rbs

@@ -0,0 +1,9 @@
+module Mirzam
+  VERSION: String
+  def self.render: (title: String, ?author: String?, ?date: String?, ?tags: Array[String], ?description: String?, ?accent: String?, ?template: Symbol, ?theme: untyped, ?width: Integer, ?height: Integer, ?font_dir: String?) -> String
+  class Error < StandardError
+  end
+  class Renderer
+    def render: (untyped source, ?template: untyped) -> String
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: mirzam
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zaniah
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+description: Generate OGP PNGs from article metadata using Zaniah.
+email:
+- t.yudai92@gmail.com
+executables:
+- mirzam
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- action.yml
+- assets/fonts/Abel-Regular.ttf
+- assets/fonts/OFL.txt
+- exe/mirzam
+- lib/mirzam.rb
+- lib/mirzam/version.rb
+- sig/mirzam.rbs
+homepage: https://github.com/noxdea/mirzam
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  source_code_uri: https://github.com/noxdea/mirzam
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Deterministic OGP image generator for Ruby
+test_files: []