ory-client 1.16.6 → 1.16.9

data/vendor/bundle/ruby/3.1.0/gems/diff-lcs-1.6.0/CONTRIBUTING.md

@@ -0,0 +1,74 @@
+# Contributing
+
+Contribution to diff-lcs is encouraged in any form: a bug report, a feature
+request, or code contributions. There are a few DOs and DON'Ts for
+
+- DO:
+
+  - Keep the coding style that already exists for any updated Ruby code (support
+    or otherwise). I use [Standard Ruby][standardrb] for linting and formatting.
+
+  - Use thoughtfully-named topic branches for contributions. Rebase your commits
+    into logical chunks as necessary.
+
+  - Use [quality commit messages][qcm].
+
+  - Add your name or GitHub handle to `CONTRIBUTORS.md` and a record in the
+    `CHANGELOG.md` as a separate commit from your main change. (Follow the style
+    in the `CHANGELOG.md` and provide a link to your PR.)
+
+  - Add or update tests, written in [RSpec][rspec], as appropriate.
+
+  - Add or update documentation, as appropriate.
+
+- DO NOT:
+
+  - Modify `VERSION` in `lib/diff/lcs.rb`. When your patch is accepted and a
+    release is made, the version will be updated at that point.
+
+  - Modify `diff-lcs.gemspect`; it is a generated file. (You _may_ use
+    `rake gemspec` to regenerate it if your change involves metadata related to
+    gem itself).
+
+  - Modify the `Gemfile`.
+
+## Test Dependencies
+
+diff-lcs uses Ryan Davis's [Hoe][Hoe] to manage the release process, and it adds
+a number of rake tasks. You will mostly be interested in `rake`, which runs
+tests in the same way that `rake spec` does.
+
+To assist with the installation of the development dependencies for diff-lcs, I
+have provided a Gemfile pointing to the (generated) `diff-lcs.gemspec` file.
+`minitar.gemspec` file. This will permit you to use `bundle install` to install
+the dependencies.
+
+You can run tests with code coverage analysis by running `rake spec:coverage`.
+
+## Workflow
+
+Here's the most direct way to get your work merged into the project:
+
+- Fork the project.
+- Clone your fork (`git clone git://github.com/<username>/diff-lcs.git`).
+- Create a topic branch to contain your change
+  (`git checkout -b my_awesome_feature`).
+- Hack away, add tests. Not necessarily in that order.
+- Make sure everything still passes by running `rake`.
+- If necessary, rebase your commits into logical chunks, without errors.
+- Push the branch up (`git push origin my_awesome_feature`).
+- Create a pull request against halostatue/diff-lcs and describe what your
+  change does and the why you think it should be merged.
+
+### Help Wanted
+
+I want to automated the releases. I am **not** switching from Hoe for release
+management, so the use of [rubygems/release-gem][release-gem] requires some care
+(perhaps by exporting `VERSION=$(rake version)` to the job), but assistance in
+getting this action going for an automated release would be greatly appreciated.
+
+[hoe]: https://github.com/seattlerb/hoe
+[qcm]: http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html
+[release-gem]: https://github.com/rubygems/release-gem
+[rspec]: http://rspec.info/documentation/
+[standardrb]: https://github.com/standardrb/standard

data/vendor/bundle/ruby/3.1.0/gems/diff-lcs-1.6.0/CONTRIBUTORS.md

@@ -0,0 +1,48 @@
+# Contributors
+
+- Austin Ziegler (@halostatue) created diff-lcs.
+
+Thanks to everyone else who has contributed to diff-lcs over the years:
+
+- @ginriki
+- @joshbronson
+- @kevinmook
+- @mckaz
+- Akinori Musha
+- Artem Ignatyev
+- Brandon Fish
+- Baptiste Courtois (@annih)
+- Camille Drapier
+- Cédric Boutillier
+- Gregg Kellogg
+- Jagdeep Singh
+- Jason Gladish
+- Jon Rowe
+- Josef Strzibny
+- Josep (@apuratepp)
+- Josh Bronson
+- Jun Aruga
+- Justin Steele
+- Kenichi Kamiya
+- Kensuke Nagae
+- Kevin Ansfield
+- Koichi Ito
+- Mark Friedgan
+- Masato Nakamura
+- Mark Young
+- Michael Granger
+- Myron Marston
+- Nicolas Leger
+- Oleg Orlov
+- Patrick Linnane
+- Paul Kunysch
+- Pete Higgins
+- Peter Goldstein
+- Peter Wagenet
+- Philippe Lafoucrière
+- Ryan Lovelett
+- Scott Steele
+- Simon Courtois
+- Tien (@tiendo1011)
+- Tomas Jura
+- Vít Ondruch

