libpng 1.6.58.4-aarch64-linux-ohos

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2801781739404a274da76f14128b6193d1b404ad40811fba83e4547a345f85ee
+  data.tar.gz: 7a8d425c8ecb899cd59d56bd6575f6ab7b2cd70a3ffa4460b809d38eff631ae3
+SHA512:
+  metadata.gz: 7e7b6abe58eb8c8519e13e3327b3ddfae171d362e13092964fcd0484bcc084d34f2fc4ebabc418199d49a5ebed8d4365ba83e4e731e0d144efbad244e4387417
+  data.tar.gz: 1952b473d5278a63d67128acade0453682cc389bd5e7cc5f3f804550a3ed3055e81261be3be41cb7dbda78aa15f0d9f14eb2a42e4a1599f10eecef5bae830045

data/.github/workflows/build.yml

@@ -0,0 +1,211 @@
+name: build
+
+on:
+  push:
+    branches: [ main ]
+    paths-ignore:
+      - '*.adoc'
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: '${{ github.workflow }}-${{ github.job }}-${{ github.head_ref || github.ref_name }}'
+  cancel-in-progress: true
+
+jobs:
+  prepare:
+    uses: metanorma/ci/.github/workflows/prepare-rake.yml@main
+
+  test:
+    name: Test on Ruby ${{ matrix.ruby.version }} ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+
+    needs: prepare
+    if: needs.prepare.outputs.push-for-tag != 'true'
+
+    continue-on-error: ${{ matrix.ruby.experimental }}
+    strategy:
+      fail-fast: false
+      max-parallel: 5
+      matrix: ${{ fromJson(needs.prepare.outputs.matrix) }}
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - uses: ruby/setup-ruby@master
+      with:
+        bundler-cache: true
+        ruby-version: ${{ matrix.ruby.version }}
+        rubygems: ${{ matrix.ruby.rubygems }}
+
+    # libpng's CMake needs cmake >= 3.10 and a working zlib. Both are
+    # pre-installed on GitHub Actions runners; this is just a sanity check.
+    - name: Install build tools
+      if: startsWith(matrix.os, 'ubuntu')
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y cmake ninja-build zlib1g-dev
+
+    - name: Install build tools (macOS)
+      if: startsWith(matrix.os, 'macos')
+      run: |
+        brew install cmake ninja
+
+    - name: Install build tools (Windows)
+      if: startsWith(matrix.os, 'windows')
+      uses: step-security/msvc-dev-cmd@v1
+
+    - run: bundle exec rake
+
+  build:
+    name: build ${{ matrix.os }}, ${{ matrix.ruby-version }}, ${{ matrix.platform }}
+    runs-on: ${{ matrix.os }}
+    needs: prepare
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            platform: any
+            ruby-version: ${{ needs.prepare.outputs.default-ruby-version }}
+          - os: ubuntu-latest
+            platform: x86_64-linux
+            ruby-version: ${{ needs.prepare.outputs.default-ruby-version }}
+          - os: ubuntu-24.04-arm
+            platform: aarch64-linux
+            ruby-version: ${{ needs.prepare.outputs.default-ruby-version }}
+          - os: windows-latest
+            platform: x64-mingw32
+            ruby-version: ${{ needs.prepare.outputs.default-ruby-version }}
+          - os: windows-latest
+            platform: x64-mingw-ucrt
+            ruby-version: ${{ needs.prepare.outputs.default-ruby-version }}
+          - os: windows-11-arm
+            platform: aarch64-mingw-ucrt
+            ruby-version: '3.4'
+          - os: macos-15-intel
+            platform: x86_64-darwin
+            ruby-version: ${{ needs.prepare.outputs.default-ruby-version }}
+          - os: macos-latest
+            platform: arm64-darwin
+            ruby-version: ${{ needs.prepare.outputs.default-ruby-version }}
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Setup Ruby
+      uses: ruby/setup-ruby@master
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true
+
+    - name: Install build tools (Linux)
+      if: startsWith(matrix.os, 'ubuntu')
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y cmake ninja-build zlib1g-dev
+
+    - name: Install build tools (macOS)
+      if: startsWith(matrix.os, 'macos')
+      run: |
+        brew install cmake ninja
+
+    - name: Install build tools (Windows)
+      if: startsWith(matrix.os, 'windows')
+      uses: step-security/msvc-dev-cmd@v1
+      with:
+        arch: ${{ matrix.platform == 'aarch64-mingw-ucrt' && 'arm64' || 'x64' }}
+
+    - run: bundle exec rake gem:native:${{ matrix.platform }}
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: pkg-${{ matrix.platform }}
+        path: pkg/*.gem
+
+    - name: Install gem
+      run: gem install -b pkg/libpng-*.gem
+
+    - name: Test conversion
+      shell: bash
+      run: |
+        ruby -rlibpng -e 'png = Libpng.encode(2, 2, "\xff" * 16, pixel_format: "RGBA"); File.binwrite("test.png", png); puts Libpng.decode(png, pixel_format: "RGBA").inspect'
+
+  build_musl:
+    name: build ${{ matrix.platform }} (Alpine)
+    runs-on: ${{ matrix.os }}
+    needs: prepare
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            platform: x86_64-linux-musl
+          - os: ubuntu-24.04-arm
+            platform: aarch64-linux-musl
+          # OHOS (OpenHarmony / Huawei HarmonyOS PC) is musl-based arm64.
+          # Built inside the same Alpine container as aarch64-linux-musl;
+          # the resulting binary is byte-compatible. Only the gem's
+          # platform label differs so RubyGems on OHOS selects it.
+          - os: ubuntu-24.04-arm
+            platform: aarch64-linux-ohos
+
+    steps:
+    - uses: actions/checkout@v4
+
+    # Run the entire build inside an Alpine container via `docker run` rather
+    # than the workflow `container:` field. The latter only works on x64
+    # runners (Actions' JS runtime has no arm64-musl build), but arm64 Ubuntu
+    # runners can run arm64 Alpine images natively via Docker.
+    - name: Build in Alpine container
+      shell: bash
+      env:
+        PLATFORM: ${{ matrix.platform }}
+        RUBY_VERSION: ${{ needs.prepare.outputs.default-ruby-version }}
+      run: |
+        cat > /tmp/alpine-build.sh <<'BUILD_EOF'
+        #!/bin/sh
+        set -e
+        apk add --no-cache build-base cmake ninja git file zlib-dev
+        # The mounted /work volume is owned by the host runner user; git in
+        # the container (running as root) refuses to operate on it without
+        # this. Without it, `git ls-files` in the gemspec returns empty and
+        # the built gem is missing lib/libpng.rb.
+        git config --global --add safe.directory /work
+        bundle install --jobs 4
+        bundle exec rake "gem:native:${PLATFORM}"
+        case "${PLATFORM}" in
+          *-ohos)
+            # OHOS gem is labeled aarch64-linux-ohos so RubyGems on OHOS
+            # selects it, but Alpine Ruby reports *-linux-musl -- a
+            # platform mismatch. The .so inside is musl-compatible, so
+            # unpack the gem and load it via -Ilib directly to verify
+            # the binary works without going through RubyGems install.
+            mkdir -p /tmp/ohos-smoke
+            gem unpack pkg/libpng-*.gem --target /tmp/ohos-smoke
+            (cd /tmp/ohos-smoke/libpng-* && \
+              ruby -Ilib -e 'require "libpng"; png = Libpng.encode(2, 2, "\xff" * 16, pixel_format: "RGBA"); puts Libpng.decode(png, pixel_format: "RGBA").inspect')
+            ;;
+          *)
+            gem install -b pkg/libpng-*.gem
+            # Smoke test from /tmp so bundler's source-tree LOAD_PATH doesn't
+            # shadow the installed gem. Activate via `gem` so RubyGems resolves
+            # the platform-specific binary gem (Alpine Ruby's platform string
+            # is *-linux-musl, which must match the gem's platform suffix).
+            (cd /tmp && ruby -e 'gem "libpng"; require "libpng"; png = Libpng.encode(2, 2, "\xff" * 16, pixel_format: "RGBA"); File.binwrite("test.png", png); puts Libpng.decode(png, pixel_format: "RGBA").inspect')
+            ;;
+        esac
+        BUILD_EOF
+        chmod +x /tmp/alpine-build.sh
+        docker run --rm \
+          -v "$PWD:/work" \
+          -v /tmp/alpine-build.sh:/alpine-build.sh \
+          -w /work \
+          -e PLATFORM \
+          ruby:${RUBY_VERSION}-alpine \
+          /alpine-build.sh
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: pkg-${{ matrix.platform }}
+        path: pkg/*.gem

data/.github/workflows/release.yml

@@ -0,0 +1,299 @@
+name: release
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+    inputs:
+      bump-type:
+        description: 'What to bump before tagging'
+        type: choice
+        options:
+          - current
+          - iteration
+          - libpng
+        default: iteration
+      libpng-version:
+        description: 'New libpng version (required when bump-type=libpng, e.g. 1.6.49)'
+        type: string
+        required: false
+
+# contents: write is needed for workflow_dispatch to push the bump commit + tag.
+# id-token: write is required for RubyGems.org Trusted Publishing (OIDC).
+permissions:
+  contents: write
+  id-token: write
+
+jobs:
+  bump:
+    if: github.event_name == 'workflow_dispatch'
+    runs-on: ubuntu-latest
+    outputs:
+      sha: ${{ steps.sha.outputs.sha }}
+      new-version: ${{ steps.bump.outputs.new-version }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: ruby/setup-ruby@master
+        with:
+          ruby-version: '3.3'
+
+      - name: Bump version.rb
+        id: bump
+        shell: bash
+        env:
+          BUMP_TYPE: ${{ inputs.bump-type }}
+          LIBPNG_VERSION_INPUT: ${{ inputs.libpng-version }}
+        run: |
+          set -euo pipefail
+
+          if [[ "$BUMP_TYPE" == "current" ]]; then
+            NEW_VERSION=$(ruby -Ilib -rlibpng/version -e 'puts Libpng::VERSION')
+            echo "new-version=${NEW_VERSION}" >> "$GITHUB_OUTPUT"
+            echo "sha=${{ github.sha }}" >> "$GITHUB_OUTPUT"
+            echo "Releasing current VERSION (${NEW_VERSION}) -- no bump."
+            exit 0
+          fi
+
+          ruby <<'RUBY'
+            bump_type = ENV.fetch("BUMP_TYPE")
+            path = "lib/libpng/version.rb"
+            content = File.read(path)
+
+            case bump_type
+            when "iteration"
+              m = %r{LIBPNG_RUBY_ITERATION = (\d+)}.match(content) or
+                raise "Could not find LIBPNG_RUBY_ITERATION in #{path}"
+              content.sub!(%r{LIBPNG_RUBY_ITERATION = \d+},
+                           "LIBPNG_RUBY_ITERATION = #{m[1].to_i + 1}") or
+                raise "Failed to substitute iteration"
+            when "libpng"
+              new_v = ENV.fetch("LIBPNG_VERSION_INPUT", "")
+              raise "libpng-version input is required when bump-type=libpng" if new_v.empty?
+              raise "Invalid version format: #{new_v} (expected X.Y.Z)" unless new_v.match?(/\A\d+\.\d+\.\d+\z/)
+              content.sub!(%r{LIBPNG_VERSION = "[^"]+"},
+                           "LIBPNG_VERSION = \"#{new_v}\"") or
+                raise "Failed to substitute libpng version"
+              content.sub!(%r{LIBPNG_RUBY_ITERATION = \d+},
+                           "LIBPNG_RUBY_ITERATION = 0") or
+                raise "Failed to reset iteration"
+            else
+              raise "Unknown bump-type: #{bump_type}"
+            end
+
+            File.write(path, content)
+            load File.expand_path(path)
+            File.open(ENV.fetch("GITHUB_OUTPUT"), "a") do |f|
+              f.puts "new-version=#{Libpng::VERSION}"
+            end
+            warn "Bumped to #{Libpng::VERSION}"
+          RUBY
+
+          NEW_VERSION=$(ruby -Ilib -rlibpng/version -e 'puts Libpng::VERSION')
+          echo "new-version=${NEW_VERSION}" >> "$GITHUB_OUTPUT"
+
+          git config user.name  "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git add lib/libpng/version.rb
+          git commit -m "Release v${NEW_VERSION}"
+          echo "sha=$(git rev-parse HEAD)" >> "$GITHUB_OUTPUT"
+
+      - name: Show what's being released
+        run: |
+          echo "Releasing version: ${{ steps.bump.outputs.new-version }}"
+          git --no-pager log --oneline -1 "${{ steps.bump.outputs.sha }}"
+
+      - name: Push bump commit + tag
+        env:
+          NEW_VERSION: ${{ steps.bump.outputs.new-version }}
+          SHA: ${{ steps.bump.outputs.sha }}
+        run: |
+          if [[ -n "${SHA}" && "${SHA}" != "${{ github.sha }}" ]]; then
+            git push origin "HEAD:${{ github.event.repository.default_branch }}"
+          fi
+          git tag "v${NEW_VERSION}" "${SHA}"
+          git push origin "v${NEW_VERSION}"
+
+  build:
+    needs: bump
+    if: always() && !cancelled() && !failure() && (needs.bump.result == 'success' || needs.bump.result == 'skipped')
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            platform: any
+            ruby-version: '3.3'
+          - os: ubuntu-latest
+            platform: x86_64-linux
+            ruby-version: '3.3'
+          - os: ubuntu-24.04-arm
+            platform: aarch64-linux
+            ruby-version: '3.3'
+          - os: windows-latest
+            platform: x64-mingw32
+            ruby-version: '3.3'
+          - os: windows-latest
+            platform: x64-mingw-ucrt
+            ruby-version: '3.3'
+          - os: windows-11-arm
+            platform: aarch64-mingw-ucrt
+            ruby-version: '3.4'
+          - os: macos-15-intel
+            platform: x86_64-darwin
+            ruby-version: '3.3'
+          - os: macos-latest
+            platform: arm64-darwin
+            ruby-version: '3.3'
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.bump.outputs.sha || github.ref }}
+
+      - uses: ruby/setup-ruby@master
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+          bundler-cache: true
+
+      - name: Install build tools (Linux)
+        if: startsWith(matrix.os, 'ubuntu')
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y cmake ninja-build zlib1g-dev
+
+      - name: Install build tools (macOS)
+        if: startsWith(matrix.os, 'macos')
+        run: |
+          brew install cmake ninja
+
+      - name: Install build tools (Windows)
+        if: startsWith(matrix.os, 'windows')
+        uses: step-security/msvc-dev-cmd@v1
+        with:
+          arch: ${{ matrix.platform == 'aarch64-mingw-ucrt' && 'arm64' || 'x64' }}
+
+      - run: bundle exec rake gem:native:${{ matrix.platform }}
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: pkg-${{ matrix.platform }}
+          path: pkg/*.gem
+
+      - name: Install gem
+        run: gem install -b pkg/libpng-*.gem
+
+      - name: Test conversion
+        shell: bash
+        run: |
+          ruby -rlibpng -e 'png = Libpng.encode(2, 2, "\xff" * 16, pixel_format: "RGBA"); puts Libpng.decode(png, pixel_format: "RGBA").inspect'
+
+  build_musl:
+    needs: bump
+    if: always() && !cancelled() && !failure() && (needs.bump.result == 'success' || needs.bump.result == 'skipped')
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            platform: x86_64-linux-musl
+          - os: ubuntu-24.04-arm
+            platform: aarch64-linux-musl
+          # OHOS: same Alpine-built musl arm64 binary as aarch64-linux-musl,
+          # packaged under a distinct platform label.
+          - os: ubuntu-24.04-arm
+            platform: aarch64-linux-ohos
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.bump.outputs.sha || github.ref }}
+
+      - name: Build in Alpine container
+        shell: bash
+        env:
+          PLATFORM: ${{ matrix.platform }}
+        run: |
+          cat > /tmp/alpine-build.sh <<'BUILD_EOF'
+          #!/bin/sh
+          set -e
+          apk add --no-cache build-base cmake ninja git file zlib-dev
+          git config --global --add safe.directory /work
+          bundle install --jobs 4
+          bundle exec rake "gem:native:${PLATFORM}"
+          case "${PLATFORM}" in
+            *-ohos)
+              # OHOS gem is labeled aarch64-linux-ohos so RubyGems on OHOS
+              # selects it, but Alpine Ruby reports *-linux-musl. The .so
+              # inside is musl-compatible -- unpack and load via -Ilib to
+              # verify the binary without going through RubyGems install.
+              mkdir -p /tmp/ohos-smoke
+              gem unpack pkg/libpng-*.gem --target /tmp/ohos-smoke
+              (cd /tmp/ohos-smoke/libpng-* && \
+                ruby -Ilib -e 'require "libpng"; png = Libpng.encode(2, 2, "\xff" * 16, pixel_format: "RGBA"); puts Libpng.decode(png, pixel_format: "RGBA").inspect')
+              ;;
+            *)
+              gem install -b pkg/libpng-*.gem
+              (cd /tmp && ruby -e 'gem "libpng"; require "libpng"; png = Libpng.encode(2, 2, "\xff" * 16, pixel_format: "RGBA"); puts Libpng.decode(png, pixel_format: "RGBA").inspect')
+              ;;
+          esac
+          BUILD_EOF
+          chmod +x /tmp/alpine-build.sh
+          docker run --rm \
+            -v "$PWD:/work" \
+            -v /tmp/alpine-build.sh:/alpine-build.sh \
+            -w /work \
+            -e PLATFORM \
+            ruby:3.3-alpine \
+            /alpine-build.sh
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: pkg-${{ matrix.platform }}
+          path: pkg/*.gem
+
+  publish:
+    needs: [ bump, build, build_musl ]
+    if: always() && !cancelled() && !failure()
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.bump.outputs.sha || github.ref }}
+
+      - uses: ruby/setup-ruby@master
+        with:
+          ruby-version: '3.3'
+          bundler-cache: true
+
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: pkg-*
+          path: pkg
+          merge-multiple: true
+
+      - name: Configure RubyGems credentials (Trusted Publishing / OIDC)
+        uses: rubygems/configure-rubygems-credentials@main
+
+      - name: Publish to rubygems.org
+        shell: bash
+        run: |
+          set +e
+          for gem in pkg/*.gem; do
+            output=$(gem push -V "$gem" 2>&1)
+            rc=$?
+            if [ $rc -eq 0 ]; then
+              echo "$output"
+              continue
+            fi
+            # RubyGems rejects re-pushing the same version with 422, even for
+            # identical content. Tolerate that so we can publish newly-added
+            # platform variants at a version whose source gem already exists.
+            if echo "$output" | grep -qE "already (exists|pushed)|Conflict|Repushing"; then
+              echo "Skip $(basename "$gem") (already published)"
+              continue
+            fi
+            echo "$output" >&2
+            exit 1
+          done

data/.gitignore

@@ -0,0 +1,19 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/ports/
+/lib/libpng/*.so
+/lib/libpng/*.so.*
+/lib/libpng/*.dylib
+/lib/libpng/*.dll
+/Makefile
+/lib/libpng/Makefile
+/.idea/
+/.vscode/
+*.gem

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,39 @@
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 2.7
+  SuggestExtensions: false
+
+Gemspec/DevelopmentDependencies:
+  Enabled: false
+
+# The wrapper is by nature a single file with FFI declarations + several
+# methods that walk libpng's chunked API; splitting would obscure the
+# 1-to-1 mapping with the C API.
+Metrics/AbcSize:
+  Max: 70
+Metrics/ClassLength:
+  Max: 200
+Metrics/CyclomaticComplexity:
+  Max: 20
+Metrics/MethodLength:
+  Max: 70
+Metrics/ModuleLength:
+  Max: 350
+Metrics/PerceivedComplexity:
+  Max: 20
+Metrics/ParameterLists:
+  Max: 9
+
+Metrics/BlockLength:
+  Exclude:
+    - spec/**/*.rb
+    - Rakefile
+    - libpng.gemspec
+
+Style/SpecialGlobalVars:
+  Exclude:
+    - ext/extconf.rb
+Style/FrozenStringLiteralComment:
+  Exclude:
+    - ext/extconf.rb
+    - lib/libpng/recipe.rb