patdiff v0.11.0 · OCaml Package

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 ->
  mine:string array ->
  other:string array ->
  string Patdiff_lib.Import.Patience_diff.Hunk.t list

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

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 : 
  old_file:string ->
  new_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 = {

name : string;
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 ->
  from_:diff_input ->
  to_:diff_input ->
  unit ->
  string

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

package patdiff