jetpacker 0.1.0 → 0.2.0

data/package/__tests__/staging.js

@@ -0,0 +1,29 @@
+/* test expect, describe, afterAll, beforeEach */
+
+const { resolve } = require('path')
+const { chdirTestApp, chdirCwd } = require('../utils/helpers')
+
+chdirTestApp()
+
+describe('Custom environment', () => {
+  afterAll(chdirCwd)
+
+  describe('toWebpackConfig', () => {
+    beforeEach(() => jest.resetModules())
+
+    test('should use staging config and default production environment', () => {
+      process.env.RAILS_ENV = 'staging'
+      delete process.env.NODE_ENV
+
+      const { environment } = require('../index')
+      const config = environment.toWebpackConfig()
+
+      expect(config.output.path).toEqual(resolve('public', 'packs-staging'))
+      expect(config.output.publicPath).toEqual('/packs-staging/')
+      expect(config).toMatchObject({
+        devtool: 'source-map',
+        stats: 'normal'
+      })
+    })
+  })
+})

data/package/__tests__/test.js

@@ -0,0 +1,26 @@
+/* test expect, describe, afterAll, beforeEach */
+
+const { resolve } = require('path')
+const { chdirTestApp, chdirCwd } = require('../utils/helpers')
+
+chdirTestApp()
+
+describe('Test environment', () => {
+  afterAll(chdirCwd)
+
+  describe('toWebpackConfig', () => {
+    beforeEach(() => jest.resetModules())
+
+    test('should use test config and production environment', () => {
+      process.env.RAILS_ENV = 'test'
+      process.env.NODE_ENV = 'test'
+
+      const { environment } = require('../index')
+      const config = environment.toWebpackConfig()
+
+      expect(config.output.path).toEqual(resolve('public', 'packs-test'))
+      expect(config.output.publicPath).toEqual('/packs-test/')
+      expect(config.devServer).toEqual(undefined)
+    })
+  })
+})

data/package/config.js

@@ -0,0 +1,37 @@
+const { resolve } = require('path')
+const { safeLoad } = require('js-yaml')
+const { readFileSync } = require('fs')
+const deepMerge = require('./utils/deep_merge')
+const { isArray, ensureTrailingSlash } = require('./utils/helpers')
+const { railsEnv } = require('./env')
+
+const defaultConfigPath = require.resolve('../lib/install/config/webpacker.yml')
+const configPath = resolve('config', 'webpacker.yml')
+
+const getDefaultConfig = () => {
+  const defaultConfig = safeLoad(readFileSync(defaultConfigPath), 'utf8')
+  return defaultConfig[railsEnv] || defaultConfig.production
+}
+
+const defaults = getDefaultConfig()
+const app = safeLoad(readFileSync(configPath), 'utf8')[railsEnv]
+
+if (isArray(app.extensions) && app.extensions.length) delete defaults.extensions
+if (isArray(app.static_assets_extensions) && app.static_assets_extensions.length) {
+  delete defaults.static_assets_extensions
+}
+
+const config = deepMerge(defaults, app)
+config.outputPath = resolve(config.public_root_path, config.public_output_path)
+
+// Ensure that the publicPath includes our asset host so dynamic imports
+// (code-splitting chunks and static assets) load from the CDN instead of a relative path.
+const getPublicPath = () => {
+  const rootUrl = ensureTrailingSlash(process.env.WEBPACKER_ASSET_HOST || '/')
+  return `${rootUrl}${config.public_output_path}/`
+}
+
+config.publicPath = getPublicPath()
+config.publicPathWithoutCDN = `/${config.public_output_path}/`
+
+module.exports = config

data/package/config_types/__tests__/config_list.js

