webpacker 5.4.4 → 6.0.0.beta

data/lib/install/typescript.rb

@@ -1,39 +0,0 @@
-require "webpacker/configuration"
-
-additional_packages = ""
-example_source = "typescript"
-
-# Additional configuration is required for React projects
-package_json = Rails.root.join("package.json")
-if File.exist?(package_json)
-  package = JSON.parse(File.read(package_json))
-  package["dependencies"] ||= {}
-
-  if package["dependencies"].key?("react")
-    additional_packages = "@types/react @types/react-dom"
-    example_source = "react"
-  end
-end
-
-say "Adding TypeScript preset to babel.config.js"
-insert_into_file Rails.root.join("babel.config.js").to_s,
-  ",\n      ['@babel/preset-typescript', { 'allExtensions': true, 'isTSX': true }]",
-  before: /\s*\].filter\(Boolean\),\n\s*plugins: \[/
-
-say "Copying tsconfig.json to the Rails root directory for typescript"
-copy_file "#{__dir__}/examples/#{example_source}/tsconfig.json", "tsconfig.json"
-
-say "Updating webpack paths to include .ts file extension"
-insert_into_file Webpacker.config.config_path, "- .ts\n".indent(4), after: /\s+extensions:\n/
-
-say "Updating webpack paths to include .tsx file extension"
-insert_into_file Webpacker.config.config_path, "- .tsx\n".indent(4), after: /\s+extensions:\n/
-
-say "Copying the example entry file to #{Webpacker.config.source_entry_path}"
-copy_file "#{__dir__}/examples/typescript/hello_typescript.ts",
-  "#{Webpacker.config.source_entry_path}/hello_typescript.ts"
-
-say "Installing all typescript dependencies"
-run "yarn add typescript @babel/preset-typescript #{additional_packages}"
-
-say "Webpacker now supports typescript 🎉", :green

data/lib/install/vue.rb

@@ -1,49 +0,0 @@
-require "webpacker/configuration"
-
-say "Copying vue loader to config/webpack/loaders"
-copy_file "#{__dir__}/loaders/vue.js", Rails.root.join("config/webpack/loaders/vue.js").to_s
-
-say "Adding vue loader plugin to config/webpack/environment.js"
-insert_into_file Rails.root.join("config/webpack/environment.js").to_s,
-  "const { VueLoaderPlugin } = require('vue-loader')\n",
-  after: /require\(('|")@rails\/webpacker\1\);?\n/
-
-insert_into_file Rails.root.join("config/webpack/environment.js").to_s,
-  "environment.plugins.prepend('VueLoaderPlugin', new VueLoaderPlugin())\n",
-  before: "module.exports"
-
-say "Adding vue loader to config/webpack/environment.js"
-insert_into_file Rails.root.join("config/webpack/environment.js").to_s,
-  "const vue = require('./loaders/vue')\n",
-  after: "require('vue-loader')\n"
-
-insert_into_file Rails.root.join("config/webpack/environment.js").to_s,
-  "environment.loaders.prepend('vue', vue)\n",
-  before: "module.exports"
-
-say "Updating webpack paths to include .vue file extension"
-insert_into_file Webpacker.config.config_path, "- .vue\n".indent(4), after: /\s+extensions:\n/
-
-say "Copying the example entry file to #{Webpacker.config.source_entry_path}"
-copy_file "#{__dir__}/examples/vue/hello_vue.js",
-  "#{Webpacker.config.source_entry_path}/hello_vue.js"
-
-say "Copying Vue app file to #{Webpacker.config.source_entry_path}"
-copy_file "#{__dir__}/examples/vue/app.vue",
-  "#{Webpacker.config.source_path}/app.vue"
-
-say "Installing all Vue dependencies"
-run "yarn add vue vue-loader vue-template-compiler"
-
-if Rails::VERSION::MAJOR == 5 && Rails::VERSION::MINOR > 1
-  say "You need to enable unsafe-eval rule.", :yellow
-  say "This can be done in Rails 5.2+ for development environment in the CSP initializer", :yellow
-  say "config/initializers/content_security_policy.rb with a snippet like this:", :yellow
-  say "if Rails.env.development?", :yellow
-  say "  policy.script_src :self, :https, :unsafe_eval", :yellow
-  say "else", :yellow
-  say "  policy.script_src :self, :https", :yellow
-  say "end", :yellow
-end
-
-say "Webpacker now supports Vue.js 🎉", :green

data/lib/tasks/installers.rake

@@ -1,42 +0,0 @@
-installers = {
-  "Angular": :angular,
-  "Elm": :elm,
-  "React": :react,
-  "Vue": :vue,
-  "Erb": :erb,
-  "Coffee": :coffee,
-  "Typescript": :typescript,
-  "Svelte": :svelte,
-  "Stimulus": :stimulus
-}.freeze
-
-dependencies = {
-  "Angular": [:typescript]
-}
-
-bin_path = ENV["BUNDLE_BIN"] || "./bin"
-
-namespace :webpacker do
-  namespace :install do
-    installers.each do |name, task_name|
-      desc "Install everything needed for #{name}"
-      task task_name => ["webpacker:verify_install"] do
-        template = File.expand_path("../install/#{task_name}.rb", __dir__)
-        base_path =
-          if Rails::VERSION::MAJOR >= 5
-            "#{RbConfig.ruby} #{bin_path}/rails app:template"
-          else
-            "#{RbConfig.ruby} #{bin_path}/rake rails:template"
-          end
-
-        dependencies[name] ||= []
-        dependencies[name].each do |dependency|
-          dependency_template = File.expand_path("../install/#{dependency}.rb", __dir__)
-          system "#{base_path} LOCATION=#{dependency_template}"
-        end
-
-        exec "#{base_path} LOCATION=#{template}"
-      end
-    end
-  end
-end

data/package/config_types/__tests__/config_list.js

@@ -1,118 +0,0 @@
-/* global test expect */
-
-const ConfigList = require('../config_list')
-
-test('new', () => {
-  const list = new ConfigList()
-  expect(list).toBeInstanceOf(ConfigList)
-  expect(list).toBeInstanceOf(Array)
-})
-
-test('get', () => {
-  const list = new ConfigList()
-  list.append('key', 'value')
-  expect(list.get('key')).toEqual('value')
-})
-
-test('append', () => {
-  const list = new ConfigList()
-  list.append('key', 'value')
-  expect(list.append('key1', 'value1')).toEqual([
-    { key: 'key', value: 'value' },
-    { key: 'key1', value: 'value1' }
-  ])
-})
-
-test('prepend', () => {
-  const list = new ConfigList()
-  list.append('key', 'value')
-  expect(list.prepend('key1', 'value1')).toEqual([
-    { key: 'key1', value: 'value1' },
-    { key: 'key', value: 'value' }
-  ])
-})
-
-test('insert without position', () => {
-  const list = new ConfigList()
-  list.append('key', 'value')
-
-  expect(list.insert('key1', 'value1')).toEqual([
-    { key: 'key', value: 'value' },
-    { key: 'key1', value: 'value1' }
-  ])
-
-  expect(list.insert('key2', 'value2')).toEqual([
-    { key: 'key', value: 'value' },
-    { key: 'key1', value: 'value1' },
-    { key: 'key2', value: 'value2' }
-  ])
-})
-
-test('insert before an item', () => {
-  const list = new ConfigList()
-  list.append('key', 'value')
-  list.append('key1', 'value1')
-
-  expect(list.insert('key2', 'value2', { before: 'key' })).toEqual([
-    { key: 'key2', value: 'value2' },
-    { key: 'key', value: 'value' },
-    { key: 'key1', value: 'value1' }
-  ])
-
-  expect(list.insert('key3', 'value3', { before: 'key2' })).toEqual([
-    { key: 'key3', value: 'value3' },
-    { key: 'key2', value: 'value2' },
-    { key: 'key', value: 'value' },
-    { key: 'key1', value: 'value1' }
-  ])
-})
-
-test('insert after an item', () => {
-  const list = new ConfigList()
-  list.append('key', 'value')
-  list.append('key1', 'value1')
-
-  expect(list.insert('key2', 'value2', { after: 'key' })).toEqual([
-    { key: 'key', value: 'value' },
-    { key: 'key2', value: 'value2' },
-    { key: 'key1', value: 'value1' }
-  ])
-
-  expect(list.insert('key3', 'value3', { after: 'key2' })).toEqual([
-    { key: 'key', value: 'value' },
-    { key: 'key2', value: 'value2' },
-    { key: 'key3', value: 'value3' },
-    { key: 'key1', value: 'value1' }
-  ])
-})
-
-test('delete', () => {
-  const list = new ConfigList()
-  list.append('key', 'value')
-  list.append('key1', 'value1')
-  expect(list.delete('key')).toEqual([{ key: 'key1', value: 'value1' }])
-  expect(list.delete('key1')).toEqual([])
-})
-
-test('getIndex', () => {
-  const list = new ConfigList()
-  list.append('key', 'value')
-  list.append('key1', 'value1')
-  expect(list.getIndex('key')).toEqual(0)
-  expect(list.getIndex('key2')).toEqual(-1)
-  expect(() => list.getIndex('key2', true)).toThrow('Item key2 not found')
-})
-
-test('values', () => {
-  const list = new ConfigList()
-  list.append('key', 'value')
-  list.append('key1', 'value1')
-  expect(list.values()).toEqual(['value', 'value1'])
-})
-
-test('keys', () => {
-  const list = new ConfigList()
-  list.append('key', 'value')
-  list.append('key1', 'value1')
-  expect(list.keys()).toEqual(['key', 'key1'])
-})

data/package/config_types/__tests__/config_object.js

@@ -1,43 +0,0 @@
-/* global test expect */
-
-const ConfigObject = require('../config_object')
-
-test('new', () => {
-  const object = new ConfigObject()
-  expect(object).toBeInstanceOf(ConfigObject)
-  expect(object).toBeInstanceOf(Object)
-})
-
-test('set', () => {
-  const object = new ConfigObject()
-  expect(object.set('key', 'value')).toEqual({ key: 'value' })
-})
-
-test('get', () => {
-  const object = new ConfigObject()
-  object.set('key', 'value')
-  object.set('key1', 'value1')
-  expect(object.get('key')).toEqual('value')
-})
-
-test('delete', () => {
-  const object = new ConfigObject()
-  object.set('key', { key1: 'value' })
-  expect(object.delete('key.key1')).toEqual({ key: {} })
-  expect(object.delete('key')).toEqual({})
-})
-
-test('toObject', () => {
-  const object = new ConfigObject()
-  object.set('key', 'value')
-  object.set('key1', 'value1')
-  expect(object.toObject()).toEqual({ key: 'value', key1: 'value1' })
-})
-
-test('merge', () => {
-  const object = new ConfigObject()
-  object.set('foo', {})
-  expect(object.merge({ key: 'foo', value: 'bar' })).toEqual(
-    { foo: {}, key: 'foo', value: 'bar' }
-  )
-})

data/package/config_types/config_list.js

@@ -1,75 +0,0 @@
-/**
-  * @class
-  * @extends { Array }
-*/
-class ConfigList extends Array {
-  static get [Symbol.species]() { return Array }
-
-  get(key) {
-    const index = this.getIndex(key, true)
-    return this[index].value
-  }
-
-  append(key, value) {
-    return this.add({ key, value })
-  }
-
-  prepend(key, value) {
-    return this.add({ key, value }, 'prepend')
-  }
-
-  insert(key, value, pos = {}) {
-    if (!(pos.before || pos.after)) return this.append(key, value)
-
-    const currentIndex = this.getIndex(key)
-    if (currentIndex >= 0) this.splice(currentIndex, 1)
-
-    let newIndex = this.getIndex(pos.before || pos.after)
-    if (pos.after) newIndex += 1
-
-    this.splice(newIndex, 0, { key, value })
-    return this
-  }
-
-  delete(key) {
-    const index = this.getIndex(key, true)
-    this.splice(index, 1)
-    return this
-  }
-
-  getIndex(key, shouldThrow = false) {
-    const index = this.findIndex((entry) => (
-      entry === key
-        || entry.key === key
-        || (entry.constructor && entry.constructor.name === key)
-    ))
-
-    if (shouldThrow && index < 0) throw new Error(`Item ${key} not found`)
-    return index
-  }
-
-  add({ key, value }, strategy = 'append') {
-    const index = this.getIndex(key)
-    if (index >= 0) this.delete(key)
-
-    switch (strategy) {
-      case 'prepend':
-        this.unshift({ key, value })
-        break
-      default:
-        this.push({ key, value })
-    }
-
-    return this
-  }
-
-  values() {
-    return this.map((item) => item.value)
-  }
-
-  keys() {
-    return this.map((item) => item.key)
-  }
-}
-
-module.exports = ConfigList

data/package/config_types/config_object.js

@@ -1,55 +0,0 @@
-const objectify = require('../utils/objectify')
-const deepAssign = require('../utils/deep_assign')
-const deepMerge = require('../utils/deep_merge')
-const { isStrPath, prettyPrint } = require('../utils/helpers')
-
-/**
-  * @class
-  * @extends { Object }
-*/
-class ConfigObject extends Object {
-  constructor(props = {}) {
-    super()
-    this.merge(props)
-  }
-
-  get(key) {
-    return isStrPath(key) ? objectify(key, this) : this[key]
-  }
-
-  set(key, value) {
-    Object.assign(this, deepAssign(this, key, value))
-    return this
-  }
-
-  delete(key) {
-    let obj = this
-    let propKey = key
-
-    if (isStrPath(key)) {
-      const keys = key.split('.')
-      propKey = keys.pop()
-      const parentObjPath = keys.join('.')
-      obj = objectify(parentObjPath, this)
-    }
-
-    if (!obj) throw new Error(`Prop not found: ${key} in ${prettyPrint(obj)}`)
-    delete obj[propKey]
-
-    return this
-  }
-
-  toObject() {
-    const object = {}
-    /* eslint no-return-assign: 0 */
-    Object.keys(this).forEach((key) => (object[key] = this[key]))
-    return object
-  }
-
-  merge(config) {
-    Object.assign(this, deepMerge(this, config))
-    return this
-  }
-}
-
-module.exports = ConfigObject

data/package/config_types/index.js

@@ -1,7 +0,0 @@
-const ConfigObject = require('./config_object')
-const ConfigList = require('./config_list')
-
-module.exports = {
-  ConfigObject,
-  ConfigList
-}

data/package/rules/module.css.js

@@ -1,3 +0,0 @@
-const getStyleRule = require('../utils/get_style_rule')
-
-module.exports = getStyleRule(/\.(css)$/i, true)

data/package/rules/module.sass.js

@@ -1,8 +0,0 @@
-const getStyleRule = require('../utils/get_style_rule')
-
-module.exports = getStyleRule(/\.(scss|sass)$/i, true, [
-  {
-    loader: 'sass-loader',
-    options: { sourceMap: true }
-  }
-])

data/package/rules/node_modules.js

@@ -1,22 +0,0 @@
-const { nodeEnv } = require('../env')
-
-// Compile standard ES features for JS in node_modules with Babel.
-//   Regex details for exclude: https://regex101.com/r/SKPnnv/1
-module.exports = {
-  test: /\.(js|mjs)$/,
-  include: /node_modules/,
-  exclude: /(?:@?babel(?:\/|\\{1,2}|-).+)|regenerator-runtime|core-js|^webpack$|^webpack-assets-manifest$|^webpack-cli$|^webpack-sources$|^@rails\/webpacker$/,
-  use: [
-    {
-      loader: 'babel-loader',
-      options: {
-        babelrc: false,
-        presets: [['@babel/preset-env', { modules: false }]],
-        cacheDirectory: true,
-        cacheCompression: nodeEnv === 'production',
-        compact: false,
-        sourceMaps: false
-      }
-    }
-  ]
-}

data/package/utils/__tests__/deep_assign.js

@@ -1,32 +0,0 @@
-/* global test expect */
-
-const deepAssign = require('../deep_assign')
-
-describe('deepAssign()', () => {
-  test('deeply assigns nested properties', () => {
-    const object = { foo: { bar: { } } }
-    const path = 'foo.bar'
-    const value = { x: 1, y: 2 }
-    const expectation = { foo: { bar: { x: 1, y: 2 } } }
-    expect(deepAssign(object, path, value)).toEqual(expectation)
-  })
-
-  test('allows assignment of a literal false', () => {
-    const object = { foo: { bar: { } } }
-    const path = 'foo.bar'
-    const value = false
-    const expectation = { foo: { bar: false } }
-    expect(deepAssign(object, path, value)).toEqual(expectation)
-  })
-
-  test('does not allow assignment of other falsy values', () => {
-    const object = { foo: { bar: { } } }
-    const path = 'foo.bar'
-    const values = [undefined, null, 0, '']
-
-    values.forEach(value => {
-      const expectation = new Error(`Value can't be ${value}`)
-      expect(() => deepAssign(object, path, value)).toThrow(expectation)
-    })
-  })
-})

data/package/utils/__tests__/deep_merge.js

@@ -1,10 +0,0 @@
-/* global test expect */
-
-const deepMerge = require('../deep_merge')
-
-test('deep merge objects together', () => {
-  const object1 = { foo: { bar: [1, 2, 3], z: 1 }, x: 0 }
-  const object2 = { foo: { bar: ['x', 'y'] }, x: 1, y: 2 }
-  const expectation = { foo: { bar: [1, 2, 3, 'x', 'y'], z: 1 }, x: 1, y: 2 }
-  expect(deepMerge(object1, object2)).toEqual(expectation)
-})

data/package/utils/__tests__/get_style_rule.js

@@ -1,65 +0,0 @@
-const { chdirTestApp, chdirCwd } = require('../helpers')
-
-chdirTestApp()
-
-const getStyleRule = require('../get_style_rule')
-
-describe('getStyleRule', () => {
-  afterAll(chdirCwd)
-
-  test('excludes modules by default', () => {
-    const cssRule = getStyleRule(/\.(css)$/i)
-    const expectation = {
-      test: /\.(css)$/i,
-      exclude: /\.module\.[a-z]+$/
-    }
-
-    expect(cssRule).toMatchObject(expectation)
-  })
-
-  test('includes modules if set to true', () => {
-    const cssRule = getStyleRule(/\.(scss)$/i, true)
-    const expectation = {
-      test: /\.(scss)$/i,
-      include: /\.module\.[a-z]+$/
-    }
-
-    expect(cssRule).toMatchObject(expectation)
-  })
-
-  test('adds extra preprocessors if supplied', () => {
-    const expectation = [{ foo: 'bar' }]
-    const cssRule = getStyleRule(/\.(css)$/i, true, expectation)
-
-    expect(cssRule.use).toMatchObject(expect.arrayContaining(expectation))
-  })
-
-  test('adds mini-css-extract-plugin when extract_css is true', () => {
-    const MiniCssExtractPlugin = require('mini-css-extract-plugin')
-    const expectation = [MiniCssExtractPlugin.loader]
-
-    require('../../config').extract_css = true
-    const cssRule = getStyleRule(/\.(css)$/i)
-
-    expect(cssRule.use).toMatchObject(expect.arrayContaining(expectation))
-  })
-
-  test('adds style-loader when extract_css is true', () => {
-    const expectation = [{loader: 'style-loader'}]
-
-    require('../../config').extract_css = false
-    const cssRule = getStyleRule(/\.(css)$/i)
-
-    expect(cssRule.use).toMatchObject(expect.objectContaining(expectation))
-  })
-
-  test(`doesn't add mini-css-extract-plugin when extract_css is false`, () => {
-    const MiniCssExtractPlugin = require('mini-css-extract-plugin')
-    const expectation = [MiniCssExtractPlugin.loader]
-
-    require('../../config').extract_css = false
-    const cssRule = getStyleRule(/\.(css)$/i)
-
-    expect(cssRule.use).toMatchObject(expect.not.arrayContaining(expectation))
-  })
-})

data/package/utils/__tests__/objectify.js

@@ -1,9 +0,0 @@
-/* global test expect */
-
-const objectify = require('../objectify')
-
-test('Get object from a string path', () => {
-  const object = { foo: { bar: { x: 1 } } }
-  expect(objectify('foo.bar', object)).toEqual({ x: 1 })
-  expect(objectify('some.bar', object)).toEqual(undefined)
-})

data/package/utils/deep_assign.js

@@ -1,22 +0,0 @@
-const { canMerge, prettyPrint } = require('./helpers')
-const deepMerge = require('./deep_merge')
-
-const deepAssign = (obj, path, value) => {
-  if (!value && value !== false) throw new Error(`Value can't be ${value}`)
-
-  const keys = path.split('.')
-  const key = keys.pop()
-
-  const objRef = keys.reduce((acc, currentValue) => {
-    /* eslint no-param-reassign: 0 */
-    if (!acc[currentValue]) acc[currentValue] = {}
-    return acc[currentValue]
-  }, obj)
-
-  if (!objRef) throw new Error(`Prop not found: ${path} in ${prettyPrint(obj)}`)
-
-  objRef[key] = canMerge(value) ? deepMerge(objRef[key], value) : value
-  return obj
-}
-
-module.exports = deepAssign

data/package/utils/deep_merge.js

@@ -1,22 +0,0 @@
-const {
-  isObject, isArray, isEqual, isEmpty
-} = require('./helpers')
-
-const deepMerge = (target, source) => {
-  if (isEmpty(target)) return source
-  if (isEmpty(source)) return target
-  if (isEqual(target, source)) return source
-  if (isArray(target) && isArray(source)) return [...new Set([...target, ...source])]
-  if (!(isObject(target) && isObject(source))) return source
-
-  return [...Object.keys(target), ...Object.keys(source)].reduce(
-    (result, key) => ({
-
-      ...result,
-      [key]: deepMerge(target[key], source[key])
-    }),
-    {}
-  )
-}
-
-module.exports = deepMerge

data/package/utils/objectify.js

@@ -1,3 +0,0 @@
-const objectify = (path, obj) => path.split('.').reduce((prev, curr) => (prev ? prev[curr] : undefined), obj)
-
-module.exports = objectify