### Inno Setup Script for Ocran Installer

Source: https://github.com/largo/ocran/blob/master/README.md

An example Inno Setup script (`.iss` file) used with Ocran's `--innosetup` option. Key sections like `[Setup]` define application details, and `[Icons]` create shortcuts. Do not include `[Files]` or `[Dirs]` sections as Ocran manages them.

```ini
[Setup]
AppName=SomeApp
AppVersion=0.1
DefaultDirName={pf}\\SomeApp
DefaultGroupName=SomeApp
OutputBaseFilename=SomeAppInstaller

[Icons]
Name: "{group}\\SomeApp"; Filename: "{app}\\someapp.bat"; IconFilename: "{app}\\someapp.ico"; Flags: runminimized;
Name: "{group}\\Uninstall SomeApp"; Filename: "{uninstallexe}"
```

--------------------------------

### Build Inno Setup Installer with OCRAN

Source: https://context7.com/largo/ocran/llms.txt

Creates a professional Windows installer using Inno Setup, which installs the application to Program Files for faster startup and persistence. Requires Inno Setup to be installed and `ISCC.exe` in the PATH.

```bash
# First create an Inno Setup script (myapp.iss):
cat > myapp.iss << 'EOF'
[Setup]
AppName=MyApplication
AppVersion=1.0
DefaultDirName={pf}\MyApplication
DefaultGroupName=MyApplication
OutputBaseFilename=MyAppInstaller

[Icons]
Name: "{group}\MyApplication"; Filename: "{app}\launcher.bat"; IconFilename: "{app}\myapp.ico"
Name: "{group}\Uninstall MyApplication"; Filename: "{uninstallexe}"
EOF

# Build installer with custom icon
ocran myapp.rb --output myapp.exe --innosetup myapp.iss \
  --icon myapp.ico --no-lzma --chdir-first

# This creates MyAppInstaller.exe in the Output directory
# User runs installer which copies files to Program Files
# Subsequent launches are much faster (no extraction needed)

# Requirements:
# - Inno Setup 5+ must be installed
# - ISCC.exe must be in PATH
# - Must use --no-lzma with Inno Setup
# - Must use --chdir-first with Inno Setup
```

--------------------------------

### Generate Inno Setup Installer with Ocran

Source: https://github.com/largo/ocran/blob/master/README.md

This snippet demonstrates how to use Ocran with the `--innosetup` option to generate a Windows installer for your application using Inno Setup. Ensure Inno Setup is installed and its directory is in your PATH. Ocran automatically handles the [Files] and [Dirs] sections of the script.

```bash
ocran someapp/script/rails someapp --output someapp.exe --add-all-core \
    --gemfile someapp/Gemfile --no-dep-run --gem-full --chdir-first --no-lzma \
    --icon someapp.ico --innosetup someapp.iss -- server
```

--------------------------------

### Maximalist Ocran Example with Innosetup, OpenSSL, tzinfo-data

Source: https://github.com/largo/ocran/blob/master/Workarounds.md

A comprehensive Ocran command for creating a Windows executable with advanced options. This includes using Innosetup for installation, enabling LZMA compression, and including specific gems like OpenSSL and tzinfo-data, along with numerous core DLLs.

```shell
ocra test.rb --chdir-first --no-lzma --innosetup setup.iss --gem-full --add-all-core --icon  iconfile.ico --output test.exe --dll ruby_builtin_dlls/libgmp-10.dll --dll ruby_builtin_dlls/libffi-7.dll --dll ruby_builtin_dlls/zlib1.dll --dll ruby_builtin_dlls/libssp-0.dll --dll ruby_builtin_dlls/libssl-1_1-x64.dll --dll ruby_builtin_dlls/libcrypto-1_1-x64.dll --dll ruby_builtin_dlls/libyaml-0-2.dll --dll ruby_builtin_dlls/libwinpthread-1.dll  --dll libiconv-2.dll --dll libsqlite3-0.dll  --dll ruby_builtin_dlls/libgcc_s_seh-1.dll --gem-full=openssl --gem-full=tzinfo-data
```

--------------------------------

### Install FreeTDS and TinyTDS for Ocran

Source: https://github.com/largo/ocran/blob/master/Workarounds.md

Installs the FreeTDS library and the TinyTDS gem, required for connecting to SQL Server. This process involves using pacman to install FreeTDS and then installing the gem with specific include paths.

