shakapacker 7.0.3 → 7.2.0.rc.0

data/lib/shakapacker/utils/misc.rb

@@ -8,6 +8,18 @@ module Shakapacker
     class Misc
       extend FileUtils
 
+      def self.use_package_json_gem
+        ENV.fetch("SHAKAPACKER_USE_PACKAGE_JSON_GEM", "false").casecmp("true").zero?
+      end
+
+      def self.require_package_json_gem
+        unless use_package_json_gem
+          raise "PackageJson should not be used unless SHAKAPACKER_USE_PACKAGE_JSON_GEM is true"
+        end
+
+        require "package_json"
+      end
+
       def self.uncommitted_changes?(message_handler)
         return false if ENV["COVERAGE"] == "true"
 

data/lib/shakapacker/version.rb

@@ -1,4 +1,4 @@
 module Shakapacker
   # Change the version in package.json too, please!
-  VERSION = "7.0.3".freeze
+  VERSION = "7.2.0.rc.0".freeze
 end

data/lib/shakapacker/version_checker.rb

@@ -91,7 +91,7 @@ module Shakapacker
         attr_reader :package_json
 
         def self.build
-          new(package_json_path, yarn_lock_path, package_lock_path)
+          new(package_json_path, yarn_lock_path, package_lock_path, pnpm_lock_path)
         end
 
         def self.package_json_path
@@ -106,10 +106,15 @@ module Shakapacker
           Rails.root.join("package-lock.json")
         end
 
-        def initialize(package_json, yarn_lock, package_lock)
+        def self.pnpm_lock_path
+          Rails.root.join("pnpm-lock.yaml")
+        end
+
+        def initialize(package_json, yarn_lock, package_lock, pnpm_lock)
           @package_json = package_json
           @yarn_lock = yarn_lock
           @package_lock = package_lock
+          @pnpm_lock = pnpm_lock
         end
 
         def raw
@@ -170,6 +175,12 @@ module Shakapacker
               return version unless version.nil?
             end
 
+            if File.exist?(@pnpm_lock)
+              version = from_pnpm_lock
+
+              return version unless version.nil?
+            end
+
             parsed_package_contents = JSON.parse(package_json_contents)
             parsed_package_contents.dig("dependencies", "shakapacker").to_s
           end
@@ -210,6 +221,28 @@ module Shakapacker
 
             version
           end
+
+          def from_pnpm_lock
+            require "yaml"
+
+            content = YAML.load_file(@pnpm_lock)
+
+            content.fetch("packages", {}).each do |key, value|
+              return value["version"] if value["name"] == "shakapacker"
+
+              parts = key.split("/")
+
+              return parts[2] if parts[1] == "shakapacker"
+              next unless parts[1].start_with?("shakapacker@")
+
+              _, version = parts[1].split("@")
+
+              return version[0, version.index("(")] if version.include?("(")
+              return version
+            end
+
+            nil
+          end
       end
   end
 end

data/lib/shakapacker/webpack_runner.rb

@@ -19,12 +19,9 @@ module Shakapacker
     def run
       env = Shakapacker::Compiler.env
       env["SHAKAPACKER_CONFIG"] = @shakapacker_config
+      env["NODE_OPTIONS"] = ENV["NODE_OPTIONS"] || ""
 
