This is an automated email from the git hooks/post-receive script.
glondu pushed a commit to branch master
in repository easy-format.
commit 3471338d7c1d4e1f060ecf2b92fdafe8d2ba56bf
Author: Stephane Glondu <st...@glondu.net>
Date: Tue Jan 26 16:06:46 2016 +0100
Imported Upstream version 1.2.0
---
.gitignore | 4 ++-
Makefile | 2 +-
easy_format.ml | 65 ++++++++++++++++++++++++++++++++++------------
easy_format.mli | 37 ++++++++++++++++++++------
simple_example.ml | 77 ++++++++++++++++++++++++++++++++++++++++++++++++++-----
5 files changed, 153 insertions(+), 32 deletions(-)
diff --git a/.gitignore b/.gitignore
index 3099d3e..061a5ce 100644
--- a/.gitignore
+++ b/.gitignore
@@ -18,4 +18,6 @@ nativecode
lambda_example
simple_example
test_easy_format
-
+easy_format_example.html
+easy_format_example.ml
+ocamldoc
diff --git a/Makefile b/Makefile
index 8944a7b..305183a 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,4 @@
-VERSION = 1.1.0
+VERSION = 1.2.0
export VERSION
NATDYNLINK := $(shell if [ -f `ocamlfind ocamlc -where`/dynlink.cmxa ]; \
diff --git a/easy_format.ml b/easy_format.ml
index 2840700..24e6a28 100644
--- a/easy_format.ml
+++ b/easy_format.ml
@@ -1,12 +1,20 @@
open Format
-type wrap =
- [ `Wrap_atoms
- | `Always_wrap
- | `Never_wrap
- | `Force_breaks
- | `Force_breaks_rec
- | `No_breaks ]
+type wrap = [
+ | `Wrap_atoms
+ | `Always_wrap
+ | `Never_wrap
+ | `Force_breaks
+ | `Force_breaks_rec
+ | `No_breaks
+]
+
+type label_break = [
+ | `Auto
+ | `Always
+ | `Always_rec
+ | `Never
+]
type style_name = string
type style = {
@@ -57,12 +65,14 @@ let list = {
}
type label_param = {
+ label_break: label_break;
space_after_label : bool;
indent_after_label : int;
label_style : style_name option;
}
let label = {
+ label_break = `Auto;
space_after_label = true;
indent_after_label = 2;
label_style = None;
@@ -118,12 +128,13 @@ let propagate_from_leaf_to_root
has the attribute wrap_body = `Force_breaks_rec.
*)
let propagate_forced_breaks x =
- (* acc = whether to force breaks in wrappable lists *)
+ (* acc = whether to force breaks in wrappable lists or labels *)
let init_acc = function
+ | List ((_, _, _, { wrap_body = `Force_breaks_rec }), _)
+ | Label ((_, { label_break = `Always_rec }), _) -> true
| Atom _
| Label _
- | Custom _ -> false
- | List ((_, _, _, { wrap_body = `Force_breaks_rec }), _) -> true
+ | Custom _
| List _ -> false
in
let merge_acc force_breaks1 force_breaks2 =
@@ -135,6 +146,7 @@ let propagate_forced_breaks x =
| List ((_, _, _, { wrap_body = `Force_breaks }), _) -> x, force_breaks
| List ((op, sep, cl, ({ wrap_body = (`Wrap_atoms
+ | `Never_wrap
| `Always_wrap) } as p)),
children) ->
if force_breaks then
@@ -143,9 +155,16 @@ let propagate_forced_breaks x =
else
x, false
- | List ((_, _, _, { wrap_body = (`Never_wrap | `No_breaks) }), _)
+ | Label ((a, ({ label_break = `Auto } as lp)), b) ->
+ if force_breaks then
+ let lp = { lp with label_break = `Always } in
+ Label ((a, lp), b), true
+ else
+ x, false
+
+ | List ((_, _, _, { wrap_body = `No_breaks }), _)
+ | Label ((_, { label_break = (`Always | `Always_rec | `Never) }), _)
| Atom _
- | Label _
| Custom _ -> x, force_breaks
in
let new_x, forced_breaks =
@@ -491,10 +510,22 @@ struct
fprint_t fmt lab;
close_tag fmt lp.label_style;
- if lp.space_after_label then
- pp_print_break fmt 1 indent
- else
- pp_print_break fmt 0 indent;
+ (match lp.label_break with
+ | `Auto ->
+ if lp.space_after_label then
+ pp_print_break fmt 1 indent
+ else
+ pp_print_break fmt 0 indent
+ | `Always
+ | `Always_rec ->
+ pp_force_newline fmt ();
+ pp_print_string fmt (String.make indent ' ')
+ | `Never ->
+ if lp.space_after_label then
+ pp_print_char fmt ' '
+ else
+ ()
+ );
fprint_t fmt x;
pp_close_box fmt ()
@@ -619,12 +650,14 @@ struct
}
let label_true = {
+ label_break = `Auto;
space_after_label = true;
indent_after_label = 2;
label_style = None;
}
let label_false = {
+ label_break = `Auto;
space_after_label = false;
indent_after_label = 2;
label_style = None;
diff --git a/easy_format.mli b/easy_format.mli
index ce706a6..0aeb629 100644
--- a/easy_format.mli
+++ b/easy_format.mli
@@ -39,6 +39,19 @@ type wrap =
i.e. never break line between list items
*)
+type label_break = [
+ | `Auto
+ | `Always
+ | `Always_rec
+ | `Never
+]
+(** When to break the line after a [Label]:
+ - [Auto]: break after the label if there's not enough room
+ - [Always]: always break after the label
+ - [Always_rec]: always break after the label and force breaks in all parent
+ lists and labels, similarly to [`Force_breaks_rec] for lists.
+ - [Never]: never break after the label
+*)
type style_name = string
@@ -116,14 +129,22 @@ val list : list_param
See {!Easy_format.label}.
*)
type label_param = {
- space_after_label : bool; (** Whether there must be some whitespace
- after the label.
- Default: [true] *)
- indent_after_label : int; (** Extra indentation before the item
- that comes after a label.
- Default: [2]
- *)
- label_style : style_name option; (** Default: [None] *)
+ label_break: label_break;
+ (** Whether to break the line after the label.
+ Introduced in version 1.2.0.
+ Default: [`Auto] *)
+
+ space_after_label : bool;
+ (** Whether there must be some whitespace after the label.
+ Default: [true] *)
+
+ indent_after_label : int;
+ (** Extra indentation before the item that comes after a label.
+ Default: [2]
+ *)
+
+ label_style : style_name option;
+ (** Default: [None] *)
}
val label : label_param
diff --git a/simple_example.ml b/simple_example.ml
index 76c349c..56abc67 100644
--- a/simple_example.ml
+++ b/simple_example.ml
@@ -123,11 +123,42 @@ let format_function_definition (body_label, body_param)
name param body =
)
(*
+ Illustrate the difference between `Force_break and `Force_breaks_rec on
+ labels.
+*)
+let label_one_atom = Atom ("reallyLongLabelOne", atom)
+let label_two_atom = Atom ("reallyLongLabelTwo", atom)
+let label_three_atom = Atom ("reallyLongLabelABC", atom)
+let make_list_in_labels (wrap) =
+ Label (
+ (label_one_atom, label),
+ (
+ Label (
+ (label_two_atom, label),
+ (
+ Label (
+ (label_three_atom, label),
+ List (
+ ("[", ",", "]", { list with wrap_body = wrap }),
+ [
+ Atom ("1.23456", atom);
+ Atom ("9.87654", atom);
+ Atom ("9.87654", atom);
+ Atom ("9.87654", atom);
+ ]
+ )
+ )
+ )
+ )
+ )
+ )
+
+(*
Illustrate the difference between `Force_break and `Force_breaks_rec
*)
-let make_heterogenous_list wrap =
+let make_heterogenous_list (container_wrap, wrap) =
List (
- ("[", ",", "]", { list with wrap_body = `Always_wrap }),
+ ("[", ",", "]", { list with wrap_body = container_wrap }),
[
Atom ("0", atom);
List (
@@ -170,6 +201,9 @@ let print_tuple fmt l =
let print_heterogenous_list fmt wrap =
Pretty.to_formatter fmt (make_heterogenous_list wrap)
+let print_list_in_labels fmt wrap =
+ Pretty.to_formatter fmt (make_list_in_labels wrap)
+
let print_sum ?wrap fmt l =
Pretty.to_formatter fmt (format_sum ?wrap l)
@@ -195,12 +229,43 @@ let () =
(* Heterogenous list *)
print "wrappable outer list, inner list using `Force_breaks";
- with_margin 80 print_heterogenous_list `Force_breaks;
- with_margin 20 print_heterogenous_list `Force_breaks;
+ with_margin 80 print_heterogenous_list (`Always_wrap, `Force_breaks);
+ with_margin 20 print_heterogenous_list (`Always_wrap, `Force_breaks);
print "wrappable outer list, inner list using `Force_breaks_rec";
- with_margin 80 print_heterogenous_list `Force_breaks_rec;
- with_margin 20 print_heterogenous_list `Force_breaks_rec;
+ with_margin 80 print_heterogenous_list (`Always_wrap, `Force_breaks_rec);
+ with_margin 20 print_heterogenous_list (`Always_wrap, `Force_breaks_rec);
+
+ print "never_wrap outer list, inner list using `Force_breaks";
+ with_margin 80 print_heterogenous_list (`Never_wrap, `Force_breaks);
+ with_margin 20 print_heterogenous_list (`Never_wrap, `Force_breaks);
+
+ print "never_wrap outer list, inner list using `Force_breaks_rec";
+ with_margin 80 print_heterogenous_list (`Never_wrap, `Force_breaks_rec);
+ with_margin 20 print_heterogenous_list (`Never_wrap, `Force_breaks_rec);
+
+ print "no breaks outer list, inner list using `Force_breaks";
+ with_margin 80 print_heterogenous_list (`No_breaks, `Force_breaks);
+ with_margin 20 print_heterogenous_list (`No_breaks, `Force_breaks);
+
+ print "no breaks outer list, inner list using `Force_breaks_rec";
+ with_margin 80 print_heterogenous_list (`No_breaks, `Force_breaks_rec);
+ with_margin 20 print_heterogenous_list (`No_breaks, `Force_breaks_rec);
+
+ print "label with inner list using `Force_breaks_rec";
+ with_margin 80 print_list_in_labels (`Force_breaks_rec);
+ with_margin 70 print_list_in_labels (`Force_breaks_rec);
+ with_margin 20 print_list_in_labels (`Force_breaks_rec);
+
+ print "label with inner list using `Force_breaks";
+ with_margin 80 print_list_in_labels (`Force_breaks);
+ with_margin 70 print_list_in_labels (`Force_breaks);
+ with_margin 20 print_list_in_labels (`Force_breaks);
+
+ print "label with inner list using `Never_wrap";
+ with_margin 80 print_list_in_labels (`Never_wrap);
+ with_margin 70 print_list_in_labels (`Never_wrap);
+ with_margin 20 print_list_in_labels (`Never_wrap);
(* Triangular array of arrays showing wrapping of lists of atoms *)
let m = Array.init 20 (fun i -> Array.init i (fun i -> sqrt (float i))) in
--
Alioth's /usr/local/bin/git-commit-notice on
/srv/git.debian.org/git/pkg-ocaml-maint/packages/easy-format.git
_______________________________________________
Pkg-ocaml-maint-commits mailing list
Pkg-ocaml-maint-commits@lists.alioth.debian.org
http://lists.alioth.debian.org/cgi-bin/mailman/listinfo/pkg-ocaml-maint-commits