data/vendor/bundle/ruby/3.1.0/gems/diff-lcs-1.6.0/Contributing.md

@@ -0,0 +1,74 @@
+# Contributing
+
+Contribution to diff-lcs is encouraged in any form: a bug report, a feature
+request, or code contributions. There are a few DOs and DON'Ts for
+
+- DO:
+
+  - Keep the coding style that already exists for any updated Ruby code (support
+    or otherwise). I use [Standard Ruby][standardrb] for linting and formatting.
+
+  - Use thoughtfully-named topic branches for contributions. Rebase your commits
+    into logical chunks as necessary.
+
+  - Use [quality commit messages][qcm].
+
+  - Add your name or GitHub handle to `CONTRIBUTORS.md` and a record in the
+    `CHANGELOG.md` as a separate commit from your main change. (Follow the style
+    in the `CHANGELOG.md` and provide a link to your PR.)
+
+  - Add or update tests, written in [RSpec][rspec], as appropriate.
+
+  - Add or update documentation, as appropriate.
+
+- DO NOT:
+
+  - Modify `VERSION` in `lib/diff/lcs.rb`. When your patch is accepted and a
+    release is made, the version will be updated at that point.
+
+  - Modify `diff-lcs.gemspect`; it is a generated file. (You _may_ use
+    `rake gemspec` to regenerate it if your change involves metadata related to
+    gem itself).
+
+  - Modify the `Gemfile`.
+
+## Test Dependencies
+
+diff-lcs uses Ryan Davis's [Hoe][Hoe] to manage the release process, and it adds
+a number of rake tasks. You will mostly be interested in `rake`, which runs
+tests in the same way that `rake spec` does.
+
+To assist with the installation of the development dependencies for diff-lcs, I
+have provided a Gemfile pointing to the (generated) `diff-lcs.gemspec` file.
+`minitar.gemspec` file. This will permit you to use `bundle install` to install
+the dependencies.
+
+You can run tests with code coverage analysis by running `rake spec:coverage`.
+
+## Workflow
+
+Here's the most direct way to get your work merged into the project:
+
+- Fork the project.
+- Clone your fork (`git clone git://github.com/<username>/diff-lcs.git`).
+- Create a topic branch to contain your change
+  (`git checkout -b my_awesome_feature`).
+- Hack away, add tests. Not necessarily in that order.
+- Make sure everything still passes by running `rake`.
+- If necessary, rebase your commits into logical chunks, without errors.
+- Push the branch up (`git push origin my_awesome_feature`).
+- Create a pull request against halostatue/diff-lcs and describe what your
+  change does and the why you think it should be merged.
+
+### Help Wanted
+
+I want to automated the releases. I am **not** switching from Hoe for release
+management, so the use of [rubygems/release-gem][release-gem] requires some care
+(perhaps by exporting `VERSION=$(rake version)` to the job), but assistance in
+getting this action going for an automated release would be greatly appreciated.
+
+[hoe]: https://github.com/seattlerb/hoe
+[qcm]: http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html
+[release-gem]: https://github.com/rubygems/release-gem
+[rspec]: http://rspec.info/documentation/
+[standardrb]: https://github.com/standardrb/standard

data/vendor/bundle/ruby/3.1.0/gems/{diff-lcs-1.5.1 → diff-lcs-1.6.0}/Manifest.txt

@@ -1,11 +1,14 @@
 .rspec
-Code-of-Conduct.md
+CHANGELOG.md
+CODE_OF_CONDUCT.md
+CONTRIBUTING.md
+CONTRIBUTORS.md
 Contributing.md
-History.md
-License.md
+LICENCE.md
 Manifest.txt
-README.rdoc
+README.md
 Rakefile
+SECURITY.md
 bin/htmldiff
 bin/ldiff
 docs/COPYING.txt

data/vendor/bundle/ruby/3.1.0/gems/diff-lcs-1.6.0/README.md

