you can override the object used for the title by supplying options[:object]
331686
def page_title(options = {})
      object = options.fetch(:object, @meta)
      options.delete(:object)
      options = Refinery::Pages.page_title.merge(options)

      title = []
      objects = (options[:chain_page_title] and object.respond_to?(:ancestors)) ? [object.ancestors, object] : [object]

      objects.flatten.compact.each do |obj|
        obj_title = obj.title if obj.title

        # Only link when the object responds to a url method.
        if options[:link] && obj.respond_to?(:url)
          title << link_to(obj_title, obj.url)
        else
          title << obj_title
        end
      end

      final_title = title.pop
      if (options[:page_title][:wrap_if_not_chained] and title.empty?) and options[:page_title][:tag].present?
        css = " class='#{options[:page_title][:class]}'" if options[:page_title][:class].present?
        final_title = "<#{options[:page_title][:tag]}#{css}>#{final_title}</#{options[:page_title][:tag]}>"
      end

      if title.empty?
        final_title.to_s.html_safe
      else
        tag = "<#{options[:ancestors][:tag]} class='#{options[:ancestors][:class]}'>"
        tag << title.join(options[:ancestors][:separator])
        tag << options[:ancestors][:separator]
        tag << "</#{options[:ancestors][:tag]}>#{final_title}"
        tag.html_safe
      end
    end
204451
def get_content_title(self, obj):
        """"""
        return Content.objects.get(id=obj.content.id).title
232777
def add_option(flag, text, scope=nil)
      scope or scope = 'Options'
      @options[scope] ||= {}
      @options[scope][flag] = text
    end
498688
function() {
    this._super();

    if (!this._options.implicit) {
      this.overrideProperty('<plural>', 'collection');
      this.overrideProperty('<singular>Objects', 'objectsQuery');
      this.addHelper('create<Singular>', 'createObject');
      this.addHelper('add<Singular>', 'addObjects');
      this.addHelper('add<Plural>', 'addObjects');
      this.addHelper('remove<Singular>', 'removeObjects');
      this.addHelper('remove<Plural>', 'removeObjects');
      this.addHelper('clear<Plural>', 'clearObjects');
      this.overrideMethod('init', 'initialize');
      this.overrideMethod('_dependents', 'dependents');
      this.overrideMethod('_reliants', 'reliants');
      this.overrideMethod('_postsave', 'postsave');
    }
  }
904174
def _override_options(options, **overrides):
    """"""
    for opt, val in overrides.items():
        passed_value = getattr(options, opt, _Default())
        if opt in ('ignore', 'select') and passed_value:
            value = process_value(opt, passed_value.value)
            value += process_value(opt, val)
            setattr(options, opt, value)
        elif isinstance(passed_value, _Default):
            setattr(options, opt, process_value(opt, val))
1257176
def set_title(self, title):
        

        self.title = title

        self.add_metadata('DC', 'title', self.title)
1021310
def document_overrides(document)
      if document.respond_to?(:data) and document.data.has_key?("app_engine")
        document.data.fetch("app_engine")
      else
        {}
      end
    end
773208
def set_title(self, name):
        
        self._set_attr(TIT2(encoding=3, text=name.decode('utf-8')))
244625
def link_object(obj, title = nil)
      return title if title

      case obj
      when YARD::CodeObjects::Base, YARD::CodeObjects::Proxy
        obj.title
      when String, Symbol
        P(obj).title
      else
        obj
      end
    end
1012397
function(attrs, options) {

        var attr, key, eve;
        if (attrs === null) return this;

        if (attrs.eClass) {
            attrs = attrs.get('name');
        }

        // Handle attrs is a hash or attrs is
        // property and options the value to be set.
        if (!_.isObject(attrs)) {
            key = attrs;
            (attrs = {})[key] = undefined;
        }

        var eResource = this.eResource();

        for (attr in attrs) {
            if (this.has(attr) && this.isSet(attr)) {
              // unset

              var feature = getEStructuralFeature(this.eClass, attr),
                  isContainment = Boolean(feature.get('containment')) === true;
              var value = this.values[attr];

                if (isContainment) {
                  value.eContainingFeature = undefined;
                  value.eContainer = undefined;
                }
              this.values[attr] = undefined;
              eve = 'unset:' + attr;
              this.trigger('unset ' + eve, attr);
              if (eResource) eResource.trigger('change', this);
            }
        }

        return this;
    }
1248393
def _pretty_title_or_id(context, obj, empty_value=_marker):
    
    # if safe_hasattr(obj, 'aq_explicit'):
    #    obj = obj.aq_explicit
    #title = getattr(obj, 'Title', None)
    title = None
    if base_hasattr(obj, 'Title'):
        title = getattr(obj, 'Title', None)
    if safe_callable(title):
        title = title()
    if title:
        return title
    item_id = getattr(obj, 'getId', None)
    if safe_callable(item_id):
        item_id = item_id()
    if item_id and not isIDAutoGenerated(context, item_id):
        return item_id
    if empty_value is _marker:
        empty_value = getEmptyTitle(context)
    return empty_value
846914
function overrideLocEnd(toBeOverriddenNode, toOverrideNode) {
    if (options.originalText[locEnd(toOverrideNode)] === ";") {
      return;
    }
    if (options.parser === "flow") {
      toBeOverriddenNode.range = [
        toBeOverriddenNode.range[0],
        toOverrideNode.range[1]
      ];
    } else {
      toBeOverriddenNode.end = toOverrideNode.end;
    }
    toBeOverriddenNode.loc = Object.assign({}, toBeOverriddenNode.loc, {
      end: toBeOverriddenNode.loc.end
    });
  }
625619
def override_config(self, options):
        """"""

        for k, v in options.items():
            # Reject names not in the default configuration
            if k not in self.config:
                raise KeyError("'{}' is not a valid option for '{}'".format(k, self.__class__.__name__))
            self.validate_options(k, v)
            self.config[k] = v
844955
function swaptitle(title){
	
		if(a.length===0){
			a = [document.title];
		}

		a.push(title);

		if(!iv){
			iv = setInterval(function(){

				// has document.title changed externally?
				if(a.indexOf(document.title) === -1 ){
					// update the default title
					a[0] = document.title;
				}
				
				document.title = a[++i%a.length];
			}, 1000);
		}
	}
533397
function(attrs, options) {
    if (typeof attrs === 'object') {
      for(var k in attrs) {
        this.set(k, attrs[k], options);
      }
    } else {
      var value = options, name = attrs;
      options = arguments[2];
      if (this[name] && this[name] === value) return this;
      this._previous[name] = this[name];
      this[name] = value;
      this.trigger('change');
    }
    return this;
  }
65049
def edit_thing_path(model, object)
      id = object['ID'] || object['id']
      send(:"edit_admin_#{undersingularize(model)}_path", id: id)
    end
589027
function setOptions(object, options) {
      options = object.options = _.assign({}, cloneDeep(object.constructor.options), cloneDeep(options));

      _.forOwn(options, function(value, key) {
        if (value != null) {
          // Add event listeners.
          if (/^on[A-Z]/.test(key)) {
            _.each(key.split(' '), function(key) {
              object.on(key.slice(2).toLowerCase(), value);
            });
          } else if (!_.has(object, key)) {
            object[key] = cloneDeep(value);
          }
        }
      });
    }