Get the current Node.js methods.
@private
336619
function getCurrentNodeMethods () {
  return http.METHODS && http.METHODS.map(function upperCaseMethod (method) {
    return method.toUpperCase()
  })
}
992596
function() {
    this.expect('function');
    this.state.push('function arguments');
    var args = this.args();
    this.expect(')');
    this.state.pop();
    return new nodes.Call('url', args);
  }
708798
def list_public_methods(obj: Any):
    
    return [member for member in dir(obj)
            if not member.startswith('_') and
            callable(getattr(obj, member))]
866284
def _gather_exposed_methods(self):
        

        self._extract_methods_from_container(self)

        for module in self.modules:
            self._extract_methods_from_container(module)
465423
function () {
        return {
            position: this.position,
            iteration: this.iteration,
            length: this.length,
            cycles: this.cycles,
            empty: this.empty(),
            eof: this.eof(),
            bof: this.bof(),
            cr: this.cr(),
            ref: this.ref
        };
    }
222791
function retrieveMethod(a, n) {
    return a[n] || a.constructor[n] || (a.prototype && a.prototype[n]);
}
223628
function findTextMethods(virtualNode) {
	const { nativeElementType, nativeTextMethods } = text;
	const nativeType = nativeElementType.find(({ matches }) => {
		return axe.commons.matches(virtualNode, matches);
	});

	// Use concat because namingMethods can be a string or an array of strings
	const methods = nativeType ? [].concat(nativeType.namingMethods) : [];

	return methods.map(methodName => nativeTextMethods[methodName]);
}
718318
public function getMethodNames() {
    return array_map(function (ClassMethodNode $node) {
      return $node->getName()->getText();
    }, $this->getMethods()->toArray());
  }
1069213
function getNodeParameters() {
        return typeof process !== "undefined" && process.argv && process.argv.length > 1 ? process.argv.slice(1) : null;
    }
129947
def all_methods(cls):
        
        def name(fn):
            return fn.__get__(cls).__name__.replace("_", "-")
        return sorted(name(f) for f in cls.__dict__.values()
                      if isinstance(f, staticmethod))
1326292
function(methodNames) {
        var methods = [], i, length, method

        for (i = 0, length = methodNames.length; i < length; i++) {
          // first, check if this is an anonymous function
          if (_.isFunction(methodNames[i]))
            method = methodNames[i]
          else {
            // else, get the function from the View
            method = this[methodNames[i]]
            if (!method)
              throw new Error('Method "' + methodNames[i] + '" does not exist')
          }
          methods.push(method)
        }
        return methods
      }
473722
def get_used_in_func(node):
    '''
    '''
    if isinstance(node, ast.FunctionDef):
        return {node.name: get_accessed(node.body)}
    names = {}
    for node in ast.iter_child_nodes(node):
        names.update(get_used_in_func(node))
    return names
58508
function getCallbackInfo(node) {
    const retv = { isCallback: false, isLexicalThis: false };
    let currentNode = node;
    let parent = node.parent;

    while (currentNode) {
        switch (parent.type) {

            // Checks parents recursively.

            case "LogicalExpression":
            case "ConditionalExpression":
                break;

            // Checks whether the parent node is `.bind(this)` call.
            case "MemberExpression":
                if (parent.object === currentNode &&
                    !parent.property.computed &&
                    parent.property.type === "Identifier" &&
                    parent.property.name === "bind" &&
                    parent.parent.type === "CallExpression" &&
                    parent.parent.callee === parent
                ) {
                    retv.isLexicalThis = (
                        parent.parent.arguments.length === 1 &&
                        parent.parent.arguments[0].type === "ThisExpression"
                    );
                    parent = parent.parent;
                } else {
                    return retv;
                }
                break;

            // Checks whether the node is a callback.
            case "CallExpression":
            case "NewExpression":
                if (parent.callee !== currentNode) {
                    retv.isCallback = true;
                }
                return retv;

            default:
                return retv;
        }

        currentNode = parent;
        parent = parent.parent;
    }

    /* istanbul ignore next */
    throw new Error("unreachable");
}
1327827
function(method) {
            return _.find(this.methods, function(handler) {
                return handler.regexp.test(method);
            }) || this.defaultHandler;
        }
1348685
function getHttpMethod() {
    let http = require('http');
    let lowerCaseMethods = http.METHODS.map(function (method) {
        return method.toLowerCase();
    });
    return lowerCaseMethods;
}
796560
function getOutsideHandler(method) {
  var lastEventId = null;

  /**
   * If the event that is firing is not the same as the event that was fired on the element
   * execute the method
   * @param  {object} evt the event that's firing
   */
  var documentHandler = function(evt) {
    if (evt.eventId !== lastEventId) {
      method(evt);
    }
  };

  /**
   * Store the id of the event for comparison when documentHandler fires
   * @param  {object} evt the event firing on the element
   */
  var elementHandler = function(evt) {
    lastEventId = evt.eventId;
  };

  return {
    documentHandler: documentHandler,
    elementHandler: elementHandler
  };
}
582352
function () {
            // Existing active nodes
            var allNodes = this.graphRoot.selectAll('g').filter('.active_node')
                .data(this.nodeModels, function (n) {
                return n.id;
            });
            return allNodes;
        }