shakapacker 7.3.0.beta.1 → 8.0.0.rc.2

data/spec/shakapacker/webpack_runner_spec.rb

@@ -2,6 +2,13 @@ require_relative "spec_helper_initializer"
 require "shakapacker/webpack_runner"
 
 describe "WebpackRunner" do
+  around do |example|
+    within_temp_directory do
+      FileUtils.cp_r(File.expand_path("./test_app", __dir__), Dir.pwd)
+      Dir.chdir("test_app") { example.run }
+    end
+  end
+
   before :all do
     @original_node_env, ENV["NODE_ENV"] = ENV["NODE_ENV"], "development"
     @original_rails_env, ENV["RAILS_ENV"] = ENV["RAILS_ENV"], "development"
@@ -12,15 +19,21 @@ describe "WebpackRunner" do
     ENV["RAILS_ENV"] = @original_rails_env
   end
 
-  let(:test_app_path) { File.expand_path("./test_app", __dir__) }
+  let(:test_app_path) { Dir.pwd }
 
   NODE_PACKAGE_MANAGERS.each do |fallback_manager|
     context "when using package_json with #{fallback_manager} as the manager" do
-      with_use_package_json_gem(enabled: true, fallback_manager: fallback_manager)
+      before do
+        manager_name = fallback_manager.split("_")[0]
+        manager_version = "1.2.3"
+        manager_version = "4.5.6" if fallback_manager == "yarn_berry"
 
-      let(:package_json) { PackageJson.read(test_app_path) }
+        PackageJson.read.merge! { { "packageManager" => "#{manager_name}@#{manager_version}" } }
 
-      require "package_json"
+        allow(Shakapacker::Utils::Manager).to receive(:error_unless_package_manager_is_obvious!)
+      end
+
+      let(:package_json) { PackageJson.read(test_app_path) }
 
       it "uses the expected package manager", unless: fallback_manager == "yarn_classic" do
         cmd = package_json.manager.native_exec_command("webpack", ["--config", "#{test_app_path}/config/webpack/webpack.config.js"])
@@ -44,42 +57,20 @@ describe "WebpackRunner" do
     end
   end
 
-  context "when not using package_json" do
-    with_use_package_json_gem(enabled: false)
-
-    it "supports running via node_modules" do
-      cmd = ["#{test_app_path}/node_modules/.bin/webpack", "--config", "#{test_app_path}/config/webpack/webpack.config.js"]
-
-      verify_command(cmd, use_node_modules: true)
-    end
-
-    it "supports running via yarn" do
-      cmd = ["yarn", "webpack", "--config", "#{test_app_path}/config/webpack/webpack.config.js"]
-
-      verify_command(cmd, use_node_modules: false)
-    end
-
-    it "passes on arguments" do
-      cmd = ["#{test_app_path}/node_modules/.bin/webpack", "--config", "#{test_app_path}/config/webpack/webpack.config.js", "--watch"]
-
-      verify_command(cmd, argv: ["--watch"])
-    end
-  end
-
   private
 
-    def verify_command(cmd, use_node_modules: true, argv: [])
+    def verify_command(cmd, argv: [])
       Dir.chdir(test_app_path) do
         klass = Shakapacker::WebpackRunner
         instance = klass.new(argv)
 
         allow(klass).to receive(:new).and_return(instance)
-        allow(instance).to receive(:node_modules_bin_exist?).and_return(use_node_modules)
         allow(Kernel).to receive(:exec)
 
         klass.run(argv)
 
         expect(Kernel).to have_received(:exec).with(Shakapacker::Compiler.env, *cmd)
+        expect(Shakapacker::Utils::Manager).to have_received(:error_unless_package_manager_is_obvious!)
       end
     end
 end

data/spec/support/package_json_helpers.rb

@@ -1,16 +1,19 @@
 NODE_PACKAGE_MANAGERS = ["npm", "yarn_classic", "yarn_berry", "pnpm", "bun"]
 
-def with_use_package_json_gem(enabled:, fallback_manager: nil)
+def with_package_json_fallback_manager(fallback_manager)
   around do |example|
