vastlint 0.4.14

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a98849d1f2a31ab7e93a306f409fc6447f122f1b45594d19c339ae3cb40270bc
+  data.tar.gz: 3261d865cfdc12e1f3cd776b4a8a68f97f55dcf2e1d70c27b5ddcb31e37047da
+SHA512:
+  metadata.gz: 5c6cf05d772b448bd91d1351d9f0ab91a59c1ac582b843d8d7e593956c0f86688309742f4c0c8a24438f7f7160280dc0a5538139aaa21ca1f956f9ffbdcf3dca
+  data.tar.gz: 8336a6dd7af6762f49da095fb5ba41c2696bae88979e33a532ce85d34e75ae376e5cb25d4f255e12c176f847a657120ad28cb98f58c0d4c9f6f1eb0ea336740a

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,194 @@
+# vastlint-ruby
+
+High-performance, in-process VAST XML validation for Ruby backends.
+
+This gem wraps the existing `vastlint-ffi` C API, which is backed by the same Rust core used by the CLI, Go binding, Erlang NIF, MCP server, and web validator. The intended use case is a DSP, SSP, ad server, or trafficking backend that needs to validate VAST XML and return structured linting results to a React or other web frontend.
+
+## Why this shape
+
+- No subprocess management in your Ruby app
+- No network hop to an external validation service
+- Stable JSON-compatible result shape for backend-to-frontend responses
+- Same rule coverage and behavior as the rest of the vastlint ecosystem
+
+## Install
+
+RubyGems.org is not currently usable for new gem registrations, so the supported distribution target for this package is GitHub Packages.
+
+Authenticate Bundler against GitHub Packages:
+
+```sh
+bundle config https://rubygems.pkg.github.com/aleksUIX USERNAME:TOKEN
+```
+
+Then add the package source in your application:
+
+```ruby
+source "https://rubygems.org"
+
+source "https://rubygems.pkg.github.com/aleksUIX" do
+  gem "vastlint"
+end
+```
+
+Then install it:
+
+```sh
+bundle install
+```
+
+The gem expects a platform-matched `libvastlint` shared library.
+
+For development in this monorepo, it will automatically try the sibling `vastlint/target/debug` and `vastlint/target/release` outputs.
+
+For a distributable gem release, vendor the release libraries into `lib/vastlint/native/*` with:
+
+```sh
+./scripts/fetch-libs.sh v0.4.14
+```
+
+You can also point the gem at an explicit shared library path:
+
+```sh
+export VASTLINT_LIB_PATH=/absolute/path/to/libvastlint.dylib
+```
+
+If you need anonymous public installs without GitHub auth, GitHub Packages is the wrong host. In that case, use a different gem server such as Gemfury, Cloudsmith, or a private Gemstash instance.
+
+## Usage
+
+```ruby
+require "vastlint"
+
+result = Vastlint.validate(vast_xml)
+
+if result.valid?
+  puts "clean tag"
+else
+  puts result.summary.errors
+  puts result.issues.first.message
+end
+
+puts result.to_json
+```
+
+### Rails controller example
+
+```ruby
+class VastValidationsController < ApplicationController
+  def create
+    result = Vastlint.validate(
+      params.require(:xml),
+      wrapper_depth: params[:wrapper_depth].to_i,
+      max_wrapper_depth: params[:max_wrapper_depth].presence&.to_i || 5,
+      rule_overrides: params[:rule_overrides]
+    )
+
+    render json: result.as_json
+  rescue ArgumentError, Vastlint::Error => error
+    render json: { error: error.message }, status: :unprocessable_entity
+  end
+end
+```
+
+The response shape is stable and frontend-friendly:
+
+```json
+{
+  "version": "4.2",
+  "issues": [
+    {
+      "id": "VAST-2.0-inline-impression",
+      "severity": "error",
+      "message": "<InLine> must contain at least one <Impression>",
+      "path": "/VAST/Ad[0]/InLine",
+      "spec_ref": "IAB VAST 2.0 §2.2.1",
+      "line": 4,
+      "col": 3
+    }
+  ],
+  "summary": {
+    "errors": 1,
+    "warnings": 0,
+    "infos": 0,
+    "valid": false
+  }
+}
+```
+
+## API
+
+```ruby
+Vastlint.validate(xml, wrapper_depth: 0, max_wrapper_depth: 5, rule_overrides: nil)
+Vastlint.version
+```
+
+`rule_overrides` accepts a hash of rule IDs to levels:
+
+```ruby
+result = Vastlint.validate(
+  vast_xml,
+  rule_overrides: {
+    "VAST-2.0-mediafile-https" => "error",
+    "VAST-4.1-mezzanine-recommended" => "off"
+  }
+)
+```
+
+## Native library layout
+
+Vendored release libraries belong at:
+
+- `lib/vastlint/native/darwin_arm64/libvastlint.dylib`
+- `lib/vastlint/native/darwin_amd64/libvastlint.dylib`
+- `lib/vastlint/native/linux_arm64/libvastlint.so`
+- `lib/vastlint/native/linux_amd64/libvastlint.so`
+
+The shared libraries come from the `vastlint-ffi-*` tarballs attached to each `vastlint` GitHub Release.
+
+## Publish
+
+### From GitHub Actions
+
+If this gem lives in its own GitHub repository, you do not need to add a separate publish token just to push to GitHub Packages. GitHub injects `GITHUB_TOKEN` automatically, and the workflow only needs `packages: write` permission.
+
+The included workflow at `.github/workflows/publish-github-packages.yml`:
+
+- derives the gem version from the tag or `lib/vastlint/version.rb`
+- downloads the matching `vastlint-ffi-*` shared libraries from the main `aleksUIX/vastlint` release
+- runs the Ruby tests
+- builds the gem
+- pushes it to `rubygems.pkg.github.com/<owner>` using `GITHUB_TOKEN`
+
+That means the normal release path can be fully automated from CI.
+
+### From a local machine
+
+Publish to GitHub Packages with a classic personal access token that has `write:packages`.
+
+```sh
+export GITHUB_PACKAGES_OWNER=aleksUIX
+export GITHUB_PACKAGES_TOKEN=YOUR_CLASSIC_PAT
+./scripts/publish-github-packages.sh
+```
+
+The script:
+
+- builds `vastlint-<version>.gem` if needed
+- writes a temporary `~/.gem/credentials` with `:github: Bearer TOKEN`
+- pushes to `https://rubygems.pkg.github.com/$GITHUB_PACKAGES_OWNER`
+
+The publish script also accepts `GITHUB_TOKEN`, so the exact same script works inside GitHub Actions without adding a separate secret.
+
+Install from the registry with:
+
+```sh
+gem install vastlint \
+  --clear-sources \
+  --source https://USERNAME:TOKEN@rubygems.pkg.github.com/aleksUIX/
+```
+
+## License
+
+Apache 2.0.
+

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |task|
+  task.libs << "lib"
+  task.pattern = "test/**/*_test.rb"
+end
+
+task default: :test

