package patdiff

You can search for identifiers within the package.

in-package search v0.2.0

package patdiff

patdiff
- Patdiff
  - Compare_core
    
    Private
  - Configuration
    
    On_disk
    
    V0
    
    V1
    
    V2
    
    V3
  - Patdiff_core
  - Private
patdiff.expect_test_patdiff
- Expect_test_patdiff
patdiff.kernel
- Patdiff_kernel
  - Ansi_output
    
    Rule
  - Ascii_output
    
    Rule
  - Compare_core
    
    Make
    
    Patdiff_core
    
    Private
    
    S
    
    Private
    
    Without_unix
    
    Private
  - Comparison_result
  - Configuration
  - Diff_input
    
    Fields
  - File_helpers
    
    Trailing_newline
  - File_name
  - Float_tolerance
  - Format
    
    Color
    
    Gray24
    
    Map
    
    Diff
    
    Key
    
    Provide_bin_io
    
    Key
    
    Provide_hash
    
    Key
    
    Provide_of_sexp
    
    Key
    
    RGB6
    
    Replace_polymorphic_compare
    
    Set
    
    Diff
    
    Elt
    
    Provide_bin_io
    
    Elt
    
    Provide_hash
    
    Elt
    
    Provide_of_sexp
    
    Elt
    
    Location_style
    
    Rule
    
    Affix
    
    Rules
    
    Style
    
    Map
    
    Diff
    
    Key
    
    Provide_bin_io
    
    Key
    
    Provide_hash
    
    Key
    
    Provide_of_sexp
    
    Key
    
    Replace_polymorphic_compare
    
    Set
    
    Diff
    
    Elt
    
    Provide_bin_io
    
    Elt
    
    Provide_hash
    
    Elt
    
    Provide_of_sexp
    
    Elt
  - Html_output
    
    Private
    
    Make
    
    Mtime
    
    Rule
    
    Without_mtime
    
    Rule
  - Hunks
  - Import
  - Is_binary
  - Output
    
    S
    
    Rule
  - Patdiff_core
    
    Private
    
    Make
    
    Output_impls
    
    S
    
    Without_unix
  - Should_keep_whitespace

Legend:
Library
Module
Module type
Parameter
Class
Class type

include module type of struct include Patdiff_kernel.Patdiff_core end

module type S = Patdiff_kernel.Patdiff_core.S

val default_context : int

val default_line_big_enough : int

val default_word_big_enough : int

val remove_ws : string -> string

remove_ws calls String.strip and replaces whitespace with " "

module Private = Patdiff_kernel.Patdiff_core.Private

module Without_unix = Patdiff_kernel.Patdiff_core.Without_unix

include Patdiff_kernel.Patdiff_core.S

val diff : 
  context:int ->
  line_big_enough:int ->
  keep_ws:bool ->
  find_moves:bool ->
  prev:string array ->
  next:string array ->
  Patdiff_kernel.Hunks.t

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

val find_moves : 
  line_big_enough:int ->
  keep_ws:bool ->
  Patdiff_kernel.Hunks.t ->
  Patdiff_kernel.Hunks.t

val refine : 
  rules:Patdiff_kernel.Format.Rules.t ->
  produce_unified_lines:bool ->
  output:Patdiff_kernel.Output.t ->
  keep_ws:bool ->
  split_long_lines:bool ->
  interleave:bool ->
  word_big_enough:int ->
  Patdiff_kernel.Hunks.t ->
  Patdiff_kernel.Hunks.t

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 : 
  file_names:(Patdiff_kernel.File_name.t * Patdiff_kernel.File_name.t) ->
  rules:Patdiff_kernel.Format.Rules.t ->
  output:Patdiff_kernel.Output.t ->
  location_style:Patdiff_kernel.Format.Location_style.t ->
  Patdiff_kernel.Hunks.t ->
  unit

Print a hunk list, usually from diff or refine

val output_to_string : 
  ?print_global_header:bool ->
  file_names:(Patdiff_kernel.File_name.t * Patdiff_kernel.File_name.t) ->
  rules:Patdiff_kernel.Format.Rules.t ->
  output:Patdiff_kernel.Output.t ->
  location_style:Patdiff_kernel.Format.Location_style.t ->
  Patdiff_kernel.Hunks.t ->
  string

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

val iter_ansi : 
  rules:Patdiff_kernel.Format.Rules.t ->
  f_hunk_break:((int * int) -> (int * int) -> unit) ->
  f_line:(string -> unit) ->
  Patdiff_kernel.Hunks.t ->
  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

val patdiff : 
  ?context:int ->
  ?keep_ws:bool ->
  ?find_moves:bool ->
  ?rules:Patdiff_kernel.Format.Rules.t ->
  ?output:Patdiff_kernel.Output.t ->
  ?produce_unified_lines:bool ->
  ?split_long_lines:bool ->
  ?print_global_header:bool ->
  ?location_style:Patdiff_kernel.Format.Location_style.t ->
  ?interleave:bool ->
  ?float_tolerance:Core.Percent.t ->
  ?line_big_enough:int ->
  ?word_big_enough:int ->
  prev:Patdiff_kernel.Diff_input.t ->
  next:Patdiff_kernel.Diff_input.t ->
  unit ->
  string

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