-    old_use_package_json_gem_value = ENV["SHAKAPACKER_USE_PACKAGE_JSON_GEM"]
     old_package_json_fallback_manager_value = ENV["PACKAGE_JSON_FALLBACK_MANAGER"]
 
-    ENV["SHAKAPACKER_USE_PACKAGE_JSON_GEM"] = enabled.to_s
     ENV["PACKAGE_JSON_FALLBACK_MANAGER"] = fallback_manager.to_s
 
     example.run
 
-    ENV["SHAKAPACKER_USE_PACKAGE_JSON_GEM"] = old_use_package_json_gem_value
     ENV["PACKAGE_JSON_FALLBACK_MANAGER"] = old_package_json_fallback_manager_value
   end
 end
+
+def within_temp_directory(tmpdir = nil, &block)
+  Dir.mktmpdir("shakapacker-", tmpdir) do |dir|
+    Dir.chdir(dir, &block)
+  end
+end

data/test/helpers.js

@@ -0,0 +1,67 @@
+const webpack = require("webpack")
+const MemoryFS = require("memory-fs")
+const thenify = require("thenify")
+const path = require("path")
+
+const createTrackLoader = () => {
+  const filesTracked = {}
+  return [
+    filesTracked,
+    (source) => {
+      filesTracked[source.resource] = true
+      return source
+    }
+  ]
+}
+
+const pathToNodeModules = path.resolve("node_modules")
+const pathToNodeModulesIncluded = path.resolve("node_modules/included")
+const pathToAppJavascript = path.resolve("app/javascript")
+
+const createInMemoryFs = () => {
+  const fs = new MemoryFS()
+
+  fs.mkdirpSync(pathToNodeModules)
+  fs.mkdirpSync(pathToNodeModulesIncluded)
+  fs.mkdirpSync(pathToAppJavascript)
+
+  return fs
+}
+
+const createTestCompiler = (config, fs = createInMemoryFs()) => {
+  Object.values(config.entry).forEach((file) => {
+    fs.writeFileSync(file, "console.log(1);")
+  })
+
+  const compiler = webpack(config)
+  compiler.run = thenify(compiler.run)
+  compiler.inputFileSystem = fs
+  compiler.outputFileSystem = fs
+  return compiler
+}
+
+const chdirTestApp = () => {
+  try {
+    return process.chdir("spec/shakapacker/test_app")
+  } catch (e) {
+    return null
+  }
+}
+
+const chdirCwd = () => process.chdir(process.cwd())
+
+const resetEnv = () => {
+  process.env = {}
+}
+
+module.exports = {
+  chdirTestApp,
+  chdirCwd,
+  resetEnv,
+  createTrackLoader,
+  pathToNodeModules,
+  pathToNodeModulesIncluded,
+  pathToAppJavascript,
+  createInMemoryFs,
+  createTestCompiler
+}

data/test/package/config.test.js

@@ -0,0 +1,50 @@
+const { resolve } = require("path")
+const { chdirTestApp, resetEnv } = require("../helpers")
+
+const rootPath = process.cwd()
+chdirTestApp()
+
+describe("Config", () => {
+  beforeEach(() => jest.resetModules() && resetEnv())
+  afterAll(() => process.chdir(rootPath))
+
+  test("public path", () => {
+    process.env.RAILS_ENV = "development"
+    const config = require("../../package/config")
+    expect(config.publicPath).toBe("/packs/")
+  })
+
+  test("public path with asset host", () => {
+    process.env.RAILS_ENV = "development"
+    process.env.SHAKAPACKER_ASSET_HOST = "http://foo.com/"
+    const config = require("../../package/config")
+    expect(config.publicPath).toBe("http://foo.com/packs/")
+  })
+
+  test("should return additional paths as listed in app config, with resolved paths", () => {
+    const config = require("../../package/config")
+
+    expect(config.additional_paths).toStrictEqual([
+      "app/assets",
+      "/etc/yarn",
+      "some.config.js",
+      "app/elm"
+    ])
+  })
+
+  test("should default manifestPath to the public dir", () => {
+    const config = require("../../package/config")
+
+    expect(config.manifestPath).toStrictEqual(
+      resolve("public/packs/manifest.json")
+    )
+  })
+
+  test("should allow overriding manifestPath", () => {
+    process.env.SHAKAPACKER_CONFIG = "config/shakapacker_manifest_path.yml"
+    const config = require("../../package/config")
+    expect(config.manifestPath).toStrictEqual(
+      resolve("app/javascript/manifest.json")
+    )
+  })
+})

