Render
When rendering 'action', the name of the action could be
camelCased or underscored.
3965
public function render($options = [])
    {
        if ($this->isPerformed()) {
            throw new Exception\DoubleRenderException(
                'Can only render or redirect once per action'
            );
        }
        list ($renderOptions, $options) = $this->splitOptions($options);
        $renderOptions = $this->normalizeRender($renderOptions);
        $this->response()->setBody($this->renderToString($renderOptions, $options));
    }
945178
def render(self, context):
        """"""

        content = mark_safe(self.get_content_from_context(context))
        if not content:
            return ''
        if self.parsed:
            try:
                t = template.Template(content, name=self.name)
                content = mark_safe(t.render(context))
            except TemplateSyntaxError as error:
                if global_settings.DEBUG:
                    content = PLACEHOLDER_ERROR % {
                        'name': self.name,
                        'error': error,
                    }
                else:
                    content = ''
        if self.as_varname is None:
            return content
        context[self.as_varname] = content
        return ''
1220529
function(actionName, event){
        var action = this.action[actionName];

        if (action)
          action.call(this, event);

        /** @cut */ if (!action)
        /** @cut */   basis.dev.warn('template call `' + actionName + '` action, but it isn\'t defined in action list');
      }
1142047
function render(engine, str, locals, engineOptions) {
  try {
    var output = engine.render(engine.engine, str, locals, engineOptions)
  } catch(e) {
    throw new Error(
      NAME + ': there was a problem rendering the template:\n' + e)
  }
  return output
}
676277
def render_app_name(context, app, template="/admin_app_name.html"):
    
    try:
        template = app['app_label'] + template
        text = render_to_string(template, context)
    except:
        text = app['name']
    return text
1170486
def _render(item: ConfigItem, indent: str = "") -> str:
    
    optional = item.default_value != _NO_DEFAULT

    if is_configurable(item.annotation):
        rendered_annotation = f"{item.annotation} (configurable)"
    else:
        rendered_annotation = str(item.annotation)

    rendered_item = "".join([
            # rendered_comment,
            indent,
            "// " if optional else "",
            f'"{item.name}": ',
            rendered_annotation,
            f" (default: {item.default_value} )" if optional else "",
            f" // {item.comment}" if item.comment else "",
            "\n"
    ])

    return rendered_item
518837
function tryRender(view, options, callback) {
  try {
    view.render(options, callback);
  } catch (err) {
    callback(err);
  }
}
471963
def render(view)
      tags = []

      render_charset(tags)
      render_title(tags)
      render_icon(tags)
      render_with_normalization(tags, :description)
      render_with_normalization(tags, :keywords)
      render_refresh(tags)
      render_noindex(tags)
      render_alternate(tags)
      render_open_search(tags)
      render_links(tags)

      render_hashes(tags)
      render_custom(tags)

      tags.tap(&:compact!).map! { |tag| tag.render(view) }
      view.safe_join tags, MetaTags.config.minify_output ? "" : "\n"
    end
293561
function splitActionName(actionName) {
    if(actionName.indexOf('_') > 0) return actionName.split('_')
    else return actionName.split(/(?=[A-Z])/).map(p => p.toLowerCase())
}
1265524
function (actionName) {
            actionName = actionName || "";

            var idx = actionName.indexOf("?");
            var object = {
                name : "",
                params : ""
            };

            if (idx < 0) {
                object.name = actionName;
            } else {
                object = {
                    name : actionName.substring(0, idx),
                    params : actionName.substring(idx + 1)
                };
            }

            return object;
        }
517440
public function renderActions($context = 'bottom')
    {
        $returnValue = (string) '';

		if(isset($this->actions[$context])){

			$decorator = null;
			if(!is_null($this->getDecorator('actions-'.$context))){
			 	$decorator = $this->getDecorator('actions-'.$context);
			}
			else if(!is_null($this->getDecorator('actions'))){
			 	$decorator = $this->getDecorator('actions');
			}

			if(!is_null($decorator)){
				$returnValue .= $decorator->preRender();
			}

			foreach($this->actions[$context] as $action){
				$returnValue .= $action->render();
			}

			if(!is_null($decorator)){
				$returnValue .= $decorator->postRender();
			}

		}



        return (string) $returnValue;
    }
1220732
function renderResult(a) {
  return a.cata({
    Success: function() {
      return success('✓ ' + a.name()) }
  , Failure: function(_, ex) {
      return failure('✗ ' + a.name()) + '\n'
           + faded(pad(2, '[' + ex.name + ']: ' + ex.message)) }
  , Ignored: function() {
      return ignored('⚪ ' + a.name()) }
  }) + logs(a)
}
693910
def render_with_overrides(*args, &block)
      options = args.extract_options!
      name = args.first
      if name.is_a?(Symbol) || name.is_a?(String)
        # TODO: block needs to be handled differently so as to provide overrides
        block_with_hooks_renderer.render(*args, options, &block)
      elsif options[:partial]
        partial_renderer.render(options.delete(:partial), options, &block)
      else
        # TODO: handle other possible rendering methods such as a custom renderer
      end
    end
990539
def _render(self, template_name, context, renderer=None):
        """"""
        if renderer is None:
            renderer = get_default_renderer()
        return mark_safe(renderer.render(template_name, context))
292097
def render_name(self, template_name, *context, **kwargs):
        
        loader = self._make_loader()
        template = loader.load_name(template_name)
        return self._render_string(template, *context, **kwargs)
348533
def render(self, namespace):
        '''
        '''
        return self._text.format_map(namespace.dictionary) \
            if self._need_format else self._text
40296
function renderParam(key, valueDict) {
    var paramDiv = $('<div class="status-param">');

    var nameDiv = $('<span class="status-param-name">');
    nameDiv.text(key + ':');
    paramDiv.append(nameDiv);

    if (valueDict.type == 'slot' && STATUS_MAP.slots) {
      paramDiv.append(renderSlot(valueDict.slotKey));
    } else {
      var valueDiv = $('<span class="status-param-value">');
      renderCollapsableValue(valueDict.value, valueDiv);
      paramDiv.append(valueDiv);
    }

    return paramDiv;
  }