shakapacker 6.5.4 → 7.0.2

data/package/environments/__tests__/base-bc.js

@@ -0,0 +1,107 @@
+/* global test expect, describe, afterAll, beforeEach */
+
+// environment.js expects to find config/webapacker.yml and resolved modules from
+// the root of a Rails project
+
+const { resetEnv, chdirWebpackerTestApp } = require('../../utils/helpers')
+
+const rootPath = process.cwd()
+chdirWebpackerTestApp()
+
+const { resolve } = require('path')
+
+const baseConfig = require('../base')
+const config = require("../../config");
+
+describe('Base config', () => {
+  beforeEach(() => jest.resetModules() && resetEnv())
+  afterAll(() => process.chdir(rootPath))
+
+  describe('config', () => {
+    test('should return entry', () => {
+      expect(baseConfig.entry.application).toEqual(
+        resolve('app', 'packs', 'entrypoints', 'application.js')
+      )
+    })
+
+    test('should return false for css_extract_ignore_order_warnings when using default config', () => {
+      expect(config.css_extract_ignore_order_warnings).toEqual(false)
+    })
+
+    test('should return true for css_extract_ignore_order_warnings when configured', () => {
+      process.env.WEBPACKER_CONFIG = 'config/webpacker_css_extract_ignore_order_warnings.yml'
+      const config = require("../../config");
+
+      expect(config.css_extract_ignore_order_warnings).toEqual(true)
+    })
+
+    test('should return only 2 entry points with config.nested_entries == false', () => {
+      expect(config.nested_entries).toEqual(false)
+
+      expect(baseConfig.entry.multi_entry.sort()).toEqual([
+        resolve('app', 'packs', 'entrypoints', 'multi_entry.css'),
+        resolve('app', 'packs', 'entrypoints', 'multi_entry.js')
+      ])
+      expect(baseConfig.entry['generated/something']).toEqual(undefined)
+    })
+
+    test('should returns top level and nested entry points with config.nested_entries == true', () => {
+      process.env.WEBPACKER_CONFIG = 'config/webpacker_nested_entries.yml'
+      const config = require("../../config");
+      const baseConfig = require('../base')
+
+      expect(config.nested_entries).toEqual(true)
+
+      expect(baseConfig.entry.application).toEqual(
+        resolve('app', 'packs', 'entrypoints', 'application.js')
+      )
+      expect(baseConfig.entry.multi_entry.sort()).toEqual([
+        resolve('app', 'packs', 'entrypoints', 'multi_entry.css'),
+        resolve('app', 'packs', 'entrypoints', 'multi_entry.js')
+      ])
+      expect(baseConfig.entry['generated/something']).toEqual(
+        resolve('app', 'packs', 'entrypoints', 'generated', 'something.js')
+      )
+    })
+
+    test('should return output', () => {
+      expect(baseConfig.output.filename).toEqual('js/[name]-[contenthash].js')
+      expect(baseConfig.output.chunkFilename).toEqual(
+        'js/[name]-[contenthash].chunk.js'
+      )
+    })
+
+    test('should return default loader rules for each file in config/loaders', () => {
+      const rules = require('../../rules')
+
+      const defaultRules = Object.keys(rules)
+      const configRules = baseConfig.module.rules
+
+      expect(defaultRules.length).toEqual(3)
+      expect(configRules.length).toEqual(3)
+    })
+
+    test('should return default plugins', () => {
+      expect(baseConfig.plugins.length).toEqual(2)
+    })
+
+    test('should return default resolveLoader', () => {
+      expect(baseConfig.resolveLoader.modules).toEqual(['node_modules'])
+    })
+
+    test('should return default resolve.modules with additions', () => {
+      expect(baseConfig.resolve.modules).toEqual([
+        resolve('app', 'packs'),
+        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/package/environments/__tests__/base.js

@@ -1,10 +1,11 @@
 /* global test expect, describe, afterAll, beforeEach */
 
-// environment.js expects to find config/webpacker.yml and resolved modules from
+// environment.js expects to find config/shakapacker.yml and resolved modules from
 // the root of a Rails project
 
 const { chdirTestApp, chdirCwd, resetEnv } = require('../../utils/helpers')
 
+const rootPath = process.cwd()
 chdirTestApp()
 
 const { resolve } = require('path')
@@ -14,13 +15,12 @@ const config = require("../../config");
 
 describe('Base config', () => {
   beforeEach(() => jest.resetModules() && resetEnv())
-
-  afterAll(chdirCwd)
+  afterAll(() => process.chdir(rootPath))
 
   describe('config', () => {
     test('should return entry', () => {
       expect(baseConfig.entry.application).toEqual(
-        resolve('app', 'packs', 'entrypoints', 'application.js')
+        resolve('app', 'javascript', 'entrypoints', 'application.js')
       )
     })
 
@@ -29,7 +29,7 @@ describe('Base config', () => {
     })
 
     test('should return true for css_extract_ignore_order_warnings when configured', () => {
-      process.env.WEBPACKER_CONFIG = 'config/webpacker_css_extract_ignore_order_warnings.yml'
+      process.env.SHAKAPACKER_CONFIG = 'config/shakapacker_css_extract_ignore_order_warnings.yml'
       const config = require("../../config");
 
       expect(config.css_extract_ignore_order_warnings).toEqual(true)
@@ -39,35 +39,35 @@ describe('Base config', () => {
       expect(config.nested_entries).toEqual(false)
 
       expect(baseConfig.entry.multi_entry.sort()).toEqual([
-        resolve('app', 'packs', 'entrypoints', 'multi_entry.css'),
-        resolve('app', 'packs', 'entrypoints', 'multi_entry.js')
+        resolve('app', 'javascript', 'entrypoints', 'multi_entry.css'),
+        resolve('app', 'javascript', 'entrypoints', 'multi_entry.js')
       ])
       expect(baseConfig.entry['generated/something']).toEqual(undefined)
     })
 
     test('should returns top level and nested entry points with config.nested_entries == true', () => {
-      process.env.WEBPACKER_CONFIG = 'config/webpacker_nested_entries.yml'
+      process.env.SHAKAPACKER_CONFIG = 'config/shakapacker_nested_entries.yml'
       const config = require("../../config");
       const baseConfig = require('../base')
 
       expect(config.nested_entries).toEqual(true)
 
       expect(baseConfig.entry.application).toEqual(
-        resolve('app', 'packs', 'entrypoints', 'application.js')
+        resolve('app', 'javascript', 'entrypoints', 'application.js')
       )
       expect(baseConfig.entry.multi_entry.sort()).toEqual([
-        resolve('app', 'packs', 'entrypoints', 'multi_entry.css'),
-        resolve('app', 'packs', 'entrypoints', 'multi_entry.js')
+        resolve('app', 'javascript', 'entrypoints', 'multi_entry.css'),
+        resolve('app', 'javascript', 'entrypoints', 'multi_entry.js')
       ])
       expect(baseConfig.entry['generated/something']).toEqual(
-        resolve('app', 'packs', 'entrypoints', 'generated', 'something.js')
+        resolve('app', 'javascript', 'entrypoints', 'generated', 'something.js')
       )
     })
 
     test('should return output', () => {
-      expect(baseConfig.output.filename).toEqual('js/[name].js')
+      expect(baseConfig.output.filename).toEqual('js/[name]-[contenthash].js')
       expect(baseConfig.output.chunkFilename).toEqual(
-        'js/[name].chunk.js'
+        'js/[name]-[contenthash].chunk.js'
       )
     })
 
@@ -91,7 +91,7 @@ describe('Base config', () => {
 
     test('should return default resolve.modules with additions', () => {
       expect(baseConfig.resolve.modules).toEqual([
-        resolve('app', 'packs'),
+        resolve('app', 'javascript'),
         resolve('app/assets'),
         resolve('/etc/yarn'),
         resolve('some.config.js'),

data/package/environments/__tests__/development.js

@@ -0,0 +1,53 @@
+/* global test expect, describe, afterAll, beforeEach */
+
+const { chdirTestApp, resetEnv } = require('../../utils/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("../../config");
+      config.useContentHash = true
+      const environmnetConfig = require('../development')
+
+      expect(environmnetConfig.output.filename).toEqual('js/[name]-[contenthash].js')
+      expect(environmnetConfig.output.chunkFilename).toEqual(
+        'js/[name]-[contenthash].chunk.js'
+      )
+    })
+  })
+
+  describe('with config.useContentHash = false', () => {
+    test('sets filename without using contentHash', () => {
+      const config = require("../../config");
+      config.useContentHash = false
+      const environmnetConfig = require('../development')
+
+      expect(environmnetConfig.output.filename).toEqual('js/[name].js')
+      expect(environmnetConfig.output.chunkFilename).toEqual(
+        'js/[name].chunk.js'
+      )
+    })
+  })
+
+  describe('with unset config.useContentHash', () => {
+    test('sets filename without using contentHash', () => {
+      const config = require("../../config");
+      delete config.useContentHash
+      const environmnetConfig = require('../development')
+
+      expect(environmnetConfig.output.filename).toEqual('js/[name].js')
+      expect(environmnetConfig.output.chunkFilename).toEqual(
+        'js/[name].chunk.js'
+      )
+    })
+  })
+})

data/package/environments/__tests__/production.js

@@ -0,0 +1,92 @@
+/* global test expect, describe, afterAll, beforeEach */
+
+const { chdirTestApp, resetEnv } = require('../../utils/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("../../config");
+      config.useContentHash = true
+      const environmnetConfig = require('../production')
+
+      expect(environmnetConfig.output.filename).toEqual('js/[name]-[contenthash].js')
+      expect(environmnetConfig.output.chunkFilename).toEqual(
+        'js/[name]-[contenthash].chunk.js'
+      )
+    })
+
+    test("doesn't shows any warning message", () => {
+      const consoleWarnSpy = jest.spyOn(console, 'warn');
+      const config = require("../../config");
+      config.useContentHash = true
+      const environmnetConfig = require('../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("../../config");
+      config.useContentHash = false
+      const environmnetConfig = require('../production')
+
+      expect(environmnetConfig.output.filename).toEqual('js/[name]-[contenthash].js')
+      expect(environmnetConfig.output.chunkFilename).toEqual(
+        'js/[name]-[contenthash].chunk.js'
+      )
+    })
+
+    test('shows a warning message', () => {
+      const consoleWarnSpy = jest.spyOn(console, 'warn');
+      const config = require("../../config");
+      config.useContentHash = false
+      const environmnetConfig = require('../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("../../config");
+      delete config.useContentHash
+      const environmnetConfig = require('../production')
+
+      expect(environmnetConfig.output.filename).toEqual('js/[name]-[contenthash].js')
+      expect(environmnetConfig.output.chunkFilename).toEqual(
+        'js/[name]-[contenthash].chunk.js'
+      )
+    })
+
+    test("doesn't shows any warning message", () => {
+      const consoleWarnSpy = jest.spyOn(console, 'warn');
+      const config = require("../../config");
+      delete config.useContentHash
+      const environmnetConfig = require('../production')
+
+      expect(consoleWarnSpy).not.toHaveBeenCalledWith(
+        expect.stringMatching(/Setting 'useContentHash' to 'false' in the production environment/)
+      )
+
+      consoleWarnSpy.mockRestore()
+    })
+  })
+})

data/package/environments/base.js

@@ -7,8 +7,8 @@ const { sync: globSync } = require('glob')
 const WebpackAssetsManifest = require('webpack-assets-manifest')
 const webpack = require('webpack')
 const rules = require('../rules')
-const { isProduction } = require('../env')
 const config = require('../config')
+const { isProduction } = require('../env')
 const { moduleExists } = require('../utils/helpers')
 
 const getEntryObject = () => {
@@ -16,7 +16,7 @@ const getEntryObject = () => {
   const rootPath = join(config.source_path, config.source_entry_path)
   if (config.source_entry_path === '/' && config.nested_entries) {
     throw new Error(
-      "Your webpacker config specified using a source_entry_path of '/' with 'nested_entries' == " +
+      "Your shakapacker config specified using a source_entry_path of '/' with 'nested_entries' == " +
       "'true'. Doing this would result in packs for every one of your source files"
     )
   }
@@ -68,7 +68,7 @@ const getPlugins = () => {
   ]
 
   if (moduleExists('css-loader') && moduleExists('mini-css-extract-plugin')) {
-    const hash = isProduction ? '-[contenthash:8]' : ''
+    const hash = isProduction || config.useContentHash ? '-[contenthash:8]' : ''
     const MiniCssExtractPlugin = require('mini-css-extract-plugin')
     plugins.push(
       new MiniCssExtractPlugin({
@@ -87,7 +87,8 @@ const getPlugins = () => {
 
 // Don't use contentHash except for production for performance
 // https://webpack.js.org/guides/build-performance/#avoid-production-specific-tooling
-const hash = isProduction ? '-[contenthash]' : ''
+const hash = isProduction || config.useContentHash ? '-[contenthash]' : ''
+
 module.exports = {
   mode: 'production',
   output: {

data/package/environments/development.js

@@ -1,55 +1,13 @@
 const { merge } = require('webpack-merge')
 
 const baseConfig = require('./base')
-const devServer = require('../dev_server')
+const webpackDevServerConfig  = require('../webpackDevServerConfig')
 const { runningWebpackDevServer } = require('../env')
 
-const { outputPath: contentBase, publicPath } = require('../config')
-
-let devConfig = {
+const devConfig = {
   mode: 'development',
-  devtool: 'cheap-module-source-map'
-}
-
-if (runningWebpackDevServer) {
-  const liveReload = devServer.live_reload !== undefined ? devServer.live_reload : !devServer.hmr
-
-  const devServerConfig = {
-    devMiddleware: {
-      publicPath
-    },
-    compress: devServer.compress,
-    allowedHosts: devServer.allowed_hosts,
-    host: devServer.host,
-    port: devServer.port,
-    https: devServer.https,
-    hot: devServer.hmr,
-    liveReload,
-    historyApiFallback: { disableDotRule: true },
-    headers: devServer.headers,
-    static: {
-      publicPath: contentBase
-    }
-  }
-
-  if (devServer.static) {
-    devServerConfig.static = { ...devServerConfig.static, ...devServer.static }
-  }
-
-  if (devServer.client) {
-    devServerConfig.client = devServer.client
-  }
-
-  devConfig = merge(devConfig, {
-    stats: {
-      colors: true,
-      entrypoints: false,
-      errorDetails: true,
-      modules: false,
-      moduleTrace: false
-    },
-    devServer: devServerConfig
-  })
+  devtool: 'cheap-module-source-map',
+  ...(runningWebpackDevServer && { devServer: webpackDevServerConfig() })
 }
 
 module.exports = merge(baseConfig, devConfig)

data/package/environments/production.js

@@ -6,6 +6,7 @@ const CompressionPlugin = require('compression-webpack-plugin')
 const TerserPlugin = require('terser-webpack-plugin')
 const baseConfig = require('./base')
 const { moduleExists } = require('../utils/helpers')
+const config = require('../config')
 
 const getPlugins = () => {
   const plugins = []
@@ -52,7 +53,7 @@ const productionConfig = {
     minimizer: [
       tryCssMinimizer(),
       new TerserPlugin({
-        parallel: Number.parseInt(process.env.WEBPACKER_PARALLEL, 10) || true,
+        parallel: Number.parseInt(process.env.SHAKAPACKER_PARALLEL, 10) || true,
         terserOptions: {
           parse: {
             // Let terser parse ecma 8 code but always output
@@ -76,4 +77,12 @@ const productionConfig = {
   }
 }
 
+if (config.useContentHash === false) {
+  // eslint-disable-next-line no-console
+  console.warn(`⚠️ WARNING
+Setting 'useContentHash' to 'false' in the production environment (specified by NODE_ENV environment variable) is not allowed!
+Content hashes get added to the filenames regardless of setting useContentHash in 'shakapacker.yml' to false.
+`)
+}
+
 module.exports = merge(baseConfig, productionConfig)

data/package/index.js

@@ -10,19 +10,26 @@ const config = require('./config')
 const devServer = require('./dev_server')
 const env = require('./env')
 const { moduleExists, canProcess } = require('./utils/helpers')
-const inliningCss = require('./inliningCss')
+const inliningCss = require('./utils/inliningCss')
 
-const webpackConfig = () => {
+const globalMutableWebpackConfig = () => {
   const { nodeEnv } = env
   const path = resolve(__dirname, 'environments', `${nodeEnv}.js`)
   const environmentConfig = existsSync(path) ? require(path) : baseConfig
   return environmentConfig
 }
 
-module.exports = {
-  config,
+const generateWebpackConfig = () => {
+  const environmentConfig = globalMutableWebpackConfig()
+  const immutable = webpackMerge.merge({}, environmentConfig)
+  return immutable
+}
+
+const shakapackerObject = {
+  config, // shakapacker.yml
   devServer,
-  webpackConfig: webpackConfig(),
+  generateWebpackConfig,
+  globalMutableWebpackConfig: globalMutableWebpackConfig(),
   baseConfig,
   env,
   rules,
@@ -31,3 +38,26 @@ module.exports = {
   inliningCss,
   ...webpackMerge
 }
+
+// For backward compatibility
+const shakapackerProxyHandler = {
+  get(target, prop) {
+    if (prop === 'webpackConfig') {
+      // eslint-disable-next-line no-console
+      console.warn(`⚠️
+DEPRECATION NOTICE:
+The 'webpackConfig' is deprecated and will be removed in a future version.
+Please use 'globalMutableWebpackConfig' instead, or use
+'generateWebpackConfig()' to avoid unwanted config mutation across the app.
+
+For more information, see version 7 upgrade documentation at:
+https://github.com/shakacode/shakapacker/blob/master/docs/v7_upgrade.md
+`)
+      return globalMutableWebpackConfig()
+    }
+
+    return target[prop]
+  }
+}
+
+module.exports = new Proxy(shakapackerObject, shakapackerProxyHandler)

data/package/rules/__tests__/__utils__/webpack.js

@@ -0,0 +1,50 @@
+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 node_modules = path.resolve("node_modules");
+const node_modules_included = path.resolve("node_modules/included");
+const app_javascript = path.resolve("app/javascript");
+
+const createInMemoryFs = () => {
+  const fs = new MemoryFS();
+
+  fs.mkdirpSync(node_modules);
+  fs.mkdirpSync(node_modules_included);
+  fs.mkdirpSync(app_javascript);
+
+  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;
+};
+
+module.exports = {
+  createTrackLoader,
+  node_modules,
+  node_modules_included,
+  app_javascript,
+  createInMemoryFs,
+  createTestCompiler,
+};

data/package/rules/__tests__/babel.js

@@ -0,0 +1,63 @@
+const path = require("path");
+const {
+  app_javascript,
+  node_modules,
+  node_modules_included,
+  createTestCompiler,
+  createTrackLoader,
+} = require("./__utils__/webpack");
+const babelConfig = require("../babel");
+
+jest.mock("../../config", () => {
+  const original = jest.requireActual("../../config");
+  return {
+    ...original,
+    additional_paths: [...original.additional_paths, "node_modules/included"],
+  };
+});
+
+const createWebpackConfig = (file, use) => {
+  return {
+    entry: { file },
+    module: {
+      rules: [
+        {
+          ...babelConfig,
+          use,
+        },
+      ],
+    },
+    output: {
+      path: "/",
+      filename: "scripts-bundled.js",
+    },
+  };
+};
+
+describe("babel", () => {
+  test("process source path", async () => {
+    const normalPath = `${app_javascript}/a.js`;
+    const [tracked, loader] = createTrackLoader();
+    const compiler = createTestCompiler(
+      createWebpackConfig(normalPath, loader)
+    );
+    await compiler.run();
+    expect(tracked[normalPath]).toBeTruthy();
+  });
+
+  test("exclude node_modules", async () => {
+    const ignored = `${node_modules}/a.js`;
+    const [tracked, loader] = createTrackLoader();
+    const compiler = createTestCompiler(createWebpackConfig(ignored, loader));
+    await compiler.run();
+    expect(tracked[ignored]).toBeUndefined();
+  });
+
+  test("explicitly included node_modules should be transpiled", async () => {
+    const included = `${node_modules_included}/a.js`;
+    const [tracked, loader] = createTrackLoader();
+    const compiler = createTestCompiler(createWebpackConfig(included, loader));
+    await compiler.run();
+    expect(tracked[included]).toBeTruthy();
+  });
+});