data/test/package/dev_server.test.js

@@ -0,0 +1,44 @@
+const { chdirTestApp } = require("../helpers")
+
+const rootPath = process.cwd()
+chdirTestApp()
+
+describe("DevServer", () => {
+  beforeEach(() => jest.resetModules())
+  afterAll(() => process.chdir(rootPath))
+
+  test("with NODE_ENV and RAILS_ENV set to development", () => {
+    process.env.NODE_ENV = "development"
+    process.env.RAILS_ENV = "development"
+    process.env.SHAKAPACKER_DEV_SERVER_HOST = "0.0.0.0"
+    process.env.SHAKAPACKER_DEV_SERVER_PORT = 5000
+    process.env.SHAKAPACKER_DEV_SERVER_DISABLE_HOST_CHECK = false
+
+    const devServer = require("../../package/dev_server")
+    expect(devServer).toBeDefined()
+    expect(devServer.host).toBe("0.0.0.0")
+    expect(devServer.port).toBe("5000")
+    expect(devServer.disable_host_check).toBe(false)
+  })
+
+  test("with custom env prefix", () => {
+    const config = require("../../package/config")
+    config.dev_server.env_prefix = "TEST_SHAKAPACKER_DEV_SERVER"
+
+    process.env.NODE_ENV = "development"
+    process.env.RAILS_ENV = "development"
+    process.env.TEST_SHAKAPACKER_DEV_SERVER_HOST = "0.0.0.0"
+    process.env.TEST_SHAKAPACKER_DEV_SERVER_PORT = 5000
+
+    const devServer = require("../../package/dev_server")
+    expect(devServer).toBeDefined()
+    expect(devServer.host).toBe("0.0.0.0")
+    expect(devServer.port).toBe("5000")
+  })
+
+  test("with NODE_ENV and RAILS_ENV set to production", () => {
+    process.env.RAILS_ENV = "production"
+    process.env.NODE_ENV = "production"
+    expect(require("../../package/dev_server")).toStrictEqual({})
+  })
+})

data/test/package/development.test.js

@@ -0,0 +1,43 @@
+const { resolve } = require("path")
+const { chdirTestApp, resetEnv } = require("../helpers")
+
+const rootPath = process.cwd()
+chdirTestApp()
+
+describe("Development environment", () => {
+  beforeEach(() => jest.resetModules() && resetEnv())
+  afterAll(() => process.chdir(rootPath))
+
+  describe("generateWebpackConfig", () => {
+    beforeEach(() => jest.resetModules())
+
+    test("should use development config and environment including devServer if WEBPACK_SERVE", () => {
+      process.env.RAILS_ENV = "development"
+      process.env.NODE_ENV = "development"
+      process.env.WEBPACK_SERVE = "true"
+      const { generateWebpackConfig } = require("../../package/index")
+
+      const webpackConfig = generateWebpackConfig()
+
+      expect(webpackConfig.output.path).toStrictEqual(
+        resolve("public", "packs")
+      )
+      expect(webpackConfig.output.publicPath).toBe("/packs/")
+    })
+
+    test("should use development config and environment if WEBPACK_SERVE", () => {
+      process.env.RAILS_ENV = "development"
+      process.env.NODE_ENV = "development"
+      process.env.WEBPACK_SERVE = undefined
+      const { generateWebpackConfig } = require("../../package/index")
+
+      const webpackConfig = generateWebpackConfig()
+
+      expect(webpackConfig.output.path).toStrictEqual(
+        resolve("public", "packs")
+      )
+      expect(webpackConfig.output.publicPath).toBe("/packs/")
+      expect(webpackConfig.devServer).toBeUndefined()
+    })
+  })
+})

data/test/package/env.test.js