@@ -0,0 +1,118 @@
+/* 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

@@ -0,0 +1,43 @@
+/* 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

@@ -0,0 +1,75 @@
+/**
+  * @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

@@ -0,0 +1,55 @@
+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

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

data/package/dev_server.js

@@ -0,0 +1,20 @@
+const { isBoolean } = require('./utils/helpers')
+const config = require('./config')
+
+const fetch = (key) => {
+  const value = process.env[key]
+  return isBoolean(value) ? JSON.parse(value) : value
+}
+
+const devServerConfig = config.dev_server
+
+if (devServerConfig) {
+  const envPrefix = config.dev_server.env_prefix || 'WEBPACKER_DEV_SERVER'
+
+  Object.keys(devServerConfig).forEach((key) => {
+    const envValue = fetch(`${envPrefix}_${key.toUpperCase().replace(/_/g, '')}`)
+    if (envValue !== undefined) devServerConfig[key] = envValue
+  })
+}
+
+module.exports = devServerConfig || {}

data/package/env.js

@@ -0,0 +1,19 @@
+const { resolve } = require('path')
+const { safeLoad } = require('js-yaml')
+const { readFileSync } = require('fs')
+
+const NODE_ENVIRONMENTS = ['development', 'production', 'test']
+const DEFAULT = 'production'
+const configPath = resolve('config', 'webpacker.yml')
+
+const railsEnv = process.env.RAILS_ENV
+const nodeEnv = process.env.NODE_ENV
+
+const config = safeLoad(readFileSync(configPath), 'utf8')
+const availableEnvironments = Object.keys(config).join('|')
+const regex = new RegExp(`^(${availableEnvironments})$`, 'g')
+
+module.exports = {
+  railsEnv: railsEnv && railsEnv.match(regex) ? railsEnv : DEFAULT,
+  nodeEnv: nodeEnv && NODE_ENVIRONMENTS.includes(nodeEnv) ? nodeEnv : DEFAULT
+}

data/package/environments/__tests__/base.js

@@ -0,0 +1,74 @@
+/* global test expect, describe, afterAll, beforeEach */
+
+// environment.js expects to find config/webpacker.yml and resolved modules from
+// the root of a Rails project
+
+const { chdirTestApp, chdirCwd } = require('../../utils/helpers')
+
+chdirTestApp()
+
+const { resolve } = require('path')
+const rules = require('../../rules')
+const { ConfigList } = require('../../config_types')
+const Environment = require('../base')
+
+describe('Environment', () => {
+  afterAll(chdirCwd)
+
+  let environment
+
+  describe('toWebpackConfig', () => {
+    beforeEach(() => {
+      environment = new Environment()
+    })
+
+    test('should return entry', () => {
+      const config = environment.toWebpackConfig()
+      expect(config.entry.application).toEqual(
+        resolve('app', 'javascript', 'packs', 'application.js')
+      )
+    })
+
+    test('should return output', () => {
+      const config = environment.toWebpackConfig()
+      expect(config.output.filename).toEqual('js/[name]-[contenthash].js')
+      expect(config.output.chunkFilename).toEqual('js/[name]-[contenthash].chunk.js')
+    })
+
+    test('should return default loader rules for each file in config/loaders', () => {
+      const config = environment.toWebpackConfig()
+      const defaultRules = Object.keys(rules)
+      const configRules = config.module.rules
+
+      expect(defaultRules.length).toEqual(7)
+      expect(configRules.length).toEqual(8)
+    })
+
+    test('should return default plugins', () => {
+      const config = environment.toWebpackConfig()
+      expect(config.plugins.length).toEqual(4)
+    })
+
+    test('should return default resolveLoader', () => {
+      const config = environment.toWebpackConfig()
+      expect(config.resolveLoader.modules).toEqual(['node_modules'])
+    })
+
+    test('should return default resolve.modules with additions', () => {
+      const config = environment.toWebpackConfig()
+      expect(config.resolve.modules).toEqual([
+        resolve('app', 'javascript'),
+        resolve('app/assets'),
+        resolve('/etc/yarn'),
+        'node_modules'
+      ])
+    })
+
+    test('returns plugins property as Array', () => {
+      const config = environment.toWebpackConfig()
+
+      expect(config.plugins).toBeInstanceOf(Array)
+      expect(config.plugins).not.toBeInstanceOf(ConfigList)
+    })
+  })
+})