nashira 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f10b503ffd6a27b47c7b2ceca97319e9e34c48561a0a019e3d7d3ff68fcf4a8e
+  data.tar.gz: 0ccde2a93e6a4a8a10f9e561e4d74e0e3ec07032634cad8275ede23eeb75687e
+SHA512:
+  metadata.gz: 3e1d6a744ca35819a42a45b113c9b24d64c5e566b9e1aa90fbfe8e5e6f755caec68835a74db35c2114f8d82b70b16c56cb2be7ec5d672ebc4303624ef313d22c
+  data.tar.gz: 6a5c13f7fefa5512015376fc153bc7477f6f05dbb0dfe1542333125d8d3070e4cefb2f899ec7670acbf81a4ab62664aca0e6a7098d546c95a7bc10095d60b971

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,39 @@
+# Nashira
+
+Deterministic CI report cards for JUnit, SimpleCov, and benchmark JSON. Nashira
+always writes both a PNG card and a Markdown summary, so the result remains
+useful when images are unavailable.
+
+## Installation
+
+```sh
+gem install nashira
+```
+
+## Usage
+
+```sh
+nashira build --junit 'tmp/junit/*.xml' \
+  --coverage coverage/.last_run.json \
+  --history .ci-history/history.json \
+  --now 2026-09-19T14:32:00Z \
+  --out card.png --summary summary.md
+```
+
+Use `--fail-on coverage-drop` (or `--fail-on tests`) in CI. The composite
+action in [`action.yml`](action.yml) installs the gem and appends the summary to
+`GITHUB_STEP_SUMMARY`. Set `history-branch` to persist the history and image on
+an orphan branch; that workflow needs `contents: write`. Without it, the
+action falls back to the cache and still emits the Markdown summary.
+
+## Development
+
+Run `rake spec` and `gem build --strict nashira.gemspec`.
+
+## Contributing
+
+Bug reports and pull requests are welcome at https://github.com/noxdea/nashira.
+
+## 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,144 @@
+name: Nashira CI report
+description: Render a deterministic CI report card and Job Summary
+inputs:
+  junit:
+    description: JUnit glob
+    required: false
+  coverage:
+    description: SimpleCov JSON path
+    required: false
+  bench:
+    description: Benchmark JSON path
+    required: false
+  history:
+    description: History JSON path
+    required: false
+    default: .ci-history/history.json
+  out:
+    description: PNG output path
+    required: false
+    default: nashira-card.png
+  summary:
+    description: Markdown output path
+    required: false
+    default: nashira-summary.md
+  history-branch:
+    description: Optional branch name reserved for persistent history
+    required: false
+  comment-on-pr:
+    description: Upsert the report as a pull request comment
+    required: false
+    default: 'false'
+  github-token:
+    description: Token used for pull request comments
+    required: false
+    default: ${{ github.token }}
+runs:
+  using: composite
+  steps:
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@984c0c890880bbf811283d6f09c4607c62d210a4 # v1.323.0
+      with:
+        ruby-version: '3.3'
+    - name: Install Nashira
+      shell: bash
+      env:
+        NASHIRA_ACTION_PATH: ${{ github.action_path }}
+      run: | # zizmor: ignore[adhoc-packages]
+        set -euo pipefail
+        cd "$NASHIRA_ACTION_PATH"
+        gem build --strict nashira.gemspec
+        gem install ./nashira-*.gem --no-document
+    - name: Restore report history
+      if: inputs.history-branch == ''
+      uses: actions/cache@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+      with:
+        path: ${{ inputs.history }}
+        key: nashira-history-${{ github.repository }}-${{ github.ref_name }}-${{ github.run_id }}
+        restore-keys: |
+          nashira-history-${{ github.repository }}-${{ github.ref_name }}-
+    - name: Restore branch history
+      if: inputs.history-branch != ''
+      shell: bash
+      env:
+        HISTORY_BRANCH: ${{ inputs.history-branch }}
+        HISTORY_PATH: ${{ inputs.history }}
+      run: |
+        set -euo pipefail
+        if git fetch --no-tags origin "refs/heads/${HISTORY_BRANCH}:refs/remotes/origin/${HISTORY_BRANCH}"; then
+          mkdir -p "$(dirname "$HISTORY_PATH")"
+          git show "refs/remotes/origin/${HISTORY_BRANCH}:${HISTORY_PATH}" > "$HISTORY_PATH" || true
+        fi
+    - name: Build report
+      shell: bash
+      env:
+        NASHIRA_JUNIT: ${{ inputs.junit }}
+        NASHIRA_COVERAGE: ${{ inputs.coverage }}
+        NASHIRA_BENCH: ${{ inputs.bench }}
+        NASHIRA_HISTORY: ${{ inputs.history }}
+        NASHIRA_OUT: ${{ inputs.out }}
+        NASHIRA_SUMMARY: ${{ inputs.summary }}
+      run: |
+        args=(build --out "$NASHIRA_OUT" --summary "$NASHIRA_SUMMARY" --history "$NASHIRA_HISTORY")
+        [[ -n "$NASHIRA_JUNIT" ]] && args+=(--junit "$NASHIRA_JUNIT")
+        [[ -n "$NASHIRA_COVERAGE" ]] && args+=(--coverage "$NASHIRA_COVERAGE")
+        [[ -n "$NASHIRA_BENCH" ]] && args+=(--bench "$NASHIRA_BENCH")
+        nashira "${args[@]}"
+    - name: Publish branch history and image
+      if: inputs.history-branch != ''
+      shell: bash
+      env:
+        HISTORY_BRANCH: ${{ inputs.history-branch }}
+        HISTORY_PATH: ${{ inputs.history }}
+        IMAGE_PATH: ${{ inputs.out }}
+        SUMMARY_PATH: ${{ inputs.summary }}
+      run: |
+        set -euo pipefail
+        workspace="$GITHUB_WORKSPACE"
+        branch_dir="$(mktemp -d)"
+        cleanup() { git worktree remove --force "$branch_dir" >/dev/null 2>&1 || true; rm -rf "$branch_dir"; }
+        trap cleanup EXIT
+        git worktree add --detach "$branch_dir" HEAD >/dev/null
+        cd "$branch_dir"
+        git checkout --orphan "$HISTORY_BRANCH" >/dev/null 2>&1
+        git rm -rf . >/dev/null 2>&1 || true
+        mkdir -p "$(dirname "$HISTORY_PATH")"
+        cp "$workspace/$HISTORY_PATH" "$HISTORY_PATH"
+        image_name="$(basename "$IMAGE_PATH")"
+        cp "$workspace/$IMAGE_PATH" "$image_name"
+        git add "$HISTORY_PATH" "$image_name"
+        git -c user.name=nashira -c user.email=nashira@users.noreply.github.com commit -m "Update CI report" >/dev/null
+        raw_url="https://raw.githubusercontent.com/${GITHUB_REPOSITORY}/${HISTORY_BRANCH}/${image_name}"
+        git push origin "HEAD:${HISTORY_BRANCH}" --force >/dev/null || {
+          echo "nashira: unable to publish history branch; summary remains available"
+          exit 0
+        }
+        summary="$workspace/$SUMMARY_PATH"
+        if [[ -f "$summary" ]]; then
+          sed -i.bak "s#](${IMAGE_PATH})#](${raw_url})#g" "$summary"
+          rm -f "$summary.bak"
+        fi
+    - name: Append report summary
+      shell: bash
+      env:
+        SUMMARY_PATH: ${{ inputs.summary }}
+      run: cat "$SUMMARY_PATH" >> "$GITHUB_STEP_SUMMARY"
+    - name: Upsert pull request comment
+      if: inputs.comment-on-pr == 'true' && github.event_name == 'pull_request'
+      shell: bash
+      env:
+        GH_TOKEN: ${{ inputs.github-token }}
+        PR_NUMBER: ${{ github.event.pull_request.number }}
+        SUMMARY_PATH: ${{ inputs.summary }}
+      run: |
+        marker='<!-- nashira-report -->'
+        body="$(printf '%s\n\n%s' "$marker" "$(cat "$SUMMARY_PATH")")"
+        if ! existing=$(gh api --paginate "repos/${GITHUB_REPOSITORY}/issues/${PR_NUMBER}/comments" --jq '.[] | select(.body | contains("<!-- nashira-report -->")) | .id' | tail -1); then
+          echo 'nashira: unable to read PR comments; summary remains available'
+          exit 0
+        fi
+        if [[ -n "$existing" ]]; then
+          gh api --method PATCH "repos/${GITHUB_REPOSITORY}/issues/comments/${existing}" -f body="$body"
+        else
+          gh api --method POST "repos/${GITHUB_REPOSITORY}/issues/${PR_NUMBER}/comments" -f body="$body"
+        fi || echo 'nashira: unable to update PR comment; summary remains available'