@@ -0,0 +1,57 @@
+const { chdirTestApp } = require("../helpers")
+
+const rootPath = process.cwd()
+chdirTestApp()
+
+describe("Env", () => {
+  beforeEach(() => jest.resetModules())
+  afterAll(() => process.chdir(rootPath))
+
+  test("with NODE_ENV and RAILS_ENV set to development", () => {
+    process.env.RAILS_ENV = "development"
+    process.env.NODE_ENV = "development"
+    expect(require("../../package/env")).toStrictEqual({
+      railsEnv: "development",
+      nodeEnv: "development",
+      isProduction: false,
+      isDevelopment: true,
+      runningWebpackDevServer: false
+    })
+  })
+
+  test("with undefined NODE_ENV and RAILS_ENV set to development", () => {
+    process.env.RAILS_ENV = "development"
+    delete process.env.NODE_ENV
+    expect(require("../../package/env")).toStrictEqual({
+      railsEnv: "development",
+      nodeEnv: "production",
+      isProduction: true,
+      isDevelopment: false,
+      runningWebpackDevServer: false
+    })
+  })
+
+  test("with undefined NODE_ENV and RAILS_ENV", () => {
+    delete process.env.NODE_ENV
+    delete process.env.RAILS_ENV
+    expect(require("../../package/env")).toStrictEqual({
+      railsEnv: "production",
+      nodeEnv: "production",
+      isProduction: true,
+      isDevelopment: false,
+      runningWebpackDevServer: false
+    })
+  })
+
+  test("with a non-standard environment", () => {
+    process.env.RAILS_ENV = "staging"
+    process.env.NODE_ENV = "staging"
+    expect(require("../../package/env")).toStrictEqual({
+      railsEnv: "staging",
+      nodeEnv: "production",
+      isProduction: true,
+      isDevelopment: false,
+      runningWebpackDevServer: false
+    })
+  })
+})

data/test/package/environments/base.test.js

@@ -0,0 +1,105 @@
+// environment.js expects to find config/shakapacker.yml and resolved modules from
+// the root of a Rails project
+
+const { resolve } = require("path")
+const { chdirTestApp, resetEnv } = require("../../helpers")
+
+const rootPath = process.cwd()
+chdirTestApp()
+
+const baseConfig = require("../../../package/environments/base")
+const config = require("../../../package/config")
+
+describe("Base config", () => {
+  beforeEach(() => jest.resetModules() && resetEnv())
+  afterAll(() => process.chdir(rootPath))
+
+  describe("config", () => {
+    test("should return entry", () => {
+      expect(baseConfig.entry.application).toStrictEqual(
+        resolve("app", "javascript", "entrypoints", "application.js")
+      )
+    })
+
+    test("should return false for css_extract_ignore_order_warnings when using default config", () => {
+      expect(config.css_extract_ignore_order_warnings).toBe(false)
+    })
+
+    test("should return true for css_extract_ignore_order_warnings when configured", () => {
+      process.env.SHAKAPACKER_CONFIG =
+        "config/shakapacker_css_extract_ignore_order_warnings.yml"
+      const config2 = require("../../../package/config")
+
+      expect(config2.css_extract_ignore_order_warnings).toBe(true)
+    })
+
+    test("should return only 2 entry points with config.nested_entries == false", () => {
+      expect(config.nested_entries).toBe(false)
+
+      expect(baseConfig.entry.multi_entry.sort()).toStrictEqual([
+        resolve("app", "javascript", "entrypoints", "multi_entry.css"),
+        resolve("app", "javascript", "entrypoints", "multi_entry.js")
+      ])
+      expect(baseConfig.entry["generated/something"]).toBeUndefined()
+    })
+
+    test("should returns top level and nested entry points with config.nested_entries == true", () => {
+      process.env.SHAKAPACKER_CONFIG = "config/shakapacker_nested_entries.yml"
+      const config2 = require("../../../package/config")
+      const baseConfig2 = require("../../../package/environments/base")
+
+      expect(config2.nested_entries).toBe(true)
+
+      expect(baseConfig2.entry.application).toStrictEqual(
+        resolve("app", "javascript", "entrypoints", "application.js")
+      )
+      expect(baseConfig2.entry.multi_entry.sort()).toStrictEqual([
+        resolve("app", "javascript", "entrypoints", "multi_entry.css"),
+        resolve("app", "javascript", "entrypoints", "multi_entry.js")
+      ])
+      expect(baseConfig2.entry["generated/something"]).toStrictEqual(
+        resolve("app", "javascript", "entrypoints", "generated", "something.js")
+      )
+    })
+
+    test("should return output", () => {
+      expect(baseConfig.output.filename).toBe("js/[name]-[contenthash].js")
+      expect(baseConfig.output.chunkFilename).toBe(
+        "js/[name]-[contenthash].chunk.js"
+      )
+    })
+
+    test("should return default loader rules for each file in config/loaders", () => {
+      const rules = require("../../../package/rules")
+
+      const defaultRules = Object.keys(rules)
+      const configRules = baseConfig.module.rules
+
+      expect(defaultRules).toHaveLength(3)
+      expect(configRules).toHaveLength(3)
+    })
+
+    test("should return default plugins", () => {
+      expect(baseConfig.plugins).toHaveLength(2)
+    })
+
+    test("should return default resolveLoader", () => {
+      expect(baseConfig.resolveLoader.modules).toStrictEqual(["node_modules"])
+    })
+
+    test("should return default resolve.modules with additions", () => {
+      expect(baseConfig.resolve.modules).toStrictEqual([
+        resolve("app", "javascript"),
+        resolve("app/assets"),
+        resolve("/etc/yarn"),
+        resolve("some.config.js"),
+        resolve("app/elm"),
+        "node_modules"
+      ])
+    })
+
+    test("returns plugins property as Array", () => {
+      expect(baseConfig.plugins).toBeInstanceOf(Array)
+    })
+  })
+})