@@ -0,0 +1,92 @@
+# Diff::LCS
+
+- home :: https://github.com/halostatue/diff-lcs
+- changelog :: https://github.com/halostatue/diff-lcs/blob/main/CHANGELOG.md
+- code :: https://github.com/halostatue/diff-lcs
+- bugs :: https://github.com/halostatue/diff-lcs/issues
+- rdoc :: http://rubydoc.info/github/halostatue/diff-lcs
+
+<a href="https://github.com/halostatue/diff-lcs/actions">
+  <img src="https://github.com/halostatue/diff-lcs/workflows/CI/badge.svg" />
+</a>
+
+## Description
+
+Diff::LCS computes the difference between two Enumerable sequences using the
+McIlroy-Hunt longest common subsequence (LCS) algorithm. It includes utilities
+to create a simple HTML diff output format and a standard diff-like tool.
+
+This is release 1.4.3, providing a simple extension that allows for
+Diff::LCS::Change objects to be treated implicitly as arrays and fixes a number
+of formatting issues.
+
+Ruby versions below 2.5 are soft-deprecated, which means that older versions are
+no longer part of the CI test suite. If any changes have been introduced that
+break those versions, bug reports and patches will be accepted, but it will be
+up to the reporter to verify any fixes prior to release. The next major release
+will completely break compatibility.
+
+## Synopsis
+
+Using this module is quite simple. By default, Diff::LCS does not extend objects
+with the Diff::LCS interface, but will be called as if it were a function:
+
+```ruby
+require 'diff/lcs'
+
+seq1 = %w(a b c e h j l m n p)
+seq2 = %w(b c d e f j k l m r s t)
+
+lcs = Diff::LCS.LCS(seq1, seq2)
+diffs = Diff::LCS.diff(seq1, seq2)
+sdiff = Diff::LCS.sdiff(seq1, seq2)
+seq = Diff::LCS.traverse_sequences(seq1, seq2, callback_obj)
+bal = Diff::LCS.traverse_balanced(seq1, seq2, callback_obj)
+seq2 == Diff::LCS.patch!(seq1, diffs)
+seq1 == Diff::LCS.unpatch!(seq2, diffs)
+seq2 == Diff::LCS.patch!(seq1, sdiff)
+seq1 == Diff::LCS.unpatch!(seq2, sdiff)
+```
+
+Objects can be extended with Diff::LCS:
+
+```ruby
+seq1.extend(Diff::LCS)
+lcs = seq1.lcs(seq2)
+diffs = seq1.diff(seq2)
+sdiff = seq1.sdiff(seq2)
+seq = seq1.traverse_sequences(seq2, callback_obj)
+bal = seq1.traverse_balanced(seq2, callback_obj)
+seq2 == seq1.patch!(diffs)
+seq1 == seq2.unpatch!(diffs)
+seq2 == seq1.patch!(sdiff)
+seq1 == seq2.unpatch!(sdiff)
+```
+
+By requiring 'diff/lcs/array' or 'diff/lcs/string', Array or String will be
+extended for use this way.
+
+Note that Diff::LCS requires a sequenced enumerable container, which means that
+the order of enumeration is both predictable and consistent for the same set of
+data. While it is theoretically possible to generate a diff for an unordered
+hash, it will only be meaningful if the enumeration of the hashes is consistent.
+In general, this will mean that containers that behave like String or Array will
+perform best.
+
+## History
+
+Diff::LCS is a port of Perl's Algorithm::Diff that uses the McIlroy-Hunt longest
+common subsequence (LCS) algorithm to compute intelligent differences between
+two sequenced enumerable containers. The implementation is based on Mario I.
+Wolczko's [Smalltalk version 1.2][smalltalk] (1993) and Ned Konz's Perl version
+[Algorithm::Diff 1.15][perl]. `Diff::LCS#sdiff` and
+`Diff::LCS#traverse_balanced` were originally written for the Perl version by
+Mike Schilli.
+
+The algorithm is described in <em>A Fast Algorithm for Computing Longest Common
+Subsequences</em>, CACM, vol.20, no.5, pp.350-353, May 1977, with a few minor
+improvements to improve the speed. A simplified description of the algorithm,
+originally written for the Perl version, was written by Mark-Jason Dominus.
+
+[smalltalk]: ftp://st.cs.uiuc.edu/pub/Smalltalk/MANCHESTER/manchester/4.0/diff.st
+[perl]: http://search.cpan.org/~nedkonz/Algorithm-Diff-1.15/

