github_diff_parser 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 26631fa3bed73629263398b5a5956aeb3f680ecdc3d990a86ff3c68cbb4e93fc
+  data.tar.gz: 1268de53cf2e150fb1667955c0b4b5b24e045c9b413c81441310f98f4c564046
+SHA512:
+  metadata.gz: b12c80f92786394271ec785c6b22db9111d20c17c3ee859b23cae2f54a9ef757b01d1cac2666df3b512eeae88524e37646efe98ba51ddcf94c3188d87bc7d42c
+  data.tar.gz: 53d34cc940811a050a26f214ab18db26acd638adaf26c717a740977cf01394682f0c3b165843449c09587b75dc54cf8e1dcc1d9419b1bda3794b751ddedd6fc2

data/.rubocop.yml

@@ -0,0 +1,9 @@
+inherit_gem:
+  rubocop-shopify: rubocop.yml
+
+AllCops:
+  NewCops: disable
+  SuggestExtensions: false
+
+Style/Documentation:
+  Enabled: false

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,84 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at chin.edouard@gmail.com. All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior,  harassment of an individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,
+available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in github_diff_parser.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "minitest", "~> 5.0"

data/Gemfile.lock

@@ -0,0 +1,47 @@
+PATH
+  remote: .
+  specs:
+    github_diff_parser (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    byebug (11.1.3)
+    minitest (5.15.0)
+    parallel (1.22.1)
+    parser (3.1.2.0)
+      ast (~> 2.4.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.3.0)
+    rexml (3.2.5)
+    rubocop (1.27.0)
+      parallel (~> 1.10)
+      parser (>= 3.1.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.16.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.17.0)
+      parser (>= 3.1.1.0)
+    rubocop-shopify (2.5.0)
+      rubocop (~> 1.25)
+    ruby-progressbar (1.11.0)
+    unicode-display_width (2.1.0)
+
+PLATFORMS
+  x86_64-darwin-20
+  x86_64-linux
+
+DEPENDENCIES
+  byebug
+  github_diff_parser!
+  minitest (~> 5.0)
+  rake (~> 13.0)
+  rubocop-shopify
+
+BUNDLED WITH
+   2.2.32

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Edouard CHIN
+
+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,60 @@
+### GithubDiffParser
+
+A Ruby Gem to parse the output of a Git Diff with an emphasises on actual line numbers **before** and **after** the changes apply. This gem matches the information you get when reviewing a Pull Request on GitHub in split mode.
+
+## Usage
+
+#### Given this diff
+
+```diff
+diff --git a/actionmailer/lib/action_mailer/railtie.rb b/actionmailer/lib/action_mailer/railtie.rb
+index 70c4937c418b2..bd87fe1057f90 100644
+--- a/actionmailer/lib/action_mailer/railtie.rb
++++ b/actionmailer/lib/action_mailer/railtie.rb
+@@ -23,7 +23,6 @@ class Railtie < Rails::Railtie # :nodoc:
+       options.stylesheets_dir ||= paths["public/stylesheets"].first
+       options.show_previews = Rails.env.development? if options.show_previews.nil?
+       options.cache_store ||= Rails.cache
+-      options.smtp_settings ||= {}
+
+       if options.show_previews
+         options.preview_path ||= defined?(Rails.root) ? "#{Rails.root}/test/mailers/previews" : nil
+@@ -46,9 +45,15 @@ class Railtie < Rails::Railtie # :nodoc:
+           self.delivery_job = delivery_job.constantize
+         end
+
+-        if smtp_timeout = options.delete(:smtp_timeout)
+-          options.smtp_settings[:open_timeout] ||= smtp_timeout
+-          options.smtp_settings[:read_timeout] ||= smtp_timeout
++        if options.smtp_settings
++          self.smtp_settings = options.smtp_settings
++        end
++
++        smtp_timeout = options.delete(:smtp_timeout)
++
++        if self.smtp_settings && smtp_timeout
++          self.smtp_settings[:open_timeout] ||= smtp_timeout
++          self.smtp_settings[:read_timeout] ||= smtp_timeout
+         end
+
+         options.each { |k, v| send("#{k}=", v) }
+
+```
+
+```ruby
+parsed_diffs = GithubDiffParser.parse(diff) # Returns an array of `GithubDiffParser:Diff` objects. Each object corresponding to a diff section in the Git Diff. In this example we only have one.
+
+parsed_diffs.deleted_mode? # If this diff deleting a file. No in this example
+parsed_diffs.new_mode? # If this diff adding a  new file. No in this example
+parsed_diffs.rename_mode? # If this diff renaming or moving a file. No in this example
+
+hunks = parsed_diffs.hunks # Returns an array of `GithubDiffParser::Hunk` objects. In this example we have two.
+lines = parsed_diffs.hunks.first.lines # Returns an array of `GithubDiffParser::Line` objects. Each object represent a line that belongs to the hunk. A line in a git diff can be either a contextual, addition or a deletion line.
+
+lines.first.previous_number # Return the line number before the changes. In this example it's 23
+lines.first.current_number # Return the line number after the changes. In this example it's 23
+lines.first.patch_position # Return the position of the line in this patch. In this example it's 1
+lines.first.contextual?  # Returns true, the first line is a contextual line
+```
+
+See the API documentation for more example.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "github_diff_parser"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/github_diff_parser/diff.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module GithubDiffParser
+  class Diff
+    # @return [String] (see #initialize)
+    attr_reader :previous_filename
+
+    # @return [String] (see #initialize)
+    attr_reader :new_filename
+
+    # @return [Array<GithubDiffParser::Hunk>] the hunks belonging to this diff
+    attr_reader :hunks
+
+    # @private
+    attr_writer :file_mode
+
+    # @param previous_filename [String] the original filename. Represented by "diff --git /a filename"
+    # @param new_filename [String]      the new filename. Represented by "diff --git /b filename"
+    def initialize(previous_filename, new_filename)
+      @previous_filename = previous_filename
+      @new_filename = new_filename
+      @hunks = []
+    end
+
+    # Add a Git Hunk to the diff.
+    #
+    # @param previous_lino_start [String] the starting line number of the hunk for the original file
+    # @param new_lino_start [String] the starting line number of the hunk for the new file
+    #
+    # @example Representation of the previous_lino_start and new_lino_start in a Git Diff
+    #   @@ -6,5 +6,6 @@ def test1 # => The first 6 is the previous_lino_start, the second is the new_lino_start
+    def add_hunk(previous_lino_start, new_lino_start)
+      hunks << Hunk.new(previous_lino_start, new_lino_start)
+    end
+
+    # Add a line belonging to the previously processed Git Hunk.
+    #
+    # @param line_content [String] the line content itself
+    # @param type [Symbol] the type of the line. Can be either :addition, :deletion or :contextual
+    # @raise [GithubDiffParser::InvalidDiff] if we are trying to add a line but the Diff doesn't contain any Hunk.
+    def add_line(line_content, type:)
+      last_hunk = hunks.last
+      raise InvalidDiff, "Couldn't find the Git diff Range Header." unless last_hunk
+
+      patch_position = hunks.flat_map(&:lines).count + hunks.count
+
+      last_hunk.add_line(line_content, patch_position, type: type)
+    end
+
+    # Check if this Diff is set to deleted mode.
+    #
+    # @example When the diff is set to deleted mode
+    #   diff --git a/package.json b/package.json
+    #   deleted file mode 100644                  # => This indicates the diff is in deletion mode.
+    #   index 3ffb801..0000000
+    #   --- a/package.json
+    #   +++ /dev/null
+    #   @@ -1,11 +0,0 @@
+    #   -{
+    #
+    # @return [Boolean]
+    def deleted_mode?
+      @file_mode == "deleted"
+    end
+
+    # Check if this Diff is set to new mode.
+    #
+    # @example When the diff is set to new mode
+    #   diff --git a/blabla.rb b/blabla.rb
+    #   new file mode 100644                     # => This indicate the diff is in new mode.
+    #   index 0000000..d3dfbe4
+    #   --- /dev/null
+    #   +++ b/blabla.rb
+    #   @@ -0,0 +1,10 @@
+    #   +Hello World
+    #
+    # @return [Boolean]
+    def new_mode?
+      @file_mode == "new"
+    end
+
+    # Check if this Diff is set to rename mode.
+    #
+    # @example When the diff is set to rename mode
+    #   diff --git a/blabla.rb b/app/my_file.rb
+    #   similarity index 100%
+    #   rename from blabla.rb
+    #   rename to app/my_file.rb
+    #
+    # @return [Boolean]
+    def rename_mode?
+      previous_filename != new_filename
+    end
+
+    # A utility method that returns the current number of a line who might not be present in the diff.
+    # This is useful if you need to keep track of the updated line numbers in a file for every changes.
+    #
+    # @param line_number [Integer]
+    #
+    # @return [Integer]
+    def previous_line_number_is_now(line_number)
+      return line_number unless line_shifted?(line_number)
+
+      applicable_hunk = last_applicable_hunk_for_line(line_number)
+      line = applicable_hunk.find_previous_line(line_number)
+
+      if line
+        line.current_number
+      else
+        line_number + last_line_offset(applicable_hunk)
+      end
+    end
+
+    private
+
+    # Check if a line was shifted. A line is considered shifted if its number is superior to the first hunk's start
+    # range.
+    #
+    # @param line_number [Integer]
+    #
+    # @return [Boolean]
+    def line_shifted?(line_number)
+      first_hunk = hunks.first
+
+      line_number > first_hunk.new_file_start_line
+    end
+
+    # Find the last hunk that shifts the line. We need the last because we know it's the one that will shift the line
+    # the most.
+    #
+    # @param line_number [Integer]
+    #
+    # @return [GithubDiffParser::Hunk]
+    def last_applicable_hunk_for_line(line_number)
+      hunks.reverse_each.find do |hunk|
+        line_number >= hunk.previous_file_start_line
+      end
+    end
+
+    # Calculate the number difference of the last line. This method is called when we can't find the desired line number
+    # in the Hunk, which means the line we are searching for is not part of the diff.
+    #
+    # @param hunk [GithubDiffParser::Hunk]
+    #
+    # @return [Integer]
+    def last_line_offset(hunk)
+      last_line = hunk.lines.last
+
+      last_line.current_number - last_line.previous_number
+    end
+  end
+end

data/lib/github_diff_parser/hunk.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module GithubDiffParser
+  class Hunk
+    # @return [Array<GithubDiffParser::Line>] all the contextual, added and removed lines belonging to this Hunk.
+    attr_reader :lines
+
+    # @return [Integer] (see #initialize)
+    attr_reader :previous_file_start_line
+
+    # @return [Integer] (see #initialize)
+    attr_reader :new_file_start_line
+
+    # @param previous_file_start_line [String] the starting line number of the hunk for the original file
+    # @param new_file_start_line [String] the starting line number of the hunk for the new file
+    #
+    # @example Representation of the previous_file_start_line and new_file_start_line in a Git Diff
+    #   @@ -6,5 +6,6 @@ def test1 # => The first 6 is the previous_file_start_line the second is the new_file_start_line
+    def initialize(previous_file_start_line, new_file_start_line)
+      @previous_file_start_line = Integer(previous_file_start_line)
+      @new_file_start_line = Integer(new_file_start_line)
+      @lines = []
+    end
+
+    # Add a line to this Hunk
+    #
+    # @param line_content [String] the line content itself
+    # @param patch_position [Integer] the the position of this line in the patch
+    # @param type [Symbol] the type of the line. Can be either :addition, :deletion or :contextual
+    def add_line(line_content, patch_position, type:)
+      case type
+      when :deletion
+        number = @previous_file_start_line + contextual_lines.count + deletion_lines.count
+        line = Line.new(line_content, number, nil, patch_position, type)
+      when :addition
+        number = @new_file_start_line + contextual_lines.count + addition_lines.count
+        line = Line.new(line_content, nil, number, patch_position, type)
+      when :contextual
+        before = @previous_file_start_line + contextual_lines.count + deletion_lines.count
+        now =  @new_file_start_line + contextual_lines.count + addition_lines.count
+        line = Line.new(line_content, before, now, patch_position, type)
+      end
+
+      @lines << line
+    end
+
+    # Get all the contextual lines for this Hunk.
+    #
+    # @return [Array<GithubDiffParser::Line>]
+    def contextual_lines
+      @lines.select(&:contextual?)
+    end
+
+    # Get all the addition lines for this Hunk.
+    #
+    # @return [Array<GithubDiffParser::Line>]
+    def addition_lines
+      @lines.select(&:addition?)
+    end
+
+    # Get all the deletion lines for this Hunk.
+    #
+    # @return [Array<GithubDiffParser::Line>]
+    def deletion_lines
+      @lines.select(&:deletion?)
+    end
+
+    # Find a line in the Hunk by it's previous line number.
+    #
+    # @param line_number [Integer]
+    #
+    # @return [GithubDiffParser::Line, nil]
+    def find_previous_line(line_number)
+      lines.find { |line| line.previous_number == line_number }
+    end
+
+    # Find a line in the Hunk by it's current line number.
+    #
+    # @param line_number [Integer]
+    #
+    # @return [GithubDiffParser::Line, nil]
+    def find_current_line(line_number)
+      lines.find { |line| line.current_number == line_number }
+    end
+  end
+end

data/lib/github_diff_parser/line.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module GithubDiffParser
+  class Line
+    # @return [String] the line content itself
+    attr_reader :content
+
+    # @return [Integer] the previous line number before the changes. This match
+    #   the number shown by GitHub on the left side when reviewing a Pull Request in split mode.
+    attr_reader :previous_number
+
+    # @return [Integer] the current line number before the changes. This match
+    #   the number shown by GitHub on the right side when reviewing a Pull Request in split mode.
+    attr_reader :current_number
+
+    # @return [Integer] the position of this line in the patch. When using the GitHub API and
+    #   you want to write a comment on a given line change, you'll use this.
+    attr_reader :patch_position
+
+    # @param content [String] the line content itself
+    # @param previous_number [Ingeter] (see #previous_number)
+    # @param current_number [Ingeter] (see #current_number)
+    # @param patch_position [Ingeter] (see #patch_position)
+    # @param type [Symbol] the type of the line. Can be either :addition, :deletion or :contextual
+    def initialize(content, previous_number, current_number, patch_position, type)
+      @content = content
+      @previous_number = previous_number
+      @current_number = current_number
+      @patch_position = patch_position
+      @type = type
+    end
+
+    # Check if this line is a contextual line. A contextual line in a Git diff always start with a space (" ")
+    #
+    # @return [Boolean]
+    def contextual?
+      @type == :contextual
+    end
+
+    # Check if this line is an addition line. An addition line in a Git diff always start with a plus ("+")
+    #
+    # @return [Boolean]
+    def addition?
+      @type == :addition
+    end
+
+    # Check if this line is a deletion line. A deletion line in a Git diff always start with a minus ("-")
+    #
+    # @return [Boolean]
+    def deletion?
+      @type == :deletion
+    end
+  end
+end

data/lib/github_diff_parser/parser.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module GithubDiffParser
+  class Parser
+    # @param git_diff [String] the Git Diff output
+    def initialize(git_diff)
+      @git_diff = git_diff
+      @parsed_diffs = []
+      @current_diff = nil
+    end
+
+    # Parse and process the Git Diff output.
+    #
+    # @return [Array<GithubDiffParser::Diff>]
+    # @raise [GithubDiffParser::InvalidDiff] if the Diff output is malformatted
+    def process
+      @git_diff.each_line do |line|
+        case line
+        when Regexes::DIFF_HEADER
+          process_new_diff(Regexp.last_match)
+        when Regexes::MODE_HEADER
+          process_diff_file_mode(Regexp.last_match)
+        when Regexes::ORIGINAL_FILE_HEADER, Regexes::NEW_FILE_HEADER
+          validate_diff
+        when Regexes::RANGE_HEADER
+          add_hunk_to_diff(Regexp.last_match)
+        when Regexes::LINE_DIFF
+          add_line_to_hunk(Regexp.last_match)
+        end
+      end
+
+      validate_diff
+
+      @parsed_diffs << @current_diff
+    end
+
+    private
+
+    # Called when encountering a `diff --git a/file b/file` in the Git Diff output.
+    # Worth to note that a Git Diff output will most likely contain multiple diff section. Each will
+    # be represented by a new GithubDiffParser::Diff object.
+    #
+    # @param match_data [MatchData]
+    def process_new_diff(match_data)
+      @parsed_diffs << @current_diff if @current_diff
+
+      @current_diff = Diff.new(match_data[:previous_filename], match_data[:new_filename])
+    end
+
+    # Called when encountering a `new file mode 100644` or `delete file mode 100644` in the Git Diff output.
+    #
+    # @param match_data [MatchData]
+    #
+    # @raise [GithubDiffParser::InvalidDiff] if the parser didn't process the `diff --git` header first.
+    def process_diff_file_mode(match_data)
+      validate_diff
+
+      @current_diff.file_mode = match_data[:file_mode]
+    end
+
+    # Called when encountering a `@@ -0,0 +1,10 @@` in the Git Diff output.
+    #
+    # @param match_data [MatchData]
+    #
+    # @raise [GithubDiffParser::InvalidDiff] if the parser didn't process the `diff --git` header first.
+    def add_hunk_to_diff(match_data)
+      validate_diff
+
+      @current_diff.add_hunk(match_data[:previous_lino_start], match_data[:new_lino_start])
+    end
+
+    # Called when encountering a `-text` or `+text` or ` text` in the Git Diff output.
+    #
+    # @param match_data [MatchData]
+    #
+    # @raise [GithubDiffParser::InvalidDiff] if the parser didn't process the `diff --git` header first.
+    def add_line_to_hunk(match_data)
+      validate_diff
+
+      @current_diff.add_line(match_data[:line], type: map_line_type(match_data[:type]))
+    end
+
+    # Validate that the Git Diff output contains a `diff --git header` before attempting to add Hunk or Lines
+    #
+    # @raise [GithubDiffParser::InvalidDiff]
+    def validate_diff
+      message = "Couldn't find the Git diff header. A valid git diff has to start with 'diff --git'"
+
+      raise InvalidDiff, message if @current_diff.nil?
+    end
+
+    # Map the type of the line.
+    #
+    # @param token [String] either '+', '-' or ' '
+    #
+    # @raise [GithubDiffParser::InvalidDiff] if a line starts with a unknown token
+    def map_line_type(token)
+      mapping = { "+" => :addition, "-" => :deletion, " " => :contextual }
+
+      mapping.fetch(token)
+    rescue KeyError
+      raise InvalidDiff, "Unexpected token: '#{token}' found at beginning of line. Expecting '+', '-', ' '"
+    end
+  end
+end

data/lib/github_diff_parser/regexes.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module GithubDiffParser
+  module Regexes
+    # This Regexp is used to match the very first line of a diff.
+    #
+    # @example Possible header on a diff.
+    #
+    #   diff --git a/app/my_file.rb b/app/my_file.rb    <-- Match this line -->
+    #   index d3dfbe4..ac0e8b3 100644
+    #   --- a/app/my_file.rb
+    #   +++ b/app/my_file.rb
+    #   @@ -5,6 +5,6 @@ def test1
+    DIFF_HEADER = %r{
+      \A                                               # Start of line
+      diff\s--git\s                                    # Match 'diff --git '
+      a/(?<previous_filename>.*?)\s                    # Match 'a/filename.json ' and capture the "filename.json" part
+      b/(?<new_filename>.*?)                           # Match 'b/filename.json ' and capture the "filename.json" part
+      \Z                                               # End of line
+    }x
+
+    # This Regexp is used to match the header containing the original filename.
+    #
+    # @example Possible header on a diff.
+    #
+    #   diff --git a/app/my_file.rb b/app/my_file.rb
+    #   index d3dfbe4..ac0e8b3 100644
+    #   --- a/app/my_file.rb                            <-- Match this line -->
+    #   +++ b/app/my_file.rb
+    #   @@ -5,6 +5,6 @@ def test1
+    ORIGINAL_FILE_HEADER = %r{
+      \A                                               # Start of line
+      ---\s.*                                          # Match '--- a/filename.rb' and capture the "filename.rb" part
+      \Z                                               # End of line
+    }x
+
+    # This Regexp is used to match the header containing the new filename.
+    #
+    # @example Possible header on a diff.
+    #
+    #   diff --git a/app/my_file.rb b/app/my_file.rb
+    #   index d3dfbe4..ac0e8b3 100644
+    #   --- a/app/my_file.rb
+    #   +++ b/app/my_file.rb                            <-- Match this line -->
+    #   @@ -5,6 +5,6 @@ def test1
+    NEW_FILE_HEADER = %r{
+      \A                                               # Start of line
+      \+\+\+\s.*                                       # Match '+++ b/filename.rb' and capture the "filename.rb" part
+      \Z                                               # End of line
+    }x
+
+    # This Regexp is used to match the header indicating when a new file is added or removed.
+    #
+    # @example Possible header on a diff when adding a file.
+    #
+    #   diff --git a/blabla.rb b/blabla.rb
+    #   new file mode 100644                           <-- Match this line -->
+    #   index 0000000..d3dfbe4
+    #   --- /dev/null
+    #   +++ b/blabla.rb
+    #   @@ -0,0 +1,10 @@
+    #
+    # @example Possible header on a diff when deleting a file.
+    #
+    #   diff --git a/package.json b/package.json
+    #   deleted file mode 100644                      <-- Match this line -->
+    #   index 3ffb801..0000000
+    #   --- a/package.json
+    #   +++ /dev/null
+    #   @@ -1,11 +0,0 @@
+    MODE_HEADER = %r{
+      \A                                               # Start of line
+      (?<file_mode>new|deleted)                        # Match 'new' or 'deleted' and capture the group
+      \sfile\smode\s\d+                                # Match ' file mode 100655'
+      \Z                                               # End of line
+    }x
+
+    # This Regexp is used to match the hunk's range of a diff.
+    #
+    # @example Possible hunk range on a diff.
+    #
+    #   diff --git a/app/my_file.rb b/app/my_file.rb
+    #   index d3dfbe4..ac0e8b3 100644
+    #   --- a/app/my_file.rb
+    #   +++ b/app/my_file.rb
+    #   @@ -5,6 +5,6 @@ def test1                     <-- Match this line -->
+    #
+    # @example Alternative match
+    #
+    #   diff --git a/app/my_file.rb b/app/my_file.rb
+    #   index d3dfbe4..ac0e8b3 100644
+    #   --- a/app/my_file.rb
+    #   +++ b/app/my_file.rb
+    #   @@ -5 +5 @@ def test1                         <-- Match this line -->
+    RANGE_HEADER = %r{
+      \A                                               # Start of line
+      @@\s                                             # Match '@@ '
+      -(?<previous_lino_start>\d+)(,\d+)?\s            # Match '-1,11 ' or match '-1 ' and capture the '1' part
+      \+(?<new_lino_start>\d+)(,\d+)?\s                # Match '+1,34 ' or match '+1 ' and capture the '1' part
+      @@.*                                             # Match '@@ Any text'
+      \Z                                               # End of line
+    }x
+
+    # This Regexp is used to match added lines.
+    #
+    # @example Diff when a line is added.
+    #
+    #   diff --git a/app/my_file.rb b/app/my_file.rb
+    #   index d3dfbe4..03d99f2 100644
+    #   --- a/app/my_file.rb
+    #   +++ b/app/my_file.rb
+    #   @@ -6,5 +6,6 @@ def test1
+    #
+    #      def test2
+    #        "This file is just added"
+    #   +    "This is a new line"                   <-- Match this line -->
+    #      end
+    #    end
+    #
+    # @example Diff when a line is removed.
+    #
+    #   diff --git a/app/my_file.rb b/app/my_file.rb
+    #   index 03d99f2..d3dfbe4 100644
+    #   --- a/app/my_file.rb
+    #   +++ b/app/my_file.rb
+    #   @@ -6,6 +6,5 @@ def test1
+    #
+    #      def test2
+    #        "This file is just added"
+    #   -    "This is a new line"                      <-- Match this line -->
+    #      end
+    #    end
+    #
+    # @example Diff containing a contextual line.
+    #
+    #   diff --git a/app/my_file.rb b/app/my_file.rb
+    #   index 03d99f2..d3dfbe4 100644
+    #   --- a/app/my_file.rb
+    #   +++ b/app/my_file.rb
+    #   @@ -6,6 +6,5 @@ def test1
+    #                                                  <-- Match this line -->
+    #      def test2                                   <-- Match this line -->
+    #        "This file is just added"                 <-- Match this line -->
+    #   -    "This is a new line"
+    #      end                                         <-- Match this line -->
+    #    end                                           <-- Match this line -->
+    LINE_DIFF = %r{
+      \A                                               # Start of line
+      (?<type>                                         # Named group <type>
+        \+                                             # Match '+' (Considered as an addition line)
+        |                                              # OR
+        -                                              # Match '-' (Considered as a deletion line)
+        |                                              # OR
+        \s                                             # Match empty space ' ' (Considered as a contextual line)
+      )                                                # End of named group
+      (?<line>.*)                                      # Match the content of the line itself
+      \Z                                               # End of line
+    }x
+  end
+end

data/lib/github_diff_parser/version.rb

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

data/lib/github_diff_parser.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "github_diff_parser/version"
+
+module GithubDiffParser
+  InvalidDiff = Class.new(ArgumentError)
+
+  autoload :Parser,  "github_diff_parser/parser"
+  autoload :Regexes, "github_diff_parser/regexes"
+  autoload :Diff,    "github_diff_parser/diff"
+  autoload :Hunk,    "github_diff_parser/hunk"
+  autoload :Line,    "github_diff_parser/line"
+
+  extend self
+
+  # Parse the output of a unified Git Diff.
+  #
+  # @param string [String] the output of a Git Diff
+  # @raise [GithubDiffParser::InvalidDiff] if the +string+ is not
+  #   a correctly formatter Git Diff.
+  #
+  # @return [Array<GitubDiffParser::Diff>]
+  def parse(string)
+    Parser.new(string).process
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: github_diff_parser
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Edouard CHIN
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-04-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-shopify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Ruby Gem to parse unified git diff output.
+email:
+- chin.edouard@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/github_diff_parser.rb
+- lib/github_diff_parser/diff.rb
+- lib/github_diff_parser/hunk.rb
+- lib/github_diff_parser/line.rb
+- lib/github_diff_parser/parser.rb
+- lib/github_diff_parser/regexes.rb
+- lib/github_diff_parser/version.rb
+homepage: https://github.com/Edouard-chin/git_diff_parser
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/Edouard-chin/git_diff_parser
+  source_code_uri: https://github.com/Edouard-chin/git_diff_parser
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.32
+signing_key:
+specification_version: 4
+summary: A Ruby Gem to parse unified git diff output.
+test_files: []