```shell
ridk exec pacman -S mingw-w64-ucrt-x86_64-freetds --noconfirm
gem install tiny_tds --with-freetds-include=C:\Ruby31-x64\msys64\ucrt64\include\freetds
copy C:\Ruby31-x64\msys64\ucrt64\bin\libsybdb-5.dll C:\Ruby31-x64\bin
```

--------------------------------

### Install SQLite3 and Ruby Dependencies for Ocran (Ruby 3.1)

Source: https://github.com/largo/ocran/blob/master/Workarounds.md

Installs the necessary SQLite3 and Ruby dependencies for Ocran on Ruby 3.1. This involves using pacman to install the sqlite3 package and copying specific DLLs to the Ruby bin directory. It also includes updating the Ruby installation with a specific version.

```shell
ridk exec pacman -S mingw-w64-x86_64-sqlite3 --noconfirm
copy C:\Ruby31-x64\msys64\mingw64\bin\libiconv-2.dll C:\Ruby31-x64\bin
copy C:\Ruby31-x64\msys64\mingw64\bin\libsqlite3-0.dll C:\Ruby31-x64\bin
ridk.cmd exec pacman -S mingw-w64-x86_64-ruby3.0.3-2 --noconfirm
copy C:\Ruby31-x64\msys64\mingw64\lib\ruby\3.0.0\x64-mingw32\fiber.so C:\Ruby31-x64\lib\ruby\3.1.0\x64-mingw-ucrt
```

--------------------------------

### Install Dependencies for Ruby 3.0 Workarounds

Source: https://github.com/largo/ocran/blob/master/Workarounds.md

Installs essential development dependencies for Ruby 3.0, including SQLite3, FreeTDS, and Ruby itself. This script prepares the environment for Ruby 3.0 based projects that might require these packages.

```shell
call ridk exec pacman -S mingw-w64-x86_64-sqlite3 --noconfirm
call ridk exec pacman -S mingw-w64-x86_64-freetds --noconfirm
call ridk exec pacman -S mingw-w64-ucrt-x86_64-freetds --noconfirm
call copy C:\Ruby32-x64\msys64\mingw64\bin\libiconv-2.dll C:\Ruby32-x64\bin
call copy C:\Ruby32-x64\msys64\mingw64\bin\libsqlite3-0.dll C:\Ruby32-x64\bin
call ridk exec pacman -S mingw-w64-x86_64-ruby --noconfirm
call copy C:\Ruby32-x64\msys64\mingw64\lib\ruby\3.0.0\x64-mingw32\fiber.so C:\Ruby32-x64\lib\ruby\3.1.0\x64-mingw-ucrt
```

--------------------------------

### Ruby Compilation with OCRAN

Source: https://github.com/largo/ocran/blob/master/README.md

OCRAN compiles Ruby code by loading the script and detecting dependencies. It automatically includes DLLs from the Ruby installation and distinguishes between console (.rb) and windowed (.rbw) applications, or can be explicitly set with flags.

```ruby
# Example: Your script should require all necessary files.
# OCRAN will detect dependencies automatically.

require 'some_gem'

puts "Hello from OCRAN!"
```

--------------------------------

### Install TinyTDS with FreeTDS for Ruby 3.0

Source: https://github.com/largo/ocran/blob/master/Workarounds.md

Installs the TinyTDS gem with specific FreeTDS include paths for Ruby 3.0 projects. This ensures that TinyTDS can correctly locate and utilize the FreeTDS library for database connections.

```shell
call gem install tiny_tds -- --with-freetds-include=C:\Ruby32-x64\msys64\ucrt64\include\freetds
call bundle config build.tiny_tds --with-freetds-include=C:\Ruby32-x64\msys64\ucrt64\include\freetds
call copy C:\Ruby32-x64\msys64\ucrt64\bin\libsybdb-5.dll C:\Ruby32-x64\bin
```

--------------------------------

### Configure Working Directory Behavior in OCRAN

Source: https://context7.com/largo/ocran/llms.txt

Controls the working directory when the executable starts. The `--chdir-first` option changes the working directory to the application's directory before running the script, ensuring consistent file operations. Without this, the working directory is where the user launches the executable, which can lead to issues with file associations or command prompt locations.

```bash
# Change to application directory before running script
ocran myapp.rb --chdir-first
```

--------------------------------

### Detect Runtime Execution Context in Ruby for OCRAN