data/test/package/environments/development.test.js

@@ -0,0 +1,50 @@
+const { chdirTestApp, resetEnv } = require("../../helpers")
+
+const rootPath = process.cwd()
+chdirTestApp()
+
+describe("Development specific config", () => {
+  beforeEach(() => {
+    jest.resetModules()
+    resetEnv()
+    process.env.NODE_ENV = "development"
+  })
+  afterAll(() => process.chdir(rootPath))
+
+  describe("with config.useContentHash = true", () => {
+    test("sets filename to use contentHash", () => {
+      const config = require("../../../package/config")
+      config.useContentHash = true
+      const environmentConfig = require("../../../package/environments/development")
+
+      expect(environmentConfig.output.filename).toBe(
+        "js/[name]-[contenthash].js"
+      )
+      expect(environmentConfig.output.chunkFilename).toBe(
+        "js/[name]-[contenthash].chunk.js"
+      )
+    })
+  })
+
+  describe("with config.useContentHash = false", () => {
+    test("sets filename without using contentHash", () => {
+      const config = require("../../../package/config")
+      config.useContentHash = false
+      const environmentConfig = require("../../../package/environments/development")
+
+      expect(environmentConfig.output.filename).toBe("js/[name].js")
+      expect(environmentConfig.output.chunkFilename).toBe("js/[name].chunk.js")
+    })
+  })
+
+  describe("with unset config.useContentHash", () => {
+    test("sets filename without using contentHash", () => {
+      const config = require("../../../package/config")
+      delete config.useContentHash
+      const environmentConfig = require("../../../package/environments/development")
+
+      expect(environmentConfig.output.filename).toBe("js/[name].js")
+      expect(environmentConfig.output.chunkFilename).toBe("js/[name].chunk.js")
+    })
+  })
+})

data/test/package/environments/production.test.js

