Public: renders the page title.

 options - The Hash containing the values to use inside the template.

 Returns: the rendered page title.
490352
def render_title(options={})
      result = ::Liquid::Template.parse(title).render(optional_data(options))
    rescue => e
      log_error(e)
    ensure
      return result.to_s
    end
651197
def render_open_tag options
      out = '<' + tag_name
      unless attributes.empty?
        attributes.each do |name,value|
          name = name.to_s.gsub('_', '-') if name.is_a? Symbol
          value = value.to_s.gsub('_', '-') if value.is_a? Symbol

          case value
          when false
            next
          when true
            if options[:format] == Rxhp::XHTML_FORMAT
              out += ' ' + name + '="' + name + '"'
            else
              out += ' ' + name
            end
          else
            out += ' ' + name.to_s + '="' + html_escape(value.to_s) + '"'
          end
        end
      end

      if options[:format] == Rxhp::XHTML_FORMAT && !children?
        out + ' />'
      else
        out + '>'
      end
    end
92878
def show
      @page = @element.page
      @options = params[:options]

      respond_to do |format|
        format.html
        format.js { @container_id = params[:container_id] }
      end
    end
368646
def get_page_template(self, **kwargs):
        
        opts = self.object_list.model._meta
        return '{0}/{1}{2}{3}.html'.format(
            opts.app_label,
            opts.object_name.lower(),
            self.template_name_suffix,
            self.page_template_suffix,
        )
49588
function (str, options, cb) {
    var ECT = this.engine;
    var tmpl = this.cache(options) || this.cache(options, new ECT({ root: { page: str }}));
    tmpl.render('page', options, cb);
  }
928322
def state_options                            
      options = Caboose::States.all.collect { |abbr, state| { 'value' => abbr, 'text' => abbr }}
      render :json => options
    end
1001629
def render options = {}
      validate!
      options = fill_options(options)

      open = render_open_tag(options)
      inner = render_children(options)
      close = render_close_tag(options)

      if options[:pretty]
        indent = ' ' * (options[:indent] * options[:depth])
        out = indent.dup
        out << open << "\n"
        out << inner if inner
        out << indent << close << "\n" if close && !close.empty?
        out
      else
        out = open
        out << inner if inner
        out << close if close
        out
      end
    end
941385
public function renderTitle(array $options = [])
    {
        $options = $options + $this->options;

        $response = (count($this->breadcrumbs) <= 1)
            ? $options['site_full_name']
            : $options['site_short_name'];

        foreach ($this->breadcrumbs->all() as $key => $value) {
            if ($key == 0) {
                continue;
            }

            $response = $value['title'].' '.$options['delimiter'].' '.$response;
        }

        return $response;
    }
454182
def render(*args, &block)
      options = _normalize_render(*args, &block)
      rendered_body = render_to_body(options)
      if options[:html]
        _set_html_content_type
      else
        _set_rendered_content_type rendered_format
      end
      self.response_body = rendered_body
    end
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)
284076
def Title(self):
        
        titlefield = self.Schema().getField('title')
        if titlefield.widget.visible:
            return safe_unicode(self.title).encode('utf-8')
        else:
            return safe_unicode(self.id).encode('utf-8')
640640
public function render() {

		$title = $list = $template = '';

		if ( $this->items ) {

			// If there's title text, format it.
			if ( $this->args['title_text'] ) {

				$title = sprintf(
					'<%1$s class="%2$s">%3$s</%1$s>',
					tag_escape( $this->args['title_tag'] ),
					esc_attr( $this->args['title_class'] ),
					esc_html( $this->args['title_text'] )
				);
			}

			// Loop through each of the items and format each into
			// an HTML string.
			foreach ( $this->items as $item ) {

				$list .= $this->formatItem( $item );
			}

			// Format the list.
			$list = sprintf(
				'<%1$s class="%2$s">%3$s</%1$s>',
				tag_escape( $this->args['list_tag'] ),
				esc_attr( $this->args['list_class'] ),
				$list
			);

			// Format the nav wrapper.
			$template = sprintf(
				'<%1$s class="%2$s" role="navigation">%3$s%4$s</%1$s>',
				tag_escape( $this->args['container_tag'] ),
				esc_attr( sprintf( $this->args['container_class'], $this->context ) ),
				$title,
				$list
			);
		}

		return apply_filters( "hybrid/pagination/{$this->context}", $template, $this->args );
	}
1109155
def render(context_scope = nil, locals = nil, &block)
      apply(context_scope, locals, &block) if context_scope || locals || block

      cache_results do
        send("to_#{@_options[:format]}")
      end
    end
264408
function(templateName, options) {
        var template = this.templates[templateName];
        if (!template) {
            throw new Error('Unknown template: ' + templateName);
        }

        if (typeof template === 'function') {
            var templateResult = template(options);
            return typeof templateResult === 'string' ? templateResult.trim() : templateResult;
        } else if (template.render) {
            return template.render(options).trim();
        } else {
            return template.toString().trim();
        }
    }
1359377
def render_title(tags)
      normalized_meta_tags[:title] = meta_tags.page_title
      normalized_meta_tags[:site] = meta_tags[:site]
      title = meta_tags.extract_full_title
      normalized_meta_tags[:full_title] = title
      tags << ContentTag.new(:title, content: title) if title.present?
    end
816132
def admin_options
      options = [{
        'value' => '',
        'text' => '-- No Office --'
      }]
      Office.reorder('lo_name').all.each do |office|
        options << { 
          'value' => office.lo_code,
          'text'  => office.lo_name
        }
      end
      render :json => options 
    end
120452
def show(options = {})
      @model = thing
      @title = @model.to_s.titleize.pluralize
      if options[:query]
        query_out = {}
        iterator = CEO::Iterator.new(thing)
        options[:query].each do |q|
          query_out.merge! iterator.query_eval(@thing, q)
        end
      end

      filtered_keys = CEO::Iterator.filter(keys(@thing), options)
      @thing_attrs = @thing.attributes.select do |k, _|
        filtered_keys.include? k
      end

      @thing_attrs.transform_keys! { |k| CEO::Iterator.acronymize(k) }
      @thing_attrs.merge! query_out if query_out

      render 'admin/show'
    end