Source: https://context7.com/largo/ocran/llms.txt

Checks if code is running under OCRAN during build to conditionally execute code. The `defined?(Ocran)` check prevents actions like starting a GUI or connecting to a database during the build process, ensuring a smoother dependency detection phase. It also allows access to runtime environment variables like `OCRAN_EXECUTABLE`.

```ruby
# Conditionally execute code only in production, not during OCRAN build
app = MyApplication.new

# Don't start GUI or server during OCRAN dependency detection
app.start unless defined?(Ocran)

# Example: Skip database connections during build
unless defined?(Ocran)
  DB = Sequel.connect('sqlite://production.db')
  app.run
end

# Access runtime environment variables in packaged executable
if ENV['OCRAN_EXECUTABLE']
  # Running as packaged executable
  app_dir = File.dirname(ENV['OCRAN_EXECUTABLE'])
  log_file = File.join(app_dir, 'application.log')
else
  # Running as regular Ruby script
  log_file = 'development.log'
end
```

--------------------------------

### Adding Additional Files and Directories with Ocran

Source: https://github.com/largo/ocran/blob/master/README.md

This command demonstrates how to include additional files (e.g., images, documents) and directories in the generated Ocran executable. Files are added as-is, directories are included recursively, and glob patterns can specify specific file sets.

```bash
ocran mainscript.rb someimage.jpeg docs/document.txt
```

```bash
ocran script.rb assets/**/*.png
```

--------------------------------

### Build Executable with Gemfile Dependencies using OCRAN

Source: https://context7.com/largo/ocran/llms.txt

Includes all gems specified in a Gemfile for complete dependency resolution. This command is useful for complex applications like Rails.

```bash
# Package a Rails application with all gem dependencies
ocran app/script/rails app --output myapp.exe --add-all-core \
  --gemfile app/Gemfile --no-dep-run --gem-full --chdir-first -- server

# Gemfile example:
# source 'https://rubygems.org'
# gem 'rails', '~> 7.0'
# gem 'sqlite3'
# gem 'puma'

# --gemfile: Use Bundler Gemfile for dependency detection
# --add-all-core: Include all Ruby standard libraries
# --no-dep-run: Don't execute script during build (faster for large apps)
# --gem-full: Include all files from gems, not just loaded ones
# --chdir-first: Change to app directory before running
# -- server: Arguments passed to the script at runtime
```

--------------------------------

### OCRAN Command Line Usage

Source: https://github.com/largo/ocran/blob/master/README.md

The general command-line syntax for OCRAN, allowing for options and script arguments. This enables customization of the build process and the final executable's behavior.

```bash
ocran [options] script.rb [<other files> ...] [-- <script arguments> ...]
```

--------------------------------

### Build Basic Executable with OCRAN

Source: https://context7.com/largo/ocran/llms.txt

Creates a standalone Windows executable from a Ruby script. Dependencies are automatically detected. The generated executable extracts the Ruby environment to a temporary directory on each run.

```bash
# Build a simple executable
ocran helloworld.rb

# This creates helloworld.exe which can run on any Windows system
# The executable will extract Ruby and dependencies to temp directory on each run

# Example Ruby script (helloworld.rb):
# hello_world = "Hello, World!"
# puts hello_world

# Running the generated executable:
# C:\> helloworld.exe
# Output: Hello, World!
```

--------------------------------

### OCRAN Packaging Options

Source: https://github.com/largo/ocran/blob/master/README.md

These options control how dependencies and additional files are included in the executable. They range from specifying DLLs and core libraries to managing gems and gem content detection modes.

```bash
ocran --dll dllname
ocran --add-all-core
ocran --gemfile <file>
ocran --no-enc
```

--------------------------------

### Passing Command Line Arguments to OCRA Scripts

Source: https://github.com/largo/ocran/blob/master/README.md

Demonstrates how to pass arguments to OCRA scripts during build time and execution time. Arguments specified after '--' are passed to the script, and any additional arguments provided by the user when invoking the executable are appended.

```shell
ocran script.rb -- --some-options=value
```

--------------------------------

### Build with Custom Icon for OCRAN Executable

Source: https://context7.com/largo/ocran/llms.txt

Replaces the default Ruby icon with a custom application icon (.ico format) during the OCRAN executable build process. The icon file can contain multiple resolutions, with 32x32 and 48x48 recommended.