data/lib/vastlint/error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Vastlint
+  class Error < StandardError; end
+  class LibraryError < Error; end
+end

data/lib/vastlint/issue.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Vastlint
+  class Issue
+    attr_reader :id, :severity, :message, :path, :spec_ref, :line, :col
+
+    def initialize(id:, severity:, message:, path:, spec_ref:, line:, col:)
+      @id = id
+      @severity = severity
+      @message = message
+      @path = path
+      @spec_ref = spec_ref
+      @line = line
+      @col = col
+    end
+
+    def as_json(*)
+      {
+        id: id,
+        severity: severity,
+        message: message,
+        path: path,
+        spec_ref: spec_ref,
+        line: line,
+        col: col
+      }
+    end
+
+    def to_h
+      as_json
+    end
+
+    def to_json(*args)
+      JSON.generate(as_json, *args)
+    end
+  end
+end

data/lib/vastlint/library.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "fiddle"
+require "fiddle/import"
+require "json"
+require "rbconfig"
+require "singleton"
+
+module Vastlint
+  class Library
+    include Singleton
+
+    def validate(xml, wrapper_depth:, max_wrapper_depth:, rule_overrides:)
+      raw_result = if default_call?(wrapper_depth, max_wrapper_depth, rule_overrides)
+        api.vastlint_validate(xml, xml.bytesize)
+      else
+        api.vastlint_validate_with_options(
+          xml,
+          xml.bytesize,
+          wrapper_depth,
+          max_wrapper_depth,
+          serialize_rule_overrides(rule_overrides)
+        )
+      end
+
+      raise LibraryError, "vastlint returned NULL" if null_pointer?(raw_result)
+
+      begin
+        json_payload = read_c_string(api.vastlint_result_json(raw_result))
+        raise LibraryError, "vastlint_result_json returned NULL" if json_payload.nil? || json_payload.empty?
+
+        json_payload
+      ensure
+        api.vastlint_result_free(raw_result) unless null_pointer?(raw_result)
+      end
+    end
+
+    def version
+      read_c_string(api.vastlint_version()) || raise(LibraryError, "vastlint_version returned NULL")
+    end
+
+    def path
+      self.class.resolve_path
+    end
+
+    class << self
+      def resolve_path
+        candidates = [ENV["VASTLINT_LIB_PATH"], vendored_path, *development_paths].compact
+        match = candidates.find { |candidate| File.file?(candidate) }
+        return match if match
+
+        raise LibraryError, <<~MESSAGE.strip
+          unable to find libvastlint for #{platform_label}
+          looked in:
+          #{candidates.map { |candidate| "  - #{candidate}" }.join("\n")}
+          set VASTLINT_LIB_PATH or vendor a release library under lib/vastlint/native
+        MESSAGE
+      end
+
+      private
+
+      def vendored_path
+        File.join(repo_root, "lib", "vastlint", "native", platform_directory, library_filename)
+      end
+
+      def development_paths
+        sibling_vastlint_root = File.expand_path("../vastlint", repo_root)
+        extension = shared_library_extension
+
+        [
+          File.join(sibling_vastlint_root, "target", "debug", "libvastlint_ffi.#{extension}"),
+          File.join(sibling_vastlint_root, "target", "release", "libvastlint_ffi.#{extension}")
+        ]
+      end
+
+      def repo_root
+        File.expand_path("../..", __dir__)
+      end
+
+      def library_filename
+        "libvastlint.#{shared_library_extension}"
+      end
+
+      def shared_library_extension
+        macos? ? "dylib" : "so"
+      end
+
+      def platform_directory
+        cpu = RbConfig::CONFIG.fetch("host_cpu")
+
+        if macos?
+          return "darwin_arm64" if cpu.match?(/arm64|aarch64/)
+          return "darwin_amd64" if cpu.match?(/x86_64|amd64/)
+        elsif linux?
+          return "linux_arm64" if cpu.match?(/arm64|aarch64/)
+          return "linux_amd64" if cpu.match?(/x86_64|amd64/)
+        end
+
+        raise LibraryError, "unsupported platform #{platform_label}"
+      end
+
+      def platform_label
+        "#{RbConfig::CONFIG.fetch("host_os")}/#{RbConfig::CONFIG.fetch("host_cpu")}"
+      end
+
+      def macos?
+        RbConfig::CONFIG.fetch("host_os").include?("darwin")
+      end
+
+      def linux?
+        RbConfig::CONFIG.fetch("host_os").include?("linux")
+      end
+    end
+
+    private
+
+    def api
+      @api ||= begin
+        library_path = self.class.resolve_path
+
+        Module.new.tap do |mod|
+          mod.extend(Fiddle::Importer)
+          mod.dlload(library_path)
+          mod.extern "void* vastlint_validate(const char*, size_t)"
+          mod.extern "void* vastlint_validate_with_options(const char*, size_t, unsigned int, unsigned int, const char*)"
+          mod.extern "char* vastlint_result_json(void*)"
+          mod.extern "void vastlint_result_free(void*)"
+          mod.extern "char* vastlint_version()"
+        end
+      rescue Fiddle::DLError => error
+        raise LibraryError, "failed to load #{library_path}: #{error.message}"
+      end
+    end
+
+    def default_call?(wrapper_depth, max_wrapper_depth, rule_overrides)
+      wrapper_depth.zero? && max_wrapper_depth == 5 && (rule_overrides.nil? || rule_overrides.empty?)
+    end
+
+    def serialize_rule_overrides(rule_overrides)
+      return nil if rule_overrides.nil? || rule_overrides.empty?
+
+      JSON.generate(rule_overrides)
+    end
+
+    def null_pointer?(pointer)
+      pointer.nil? || pointer.to_i.zero?
+    end
+
+    def read_c_string(value)
+      case value
+      when nil
+        nil
+      when String
+        value
+      else
+        Fiddle::Pointer.new(value.to_i).to_s
+      end
+    end
+  end
+end

