35166323

Build Type

push

appveyor

Committed by GitHub

Commit Message

<a href="https://github.com/benmosher/eslint-plugin-import/commit/<a class=hub.com/benmosher/eslint-plugin-import/commit/c5cc24987bce632bd292a36182caa18aa47c2cae">c5cc24987<a href="https://github.com/benmosher/eslint-plugin-import/commit/c5cc24987bce632bd292a36182caa18aa47c2cae">">Merge </a><a class="double-link" href="https://github.com/benmosher/eslint-plugin-import/commit/<a class="double-link" href="https://github.com/benmosher/eslint-plugin-import/commit/fef718cb134016855afe61682e32c63ba3ed9281">fef718cb1</a>">fef718cb1</a><a href="https://github.com/benmosher/eslint-plugin-import/commit/c5cc24987bce632bd292a36182caa18aa47c2cae"> into bbe529a4f">bbe529a4f</a>

Run Details

1604 of 1754 branches covered (91.45%)

2 of 2 new or added lines in 1 file covered. (100.0%)

2233 of 2340 relevant lines covered (95.43%)

74.6 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

63.19

/resolvers/webpack/index.js

var findRoot = require('find-root')
  , path = require('path')
  , get = require('lodash/get')
  , isEqual = require('lodash/isEqual')
  , find = require('array-find')
  , interpret = require('interpret')
  , fs = require('fs')
  , coreLibs = require('node-libs-browser')
  , resolve = require('resolve')
  , semver = require('semver')
  , has = require('has')

var log = require('debug')('eslint-plugin-import:resolver:webpack')

exports.interfaceVersion = 2

/**
 * Find the full path to 'source', given 'file' as a full reference path.
 *
 * resolveImport('./foo', '/Users/ben/bar.js') => '/Users/ben/foo.js'
 * @param  {string} source - the module to resolve; i.e './some-module'
 * @param  {string} file - the importing file's full path; i.e. '/usr/local/bin/file.js'
 * @param  {object} settings - the webpack config file name, as well as cwd
 * @example
 * options: {
 *  // Path to the webpack config
 *  config: 'webpack.config.js',
 *  // Path to be used to determine where to resolve webpack from
 *  // (may differ from the cwd in some cases)
 *  cwd: process.cwd()
 * }
 * @return {string?} the resolved path to source, undefined if not resolved, or null
 *                   if resolved to a non-FS resource (i.e. script tag at page load)
 */