```bash
# Build with custom .ico file
ocran myapp.rb --icon myapp.ico --output myapp.exe
```

--------------------------------

### Build Executable with OCRAN

Source: https://github.com/largo/ocran/blob/master/README.md

This command packages a Ruby script, the Ruby interpreter, and all its dependencies into a Windows executable. The executable will be named after the script file (e.g., script.exe).

```bash
ocran script.rb
```

--------------------------------

### Add DLLs and Resources with OCRAN

Source: https://context7.com/largo/ocran/llms.txt

Explicitly includes DLL files and resource files that may not be auto-detected by OCRAN. This ensures that necessary external libraries and assets are packaged with the executable.

```bash
# Include specific DLLs from Ruby's bin directory
ocran app.rb --dll sqlite3.dll --dll libxml2.dll

# Include custom resource files and directories
ocran app.rb assets/logo.png config/settings.yml docs/
```

--------------------------------

### OCRAN Output and Executable Options

Source: https://github.com/largo/ocran/blob/master/README.md

These options customize the output executable's name, compression, and type (console or windowed). They also allow for setting the working directory, adding custom icons, and configuring runtime behavior.

```bash
ocran --output <file>
ocran --no-lzma
ocran --innosetup <file>
ocran --windows
ocran --console
ocran --chdir-first
ocran --icon <ico>
ocran --rubyopt <str>
ocran --debug
ocran --debug-extract
```

--------------------------------

### Adding Relative Load Paths in Ruby

Source: https://github.com/largo/ocran/blob/master/README.md

This Ruby code snippet illustrates how to add relative load paths for additional library files located in subdirectories of the source script. It's crucial for applications that organize their code across multiple directories.

```ruby
$LOAD_PATH.unshift File.join(File.dirname($0), 'path/to/script')
```

--------------------------------

### Programmatic API (Ocran::Option Class) for OCRAN

Source: https://context7.com/largo/ocran/llms.txt

Parses and manages command-line options for OCRAN executable building programmatically. The `Ocran::Option` class allows creating, parsing options, and accessing parsed settings such as the script path, output executable name, windowed mode, and compression settings.

```ruby
require 'ocran/option'

# Create and parse options
option = Ocran::Option.new
option.parse(['myapp.rb', '--output', 'custom.exe', '--windows'])

# Access parsed options
option.script              # => #<Pathname:myapp.rb>
option.output_executable   # => #<Pathname:custom.exe>
option.windowed?           # => true
option.enable_compression? # => true (default)
option.verbose?            # => false
option.quiet?              # => false
option.add_all_core?       # => false
option.run_script?         # => true (runs for dependency detection)

# Source files to include
option.source_files        # => [#<Pathname:myapp.rb>]
option.extra_dlls          # => []

# Gem configuration
option.gem_options         # => []
option.gemfile             # => nil
```

--------------------------------

### Set Ruby Options for OCRAN Executable

Source: https://context7.com/largo/ocran/llms.txt

Configures the `RUBYOPT` environment variable for the packaged executable, allowing options like warnings (`-w`) or debug mode (`-d`) to be enabled when the executable launches Ruby. These options are preserved from the build environment if not explicitly set.

```bash
# Enable Ruby warnings in executable
ocran myapp.rb --rubyopt "-w"

# Enable debug mode and verbose
ocran myapp.rb --rubyopt "-w -d"
```

--------------------------------

### Orchestrate OCRAN Build Process with Runner Class (Ruby)

Source: https://context7.com/largo/ocran/llms.txt

The Runner class orchestrates the OCRAN build process, from script execution to executable generation. It automatically parses ARGV, runs the target script to detect dependencies (loaded features, gems, DLLs), and then builds the executable. It also handles capturing the environment before and after script execution and loading autoloaded constants.

```ruby
require 'ocran/runner'

# Initialize runner (parses ARGV automatically)
runner = Ocran::Runner.new

# Run the target script to detect dependencies
# This loads the script using Kernel#load
runner.run

# After script exits, at_exit hook triggers:
# - Captures all loaded features ($LOADED_FEATURES)
# - Detects required gems
# - Finds DLL dependencies
# - Builds executable with StubBuilder or InnoSetupScriptBuilder

# Force load autoloaded constants
runner.attempt_load_autoload

# The runner automatically:
# 1. Saves pre-execution environment (RuntimeEnvironment)
# 2. Parses options (Option)
# 3. Loads target script
# 4. Captures post-execution environment
# 5. Builds executable with all dependencies
```

