Merge pull request #500 from tarides/no-docs

Stop publishing docs -- go to ocaml.org instead :-)

Author: samoht

Diff for: CHANGES.md

@@ -11,6 +11,8 @@
 
 - Use the 'user' option as the fork owner, only attempt to decode the remote URL
   if the user option is not set. (#480, @Julow)
+- `dune-release` no longer publishes docs to github pages. Instead, we rely on
+  the docs published under `ocaml.org/packages` (#499 #500, @v-gb @samoht)
 
 ### Deprecated
 

Diff for: README.md

@@ -27,7 +27,7 @@ dune-release help         # for more help
 
 Calling `dune-release` without any argument will start the automated release process, composed of the following steps:
 - create the distribution archive;
-- publish it online with its documentation;
+- publish it online;
 - create an opam package;
 - submit it to OCaml's opam repository.
 
@@ -111,32 +111,16 @@ dune-release help distrib
 ```
 
 
-### Publish the distribution and documentation online
+### Publish the distribution online
 
-Once the distribution archive is created you can now publish it and its documentation online.
-
-You can publish the archive only with:
+Once the distribution archive is created you can now publish it with:
 
 ```
-dune-release publish distrib
+dune-release publish
 ```
 
 This means creating a Github release associated with the tag and upload the distribution tarball as a release artifact.
 
-You can publish the documentation only with:
-
-```
-dune-release publish doc
-```
-
-This means publishing the dune generated documentation to `gh-pages` to be served as a static website on github.io.
-
-If neither `distrib` neither `doc` is specified, `dune-release` publishes both:
-
-```
-dune-release publish
-```
-
 The full documentation of this command is available with
 ```
 dune-release help publish

Diff for: bin/bistro.ml

@@ -21,8 +21,8 @@ let bistro () (`Dry_run dry_run) (`Package_names pkg_names)
       Distrib.distrib ~dry_run ~pkg_names ~version ~tag ~keep_v ~keep_dir
         ~skip_lint ~skip_build ~skip_tests ~include_submodules ()
       >! fun () ->
-      Publish.publish ~token ~pkg_names ~version ~tag ~keep_v ~dry_run ?dev_repo
-        ~publish_artefacts:[] ~yes:false ~draft ()
+      Publish.publish ~token ~version ~tag ~keep_v ~dry_run ?dev_repo ~yes:false
+        ~draft ()
       >! fun () ->
       Opam.get_pkgs ~dry_run ~keep_v ~tag ~pkg_names ~version () >>= fun pkgs ->
       Opam.pkg ~dry_run ~pkgs () >! fun () ->
@@ -44,7 +44,7 @@ let man =
     `P "The $(tname) command (quick in Russian) is equivalent to invoke:";
     `Pre
       "dune-release distrib       # Create the distribution archive\n\
-       dune-release publish       # Publish it to Github with its documentation\n\
+       dune-release publish       # Publish it to Github\n\
        dune-release opam pkg      # Create an opam package\n\
        dune-release opam submit   # Submit it to OCaml's opam repository";
     `P "See dune-release(7) for more information.";

Diff for: bin/publish.ml

@@ -7,50 +7,6 @@
 open Bos_setup
 open Dune_release
 
-let gen_doc ~dry_run ~force dir pkg_names =
-  let names = String.concat ~sep:"," pkg_names in
-  let build_doc = Cmd.(v "dune" % "build" % "-p" % names % "@doc") in
-  let doc_dir = Pkg.doc_dir in
-  let do_doc () = Sos.run ~dry_run ~force build_doc in
-  R.join @@ Sos.with_dir ~dry_run dir do_doc () >>= fun () ->
-  Ok Fpath.(dir // doc_dir)
-
-let publish_doc ~dry_run ~yes pkg_names pkg =
-  App_log.status (fun l -> l "Publishing documentation");
-  Pkg.distrib_file ~dry_run pkg >>= fun archive ->
-  Pkg.publish_msg pkg >>= fun msg ->
-  Archive.untbz ~dry_run ~clean:true archive >>= fun dir ->
-  OS.Dir.exists dir >>= fun force ->
-  Pkg.infer_pkg_names dir pkg_names >>= fun pkg_names ->
-  App_log.status (fun l ->
-      l "Selected packages: %a"
-        Fmt.(list ~sep:(any "@ ") (styled `Bold string))
-        pkg_names);
-  App_log.status (fun l ->
-      l "Generating documentation from %a" Text.Pp.path archive);
-  gen_doc ~dry_run ~force dir pkg_names >>= fun docdir ->
-  App_log.status (fun l -> l "Publishing to github");
-  Github.publish_doc ~dry_run ~msg ~docdir ~yes pkg
-
-let pp_field = Fmt.(styled `Bold string)
-
-(* If `publish doc` is invoked explicitly from the CLI, we should fail if the
-   documentation cannot be published. If it is not called explicitly, we can
-   skip this step if the `doc` field of the opam file is not set. *)
-let publish_doc ~specific ~dry_run ~yes pkg_names pkg =
-  match Pkg.doc_uri pkg with
-  | _ when specific -> publish_doc ~dry_run ~yes pkg_names pkg
-  | Error _ | Ok "" ->
-      Pkg.name pkg >>= fun name ->
-      Pkg.opam pkg >>= fun opam ->
-      App_log.status (fun l ->
-          l
-            "Skipping documentation publication for package %s: no %a field in \
-             %a"
-            name pp_field "doc" Fpath.pp opam);
-      Ok ()
-  | Ok _ -> publish_doc ~dry_run ~yes pkg_names pkg
-
 let publish_distrib ?token ~dry_run ~yes ~draft ?dev_repo pkg =
   App_log.status (fun l -> l "Publishing distribution");
   Pkg.distrib_file ~dry_run pkg >>= fun archive ->
@@ -63,63 +19,26 @@ let publish_distrib ?token ~dry_run ~yes ~draft ?dev_repo pkg =
   Sos.write_file ~dry_run url_file url >>= fun () -> Ok ()
 
 let publish ?build_dir ?opam ?change_log ?distrib_file ?publish_msg ?token
-    ?dev_repo ~pkg_names ~version ~tag ~keep_v ~dry_run ~publish_artefacts ~yes
-    ~draft () =
-  let specific_doc =
-    List.exists (function `Doc -> true | _ -> false) publish_artefacts
-  in
-  let publish_artefacts =
-    match publish_artefacts with [] -> [ `Doc; `Distrib ] | v -> v
-  in
+    ?dev_repo ~version ~tag ~keep_v ~dry_run ~yes ~draft () =
   Config.keep_v ~keep_v >>= fun keep_v ->
   let pkg =
     Pkg.v ~dry_run ?version ?tag ~keep_v ?build_dir ?opam ?change_log
       ?distrib_file ?publish_msg ()
   in