exports.resolve = function (source, file, settings) {

  // strip loaders
  var finalBang = source.lastIndexOf('!')
  if (finalBang >= 0) {
    source = source.slice(finalBang + 1)
  }

  // strip resource query
  var finalQuestionMark = source.lastIndexOf('?')
  if (finalQuestionMark >= 0) {
    source = source.slice(0, finalQuestionMark)
  }

  var webpackConfig

  var _configPath = get(settings, 'config')
    /**
     * Attempt to set the current working directory.
     * If none is passed, default to the `cwd` where the config is located.
     */
    , cwd = get(settings, 'cwd')
    , configIndex = get(settings, 'config-index')
    , env = get(settings, 'env')
    , argv = get(settings, 'argv', {})
    , packageDir

  var configPath = typeof _configPath === 'string' && _configPath.startsWith('.')
    ? path.resolve(_configPath)
    : _configPath

  log('Config path from settings:', configPath)

  // see if we've got a config path, a config object, an array of config objects or a config function
  if (!configPath || typeof configPath === 'string') {

      // see if we've got an absolute path
      if (!configPath || !path.isAbsolute(configPath)) {
        // if not, find ancestral package.json and use its directory as base for the path
        packageDir = findRoot(path.resolve(file))
        if (!packageDir) throw new Error('package not found above ' + file)
      }

      configPath = findConfigPath(configPath, packageDir)

      log('Config path resolved to:', configPath)
      if (configPath) {
        try {
          webpackConfig = require(configPath)
        } catch(e) {
          console.log('Error resolving webpackConfig', e)
          throw e
        }
      } else {
        log('No config path found relative to', file, '; using {}')
        webpackConfig = {}
      }

      if (webpackConfig && webpackConfig.default) {
        log('Using ES6 module "default" key instead of module.exports.')
        webpackConfig = webpackConfig.default
      }

  } else {
    webpackConfig = configPath
    configPath = null
  }

  if (typeof webpackConfig === 'function') {
    webpackConfig = webpackConfig(env, argv)
  }

  if (Array.isArray(webpackConfig)) {
    webpackConfig = webpackConfig.map(cfg => {
      if (typeof cfg === 'function') {
        return cfg(env, argv)
      }

      return cfg
    })

    if (typeof configIndex !== 'undefined' && webpackConfig.length > configIndex) {
      webpackConfig = webpackConfig[configIndex]
    }
    else {
      webpackConfig = find(webpackConfig, function findFirstWithResolve(config) {
        return !!config.resolve
      })
    }
  }

  if (webpackConfig == null) {
    webpackConfig = {}

    console.warn('No webpack configuration with a "resolve" field found. Using empty object instead')
  }

  log('Using config: ', webpackConfig)

  // externals
  if (findExternal(source, webpackConfig.externals, path.dirname(file))) {
    return { found: true, path: null }
  }

  // otherwise, resolve "normally"
  var resolveSync = getResolveSync(configPath, webpackConfig, cwd)

  try {
    return { found: true, path: resolveSync(path.dirname(file), source) }
  } catch (err) {
    if (source in coreLibs) {
      return { found: true, path: coreLibs[source] }
    }

    log('Error during module resolution:', err)
    return { found: false }
  }
}

var MAX_CACHE = 10
var _cache = []
function getResolveSync(configPath, webpackConfig, cwd) {
  var cacheKey = { configPath: configPath, webpackConfig: webpackConfig }
  var cached = find(_cache, function (entry) { return isEqual(entry.key, cacheKey) })
  if (!cached) {
    cached = {
      key: cacheKey,
      value: createResolveSync(configPath, webpackConfig, cwd),
    }
    // put in front and pop last item
    if (_cache.unshift(cached) > MAX_CACHE) {
      _cache.pop()
    }
  }
  return cached.value
}

function createResolveSync(configPath, webpackConfig, cwd) {
  var webpackRequire
    , basedir = null

  if (typeof configPath === 'string') {
    // This can be changed via the settings passed in when defining the resolver
    basedir = cwd || configPath
    log(`Attempting to load webpack path from ${basedir}`)
  }

  try {
    // Attempt to resolve webpack from the given `basedir`
    var webpackFilename = resolve.sync('webpack', { basedir, preserveSymlinks: false })
    var webpackResolveOpts = { basedir: path.dirname(webpackFilename), preserveSymlinks: false }

    webpackRequire = function (id) {
      return require(resolve.sync(id, webpackResolveOpts))
    }
  } catch (e) {
    // Something has gone wrong (or we're in a test). Use our own bundled
    // enhanced-resolve.
    log('Using bundled enhanced-resolve.')
    webpackRequire = require
  }

  var enhancedResolvePackage = webpackRequire('enhanced-resolve/package.json')
  var enhancedResolveVersion = enhancedResolvePackage.version
  log('enhanced-resolve version:', enhancedResolveVersion)

  var resolveConfig = webpackConfig.resolve || {}

  if (semver.major(enhancedResolveVersion) >= 2) {
    return createWebpack2ResolveSync(webpackRequire, resolveConfig)
  }

  return createWebpack1ResolveSync(webpackRequire, resolveConfig, webpackConfig.plugins)
}

function createWebpack2ResolveSync(webpackRequire, resolveConfig) {
  var EnhancedResolve = webpackRequire('enhanced-resolve')

  return EnhancedResolve.create.sync(Object.assign({}, webpack2DefaultResolveConfig, resolveConfig))
}