--------------------------------

### Exception Handling for Windowed Ruby Applications

Source: https://github.com/largo/ocran/blob/master/README.md

Provides a Ruby code snippet for wrapping script logic in an exception handler. This is useful for windowed applications (using rubyw.exe) to log errors to a file, preventing unhandled exceptions that might occur when standard output is not available.

```ruby
begin
  # your script here
rescue Exception => e
  File.open("except.log") do |f|
    f.puts e.inspect
    f.puts e.backtrace
  end
end
```

--------------------------------

### Maintaining Original Working Directory in Ruby

Source: https://github.com/largo/ocran/blob/master/README.md

This Ruby code demonstrates how to maintain the user's original working directory while ensuring that additional Ruby scripts located in the source directory can be required. It adds the directory of the main script to the Ruby load path.

```ruby
$LOAD_PATH.unshift File.dirname($0)
```

--------------------------------

### Build Executable with Custom Name and Windowed Mode using OCRAN

Source: https://context7.com/largo/ocran/llms.txt

Specifies a custom name for the generated executable and optionally creates a windowed application (no console). The `.rbw` extension automatically enables windowed mode.

```bash
# Create executable with custom name
ocran script.rb --output myapp.exe

# Build a windowed application (no console)
ocran gui_app.rbw --output MyApplication.exe --windows

# The --windows flag forces use of rubyw.exe (no console window)
# .rbw extension automatically enables windowed mode
```

--------------------------------

### Detecting Ocran Build Environment in Ruby

Source: https://github.com/largo/ocran/blob/master/README.md

This Ruby code shows how to detect if the current script is being built by Ocran by checking for the `Ocran` constant. This is useful for conditionally executing code, such as preventing GUI windows from appearing during the build process.

```ruby
app = MyApp.new
app.main_loop unless defined?(Ocran)
```

--------------------------------

### Control Gem Inclusion with OCRAN

Source: https://context7.com/largo/ocran/llms.txt

Fine-tunes which gem files are included in the executable to balance size and functionality. Options range from minimal inclusion of loaded scripts to full inclusion of all gem contents.

```bash
# Minimal gem inclusion (only loaded scripts)
ocran app.rb --gem-minimal

# Selective gem inclusion for specific gems
ocran app.rb --gem-full=nokogiri --gem-minimal=rails

# Include all gems completely (largest size)
ocran app.rb --gem-full

# Gem inclusion modes:
# --gem-minimal: Only .rb files that were actually loaded
# --gem-guess: Loaded files + likely needed data files (DEFAULT)
# --gem-all: All scripts and data files (excludes tests, docs)
# --gem-full: Everything including tests, docs, C sources

# Control specific file types across all gems:
ocran app.rb --no-gem-extras  # Exclude README, tests, specs, C sources
ocran app.rb --no-gem-files   # Exclude data files
```

--------------------------------

### Create Executable with Ocran (Ruby 3.1, SQLite3)

Source: https://github.com/largo/ocran/blob/master/Workarounds.md

Generates a Windows executable using Ocran, including specific DLLs for SQLite3 and other core Ruby dependencies. This command is useful for creating self-contained applications that rely on SQLite.

```shell
ocra test.rb --dll libiconv-2.dll --dll libsqlite3-0.dll --dll ruby_builtin_dlls/libgmp-10.dll --dll ruby_builtin_dlls/libffi-7.dll --dll ruby_builtin_dlls/zlib1.dll --dll ruby_builtin_dlls/libssp-0.dll --dll ruby_builtin_dlls/libssl-1_1-x64.dll --dll ruby_builtin_dlls/libcrypto-1_1-x64.dll --dll ruby_builtin_dlls/libyaml-0-2.dll --dll ruby_builtin_dlls/libwinpthread-1.dll  --dll ruby_builtin_dlls/libgcc_s_seh-1.dll
```

--------------------------------

### OCRAN Gem Content Detection Modes

Source: https://github.com/largo/ocran/blob/master/README.md

These modes determine the extent to which files from gems are included in the final executable. Options range from minimal inclusion of loaded scripts to including everything found in the gem directory.

```bash
ocran --gem-minimal[=gem1,..]
ocran --gem-guess=[gem1,...]  # DEFAULT
ocran --gem-all[=gem1,..]
ocran --gem-full[=gem1,..]
ocran --gem-spec[=gem1,..] # Does not work with Rubygems 1.7+
```

