mac_ocr 0.1.0-universal-darwin

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1f8090958f7f18af8c41be1f49104218a321ce656d13c3903bfcdff596260dd2
+  data.tar.gz: e2fb9cede71b148295f49fd7e58d1530ee495f375521256a66ca3ba07acc602d
+SHA512:
+  metadata.gz: 8859ca4fd31d805ebb51947940c66bc010509a4b9412cdbe52d50a9a5088710f9d8ac83ef071cc379084ee2ea6f75ef6561f897e90de2e4067634ac259e08ef7
+  data.tar.gz: 140136c38f73e19a321ba546c43a55d20ada11eb4bcaeef9a2646b5f26d022a65af2683408c1e07783e64d4be7981a3daab30944a13a82e1cd31919cc4188d36

data/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-05-27
+
+### Added
+- `MacOcr::OCR#recognize` returns `[text, confidence, [x, y, w, h]]` tuples
+  using Apple's Vision `VNRecognizeTextRequest`.
+- Bundled Swift CLI helper (`bin/mac_ocr_helper`) shipped as a universal
+  arm64 + x86_64 binary targeting macOS 11+.
+- Constructor options: `recognition_level:` (`:accurate` | `:fast`) and
+  `language_preference:` (Array of BCP-47 language codes).
+- Structured exception hierarchy: `MacOcr::Error`, `InvalidArgumentError`,
+  `HelperExecutionError`, `HelperNotFoundError`.
+- Rake tasks: `helper:build`, `helper:clean`, `release:prepare`, `test`.
+- Minitest suite with a KR+EN fixture image.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Team Milestone
+
+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,126 @@
+# mac_ocr
+
+Ruby OCR on macOS via the Apple Vision framework.
+
+`mac_ocr` is a small Ruby gem that wraps a bundled Swift helper which calls
+[`VNRecognizeTextRequest`](https://developer.apple.com/documentation/vision/vnrecognizetextrequest).
+It returns recognized text, per-line confidence, and normalized bounding
+boxes — the same shape exposed by the Python package
+[`ocrmac`](https://github.com/straussmaximilian/ocrmac), so code written
+against ocrmac ports over with minimal changes.
+
+- macOS only (the gem targets `universal-darwin`, macOS 11+)
+- Ruby 3.0+
+- No runtime dependencies beyond the bundled helper
+
+## Installation
+
+From rubygems (once published):
+
+```ruby
+# Gemfile
+gem "mac_ocr"
+```
+
+Directly from GitHub:
+
+```ruby
+# Gemfile
+gem "mac_ocr", git: "https://github.com/TeamMilestone/mac_ocr"
+```
+
+The gem ships with a pre-built universal (arm64 + x86_64) helper binary at
+`bin/mac_ocr_helper`, so no compilation is required at install time. If you
+clone the repo to develop, build it once with `rake helper:build` (needs
+Xcode Command Line Tools for `swiftc` and `lipo`).
+
+## Usage
+
+```ruby
+require "mac_ocr"
+
+ocr = MacOcr::OCR.new(
+  "image.png",
+  recognition_level: :accurate,            # :accurate (default) or :fast
+  language_preference: ["ko-KR", "en-US"]  # optional, nil for default
+)
+
+ocr.recognize
+# => [
+#      ["Hello, world!", 1.0, [0.041, 0.575, 0.400, 0.237]],
+#      ["안녕, 세상!",   1.0, [0.041, 0.171, 0.321, 0.282]]
+#    ]
+```
+
+Each row is `[text, confidence, [x, y, width, height]]`. Bounding box
+values are in Vision's normalized coordinate space: floats in `[0, 1]`,
+origin at the **bottom-left** of the image. No coordinate conversion is
+performed by the Ruby layer — this matches ocrmac's contract.
+
+### Porting from ocrmac
+
+The captcha-style helper from Python ports almost verbatim:
+
+```ruby
+def run_ocr(image_path)
+  items = MacOcr::OCR.new(
+    image_path,
+    recognition_level: :accurate,
+    language_preference: ["ko-KR", "en-US"]
+  ).recognize
+
+  # Sort top-to-bottom: larger Vision y is higher on the page.
+  items.sort_by { |_text, _conf, bbox| -bbox[1] }.map { |t, _c, _b| t }
+end
+```
+
+### Errors
+
+| Exception | Raised when |
+|---|---|
+| `MacOcr::InvalidArgumentError` | Bad constructor args, missing image file, unsupported language code |
+| `MacOcr::HelperExecutionError` | Vision request failed, helper produced unexpected output (carries `code`, `exit_status`, `stderr`) |
+| `MacOcr::HelperNotFoundError` | Bundled binary missing or not executable (e.g. forgot `rake helper:build` in a checkout) |
+
+All inherit from `MacOcr::Error`, so `rescue MacOcr::Error` catches them all.
+
+## Architecture
+
+`MacOcr::OCR` shells out to `bin/mac_ocr_helper`, a Swift CLI that takes
+an image path plus flags and emits a JSON document:
+
+```
+mac_ocr_helper <image_path> [--level accurate|fast]
+                            [--languages ko-KR,en-US]
+                            [--confidence 0.0]
+```
+
+```json
+{ "results": [ { "text": "...", "confidence": 0.5, "bbox": [x, y, w, h] } ] }
+```
+
+Process spawn overhead is a few milliseconds; Vision itself takes 50–200 ms
+per image, so the shell-out cost is negligible for typical workloads.
+
+See `docs/HANDOFF.md` for the design rationale (including why we chose a
+Swift CLI over a Ruby/FFI binding or an Objective-C bridge gem).
+
+## Development
+
+```bash
+bundle install
+rake helper:build   # rebuild bin/mac_ocr_helper
+rake test           # run minitest suite
+rake release:prepare  # clean+build+test+gem build
+```
+
+## Credits
+
+This gem is a Ruby port of the Vision-framework surface of the Python
+package [`ocrmac`](https://github.com/straussmaximilian/ocrmac) by
+Maximilian Strauss. The public API and coordinate conventions are
+deliberately compatible. Many thanks to the ocrmac maintainers.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

data/ext/mac_ocr_helper/build.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+#
+# Build the mac_ocr_helper as a universal (arm64 + x86_64) binary.
+#
+# Output: bin/mac_ocr_helper
+#
+# Requires: macOS with Xcode Command Line Tools (provides swiftc and lipo).
+#
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+SRC="$ROOT/ext/mac_ocr_helper/main.swift"
+BUILD_DIR="$ROOT/ext/mac_ocr_helper/build"
+OUT="$ROOT/bin/mac_ocr_helper"
+
+mkdir -p "$BUILD_DIR" "$(dirname "$OUT")"
+
+echo "==> building arm64 slice"
+xcrun swiftc -O \
+  -target arm64-apple-macos11 \
+  -o "$BUILD_DIR/mac_ocr_helper-arm64" \
+  "$SRC"
+
+echo "==> building x86_64 slice"
+xcrun swiftc -O \
+  -target x86_64-apple-macos11 \
+  -o "$BUILD_DIR/mac_ocr_helper-x86_64" \
+  "$SRC"
+
+echo "==> lipo'ing universal binary -> $OUT"
+xcrun lipo -create \
+  "$BUILD_DIR/mac_ocr_helper-arm64" \
+  "$BUILD_DIR/mac_ocr_helper-x86_64" \
+  -output "$OUT"
+
+xcrun lipo -info "$OUT"
+echo "==> done. size: $(du -h "$OUT" | cut -f1)"

data/ext/mac_ocr_helper/main.swift

@@ -0,0 +1,183 @@
+import Foundation
+import Vision
+import CoreGraphics
+import ImageIO
+
+// MARK: - Exit codes
+
+let exitSuccess: Int32 = 0
+let exitVisionError: Int32 = 1
+let exitUsageError: Int32 = 2
+
+// MARK: - JSON I/O
+
+func emitError(_ message: String, code: String, exitCode: Int32) -> Never {
+    let payload: [String: Any] = ["error": message, "code": code]
+    if let data = try? JSONSerialization.data(withJSONObject: payload, options: []),
+       let line = String(data: data, encoding: .utf8) {
+        FileHandle.standardError.write(Data(line.utf8))
+        FileHandle.standardError.write(Data("\n".utf8))
+    }
+    exit(exitCode)
+}
+
+func emitResults(_ observations: [VNRecognizedTextObservation], confidenceThreshold: Float) {
+    var rows: [[String: Any]] = []
+    rows.reserveCapacity(observations.count)
+    for obs in observations {
+        guard let top = obs.topCandidates(1).first else { continue }
+        let conf = top.confidence
+        if conf < confidenceThreshold { continue }
+        let box = obs.boundingBox
+        rows.append([
+            "text": top.string,
+            "confidence": Double(conf),
+            "bbox": [
+                Double(box.origin.x),
+                Double(box.origin.y),
+                Double(box.size.width),
+                Double(box.size.height)
+            ]
+        ])
+    }
+    let payload: [String: Any] = ["results": rows]
+    guard let data = try? JSONSerialization.data(withJSONObject: payload, options: []) else {
+        emitError("failed to serialize results", code: "SERIALIZE_ERROR", exitCode: exitVisionError)
+    }
+    FileHandle.standardOutput.write(data)
+    FileHandle.standardOutput.write(Data("\n".utf8))
+}
+
+// MARK: - Argument parsing
+
+struct CLIArgs {
+    var imagePath: String
+    var level: VNRequestTextRecognitionLevel = .accurate
+    var languages: [String]? = nil
+    var confidence: Float = 0.0
+}
+
+func parseArgs(_ argv: [String]) -> CLIArgs {
+    var imagePath: String? = nil
+    var level: VNRequestTextRecognitionLevel = .accurate
+    var languages: [String]? = nil
+    var confidence: Float = 0.0
+
+    var i = 1
+    while i < argv.count {
+        let arg = argv[i]
+        switch arg {
+        case "--level":
+            guard i + 1 < argv.count else {
+                emitError("--level requires a value (accurate|fast)", code: "BAD_ARGS", exitCode: exitUsageError)
+            }
+            let v = argv[i + 1]
+            switch v {
+            case "accurate": level = .accurate
+            case "fast":     level = .fast
+            default:
+                emitError("invalid --level: \(v) (expected accurate|fast)", code: "BAD_ARGS", exitCode: exitUsageError)
+            }
+            i += 2
+        case "--languages":
+            guard i + 1 < argv.count else {
+                emitError("--languages requires a comma-separated value", code: "BAD_ARGS", exitCode: exitUsageError)
+            }
+            let raw = argv[i + 1]
+            languages = raw.split(separator: ",").map { String($0).trimmingCharacters(in: .whitespaces) }.filter { !$0.isEmpty }
+            i += 2
+        case "--confidence":
+            guard i + 1 < argv.count, let v = Float(argv[i + 1]) else {
+                emitError("--confidence requires a float value", code: "BAD_ARGS", exitCode: exitUsageError)
+            }
+            confidence = v
+            i += 2
+        case "-h", "--help":
+            let usage = """
+            Usage: mac_ocr_helper <image_path> [--level accurate|fast] [--languages ko-KR,en-US] [--confidence 0.0]
+
+            Calls Apple's Vision VNRecognizeTextRequest on <image_path> and prints
+            a JSON document to stdout:
+
+              {"results": [{"text": "...", "confidence": 0.5, "bbox": [x, y, w, h]}]}
+
+            Bounding boxes are in Vision's normalized coordinate space (0..1,
+            origin at bottom-left).
+
+            Exit codes:
+              0 — success
+              1 — Vision request failed (error JSON on stderr)
+              2 — usage / file / argument error (error JSON on stderr)
+            """
+            FileHandle.standardOutput.write(Data(usage.utf8))
+            FileHandle.standardOutput.write(Data("\n".utf8))
+            exit(exitSuccess)
+        default:
+            if arg.hasPrefix("--") {
+                emitError("unknown option: \(arg)", code: "BAD_ARGS", exitCode: exitUsageError)
+            }
+            if imagePath != nil {
+                emitError("unexpected positional argument: \(arg)", code: "BAD_ARGS", exitCode: exitUsageError)
+            }
+            imagePath = arg
+            i += 1
+        }
+    }
+
+    guard let path = imagePath else {
+        emitError("missing required <image_path> argument", code: "BAD_ARGS", exitCode: exitUsageError)
+    }
+
+    return CLIArgs(imagePath: path, level: level, languages: languages, confidence: confidence)
+}
+
+// MARK: - Main
+
+let args = parseArgs(CommandLine.arguments)
+
+let fm = FileManager.default
+var isDir: ObjCBool = false
+guard fm.fileExists(atPath: args.imagePath, isDirectory: &isDir), !isDir.boolValue else {
+    emitError("image file not found: \(args.imagePath)", code: "FILE_NOT_FOUND", exitCode: exitUsageError)
+}
+
+let url = URL(fileURLWithPath: args.imagePath)
+
+// Build request
+let request = VNRecognizeTextRequest()
+request.recognitionLevel = args.level
+request.usesLanguageCorrection = true
+
+if let langs = args.languages {
+    // Validate against the set of supported languages when the API is available.
+    // On macOS 11 the instance method does not exist; we let Vision reject any
+    // invalid language at perform time instead.
+    if #available(macOS 12.0, *) {
+        do {
+            let supported = try request.supportedRecognitionLanguages()
+            let unsupported = langs.filter { !supported.contains($0) }
+            if !unsupported.isEmpty {
+                emitError(
+                    "unsupported language(s): \(unsupported.joined(separator: ",")). supported=\(supported.joined(separator: ","))",
+                    code: "INVALID_LANGUAGE",
+                    exitCode: exitUsageError
+                )
+            }
+        } catch {
+            emitError("failed to query supported languages: \(error.localizedDescription)", code: "VISION_ERROR", exitCode: exitVisionError)
+        }
+    }
+    request.recognitionLanguages = langs
+}
+
+// Perform request
+let handler = VNImageRequestHandler(url: url, options: [:])
+do {
+    try handler.perform([request])
+} catch {
+    emitError("Vision perform failed: \(error.localizedDescription)", code: "VISION_ERROR", exitCode: exitVisionError)
+}
+
+let observations = (request.results ?? [])
+emitResults(observations, confidenceThreshold: args.confidence)
+exit(exitSuccess)

data/lib/mac_ocr/error.rb

@@ -0,0 +1,18 @@
+module MacOcr
+  class Error < StandardError; end
+
+  class HelperNotFoundError < Error; end
+
+  class InvalidArgumentError < Error; end
+
+  class HelperExecutionError < Error
+    attr_reader :code, :exit_status, :stderr
+
+    def initialize(message, code: nil, exit_status: nil, stderr: nil)
+      super(message)
+      @code        = code
+      @exit_status = exit_status
+      @stderr      = stderr
+    end
+  end
+end

data/lib/mac_ocr/helper.rb

@@ -0,0 +1,25 @@
+require_relative "error"
+
+module MacOcr
+  module Helper
+    BINARY_NAME = "mac_ocr_helper".freeze
+
+    # Returns the absolute path to the bundled helper binary.
+    # Raises HelperNotFoundError if the binary cannot be located.
+    def self.binary_path
+      candidate = File.expand_path("../../../bin/#{BINARY_NAME}", __FILE__)
+      unless File.executable?(candidate)
+        raise HelperNotFoundError, <<~MSG.strip
+          mac_ocr helper binary not found or not executable at:
+            #{candidate}
+
+          If you are developing from a git checkout, build it with:
+            rake helper:build
+
+          mac_ocr is only supported on macOS.
+        MSG
+      end
+      candidate
+    end
+  end
+end

data/lib/mac_ocr/ocr.rb

@@ -0,0 +1,106 @@
+require "json"
+require "open3"
+
+require_relative "error"
+require_relative "helper"
+
+module MacOcr
+  # Performs text recognition on a single image using the bundled Swift helper
+  # that calls Apple's Vision framework (VNRecognizeTextRequest).
+  #
+  # Example:
+  #   ocr = MacOcr::OCR.new(
+  #     "image.png",
+  #     recognition_level: :accurate,
+  #     language_preference: ["ko-KR", "en-US"]
+  #   )
+  #   ocr.recognize
+  #   # => [["text", 0.5, [x, y, w, h]], ...]
+  #
+  # Bounding boxes are in Vision's normalized coordinate space (0..1, origin
+  # at bottom-left) — passed through unchanged from the underlying API.
+  class OCR
+    VALID_LEVELS = %i[accurate fast].freeze
+
+    attr_reader :image_path, :recognition_level, :language_preference
+
+    def initialize(image_path, recognition_level: :accurate, language_preference: nil)
+      raise InvalidArgumentError, "image_path must be a String, got #{image_path.class}" unless image_path.is_a?(String)
+      unless VALID_LEVELS.include?(recognition_level)
+        raise InvalidArgumentError, "recognition_level must be one of #{VALID_LEVELS.inspect}, got #{recognition_level.inspect}"
+      end
+      if language_preference && !language_preference.is_a?(Array)
+        raise InvalidArgumentError, "language_preference must be an Array or nil, got #{language_preference.class}"
+      end
+
+      @image_path          = image_path
+      @recognition_level   = recognition_level
+      @language_preference = language_preference
+    end
+
+    # Returns an array of [text, confidence, [x, y, w, h]] tuples.
+    def recognize
+      cmd = build_command
+      stdout, stderr, status = Open3.capture3(*cmd)
+
+      unless status.success?
+        raise_from_failure(stderr, status)
+      end
+
+      payload = parse_json(stdout)
+      results = payload["results"]
+      unless results.is_a?(Array)
+        raise HelperExecutionError.new(
+          "helper returned malformed payload (missing 'results' array)",
+          exit_status: status.exitstatus,
+          stderr: stderr
+        )
+      end
+
+      results.map { |row| [row["text"], row["confidence"], row["bbox"]] }
+    end
+
+    private
+
+    def build_command
+      cmd = [Helper.binary_path, @image_path, "--level", @recognition_level.to_s]
+      if @language_preference && !@language_preference.empty?
+        cmd << "--languages" << @language_preference.join(",")
+      end
+      cmd
+    end
+
+    def parse_json(stdout)
+      JSON.parse(stdout)
+    rescue JSON::ParserError => e
+      raise HelperExecutionError.new(
+        "helper produced invalid JSON: #{e.message}",
+        stderr: stdout
+      )
+    end
+
+    def raise_from_failure(stderr, status)
+      code, message = extract_error(stderr)
+      case code
+      when "BAD_ARGS", "FILE_NOT_FOUND", "INVALID_LANGUAGE"
+        raise InvalidArgumentError, message || "helper rejected arguments (exit #{status.exitstatus})"
+      else
+        raise HelperExecutionError.new(
+          message || "helper exited with status #{status.exitstatus}",
+          code: code,
+          exit_status: status.exitstatus,
+          stderr: stderr
+        )
+      end
+    end
+
+    def extract_error(stderr)
+      return [nil, nil] if stderr.nil? || stderr.strip.empty?
+
+      parsed = JSON.parse(stderr)
+      [parsed["code"], parsed["error"]]
+    rescue JSON::ParserError
+      [nil, stderr.strip]
+    end
+  end
+end

data/lib/mac_ocr/version.rb

@@ -0,0 +1,3 @@
+module MacOcr
+  VERSION = "0.1.0"
+end

data/lib/mac_ocr.rb

@@ -0,0 +1,7 @@
+require_relative "mac_ocr/version"
+require_relative "mac_ocr/error"
+require_relative "mac_ocr/helper"
+require_relative "mac_ocr/ocr"
+
+module MacOcr
+end

data/mac_ocr.gemspec

@@ -0,0 +1,35 @@
+require_relative "lib/mac_ocr/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "mac_ocr"
+  spec.version       = MacOcr::VERSION
+  spec.authors       = ["Team Milestone"]
+  spec.email         = ["dev@team-milestone.io"]
+
+  spec.summary       = "Ruby OCR on macOS via the Apple Vision framework."
+  spec.description   = "A Ruby port of the small surface of the Python ocrmac package. " \
+                       "Wraps a bundled Swift helper that calls VNRecognizeTextRequest, " \
+                       "returning text, confidence, and normalized bounding boxes."
+  spec.homepage      = "https://github.com/TeamMilestone/mac_ocr"
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = ">= 3.0.0"
+  spec.platform              = Gem::Platform.new("universal-darwin")
+
+  spec.metadata["homepage_uri"]      = spec.homepage
+  spec.metadata["source_code_uri"]   = spec.homepage
+  spec.metadata["bug_tracker_uri"]   = "#{spec.homepage}/issues"
+  spec.metadata["changelog_uri"]     = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  spec.files = Dir[
+    "lib/**/*.rb",
+    "ext/mac_ocr_helper/main.swift",
+    "ext/mac_ocr_helper/build.sh",
+    "bin/mac_ocr_helper",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md",
+    "mac_ocr.gemspec"
+  ]
+  spec.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: mac_ocr
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: universal-darwin
+authors:
+- Team Milestone
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A Ruby port of the small surface of the Python ocrmac package. Wraps
+  a bundled Swift helper that calls VNRecognizeTextRequest, returning text, confidence,
+  and normalized bounding boxes.
+email:
+- dev@team-milestone.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- bin/mac_ocr_helper
+- ext/mac_ocr_helper/build.sh
+- ext/mac_ocr_helper/main.swift
+- lib/mac_ocr.rb
+- lib/mac_ocr/error.rb
+- lib/mac_ocr/helper.rb
+- lib/mac_ocr/ocr.rb
+- lib/mac_ocr/version.rb
+- mac_ocr.gemspec
+homepage: https://github.com/TeamMilestone/mac_ocr
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/TeamMilestone/mac_ocr
+  source_code_uri: https://github.com/TeamMilestone/mac_ocr
+  bug_tracker_uri: https://github.com/TeamMilestone/mac_ocr/issues
+  changelog_uri: https://github.com/TeamMilestone/mac_ocr/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Ruby OCR on macOS via the Apple Vision framework.
+test_files: []