@@ -0,0 +1,106 @@
+const { chdirTestApp, resetEnv } = require("../../helpers")
+
+const rootPath = process.cwd()
+chdirTestApp()
+
+describe("Production specific config", () => {
+  beforeEach(() => {
+    jest.resetModules()
+    resetEnv()
+    process.env.NODE_ENV = "production"
+  })
+  afterAll(() => process.chdir(rootPath))
+
+  describe("with config.useContentHash = true", () => {
+    test("sets filename to use contentHash", () => {
+      const config = require("../../../package/config")
+      config.useContentHash = true
+      const environmentConfig = require("../../../package/environments/production")
+
+      expect(environmentConfig.output.filename).toBe(
+        "js/[name]-[contenthash].js"
+      )
+      expect(environmentConfig.output.chunkFilename).toBe(
+        "js/[name]-[contenthash].chunk.js"
+      )
+    })
+
+    test("doesn't shows any warning message", () => {
+      const consoleWarnSpy = jest.spyOn(console, "warn")
+      const config = require("../../../package/config")
+      config.useContentHash = true
+
+      require("../../../package/environments/production")
+
+      expect(consoleWarnSpy).not.toHaveBeenCalledWith(
+        expect.stringMatching(
+          /Setting 'useContentHash' to 'false' in the production environment/
+        )
+      )
+
+      consoleWarnSpy.mockRestore()
+    })
+  })
+
+  describe("with config.useContentHash = false", () => {
+    test("sets filename to use contentHash", () => {
+      const config = require("../../../package/config")
+      config.useContentHash = false
+      const environmentConfig = require("../../../package/environments/production")
+
+      expect(environmentConfig.output.filename).toBe(
+        "js/[name]-[contenthash].js"
+      )
+      expect(environmentConfig.output.chunkFilename).toBe(
+        "js/[name]-[contenthash].chunk.js"
+      )
+    })
+
+    test("shows a warning message", () => {
+      const consoleWarnSpy = jest.spyOn(console, "warn")
+      const config = require("../../../package/config")
+      config.useContentHash = false
+
+      require("../../../package/environments/production")
+
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringMatching(
+          /Setting 'useContentHash' to 'false' in the production environment/
+        )
+      )
+
+      consoleWarnSpy.mockRestore()
+    })
+  })
+
+  describe("with unset config.useContentHash", () => {
+    test("sets filename to use contentHash", () => {
+      const config = require("../../../package/config")
+      delete config.useContentHash
+      const environmentConfig = require("../../../package/environments/production")
+
+      expect(environmentConfig.output.filename).toBe(
+        "js/[name]-[contenthash].js"
+      )
+      expect(environmentConfig.output.chunkFilename).toBe(
+        "js/[name]-[contenthash].chunk.js"
+      )
+    })
+
+    test("doesn't shows any warning message", () => {
+      const consoleWarnSpy = jest.spyOn(console, "warn")
+      const config = require("../../../package/config")
+      delete config.useContentHash
+
+      require("../../../package/environments/production")
+
+      expect(consoleWarnSpy).not.toHaveBeenCalledWith(
+        expect.stringMatching(
+          /Setting 'useContentHash' to 'false' in the production environment/
+        )
+      )
+
+      consoleWarnSpy.mockRestore()
+    })
+  })
+})

data/test/package/index.test.js

@@ -0,0 +1,45 @@
+const index = require("../../package/index")
+
+describe("index", () => {
+  test("exports webpack-merge v5 functions", () => {
+    expect(index.merge).toBeInstanceOf(Function)
+    expect(index.mergeWithRules).toBeInstanceOf(Function)
+    expect(index.mergeWithCustomize).toBeInstanceOf(Function)
+  })
+
+  test("webpackConfig returns an immutable object", () => {
+    const { generateWebpackConfig } = require("../../package/index")
+
+    const webpackConfig1 = generateWebpackConfig()
+    const webpackConfig2 = generateWebpackConfig()
+
+    webpackConfig1.newKey = "new value"
+    webpackConfig1.output.path = "new path"
+
+    expect(webpackConfig2).not.toHaveProperty("newKey")
+    expect(webpackConfig2.output.path).not.toBe("new value")
+  })
+
+  test("webpackConfig merges extra config", () => {
+    const { generateWebpackConfig } = require("../../package/index")
+
+    const webpackConfig = generateWebpackConfig({
+      newKey: "new value",
+      output: {
+        path: "new path"
+      }
+    })
+
+    expect(webpackConfig).toHaveProperty("newKey", "new value")
+    expect(webpackConfig).toHaveProperty("output.path", "new path")
+    expect(webpackConfig).toHaveProperty("output.publicPath", "/packs/")
+  })
+
+  test("webpackConfig errors if multiple configs are provided", () => {
+    const { generateWebpackConfig } = require("../../package/index")
+
+    expect(() => generateWebpackConfig({}, {})).toThrow(
+      "use webpack-merge to merge configs before passing them to Shakapacker"
+    )
+  })
+})