autorequire.coffee | |
---|---|
fs = require 'fs'
path = require 'path'
utils = require './utils'
Loader = require './loader'
ModuleGroupFactory = require './module_group_factory' | |
autorequire()Set up an autorequired module at the specified path. The path must be a relative file system path. | autorequire = (requirePath, conventionAndOrOverrides...) ->
raise TypeError, 'autorequire only supports ./relative paths for now.' unless requirePath[0] == '.'
workingDir = utils.getCallingDirectoryFromStack()
rootPath = path.normalize workingDir + '/' + requirePath |
You can optionally specify a convention, as well as overrides to individual methods in that convention: | overrides = conventionAndOrOverrides.pop() if typeof conventionAndOrOverrides[conventionAndOrOverrides.length - 1] == 'object' |
| convention = conventionAndOrOverrides.shift() or 'Default' |
| if typeof convention == 'string'
throw new TypeError "There is no built-in '#{convention}' convention" unless conventions[convention]
conventionPrototype = conventions[convention] |
| if typeof convention == 'function'
conventionPrototype = convention |
If you pass an options hash, a custom convention will be built by inheriting the convention you specified (or the Default convention), setting each propery in the hash to the new convention's prototype. For a full reference of the methods available to a convention, take a look at
| if overrides
class CustomConvention extends conventionPrototype
for own key, value of overrides
CustomConvention::[key] = value
conventionPrototype = CustomConvention
unless conventionPrototype?
throw new TypeError 'autorequire was unable to determine a valid convention, please check your arguments.'
convention = new conventionPrototype
convention.buildRootModuleGroup rootPath |
Public API Properties | |
Set up all our conventions to be lazy-loaded so that they can be inherited from with minimal performance hit. | conventions = {}
for file in fs.readdirSync path.join(__dirname, 'conventions') when file != '.'
convention = path.basename(file, path.extname(file))
do (convention) ->
conventionName = convention.split(/[-_]+/).map((val) -> val[0].toLocaleUpperCase() + val[1..]).join ''
conventionName = conventionName[0].toLocaleUpperCase() + conventionName[1..]
utils.lazyLoad conventions, conventionName, ->
require "./conventions/#{convention}" |
Exported properties; they adhere to the | module.exports = autorequire
autorequire.conventions = conventions
autorequire.Loader = Loader
autorequire.ModuleGroupFactory = ModuleGroupFactory
|