data/lib/vastlint/native/README.md

@@ -0,0 +1,10 @@
+Place release shared libraries here before publishing the gem.
+
+Expected layout:
+
+- darwin_arm64/libvastlint.dylib
+- darwin_amd64/libvastlint.dylib
+- linux_arm64/libvastlint.so
+- linux_amd64/libvastlint.so
+
+Use ../../scripts/fetch-libs.sh to download the platform tarballs from a tagged vastlint GitHub Release and copy the shared libraries into this directory.

data/lib/vastlint/result.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Vastlint
+  class Result
+    attr_reader :version, :issues, :summary
+
+    def self.from_json(json_payload)
+      parsed = JSON.parse(json_payload)
+
+      new(
+        version: parsed["version"],
+        issues: Array(parsed["issues"]).map do |issue|
+          Issue.new(
+            id: issue["id"],
+            severity: issue["severity"],
+            message: issue["message"],
+            path: issue["path"],
+            spec_ref: issue["spec_ref"],
+            line: issue["line"],
+            col: issue["col"]
+          )
+        end,
+        summary: Summary.new(
+          errors: parsed.fetch("summary").fetch("errors"),
+          warnings: parsed.fetch("summary").fetch("warnings"),
+          infos: parsed.fetch("summary").fetch("infos"),
+          valid: parsed.fetch("summary").fetch("valid")
+        )
+      )
+    rescue JSON::ParserError => error
+      raise LibraryError, "failed to parse vastlint result JSON: #{error.message}"
+    end
+
+    def initialize(version:, issues:, summary:)
+      @version = version
+      @issues = issues
+      @summary = summary
+    end
+
+    def valid?
+      summary.valid?
+    end
+
+    def as_json(*)
+      {
+        version: version,
+        issues: issues.map(&:as_json),
+        summary: summary.as_json
+      }
+    end
+
+    def to_h
+      as_json
+    end
+
+    def to_json(*args)
+      JSON.generate(as_json, *args)
+    end
+  end
+end

