RubyGems - embeditor-rails - Versions diffs - 2.0.0.beta → 2.0.0 - Mend

embeditor-rails 2.0.0.beta → 2.0.0

Files changed (1024) hide show

data/lib/node_modules/npm/node_modules/node-gyp/lib/build.js DELETED

@@ -1,275 +0,0 @@
-module.exports = exports = build
-/**
- * Module dependencies.
- */
-var fs = require('graceful-fs')
-  , rm = require('rimraf')
-  , path = require('path')
-  , glob = require('glob')
-  , log = require('npmlog')
-  , which = require('which')
-  , mkdirp = require('mkdirp')
-  , exec = require('child_process').exec
-  , win = process.platform == 'win32'
-exports.usage = 'Invokes `' + (win ? 'msbuild' : 'make') + '` and builds the module'
-function build (gyp, argv, callback) {
-  var makeCommand = gyp.opts.make || process.env.MAKE
-      || (process.platform.indexOf('bsd') != -1 && process.platform.indexOf('kfreebsd') == -1 ? 'gmake' : 'make')
-    , command = win ? 'msbuild' : makeCommand
-    , buildDir = path.resolve('build')
-    , configPath = path.resolve(buildDir, 'config.gypi')
-    , jobs = gyp.opts.jobs || process.env.JOBS
-    , buildType
-    , config
-    , arch
-    , nodeDir
-    , copyDevLib
-  loadConfigGypi()
-  /**
-   * Load the "config.gypi" file that was generated during "configure".
-   */
-  function loadConfigGypi () {
-    fs.readFile(configPath, 'utf8', function (err, data) {
-      if (err) {
-        if (err.code == 'ENOENT') {
-          callback(new Error('You must run `node-gyp configure` first!'))
-        } else {
-          callback(err)
-        }
-        return
-      }
-      config = JSON.parse(data.replace(/\#.+\n/, ''))
-      // get the 'arch', 'buildType', and 'nodeDir' vars from the config
-      buildType = config.target_defaults.default_configuration
-      arch = config.variables.target_arch
-      nodeDir = config.variables.nodedir
-      copyDevLib = config.variables.copy_dev_lib == 'true'
-      if ('debug' in gyp.opts) {
-        buildType = gyp.opts.debug ? 'Debug' : 'Release'
-      }
-      if (!buildType) {
-        buildType = 'Release'
-      }
-      log.verbose('build type', buildType)
-      log.verbose('architecture', arch)
-      log.verbose('node dev dir', nodeDir)
-      if (win) {
-        findSolutionFile()
-      } else {
-        doWhich()
-      }
-    })
-  }
-  /**
-   * On Windows, find the first build/*.sln file.
-   */
-  function findSolutionFile () {
-    glob('build/*.sln', function (err, files) {
-      if (err) return callback(err)
-      if (files.length === 0) {
-        return callback(new Error('Could not find *.sln file. Did you run "configure"?'))
-      }
-      guessedSolution = files[0]
-      log.verbose('found first Solution file', guessedSolution)
-      doWhich()
-    })
-  }
-  /**
-   * Uses node-which to locate the msbuild / make executable.
-   */
-  function doWhich () {
-    // First make sure we have the build command in the PATH
-    which(command, function (err, execPath) {
-      if (err) {
-        if (win && /not found/.test(err.message)) {
-          // On windows and no 'msbuild' found. Let's guess where it is
-          findMsbuild()
-        } else {
-          // Some other error or 'make' not found on Unix, report that to the user
-          callback(err)
-        }
-        return
-      }
-      log.verbose('`which` succeeded for `' + command + '`', execPath)
-      copyNodeLib()
-    })
-  }
-  /**
-   * Search for the location of "msbuild.exe" file on Windows.
-   */
-  function findMsbuild () {
-    log.verbose('could not find "msbuild.exe" in PATH - finding location in registry')
-    var notfoundErr = new Error('Can\'t find "msbuild.exe". Do you have Microsoft Visual Studio C++ 2008+ installed?')
-    var cmd = 'reg query "HKLM\\Software\\Microsoft\\MSBuild\\ToolsVersions" /s'
-    if (process.arch !== 'ia32')
-      cmd += ' /reg:32'
-    exec(cmd, function (err, stdout, stderr) {
-      var reVers = /ToolsVersions\\([^\\]+)$/i
-        , rePath = /\r\n[ \t]+MSBuildToolsPath[ \t]+REG_SZ[ \t]+([^\r]+)/i
-        , msbuilds = []
-        , r
-        , msbuildPath
-      if (err) {
-        return callback(notfoundErr)
-      }
-      stdout.split('\r\n\r\n').forEach(function(l) {
-        if (!l) return
-        l = l.trim()
-        if (r = reVers.exec(l.substring(0, l.indexOf('\r\n')))) {
-          var ver = parseFloat(r[1], 10)
-          if (ver >= 3.5) {
-            if (r = rePath.exec(l)) {
-              msbuilds.push({
-                version: ver,
-                path: r[1]
-              })
-            }
-          }
-        }
-      })
-      msbuilds.sort(function (x, y) {
-        return (x.version < y.version ? -1 : 1)
-      })
-      ;(function verifyMsbuild () {
-        if (!msbuilds.length) return callback(notfoundErr);
-        msbuildPath = path.resolve(msbuilds.pop().path, 'msbuild.exe')
-        fs.stat(msbuildPath, function (err, stat) {
-          if (err) {
-            if (err.code == 'ENOENT') {
-              if (msbuilds.length) {
-                return verifyMsbuild()
-              } else {
-                callback(notfoundErr)
-              }
-            } else {
-              callback(err)
-            }
-            return
-          }
-          command = msbuildPath
-          copyNodeLib()
-        })
-      })()
-    })
-  }
-  /**
-   * Copies the node.lib file for the current target architecture into the
-   * current proper dev dir location.
-   */
-  function copyNodeLib () {
-    if (!win || !copyDevLib) return doBuild()
-    var buildDir = path.resolve(nodeDir, buildType)
-      , archNodeLibPath = path.resolve(nodeDir, arch, 'node.lib')
-      , buildNodeLibPath = path.resolve(buildDir, 'node.lib')
-    mkdirp(buildDir, function (err, isNew) {
-      if (err) return callback(err)
-      log.verbose('"' + buildType + '" dir needed to be created?', isNew)
-      var rs = fs.createReadStream(archNodeLibPath)
-        , ws = fs.createWriteStream(buildNodeLibPath)
-      log.verbose('copying "node.lib" for ' + arch, buildNodeLibPath)
-      rs.pipe(ws)
-      rs.on('error', callback)
-      ws.on('error', callback)
-      rs.on('end', doBuild)
-    })
-  }
-  /**
-   * Actually spawn the process and compile the module.
-   */
-  function doBuild () {
-    // Enable Verbose build
-    var verbose = log.levels[log.level] <= log.levels.verbose
-    if (!win && verbose) {
-      argv.push('V=1')
-    }
-    if (win && !verbose) {
-      argv.push('/clp:Verbosity=minimal')
-    }
-    if (win) {
-      // Turn off the Microsoft logo on Windows
-      argv.push('/nologo')
-    }
-    // Specify the build type, Release by default
-    if (win) {
-      var p = arch === 'x64' ? 'x64' : 'Win32'
-      argv.push('/p:Configuration=' + buildType + ';Platform=' + p)
-      if (jobs) {
-        if (!isNaN(parseInt(jobs, 10))) {
-          argv.push('/m:' + parseInt(jobs, 10))
-        } else if (jobs.toUpperCase() === 'MAX') {
-          argv.push('/m:' + require('os').cpus().length)
-        }
-      }
-    } else {
-      argv.push('BUILDTYPE=' + buildType)
-      // Invoke the Makefile in the 'build' dir.
-      argv.push('-C')
-      argv.push('build')
-      if (jobs) {
-        if (!isNaN(parseInt(jobs, 10))) {
-          argv.push('--jobs')
-          argv.push(parseInt(jobs, 10))
-        } else if (jobs.toUpperCase() === 'MAX') {
-          argv.push('--jobs')
-          argv.push(require('os').cpus().length)
-        }
-      }
-    }
-    if (win) {
-      // did the user specify their own .sln file?
-      var hasSln = argv.some(function (arg) {
-        return path.extname(arg) == '.sln'
-      })
-      if (!hasSln) {
-        argv.unshift(gyp.opts.solution || guessedSolution)
-      }
-    }
-    var proc = gyp.spawn(command, argv)
-    proc.on('exit', onExit)
-  }
-  /**
-   * Invoked after the make/msbuild command exits.
-   */
-  function onExit (code, signal) {
-    if (code !== 0) {
-      return callback(new Error('`' + command + '` failed with exit code: ' + code))
-    }
-    if (signal) {
-      return callback(new Error('`' + command + '` got signal: ' + signal))
-    }
-    callback()
-  }
-}

data/lib/node_modules/npm/node_modules/node-gyp/lib/clean.js DELETED

@@ -1,22 +0,0 @@
-module.exports = exports = clean
-exports.usage = 'Removes any generated build files and the "out" dir'
-/**
- * Module dependencies.
- */
-var rm = require('rimraf')
-var log = require('npmlog')
-function clean (gyp, argv, callback) {
-  // Remove the 'build' dir
-  var buildDir = 'build'
-  log.verbose('clean', 'removing "%s" directory', buildDir)
-  rm(buildDir, callback)
-}

data/lib/node_modules/npm/node_modules/node-gyp/lib/configure.js DELETED

@@ -1,344 +0,0 @@
-module.exports = exports = configure
-/**
- * Module dependencies.
- */
-var fs = require('graceful-fs')
-  , path = require('path')
-  , glob = require('glob')
-  , log = require('npmlog')
-  , osenv = require('osenv')
-  , which = require('which')
-  , semver = require('semver')
-  , mkdirp = require('mkdirp')
-  , cp = require('child_process')
-  , spawn = cp.spawn
-  , execFile = cp.execFile
-  , win = process.platform == 'win32'
-exports.usage = 'Generates ' + (win ? 'MSVC project files' : 'a Makefile') + ' for the current module'
-function configure (gyp, argv, callback) {
-  var python = gyp.opts.python || process.env.PYTHON || 'python'
-    , buildDir = path.resolve('build')
-    , configNames = [ 'config.gypi', 'common.gypi' ]
-    , configs = []
-    , nodeDir
-  checkPython()
-  // Check if Python is in the $PATH
-  function checkPython () {
-    log.verbose('check python', 'checking for Python executable "%s" in the PATH', python)
-    which(python, function (err, execPath) {
-      if (err) {
-        log.verbose('`which` failed', python, err)
-        if (win) {
-          guessPython()
-        } else {
-          failNoPython()
-        }
-      } else {
-        log.verbose('`which` succeeded', python, execPath)
-        checkPythonVersion()
-      }
-    })
-  }
-  // Called on Windows when "python" isn't available in the current $PATH.
-  // We're gonna check if "%SystemDrive%\python27\python.exe" exists.
-  function guessPython () {
-    log.verbose('could not find "' + python + '". guessing location')
-    var rootDir = process.env.SystemDrive || 'C:\\'
-    if (rootDir[rootDir.length - 1] !== '\\') {
-      rootDir += '\\'
-    }
-    var pythonPath = path.resolve(rootDir, 'Python27', 'python.exe')
-    log.verbose('ensuring that file exists:', pythonPath)
-    fs.stat(pythonPath, function (err, stat) {
-      if (err) {
-        if (err.code == 'ENOENT') {
-          failNoPython()
-        } else {
-          callback(err)
-        }
-        return
-      }
-      python = pythonPath
-      checkPythonVersion()
-    })
-  }
-  function checkPythonVersion () {
-    var env = { TERM: 'dumb', PATH: process.env.PATH };
-    execFile(python, ['-c', 'import platform; print(platform.python_version());'], { env: env }, function (err, stdout) {
-      if (err) {
-        return callback(err)
-      }
-      log.verbose('check python version', '`%s -c "import platform; print(platform.python_version());"` returned: %j', python, stdout)
-      var version = stdout.trim()
-      if (~version.indexOf('+')) {
-        log.silly('stripping "+" sign(s) from version')
-        version = version.replace(/\+/g, '')
-      }
-      if (~version.indexOf('rc')) {
-        log.silly('stripping "rc" identifier from version')
-        version = version.replace(/rc(.*)$/ig, '')
-      }
-      var range = semver.Range('>=2.5.0 <3.0.0');
-      if (range.test(version)) {
-        getNodeDir()
-      } else {
-        failPythonVersion(version)
-      }
-    })
-  }
-  function failNoPython () {
-    callback(new Error('Can\'t find Python executable "' + python +
-          '", you can set the PYTHON env variable.'))
-  }
-  function failPythonVersion (badVersion) {
-    callback(new Error('Python executable "' + python +
-          '" is v' + badVersion + ', which is not supported by gyp.\n' +
-          'You can pass the --python switch to point to Python >= v2.5.0 & < 3.0.0.'))
-  }
-  function getNodeDir () {
-    // 'python' should be set by now
-    process.env.PYTHON = python
-    if (gyp.opts.nodedir) {
-      // --nodedir was specified. use that for the dev files
-      nodeDir = gyp.opts.nodedir.replace(/^~/, osenv.home())
-      log.verbose('get node dir', 'compiling against specified --nodedir dev files: %s', nodeDir)
-      createBuildDir()
-    } else {
-      // if no --nodedir specified, ensure node dependencies are installed
-      var version
-      var versionStr
-      if (gyp.opts.target) {
-        // if --target was given, then determine a target version to compile for
-        versionStr = gyp.opts.target
-        log.verbose('get node dir', 'compiling against --target node version: %s', versionStr)
-      } else {
-        // if no --target was specified then use the current host node version
-        versionStr = process.version
-        log.verbose('get node dir', 'no --target version specified, falling back to host node version: %s', versionStr)
-      }
-      // make sure we have a valid version
-      try {
-        version = semver.parse(versionStr)
-      } catch (e) {
-        return callback(e)
-      }
-      if (!version) {
-        return callback(new Error('Invalid version number: ' + versionStr))
-      }
-      // ensure that the target node version's dev files are installed
-      gyp.opts.ensure = true
-      gyp.commands.install([ versionStr ], function (err, version) {
-        if (err) return callback(err)
-        log.verbose('get node dir', 'target node version installed:', version)
-        nodeDir = path.resolve(gyp.devDir, version)
-        createBuildDir()
-      })
-    }
-  }
-  function createBuildDir () {
-    log.verbose('build dir', 'attempting to create "build" dir: %s', buildDir)
-    mkdirp(buildDir, function (err, isNew) {
-      if (err) return callback(err)
-      log.verbose('build dir', '"build" dir needed to be created?', isNew)
-      createConfigFile()
-    })
-  }
-  function createConfigFile (err) {
-    if (err) return callback(err)
-    var configFilename = 'config.gypi'
-    var configPath = path.resolve(buildDir, configFilename)
-    log.verbose('build/' + configFilename, 'creating config file')
-    var config = process.config || {}
-      , defaults = config.target_defaults
-      , variables = config.variables
-    // default "config.variables"
-    if (!variables) variables = config.variables = {}
-    // default "config.defaults"
-    if (!defaults) defaults = config.target_defaults = {}
-    // don't inherit the "defaults" from node's `process.config` object.
-    // doing so could cause problems in cases where the `node` executable was
-    // compiled on a different machine (with different lib/include paths) than
-    // the machine where the addon is being built to
-    defaults.cflags = []
-    defaults.defines = []
-    defaults.include_dirs = []
-    defaults.libraries = []
-    // set the default_configuration prop
-    if ('debug' in gyp.opts) {
-      defaults.default_configuration = gyp.opts.debug ? 'Debug' : 'Release'
-    }
-    if (!defaults.default_configuration) {
-      defaults.default_configuration = 'Release'
-    }
-    // set the target_arch variable
-    variables.target_arch = gyp.opts.arch || process.arch || 'ia32'
-    // set the node development directory
-    variables.nodedir = nodeDir
-    // don't copy dev libraries with nodedir option
-    variables.copy_dev_lib = !gyp.opts.nodedir
-    // disable -T "thin" static archives by default
-    variables.standalone_static_library = gyp.opts.thin ? 0 : 1;
-    // loop through the rest of the opts and add the unknown ones as variables.
-    // this allows for module-specific configure flags like:
-    //
-    //   $ node-gyp configure --shared-libxml2
-    Object.keys(gyp.opts).forEach(function (opt) {
-      if (opt === 'argv') return
-      if (opt in gyp.configDefs) return
-      variables[opt.replace(/-/g, '_')] = gyp.opts[opt]
-    })
-    // ensures that any boolean values from `process.config` get stringified
-    function boolsToString (k, v) {
-      if (typeof v === 'boolean')
-        return String(v)
-      return v
-    }
-    log.silly('build/' + configFilename, config)
-    // now write out the config.gypi file to the build/ dir
-    var prefix = '# Do not edit. File was generated by node-gyp\'s "configure" step'
-      , json = JSON.stringify(config, boolsToString, 2)
-    log.verbose('build/' + configFilename, 'writing out config file: %s', configPath)
-    configs.push(configPath)
-    fs.writeFile(configPath, [prefix, json, ''].join('\n'), findConfigs)
-  }
-  function findConfigs (err) {
-    if (err) return callback(err)
-    var name = configNames.shift()
-    if (!name) return runGyp()
-    var fullPath = path.resolve(name)
-    log.verbose(name, 'checking for gypi file: %s', fullPath)
-    fs.stat(fullPath, function (err, stat) {
-      if (err) {
-        if (err.code == 'ENOENT') {
-          findConfigs() // check next gypi filename
-        } else {
-          callback(err)
-        }
-      } else {
-        log.verbose(name, 'found gypi file')
-        configs.push(fullPath)
-        findConfigs()
-      }
-    })
-  }
-  function runGyp (err) {
-    if (err) return callback(err)
-    if (!~argv.indexOf('-f') && !~argv.indexOf('--format')) {
-      if (win) {
-        log.verbose('gyp', 'gyp format was not specified; forcing "msvs"')
-        // force the 'make' target for non-Windows
-        argv.push('-f', 'msvs')
-      } else {
-        log.verbose('gyp', 'gyp format was not specified; forcing "make"')
-        // force the 'make' target for non-Windows
-        argv.push('-f', 'make')
-      }
-    }
-    function hasMsvsVersion () {
-      return argv.some(function (arg) {
-        return arg.indexOf('msvs_version') === 0
-      })
-    }
-    if (win && !hasMsvsVersion()) {
-      if ('msvs_version' in gyp.opts) {
-        argv.push('-G', 'msvs_version=' + gyp.opts.msvs_version)
-      } else {
-        argv.push('-G', 'msvs_version=auto')
-      }
-    }
-    // include all the ".gypi" files that were found
-    configs.forEach(function (config) {
-      argv.push('-I', config)
-    })
-    // this logic ported from the old `gyp_addon` python file
-    var gyp_script = path.resolve(__dirname, '..', 'gyp', 'gyp_main.py')
-    var addon_gypi = path.resolve(__dirname, '..', 'addon.gypi')
-    var common_gypi = path.resolve(nodeDir, 'common.gypi')
-    var output_dir = 'build'
-    if (win) {
-      // Windows expects an absolute path
-      output_dir = buildDir
-    }
-    argv.push('-I', addon_gypi)
-    argv.push('-I', common_gypi)
-    argv.push('-Dlibrary=shared_library')
-    argv.push('-Dvisibility=default')
-    argv.push('-Dnode_root_dir=' + nodeDir)
-    argv.push('-Dmodule_root_dir=' + process.cwd())
-    argv.push('--depth=.')
-    // tell gyp to write the Makefile/Solution files into output_dir
-    argv.push('--generator-output', output_dir)
-    // tell make to write its output into the same dir
-    argv.push('-Goutput_dir=.')
-    // enforce use of the "binding.gyp" file
-    argv.unshift('binding.gyp')
-    // execute `gyp` from the current target nodedir
-    argv.unshift(gyp_script)
-    var cp = gyp.spawn(python, argv)
-    cp.on('exit', onCpExit)
-  }
-  /**
-   * Called when the `gyp` child process exits.
-   */
-  function onCpExit (code, signal) {
-    if (code !== 0) {
-      callback(new Error('`gyp` failed with exit code: ' + code))
-    } else {
-      // we're done
-      callback()
-    }
-  }
-}