data/vendor/bundle/ruby/3.1.0/gems/{diff-lcs-1.5.1 → diff-lcs-1.6.0}/Rakefile

@@ -1,49 +1,14 @@
-# frozen_string_literal: true
-
 require "rubygems"
 require "rspec"
 require "rspec/core/rake_task"
 require "hoe"
+require "rake/clean"
 
-# This is required until https://github.com/seattlerb/hoe/issues/112 is fixed
-class Hoe
-  def with_config
-    config = Hoe::DEFAULT_CONFIG
-
-    rc = File.expand_path("~/.hoerc")
-    homeconfig = load_config(rc)
-    config = config.merge(homeconfig)
-
-    localconfig = load_config(File.expand_path(File.join(Dir.pwd, ".hoerc")))
-    config = config.merge(localconfig)
-
-    yield config, rc
-  end
-
-  def load_config(name)
-    File.exist?(name) ? safe_load_yaml(name) : {}
-  end
-
-  def safe_load_yaml(name)
-    return safe_load_yaml_file(name) if YAML.respond_to?(:safe_load_file)
-
-    data = IO.binread(name)
-    YAML.safe_load(data, permitted_classes: [Regexp])
-  rescue
-    YAML.safe_load(data, [Regexp])
-  end
-
-  def safe_load_yaml_file(name)
-    YAML.safe_load_file(name, permitted_classes: [Regexp])
-  rescue
-    YAML.safe_load_file(name, [Regexp])
-  end
-end
-
-Hoe.plugin :bundler
+Hoe.plugin :cov
 Hoe.plugin :doofus
 Hoe.plugin :gemspec2
-Hoe.plugin :git
+Hoe.plugin :git2
+Hoe.plugin :rubygems
 
 if RUBY_VERSION < "1.9"
   class Array # :nodoc:
@@ -70,13 +35,16 @@ end
 _spec = Hoe.spec "diff-lcs" do
   developer("Austin Ziegler", "halostatue@gmail.com")
 
-  require_ruby_version ">= 1.8"
+  self.history_file = "CHANGELOG.md"
+  self.readme_file = "README.md"
+  self.licenses = ["MIT", "Artistic-1.0-Perl", "GPL-2.0-or-later"]
 
-  self.history_file = "History.md"
-  self.readme_file = "README.rdoc"
-  self.licenses = ["MIT", "Artistic-2.0", "GPL-2.0-or-later"]
+  require_ruby_version ">= 1.8"
 
-  spec_extras[:metadata] = ->(val) { val["rubygems_mfa_required"] = "true" }
+  spec_extras[:metadata] = ->(val) {
+    val["rubygems_mfa_required"] = "true"
+    val["changelog_uri"] = "https://github.com/halostatue/diff-lcs/blob/main/CHANGELOG.md"
+  }
 
   extra_dev_deps << ["hoe", ">= 3.0", "< 5"]
   extra_dev_deps << ["hoe-doofus", "~> 1.0"]

data/vendor/bundle/ruby/3.1.0/gems/diff-lcs-1.6.0/SECURITY.md

@@ -0,0 +1,41 @@
+# diff-lcs Security
+
+## Supported Versions
+
+Security reports are accepted for the most recent major release and the previous
+version for a limited time after the initial major release version. After a
+major release, the previous version will receive full support for six months and
+security support for an additional six months (for a total of twelve months).
+
+Because diff-lcs 1.x supports a wide range of Ruby versions, security reports
+will only be accepted when they can be demonstrated on Ruby 3.1 or higher.
+
+> [!information]
+>
+> There will be a diff-lcs 2.0 released in 2025 which narrows support to modern
+> versions of Ruby only.
+>
+> | Release Date | Support Ends | Security Support Ends |
+> | ------------ | ------------ | --------------------- |
+> | 2025         | +6 months    | +12 months            |
+>
+> If the 2.0.0 release happens on 2025-07-01, regular support for diff-lcs 1.x
+> will end on 2026-12-31 and security support for diff-lcs 1.x will end on
+> 2026-06-30.
+
+## Reporting a Vulnerability
+
+By preference, use the [Tidelift security contact][tidelift]. Tidelift will
+coordinate the fix and disclosure.
+
+Alternatively, Send an email to [diff-lcs@halostatue.ca][email] with the text
+`Diff::LCS` in the subject. Emails sent to this address should be encrypted
+using [age][age] with the following public key:
+
+```
+age1fc6ngxmn02m62fej5cl30lrvwmxn4k3q2atqu53aatekmnqfwumqj4g93w
+```
+
+[tidelift]: https://tidelift.com/security
+[email]: mailto:diff-lcs@halostatue.ca
+[age]: https://github.com/FiloSottile/age