-  let publish_artefact acc artefact =
-    acc >>= fun () ->
-    match artefact with
-    | `Doc -> publish_doc ~specific:specific_doc ~dry_run ~yes pkg_names pkg
-    | `Distrib -> publish_distrib ?token ~dry_run ~yes ~draft ?dev_repo pkg
-  in
-  List.fold_left publish_artefact (Ok ()) publish_artefacts >>= fun () -> Ok 0
+  publish_distrib ?token ~dry_run ~yes ~draft ?dev_repo pkg >>= fun () -> Ok 0
 
-let publish_cli () (`Build_dir build_dir) (`Package_names pkg_names)
-    (`Package_version version) (`Dist_tag tag) (`Keep_v keep_v)
-    (`Dist_opam opam) (`Change_log change_log) (`Dist_file distrib_file)
-    (`Publish_msg publish_msg) (`Dry_run dry_run)
-    (`Publish_artefacts publish_artefacts) (`Yes yes) (`Token token)
-    (`Draft draft) (`Dev_repo dev_repo) =
+let publish_cli () (`Build_dir build_dir) (`Package_version version)
+    (`Dist_tag tag) (`Keep_v keep_v) (`Dist_opam opam) (`Change_log change_log)
+    (`Dist_file distrib_file) (`Publish_msg publish_msg) (`Dry_run dry_run)
+    (`Yes yes) (`Token token) (`Draft draft) (`Dev_repo dev_repo) =
   publish ?build_dir ?opam ?change_log ?distrib_file ?publish_msg ?token