data/lib/vastlint/summary.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Vastlint
+  class Summary
+    attr_reader :errors, :warnings, :infos
+
+    def initialize(errors:, warnings:, infos:, valid:)
+      @errors = errors
+      @warnings = warnings
+      @infos = infos
+      @valid = valid
+    end
+
+    def valid?
+      @valid
+    end
+
+    def as_json(*)
+      {
+        errors: errors,
+        warnings: warnings,
+        infos: infos,
+        valid: valid?
+      }
+    end
+
+    def to_h
+      as_json
+    end
+
+    def to_json(*args)
+      JSON.generate(as_json, *args)
+    end
+  end
+end

data/lib/vastlint/version.rb

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

data/lib/vastlint.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "vastlint/version"
+require_relative "vastlint/error"
+require_relative "vastlint/library"
+require_relative "vastlint/issue"
+require_relative "vastlint/summary"
+require_relative "vastlint/result"
+
+module Vastlint
+  class << self
+    def validate(xml, wrapper_depth: 0, max_wrapper_depth: 5, rule_overrides: nil)
+      normalized_xml = normalize_xml(xml)
+      validate_options!(wrapper_depth, max_wrapper_depth, rule_overrides)
+
+      Result.from_json(
+        Library.instance.validate(
+          normalized_xml,
+          wrapper_depth: wrapper_depth,
+          max_wrapper_depth: max_wrapper_depth,
+          rule_overrides: rule_overrides
+        )
+      )
+    end
+
+    def version
+      Library.instance.version
+    end
+
+    private
+
+    def normalize_xml(xml)
+      raise ArgumentError, "xml must be a String" unless xml.is_a?(String)
+      raise ArgumentError, "xml must not be empty" if xml.empty?
+
+      xml
+    end
+
+    def validate_options!(wrapper_depth, max_wrapper_depth, rule_overrides)
+      unless wrapper_depth.is_a?(Integer) && wrapper_depth >= 0
+        raise ArgumentError, "wrapper_depth must be an Integer >= 0"
+      end
+
+      unless max_wrapper_depth.is_a?(Integer) && max_wrapper_depth >= 0
+        raise ArgumentError, "max_wrapper_depth must be an Integer >= 0"
+      end
+
+      return if rule_overrides.nil? || rule_overrides.is_a?(Hash)
+
+      raise ArgumentError, "rule_overrides must be a Hash or nil"
+    end
+  end
+end

data/scripts/fetch-libs.sh