data/vendor/bundle/ruby/3.1.0/gems/{diff-lcs-1.5.1 → diff-lcs-1.6.0}/docs/artistic.txt

@@ -122,6 +122,6 @@ products derived from this software without specific prior written permission.
 
 10. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
 IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
-WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 
 				The End

data/vendor/bundle/ruby/3.1.0/gems/{diff-lcs-1.5.1 → diff-lcs-1.6.0}/lib/diff/lcs/change.rb

@@ -4,7 +4,7 @@
 # addition of an element from either the old or the new sequenced
 # enumerable.
 class Diff::LCS::Change
-  IntClass = 1.class # Fixnum is deprecated in Ruby 2.4 # rubocop:disable Naming/ConstantName
+  IntClass = 1.class # Fixnum is deprecated in Ruby 2.4 # standard:disable Naming/ConstantName
 
   # The only actions valid for changes are '+' (add), '-' (delete), '='
   # (no change), '!' (changed), '<' (tail changes from first sequence), or

data/vendor/bundle/ruby/3.1.0/gems/{diff-lcs-1.5.1 → diff-lcs-1.6.0}/lib/diff/lcs/htmldiff.rb

@@ -5,7 +5,9 @@ require "cgi"
 # Produce a simple HTML diff view.
 class Diff::LCS::HTMLDiff
   class << self
+    # standard:disable ThreadSafety/ClassAndModuleAttributes
     attr_accessor :can_expand_tabs # :nodoc:
+    # standard:enable ThreadSafety/ClassAndModuleAttributes
   end
   self.can_expand_tabs = true
 

data/vendor/bundle/ruby/3.1.0/gems/{diff-lcs-1.5.1 → diff-lcs-1.6.0}/lib/diff/lcs/hunk.rb

@@ -22,11 +22,13 @@ class Diff::LCS::Hunk
     end
 
     if String.method_defined?(:encoding)
-      @preferred_data_encoding = data_old.fetch(0) { data_new.fetch(0, "") }.encoding
+      @preferred_data_encoding = data_old.fetch(0) { data_new.fetch(0) { "" } }.encoding
     end
 
     @data_old = data_old
     @data_new = data_new
+    @old_empty = data_old.empty? || (data_old.size == 1 && data_old[0].empty?)
+    @new_empty = data_new.empty? || (data_new.size == 1 && data_new[0].empty?)
 
     before = after = file_length_difference
     after += @blocks[0].diff_size
@@ -79,14 +81,12 @@ class Diff::LCS::Hunk
     old_size = @data_old.size
 
     add_end =
-      if (@end_old + context) > old_size
-        old_size - @end_old
+      if (@end_old + context) >= old_size
+        old_size - @end_old - 1
       else
         context
       end
 
-    add_end = @max_diff_size if add_end >= old_size
-
     @end_old += add_end
     @end_new += add_end
   end
@@ -131,11 +131,16 @@ class Diff::LCS::Hunk
 
   # Note that an old diff can't have any context. Therefore, we know that
   # there's only one block in the hunk.
-  def old_diff(_last = false)
+  def old_diff(last = false)
     warn "Expecting only one block in an old diff hunk!" if @blocks.size > 1
 
     block = @blocks[0]
 
+    if last
+      old_missing_newline = !@old_empty && missing_last_newline?(@data_old)
+      new_missing_newline = !@new_empty && missing_last_newline?(@data_new)
+    end
+
     # Calculate item number range. Old diff range is just like a context
     # diff range, except the ranges are on one line with the action between
     # them.
@@ -146,19 +151,22 @@ class Diff::LCS::Hunk
       @data_old[@start_old..@end_old].each { |e| s << encode("< ") + e.chomp + encode("\n") }
     end
 
+    s << encode("\\n") if old_missing_newline && !new_missing_newline
     s << encode("---\n") if block.op == "!"
 
     unless block.insert.empty?
       @data_new[@start_new..@end_new].each { |e| s << encode("> ") + e.chomp + encode("\n") }
     end
 