/**
 * webpack 2 defaults:
 * https://github.com/webpack/webpack/blob/v2.1.0-beta.20/lib/WebpackOptionsDefaulter.js#L72-L87
 * @type {Object}
 */
var webpack2DefaultResolveConfig = {
  unsafeCache: true, // Probably a no-op, since how can we cache anything at all here?
  modules: ['node_modules'],
  extensions: ['.js', '.json'],
  aliasFields: ['browser'],
  mainFields: ['browser', 'module', 'main'],
}

// adapted from tests &
// https://github.com/webpack/webpack/blob/v1.13.0/lib/WebpackOptionsApply.js#L322
function createWebpack1ResolveSync(webpackRequire, resolveConfig, plugins) {
  var Resolver = webpackRequire('enhanced-resolve/lib/Resolver')
  var SyncNodeJsInputFileSystem = webpackRequire('enhanced-resolve/lib/SyncNodeJsInputFileSystem')

  var ModuleAliasPlugin = webpackRequire('enhanced-resolve/lib/ModuleAliasPlugin')
  var ModulesInDirectoriesPlugin =
    webpackRequire('enhanced-resolve/lib/ModulesInDirectoriesPlugin')
  var ModulesInRootPlugin = webpackRequire('enhanced-resolve/lib/ModulesInRootPlugin')
  var ModuleAsFilePlugin = webpackRequire('enhanced-resolve/lib/ModuleAsFilePlugin')
  var ModuleAsDirectoryPlugin = webpackRequire('enhanced-resolve/lib/ModuleAsDirectoryPlugin')
  var DirectoryDescriptionFilePlugin =
    webpackRequire('enhanced-resolve/lib/DirectoryDescriptionFilePlugin')
  var DirectoryDefaultFilePlugin =
    webpackRequire('enhanced-resolve/lib/DirectoryDefaultFilePlugin')
  var FileAppendPlugin = webpackRequire('enhanced-resolve/lib/FileAppendPlugin')
  var ResultSymlinkPlugin = webpackRequire('enhanced-resolve/lib/ResultSymlinkPlugin')
  var DirectoryDescriptionFileFieldAliasPlugin =
    webpackRequire('enhanced-resolve/lib/DirectoryDescriptionFileFieldAliasPlugin')

  var resolver = new Resolver(new SyncNodeJsInputFileSystem())

  resolver.apply(
    resolveConfig.packageAlias
      ? new DirectoryDescriptionFileFieldAliasPlugin('package.json', resolveConfig.packageAlias)
      : function() {},
    new ModuleAliasPlugin(resolveConfig.alias || {}),
    makeRootPlugin(ModulesInRootPlugin, 'module', resolveConfig.root),
    new ModulesInDirectoriesPlugin(
      'module',
      resolveConfig.modulesDirectories || resolveConfig.modules || ['web_modules', 'node_modules']
    ),
    makeRootPlugin(ModulesInRootPlugin, 'module', resolveConfig.fallback),
    new ModuleAsFilePlugin('module'),
    new ModuleAsDirectoryPlugin('module'),
    new DirectoryDescriptionFilePlugin(
      'package.json',
      ['module', 'jsnext:main'].concat(resolveConfig.packageMains || webpack1DefaultMains)
    ),
    new DirectoryDefaultFilePlugin(['index']),
    new FileAppendPlugin(resolveConfig.extensions || ['', '.webpack.js', '.web.js', '.js']),
    new ResultSymlinkPlugin()
  )


  var resolvePlugins = []

  // support webpack.ResolverPlugin
  if (plugins) {
    plugins.forEach(function (plugin) {
      if (
        plugin.constructor &&
        plugin.constructor.name === 'ResolverPlugin' &&
        Array.isArray(plugin.plugins)
      ) {
        resolvePlugins.push.apply(resolvePlugins, plugin.plugins)
      }
    })
  }

  resolver.apply.apply(resolver, resolvePlugins)

  return function() {
    return resolver.resolveSync.apply(resolver, arguments)
  }
}

