rodiff 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28e710101370bfd2b8a7efd8047d9c0d40b4f68784863673cf897ed9494deaee
-  data.tar.gz: ddf19f3a1f7f93f46fa9050431815e480dac9708a6e3337fbca9ac58ceb51fb9
+  metadata.gz: 864417eae37667c26264ea7de3365d12511c4069d89e83c859641de7c00c22cc
+  data.tar.gz: 5cc69618a1b4893e10d428a387e85f813b26278496f2601abc5315113726e3a3
 SHA512:
-  metadata.gz: 0073e776a4217abf7467ea32211340f1d0f0a6f01b40b3585d32efb77a55536d6826df8ff29de85876a853863ccd505b498fa999b2cdeb378b614a65f8e6a05f
-  data.tar.gz: b45fc039a867b9948cd8735deb59505177fd373bb280c273bd4b76107da1aef7d61f22e42bad30674c55165a17e7ba00f5ecab5a6853b23796d9774cc6cc703f
+  metadata.gz: f77b00f02f5f934de75c153c82c8000641a8e1f6e8edebab6f56c0f42af3a34179ca3796a49f82506747934d6f1cc1d34fed2e027290febad530ca92e5630321
+  data.tar.gz: 3551ea66e08e3c8f65bd7ed32fc47f5a3b0681ebd08646edc313284dc9260e04c855a7a9c2cb7d3c7fc1e878f56d40c8fe1b95c06a51a9076a52296bec778357

data/README.md

@@ -1,14 +1,17 @@
 # rodiff
 