-    ~pkg_names ~version ~tag ~keep_v ~dry_run ~publish_artefacts ~yes ~draft
-    ?dev_repo ()
+    ~version ~tag ~keep_v ~dry_run ~yes ~draft ?dev_repo ()
   |> Cli.handle_error
 
 (* Command line interface *)
 
 open Cmdliner
 
-let artefacts =
-  let parser = function
-    | "do" | "doc" -> `Ok `Doc
-    | "di" | "dis" | "dist" | "distr" | "distri" | "distrib" -> `Ok `Distrib
-    | s -> `Error (strf "`%s' unknown publication artefact" s)
-  in
-  let printer ppf = function
-    | `Doc -> Fmt.string ppf "doc"
-    | `Distrib -> Fmt.string ppf "distrib"
-  in
-  let artefact = (parser, printer) in
-  let doc =
-    strf
-      "The artefact to publish. $(docv) must be either `doc` or `distrib`. If \
-       absent, the set of default publication artefacts is determined by the \
-       package description."
-  in
-  Cli.named
-    (fun x -> `Publish_artefacts x)
-    Arg.(value & pos_all artefact [] & info [] ~doc ~docv:"ARTEFACT")
-
 let doc = "Publish package distribution archives and/or documentation."
 let sdocs = Manpage.s_common_options
 let exits = Cli.exits
@@ -128,29 +47,20 @@ let man_xrefs = [ `Main; `Cmd "distrib" ]
 let man =
   [
     `S Manpage.s_synopsis;
-    `P "$(mname) $(tname) [$(i,OPTION)]... [$(i,ARTEFACT)]...";
+    `P "$(mname) $(tname) [$(i,OPTION)]...";
     `S Manpage.s_description;
-    `P
-      "The $(tname) command publishes package distribution archives and/or \
-       documentation.";
+    `P "The $(tname) command publishes package distribution archives.";
     `P
       "Artefact publication always relies on a distribution archive having \
        been generated before with dune-release-distrib(1).";
-    `S "ARTEFACTS";
-    `I
-      ( "$(b,distrib)",
-        "Publishes a distribution archive as part of a Github release." );
-    `I
-      ( "$(b,doc)",
-        "Publishes the documentation of a distribution archive to gh-pages." );
   ]
 
 let term =
   Term.(
-    const publish_cli $ Cli.setup $ Cli.build_dir $ Cli.pkg_names
-    $ Cli.pkg_version $ Cli.dist_tag $ Cli.keep_v $ Cli.dist_opam
-    $ Cli.change_log $ Cli.dist_file $ Cli.publish_msg $ Cli.dry_run $ artefacts
-    $ Cli.yes $ Cli.token $ Cli.draft $ Cli.dev_repo)
+    const publish_cli $ Cli.setup $ Cli.build_dir $ Cli.pkg_version
+    $ Cli.dist_tag $ Cli.keep_v $ Cli.dist_opam $ Cli.change_log $ Cli.dist_file
+    $ Cli.publish_msg $ Cli.dry_run $ Cli.yes $ Cli.token $ Cli.draft
+    $ Cli.dev_repo)
 
 let info = Cmd.info "publish" ~doc ~sdocs ~exits ~man ~man_xrefs
 let cmd = Cmd.v info term

Diff for: bin/publish.mli

@@ -14,22 +14,18 @@ val publish :
   ?publish_msg:string ->
   ?token:string Dune_release.Config.Cli.t ->
   ?dev_repo:string ->
-  pkg_names:string list ->
   version:Dune_release.Version.t option ->
   tag:Dune_release.Vcs.Tag.t option ->
   keep_v:bool Dune_release.Config.Cli.t ->
   dry_run:bool ->
-  publish_artefacts:[ `Distrib | `Doc ] list ->
   yes:bool ->
   draft:bool ->
   unit ->
   (int, Bos_setup.R.msg) result
 (** [publish ~build_dir ~opam ~change_log ~distrib_uri ~distrib_file
-    ~publish_msg ~name ~pkg_names ~version ~tag ~keep_v ~dry_run
-    ~publish_artefacts ~yes ~draft ()]
-    publishes the artefacts [publish_artefacts] of the package built with
-    [name], [version] and [tag]. Returns the exit code (0 for success, 1 for
-    failure) or error messages.
+    ~publish_msg ~version ~tag ~keep_v ~dry_run ~yes ~draft ()]
+    publishes the artefacts of the package built with [version] and [tag].
+    Returns the exit code (0 for success, 1 for failure) or error messages.
 
     - [keep_v] indicates whether the version is prefixed by 'v'. *)
 

Diff for: lib/github.ml

@@ -7,9 +7,6 @@
 open Bos_setup
 
 module D = struct
-  let user = "${user}"
-  let dir = Fpath.v "${dir}"
-  let fetch_head = "${fetch_head}"
   let pr_url = "${pr_url}"
   let pr_node_id = "${pr_node_id}"
   let download_url = "${download_url}"
@@ -36,126 +33,6 @@ module Parse = struct
     | _ -> None
 end
 
-(* Publish documentation *)
-
-let publish_in_git_branch ~dry_run ~remote ~branch ~name ~version ~docdir ~dir
-    ~yes =
-  let pp_distrib ppf (name, version) =
-    Fmt.pf ppf "%a %a" Text.Pp.name name Text.Pp.version version
-  in
-  let log_publish_result msg distrib dir =
-    App_log.success (fun m ->
-        m "%s %a in directory %a of gh-pages branch" msg pp_distrib distrib
-          Fpath.pp dir)
-  in
-  let delete dir =
-    if not (Fpath.is_current_dir dir) then Sos.delete_dir ~dry_run dir
-    else
-      let delete acc p = acc >>= fun () -> Sos.delete_path ~dry_run p in
-      let gitdir = Fpath.v ".git" in
-      let not_git p = not (Fpath.equal p gitdir) in
-      OS.Dir.contents dir >>= fun files ->
-      List.fold_left delete (Ok ()) (List.filter not_git files)
-  in
-  let replace_dir_and_push docdir dir =
-    let msg = strf "Update %s doc to %a." name Version.pp version in
-    Vcs.get () >>= fun repo ->
-    Vcs.run_git_quiet repo ~dry_run ~force:(dir <> D.dir)
-      Cmd.(v "checkout" % branch)
-    >>= fun () ->
-    delete dir >>= fun () ->
-    Sos.cp ~dry_run ~rec_:true ~force:true ~src:Fpath.(docdir / ".") ~dst:dir
-    >>= fun () ->
-    (if dry_run then Ok true else Vcs.is_dirty repo) >>= function
-    | false -> Ok false
-    | true ->
-        Vcs.run_git_quiet repo ~dry_run Cmd.(v "add" % p dir) >>= fun () ->
-        Vcs.run_git_quiet repo ~dry_run Cmd.(v "commit" % "-m" % msg)
-        >>= fun () ->
-        Vcs.run_git_quiet repo ~dry_run Cmd.(v "push") >>= fun () -> Ok true
-  in
-  if not (Fpath.is_rooted ~root:Fpath.(v ".") dir) then
-    R.error_msgf "%a directory is not rooted in the repository or not relative"
-      Fpath.pp dir
-  else
-    let clonedir = Fpath.(parent (parent (parent docdir)) / "gh-pages") in
-    Sos.delete_dir ~dry_run ~force:true clonedir >>= fun () ->
-    Vcs.get () >>= fun repo ->
-    Vcs.clone ~dry_run ~force:true ~dir:clonedir repo >>= fun () ->
-    Sos.relativize ~src:clonedir ~dst:docdir >>= fun rel_docdir ->
-    App_log.status (fun l ->
-        l "Updating local %a branch" Text.Pp.commit "gh-pages");
-    Sos.with_dir ~dry_run clonedir (replace_dir_and_push rel_docdir) dir
-    >>= fun res ->
-    res >>= function
-    | false (* no changes *) ->
-        log_publish_result "No documentation changes for" (name, version) dir;
-        Ok ()
-    | true ->
-        let push_spec = strf "%s:%s" branch branch in
-        Prompt.(
-          confirm_or_abort ~yes
-            ~question:(fun l ->
-              l "Push new documentation to %a?" Text.Pp.url
-                (remote ^ "#gh-pages"))
-            ~default_answer:Yes)
-        >>= fun () ->
-        App_log.status (fun l ->
-            l "Pushing new documentation to %a" Text.Pp.url
-              (remote ^ "#gh-pages"));
-        Vcs.run_git_quiet repo ~dry_run Cmd.(v "push" % remote % push_spec)
-        >>= fun () ->
-        Sos.delete_dir ~dry_run clonedir >>= fun () ->
-        log_publish_result "Published documentation for" (name, version) dir;
-        Ok ()
-
-let publish_doc ~dry_run ~msg:_ ~docdir ~yes p =
-  Pkg.github_doc_owner_repo_and_path p >>= fun (user, repo, dir) ->
-  Pkg.name p >>= fun name ->
-  Pkg.version p >>= fun version ->
-  let remote = strf "git@@github.com:%s/%s.git" user repo in
-  Vcs.get () >>= fun vcs ->
-  let force = user <> D.user in
-  let create_empty_gh_pages () =
-    let msg = "Initial commit by dune-release." in
-    let create () =
-      Vcs.run_git_quiet vcs ~dry_run Cmd.(v "init") >>= fun () ->
-      Vcs.run_git_quiet vcs ~dry_run
-        Cmd.(v "checkout" % "--orphan" % "gh-pages")
-      >>= fun () ->
-      Sos.write_file ~dry_run (Fpath.v "README") ""
-      (* need some file *) >>= fun () ->
-      Vcs.run_git_quiet vcs ~dry_run Cmd.(v "add" % "README") >>= fun () ->
-      Vcs.run_git_quiet vcs ~dry_run Cmd.(v "commit" % "README" % "-m" % msg)
-    in
-    OS.Dir.with_tmp "gh-pages-%s.tmp"
-      (fun dir () ->
-        Sos.with_dir ~dry_run dir create () |> R.join >>= fun () ->
-        Vcs.run_git_quiet vcs ~dry_run ~force
-          Cmd.(v "fetch" % Fpath.to_string dir % "gh-pages"))
-      ()
-    |> R.join
-  in
-  (match
-     Vcs.run_git_quiet vcs ~dry_run ~force Cmd.(v "fetch" % remote % "gh-pages")
-   with
-  | Ok () -> Ok ()
-  | Error _ ->
-      App_log.status (fun l ->
-          l "Creating new gh-pages branch with initial commit on %s/%s" user
-            repo);
-      create_empty_gh_pages ())
-  >>= fun () ->
-  Vcs.run_git_string vcs ~dry_run ~force
-    Cmd.(v "rev-parse" % "FETCH_HEAD")
-    ~default:(Sos.out D.fetch_head)
-  >>= fun id ->
-  Vcs.run_git_quiet vcs ~dry_run ~force
-    Cmd.(v "branch" % "-f" % "gh-pages" % id)
-  >>= fun () ->
-  publish_in_git_branch ~dry_run ~remote ~branch:"gh-pages" ~name ~version
-    ~docdir ~dir ~yes
-
 (* Publish releases *)
 
 let run_with_auth ?(default_body = `Null) ~dry_run Curl.{ url; args; meth } =