@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+REPO="aleksUIX/vastlint"
+RELEASE_TAG="${1:-}"
+
+if [[ -z "$RELEASE_TAG" ]]; then
+  echo "Usage: $0 <release-tag>  (e.g. v0.4.14)" >&2
+  exit 1
+fi
+
+BASE_URL="https://github.com/${REPO}/releases/download/${RELEASE_TAG}"
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
+TMPDIR="$(mktemp -d)"
+trap 'rm -rf "$TMPDIR"' EXIT
+
+while IFS='|' read -r TARBALL PLATFORM_DIR LIB_NAME; do
+  [[ -n "$TARBALL" ]] || continue
+
+  URL="${BASE_URL}/${TARBALL}"
+  DEST_DIR="${REPO_ROOT}/lib/vastlint/native/${PLATFORM_DIR}"
+  UNPACK_DIR="${TMPDIR}/${PLATFORM_DIR}"
+
+  echo "→ Downloading ${TARBALL}"
+  mkdir -p "$UNPACK_DIR" "$DEST_DIR"
+  curl -fsSL "$URL" -o "${TMPDIR}/${TARBALL}"
+  tar xzf "${TMPDIR}/${TARBALL}" -C "$UNPACK_DIR"
+
+  cp "${UNPACK_DIR}/${LIB_NAME}" "${DEST_DIR}/${LIB_NAME}"
+  chmod 755 "${DEST_DIR}/${LIB_NAME}"
+  echo "  ✓ ${DEST_DIR}/${LIB_NAME}"
+done <<'PLATFORMS'
+vastlint-ffi-macos-aarch64.tar.gz|darwin_arm64|libvastlint.dylib
+vastlint-ffi-macos-x86_64.tar.gz|darwin_amd64|libvastlint.dylib
+vastlint-ffi-linux-aarch64.tar.gz|linux_arm64|libvastlint.so
+vastlint-ffi-linux-x86_64.tar.gz|linux_amd64|libvastlint.so
+PLATFORMS
+
+echo
+echo "Done. Vendored shared libraries updated to ${RELEASE_TAG}."

data/scripts/publish-github-packages.sh

@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+OWNER="${GITHUB_PACKAGES_OWNER:-${GITHUB_REPOSITORY_OWNER:-aleksUIX}}"
+TOKEN="${GITHUB_PACKAGES_TOKEN:-${GITHUB_TOKEN:-}}"
+
+if [[ -z "$TOKEN" ]]; then
+  echo "GITHUB_PACKAGES_TOKEN or GITHUB_TOKEN is required" >&2
+  echo "Use GITHUB_TOKEN in GitHub Actions, or a classic GitHub personal access token with write:packages locally" >&2
+  exit 1
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
+
+cd "$REPO_ROOT"
+
+VERSION="$(ruby -Ilib -e 'require "vastlint/version"; print Vastlint::VERSION')"
+GEM_FILE="vastlint-${VERSION}.gem"
+
+if [[ ! -f "$GEM_FILE" ]]; then
+  gem build vastlint.gemspec
+fi
+
+TMP_HOME="$(mktemp -d)"
+trap 'rm -rf "$TMP_HOME"' EXIT
+
+mkdir -p "$TMP_HOME/.gem"
+chmod 700 "$TMP_HOME/.gem"
+
+cat > "$TMP_HOME/.gem/credentials" <<EOF
+---
+:github: Bearer ${TOKEN}
+EOF
+
+chmod 600 "$TMP_HOME/.gem/credentials"
+
+HOME="$TMP_HOME" gem push \
+  --key github \
+  --host "https://rubygems.pkg.github.com/${OWNER}" \
+  "$GEM_FILE"

data/scripts/publish-rubygems.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+API_KEY="${RUBYGEMS_API_KEY:-}"
+
+if [[ -z "$API_KEY" ]]; then
+  echo "RUBYGEMS_API_KEY is required (an API key from https://rubygems.org/profile/api_keys with Push rights)" >&2
+  exit 1
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
+
+cd "$REPO_ROOT"
+
+VERSION="$(ruby -Ilib -e 'require "vastlint/version"; print Vastlint::VERSION')"
+GEM_FILE="vastlint-${VERSION}.gem"
+
+if [[ ! -f "$GEM_FILE" ]]; then
+  gem build vastlint.gemspec
+fi
+
+TMP_HOME="$(mktemp -d)"
+trap 'rm -rf "$TMP_HOME"' EXIT
+
+mkdir -p "$TMP_HOME/.gem"
+chmod 700 "$TMP_HOME/.gem"
+
+cat > "$TMP_HOME/.gem/credentials" <<EOF
+---
+:rubygems_api_key: ${API_KEY}
+EOF
+
+chmod 600 "$TMP_HOME/.gem/credentials"
+
+HOME="$TMP_HOME" gem push "$GEM_FILE"