--------------------------------

### Generate Self-Extracting Executable with StubBuilder Class (Ruby)

Source: https://context7.com/largo/ocran/llms.txt

The StubBuilder class generates self-extracting executables containing an embedded Ruby environment and opcodes. It allows specifying executable name, build options, and embedding Ruby executables, directories, and script files. Environment variables and the launch command can also be set. Opcodes like OP_CREATE_DIRECTORY, OP_CREATE_FILE, OP_SETENV, and OP_SET_SCRIPT are used during the build process.

```ruby
require 'ocran/stub_builder'

# Create executable with configuration
Ocran::StubBuilder.new(
  'myapp.exe',
  chdir_before: true,
  debug_extract: false,
  debug_mode: false,
  enable_compression: true,
  gui_mode: false,
  icon_path: 'myapp.ico'
) do |builder|
  # Add Ruby executable
  builder.cp('C:/Ruby32/bin/ruby.exe', 'bin/ruby.exe')

  # Create directories
  builder.mkdir('src')
  builder.mkdir('lib/ruby/3.2.0')

  # Copy script files
  builder.cp('myapp.rb', 'src/myapp.rb')
  builder.cp('lib/helper.rb', 'src/lib/helper.rb')

  # Set environment variables
  builder.export('RUBYOPT', '-rubygems')
  builder.export('GEM_PATH', 'lib/ruby/gems/3.2.0')

  # Set launch command (must be called last)
  builder.exec('bin/ruby.exe', 'src/myapp.rb', '--arg1', 'value1')
end

# Opcodes written to executable:
# OP_CREATE_DIRECTORY: Creates directory structure
# OP_CREATE_FILE: Embeds file with content
# OP_SETENV: Sets environment variable
# OP_SET_SCRIPT: Specifies Ruby interpreter and script to execute
```

--------------------------------

### Accessing Ocran Executable Path in Ruby

Source: https://github.com/largo/ocran/blob/master/README.md

This Ruby code snippet shows how to access the full path of the generated Ocran executable using the `OCRAN_EXECUTABLE` environment variable. This is useful for applications that need to know their own location at runtime.

```ruby
ENV["OCRAN_EXECUTABLE"] # => C:\\Program Files\\MyApp\\MyApp.exe
```

--------------------------------

### OCRAN Auto-detection Options

Source: https://github.com/largo/ocran/blob/master/README.md

These options control how OCRAN automatically detects script dependencies and runtime DLLs. Disabling auto-detection can be useful in specific scenarios or for fine-grained control.

```bash
ocran --no-dep-run
ocran --no-autoload
ocran --no-autodll
```

--------------------------------

### Rake Build Tasks

Source: https://github.com/largo/ocran/blob/master/Manifest.txt

Contains Rake tasks for building, testing, and managing the Ocran project. It simplifies common development workflows.

```Ruby
require 'rake'
require_relative 'lib/ocran/version.rb'

Gem::Specification.new do |spec|
  spec.name          = "ocran"
  spec.version       = Ocran::VERSION
  spec.authors       = ["Your Name"]
  spec.email         = ["your.email@example.com"]
  spec.summary       = %q{A Ruby wrapper for Tesseract OCR.}
  spec.description   = %q{Provides a simple interface to use the Tesseract OCR engine from Ruby.}
  spec.homepage      = %q{https://github.com/yourusername/ocran}
  spec.license       = "MIT"

  spec.files         = `git ls-files`.split("\n")
  spec.executables   = spec.files.grep(/^bin/) { |f| File.basename(f) }
  spec.test_files    = spec.files.grep(/^test/) { |f| File.basename(f) }
  spec.require_paths = ["lib"]

  spec.add_development_dependency "rake", ">= 0.9.0"
  spec.add_development_dependency "minitest", ">= 5.0.0"
end

```

--------------------------------

### Ocran Main Executable

Source: https://github.com/largo/ocran/blob/master/Manifest.txt

The primary executable for the Ocran project. This script likely orchestrates the OCR process using the Ocran library.

```Shell
#!/usr/bin/env ruby

require "ocran"

if __FILE__ == $0
  if ARGV.empty?
    STDERR.puts "Usage: ocran <image_file>"
    exit 1
  end
  image_path = ARGV[0]
  puts Ocran.recognize(image_path)
end
```

