package patdiff

  1. Overview
  2. Docs
File Diff using the Patience Diff algorithm

Install 

dune-project
 Dependency

github.com Readme Changelog MIT License Edit opam file Versions (8)

Authors

  1. J
    Jane Street Group, LLC

Maintainers

  1. J
    Jane Street developers

Sources

patdiff-v0.12.0.tar.gz
sha256=718f30ca6e567266d2dec5c040e5e6b56657a2adcde1d2367d9dca38c814786a
md5=c7f69086b9b2c5a0fbb43b1ef89162b1

doc/patdiff.lib/Patdiff_lib/Patdiff_core/index.html

Module Patdiff_lib.Patdiff_core

module Format : module type of struct include Patdiff_format end

Patdiff_format is the home of all the internal representations of the formatting that will be applied to the diff. ie. prefixes, suffixes, & valid styles.

module Output : module type of struct include Output_mode end
val default_context : int
val default_line_big_enough : int
val default_word_big_enough : int
val diff : context:int -> line_big_enough:int -> keep_ws:bool -> prev:string array -> next:string array -> string Patdiff_lib.Import.Patience_diff.Hunk.t list

diff ~context ~keep_ws ~prev ~next uses Patience_diff.String to get a list of hunks describing the comparison between prev and next.

val remove_ws : string -> string
val refine : rules:Format.Rules.t -> produce_unified_lines:bool -> output:Output.t -> keep_ws:bool -> split_long_lines:bool -> interleave:bool -> word_big_enough:int -> string Patdiff_lib.Import.Patience_diff.Hunk.t list -> string Patdiff_lib.Import.Patience_diff.Hunk.t list

refine hunks maps each Range.Replace (prev, next) in hunks to a diff of prev against next.

val explode : string array -> keep_ws:bool -> [ `Newline of int * string option | `Word of string ] array
val print : prev_file:string -> next_file:string -> rules:Format.Rules.t -> output:Output.t -> location_style:Format.Location_style.t -> string Patdiff_lib.Import.Patience_diff.Hunk.t list -> unit

Print a hunk list, usually from diff or refine

val output_to_string : ?print_global_header:bool -> file_names:(string * string) -> rules:Format.Rules.t -> output:Output.t -> location_style:Format.Location_style.t -> string Patdiff_lib.Import.Patience_diff.Hunk.t list -> string

Output a hunk list, usually from diff or refine, to a string

val iter_ansi : rules:Format.Rules.t -> f_hunk_break:((int * int) -> (int * int) -> unit) -> f_line:(string -> unit) -> string Patdiff_lib.Import.Patience_diff.Hunk.t list -> unit

Iter along the lines of the diff and the breaks between hunks. Offers more flexibility regarding what the caller wants to do with the lines

type diff_input = {
  1. name : string;
  2. text : string;
}
val patdiff : ?context:int -> ?keep_ws:bool -> ?rules:Format.Rules.t -> ?output:Output.t -> ?produce_unified_lines:bool -> ?split_long_lines:bool -> ?print_global_header:bool -> ?location_style:Format.Location_style.t -> ?interleave:bool -> ?line_big_enough:int -> ?word_big_enough:int -> prev:diff_input -> next:diff_input -> unit -> string

Runs the equivalent of the command line version of patdiff on two given contents prev and next. Uses Patience_diff.String.