diff --git a/CHANGELOG.md b/CHANGELOG.md index fe1f494e..7ca34e09 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,7 @@ ### Features - Add support for `buildNpmPackage` +- Dune: extract dependencies from `dune-project` and `.opam` files ### Fixes diff --git a/README.md b/README.md index ae5f67f5..7fd5f52a 100644 --- a/README.md +++ b/README.md @@ -73,6 +73,7 @@ Options: - `buildPythonApplication` and `buildPythonPackage` - `buildGoModule` - `buildNpmPackage` +- `buildDunePackage` ### Supported fetchers diff --git a/src/cli.rs b/src/cli.rs index dc63d2f8..1d8a947c 100644 --- a/src/cli.rs +++ b/src/cli.rs @@ -73,6 +73,7 @@ pub struct Opts { #[derive(Clone, ValueEnum)] #[clap(rename_all = "camelCase")] pub enum BuilderFunction { + BuildDunePackage, BuildGoModule, BuildNpmPackage, BuildPythonApplication, diff --git a/src/codegen/dune.rs b/src/codegen/dune.rs new file mode 100644 index 00000000..bad2069f --- /dev/null +++ b/src/codegen/dune.rs @@ -0,0 +1,111 @@ +use anyhow::Result; +use parse_display::Display; + +use crate::{ + codegen::{Builder, Codegen}, + lang::dune::get_dune_dependencies, +}; + +#[derive(Clone, Copy, Display)] +#[display("buildDunePackage")] +pub struct BuildDunePackage; + +impl Builder for BuildDunePackage { + fn function(&self) -> &'static str { + "buildDunePackage" + } + + fn after_inputs(&self, cg: &mut Codegen<'_>) -> Result { + let deps = get_dune_dependencies(cg.src_dir); + + for tool in deps.tools { + cg.inputs + .native_build_inputs + .always + .insert(format!("ocamlPackages.{tool}")); + } + for dep in &deps.build { + cg.inputs + .build_inputs + .always + .insert(format!("ocamlPackages.{dep}")); + } + for dep in &deps.check { + cg.inputs + .check_inputs + .always + .insert(format!("ocamlPackages.{dep}")); + } + for license in deps.licenses { + cg.licenses.insert(license, 1.0); + } + + Ok(String::new()) + } +} + +#[cfg(test)] +mod tests { + use std::{collections::BTreeMap, fs::write}; + + use insta::assert_snapshot; + use tempfile::TempDir; + + use super::*; + use crate::codegen::SourceLayout; + + async fn generate_dune(dune_project: bool) -> String { + let dir = TempDir::new().unwrap(); + if dune_project { + write( + dir.path().join("dune-project"), + include_str!("../lang/fixtures/ocaml-lsp.dune-project"), + ) + .unwrap(); + } else { + write( + dir.path().join("ocaml-lsp-server.opam"), + include_str!("../lang/fixtures/ocaml-lsp-server.opam"), + ) + .unwrap(); + } + let dir_path = dir.path().to_owned(); + + let mut frontend = crate::frontend::headless(); + let cg = Codegen { + description: "LSP Server for OCaml".into(), + fetcher_input: "fetchFromGitHub".into(), + file_url_prefix: None, + frontend: &mut frontend, + inputs: Default::default(), + layout: SourceLayout::detect(dir_path.as_path()), + licenses: BTreeMap::new(), + maintainers: &["alice".to_string()], + nix_update_script: true, + nixpkgs: "", + out: String::new(), + out_dir: None, + overwrite: None, + pname: "ocaml-lsp", + python_deps: Default::default(), + releases_page: None, + src: "src", + src_dir: &dir_path, + src_expr: "src", + url: "https://github.com/ocaml/ocaml-lsp", + version: "1.27.0", + }; + + cg.generate(BuildDunePackage).await.unwrap() + } + + #[tokio::test] + async fn code_dune_project() { + assert_snapshot!(generate_dune(true).await); + } + + #[tokio::test] + async fn code_opam() { + assert_snapshot!(generate_dune(false).await); + } +} diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs index ccc11130..e896b376 100644 --- a/src/codegen/mod.rs +++ b/src/codegen/mod.rs @@ -1,4 +1,5 @@ pub mod drv; +pub mod dune; pub mod go; pub mod npm; pub mod python; @@ -26,8 +27,8 @@ use tracing::warn; use crate::{ cli::CargoVendor, codegen::{ - drv::MkDerivation, go::BuildGoModule, npm::BuildNpmPackage, python::BuildPythonPackage, - rust::BuildRustPackage, + drv::MkDerivation, dune::BuildDunePackage, go::BuildGoModule, npm::BuildNpmPackage, + python::BuildPythonPackage, rust::BuildRustPackage, }, frontend::FrontendDispatch, inputs::{AllInputs, write_all_lambda_inputs, write_inputs, write_lambda_input}, @@ -43,6 +44,7 @@ use crate::{ #[derive(Clone, Copy, Display)] #[display("{0}")] pub enum BuilderDispatch { + BuildDunePackage(BuildDunePackage), BuildGoModule(BuildGoModule), BuildNpmPackage(BuildNpmPackage), BuildPythonPackage(BuildPythonPackage), @@ -77,6 +79,7 @@ pub struct Codegen<'a> { pub struct SourceLayout { pub has_cargo: bool, pub has_cargo_lock: bool, + pub has_dune: bool, pub has_cmake: bool, pub has_go: bool, pub has_meson: bool, @@ -217,7 +220,7 @@ impl Codegen<'_> { if cargo_deps.is_some() { write_lambda_input(&mut self.out, &mut written, "rustPlatform")?; } - let (native_build_inputs, build_inputs) = + let (native_build_inputs, build_inputs, check_inputs) = write_all_lambda_inputs(&mut self.out, &self.inputs, &mut written)?; for input in builder.extra_lambda_inputs(&self) { write_lambda_input(&mut self.out, &mut written, &input)?; @@ -256,6 +259,9 @@ impl Codegen<'_> { if build_inputs { write_inputs(&mut self.out, &self.inputs.build_inputs, "buildInputs")?; } + if check_inputs { + write_inputs(&mut self.out, &self.inputs.check_inputs, "checkInputs")?; + } write!(self.out, "{after_inputs}")?; if !self.inputs.env.is_empty() { @@ -473,6 +479,7 @@ impl SourceLayout { has_cargo_lock: src_dir.join("Cargo.lock").is_file(), has_cmake: src_dir.join("CMakeLists.txt").is_file(), has_go: src_dir.join("go.mod").is_file(), + has_dune: src_dir.join("dune-project").is_file(), has_meson: src_dir.join("meson.build").is_file(), has_npm: src_dir.join("package.json").is_file(), has_npm_lock: src_dir.join("package-lock.json").is_file() diff --git a/src/codegen/snapshots/nix_init__codegen__dune__tests__code_dune_project.snap b/src/codegen/snapshots/nix_init__codegen__dune__tests__code_dune_project.snap new file mode 100644 index 00000000..e05335a7 --- /dev/null +++ b/src/codegen/snapshots/nix_init__codegen__dune__tests__code_dune_project.snap @@ -0,0 +1,65 @@ +--- +source: src/codegen/dune.rs +expression: generate_dune(true).await +--- +{ + lib, + buildDunePackage, + fetchFromGitHub, + ocamlPackages, + nix-update-script, +}: + +buildDunePackage (finalAttrs: { + pname = "ocaml-lsp"; + version = "1.27.0"; + __structuredAttrs = true; + + src = src; + + nativeBuildInputs = [ + ocamlPackages.cinaps + ]; + + buildInputs = [ + ocamlPackages.astring + ocamlPackages.base + ocamlPackages.camlp-streams + ocamlPackages.chrome-trace + ocamlPackages.csexp + ocamlPackages.dune-build-info + ocamlPackages.dune-rpc + ocamlPackages.dyn + ocamlPackages.fiber + ocamlPackages.jsonrpc + ocamlPackages.lsp + ocamlPackages.merlin-lib + ocamlPackages.ocamlc-loc + ocamlPackages.ocamlformat-rpc-lib + ocamlPackages.ordering + ocamlPackages.pp + ocamlPackages.ppx_yojson_conv_lib + ocamlPackages.re + ocamlPackages.spawn + ocamlPackages.stdune + ocamlPackages.uutf + ocamlPackages.xdg + ocamlPackages.yojson + ]; + + checkInputs = [ + ocamlPackages.cinaps + ocamlPackages.ocamlformat + ocamlPackages.ppx_expect + ]; + + passthru.updateScript = nix-update-script { }; + + meta = { + description = "LSP Server for OCaml"; + homepage = "https://github.com/ocaml/ocaml-lsp"; + license = lib.licenses.isc; + maintainers = with lib.maintainers; [ alice ]; + mainProgram = "ocaml-lsp"; + }; +}) diff --git a/src/codegen/snapshots/nix_init__codegen__dune__tests__code_opam.snap b/src/codegen/snapshots/nix_init__codegen__dune__tests__code_opam.snap new file mode 100644 index 00000000..0b4e63b1 --- /dev/null +++ b/src/codegen/snapshots/nix_init__codegen__dune__tests__code_opam.snap @@ -0,0 +1,59 @@ +--- +source: src/codegen/dune.rs +expression: generate_dune(false).await +--- +{ + lib, + buildDunePackage, + fetchFromGitHub, + ocamlPackages, + nix-update-script, +}: + +buildDunePackage (finalAttrs: { + pname = "ocaml-lsp"; + version = "1.27.0"; + __structuredAttrs = true; + + src = src; + + buildInputs = [ + ocamlPackages.astring + ocamlPackages.base + ocamlPackages.camlp-streams + ocamlPackages.chrome-trace + ocamlPackages.csexp + ocamlPackages.dune-build-info + ocamlPackages.dune-rpc + ocamlPackages.dyn + ocamlPackages.fiber + ocamlPackages.jsonrpc + ocamlPackages.lsp + ocamlPackages.merlin-lib + ocamlPackages.ocamlc-loc + ocamlPackages.ocamlformat-rpc-lib + ocamlPackages.ordering + ocamlPackages.pp + ocamlPackages.ppx_yojson_conv_lib + ocamlPackages.re + ocamlPackages.spawn + ocamlPackages.stdune + ocamlPackages.xdg + ocamlPackages.yojson + ]; + + checkInputs = [ + ocamlPackages.ocamlformat + ocamlPackages.ppx_expect + ]; + + passthru.updateScript = nix-update-script { }; + + meta = { + description = "LSP Server for OCaml"; + homepage = "https://github.com/ocaml/ocaml-lsp"; + license = lib.licenses.isc; + maintainers = with lib.maintainers; [ alice ]; + mainProgram = "ocaml-lsp"; + }; +}) diff --git a/src/inputs.rs b/src/inputs.rs index 2ce8163c..fb6410f7 100644 --- a/src/inputs.rs +++ b/src/inputs.rs @@ -10,6 +10,7 @@ use anyhow::Result; pub struct AllInputs { pub native_build_inputs: Inputs, pub build_inputs: Inputs, + pub check_inputs: Inputs, pub env: BTreeMap, (Cow<'static, str>, Vec)>, } @@ -30,15 +31,16 @@ pub fn write_all_lambda_inputs( out: &mut impl Write, inputs: &AllInputs, written: &mut BTreeSet, -) -> Result<(bool, bool)> { +) -> Result<(bool, bool, bool)> { let native_build_inputs = write_lambda_inputs(out, written, &inputs.native_build_inputs)?; let build_inputs = write_lambda_inputs(out, written, &inputs.build_inputs)?; + let check_inputs = write_lambda_inputs(out, written, &inputs.check_inputs)?; for input in inputs.env.values().flat_map(|(_, inputs)| inputs) { if written.insert(input.clone()) { writeln!(out, " {input},")?; } } - Ok((native_build_inputs, build_inputs)) + Ok((native_build_inputs, build_inputs, check_inputs)) } fn write_lambda_inputs( diff --git a/src/lang/dune.rs b/src/lang/dune.rs new file mode 100644 index 00000000..29cae1dc --- /dev/null +++ b/src/lang/dune.rs @@ -0,0 +1,378 @@ +use std::{collections::BTreeSet, fs, path::Path}; + +use tracing::warn; + +use crate::{license::parse_spdx_expression, utils::ResultExt}; + +#[derive(Debug, Default)] +pub struct DuneDependencies { + pub build: BTreeSet, + pub check: BTreeSet, + /// tools required by `(using ...)` extensions, e.g. `cinaps` + pub tools: BTreeSet<&'static str>, + pub licenses: BTreeSet<&'static str>, +} + +/// Extract dependencies from the `dune-project` file, falling back to the +/// `.opam` files in the source directory if it doesn't declare any packages. +pub fn get_dune_dependencies(src_dir: &Path) -> DuneDependencies { + let mut deps = DuneDependencies::default(); + + if let Some(content) = read_file(src_dir.join("dune-project")) { + load_dune_project(&content, &mut deps); + if !deps.build.is_empty() || !deps.check.is_empty() { + return deps; + } + deps = DuneDependencies::default(); + } + + if let Some(entries) = fs::read_dir(src_dir).ok_inspect(|e| warn!("{e}")) { + for entry in entries.flatten() { + let path = entry.path(); + if path.extension().is_some_and(|ext| ext == "opam") + && let Some(content) = read_file(&path) + { + load_opam(&content, &mut deps); + } + } + } + deps +} + +fn read_file(path: impl AsRef) -> Option { + fs::read_to_string(path).ok_inspect(|e| warn!("{e}")) +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] +enum Filter { + None, + Test, + Skip, +} + +fn add_dep(name: &str, filter: Filter, deps: &mut DuneDependencies) { + if filter == Filter::Skip { + return; + } + + let name = name.to_lowercase(); + let name = match name.as_str() { + // provided by `buildDunePackage` itself + "ocaml" | "ocaml-base-compiler" | "ocaml-variants" | "dune" => return, + // system dependencies, e.g. `conf-pkg-config` + _ if name.starts_with("conf-") => return, + "ocamlfind" => "findlib", + _ => name.as_str(), + }; + + let set = match filter { + Filter::Test => &mut deps.check, + Filter::Skip | Filter::None => &mut deps.build, + }; + set.insert(name.into()); +} + +/// tools required by dune extensions +fn dune_tool(tool: &str) -> Option<&'static str> { + match tool { + "cinaps" => Some("cinaps"), + "melange" => Some("melange"), + "reason" => Some("reason"), + _ => None, + } +} + +fn load_dune_license(items: &[Node], deps: &mut DuneDependencies) { + for item in items { + if let Node::Sym(license) | Node::Str(license) = item { + for license in parse_spdx_expression(license, "dune-project") { + deps.licenses.insert(license); + } + } + } +} + +// Parsing dune-project files + +fn load_dune_project(src: &str, deps: &mut DuneDependencies) { + for node in lex(src, b';') { + let Node::Group('(', items) = node else { + continue; + }; + let Some(Node::Sym(name)) = items.first() else { + continue; + }; + match name.as_str() { + "license" => load_dune_license(&items[1..], deps), + "using" => { + let Some(Node::Sym(tool)) = items.get(1) else { + continue; + }; + if let Some(pkg) = dune_tool(tool) { + deps.tools.insert(pkg); + } + } + "package" => { + for item in &items[1..] { + let Node::Group('(', fields) = item else { + continue; + }; + let Some(Node::Sym(field)) = fields.first() else { + continue; + }; + if field == "depends" { + for dep in &fields[1..] { + add_dune_project_dep(dep, deps); + } + } else if field == "license" { + load_dune_license(&fields[1..], deps); + } + } + } + _ => {} + } + } +} + +fn add_dune_project_dep(node: &Node, deps: &mut DuneDependencies) { + let (name, filter) = match node { + Node::Sym(name) | Node::Str(name) => (name, Filter::None), + Node::Group('(', items) => match items.first() { + Some(Node::Sym(name)) | Some(Node::Str(name)) => { + (name, filter_dune_project(&items[1..])) + } + _ => return, + }, + _ => return, + }; + add_dep(name, filter, deps); +} + +fn filter_dune_project(items: &[Node]) -> Filter { + let mut filter = Filter::None; + for item in items { + match item { + Node::Sym(flag) => match flag.as_str() { + ":with-test" => filter = filter.max(Filter::Test), + ":with-doc" | ":with-dev-setup" | ":post" => filter = Filter::Skip, + _ => {} + }, + Node::Group('(', items) => filter = filter.max(filter_dune_project(items)), + _ => {} + } + } + filter +} + +// Parsing opam files + +fn load_opam(src: &str, deps: &mut DuneDependencies) { + let nodes = lex(src, b'#'); + for (i, node) in nodes.iter().enumerate() { + let Node::Sym(field) = node else { + continue; + }; + // `depends:` is lexed as a single atom since `:` isn't an atom terminator + let Some(field) = field.strip_suffix(':') else { + continue; + }; + if !matches!(field, "depends" | "depopts" | "license") { + continue; + } + if field == "license" { + if let Some(Node::Str(license) | Node::Sym(license)) = nodes.get(i + 1) { + for license in parse_spdx_expression(license, "opam file") { + deps.licenses.insert(license); + } + } + continue; + } + let Some(Node::Group('[', items)) = nodes.get(i + 1) else { + continue; + }; + + let mut items = items.iter().peekable(); + while let Some(item) = items.next() { + let name = match item { + Node::Sym(name) | Node::Str(name) => name, + _ => continue, + }; + let filter = match items.peek() { + Some(Node::Group('{', filter)) => filter_opam(filter), + _ => Filter::None, + }; + add_dep(name, filter, deps); + } + } +} + +fn filter_opam(items: &[Node]) -> Filter { + let mut filter = Filter::None; + for item in items { + match item { + Node::Sym(flag) => match flag.as_str() { + "with-test" => filter = filter.max(Filter::Test), + "with-doc" | "with-dev-setup" | "post" | "dev" => filter = Filter::Skip, + _ => {} + }, + Node::Group('(', items) | Node::Group('{', items) => { + filter = filter.max(filter_opam(items)) + } + _ => {} + } + } + filter +} + +// Lexing dune-project and opam files + +#[derive(Debug)] +enum Node { + Sym(String), + Str(String), + Group(char, Vec), +} + +/// `comment` is `;` for dune-project files and `#` for opam files +fn lex(src: &str, comment: u8) -> Vec { + let mut lex = Lex { + src: src.as_bytes(), + pos: 0, + comment, + }; + lex.nodes(0).unwrap_or_default() +} + +struct Lex<'a> { + src: &'a [u8], + pos: usize, + comment: u8, +} + +impl Lex<'_> { + fn nodes(&mut self, depth: u8) -> Option> { + if depth >= 48 { + return None; + } + + let mut nodes = Vec::new(); + loop { + self.skip_trivia(); + match self.src.get(self.pos) { + None | Some(b')' | b'}' | b']') => return Some(nodes), + Some(_) => nodes.push(self.node(depth)?), + } + } + } + + fn node(&mut self, depth: u8) -> Option { + match self.src[self.pos] { + b'"' => Some(self.string()), + c @ (b'(' | b'{' | b'[') => { + self.pos += 1; + let group = self.nodes(depth + 1)?; + if self.src.get(self.pos) == Some(&closing(c)) { + self.pos += 1; + } + Some(Node::Group(c as char, group)) + } + _ => Some(self.sym()), + } + } + + fn skip_trivia(&mut self) { + while let Some(&c) = self.src.get(self.pos) { + if c == self.comment { + while self.src.get(self.pos).is_some_and(|&c| c != b'\n') { + self.pos += 1; + } + } else if c.is_ascii_whitespace() { + self.pos += 1; + } else { + return; + } + } + } + + fn string(&mut self) -> Node { + self.pos += 1; + let mut bytes = Vec::new(); + while let Some(&c) = self.src.get(self.pos) { + match c { + b'"' => { + self.pos += 1; + break; + } + b'\\' => { + self.pos += 1; + match self.src.get(self.pos) { + Some(&c) => { + bytes.push(match c { + b'n' => b'\n', + b't' => b'\t', + b'r' => b'\r', + _ => c, + }); + self.pos += 1; + } + None => break, + } + } + _ => { + bytes.push(c); + self.pos += 1; + } + } + } + Node::Str(String::from_utf8_lossy(&bytes).into_owned()) + } + + fn sym(&mut self) -> Node { + let start = self.pos; + while let Some(&c) = self.src.get(self.pos) { + if c.is_ascii_whitespace() + || c == self.comment + || matches!(c, b'(' | b')' | b'{' | b'}' | b'[' | b']' | b'"') + { + break; + } + self.pos += 1; + } + Node::Sym(String::from_utf8_lossy(&self.src[start..self.pos]).into_owned()) + } +} + +const fn closing(open: u8) -> u8 { + match open { + b'(' => b')', + b'{' => b'}', + _ => b']', + } +} + +#[cfg(test)] +mod tests { + use std::fs::write; + + use insta::assert_debug_snapshot; + use tempfile::TempDir; + + use super::get_dune_dependencies; + + const OCAML_LSP_DUNE_PROJECT: &str = include_str!("fixtures/ocaml-lsp.dune-project"); + const OCAML_LSP_OPAM: &str = include_str!("fixtures/ocaml-lsp-server.opam"); + + #[test] + fn ocaml_lsp() { + let dir = TempDir::new().unwrap(); + write(dir.path().join("dune-project"), OCAML_LSP_DUNE_PROJECT).unwrap(); + assert_debug_snapshot!(get_dune_dependencies(dir.path())); + } + + #[test] + fn ocaml_lsp_opam() { + let dir = TempDir::new().unwrap(); + write(dir.path().join("ocaml-lsp-server.opam"), OCAML_LSP_OPAM).unwrap(); + assert_debug_snapshot!(get_dune_dependencies(dir.path())); + } +} diff --git a/src/lang/fixtures/ocaml-lsp-server.opam b/src/lang/fixtures/ocaml-lsp-server.opam new file mode 100644 index 00000000..e0d95c23 --- /dev/null +++ b/src/lang/fixtures/ocaml-lsp-server.opam @@ -0,0 +1,72 @@ +# This file is generated by dune, edit dune-project instead +opam-version: "2.0" +synopsis: "LSP Server for OCaml" +description: "An LSP server for OCaml." +maintainer: ["Rudi Grinberg "] +authors: [ + "Andrey Popp <8mayday@gmail.com>" + "Rusty Key " + "Louis Roché " + "Oleksiy Golovko " + "Rudi Grinberg " + "Sacha Ayoun " + "cannorin " + "Ulugbek Abdullaev " + "Thibaut Mattio " + "Max Lantas " +] +license: "ISC" +homepage: "https://github.com/ocaml/ocaml-lsp" +bug-reports: "https://github.com/ocaml/ocaml-lsp/issues" +depends: [ + "dune" {>= "3.0"} + "yojson" + "base" {>= "v0.16.0"} + "lsp" {= version} + "jsonrpc" {= version} + "re" {>= "1.5.0"} + "ppx_yojson_conv_lib" {>= "v0.14"} + "dune-rpc" {>= "3.22.0"} + "chrome-trace" {>= "3.3.0"} + "dyn" + "stdune" {>= "3.22.0"} + "fiber" {>= "3.1.1" & < "4.0.0"} + "ocaml" {>= "5.5" & < "5.6"} + "xdg" + "ordering" + "dune-build-info" {>= "3.22.0"} + "spawn" + "astring" + "camlp-streams" + "ppx_expect" {>= "v0.17.0" & with-test} + "ocamlformat" {with-test & = "0.28.1"} + "ocamlc-loc" {>= "3.7.0"} + "pp" {>= "1.1.2"} + "csexp" {>= "1.5"} + "ocamlformat-rpc-lib" {>= "0.21.0"} + "odoc" {with-doc} + "merlin-lib" {>= "5.8" & < "5.9"} + "ocaml-index" {post} + "ppx_yojson_conv" {with-dev-setup} +] +dev-repo: "git+https://github.com/ocaml/ocaml-lsp.git" +build: [ + ["dune" "subst"] {dev} + [ + "dune" + "build" + "-p" + name + "-j" + jobs + "@install" + "@doc" {with-doc} + ] +] + +pin-depends: [ + [ "merlin-lib.5.7-504" "git+https://github.com/ocaml/merlin.git#main" ] + [ "ocaml-index.5.7-504" "git+https://github.com/ocaml/merlin.git#main" ] +] + +x-maintenance-intent: [ "(latest)" ] diff --git a/src/lang/fixtures/ocaml-lsp.dune-project b/src/lang/fixtures/ocaml-lsp.dune-project new file mode 100644 index 00000000..1bf9aaf1 --- /dev/null +++ b/src/lang/fixtures/ocaml-lsp.dune-project @@ -0,0 +1,84 @@ +(lang dune 3.0) +(using cinaps 1.0) +(name lsp) + +(implicit_transitive_deps false) + +(license ISC) +(maintainers "Rudi Grinberg ") +(authors + "Andrey Popp <8mayday@gmail.com>" + "Rusty Key " + "Louis Roché " + "Oleksiy Golovko " + "Rudi Grinberg " + "Sacha Ayoun " + "cannorin " + "Ulugbek Abdullaev " + "Thibaut Mattio " + "Max Lantas ") + +(source (github ocaml/ocaml-lsp)) + +(generate_opam_files true) + +(package + (name lsp) + (synopsis "LSP protocol implementation in OCaml") + (description " +Implementation of the LSP protocol in OCaml. It is designed to be as portable as +possible and does not make any assumptions about IO. +") + (depends + (jsonrpc (= :version)) + yojson + (ppx_yojson_conv_lib (>= "v0.14")) + (cinaps :with-test) + (ppx_expect (and (>= v0.17.0) :with-test)) + (uutf (>= 1.0.2)) + (odoc :with-doc) + (ocaml (>= 4.14)) + (ppx_yojson_conv :with-dev-setup))) + +(package + (name ocaml-lsp-server) + (synopsis "LSP Server for OCaml") + (description "An LSP server for OCaml.") + (depends + yojson + (base (>= v0.16.0)) + (lsp (= :version)) + (jsonrpc (= :version)) + (re (>= 1.5.0)) + (ppx_yojson_conv_lib (>= "v0.14")) + (dune-rpc (>= 3.22.0)) + (chrome-trace (>= 3.3.0)) + dyn + (stdune (>= 3.22.0)) + (fiber (and (>= 3.1.1) (< 4.0.0))) + (ocaml (and (>= 5.5) (< 5.6))) + xdg + ordering + (dune-build-info (>= 3.22.0)) + spawn + astring + camlp-streams + (ppx_expect (and (>= v0.17.0) :with-test)) + (ocamlformat (and :with-test (= 0.28.1))) + (ocamlc-loc (>= 3.7.0)) + (pp (>= 1.1.2)) + (csexp (>= 1.5)) + (ocamlformat-rpc-lib (>= 0.21.0)) + (odoc :with-doc) + (merlin-lib (and (>= 5.8) (< 5.9))) + (ocaml-index :post) + (ppx_yojson_conv :with-dev-setup))) + +(package + (name jsonrpc) + (synopsis "Jsonrpc protocol implementation") + (description "See https://www.jsonrpc.org/specification") + (depends + (yojson (>= 2.0)) + (ocaml (>= 4.08)) + (odoc :with-doc))) diff --git a/src/lang/go/snapshots/nix_init__lang__go__tests__basic.snap b/src/lang/go/snapshots/nix_init__lang__go__tests__basic.snap index e7752937..fe8a223a 100644 --- a/src/lang/go/snapshots/nix_init__lang__go__tests__basic.snap +++ b/src/lang/go/snapshots/nix_init__lang__go__tests__basic.snap @@ -31,5 +31,14 @@ AllInputs { aarch64_linux: {}, x86_64_linux: {}, }, + check_inputs: Inputs { + always: {}, + darwin: {}, + aarch64_darwin: {}, + x86_64_darwin: {}, + linux: {}, + aarch64_linux: {}, + x86_64_linux: {}, + }, env: {}, } diff --git a/src/lang/mod.rs b/src/lang/mod.rs index ce0c9ed9..3f0d2e38 100644 --- a/src/lang/mod.rs +++ b/src/lang/mod.rs @@ -1,3 +1,4 @@ +pub mod dune; pub mod go; pub mod npm; pub mod python; diff --git a/src/lang/rust/snapshots/nix_init__lang__rust__tests__libz_ng.snap b/src/lang/rust/snapshots/nix_init__lang__rust__tests__libz_ng.snap index 4e699fa6..8cdbb24c 100644 --- a/src/lang/rust/snapshots/nix_init__lang__rust__tests__libz_ng.snap +++ b/src/lang/rust/snapshots/nix_init__lang__rust__tests__libz_ng.snap @@ -23,5 +23,14 @@ AllInputs { aarch64_linux: {}, x86_64_linux: {}, }, + check_inputs: Inputs { + always: {}, + darwin: {}, + aarch64_darwin: {}, + x86_64_darwin: {}, + linux: {}, + aarch64_linux: {}, + x86_64_linux: {}, + }, env: {}, } diff --git a/src/lang/rust/snapshots/nix_init__lang__rust__tests__libz_static.snap b/src/lang/rust/snapshots/nix_init__lang__rust__tests__libz_static.snap index 4f112334..eddd9f68 100644 --- a/src/lang/rust/snapshots/nix_init__lang__rust__tests__libz_static.snap +++ b/src/lang/rust/snapshots/nix_init__lang__rust__tests__libz_static.snap @@ -23,5 +23,14 @@ AllInputs { aarch64_linux: {}, x86_64_linux: {}, }, + check_inputs: Inputs { + always: {}, + darwin: {}, + aarch64_darwin: {}, + x86_64_darwin: {}, + linux: {}, + aarch64_linux: {}, + x86_64_linux: {}, + }, env: {}, } diff --git a/src/lang/rust/snapshots/nix_init__lang__rust__tests__libz_stock.snap b/src/lang/rust/snapshots/nix_init__lang__rust__tests__libz_stock.snap index b07be0d8..dd47d01c 100644 --- a/src/lang/rust/snapshots/nix_init__lang__rust__tests__libz_stock.snap +++ b/src/lang/rust/snapshots/nix_init__lang__rust__tests__libz_stock.snap @@ -25,5 +25,14 @@ AllInputs { aarch64_linux: {}, x86_64_linux: {}, }, + check_inputs: Inputs { + always: {}, + darwin: {}, + aarch64_darwin: {}, + x86_64_darwin: {}, + linux: {}, + aarch64_linux: {}, + x86_64_linux: {}, + }, env: {}, } diff --git a/src/lang/rust/snapshots/nix_init__lang__rust__tests__llvm.snap b/src/lang/rust/snapshots/nix_init__lang__rust__tests__llvm.snap index 46c97422..d62c2ce8 100644 --- a/src/lang/rust/snapshots/nix_init__lang__rust__tests__llvm.snap +++ b/src/lang/rust/snapshots/nix_init__lang__rust__tests__llvm.snap @@ -25,6 +25,15 @@ AllInputs { aarch64_linux: {}, x86_64_linux: {}, }, + check_inputs: Inputs { + always: {}, + darwin: {}, + aarch64_darwin: {}, + x86_64_darwin: {}, + linux: {}, + aarch64_linux: {}, + x86_64_linux: {}, + }, env: { "LLVM_SYS_150_PREFIX": ( "llvmPackages_15.llvm.dev", diff --git a/src/lang/rust/snapshots/nix_init__lang__rust__tests__zstd_env.snap b/src/lang/rust/snapshots/nix_init__lang__rust__tests__zstd_env.snap index ae227667..dd06f499 100644 --- a/src/lang/rust/snapshots/nix_init__lang__rust__tests__zstd_env.snap +++ b/src/lang/rust/snapshots/nix_init__lang__rust__tests__zstd_env.snap @@ -25,6 +25,15 @@ AllInputs { aarch64_linux: {}, x86_64_linux: {}, }, + check_inputs: Inputs { + always: {}, + darwin: {}, + aarch64_darwin: {}, + x86_64_darwin: {}, + linux: {}, + aarch64_linux: {}, + x86_64_linux: {}, + }, env: { "ZSTD_SYS_USE_PKG_CONFIG": ( "true", diff --git a/src/lang/rust/snapshots/nix_init__lang__rust__tests__zstd_old.snap b/src/lang/rust/snapshots/nix_init__lang__rust__tests__zstd_old.snap index 262ea436..489e9b20 100644 --- a/src/lang/rust/snapshots/nix_init__lang__rust__tests__zstd_old.snap +++ b/src/lang/rust/snapshots/nix_init__lang__rust__tests__zstd_old.snap @@ -21,5 +21,14 @@ AllInputs { aarch64_linux: {}, x86_64_linux: {}, }, + check_inputs: Inputs { + always: {}, + darwin: {}, + aarch64_darwin: {}, + x86_64_darwin: {}, + linux: {}, + aarch64_linux: {}, + x86_64_linux: {}, + }, env: {}, } diff --git a/src/lang/rust/snapshots/nix_init__lang__rust__tests__zstd_pkg_config.snap b/src/lang/rust/snapshots/nix_init__lang__rust__tests__zstd_pkg_config.snap index 7c8b4343..322a581d 100644 --- a/src/lang/rust/snapshots/nix_init__lang__rust__tests__zstd_pkg_config.snap +++ b/src/lang/rust/snapshots/nix_init__lang__rust__tests__zstd_pkg_config.snap @@ -25,5 +25,14 @@ AllInputs { aarch64_linux: {}, x86_64_linux: {}, }, + check_inputs: Inputs { + always: {}, + darwin: {}, + aarch64_darwin: {}, + x86_64_darwin: {}, + linux: {}, + aarch64_linux: {}, + x86_64_linux: {}, + }, env: {}, } diff --git a/src/lang/snapshots/nix_init__lang__dune__tests__ocaml_lsp.snap b/src/lang/snapshots/nix_init__lang__dune__tests__ocaml_lsp.snap new file mode 100644 index 00000000..8f3a8cf6 --- /dev/null +++ b/src/lang/snapshots/nix_init__lang__dune__tests__ocaml_lsp.snap @@ -0,0 +1,42 @@ +--- +source: src/lang/dune.rs +expression: get_dune_dependencies(dir.path()) +--- +DuneDependencies { + build: { + "astring", + "base", + "camlp-streams", + "chrome-trace", + "csexp", + "dune-build-info", + "dune-rpc", + "dyn", + "fiber", + "jsonrpc", + "lsp", + "merlin-lib", + "ocamlc-loc", + "ocamlformat-rpc-lib", + "ordering", + "pp", + "ppx_yojson_conv_lib", + "re", + "spawn", + "stdune", + "uutf", + "xdg", + "yojson", + }, + check: { + "cinaps", + "ocamlformat", + "ppx_expect", + }, + tools: { + "cinaps", + }, + licenses: { + "isc", + }, +} diff --git a/src/lang/snapshots/nix_init__lang__dune__tests__ocaml_lsp_opam.snap b/src/lang/snapshots/nix_init__lang__dune__tests__ocaml_lsp_opam.snap new file mode 100644 index 00000000..3c5e585d --- /dev/null +++ b/src/lang/snapshots/nix_init__lang__dune__tests__ocaml_lsp_opam.snap @@ -0,0 +1,38 @@ +--- +source: src/lang/dune.rs +expression: get_dune_dependencies(dir.path()) +--- +DuneDependencies { + build: { + "astring", + "base", + "camlp-streams", + "chrome-trace", + "csexp", + "dune-build-info", + "dune-rpc", + "dyn", + "fiber", + "jsonrpc", + "lsp", + "merlin-lib", + "ocamlc-loc", + "ocamlformat-rpc-lib", + "ordering", + "pp", + "ppx_yojson_conv_lib", + "re", + "spawn", + "stdune", + "xdg", + "yojson", + }, + check: { + "ocamlformat", + "ppx_expect", + }, + tools: {}, + licenses: { + "isc", + }, +} diff --git a/src/main.rs b/src/main.rs index 9dbbee78..5aa633cd 100644 --- a/src/main.rs +++ b/src/main.rs @@ -36,11 +36,15 @@ use zip::ZipArchive; use crate::{ cfg::load_config, - cli::{BuilderFunction, CargoVendor, Opts}, + cli::{ + BuilderFunction::{self}, + CargoVendor, Opts, + }, cmd::{NIX, NURL}, codegen::{ - BuilderDispatch, Codegen, SourceLayout, drv::MkDerivation, go::BuildGoModule, - npm::BuildNpmPackage, python::BuildPythonPackage, rust::BuildRustPackage, + BuilderDispatch, Codegen, SourceLayout, drv::MkDerivation, dune::BuildDunePackage, + go::BuildGoModule, npm::BuildNpmPackage, python::BuildPythonPackage, + rust::BuildRustPackage, }, fetcher::{Fetcher, FetcherDispatch, PackageInfo, PypiFormat, Revisions, Version}, frontend::{Frontend, headless, readline}, @@ -384,6 +388,7 @@ async fn run() -> Result<()> { let builder = match (opts.builder, opts.cargo_vendor) { (Some(builder), rust @ Some(vendor)) if layout.has_cargo => match builder { + BuilderFunction::BuildDunePackage => BuildDunePackage.into(), BuilderFunction::BuildGoModule => BuildGoModule.into(), BuilderFunction::BuildNpmPackage => BuildNpmPackage.into(), BuilderFunction::BuildPythonApplication => BuildPythonPackage::new(true, rust).into(), @@ -395,6 +400,7 @@ async fn run() -> Result<()> { (Some(builder), _) => { let rust = layout.has_cargo.then_some(CargoVendor::FetchCargoVendor); match builder { + BuilderFunction::BuildDunePackage => BuildDunePackage.into(), BuilderFunction::BuildGoModule => BuildGoModule.into(), BuilderFunction::BuildNpmPackage => BuildNpmPackage.into(), BuilderFunction::BuildPythonApplication => { @@ -438,6 +444,10 @@ async fn run() -> Result<()> { } } + if layout.has_dune { + builders.push(BuildDunePackage.into()); + } + if layout.has_python { for application in [true, false] { builders.push(BuildPythonPackage::new(application, None).into()); diff --git a/tests/cmd/dune.out/default.nix b/tests/cmd/dune.out/default.nix new file mode 100644 index 00000000..db584e58 --- /dev/null +++ b/tests/cmd/dune.out/default.nix @@ -0,0 +1,67 @@ +{ + lib, + buildDunePackage, + fetchFromGitHub, + ocamlPackages, + nix-update-script, +}: + +buildDunePackage (finalAttrs: { + pname = "ocaml-lsp"; + version = "1.27.0"; + __structuredAttrs = true; + + src = fetchFromGitHub { + owner = "ocaml"; + repo = "ocaml-lsp"; + tag = finalAttrs.version; + hash = "sha256-XrNYqNeaJAvkSYU0vha0apbN9uAYiGIuiJJMJMAN5ug="; + }; + + nativeBuildInputs = [ + ocamlPackages.cinaps + ]; + + buildInputs = [ + ocamlPackages.astring + ocamlPackages.base + ocamlPackages.camlp-streams + ocamlPackages.chrome-trace + ocamlPackages.csexp + ocamlPackages.dune-build-info + ocamlPackages.dune-rpc + ocamlPackages.dyn + ocamlPackages.fiber + ocamlPackages.jsonrpc + ocamlPackages.lsp + ocamlPackages.merlin-lib + ocamlPackages.ocamlc-loc + ocamlPackages.ocamlformat-rpc-lib + ocamlPackages.ordering + ocamlPackages.pp + ocamlPackages.ppx_yojson_conv_lib + ocamlPackages.re + ocamlPackages.spawn + ocamlPackages.stdune + ocamlPackages.uutf + ocamlPackages.xdg + ocamlPackages.yojson + ]; + + checkInputs = [ + ocamlPackages.cinaps + ocamlPackages.ocamlformat + ocamlPackages.ppx_expect + ]; + + passthru.updateScript = nix-update-script { }; + + meta = { + description = "[..]"; + homepage = "https://github.com/ocaml/ocaml-lsp"; + changelog = "https://github.com/ocaml/ocaml-lsp/blob/${finalAttrs.src.rev}/CHANGES.md"; + license = lib.licenses.isc; + maintainers = with lib.maintainers; [ alice ]; + mainProgram = "ocaml-lsp"; + }; +}) diff --git a/tests/cmd/dune.toml b/tests/cmd/dune.toml new file mode 100644 index 00000000..7ab36300 --- /dev/null +++ b/tests/cmd/dune.toml @@ -0,0 +1,5 @@ +args = [ + "--headless", + "--url=https://github.com/ocaml/ocaml-lsp", + "--rev=1.27.0", +]