nebius/SWE-rebench-V2-PRs huggingface dataset:
Repository: domluna/JuliaFormatter.jl
Pull request #288 (2020-09-12 14:37:32)

Give `//` the same binaryop whitespace exception as `^`
As mentioned in #283, BlueStyle recommends exempting both `^` and `//` from the rule that binary operators are surrounded by whitespace. `a ^ b` is already formatted as `a^b`. This PR adds the analogous formatting `x // y` -> `x//y`.

Since `x//y` is a single `Rational` number, i think this makes sense as a general rule, so i've added it to the DefaultStyle - does that seem reasonable?

This is my first attempt at making contributions to the code in the package, so please let me know if this approach seems right 😄 Hopefully tests show the intended behaviour


Patch:
diff --git a/src/styles/default/pretty.jl b/src/styles/default/pretty.jl
index 64d7e16c..9787e8d0 100644
--- a/src/styles/default/pretty.jl
+++ b/src/styles/default/pretty.jl
@@ -1364,14 +1364,25 @@ function p_binaryopcall(
     elseif op.kind === Tokens.EX_OR
         add_node!(t, Whitespace(1), s)
         add_node!(t, pretty(style, op, s), s, join_lines = true)
-    elseif (is_number(cst[1]) || op.kind === Tokens.CIRCUMFLEX_ACCENT) && op.dot
+    elseif (
+        is_number(cst[1]) ||
+        op.kind === Tokens.FWDFWD_SLASH ||
+        op.kind === Tokens.CIRCUMFLEX_ACCENT
+    ) && op.dot
         add_node!(t, Whitespace(1), s)
         add_node!(t, pretty(style, op, s), s, join_lines = true)
         nest ? add_node!(t, Placeholder(1), s) : add_node!(t, Whitespace(1), s)
-    elseif (
-        nospace ||
-        (CSTParser.precedence(op) in (8, 13, 14, 16) && op.kind !== Tokens.ANON_FUNC)
-    ) && op.kind !== Tokens.IN
+    elseif op.kind !== Tokens.IN && (
+        nospace || (
+            op.kind !== Tokens.ANON_FUNC && CSTParser.precedence(op) in (
+                CSTParser.ColonOp,
+                CSTParser.RationalOp,
+                CSTParser.PowerOp,
+                CSTParser.DeclarationOp,
+                CSTParser.DotOp,
+            )
+        )
+    )
         add_node!(t, pretty(style, op, s), s, join_lines = true)
     else
         add_node!(t, Whitespace(1), s)


Test patch:
diff --git a/test/default_style.jl b/test/default_style.jl
index 0cd09ebd..6cf7e074 100644
--- a/test/default_style.jl
+++ b/test/default_style.jl
@@ -164,6 +164,7 @@
         @test fmt("10.0 .^ a") == "10.0 .^ a"
         @test fmt("a.^b") == "a .^ b"
         @test fmt("a.^10.") == "a .^ 10.0"
+        @test fmt("a.//10") == "a .// 10"
     end
 
     @testset "toplevel" begin
@@ -376,6 +377,9 @@
         str = "!(typ <: ArithmeticTypes)"
         @test fmt(str) == str
 
+        # `//` and `^` are binary ops without whitespace around them
+        @test fmt("1 // 2 + 3 ^ 4") == "1//2 + 3^4"
+
         # Function def
 
         str_ = """foo() = if cond a else b end"""
Repository: domluna/JuliaFormatter.jl
Pull request #307 (2020-09-27 17:40:15)

BlueStyle always perform multi-line nest if a multi-line argument is present
Implements what's discussed in https://github.com/domluna/JuliaFormatter.jl/issues/283#issuecomment-698950649


Patch:
diff --git a/Project.toml b/Project.toml
index 540683d5..1fde788b 100644
--- a/Project.toml
+++ b/Project.toml
@@ -1,7 +1,7 @@
 name = "JuliaFormatter"
 uuid = "98e50ef6-434e-11e9-1051-2b60c6c9e899"
 authors = ["Dominique Luna <dluna132@gmail.com>"]
-version = "0.9.4"
+version = "0.9.5"
 
 [deps]
 CSTParser = "00ebfdb7-1f24-5e51-bd34-a7502290713f"
diff --git a/src/styles/blue/nest.jl b/src/styles/blue/nest.jl
index 2cbcb27b..e19de244 100644
--- a/src/styles/blue/nest.jl
+++ b/src/styles/blue/nest.jl
@@ -3,15 +3,19 @@ function n_tupleh!(bs::BlueStyle, fst::FST, s::State)
     lidx = findlast(n -> n.typ === PLACEHOLDER, fst.nodes)
     fidx = findfirst(n -> n.typ === PLACEHOLDER, fst.nodes)
     opener = findfirst(is_opener, fst.nodes) !== nothing
+    multiline_arg = findfirst(is_block, fst.nodes) !== nothing
+    multiline_arg && (fst.nest_behavior = AlwaysNest)
 
     if lidx !== nothing && (line_margin > s.opts.margin || must_nest(fst))
-        fidx = findfirst(n -> n.typ === PLACEHOLDER, fst.nodes)
         args_range = fidx+1:lidx-1
         args_margin = sum(length.(fst[args_range]))
 
-        nest_to_oneline =
+        nest_to_oneline = if can_nest(fst)
             (fst.indent + s.opts.indent + args_margin <= s.opts.margin) &&
-            !contains_comment(fst.nodes[args_range])
+                !contains_comment(fst.nodes[args_range])
+        else
+            false
+        end
 
         # @info "" nest_to_oneline fst.indent fst.indent + s.opts.indent + args_margin args_margin
 
@@ -59,6 +63,7 @@ function n_tupleh!(bs::BlueStyle, fst::FST, s::State)
         if opener
             s.line_offset = fst[end].indent + 1
         end
+
     else
         extra_margin = fst.extra_margin
         opener && (extra_margin += 1)


Test patch:
diff --git a/test/blue_style.jl b/test/blue_style.jl
index 6a21b78d..f928b3ed 100644
--- a/test/blue_style.jl
+++ b/test/blue_style.jl
@@ -138,6 +138,33 @@
         """
         @test bluefmt(str_, 4, 37) == str
 
+        str = """
+        Dict(
+            "options" => join(
+                imap(Iterators.filter(keep_option, connection_options)) do (k, v)
+                    "-c k=(show_option(v))"
+                end,
+                " ",
+            ),
+        )
+        """
+        @test bluefmt(str, 4, 92) == str
+
+        str_ = """
+        var = foo(
+            map(arr) do x
+                x * 10
+            end, "")
+        """
+        str = """
+        var = foo(
+            map(arr) do x
+                x * 10
+            end,
+            "",
+        )
+        """
+        @test bluefmt(str_, 4, 92) == str
     end
 
     @testset "do not prepend return in `do` blocks" begin
Repository: domluna/JuliaFormatter.jl
Pull request #479 (2021-09-19 21:16:09)

Comprehension margin fix


Patch:
diff --git a/Project.toml b/Project.toml
index 9191bb90..5b867c1c 100644
--- a/Project.toml
+++ b/Project.toml
@@ -1,7 +1,7 @@
 name = "JuliaFormatter"
 uuid = "98e50ef6-434e-11e9-1051-2b60c6c9e899"
 authors = ["Dominique Luna <dluna132@gmail.com>"]
-version = "0.16.0"
+version = "0.16.1"
 
 [deps]
 CSTParser = "00ebfdb7-1f24-5e51-bd34-a7502290713f"
diff --git a/src/styles/default/nest.jl b/src/styles/default/nest.jl
index d698621c..c662306b 100644
--- a/src/styles/default/nest.jl
+++ b/src/styles/default/nest.jl
@@ -328,6 +328,7 @@ function n_comprehension!(ds::DefaultStyle, fst::FST, s::State; indent = -1)
     style = getstyle(ds)
     line_offset = s.line_offset
     line_margin = s.line_offset + length(fst) + fst.extra_margin
+    nested = false
 
     closer = is_closer(fst[end])
     if closer && (line_margin > s.opts.margin || must_nest(fst))
@@ -342,6 +343,7 @@ function n_comprehension!(ds::DefaultStyle, fst::FST, s::State; indent = -1)
 
         add_indent!(fst, s, s.opts.indent)
         fst[end].indent = fst.indent - s.opts.indent
+        nested = true
     end
 
     for (i, n) in enumerate(fst.nodes)
@@ -357,7 +359,7 @@ function n_comprehension!(ds::DefaultStyle, fst::FST, s::State; indent = -1)
         elseif i == length(fst.nodes) && !closer
             nest!(style, n, s)
         else
-            n.extra_margin = 1
+            n.extra_margin = nested ? 0 : 1
             nest!(style, n, s)
         end
     end


Test patch:
diff --git a/test/default_style.jl b/test/default_style.jl
index a8b2ef59..8cbe42e9 100644
--- a/test/default_style.jl
+++ b/test/default_style.jl
@@ -4386,4 +4386,16 @@ some_function(
         str = "const FOO = '😢'"
         @test fmt(str) == str
     end
+
+    @testset "comprehension leftover extra margin" begin
+        str_ = """
+        src_idx = [mod1(div(dest_idx[dim] - 1, inner[dim]) + 1, S[dim]) for dim = 1:length(S)]
+        """
+        str = """
+        src_idx = [
+            mod1(div(dest_idx[dim] - 1, inner[dim]) + 1, S[dim]) for dim = 1:length(S)
+        ]
+        """
+        @test fmt(str_, 4, 78) == str
+    end
 end
Repository: domluna/JuliaFormatter.jl
Pull request #660 (2022-11-29 19:29:08)

Remove warning which occurs when `long_to_short_function_def` and `short_to_long_function_def` are both `true`
#657 shows these options can be set in alongside eachother just fine.


Patch:
diff --git a/src/JuliaFormatter.jl b/src/JuliaFormatter.jl
index 7dcc37f1..f229db87 100644
--- a/src/JuliaFormatter.jl
+++ b/src/JuliaFormatter.jl
@@ -653,9 +653,6 @@ function format_text(text::AbstractString, style::SciMLStyle; maxiters = 3, kwar
 end
 
 function format_text(text::AbstractString, style::AbstractStyle, opts::Options)
-    if opts.long_to_short_function_def && opts.short_to_long_function_def
-        @warn "Both `long_to_short_function_def` and `short_to_long_function_def` are set"
-    end
     if opts.always_for_in == true
         @assert valid_for_in_op(opts.for_in_replacement) "`for_in_replacement` is set to an invalid operator \"$(opts.for_in_replacement)\", valid operators are $(VALID_FOR_IN_OPERATORS). Change it to one of the valid operators and then reformat."
     end
diff --git a/src/styles/default/pretty.jl b/src/styles/default/pretty.jl
index f29c8507..3b546b8a 100644
--- a/src/styles/default/pretty.jl
+++ b/src/styles/default/pretty.jl
@@ -2150,7 +2150,7 @@ function p_vcat(ds::DefaultStyle, cst::CSTParser.EXPR, s::State)
                 add_node!(t, Placeholder(1), s)
                 # Keep trailing semicolon if there's only one arg
             elseif length(args) == 1 && has_semicolon(s.doc, n.startline)
-                add_node!(t, InverseTrailingSemicolon(), s)
+                add_node!(t, Semicolon(), s)
                 add_node!(t, Placeholder(0), s)
             else
                 add_node!(t, Placeholder(0), s)


Test patch:
diff --git a/test/issues.jl b/test/issues.jl
index a5bb3829..fcbeec04 100644
--- a/test/issues.jl
+++ b/test/issues.jl
@@ -1486,4 +1486,22 @@
         """
         @test fmt(s, 4, 92, align_assignment = true) == s
     end
+
+    @testset "655" begin
+        s = """
+        [
+          a;
+        ]
+        """
+        @test fmt(s, 2, 92, join_lines_based_on_source = true) == s
+        @test fmt(s, 2, 1) == s
+        s = """
+        [
+          a
+        ]
+        """
+        @test fmt(s, 2, 92, join_lines_based_on_source = true, trailing_comma = nothing) ==
+              s
+        @test fmt(s, 2, 1, trailing_comma = nothing) == s
+    end
 end
diff --git a/test/options.jl b/test/options.jl
index 3f9795bd..140e2f4f 100644
--- a/test/options.jl
+++ b/test/options.jl
@@ -354,14 +354,6 @@
                 nothing
             end"""
         @test fmt(str_, 4, length(str), long_to_short_function_def = true) == str
-
-        @test_logs (:warn, r"Both `long_to_short_function_def`.*") match_mode = :any fmt(
-            "foo",
-            4,
-            1,
-            long_to_short_function_def = true,
-            short_to_long_function_def = true,
-        )
     end
 
     @testset "always use return" begin
Repository: domluna/JuliaFormatter.jl
Pull request #661 (2022-11-29 19:47:29)

Limit usage of InverseTrailingSemicolon 
Depending on the types inside a vector

```
[
  ...
]
```

Having removing or adding the semicolon can change the type entirely.

```
julia> [
       [1,0];
       ]
2-element Vector{Int64}:
 1
 0

julia> [
       [1,0]
       ]
1-element Vector{Vector{Int64}}:
 [1, 0]
```

So we should no longer do that.

fix https://github.com/domluna/JuliaFormatter.jl/issues/655


Patch:
diff --git a/src/styles/default/pretty.jl b/src/styles/default/pretty.jl
index f29c8507..3b546b8a 100644
--- a/src/styles/default/pretty.jl
+++ b/src/styles/default/pretty.jl
@@ -2150,7 +2150,7 @@ function p_vcat(ds::DefaultStyle, cst::CSTParser.EXPR, s::State)
                 add_node!(t, Placeholder(1), s)
                 # Keep trailing semicolon if there's only one arg
             elseif length(args) == 1 && has_semicolon(s.doc, n.startline)
-                add_node!(t, InverseTrailingSemicolon(), s)
+                add_node!(t, Semicolon(), s)
                 add_node!(t, Placeholder(0), s)
             else
                 add_node!(t, Placeholder(0), s)


Test patch:
diff --git a/test/issues.jl b/test/issues.jl
index a5bb3829..fcbeec04 100644
--- a/test/issues.jl
+++ b/test/issues.jl
@@ -1486,4 +1486,22 @@
         """
         @test fmt(s, 4, 92, align_assignment = true) == s
     end
+
+    @testset "655" begin
+        s = """
+        [
+          a;
+        ]
+        """
+        @test fmt(s, 2, 92, join_lines_based_on_source = true) == s
+        @test fmt(s, 2, 1) == s
+        s = """
+        [
+          a
+        ]
+        """
+        @test fmt(s, 2, 92, join_lines_based_on_source = true, trailing_comma = nothing) ==
+              s
+        @test fmt(s, 2, 1, trailing_comma = nothing) == s
+    end
 end
Repository: domluna/JuliaFormatter.jl
Pull request #695 (2023-02-20 12:56:19)

revert 663 breaking the macro like this can change semantics
close https://github.com/domluna/JuliaFormatter.jl/issues/693


Patch:
diff --git a/Project.toml b/Project.toml
index 1e3b24ea..5f7f8dff 100644
--- a/Project.toml
+++ b/Project.toml
@@ -1,7 +1,7 @@
 name = "JuliaFormatter"
 uuid = "98e50ef6-434e-11e9-1051-2b60c6c9e899"
 authors = ["Dominique Luna <dluna132@gmail.com>"]
-version = "1.0.23"
+version = "1.0.24"
 
 [deps]
 CSTParser = "00ebfdb7-1f24-5e51-bd34-a7502290713f"
diff --git a/src/styles/default/nest.jl b/src/styles/default/nest.jl
index 2a5f2921..44cc7728 100644
--- a/src/styles/default/nest.jl
+++ b/src/styles/default/nest.jl
@@ -98,8 +98,6 @@ function nest!(ds::DefaultStyle, fst::FST, s::State)
         n_call!(style, fst, s)
     elseif fst.typ === MacroCall
         n_macrocall!(style, fst, s)
-    elseif fst.typ === MacroBlock
-        n_block!(style, fst, s)
     elseif fst.typ === RefN
         n_ref!(style, fst, s)
     elseif fst.typ === TypedVcat


Test patch:
diff --git a/test/issues.jl b/test/issues.jl
index ecab8f71..0a9e07c9 100644
--- a/test/issues.jl
+++ b/test/issues.jl
@@ -316,26 +316,16 @@
         end"""
 
         # NOTE: this looks slightly off because we're compensating for escaping quotes
-        # NOTE: updated test in light of fixing #663 which allows breaking on consecutive macrocalls
-        # Meaning "@macro1 @macro2"
-        #
-        # can be
-        #
-        # """
-        # @macro1
-        # @macro2
-        # """
         str = """
         begin
             f() do
-                @info
-                @sprintf \"\"\"
-          Δmass   = %.16e\"\"\" abs(weightedsum(Q) - weightedsum(Qe)) / weightedsum(Qe)
+                @info @sprintf \"\"\"
+                Δmass   = %.16e\"\"\" abs(weightedsum(Q) - weightedsum(Qe)) /
+                                   weightedsum(Qe)
             end
         end"""
         @test fmt(str_, m = 81) == str
-        @test fmt(str_, m = 82) == str_
-        @test fmt(str, m = 200) == str
+        @test fmt(str, m = 82) == str_
     end
 
     @testset "issue #202" begin
@@ -1537,17 +1527,6 @@
         @test fmt(s, 4, 92) == s
     end
 
-    @testset "663" begin
-        s1 = """
-        @macro1 foo @macro2 bar(a=10)
-        """
-        s2 = """
-        @macro1 foo
-        @macro2 bar(a = 10)
-        """
-        @test fmt(s1, 4, 19) == s2
-    end
-
     @testset "667" begin
         s = raw"""
         \"""
Repository: domluna/JuliaFormatter.jl
Pull request #726 (2023-06-01 15:43:36)

No more nesting for trivial begin-end
Ref https://github.com/SciML/SciMLStyle/pull/36


Patch:
diff --git a/src/styles/sciml/pretty.jl b/src/styles/sciml/pretty.jl
index 2c50bdd0..07c3b667 100644
--- a/src/styles/sciml/pretty.jl
+++ b/src/styles/sciml/pretty.jl
@@ -98,24 +98,14 @@ function p_begin(ss::SciMLStyle, cst::CSTParser.EXPR, s::State)
         add_node!(t, pretty(style, cst[end], s), s, join_lines = true)
     else
         stmts_idxs = 2:length(cst)-1
-        # Don't nest into multiple lines when there's only one statement
-        # and it's not a macroblock.
-        if length(stmts_idxs) == 1 &&
-           !(cst[2].head === :macrocall && !is_closer(cst[2][end]))
-            add_node!(t, Whitespace(1), s)
-            add_node!(t, pretty(style, cst[2], s), s, join_lines = true)
-            add_node!(t, Whitespace(1), s)
-            add_node!(t, pretty(style, cst[end], s), s, join_lines = true)
-        else
-            s.indent += s.opts.indent
-            nodes = CSTParser.EXPR[]
-            for i in 2:length(cst)-1
-                push!(nodes, cst[i])
-            end
-            add_node!(t, p_block(style, nodes, s), s, max_padding = s.opts.indent)
-            s.indent -= s.opts.indent
-            add_node!(t, pretty(style, cst[end], s), s)
+        s.indent += s.opts.indent
+        nodes = CSTParser.EXPR[]
+        for i in 2:length(cst)-1
+            push!(nodes, cst[i])
         end
+        add_node!(t, p_block(style, nodes, s), s, max_padding = s.opts.indent)
+        s.indent -= s.opts.indent
+        add_node!(t, pretty(style, cst[end], s), s)
     end
     t
 end


Test patch:
diff --git a/test/issues.jl b/test/issues.jl
index deff016c..b75f79e7 100644
--- a/test/issues.jl
+++ b/test/issues.jl
@@ -1421,7 +1421,12 @@
         str = raw"""
         begin @foo(a) end
         """
-        @test format_text(str, SciMLStyle()) == str
+        str_ = raw"""
+        begin
+            @foo(a)
+        end
+        """
+        @test format_text(str, SciMLStyle()) == str_
     end
 
     @testset "613" begin
diff --git a/test/sciml_style.jl b/test/sciml_style.jl
index c6ee8c3b..b9a2ffc4 100644
--- a/test/sciml_style.jl
+++ b/test/sciml_style.jl
@@ -14,7 +14,12 @@
     str = raw"""
     begin include("hi") end
     """
-    @test format_text(str, SciMLStyle()) == str
+    formatted_str = raw"""
+    begin
+        include("hi")
+    end
+    """
+    @test format_text(str, SciMLStyle()) == formatted_str
 
     str = raw"""
     begin include("hi"); 1 end
Repository: domluna/JuliaFormatter.jl
Pull request #918 (2025-04-28 19:21:18)

fix: set `ignore_warnings=true` during parsing
Fixes https://github.com/domluna/JuliaFormatter.jl/issues/917.


Patch:
diff --git a/src/JuliaFormatter.jl b/src/JuliaFormatter.jl
index 8a76dd6c..74721bfc 100644
--- a/src/JuliaFormatter.jl
+++ b/src/JuliaFormatter.jl
@@ -207,7 +207,7 @@ function format_text(text::AbstractString, style::AbstractStyle, opts::Options)
     if opts.always_for_in == true
         @assert valid_for_in_op(opts.for_in_replacement) "`for_in_replacement` is set to an invalid operator \"$(opts.for_in_replacement)\", valid operators are $(VALID_FOR_IN_OPERATORS). Change it to one of the valid operators and then reformat."
     end
-    t = JuliaSyntax.parseall(JuliaSyntax.GreenNode, text)
+    t = JuliaSyntax.parseall(JuliaSyntax.GreenNode, text; ignore_warnings = true)
     state = State(Document(text), opts)
     text = format_text(t, style, state)
     return text
@@ -277,7 +277,7 @@ function format_text(node::JuliaSyntax.GreenNode, style::AbstractStyle, s::State
     text = normalize_line_ending(text, replacer)
 
     try
-        _ = JuliaSyntax.parseall(JuliaSyntax.GreenNode, text)
+        _ = JuliaSyntax.parseall(JuliaSyntax.GreenNode, text; ignore_warnings = true)
     catch err
         @warn "Formatted text is not parsable ... no change made."
         rethrow(err)


Test patch:
diff --git a/test/issues.jl b/test/issues.jl
index 14ea67d9..a9976c51 100644
--- a/test/issues.jl
+++ b/test/issues.jl
@@ -1947,4 +1947,10 @@
         """
         @test fmt(str_, 4, 100) == s
     end
+
+    @testset "917" begin
+        s = "using Foo: ( .. )"
+        sf = "using Foo: (..)"
+        @test fmt(s, 4, 100) == sf
+    end
 end
Repository: serverless-heaven/serverless-webpack
Pull request #234 (2017-09-21 10:41:50)

Log errors in webpack config explicitly.
## What did you implement:

This PR adds an extra log line if the webpack config file could not be loaded.
This makes the reason for errors in the configuration more clear than just printing the
actual exception without context.

## How did you implement it:

Added a try/catch around the `require()` of the configuration file.

## How can we verify it:

Implement a syntax error in your webpack config. Any try to package or deploy should mention
to the configuration file now before printing the error message or stacktrace.

## Todos:

- [x] Write tests
- [ ] Write documentation
- [x] Fix linting errors
- [x] Make sure code coverage hasn't dropped
- [x] Provide verification config / commands / resources
- [x] Enable "Allow edits from maintainers" for this PR
- [x] Update the messages below

***Is this ready for review?:*** YES
***Is it a breaking change?:*** NO



Patch:
diff --git a/lib/validate.js b/lib/validate.js
index 1983a65..1c762fd 100644
--- a/lib/validate.js
+++ b/lib/validate.js
@@ -99,7 +99,12 @@ module.exports = {
         throw new this.serverless.classes
           .Error('The webpack plugin could not find the configuration file at: ' + webpackConfigFilePath);
       }
-      this.webpackConfig = require(webpackConfigFilePath);
+      try {
+        this.webpackConfig = require(webpackConfigFilePath);
+      } catch (err) {
+        this.serverless.cli.log(`Could not load webpack config '${webpackConfigFilePath}'`);
+        return BbPromise.reject(err);
+      }
     }
 
     // Default context


Test patch:
diff --git a/tests/validate.test.js b/tests/validate.test.js
index 8668368..1e6d6c3 100644
--- a/tests/validate.test.js
+++ b/tests/validate.test.js
@@ -223,6 +223,16 @@ describe('validate', () => {
           return null;
         });
     });
+
+    it('should fail when importing a broken configuration file', () => {
+      const testConfig = 'invalid.webpack.config.js';
+      const testServicePath = 'testpath';
+      module.serverless.config.servicePath = testServicePath;
+      module.serverless.service.custom.webpack = testConfig;
+      serverless.utils.fileExistsSync = sinon.stub().returns(true);
+      return expect(module.validate()).to.be.rejected
+      .then(() => expect(serverless.cli.log).to.have.been.calledWith(sinon.match(/^Could not load webpack config/)));
+    });
   });
 
   describe('lib', () => {