data/test/fixtures/invalid.xml

@@ -0,0 +1,18 @@
+<VAST version="4.2">
+  <Ad>
+    <InLine>
+      <AdSystem>Broken DSP Creative</AdSystem>
+      <AdTitle>Invalid Ad</AdTitle>
+      <Creatives>
+        <Creative>
+          <Linear>
+            <Duration>30</Duration>
+            <MediaFiles>
+              <MediaFile delivery="progressive" type="video/mp4" width="640" height="360">http://example.com/video.mp4</MediaFile>
+            </MediaFiles>
+          </Linear>
+        </Creative>
+      </Creatives>
+    </InLine>
+  </Ad>
+</VAST>

data/test/fixtures/valid.xml

@@ -0,0 +1,19 @@
+<VAST version="2.0">
+  <Ad>
+    <InLine>
+      <AdSystem>Test</AdSystem>
+      <AdTitle>Test Ad</AdTitle>
+      <Impression><![CDATA[https://example.com/pixel]]></Impression>
+      <Creatives>
+        <Creative>
+          <Linear>
+            <Duration>00:00:30</Duration>
+            <MediaFiles>
+              <MediaFile delivery="progressive" type="video/mp4" width="640" height="360"><![CDATA[https://example.com/video.mp4]]></MediaFile>
+            </MediaFiles>
+          </Linear>
+        </Creative>
+      </Creatives>
+    </InLine>
+  </Ad>
+</VAST>

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require_relative "../lib/vastlint"

data/test/vastlint_test.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class VastlintTest < Minitest::Test
+  def test_version_returns_a_string
+    refute_empty Vastlint.version
+  end
+
+  def test_valid_fixture_returns_no_errors
+    result = Vastlint.validate(read_fixture("valid.xml"))
+
+    assert result.valid?
+    assert_equal 0, result.summary.errors
+    assert_equal true, result.summary.valid?
+    assert_equal "2.0", result.version
+  end
+
+  def test_invalid_fixture_returns_structured_issues
+    result = Vastlint.validate(read_fixture("invalid.xml"))
+
+    refute result.valid?
+    assert_operator result.summary.errors, :>, 0
+    assert_operator result.issues.length, :>, 0
+    assert_includes %w[error warning info], result.issues.first.severity
+    assert_kind_of Hash, result.as_json
+  end
+
+  private
+
+  def read_fixture(name)
+    File.read(File.expand_path("fixtures/#{name}", __dir__))
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: vastlint
+version: !ruby/object:Gem::Version
+  version: 0.4.14
+platform: ruby
+authors:
+- Alex Sekowski
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-07-03 00:00:00.000000000 Z
+dependencies: []
+description: Ruby bindings for the vastlint Rust core via the stable C FFI. Validate
+  VAST XML in a DSP backend and return structured results directly to a React frontend.
+email:
+- alex@vastlint.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- Rakefile
+- lib/vastlint.rb
+- lib/vastlint/error.rb
+- lib/vastlint/issue.rb
+- lib/vastlint/library.rb
+- lib/vastlint/native/README.md
+- lib/vastlint/native/darwin_amd64/libvastlint.dylib
+- lib/vastlint/native/darwin_arm64/libvastlint.dylib
+- lib/vastlint/native/linux_amd64/libvastlint.so
+- lib/vastlint/native/linux_arm64/libvastlint.so
+- lib/vastlint/result.rb
+- lib/vastlint/summary.rb
+- lib/vastlint/version.rb
+- scripts/fetch-libs.sh
+- scripts/publish-github-packages.sh
+- scripts/publish-rubygems.sh
+- test/fixtures/invalid.xml
+- test/fixtures/valid.xml
+- test/test_helper.rb
+- test/vastlint_test.rb
+homepage: https://vastlint.org
+licenses:
+- Apache-2.0
+metadata:
+  homepage_uri: https://vastlint.org
+  source_code_uri: https://github.com/aleksUIX/vastlint-ruby
+  changelog_uri: https://github.com/aleksUIX/vastlint-ruby/releases
+  documentation_uri: https://vastlint.org/docs/rules
+  github_repo: ssh://github.com/aleksUIX/vastlint-ruby
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: In-process Ruby bindings for vastlint VAST XML validation
+test_files: []