-      cmd = if node_modules_bin_exist?
-        ["#{@node_modules_bin_path}/webpack"]
-      else
-        ["yarn", "webpack"]
-      end
+      cmd = build_cmd
 
       if @argv.include?("--debug-webpacker")
         Shakapacker.puts_deprecation_message(
@@ -36,15 +33,15 @@ module Shakapacker
       end
 
       if @argv.delete("--debug-shakapacker") || @argv.delete("--debug-webpacker")
-        cmd = ["node", "--inspect-brk"] + cmd
+        env["NODE_OPTIONS"] = "#{env["NODE_OPTIONS"]} --inspect-brk"
       end
 
       if @argv.delete "--trace-deprecation"
-        cmd = ["node", "--trace-deprecation"] + cmd
+        env["NODE_OPTIONS"] = "#{env["NODE_OPTIONS"]} --trace-deprecation"
       end
 
       if @argv.delete "--no-deprecation"
-        cmd = ["node", "--no-deprecation"] + cmd
+        env["NODE_OPTIONS"] = "#{env["NODE_OPTIONS"]} --no-deprecation"
       end
 
       # Webpack commands are not compatible with --config option.
@@ -60,6 +57,17 @@ module Shakapacker
     end
 
     private
+
+      def build_cmd
+        if Shakapacker::Utils::Misc.use_package_json_gem
+          return package_json.manager.native_exec_command("webpack")
+        end
+
+        return ["#{@node_modules_bin_path}/webpack"] if node_modules_bin_exist?
+
+        ["yarn", "webpack"]
+      end
+
       def node_modules_bin_exist?
         File.exist?("#{@node_modules_bin_path}/webpack")
       end

data/lib/tasks/shakapacker/binstubs.rake

@@ -3,7 +3,7 @@ bin_path = ENV["BUNDLE_BIN"] || Rails.root.join("bin")
 
 namespace :shakapacker do
   desc "Installs Shakapacker binstubs in this application"
-  task binstubs: [:check_node, :check_yarn] do |task|
+  task binstubs: [:check_node, :check_manager] do |task|
     prefix = task.name.split(/#|shakapacker:binstubs/).first
 
     if Rails::VERSION::MAJOR >= 5

data/lib/tasks/shakapacker/check_manager.rake

@@ -0,0 +1,27 @@
+require "shakapacker/utils/misc"
+
+namespace :shakapacker do
+  desc "Verifies if the expected JS package manager is installed"
+  task :check_manager do |task|
+    unless Shakapacker::Utils::Misc.use_package_json_gem
+      prefix = task.name.split(/#|shakapacker:/).first
+      Rake::Task["#{prefix}shakapacker:check_manager"].invoke
+      next
+    end
+
+    require "package_json"
+
+    package_json = PackageJson.read
+    pm = package_json.manager.binary
+
+    begin
+      version = package_json.manager.version
+
+      $stdout.puts "using #{pm}@#{version} to manage dependencies and scripts in package.json"
+    rescue PackageJson::Error
+      $stderr.puts "#{pm} not installed - please ensure it is installed before trying again"
+      $stderr.puts "Exiting!"
+      exit!
+    end
+  end
+end

data/lib/tasks/shakapacker/check_yarn.rake

@@ -1,7 +1,8 @@
-require "semantic_range"
 namespace :shakapacker do
   desc "Verifies if Yarn is installed"
   task :check_yarn do
+    require "semantic_range"
+
     begin
       which_command = Gem.win_platform? ? "where" : "which"
       raise Errno::ENOENT if `#{which_command} yarn`.strip.empty?

data/lib/tasks/shakapacker/info.rake

@@ -1,4 +1,5 @@
 require "shakapacker/version"
+require "shakapacker/utils/misc"
 
 namespace :shakapacker do
   desc "Provide information on Shakapacker's environment"
@@ -8,14 +9,30 @@ namespace :shakapacker do
       $stdout.puts "Rails: #{Rails.version}"
       $stdout.puts "Shakapacker: #{Shakapacker::VERSION}"
       $stdout.puts "Node: #{`node --version`}"
-      $stdout.puts "Yarn: #{`yarn --version`}"
+      if Shakapacker::Utils::Misc.use_package_json_gem
+        require "package_json"
+
+        pj_manager = PackageJson.read.manager
+
+        $stdout.puts "#{pj_manager.binary}: #{pj_manager.version}"
+      else
+        $stdout.puts "Yarn: #{`yarn --version`}"
+      end
+
+      if Shakapacker::Utils::Misc.use_package_json_gem
+        node_package_version = Shakapacker::VersionChecker.build.node_package_version.raw
+      else
+        node_package_version = `npm list shakapacker version`
+      end
 
       $stdout.puts "\n"
-      $stdout.puts "shakapacker: \n#{`npm list shakapacker version`}"
+      $stdout.puts "shakapacker: #{node_package_version}"
 
       $stdout.puts "Is bin/shakapacker present?: #{File.exist? 'bin/shakapacker'}"
       $stdout.puts "Is bin/shakapacker-dev-server present?: #{File.exist? 'bin/shakapacker-dev-server'}"
-      $stdout.puts "Is bin/yarn present?: #{File.exist? 'bin/yarn'}"
+      unless Shakapacker::Utils::Misc.use_package_json_gem
+        $stdout.puts "Is bin/yarn present?: #{File.exist? 'bin/yarn'}"
+      end
     end
   end
 end

data/lib/tasks/shakapacker/install.rake

@@ -3,7 +3,7 @@ bin_path = ENV["BUNDLE_BIN"] || Rails.root.join("bin")
 
 namespace :shakapacker do
   desc "Install Shakapacker in this application"
-  task install: [:check_node, :check_yarn] do |task|
+  task install: [:check_node] do |task|
     Shakapacker::Configuration.installing = true
 
     prefix = task.name.split(/#|shakapacker:install/).first

data/lib/tasks/shakapacker/verify_install.rake

@@ -1,4 +1,4 @@
 namespace :shakapacker do
   desc "Verifies if Shakapacker is installed"
-  task verify_install: [:verify_config, :check_node, :check_yarn, :check_binstubs]
+  task verify_install: [:verify_config, :check_node, :check_manager, :check_binstubs]
 end

data/lib/tasks/shakapacker.rake

@@ -1,11 +1,11 @@
 tasks = {
   "shakapacker:info"                    => "Provides information on Shakapacker's environment",
-  "shakapacker:install"                 => "Installs and setup webpack with Yarn",
+  "shakapacker:install"                 => "Installs and setup webpack",
   "shakapacker:compile"                 => "Compiles webpack bundles based on environment",
   "shakapacker:clean"                   => "Remove old compiled bundles",
   "shakapacker:clobber"                 => "Removes the webpack compiled output directory",
   "shakapacker:check_node"              => "Verifies if Node.js is installed",
-  "shakapacker:check_yarn"              => "Verifies if Yarn is installed",
+  "shakapacker:check_manager"           => "Verifies if the expected JS package manager is available",
   "shakapacker:check_binstubs"          => "Verifies that bin/shakapacker is present",
   "shakapacker:binstubs"                => "Installs Shakapacker binstubs in this application",
   "shakapacker:verify_install"          => "Verifies if Shakapacker is installed",

data/lib/tasks/webpacker/check_yarn.rake

@@ -4,6 +4,6 @@ namespace :webpacker do
     Shakapacker.puts_rake_deprecation_message(task.name)
 
     prefix = task.name.split(/#|webpacker:/).first
-    Rake::Task["#{prefix}shakapacker:check_yarn"].invoke
+    Rake::Task["#{prefix}shakapacker:check_manager"].invoke
   end
 end

data/package/__tests__/index.js

@@ -1,4 +1,5 @@
 const index = require('../index')
+const { generateWebpackConfig } = require("../index");
 
 describe('index', () => {
   test('exports webpack-merge v5 functions', () => {
@@ -19,4 +20,27 @@ describe('index', () => {
     expect(webpackConfig2).not.toHaveProperty('newKey')
     expect(webpackConfig2.output.path).not.toEqual('new value')
   })
+
+  test('webpackConfig merges extra config', () => {
+    const { generateWebpackConfig } = require('../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('../index')
+
+    expect(() => generateWebpackConfig({}, {})).toThrow(
+      'use webpack-merge to merge configs before passing them to Shakapacker'
+    )
+  })
 })

data/package/index.d.ts

@@ -34,7 +34,7 @@ declare module 'shakapacker' {
 
   export const config: Config
   export const devServer: Record<string, unknown>
-  export function generateWebpackConfig(): Configuration
+  export function generateWebpackConfig(extraConfig?: Configuration): Configuration
   export const globalMutableWebpackConfig: Configuration
   export const baseConfig: Configuration
   export const env: Env

data/package/index.js

@@ -19,9 +19,15 @@ const globalMutableWebpackConfig = () => {
   return environmentConfig
 }
 
-const generateWebpackConfig = () => {
+const generateWebpackConfig = (extraConfig = {}, ...extraArgs) => {
+  if (extraArgs.length > 0) {
+    throw new Error(
+      'Only one extra config may be passed here - use webpack-merge to merge configs before passing them to Shakapacker'
+    )
+  }
+
   const environmentConfig = globalMutableWebpackConfig()
-  const immutable = webpackMerge.merge({}, environmentConfig)
+  const immutable = webpackMerge.merge({}, environmentConfig, extraConfig)
   return immutable
 }
 

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shakapacker",
-  "version": "7.0.3",
+  "version": "7.2.0-rc.0",
   "description": "Use webpack to manage app-like JavaScript modules in Rails",
   "main": "package/index.js",
   "types": "package/index.d.ts",
@@ -10,7 +10,7 @@
   ],
   "engines": {
     "node": "^12.13.0 || ^14 || >=16",
-    "yarn": ">=1 <4"
+    "yarn": ">=1 <5"
   },
   "peerDependencies": {
     "@types/babel__core": "^7.0.0",

data/shakapacker.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |s|
   s.required_ruby_version = ">= 2.6.0"
 
   s.add_dependency "activesupport", ">= 5.2"
+  s.add_dependency "package_json"
   s.add_dependency "railties",      ">= 5.2"
   s.add_dependency "rack-proxy",    ">= 0.6.1"
   s.add_dependency "semantic_range", ">= 2.3.0"

data/spec/backward_compatibility_specs/compiler_strategy_spec.rb

@@ -2,17 +2,19 @@ require_relative "spec_helper_initializer"
 
 describe "Webpacker::CompilerStrategy" do
   describe "#from_config" do
-    it "returns and instance of MtimeStrategy when compiler_strategy is set to mtime" do
+    it "returns an instance of MtimeStrategy when compiler_strategy is set to mtime" do
       allow(Webpacker.config).to receive(:compiler_strategy).and_return("mtime")
+
       expect(Webpacker::CompilerStrategy.from_config).to be_an_instance_of(Webpacker::MtimeStrategy)
     end
 
-    it "returns and instance of DigestStrategy when compiler_strategy is set to digest" do
+    it "returns an instance of DigestStrategy when compiler_strategy is set to digest" do
       allow(Webpacker.config).to receive(:compiler_strategy).and_return("digest")
+
       expect(Webpacker::CompilerStrategy.from_config).to be_an_instance_of(Webpacker::DigestStrategy)
     end
 
-    it "raise exception for unknown compiler_strategy in the config file" do
+    it "raise an exception for unknown compiler_strategy in the config file" do
       expected_error_message = "Unknown strategy 'other'. Available options are 'mtime' and 'digest'."
       allow(Webpacker.config).to receive(:compiler_strategy).and_return("other")
 

data/spec/backward_compatibility_specs/configuration_spec.rb

@@ -14,36 +14,43 @@ describe "Webpacker::Configuration" do
 
     it "#source_path returns correct path" do
       source_path = File.expand_path File.join(File.dirname(__FILE__), "webpacker_test_app/app/packs").to_s
+
       expect(config.source_path.to_s).to eq source_path
     end
 
     it "#source_entry_path returns correct path" do
       source_entry_path = File.expand_path File.join(File.dirname(__FILE__), "webpacker_test_app/app/packs", "entrypoints").to_s
+
       expect(config.source_entry_path.to_s).to eq source_entry_path
     end
 
     it "#public_root_path returns correct path" do
       public_root_path = File.expand_path File.join(File.dirname(__FILE__), "webpacker_test_app/public").to_s
+
       expect(config.public_path.to_s).to eq public_root_path
     end
 
     it "#public_output_path returns correct path" do
       public_output_path = File.expand_path File.join(File.dirname(__FILE__), "webpacker_test_app/public/packs").to_s
+
       expect(config.public_output_path.to_s).to eq public_output_path
     end
 
     it "#public_manifest_path returns correct path" do
       public_manifest_path = File.expand_path File.join(File.dirname(__FILE__), "webpacker_test_app/public/packs", "manifest.json").to_s
+
       expect(config.public_manifest_path.to_s).to eq public_manifest_path
     end
 
     it "#manifest_path returns correct path" do
       manifest_path = File.expand_path File.join(File.dirname(__FILE__), "webpacker_test_app/public/packs", "manifest.json").to_s
+
       expect(config.manifest_path.to_s).to eq manifest_path
     end
 
     it "#cache_path returns correct path" do
       cache_path = File.expand_path File.join(File.dirname(__FILE__), "webpacker_test_app/tmp/webpacker").to_s
+
       expect(config.cache_path.to_s).to eq cache_path
     end
 
@@ -186,6 +193,7 @@ describe "Webpacker::Configuration" do
 
     it "#public_output_path returns correct path" do
       expected_public_output_path = File.expand_path File.join(File.dirname(__FILE__), "public/packs").to_s
+
       expect(config.public_output_path.to_s).to eq expected_public_output_path
     end
   end
@@ -199,6 +207,7 @@ describe "Webpacker::Configuration" do
 
     it "#manifest_path returns correct expected value" do
       expected_manifest_path = File.expand_path File.join(File.dirname(__FILE__), "webpacker_test_app/app/packs", "manifest.json").to_s
+
       expect(config.manifest_path.to_s).to eq expected_manifest_path
     end
   end
@@ -206,8 +215,8 @@ describe "Webpacker::Configuration" do
   context "with webpacker_precompile entry set to false" do
     describe "#webpacker_precompile?" do
       before :each do
-        ENV.delete("WEBPACKER_PRECOMPILE")
         ENV.delete("SHAKAPACKER_PRECOMPILE")
+        ENV.delete("WEBPACKER_PRECOMPILE")
       end
 
       let(:config) {
@@ -229,9 +238,8 @@ describe "Webpacker::Configuration" do
         expect(subject).to be true
       end
 
-      it "returns false with WEBPACKER_PRECOMPILE set to falsy value" do
-        # ENV["WEBPACKER_PRECOMPILE"] = "no"
-        ENV.delete("WEBPACKER_PRECOMPILE")
+      it "returns false with WEBPACKER_PRECOMPILE set to nil" do
+        ENV["SHAKAPACKER_PRECOMPILE"] = nil
         expect(subject).to be false
       end
     end

data/spec/backward_compatibility_specs/dev_server_runner_spec.rb

@@ -17,63 +17,124 @@ describe "DevServerRunner" do
 
   let(:test_app_path) { File.expand_path("webpacker_test_app", __dir__) }
 
-  it "run cmd via node modules" do
-    cmd = ["#{test_app_path}/node_modules/.bin/webpack", "serve", "--config", "#{test_app_path}/config/webpack/webpack.config.js"]
-    verify_command(cmd, use_node_modules: true)
-  end
+  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)
 
-  it "run cmd via yarn" do
-    cmd = ["yarn", "webpack", "serve", "--config", "#{test_app_path}/config/webpack/webpack.config.js"]
-    verify_command(cmd, use_node_modules: false)
-  end
+      let(:package_json) { PackageJson.read(test_app_path) }
 
-  it "run cmd argv" do
-    cmd = ["#{test_app_path}/node_modules/.bin/webpack", "serve", "--config", "#{test_app_path}/config/webpack/webpack.config.js", "--quiet"]
-    verify_command(cmd, argv: (["--quiet"]))
-  end
+      require "package_json"
+
+      it "uses the expected package manager", unless: fallback_manager == "yarn_classic" do
+        cmd = package_json.manager.native_exec_command("webpack", ["serve", "--config", "#{test_app_path}/config/webpack/webpack.config.js"])
+
+        manager_name = fallback_manager.split("_")[0]
+
+        expect(cmd).to start_with(manager_name)
+      end
+
+      it "runs the command using the manager" do
+        cmd = package_json.manager.native_exec_command("webpack", ["serve", "--config", "#{test_app_path}/config/webpack/webpack.config.js"])
+
+        verify_command(cmd)
+      end
 
-  it "run cmd argv with https" do
-    cmd = ["#{test_app_path}/node_modules/.bin/webpack", "serve", "--config", "#{test_app_path}/config/webpack/webpack.config.js", "--https"]
+      it "passes on arguments" do
+        cmd = package_json.manager.native_exec_command("webpack", ["serve", "--config", "#{test_app_path}/config/webpack/webpack.config.js", "--quiet"])
 
-    dev_server = double()
-    allow(dev_server).to receive(:host).and_return("localhost")
-    allow(dev_server).to receive(:port).and_return("3035")
-    allow(dev_server).to receive(:pretty?).and_return(false)
-    allow(dev_server).to receive(:https?).and_return(true)
-    allow(dev_server).to receive(:hmr?).and_return(false)
+        verify_command(cmd, argv: (["--quiet"]))
+      end
 
-    allow(Webpacker::DevServer).to receive(:new) do
-      verify_command(cmd, argv: (["--https"]))
-    end.and_return(dev_server)
+      it "supports the https flag" do
+        cmd = package_json.manager.native_exec_command("webpack", ["serve", "--config", "#{test_app_path}/config/webpack/webpack.config.js", "--https"])
+
+        dev_server = double()
+        allow(dev_server).to receive(:host).and_return("localhost")
+        allow(dev_server).to receive(:port).and_return("3035")
+        allow(dev_server).to receive(:pretty?).and_return(false)
+        allow(dev_server).to receive(:https?).and_return(true)
+        allow(dev_server).to receive(:hmr?).and_return(false)
+
+        allow(Shakapacker::DevServer).to receive(:new) do
+          verify_command(cmd, argv: (["--https"]))
+        end.and_return(dev_server)
+      end
+
+      it "accepts environment variables" do
+        cmd = package_json.manager.native_exec_command("webpack", ["serve", "--config", "#{test_app_path}/config/webpack/webpack.config.js"])
+        env = Webpacker::Compiler.env.dup
+
+        # ENV["WEBPACKER_CONFIG"] is the interface and env["SHAKAPACKER_CONFIG"] is internal
+        ENV["WEBPACKER_CONFIG"] = env["SHAKAPACKER_CONFIG"] = "#{test_app_path}/config/webpacker_other_location.yml"
+        env["WEBPACK_SERVE"] = "true"
+
+        verify_command(cmd, env: env)
+      end
+    end
   end
 
-  it "accepts environment variables" do
-    cmd = ["#{test_app_path}/node_modules/.bin/webpack", "serve", "--config", "#{test_app_path}/config/webpack/webpack.config.js"]
-    env = Webpacker::Compiler.env.dup
+  context "when not using package_json" do
+    with_use_package_json_gem(enabled: false)
 
-    # ENV["WEBPACKER_CONFIG"] is the interface and env["SHAKAPACKER_CONFIG"] is internal
-    ENV["WEBPACKER_CONFIG"] = env["SHAKAPACKER_CONFIG"] = "#{test_app_path}/config/webpacker_other_location.yml"
-    env["WEBPACK_SERVE"] = "true"
-    verify_command(cmd, env: env)
+    it "supports running via node modules" do
+      cmd = ["#{test_app_path}/node_modules/.bin/webpack", "serve", "--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", "serve", "--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", "serve", "--config", "#{test_app_path}/config/webpack/webpack.config.js", "--quiet"]
+
+      verify_command(cmd, argv: (["--quiet"]))
+    end
+
+    it "supports the https flag" do
+      cmd = ["#{test_app_path}/node_modules/.bin/webpack", "serve", "--config", "#{test_app_path}/config/webpack/webpack.config.js", "--https"]
+
+      dev_server = double()
+      allow(dev_server).to receive(:host).and_return("localhost")
+      allow(dev_server).to receive(:port).and_return("3035")
+      allow(dev_server).to receive(:pretty?).and_return(false)
+      allow(dev_server).to receive(:https?).and_return(true)
+      allow(dev_server).to receive(:hmr?).and_return(false)
+
+      allow(Shakapacker::DevServer).to receive(:new) do
+        verify_command(cmd, argv: (["--https"]))
+      end.and_return(dev_server)
+    end
+
+    it "accepts environment variables" do
+      cmd = ["#{test_app_path}/node_modules/.bin/webpack", "serve", "--config", "#{test_app_path}/config/webpack/webpack.config.js"]
+      env = Webpacker::Compiler.env.dup
+
+      # ENV["WEBPACKER_CONFIG"] is the interface and env["SHAKAPACKER_CONFIG"] is internal
+      ENV["WEBPACKER_CONFIG"] = env["SHAKAPACKER_CONFIG"] = "#{test_app_path}/config/webpacker_other_location.yml"
+      env["WEBPACK_SERVE"] = "true"
+
+      verify_command(cmd, env: env)
+    end
   end
 
   private
 
     def verify_command(cmd, use_node_modules: true, argv: [], env: Webpacker::Compiler.env)
-      cwd = Dir.pwd
-      Dir.chdir(test_app_path)
-      klass = Webpacker::DevServerRunner
-      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).with(env, *cmd)
+      Dir.chdir(test_app_path) do
+        klass = Webpacker::DevServerRunner
+        instance = klass.new(argv)
 
-      klass.run(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).with(env, *cmd)
 
-      expect(Kernel).to have_received(:exec).with(env, *cmd)
+        klass.run(argv)
 
-      ensure
-        Dir.chdir(cwd)
+        expect(Kernel).to have_received(:exec).with(env, *cmd)
+      end
     end
 end

data/spec/backward_compatibility_specs/dev_server_spec.rb

@@ -41,7 +41,7 @@ describe "DevServer" do
     end
   end
 
-  it "users SHAKAPACKER_DEV_SERVER for DEFAULT_ENV_PREFIX" do
+  it "uses SHAKAPACKER_DEV_SERVER for DEFAULT_ENV_PREFIX" do
     expect(Webpacker::DevServer::DEFAULT_ENV_PREFIX).to eq "SHAKAPACKER_DEV_SERVER"
   end
 end