+    s << encode("\\n") if new_missing_newline && !old_missing_newline
+
     s
   end
   private :old_diff
 
   def unified_diff(last = false)
     # Calculate item number range.
-    s = encode("@@ -#{unified_range(:old, last)} +#{unified_range(:new, last)} @@\n")
+    s = encode("@@ -#{unified_range(:old)} +#{unified_range(:new)} @@\n")
 
     # Outlist starts containing the hunk of the old file. Removing an item
     # just means putting a '-' in front of it. Inserting an item requires
@@ -178,8 +186,8 @@ class Diff::LCS::Hunk
     last_block = blocks[-1]
 
     if last
-      old_missing_newline = missing_last_newline?(@data_old)
-      new_missing_newline = missing_last_newline?(@data_new)
+      old_missing_newline = !@old_empty && missing_last_newline?(@data_old)
+      new_missing_newline = !@new_empty && missing_last_newline?(@data_new)
     end
 
     @blocks.each do |block|
@@ -213,8 +221,8 @@ class Diff::LCS::Hunk
 
   def context_diff(last = false)
     s = encode("***************\n")
-    s << encode("*** #{context_range(:old, ",", last)} ****\n")
-    r = context_range(:new, ",", last)
+    s << encode("*** #{context_range(:old, ",")} ****\n")
+    r = context_range(:new, ",")
 
     if last
       old_missing_newline = missing_last_newline?(@data_old)
@@ -273,14 +281,24 @@ class Diff::LCS::Hunk
   end
   private :context_diff
 
-  def ed_diff(format, _last = false)
+  def ed_diff(format, last)
     warn "Expecting only one block in an old diff hunk!" if @blocks.size > 1
+    if last
+      # ed script doesn't support well incomplete lines
+      warn "<old_file>: No newline at end of file\n" if !@old_empty && missing_last_newline?(@data_old)
+      warn "<new_file>: No newline at end of file\n" if !@new_empty && missing_last_newline?(@data_new)
+
+      if @blocks[0].op == "!"
+        return +"" if @blocks[0].changes[0].element == @blocks[0].changes[1].element + "\n"
+        return +"" if @blocks[0].changes[0].element + "\n" == @blocks[0].changes[1].element
+      end
+    end
 
     s =
       if format == :reverse_ed
-        encode("#{ED_DIFF_OP_ACTION[@blocks[0].op]}#{context_range(:old, ",")}\n")
+        encode("#{ED_DIFF_OP_ACTION[@blocks[0].op]}#{context_range(:old, " ")}\n")
       else
-        encode("#{context_range(:old, " ")}#{ED_DIFF_OP_ACTION[@blocks[0].op]}\n")
+        encode("#{context_range(:old, ",")}#{ED_DIFF_OP_ACTION[@blocks[0].op]}\n")
       end
 
     unless @blocks[0].insert.empty?
@@ -295,7 +313,7 @@ class Diff::LCS::Hunk
 
   # Generate a range of item numbers to print. Only print 1 number if the
   # range has only one item in it. Otherwise, it's 'start,end'
-  def context_range(mode, op, last = false)
+  def context_range(mode, op)
     case mode
     when :old
       s, e = (@start_old + 1), (@end_old + 1)
@@ -303,9 +321,6 @@ class Diff::LCS::Hunk
       s, e = (@start_new + 1), (@end_new + 1)
     end
 
-    e -= 1 if last
-    e = 1 if e.zero?
-
     (s < e) ? "#{s}#{op}#{e}" : e.to_s
   end
   private :context_range
@@ -313,18 +328,19 @@ class Diff::LCS::Hunk
   # Generate a range of item numbers to print for unified diff. Print number
   # where block starts, followed by number of lines in the block
   # (don't print number of lines if it's 1)
-  def unified_range(mode, last)
+  def unified_range(mode)
     case mode
     when :old
+      return "0,0" if @old_empty
       s, e = (@start_old + 1), (@end_old + 1)
     when :new
+      return "0,0" if @new_empty
       s, e = (@start_new + 1), (@end_new + 1)
     end
 
-    length = e - s + (last ? 0 : 1)
+    length = e - s + 1
 
-    first = (length < 2) ? e : s # "strange, but correct"
-    (length <= 1) ? first.to_s : "#{first},#{length}"
+    (length <= 1) ? e.to_s : "#{s},#{length}"
   end
   private :unified_range