/* eslint-disable */
// from https://github.com/webpack/webpack/blob/v1.13.0/lib/WebpackOptionsApply.js#L365
function makeRootPlugin(ModulesInRootPlugin, name, root) {
  if(typeof root === "string")
    return new ModulesInRootPlugin(name, root);
  else if(Array.isArray(root)) {
    return function() {
      root.forEach(function(root) {
        this.apply(new ModulesInRootPlugin(name, root));
      }, this);
    };
  }
  return function() {};
}
/* eslint-enable */

function findExternal(source, externals, context) {
  if (!externals) return false

  // string match
  if (typeof externals === 'string') return (source === externals)

  // array: recurse
  if (externals instanceof Array) {
    return externals.some(function (e) { return findExternal(source, e, context) })
  }

  if (externals instanceof RegExp) {
    return externals.test(source)
  }

  if (typeof externals === 'function') {
    var functionExternalFound = false
    externals.call(null, context, source, function(err, value) {
      if (err) {
        functionExternalFound = false
      } else {
        functionExternalFound = findExternal(source, value, context)
      }
    })
    return functionExternalFound
  }

  // else, vanilla object
  for (var key in externals) {
    if (!has(externals, key)) continue
    if (source === key) return true
  }
  return false
}

/**
 * webpack 1 defaults: http://webpack.github.io/docs/configuration.html#resolve-packagemains
 * @type {Array}
 */
var webpack1DefaultMains = [
  'webpack', 'browser', 'web', 'browserify', ['jam', 'main'], 'main',
]

function findConfigPath(configPath, packageDir) {
  var extensions = Object.keys(interpret.extensions).sort(function(a, b) {
    return a === '.js' ? -1 : b === '.js' ? 1 : a.length - b.length
  })
    , extension


  if (configPath) {
    // extensions is not reused below, so safe to mutate it here.
    extensions.reverse()
    extensions.forEach(function (maybeExtension) {
      if (extension) {
        return
      }

      if (configPath.substr(-maybeExtension.length) === maybeExtension) {
        extension = maybeExtension
      }
    })

    // see if we've got an absolute path
    if (!path.isAbsolute(configPath)) {
      configPath = path.join(packageDir, configPath)
    }
  } else {
    extensions.forEach(function (maybeExtension) {
      if (extension) {
        return
      }

      var maybePath = path.resolve(
        path.join(packageDir, 'webpack.config' + maybeExtension)
      )
      if (fs.existsSync(maybePath)) {
        configPath = maybePath
        extension = maybeExtension
      }
    })
  }

  registerCompiler(interpret.extensions[extension])
  return configPath
}

function registerCompiler(moduleDescriptor) {
  if(moduleDescriptor) {
    if(typeof moduleDescriptor === 'string') {
      require(moduleDescriptor)
    } else if(!Array.isArray(moduleDescriptor)) {
      moduleDescriptor.register(require(moduleDescriptor.module))
    } else {
      for(var i = 0; i < moduleDescriptor.length; i++) {
        try {
          registerCompiler(moduleDescriptor[i])
          break
        } catch(e) {
          log('Failed to register compiler for moduleDescriptor[]:', i, moduleDescriptor)
        }
      }
    }
  }
}