-A ruby wrapper for [Odiff](https://github.com/dmtrKovalenko/odiff), an image comparison tool written in OCamel.
+[![Version][rubygems_badge]][rubygems]
+[![CI][ci_badge]][ci_workflows]
+[![Coverage][coverage_badge]][coverage]
+[![Maintainability][maintainability_badge]][maintainability]
 
+A ruby image comparison tool powered by [Odiff](https://github.com/dmtrKovalenko/odiff) in OCamel.
 
 ## Motivation
 
-A strong candidate against the veteran players on the internet like [pixelmatch](https://github.com/mapbox/pixelmatch) and [ImageMagick](https://github.com/ImageMagick/ImageMagick)
-
 Impressive [benchmarks](https://github.com/dmtrKovalenko/odiff#benchmarks) from `Odiff`.
 
+A strong candidate against the veteran players like [pixelmatch](https://github.com/mapbox/pixelmatch) and [ImageMagick](https://github.com/ImageMagick/ImageMagick)
 
 ## Getting Started
 
@@ -27,7 +30,7 @@ This gem wraps the [standalone executable](https://github.com/dmtrKovalenko/odif
 Supported platforms are:
 - arm64-darwin (macos-arm64)
 - x64-mingw32 (windows-x64)
-- x64-mingw-ucr (windows-x64)
+- x64-mingw-ucrt (windows-x64)
 - x86_64-darwin (macos-x64)
 - x86_64-linux (linux-x64)
 
@@ -35,7 +38,7 @@ Supported platforms are:
 
 If you are not able to use the vendored standalone executables, a local installation of the `Odiff` executable can be configured by setting an environment variable named `ODIFF_INSTALL_DIR` to the directory path containing the executable.
 
-For example, if you've installed `odiff` via npm which could be something like `/path/to/node_modules/bin/odiff`, then you should set your environment variable like so:
+For example, if you've installed the [`odiff-bin`](https://github.com/dmtrKovalenko/odiff#cross-platform) npm package and had the binaries downloaded at `/path/to/node_modules/bin/odiff`, then you should set your environment variable like so:
 
 ``` sh
 ODIFF_INSTALL_DIR=/path/to/node_modules/bin
@@ -47,6 +50,63 @@ or, for relative paths like `./node_modules/.bin/odiff`:
 ODIFF_INSTALL_DIR=node_modules/.bin
 ```
 
+## Configuration
+
+Rodiff automatically discovers and loads configuration from `.rodiff.yml` files in your project.
+
+### Configuration File Discovery
+
+Rodiff searches for `.rodiff.yml` starting from the current directory and traversing upward to your home directory:
+
+```
+/home/username/projects/myapp/src/tests/.rodiff.yml  ← checks here first
+/home/username/projects/myapp/src/.rodiff.yml
+/home/username/projects/myapp/.rodiff.yml            ← typically found here
+/home/username/projects/.rodiff.yml
+/home/username/.rodiff.yml                            ← stops here (home directory)
+```
+
+### Configuration Options
+
+Create a `.rodiff.yml` file in your project root:
+
+```yaml
+# File patterns for image comparison (supports glob patterns)
+include_pattern: "screenshots/**/*.png"
+exclude_pattern: "screenshots/archived/**"
+
+# Comparison settings
+color_threshold: 0.1          # 0.0 - 1.0 (lower = stricter)
+ignore_antialiasing: false    # Ignore antialiasing differences
+output_diff_mask: false       # Output black/white mask instead of diff image
+
+# Error handling
+fail_if_no_comparison: false  # Exit with error if no images found
+exit_code_error: 1           # Exit code for errors (not image differences)
+```
+
+### Programmatic Configuration
+
+You can also configure Rodiff programmatically:
+
+```ruby
+Rodiff.configure do |config|
+  config.include_pattern = "**/*.png"
+  config.color_threshold = 0.15
+  config.ignore_antialiasing = true
+end
+```
+
+Or override specific values:
+
+```ruby
+config = Rodiff::Configuration.new
+config.overrides(
+  color_threshold: 0.2,
+  output_diff_mask: true
+)
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -93,4 +153,17 @@ See https://bundler.io/man/bundle-config.1.html for more information.
 ## License
 
 Rodiff is released under the [MIT License](https://opensource.org/licenses/MIT).
-Odiff is released under the [MIT License](https://opensource.org/licenses/MIT).
+Odiff is released under the [MIT License](https://opensource.org/licenses/MIT).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [https://github.com/ryancyq/rodiff](https://github.com/ryancyq/rodiff).
+
+[rubygems_badge]: https://img.shields.io/gem/v/rodiff.svg
+[rubygems]: https://rubygems.org/gems/rodiff
+[ci_badge]: https://github.com/ryancyq/rodiff/actions/workflows/ci.yml/badge.svg
+[ci_workflows]: https://github.com/ryancyq/rodiff/actions/workflows/ci.yml
+[coverage_badge]: https://codecov.io/gh/ryancyq/rodiff/graph/badge.svg?token=SYR7FSDWT5
+[coverage]: https://codecov.io/gh/ryancyq/rodiff
+[maintainability_badge]: https://api.codeclimate.com/v1/badges/d5b1002a1a7162f86a7a/maintainability
+[maintainability]: https://codeclimate.com/github/ryancyq/rodiff/maintainability

data/exe/rodiff

@@ -1,23 +1,8 @@
 #!/usr/bin/env ruby
-# frozen_string_literal: true
 
 $LOAD_PATH.unshift File.expand_path("../lib", __dir__)
 
 require "rodiff/cli"
 
-begin
-  verbose = ARGV.delete "--verbose"
-  command = [Rodiff::CLI.executable, *ARGV]
-  puts "rodiff: #{command.inspect}" if verbose
-
-  if Gem.win_platform?
-    # use system rather than exec as exec inexplicably fails to find the executable on Windows
-    # see related https://github.com/rubys/sprockets-esbuild/pull/4
-    system(*command, exception: true)
-  else
-    exec(*command)
-  end
-rescue Rodiff::CLI::CommandError => e
-  warn("ERROR: #{e.message}")
-  exit 1
-end
+# set invoked_via_subcommand to ensure default command is used
+Rodiff::CLI.start(ARGV, invoked_via_subcommand: true)

data/lib/rodiff/cli.rb

@@ -1,87 +1,69 @@
 # frozen_string_literal: true
 
-require "rodiff/odiff"
+require "thor"
+require "open3"
+require "shellwords"
 
-module Rodiff
-  class CLI
-    DEFAULT_DIR = File.expand_path(File.join(__dir__, "..", "..", "exe"))
-
-    class CommandError < StandardError; end
+require "rodiff/configuration"
+require "rodiff/error"
+require "rodiff/version"
 
-    class UnsupportedPlatform < CommandError
-      def initialize(platform)
-        super(
-          <<~MSG
-            odiff does not support the #{platform} platform
-            Please install odiff following instructions at https://github.com/dmtrKovalenko/odiff#installation
-          MSG
-        )
+module Rodiff
+  class CLI < Thor
+    package_name "rodiff"
+
+    default_command :compare
+
+    desc "version", "Print version"
+    map ["-v", "--version"] => :version
+    method_option :odiff, type: :boolean, required: false
+    def version
+      if options.odiff?
+        odiff_exec("--version")
+      else
+        say Rodiff::VERSION
       end
     end
 
-    class ExecutableNotFound < CommandError
-      def initialize(platform, exe_path)
-        super(
-          <<~MSG
-            Cannot find the odiff executable for #{platform} in #{exe_path}
-
-            If you're using bundler, please make sure you're on the latest bundler version:
-
-                gem install bundler
-                bundle update --bundler
+    desc "compare [BASELINE] [VARIANT] [DIFF]", "Compare VARIANT against BASELINE, output to DIFF"
+    method_option :verbose, type: :boolean, default: false
+    def compare(baseline = nil, variant = nil, diff = nil)
+      all_present, all_absent = args_presence(baseline, variant, diff)
+      raise ArgumentError, "BASELINE, VARIANT, DIFF must be provided" unless all_present ^ all_absent
 
-            Then make sure your lock file includes this platform by running:
-
-                bundle lock --add-platform #{platform}
-                bundle install
-
-            See `bundle lock --help` output for details.
-
-            If you're still seeing this message after taking those steps, try running
-            `bundle config` and ensure `force_ruby_platform` isn't set to `true`. See
-            https://github.com/ryancyq/rodiff#check-bundle_force_ruby_platform
-            for more details.
-          MSG
-          )
-      end
+      odiff_exec(baseline, variant, diff)
+    rescue Rodiff::Error => e
+      raise Thor::Error, "ERROR: #{e.message}"
     end
 
-    class InstallDirectoryNotFound < CommandError
-      def initialize(install_dir)
-        super("ODIFF_INSTALL_DIR is set to #{install_dir}, but that directory does not exist.")
-      end
+    def self.exit_on_failure?
+      true
     end
 
-    class << self
-      def platform
-        %i[cpu os].map { |m| Gem::Platform.local.public_send(m) }.join("-")
-      end
+    private
 
-      def supported_platform?(platform = nil)
-        return Gem::Platform.match_gem?(Gem::Platform.new(platform), "rodiff") unless platform.nil?
+    def config
+      Rodiff.configuration
+    end
 
-        Rodiff::Odiff::PLATFORMS.keys.any? { |p| Gem::Platform.match_gem?(Gem::Platform.new(p), "rodiff") }
+    def args_presence(*args)
+      args.each_with_object([true, true]) do |e, acc|
+        acc[0] = false if e.nil? || e == ""
+        acc[1] = false unless e.nil? || e == ""
       end
+    end
 
-      def executable(exe_path: DEFAULT_DIR)
-        if (odiff_install_dir = ENV.fetch("ODIFF_INSTALL_DIR", nil))
-          raise InstallDirectoryNotFound, odiff_install_dir unless File.directory?(odiff_install_dir)
-
-          warn "NOTE: using ODIFF_INSTALL_DIR to find odiff executable: #{odiff_install_dir}"
-          exe_path = odiff_install_dir
-          exe_file = File.expand_path(File.join(odiff_install_dir, "odiff"))
-        else
-          raise UnsupportedPlatform, platform unless supported_platform?
-
-          exe_files_of_platforms = File.expand_path(File.join(exe_path, "*", "odiff"))
-          exe_file = Dir.glob(exe_files_of_platforms).find do |f|
-            supported_platform?(File.basename(File.dirname(f)))
-          end
-        end
-
-        raise ExecutableNotFound.new(platform, exe_path) if exe_file.nil? || !File.exist?(exe_file)
-
-        exe_file
+    def odiff_exec(*cmd)
+      cmd_parts = []
+      cmd_parts << config.odiff_exe_path
+      cmd_parts.push(*cmd)
+
+      stdout, stderr, status = Open3.capture3(*cmd_parts)
+      if block_given?
+        yield stdout, stderr, status
+      else
+        say_error stderr unless stderr.nil? || stderr == ""
+        say stdout unless stdout.nil? || stdout == ""
       end
     end
   end

data/lib/rodiff/configuration.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "rodiff/error"
+require "rodiff/executable"
+require "rodiff/helpers/file_finder"
+
+module Rodiff
+  def self.configuration
+    @configuration ||= Rodiff::Configuration.new
+  end
+
+  def self.configure
+    yield configuration
+  end
+
+  class Configuration
+    class UnknownConfiguration < Rodiff::Error; end
+
+    DOTFILE = ".rodiff.yml"
+    GEM_ROOT = if RUBY_VERSION >= "3.1"
+                 File.dirname(__FILE__, 3).freeze
+               else
+                 File.expand_path(File.join(File.dirname(__FILE__), "..", "..")).freeze
+               end
+    DEFAULT_CONFIG = File.join(GEM_ROOT, "config", "default.yml").freeze
+    SEARCH_ROOT = Dir.home.freeze
+
+    ATTRS = Module.new.tap { |mod| include mod }
+    READER_ATTRS = {
+      default_dir: "/"
+    }.freeze
+
+    ACCESSOR_ATTRS = {
+      include_pattern:       "{*,**/*}.jpg",
+      exclude_pattern:       "",
+      compare_pattern:       "",
+
+      ignore_antialiasing:   false,
+      color_threshold:       0.1,
+      output_diff_mask:      false,
+
+      exit_code_odiff:       ->(code) { code },
+      exit_code_error:       1,
+      fail_if_no_comparison: false
+    }.freeze
+
+    def self.generate_config(mod, path, line, attrs)
+      mod.module_eval(Array(attrs).join(";").to_s, path, line)
+    end
+
+    def self.config_attribute(name, type:)
+      case type
+      when :reader, :writer, :accessor then "attr_#{type} :#{name}"
+      when :proxy
+        <<-RUBY
+          def #{name}
+            value_for(:#{name}) { super() }
+          end
+        RUBY
+      else
+        raise ArgumentError, "unsupported type #{type.inspect}"
+      end
+    end
+
+    generate_config ATTRS, __FILE__, __LINE__, [
+      *READER_ATTRS.keys.map { |key| config_attribute(key, type: :reader) },
+      *ACCESSOR_ATTRS.keys.map { |key| config_attribute(key, type: :accessor) }
+    ]
+
+    generate_config self, __FILE__, __LINE__, [
+      *READER_ATTRS.keys.map { |key| config_attribute(key, type: :proxy) },
+      *ACCESSOR_ATTRS.keys.map { |key| config_attribute(key, type: :proxy) }
+    ]
+
+    def initialize
+      @config_overrides = {}
+
+      READER_ATTRS.each { |key, value| instance_variable_set("@#{key}", value) }
+      ACCESSOR_ATTRS.each { |key, value| instance_variable_set("@#{key}", value) }
+
+      load_from_file(DEFAULT_CONFIG)
+      load_from_file(config_file_override) if config_file_override
+    end
+
+    def odiff_exe_path
+      @odiff_exe_path ||= Rodiff::Executable.resolve
+    end
+
+    def odiff_exe_path=(path)
+      @odiff_exe_path = Rodiff::Executable.resolve(exe_path: path)
+    end
+
+    def overrides(opts = {})
+      opts.each_key { |key| validate_config_key!(key) }
+      @config_overrides.merge!(opts.transform_keys(&:to_sym))
+    end
+
+    private
+
+    def config_file_override(start_dir: Dir.pwd)
+      @config_file_override ||= begin
+        finder = Helpers::FileFinder.new("/")
+        finder.find_upwards(DOTFILE, start_dir, SEARCH_ROOT)
+      end
+    end
+
+    def load_from_file(path)
+      yml_config = YAML.load_file(path) if File.exist?(path)
+
+      if yml_config.is_a?(Hash)
+        yml_config.each do |key, value|
+          validate_config_key!(key.to_sym)
+          public_send("#{key}=", value) if respond_to?("#{key}=")
+        end
+      elsif empty_yml?(yml_config)
+        warn "Configuration file #{path} is empty"
+      else
+        warn "Configuration file #{path} must contain a Hash, got #{yml_config.class}"
+      end
+    rescue Psych::SyntaxError => e
+      raise Rodiff::Error, "Invalid YAML in #{path}: #{e.message}"
+    end
+
+    def empty_yml?(data)
+      # Ruby 2.7-3.0 with Psych 3.x
+      return data == false if RUBY_VERSION < "3.1"
+
+      # Ruby 3.1+ with Psych 4.x
+      data.nil?
+    end
+
+    def validate_config_key!(key)
+      return if READER_ATTRS.key?(key) || ACCESSOR_ATTRS.key?(key)
+
+      raise UnknownConfiguration, "unknown config #{key.inspect}"
+    end
+
+    def value_for(key, &block)
+      validate_config_key!(key)
+      @config_overrides.fetch(key, &block)
+    end
+
+    def files_from_dir(dir)
+      included_files = files_from_glob(file_glob_pattern(dir, include_pattern))
+      excluded_files = files_from_glob(file_glob_pattern(dir, exclude_pattern))
+      (included_files - excluded_files).uniq
+    end
+
+    def files_from_glob(file_glob)
+      files = Dir.glob(file_glob)
+      files.map { |file| File.expand_path(file) }.sort
+    end
+
+    def file_glob_pattern(path, pattern)
+      trimmed = "{#{pattern.gsub(%r{\s*,\s*}, ",")}}"
+      return trimmed if pattern =~ %r{^(\./)?#{Regexp.escape(path)}} || absolute_pattern?(pattern)
+
+      File.join(path, trimmed)
+    end
+
+    def absolute_pattern?(pattern)
+      return pattern.start_with?(File::Separator) unless windows?
+      return false unless File::ALT_SEPARATOR
+
+      win_absolute_pattern = %r{\A\w+:#{Regexp.escape(File::ALT_SEPARATOR)}}.match?(pattern)
+      win_network_pattern = pattern.start_with?(File::ALT_SEPARATOR * 2)
+      win_absolute_pattern || win_network_pattern
+    end
+
+    def windows?
+      @windows ||= begin
+        require "rbconfig"
+        os = RbConfig::CONFIG["host_os"]
+        os.match?(%r{mingw})
+      end
+    end
+  end
+end

data/lib/rodiff/error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rodiff
+  class Error < StandardError; end
+end

data/lib/rodiff/executable.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "rodiff/odiff"
+require "rodiff/error"
+
+module Rodiff
+  class Executable
+    DEFAULT_DIR = File.expand_path(File.join(__dir__, "..", "..", "exe"))
+    LOCAL_INSTALL_DIR_ENV = "ODIFF_INSTALL_DIR"
+
+    class UnsupportedPlatform < Rodiff::Error
+      def initialize(platform)
+        super(
+          <<~MSG
+            odiff does not support the #{platform} platform
+            Please install odiff following instructions at https://github.com/dmtrKovalenko/odiff#installation
+          MSG
+        )
+      end
+    end
+
+    class ExecutableNotFound < Rodiff::Error
+      def initialize(platform, exe_path)
+        super(
+          <<~MSG
+            Cannot find the odiff executable for #{platform} in #{exe_path}
+
+            If you're using bundler, please make sure you're on the latest bundler version:
+
+                gem install bundler
+                bundle update --bundler
+
+            Then make sure your lock file includes this platform by running:
+
+                bundle lock --add-platform #{platform}
+                bundle install
+
+            See `bundle lock --help` output for details.
+
+            If you're still seeing this message after taking those steps, try running
+            `bundle config` and ensure `force_ruby_platform` isn't set to `true`. See
+            https://github.com/ryancyq/rodiff#check-bundle_force_ruby_platform
+            for more details.
+          MSG
+          )
+      end
+    end
+
+    class InstallDirectoryNotFound < Rodiff::Error
+      def initialize(install_dir)
+        super("#{LOCAL_INSTALL_DIR_ENV} is set to #{install_dir}, but that directory does not exist.")
+      end
+    end
+
+    class << self
+      def platform
+        %i[cpu os].map { |m| Gem::Platform.local.public_send(m) }.join("-")
+      end
+
+      def supported_platform?(platform = nil)
+        return Gem::Platform.match_gem?(Gem::Platform.new(platform), "rodiff") unless platform.nil?
+
+        Rodiff::Odiff::PLATFORMS.keys.any? { |p| Gem::Platform.match_gem?(Gem::Platform.new(p), "rodiff") }
+      end
+
+      def resolve(exe_path: DEFAULT_DIR)
+        if (odiff_install_dir = ENV.fetch(LOCAL_INSTALL_DIR_ENV, nil))
+          exe_path = odiff_install_dir
+          exe_file = expand_local_install_dir(odiff_install_dir)
+        elsif supported_platform?
+          exe_file = expand_bundled_dir(exe_path)
+        else
+          raise UnsupportedPlatform, platform
+        end
+
+        raise ExecutableNotFound.new(platform, exe_path) if exe_file.nil? || !File.exist?(exe_file)
+
+        exe_file
+      end
+
+      private
+
+      def expand_local_install_dir(local_install_dir)
+        raise InstallDirectoryNotFound, local_install_dir unless File.directory?(local_install_dir)
+
+        warn "NOTE: using #{LOCAL_INSTALL_DIR_ENV} to find odiff executable: #{local_install_dir}"
+        exe_files = File.expand_path(File.join(local_install_dir, "odiff{,.exe}"))
+        Dir.glob(exe_files).first
+      end
+
+      def expand_bundled_dir(bundled_dir)
+        exe_files_of_platforms = File.expand_path(File.join(bundled_dir, "*", "odiff"))
+        Dir.glob(exe_files_of_platforms).find do |f|
+          supported_platform?(File.basename(File.dirname(f)))
+        end
+      end
+    end
+  end
+end

data/lib/rodiff/helpers/file_finder.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Rodiff
+  module Helpers
+    class FileFinder
+      attr_reader :root_dir
+
+      def initialize(root)
+        @root_dir = root
+      end
+
+      def find_upwards(filename, start_dir, stop_dir = nil)
+        traverse_upwards(filename, start_dir, stop_dir) { |file| return file if file } # return first result
+      end
+
+      def find_top_most(filename, start_dir, stop_dir = nil)
+        top_most_file = nil
+        traverse_upwards(filename, start_dir, stop_dir) { |file| top_most_file = file }
+        top_most_file
+      end
+
+      private
+
+      def traverse_upwards(filename, start_dir, stop_dir)
+        start = Pathname.new(start_dir).expand_path
+        root = Pathname.new(root_dir).expand_path
+        return unless start.to_s.start_with?(root.to_s)
+
+        stop = Pathname.new(stop_dir).expand_path if stop_dir
+        start.ascend do |dir|
+          file = File.join(dir, filename)
+          yield(file) if File.exist?(file)
+
+          break if dir == stop || dir == root
+        end
+      end
+    end
+  end
+end

data/lib/rodiff/odiff.rb

@@ -2,7 +2,7 @@
 
 module Rodiff
   module Odiff
-    VERSION = "v3.1.1"
+    VERSION = "3.1.1"
 
     # rubygems platform name => upstream release filename
     PLATFORMS = {

data/lib/rodiff/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rodiff
-  VERSION = "1.0.0"
+  VERSION = "1.2.0"
 end

data/lib/rodiff.rb

@@ -3,6 +3,6 @@
 module Rodiff
 end
 
-require_relative "rodiff/version"
-require_relative "rodiff/odiff"
-require_relative "rodiff/cli"
+require "rodiff/error"
+require "rodiff/configuration"
+require "rodiff/executable"

metadata

@@ -1,16 +1,34 @@
 --- !ruby/object:Gem::Specification
 name: rodiff
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Ryan Chang
-autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-09-08 00:00:00.000000000 Z
-dependencies: []
-description: 
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.5.0
 email:
 - ryancyq@gmail.com
 executables:
@@ -24,6 +42,10 @@ files:
 - exe/rodiff
 - lib/rodiff.rb
 - lib/rodiff/cli.rb
+- lib/rodiff/configuration.rb
+- lib/rodiff/error.rb
+- lib/rodiff/executable.rb
+- lib/rodiff/helpers/file_finder.rb
 - lib/rodiff/odiff.rb
 - lib/rodiff/version.rb
 homepage: https://github.com/ryancyq/rodiff
@@ -34,7 +56,6 @@ metadata:
   allowed_push_host: https://rubygems.org
   changelog_uri: https://github.com/ryancyq/rodiff/blob/main/CHANGELOG.md
   homepage_uri: https://github.com/ryancyq/rodiff
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -49,9 +70,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.2.0
 requirements:
-- odiff, v3.1.1
-rubygems_version: 3.5.16
-signing_key: 
+- odiff, >= 3.0
+rubygems_version: 4.0.3
 specification_version: 4
-summary: A ruby wrapper for odiff
+summary: A ruby image comparison tool powered by ODiff in OCamel
 test_files: []