data/exe/nashira

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

data/lib/nashira/version.rb

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

data/lib/nashira.rb

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "optparse"
+require "rexml/document"
+require "time"
+require "zlib"
+require "zaniah"
+require "zaniah/ui"
+begin
+  require "auva"
+rescue LoadError
+end
+require_relative "nashira/version"
+
+module Nashira
+  class Error < StandardError; end
+  Tests = Data.define(:total, :failed, :skipped, :duration, :slowest, :failures)
+  CoverageData = Data.define(:percent, :covered, :total, :delta)
+  Bench = Data.define(:name, :value, :unit, :delta)
+  HistoryPoint = Data.define(:commit, :coverage, :tests, :at)
+  Report = Data.define(:status, :repository, :branch, :commit, :run_url, :finished_at,
+    :duration, :tests, :coverage, :benchmarks, :history) do
+    def self.build(tests: nil, coverage: nil, benchmarks: [], history: [], **metadata)
+      status = tests&.failed.to_i.positive? ? :fail : :pass
+      new(status: status, repository: metadata[:repository], branch: metadata[:branch],
+        commit: metadata[:commit], run_url: metadata[:run_url], finished_at: metadata[:finished_at],
+        duration: tests&.duration, tests: tests, coverage: coverage,
+        benchmarks: benchmarks || [], history: history || [])
+    end
+  end
+  ParseResult = Data.define(:value, :warnings)
+
+  module JUnit
+    module_function
+
+    def parse(paths, top: 5)
+      warnings = []
+      cases = []
+      Array(paths).flat_map { |path| Dir[path.to_s] }.sort.each do |path|
+        begin
+          root = REXML::Document.new(File.read(path, encoding: "UTF-8").delete_prefix("\uFEFF")).root
+          raise REXML::ParseException, "missing root" unless root
+          root.each_element(".//testcase") do |testcase|
+            time = Float(testcase.attributes["time"] || 0)
+            name = [testcase.attributes["classname"], testcase.attributes["name"]].compact.join("#")
+            kind = testcase.elements["failure"] ? :failure : testcase.elements["error"] ? :error : testcase.elements["skipped"] ? :skipped : :pass
+            cases << [name.empty? ? "unknown" : name, time, kind]
+          rescue ArgumentError
+            cases << [testcase.attributes["name"] || "unknown", 0.0, :pass]
+            warnings << "#{path}: invalid testcase time"
+          end
+        rescue StandardError => error
+          warnings << "#{path}: #{error.message}"
+        end
+      end
+      failures = cases.filter_map { |name, _, kind| name if %i[failure error].include?(kind) }
+      result = Tests.new(total: cases.length, failed: failures.length,
+        skipped: cases.count { |_, _, kind| kind == :skipped }, duration: cases.sum { |_, time, _| time },
+        slowest: cases.sort_by { |_, time, _| -time }.first(top).map { |name, time, _| [name, time] }, failures: failures.first(8))
+      ParseResult.new(value: result, warnings: warnings)
+    end
+  end
+
+  module CoverageParser
+    module_function
+
+    def parse(path, base: nil)
+      return ParseResult.new(value: nil, warnings: []) unless path && File.file?(path)
+      warnings = []
+      data = JSON.parse(File.read(path, encoding: "UTF-8").delete_prefix("\uFEFF"))
+      lines = data.dig("result", "line") || data.dig("result", "lines") || data.dig("metrics", "lines") || data["lines"] || {}
+      percent = lines["percent"] || lines["covered_percent"] || data["covered_percent"] || data["percent"]
+      covered = lines["covered"] || data["covered"]
+      total = lines["total"] || data["total"]
+      percent = percent.to_f
+      percent = covered.to_f * 100 / total if percent.zero? && covered && total && total.to_f.positive?
+      ParseResult.new(value: CoverageData.new(percent: percent, covered: covered, total: total,
+        delta: base.nil? ? nil : percent - base.to_f), warnings: warnings)
+    rescue JSON::ParserError, Errno::ENOENT, TypeError, NoMethodError => error
+      ParseResult.new(value: nil, warnings: ["#{path}: #{error.message}"])
+    end
+  end
+
+  module Benchmarks
+    module_function
+
+    def parse(path)
+      return ParseResult.new(value: [], warnings: []) unless path && File.file?(path)
+      value = JSON.parse(File.read(path, encoding: "UTF-8").delete_prefix("\uFEFF"))
+      values = value.is_a?(Array) ? value : value.fetch("benchmarks", value.fetch("results", []))
+      values = values.map.with_index do |entry, index|
+        entry = {"value" => entry} unless entry.is_a?(Hash)
+        Bench.new(name: (entry["name"] || entry["label"] || "bench-#{index}"), value: entry["value"].to_f,
+          unit: entry["unit"] || "", delta: entry["delta"])
+      end
+      ParseResult.new(value: values, warnings: [])
+    rescue JSON::ParserError, Errno::ENOENT, TypeError, NoMethodError => error
+      ParseResult.new(value: [], warnings: ["#{path}: #{error.message}"])
+    end
+  end
+
+  module History
+    MAX = 50
+    module_function
+
+    def load(path)
+      return [] unless path && File.file?(path)
+      values = JSON.parse(File.read(path, encoding: "UTF-8").delete_prefix("\uFEFF"))
+      return [] unless values.is_a?(Array)
+      values.filter_map do |entry|
+        next unless entry.is_a?(Hash)
+        HistoryPoint.new(commit: entry["commit"], coverage: entry["coverage"], tests: entry["tests"], at: entry["at"])
+      end
+    rescue JSON::ParserError, Errno::ENOENT, TypeError
+      []
+    end
+
+    def append(path, point)
+      values = load(path) + [point]
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, JSON.pretty_generate(values.last(MAX).map(&:to_h)) + "\n")
+      values.last(MAX)
+    end
+  end
+
+  module Summary
+    module_function
+
+    def markdown(report, image: nil)
+      lines = ["## Nashira: #{report.status.to_s.upcase}", ""]
+      lines << "![CI report](#{image})" if image
+      lines << "| Metric | Value |" << "| --- | --- |"
+      if report.tests
+        lines << "| Tests | #{report.tests.total} (#{report.tests.failed} failed, #{report.tests.skipped} skipped) |"
+      end
+      if report.coverage
+        delta = report.coverage.delta ? format(" (%+.2f%%)", report.coverage.delta) : ""
+        lines << "| Coverage | #{format("%.2f", report.coverage.percent)}%#{delta} |"
+      end
+      report.benchmarks.each { |bench| lines << "| #{bench.name} | #{bench.value} #{bench.unit} |" }
+      if report.status != :fail && report.history.length > 1
+        trend = report.history.last(20).filter_map(&:coverage).map { |value| format("%.2f", value) }.join(" → ")
+        lines << "| Coverage trend | #{trend} |"
+      end
+      if report.tests&.slowest&.any?
+        lines.concat(["", "### Slowest tests", *report.tests.slowest.map { |name, seconds| "- `#{name}` (#{format("%.3f", seconds)}s)" }])
+      end
+      if report.tests&.failures&.any?
+        lines.concat(["", "### Failed tests", *report.tests.failures.map { |name| "- `#{name}`" }]) if report.status == :fail
+      end
+      lines.join("\n") + "\n"
+    end
+  end
+
+  module View
+    module_function
+
+    def call(report, theme: Zaniah::Theme.dark)
+      title = "[#{report.status.to_s.upcase}] #{report.repository || "CI report"}"
+      status = report.status == :pass ? :success : :danger
+      header = Zaniah::UI::Card.new(
+        Zaniah::UI::Label.new(title, size: :xl),
+        Zaniah::UI::Badge.new(report.status.to_s.upcase, variant: status)
+      )
+      metrics = Zaniah::Div.new.flex_row.gap(12).children([
+        metric("Tests", report.tests && "#{report.tests.total} (#{report.tests.failed} failed)", theme),
+        metric("Coverage", report.coverage && format("%.2f%%", report.coverage.percent), theme),
+        *report.benchmarks.first(3).map { |bench| metric(bench.name, "#{bench.value} #{bench.unit}", theme) }
+      ].compact)
+      trend = if report.status != :fail && report.history.length > 1
+        values = report.history.last(20).filter_map(&:coverage)
+        Zaniah::UI::Card.new(Zaniah::UI::Label.new("Coverage trend", size: :md), Zaniah::UI::Sparkline.new(values, width: 640, height: 120)) unless values.empty?
+      elsif report.tests&.failures&.any?
+        Zaniah::UI::Card.new(Zaniah::UI::Label.new("Failed tests", size: :md),
+          *report.tests.failures.first(8).map { |name| Zaniah::UI::Label.new(name, tone: :muted, size: :sm) })
+      end
+      slow = if report.tests&.slowest&.any?
+        rows = report.tests.slowest.map { |name, seconds| {name: name, duration: format("%.3fs", seconds)} }
+        Zaniah::UI::Table.new(rows, columns: [
+          {key: :name, label: "Test", width: 560, sortable: false},
+          {key: :duration, label: "Duration", width: 140, sortable: false}
+        ], height: [rows.length * 32 + 40, 100].max, selection: :none)
+      end
+      root = Zaniah::Div.new.flex_col.p(48).gap(18).bg(theme.colors.background).child(header).child(metrics)
+      root.child(trend) if trend
+      root.child(Zaniah::UI::Card.new(Zaniah::UI::Label.new("Slowest tests", size: :md), slow)) if slow
+      root
+    end
+
+    def metric(label, value, _theme)
+      return unless value
+      Zaniah::UI::Card.new(Zaniah::UI::Label.new(label, tone: :muted, size: :xs), Zaniah::UI::Label.new(value, size: :lg))
+    end
+  end
+
+  class Renderer
+    def initialize(theme: Zaniah::Theme.dark, width: 1200, height: 800)
+      @theme, @width, @height = theme, width, height
+      @font_db = Zaniah::TextSystem::FontDB.new(paths: [])
+      @font = @font_db.find(family: theme.typography.font_sans)
+      @text_system = Zaniah::TextSystem::Renderer.new(font: @font, font_db: @font_db)
+    rescue StandardError
+      @font_db = @font = @text_system = nil
+    end
+
+    def render(report)
+      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 { View.call(report, theme: @theme) }
+      window.tick
+      device = window.device
+      Zaniah::PNG.encode(device.width.to_i, device.height.to_i, device.pixels)
+    ensure
+      window&.close
+    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 StandardError
+    raise Error, "unknown theme: #{value}"
+  end
+
+  class CLI
+    def self.run(argv, out: $stdout, err: $stderr)
+      options = {junit: [], coverage: nil, bench: nil, history: nil, out: "card.png", summary: "summary.md", base: nil, now: Time.now.utc.iso8601, title: nil, theme: :dark, branch: nil, commit: nil, run_url: nil, fail_on: nil}
+      OptionParser.new do |opts|
+        opts.banner = "Usage: nashira build [options]"
+        opts.on("--junit GLOB") { |v| options[:junit] << v }
+        opts.on("--coverage PATH") { |v| options[:coverage] = v }
+        opts.on("--bench PATH") { |v| options[:bench] = v }
+        opts.on("--history PATH") { |v| options[:history] = v }
+        opts.on("--base-coverage VALUE", Float) { |v| options[:base] = v }
+        opts.on("--now TIME") { |v| options[:now] = v }
+        opts.on("--out PATH") { |v| options[:out] = v }
+        opts.on("--summary PATH") { |v| options[:summary] = v }
+        opts.on("--title TITLE") { |v| options[:title] = v }
+        opts.on("--theme NAME") { |v| options[:theme] = v }
+        opts.on("--branch NAME") { |v| options[:branch] = v }
+        opts.on("--commit SHA") { |v| options[:commit] = v }
+        opts.on("--run-url URL") { |v| options[:run_url] = v }
+        opts.on("--fail-on NAME") { |v| options[:fail_on] = v }
+      end.parse!(argv.drop(argv.first == "build" ? 1 : 0))
+      tests_result = JUnit.parse(options[:junit])
+      coverage_result = CoverageParser.parse(options[:coverage], base: options[:base])
+      benchmarks_result = Benchmarks.parse(options[:bench])
+      tests = tests_result.value
+      coverage = coverage_result.value
+      benchmarks = benchmarks_result.value
+      warnings = tests_result.warnings + coverage_result.warnings + benchmarks_result.warnings
+      history = History.load(options[:history])
+      point = options[:history] && HistoryPoint.new(commit: options[:commit], coverage: coverage&.percent,
+        tests: tests&.total, at: options[:now])
+      report = Report.build(tests: tests, coverage: coverage, benchmarks: benchmarks,
+        history: point ? history + [point] : history,
+        repository: options[:title], branch: options[:branch], commit: options[:commit], run_url: options[:run_url], finished_at: options[:now])
+      FileUtils.mkdir_p(File.dirname(options[:out]))
+      FileUtils.mkdir_p(File.dirname(options[:summary]))
+      File.binwrite(options[:out], Renderer.new(theme: Nashira.theme(options[:theme])).render(report))
+      File.write(options[:summary], Summary.markdown(report, image: options[:out]))
+      History.append(options[:history], point) if point
+      warnings.each { |warning| err.puts "nashira: warning: #{warning}" }
+      (options[:fail_on] == "coverage-drop" && coverage&.delta.to_f.negative?) || (options[:fail_on] == "tests" && tests&.failed.to_i.positive?) ? 1 : 0
+    rescue OptionParser::ParseError, KeyError, Error => error
+      err.puts "nashira: #{error.message}"
+      1
+    end
+  end
+end

data/sig/nashira.rbs

@@ -0,0 +1,9 @@
+module Nashira
+  VERSION: String
+  def self.theme: (untyped value) -> untyped
+  class Error < StandardError
+  end
+  class CLI
+    def self.run: (Array[String] argv, ?out: IO, ?err: IO) -> Integer
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: nashira
+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: Parse test, coverage, and benchmark reports into deterministic PNG and
+  Markdown summaries.
+email:
+- t.yudai92@gmail.com
+executables:
+- nashira
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- action.yml
+- exe/nashira
+- lib/nashira.rb
+- lib/nashira/version.rb
+- sig/nashira.rbs
+homepage: https://github.com/noxdea/nashira
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  source_code_uri: https://github.com/noxdea/nashira
+  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: CI report cards for GitHub summaries and pull requests
+test_files: []