1	var findRoot = require('find-root')	1✔
2	, path = require('path')	1✔
3	, get = require('lodash/get')	1✔
4	, isEqual = require('lodash/isEqual')	1✔
5	, find = require('array-find')	1✔
6	, interpret = require('interpret')	1✔
7	, fs = require('fs')	1✔
8	, coreLibs = require('node-libs-browser')	1✔
9	, resolve = require('resolve')	1✔
10	, semver = require('semver')	1✔
11	, has = require('has')	1✔
12
13	var log = require('debug')('eslint-plugin-import:resolver:webpack')	1✔
14
15	exports.interfaceVersion = 2	1✔
16
17	/**
18	* Find the full path to 'source', given 'file' as a full reference path.
19	*
20	* resolveImport('./foo', '/Users/ben/bar.js') => '/Users/ben/foo.js'
21	* @param {string} source - the module to resolve; i.e './some-module'
22	* @param {string} file - the importing file's full path; i.e. '/usr/local/bin/file.js'
23	* @param {object} settings - the webpack config file name, as well as cwd
24	* @example
25	* options: {
26	* // Path to the webpack config
27	* config: 'webpack.config.js',
28	* // Path to be used to determine where to resolve webpack from
29	* // (may differ from the cwd in some cases)
30	* cwd: process.cwd()
31	* }
32	* @return {string?} the resolved path to source, undefined if not resolved, or null
33	* if resolved to a non-FS resource (i.e. script tag at page load)
34	*/
35	exports.resolve = function (source, file, settings) {	1✔
36
37	// strip loaders
38	var finalBang = source.lastIndexOf('!')	57✔
39	if (finalBang >= 0) {	57✔
40	source = source.slice(finalBang + 1)	1✔
41	}
42
43	// strip resource query
44	var finalQuestionMark = source.lastIndexOf('?')	57✔
45	if (finalQuestionMark >= 0) {	57✔
46	source = source.slice(0, finalQuestionMark)	3✔
47	}
48
49	var webpackConfig
50
51	var _configPath = get(settings, 'config')	57✔
52	/**
53	* Attempt to set the current working directory.
54	* If none is passed, default to the `cwd` where the config is located.
55	*/
56	, cwd = get(settings, 'cwd')	57✔
57	, configIndex = get(settings, 'config-index')	57✔
58	, env = get(settings, 'env')	57✔
59	, argv = get(settings, 'argv', {})	57✔
60	, packageDir
61
62	var configPath = typeof _configPath === 'string' && _configPath.startsWith('.')	57!
63	? path.resolve(_configPath)
64	: _configPath
65
66	log('Config path from settings:', configPath)	57✔
67
68	// see if we've got a config path, a config object, an array of config objects or a config function
69	if (!configPath \|\| typeof configPath === 'string') {	57✔
70
71	// see if we've got an absolute path
72	if (!configPath \|\| !path.isAbsolute(configPath)) {	54!
73	// if not, find ancestral package.json and use its directory as base for the path
74	packageDir = findRoot(path.resolve(file))	54✔
75	if (!packageDir) throw new Error('package not found above ' + file)	54!
76	}
77
78	configPath = findConfigPath(configPath, packageDir)	54✔
79
80	log('Config path resolved to:', configPath)	54✔
81	if (configPath) {	54!
82	try {	54✔
83	webpackConfig = require(configPath)	54✔
84	} catch(e) {
85	console.log('Error resolving webpackConfig', e)	×
86	throw e	×
87	}
88	} else {
89	log('No config path found relative to', file, '; using {}')	×
90	webpackConfig = {}	×
91	}
92
93	if (webpackConfig && webpackConfig.default) {	54!
94	log('Using ES6 module "default" key instead of module.exports.')	×
95	webpackConfig = webpackConfig.default	×
96	}
97
98	} else {
99	webpackConfig = configPath	3✔
100	configPath = null	3✔
101	}
102
103	if (typeof webpackConfig === 'function') {	57!
104	webpackConfig = webpackConfig(env, argv)	×
105	}
106
107	if (Array.isArray(webpackConfig)) {	57!
108	webpackConfig = webpackConfig.map(cfg => {	×
109	if (typeof cfg === 'function') {	×
110	return cfg(env, argv)	×
111	}
112
113	return cfg	×
114	})
115
116	if (typeof configIndex !== 'undefined' && webpackConfig.length > configIndex) {	×
117	webpackConfig = webpackConfig[configIndex]	×
118	}
119	else {
120	webpackConfig = find(webpackConfig, function findFirstWithResolve(config) {	×
121	return !!config.resolve	×
122	})
123	}
124	}
125
126	if (webpackConfig == null) {	57!
127	webpackConfig = {}	×
128
129	console.warn('No webpack configuration with a "resolve" field found. Using empty object instead')	×
130	}
131
132	log('Using config: ', webpackConfig)	57✔
133
134	// externals
135	if (findExternal(source, webpackConfig.externals, path.dirname(file))) {	57!
136	return { found: true, path: null }	×
137	}
138
139	// otherwise, resolve "normally"
140	var resolveSync = getResolveSync(configPath, webpackConfig, cwd)	57✔
141
142	try {	57✔
143	return { found: true, path: resolveSync(path.dirname(file), source) }	57✔
144	} catch (err) {
145	if (source in coreLibs) {	21✔
146	return { found: true, path: coreLibs[source] }	2✔
147	}
148
149	log('Error during module resolution:', err)	19✔
150	return { found: false }	19✔
151	}
152	}
153
154	var MAX_CACHE = 10	1✔
155	var _cache = []	1✔
156	function getResolveSync(configPath, webpackConfig, cwd) {
157	var cacheKey = { configPath: configPath, webpackConfig: webpackConfig }	57✔
158	var cached = find(_cache, function (entry) { return isEqual(entry.key, cacheKey) })	63✔
159	if (!cached) {	57✔
160	cached = {	3✔
161	key: cacheKey,
162	value: createResolveSync(configPath, webpackConfig, cwd),
163	}
164	// put in front and pop last item
165	if (_cache.unshift(cached) > MAX_CACHE) {	3!
166	_cache.pop()	×
167	}
168	}
169	return cached.value	57✔
170	}
171
172	function createResolveSync(configPath, webpackConfig, cwd) {
173	var webpackRequire
174	, basedir = null	3✔
175
176	if (typeof configPath === 'string') {	3✔
177	// This can be changed via the settings passed in when defining the resolver
178	basedir = cwd \|\| configPath	2✔
179	log(`Attempting to load webpack path from ${basedir}`)	2✔
180	}
181
182	try {	3✔
183	// Attempt to resolve webpack from the given `basedir`
184	var webpackFilename = resolve.sync('webpack', { basedir, preserveSymlinks: false })	3✔
185	var webpackResolveOpts = { basedir: path.dirname(webpackFilename), preserveSymlinks: false }	×
186
187	webpackRequire = function (id) {	×
188	return require(resolve.sync(id, webpackResolveOpts))	×
189	}
190	} catch (e) {
191	// Something has gone wrong (or we're in a test). Use our own bundled
192	// enhanced-resolve.
193	log('Using bundled enhanced-resolve.')	3✔
194	webpackRequire = require	3✔
195	}
196
197	var enhancedResolvePackage = webpackRequire('enhanced-resolve/package.json')	3✔
198	var enhancedResolveVersion = enhancedResolvePackage.version	3✔
199	log('enhanced-resolve version:', enhancedResolveVersion)	3✔
200
201	var resolveConfig = webpackConfig.resolve \|\| {}	3✔
202
203	if (semver.major(enhancedResolveVersion) >= 2) {	3!
204	return createWebpack2ResolveSync(webpackRequire, resolveConfig)	×
205	}
206
207	return createWebpack1ResolveSync(webpackRequire, resolveConfig, webpackConfig.plugins)	3✔
208	}
209
210	function createWebpack2ResolveSync(webpackRequire, resolveConfig) {
211	var EnhancedResolve = webpackRequire('enhanced-resolve')	×
212
213	return EnhancedResolve.create.sync(Object.assign({}, webpack2DefaultResolveConfig, resolveConfig))	×
214	}
215
216	/**
217	* webpack 2 defaults:
218	* https://github.com/webpack/webpack/blob/v2.1.0-beta.20/lib/WebpackOptionsDefaulter.js#L72-L87
219	* @type {Object}
220	*/
221	var webpack2DefaultResolveConfig = {	1✔
222	unsafeCache: true, // Probably a no-op, since how can we cache anything at all here?
223	modules: ['node_modules'],
224	extensions: ['.js', '.json'],
225	aliasFields: ['browser'],
226	mainFields: ['browser', 'module', 'main'],
227	}
228
229	// adapted from tests &
230	// https://github.com/webpack/webpack/blob/v1.13.0/lib/WebpackOptionsApply.js#L322
231	function createWebpack1ResolveSync(webpackRequire, resolveConfig, plugins) {
232	var Resolver = webpackRequire('enhanced-resolve/lib/Resolver')	3✔
233	var SyncNodeJsInputFileSystem = webpackRequire('enhanced-resolve/lib/SyncNodeJsInputFileSystem')	3✔
234
235	var ModuleAliasPlugin = webpackRequire('enhanced-resolve/lib/ModuleAliasPlugin')	3✔
236	var ModulesInDirectoriesPlugin =
237	webpackRequire('enhanced-resolve/lib/ModulesInDirectoriesPlugin')	3✔
238	var ModulesInRootPlugin = webpackRequire('enhanced-resolve/lib/ModulesInRootPlugin')	3✔
239	var ModuleAsFilePlugin = webpackRequire('enhanced-resolve/lib/ModuleAsFilePlugin')	3✔
240	var ModuleAsDirectoryPlugin = webpackRequire('enhanced-resolve/lib/ModuleAsDirectoryPlugin')	3✔
241	var DirectoryDescriptionFilePlugin =
242	webpackRequire('enhanced-resolve/lib/DirectoryDescriptionFilePlugin')	3✔
243	var DirectoryDefaultFilePlugin =
244	webpackRequire('enhanced-resolve/lib/DirectoryDefaultFilePlugin')	3✔
245	var FileAppendPlugin = webpackRequire('enhanced-resolve/lib/FileAppendPlugin')	3✔
246	var ResultSymlinkPlugin = webpackRequire('enhanced-resolve/lib/ResultSymlinkPlugin')	3✔
247	var DirectoryDescriptionFileFieldAliasPlugin =
248	webpackRequire('enhanced-resolve/lib/DirectoryDescriptionFileFieldAliasPlugin')	3✔
249
250	var resolver = new Resolver(new SyncNodeJsInputFileSystem())	3✔
251
252	resolver.apply(	3✔
253	resolveConfig.packageAlias	3!
254	? new DirectoryDescriptionFileFieldAliasPlugin('package.json', resolveConfig.packageAlias)
255	: function() {},
256	new ModuleAliasPlugin(resolveConfig.alias \|\| {}),	6✔
257	makeRootPlugin(ModulesInRootPlugin, 'module', resolveConfig.root),
258	new ModulesInDirectoriesPlugin(
259	'module',
260	resolveConfig.modulesDirectories \|\| resolveConfig.modules \|\| ['web_modules', 'node_modules']	8✔
261	),
262	makeRootPlugin(ModulesInRootPlugin, 'module', resolveConfig.fallback),
263	new ModuleAsFilePlugin('module'),
264	new ModuleAsDirectoryPlugin('module'),
265	new DirectoryDescriptionFilePlugin(
266	'package.json',
267	['module', 'jsnext:main'].concat(resolveConfig.packageMains \|\| webpack1DefaultMains)	6✔
268	),
269	new DirectoryDefaultFilePlugin(['index']),
270	new FileAppendPlugin(resolveConfig.extensions \|\| ['', '.webpack.js', '.web.js', '.js']),	5✔
271	new ResultSymlinkPlugin()
272	)
273
274
275	var resolvePlugins = []	3✔
276
277	// support webpack.ResolverPlugin
278	if (plugins) {	3!
279	plugins.forEach(function (plugin) {	×
280	if (	×
281	plugin.constructor &&	×
282	plugin.constructor.name === 'ResolverPlugin' &&
283	Array.isArray(plugin.plugins)
284	) {
285	resolvePlugins.push.apply(resolvePlugins, plugin.plugins)	×
286	}
287	})
288	}
289
290	resolver.apply.apply(resolver, resolvePlugins)	3✔
291
292	return function() {	3✔
293	return resolver.resolveSync.apply(resolver, arguments)	57✔
294	}
295	}
296
297	/* eslint-disable */
298	// from https://github.com/webpack/webpack/blob/v1.13.0/lib/WebpackOptionsApply.js#L365
299	function makeRootPlugin(ModulesInRootPlugin, name, root) {
300	if(typeof root === "string")	6✔
301	return new ModulesInRootPlugin(name, root);	1✔
302	else if(Array.isArray(root)) {	5!
303	return function() {	×
304	root.forEach(function(root) {	×
305	this.apply(new ModulesInRootPlugin(name, root));	×
306	}, this);
307	};
308	}
309	return function() {};	5✔
310	}
311	/* eslint-enable */
312
313	function findExternal(source, externals, context) {
314	if (!externals) return false	57!
315
316	// string match
317	if (typeof externals === 'string') return (source === externals)	×
318
319	// array: recurse
320	if (externals instanceof Array) {	×
321	return externals.some(function (e) { return findExternal(source, e, context) })	×
322	}
323
324	if (externals instanceof RegExp) {	×
325	return externals.test(source)	×
326	}
327
328	if (typeof externals === 'function') {	×
329	var functionExternalFound = false	×
330	externals.call(null, context, source, function(err, value) {	×
331	if (err) {	×
332	functionExternalFound = false	×
333	} else {
334	functionExternalFound = findExternal(source, value, context)	×
335	}
336	})
337	return functionExternalFound	×
338	}
339
340	// else, vanilla object
341	for (var key in externals) {	×
342	if (!has(externals, key)) continue	×
343	if (source === key) return true	×
344	}
345	return false	×
346	}
347
348	/**
349	* webpack 1 defaults: http://webpack.github.io/docs/configuration.html#resolve-packagemains
350	* @type {Array}
351	*/
352	var webpack1DefaultMains = [	1✔
353	'webpack', 'browser', 'web', 'browserify', ['jam', 'main'], 'main',
354	]
355
356	function findConfigPath(configPath, packageDir) {
357	var extensions = Object.keys(interpret.extensions).sort(function(a, b) {	54✔
358	return a === '.js' ? -1 : b === '.js' ? 1 : a.length - b.length	6,102!
359	})
360	, extension
361
362
363	if (configPath) {	54✔
364	// extensions is not reused below, so safe to mutate it here.
365	extensions.reverse()	1✔
366	extensions.forEach(function (maybeExtension) {	1✔
367	if (extension) {	30!
368	return	×
369	}
370
371	if (configPath.substr(-maybeExtension.length) === maybeExtension) {	30✔
372	extension = maybeExtension	1✔
373	}
374	})
375
376	// see if we've got an absolute path
377	if (!path.isAbsolute(configPath)) {	1!
378	configPath = path.join(packageDir, configPath)	1✔
379	}
380	} else {
381	extensions.forEach(function (maybeExtension) {	53✔
382	if (extension) {	1,590✔
383	return	1,537✔
384	}
385
386	var maybePath = path.resolve(	53✔
387	path.join(packageDir, 'webpack.config' + maybeExtension)
388	)
389	if (fs.existsSync(maybePath)) {	53!
390	configPath = maybePath	53✔
391	extension = maybeExtension	53✔
392	}
393	})
394	}
395
396	registerCompiler(interpret.extensions[extension])	54✔
397	return configPath	54✔
398	}
399
400	function registerCompiler(moduleDescriptor) {
401	if(moduleDescriptor) {	54!
402	if(typeof moduleDescriptor === 'string') {	×
403	require(moduleDescriptor)	×
404	} else if(!Array.isArray(moduleDescriptor)) {	×
405	moduleDescriptor.register(require(moduleDescriptor.module))	×
406	} else {
407	for(var i = 0; i < moduleDescriptor.length; i++) {	×
408	try {	×
409	registerCompiler(moduleDescriptor[i])	×
410	break	×
411	} catch(e) {
412	log('Failed to register compiler for moduleDescriptor[]:', i, moduleDescriptor)	×
413	}
414	}
415	}
416	}
417	}

benmosher / eslint-plugin-import / 35166323

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous