shakapacker 7.2.3 → 8.0.0.pre.rc.1

data/spec/shakapacker/utils_manager_spec.rb

@@ -0,0 +1,125 @@
+require_relative "spec_helper_initializer"
+require "shakapacker/utils/manager"
+
+Struct.new("Status", :exit_code) do
+  def success?
+    exit_code.zero?
+  end
+
+  def exitstatus
+    exit_code
+  end
+end
+
+describe "Shakapacker::Utils::Manager" do
+  around do |example|
+    within_temp_directory { example.run }
+  end
+
+  describe "~error_unless_package_manager_is_obvious!" do
+    before do
+      allow(Shakapacker).to receive(:puts_deprecation_message)
+    end
+
+    context "when 'packageManager' is set in the package.json" do
+      before do
+        File.write("package.json", { "packageManager" => "pnpm" }.to_json)
+      end
+
+      it "does nothing" do
+        Shakapacker::Utils::Manager.error_unless_package_manager_is_obvious!
+
+        expect(Shakapacker).not_to have_received(:puts_deprecation_message)
+      end
+    end
+
+    context "when the guessed manager is npm" do
+      it "does nothing" do
+        File.write("package.json", {}.to_json)
+        FileUtils.touch("package-lock.json")
+
+        Shakapacker::Utils::Manager.error_unless_package_manager_is_obvious!
+
+        expect(Shakapacker).not_to have_received(:puts_deprecation_message)
+      end
+    end
+
+    Shakapacker::Utils::Manager::MANAGER_LOCKS.reject { |manager| manager == "npm" }.each do |manager, lock|
+      context "when there is a #{lock}" do
+        before do
+          allow(Open3).to receive(:capture3).and_return(["1.2.3\n", "", Struct::Status.new(0)])
+        end
+
+        it "raises an error about setting 'packageManager' for #{manager}" do
+          File.write("package.json", {}.to_json)
+          FileUtils.touch(lock)
+
+          expect { Shakapacker::Utils::Manager.error_unless_package_manager_is_obvious! }.to raise_error(Shakapacker::Utils::Manager::Error, <<~MSG)
+            You don't have "packageManager" set in your package.json
+            meaning that Shakapacker will use npm but you've got a #{lock}
+            file meaning you probably want to be using #{manager} instead.
+
+            To make this happen, set "packageManager" in your package.json to #{manager}@1.2.3
+          MSG
+        end
+      end
+    end
+  end
+
+  describe "~guess_binary" do
+    Shakapacker::Utils::Manager::MANAGER_LOCKS.each do |manager, lock|
+      context "when a #{lock} exists" do
+        before { FileUtils.touch(lock) }
+
+        it "guesses #{manager}" do
+          expect(Shakapacker::Utils::Manager.guess_binary).to eq manager
+        end
+      end
+    end
+
+    context "when there is no lockfile" do
+      it "returns npm" do
+        expect(Shakapacker::Utils::Manager.guess_binary).to eq "npm"
+      end
+    end
+  end
+
+  describe "~guess_version" do
+    before do
+      allow(Open3).to receive(:capture3).and_return(["1.2.3\n", "", Struct::Status.new(0)])
+    end
+
+    Shakapacker::Utils::Manager::MANAGER_LOCKS.each do |manager, lock|
+      context "when a #{lock} exists" do
+        before { FileUtils.touch(lock) }
+
+        it "calls #{manager} with --version" do
+          Shakapacker::Utils::Manager.guess_version
+
+          expect(Open3).to have_received(:capture3).with("#{manager} --version")
+        end
+      end
+    end
+
+    it "returns the output without a trailing newline" do
+      FileUtils.touch("package-lock.json")
+
+      expect(Shakapacker::Utils::Manager.guess_version).to eq("1.2.3")
+    end
+
+    context "when the command errors" do
+      before do
+        allow(Open3).to receive(:capture3).and_return(["", "oh noes!", Struct::Status.new(1)])
+      end
+
+      it "raises an error" do
+        FileUtils.touch("package-lock.json")
+
+        expect { Shakapacker::Utils::Manager.guess_version }.to raise_error(
+          Shakapacker::Utils::Manager::Error,
+          "npm --version failed with exit code 1: oh noes!"
+        )
+      end
+    end
+  end
+end

data/spec/shakapacker/version_checker_spec.rb

@@ -29,19 +29,19 @@ describe "VersionChecker" do
     version_checker.raise_if_gem_and_node_package_versions_differ
   end
 
-  it "prints error in stderr if consistency check is disabled and version mismatch" do
+  it "does nothing if consistency check is disabled and version mismatch" do
     node_package_version = NodePackageVersionDouble.new(raw: "6.1.0", major_minor_patch: ["6", "1", "0"])
 
     expect { check_version(node_package_version, "6.0.0", false) }
-      .to output(/Shakapacker::VersionChecker - Version mismatch/)
+      .not_to output
       .to_stderr
   end
 
-  it "prints error in stderr if consistency check is disabled and we have semver" do
+  it "does nothing if consistency check is disabled and we have semver" do
     node_package_version = NodePackageVersionDouble.new(raw: "^6.1.0", major_minor_patch: ["6", "1", "0"], semver_wildcard: true)
 
     expect { check_version(node_package_version, "6.0.0", false) }
-      .to output(/Shakapacker::VersionChecker - Semver wildcard without a lockfile detected/)
+      .not_to output
       .to_stderr
   end
 

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")
+    })
+  })
+})