--------------------------------

### Ocran Test Suite

Source: https://github.com/largo/ocran/blob/master/Manifest.txt

Unit tests for the Ocran gem, ensuring its functionality and stability. Uses the Minitest framework.

```Ruby
require 'minitest/autorun'
require_relative '../lib/ocran'

class TestOcran < Minitest::Test
  def test_recognize_simple_image
    # This test assumes you have a test image named 'test_image.png' in the 'test/' directory
    # and that Tesseract is installed and configured correctly.
    # Create a dummy image file for testing if needed, or use a real one.
    image_path = File.join(File.dirname(__FILE__), 'test_image.png')
    
    # If you don't have a test_image.png, you might skip this test or create a placeholder.
    unless File.exist?(image_path)
      puts "Skipping test_recognize_simple_image: #{image_path} not found."
      return
    end

    begin
      text = Ocran.recognize(image_path)
      # Assert that the recognized text is as expected. This will depend on the content of 'test_image.png'.
      # For example, if 'test_image.png' contains 'Hello World', you'd assert:
      # assert_equal "Hello World", text
      assert !text.empty?, "Expected to recognize text, but got empty string."
    rescue => e
      flunk "OCR recognition failed: #{e.message}"
    end
  end

  def test_recognize_invalid_path
    assert_raises RuntimeError do
      Ocran.recognize('non_existent_image.png')
    end
  end
end
```

--------------------------------

### Ocran Core Library Functionality

Source: https://github.com/largo/ocran/blob/master/Manifest.txt

The main Ruby library file for Ocran. It likely contains the core logic for interacting with the OCR engine.

```Ruby
require 'open3'

module Ocran
  class << self
    def recognize(image_path)
      # Ensure the path to the tesseract executable is correct
      tesseract_cmd = ENV['TESSERACT_CMD'] || 'tesseract'
      
      # Construct the command to run tesseract
      # '-l eng' specifies the language (English)
      # '--psm 3' sets the page segmentation mode (fully automatic)
      command = "#{tesseract_cmd} #{image_path} stdout -l eng --psm 3"
      
      stdout_str, stderr_str, status = Open3.capture3(command)
      
      if status.success?
        return stdout_str.strip
      else
        raise "Tesseract OCR failed: #{stderr_str.strip}"
      end
    end
  end
end
```

--------------------------------

### Ocran Version Definition

Source: https://github.com/largo/ocran/blob/master/Manifest.txt

Defines the version of the Ocran gem. This file is crucial for dependency management and tracking releases.

```Ruby
module Ocran
  VERSION = "0.1.0"
end
```

--------------------------------

### Debug OCRAN Executable Extraction and Execution

Source: https://context7.com/largo/ocran/llms.txt

Enables debugging features to troubleshoot executable issues and inspect extracted files. The `--debug-extract` option keeps extracted files in the executable directory, while `--debug` provides verbose output during execution, showing extraction paths, environment variables, and command execution details.

```bash
# Extract files to executable directory (not temp) and keep them
ocran myapp.rb --debug-extract

# Enable verbose debug output during execution
ocran myapp.rb --debug

# Build with debug info and custom name
ocran myapp.rb --debug --output myapp-debug.exe
```

--------------------------------

### Disable Automatic Dependency Detection in OCRAN

Source: https://context7.com/largo/ocran/llms.txt

Manually controls dependency detection for complex applications where auto-detection might fail. Options like `--no-dep-run`, `--no-autoload`, `--no-autodll`, and `--no-enc` provide fine-grained control over what is included in the executable, potentially reducing its size.

```bash
# Build without running the script (manual dependency control)
ocran myapp.rb --no-dep-run --add-all-core --gem-full

# Disable autoload detection
ocran myapp.rb --no-autoload

# Disable DLL auto-detection
ocran myapp.rb --no-autodll

# Exclude encoding support files (smaller executable)
ocran myapp.rb --no-enc
```

--------------------------------

### Resolve TinyTDS 'Module Not Found' Error with msys-2.0.dll

Source: https://github.com/largo/ocran/blob/master/Workarounds.md

A workaround for the 'module cannot be found' error with TinyTDS. This involves explicitly including the msys-2.0.dll, which is a compatibility library from msys, when creating the executable with Ocran.

```shell
ruby .\bin\ocran .\samples\tiny_tds.rb --dll ../msys64/usr/bin/msys-2.0.dll
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.