Builds a listing of all functions sorted A-Z, with their names and descriptions
352913
def build_listing(self):
        
        def func_entry(name, func):
            args, varargs, defaults = self._get_arg_spec(func)

            # add regular arguments
            params = [{'name': str(a), 'optional': a in defaults, 'vararg': False} for a in args if a != 'ctx']

            # add possible variable argument
            if varargs:
                params += [{'name': str(varargs), 'optional': False, 'vararg': True}]

            return {'name': str(name.upper()),
                    'description': str(func.__doc__).strip(),
                    'params': params}

        listing = [func_entry(f_name, f) for f_name, f in self._functions.items()]
        return sorted(listing, key=lambda l: l['name'])
55917
def build_documentation_lines(self):
        
        return [
            line_string for key in sorted(self.keys)
            for line_string in self.build_paramter_string(key)
        ]
522243
def all(self, func):
        
        return all([func(k, v) for k, v in self.items()])
1170231
function listify(fp, methods, ctx) {
  var len = methods.length, i = 0;
  var res = [''];
  while (len--) {
    var method = methods[i++];
    var line = ctx[method];
    var item = line ? linkify('.' + method, fp, '#L' + line) : method;
    item = '  - ' + item;
    res.push(item);
  }
  return res.sort().join('\n');
}
229286
def sort_func(self, key):
        
        if key == self._KEYS.SCHEMA:
            return 'aaa'
        if key == self._KEYS.NAME:
            return 'aab'
        if key == self._KEYS.SOURCES:
            return 'aac'
        if key == self._KEYS.ALIAS:
            return 'aad'
        if key == self._KEYS.MODELS:
            return 'aae'
        if key == self._KEYS.PHOTOMETRY:
            return 'zzy'
        if key == self._KEYS.SPECTRA:
            return 'zzz'
        return key
217665
def get_functions_and_classes(package):
    
    classes, functions = [], []
    for name, member in inspect.getmembers(package):
        if not name.startswith('_'):
            if inspect.isclass(member):
                classes.append([name, member])
            elif inspect.isfunction(member):
                functions.append([name, member])
    return classes, functions
1041041
def list(cls,
             l,
             order=None,
             header=None,
             output="table",
             sort_keys=True,
             show_none=""
             ):
        
        d = {}
        count = 0
        for entry in l:
            name = str(count)
            d[name] = entry
            count += 1
        return cls.dict(d,
                        order=order,
                        header=header,
                        sort_keys=sort_keys,
                        output=output,
                        show_none=show_none)
1148446
function buildDocsList() {
  const packagesWithoutBuiltDocs = [
    'basic-component-mixins',
    'basic-web-components'
  ];
  const ary = allPackages.filter(item => {
    return packagesWithoutBuiltDocs.indexOf(item) < 0;
  }).map(item => {
    return {
      src: `packages/${item}/src/*.js`,
      dest: `packages/${item}/README.md`};
  });

  return ary.concat(buildMixinsDocsList());
}
1149288
def list_functions(region=None, key=None, keyid=None, profile=None):
    '''
    

    '''
    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)

    ret = []
    for funcs in __utils__['boto3.paged_call'](conn.list_functions):
        ret += funcs['Functions']
    return ret
1243515
function findHoistableFunctionDeclarations (ast) {
  var tagged = [];
  traverse.traverse(ast, {
    enter: function (node, parent) {
      if (node.type === 'FunctionDeclaration' && ~node.id.name.indexOf('$')) {
        tagged.push([node, parent]);
      }
    }
  });

  return tagged;
}
347988
def functions(self):
        
        it = ffi.lib.LLVMPY_ModuleFunctionsIter(self)
        return _FunctionsIterator(it, dict(module=self))
812594
def all_function_definitions(function):
    
    return [function] + [f for c in function.contract.inheritance
                         for f in c.functions_and_modifiers_not_inherited
                         if f.full_name == function.full_name]
1340644
def list_actions(cls):
        """"""
        # Make sure these are always at the beginning of the list
        actions = ['start', 'stop', 'restart', 'status']
        # Iterate over the instance attributes checking for actions that
        # have been exposed
        for func_name in dir(cls):
            func = getattr(cls, func_name)
            if (not hasattr(func, '__call__') or
                    not getattr(func, '__daemonocle_exposed__', False)):
                # Not a function or not exposed
                continue
            action = func_name.replace('_', '-')
            if action not in actions:
                actions.append(action)

        return actions
682982
def system_listMethods(self):
        """"""

        methods = set(self.funcs.keys())
        if self.instance is not None:
            # Instance can implement _listMethod to return a list of
            # methods
            if hasattr(self.instance, '_listMethods'):
                methods |= set(self.instance._listMethods())
            # if the instance has a _dispatch method then we
            # don't have enough information to provide a list
            # of methods
            elif not hasattr(self.instance, '_dispatch'):
                methods |= set(list_public_methods(self.instance))
        return sorted(methods)
1078180
function functionEntry (name) {
      const fn = functions[name]
      let syntax = SYNTAX[name] || (fn.doc && fn.doc.syntax && fn.doc.syntax[0]) || name
      syntax = syntax
        // .replace(/^math\./, '')
        .replace(/\s+\/\/.*$/, '')
        .replace(/;$/, '')
      if (syntax.length < 40) {
        syntax = syntax.replace(/ /g, '&nbsp;')
      }

      let description = ''
      if (fn.doc.description) {
        description = fn.doc.description.replace(/\n/g, ' ').split('.')[0] + '.'
      }

      return '[' + syntax + '](functions/' + name + '.md) | ' + description
    }
153159
private static DebuggableScript[] getAllFunctions
            (DebuggableScript function) {
        ObjArray functions = new ObjArray();
        collectFunctions_r(function, functions);
        DebuggableScript[] result = new DebuggableScript[functions.size()];
        functions.toArray(result);
        return result;
    }
1354473
def sort_func(self, key):
        """"""
        if key == self._KEYS.TIME:
            return 'aaa'
        if key == self._KEYS.DATA:
            return 'zzy'
        if key == self._KEYS.SOURCE:
            return 'zzz'
        return key