David's virtual world

class sfMenuBuilder {
  protected static 
    $instances    = array();
 
  protected
    $menuItems    = array(),
    $route        = null,
    $routeName    = null,
    $routeObject  = null,
    $i18n         = null;
 
  /**
   * Initialize an instance of sfMenuBuilder with the given data and name.
   * If there is an existing instance with the same name it will be overwritten.
   * 
   * Since sfMenuBuilder needs the current sfContext to access the routing and 
   * request objects the context has to be provided as parameter. 
   * 
   * @param array $itemsData    Array of data to create sfMenuItem objects
   * @param sfRoute $route      The current sfRoute
   * @param string $routeName   The name of the current sfRoute
   * @param string $name        The name of the instance, optional, defaults to "default"
   * @param sfI18n $i18n        An instance of sfI18n to perform translations using __()
   * 
   * @return sfMenuBuilder      The newly created instance
   */
  public static function initInstance(array $itemsData, sfRoute $route, $routeName, $name = 'default', sfI18n $i18n = null) {
    self::$instances[$name] = new sfMenuBuilder($itemsData, $route, $routeName, $i18n);
    return self::$instances[$name];
  }
 
  /**
   * Get the instance for the given name parameter.
   * 
   * Warning: this does not create instances automatically! If you 
   * try to get an instance that doesn't exist, null will be returned!
   * 
   * @param string $name    The name of the instance to fetch
   * 
   * @return sfMenuBuilder  An sfMenuBuilder instance for the given name.
   */
  public static function getInstance($name = 'default') {
    if (isset(self::$instances[$name])) {
      return self::$instances[$name];
    }
    return null;
  }
 
  /**
   * Set to protected to prevent access from outside the singleton instance holder.
   * 
   * @param array $itemsData    Array of data to create sfMenuItem objects
   * @param sfRoute $route      The current sfRoute
   * @param string $routeName   The name of the current sfRoute
   * @param sfI18n $i18n        An instance of sfI18n to perform translations using __()
   */
  protected function __construct(array &$itemsData, sfRoute $route, $routeName, sfI18n $i18n = null) {
    $this->routeName = $routeName;
    $this->route = $route;
    $this->i18n = $i18n;
 
    if ($this->route instanceof sfObjectRoute) {
      $options = $this->route->getOptions();
      if ($options['type'] == 'object') {
        $this->routeObject = $this->route->getObject();
      }
    }
 
    foreach ($itemsData as $routeName => $itemData) {
      $this->menuItems[$routeName] = new sfMenuItem($routeName, $itemData);
      $this->menuItems[$routeName]->initialize($this->routeName, $this->route, $this->routeObject, $this->i18n);
    }
  }
 
  /**
   * Render all items of a given level of the menu.
   * 
   * By default, only items inside the current route branch will be rendered.
   * To render all items regardless of their branch set the $forceAll 
   * parameter to true.
   * 
   * @param int $level          Level to render. 0 = top level, 1 = second level and so on
   * @param boolean $forceAll   Set to true to render all items even if their part of the tree is inactive
   * 
   * @return array              Array of items' XHTML code grouped by position
   */
  public function renderLevel($level = 0, $forceAll = false) {
    $rendered = array();
    foreach ($this->menuItems as $item) {
      $item->renderLevel($level, $rendered, $forceAll);
    }
    return $rendered;
  }
 
  /**
   * Render all menu items into a tree structure.
   * 
   * @param string $container   The XHTML container tag to use. Defaults to 'ul'.
   * 
   * @return string             Rendered items and child items, wrapped in container tag
   */
  public function renderTree($container = 'ul') {
    $rendered = '';
    foreach ($this->menuItems as $item) {
      $rendered .= $item->renderTree($container);
    }
    return content_tag($container, $rendered);
  }
}

class sfMenuItem {
  protected
    $myRouteName        = null,
    $children           = array(),
    $allRouteNames      = array(),
    $title              = '',
    $position           = 'default',
    $container          = 'li',
    $requireObjectClass = null,
    $customFunction     = null,
    $customUrl          = null,
    $route              = null,
    $routeName          = null,
    $routeObject        = null,
    $i18n               = null;
 
  /**
   * Generate a new sfMenuItem object using its own route name and the node
   * data from the structural schema.
   * 
   * @param string $myRouteName   This item's sfRoute name (as in routing.yml)
   * @param array $itemData       The data definition for this item
   */
  public function __construct($myRouteName, array $itemData) {
    $this->myRouteName = $myRouteName;
    $this->allRouteNames[] = $myRouteName;
 
    if (isset($itemData['title'])) {
      $this->title = $itemData['title'];
    }
    if (isset($itemData['position'])) {
      $this->position = $itemData['position'];
    }
    if (isset($itemData['container'])) {
      $this->container = $itemData['container'];
    }
    if (isset($itemData['alias_routes'])) {
      $this->allRouteNames = array_merge($this->allRouteNames, (array) $itemData['alias_routes']);
    }
    if (isset($itemData['require_object_class'])) {
      $this->requireObjectClass = $itemData['require_object_class'];
    }
    if (isset($itemData['custom_function'])) {
      $this->customFunction = new sfCallable($itemData['custom_function']);
    }
    if (isset($itemData['custom_url'])) {
      $this->customUrl = $itemData['custom_url'];
    }
 
    if (isset($itemData['children']) && is_array($itemData['children'])) {
      foreach ($itemData['children'] as $subRouteName => $subItemData) {
        $this->children[$subRouteName] = new sfMenuItem($subRouteName, $subItemData);
        $this->allRouteNames = array_merge($this->allRouteNames, $this->children[$subRouteName]->getAllRouteNames());
      }
    }
  }
 
  /**
   * Initialize the menu item and all child menu items using the current routing 
   * status of the application.
   * By passing the routing information you can either use routes from outside
   * the context (e.g. testing data) or just improve performance because this
   * would have to be repeated for all the child menu items. 
   * 
   * @param string $routeName   Name of the currently active route
   * @param sfRoute $route      Currently active route object
   * @param mixed $routeObject  Object that is transported through the route if it is an sfObjectRoute
   * @param sfI18n $i18n        An instance of sfI18n to perform translations using __()
   */
  public function initialize($routeName, sfRoute $route, $routeObject, sfI18n $i18n = null) {
    $this->routeName = $routeName;
    $this->route = $route;
    $this->routeObject = $routeObject;
    $this->i18n = $i18n;
 
    foreach ($this->children as $child) {
      $child->initialize($this->routeName, $this->route, $this->routeObject, $this->i18n);
    }
  }
 
  /**
   * Get this menu item's route name.
   * 
   * @return string   Route name of this single menu item
   */
  public function getMyRouteName() {
    return $this->myRouteName;
  }
 
  /**
   * Get all child sfMenuItem objects.
   * 
   * @return array    Array of sfMenuItem objects, using the route names as keys.
   */
  public function getChildren() {
    return $this->children;
  }
 
  /**
   * Get an array of all route names and alias route names this menu item
   * might use. Also includes all sub items' routes recursively.
   * 
   * @return array    Array of route names
   */
  public function getAllRouteNames() {
    return $this->allRouteNames;
  }
 
  /**
   * Get the title that will be used to render this item.
   * 
   * @return string   Title text
   */
  public function getTitle() {
    return $this->title;
  }
 
  /**
   * Get the position this item will be rendered at.
   * 
   * @return string   Position. Defaults to "default"
   */
  public function getPosition() {
    return $this->position;
  }
 
  /**
   * Get this menu item's wrapper container.
   * 
   * @return string   HTML wrapper Container name
   */
  public function getContainer() {
    return $this->container;
  }
 
  /**
   * Get the object class that is required for this item to 
   * be rendered as "enabled".
   * 
   * @return string   Object class name 
   */
  public function getRequireObjectClass() {
    return $this->requireObjectClass;
  }
 
  /**
   * Get this menu item's custom URL.
   * 
   * @return string   Custom URL
   */
  public function getCustomUrl() {
    return $this->customUrl;
  }
 
  /**
   * If an i18n instance was provided, this will do the translation.
   * @see sfI18n::__()
   * 
   * @param string $string  The string to translate
   * 
   * @return string         Translated string
   */
  public function __($string) {
    if (is_null($this->i18n)) {
      return $string;
    }
    return $this->i18n->__($string);
  }
 
  /**
   * Render the current menu item's content text.
   * 
   * The content always contains an 'a' tag containing either a href
   * link (if the item is enabled) or the item title only.
   * 
   * All titles are translated using i18n.
   * 
   * @return string   Rendered menu item content HTML code
   */
  public function renderContent() {
    if ($this->customFunction instanceof sfCallable) {
      return $this->customFunction->call($this);
    }
 
    if (!$this->isEnabled()) {
      return content_tag('a', $this->__($this->title));
    } else {
      if (!is_null($this->customUrl)) {
        return link_to($this->__($this->title), $this->customUrl);
      } elseif (is_null($this->requireObjectClass)) {
        return link_to($this->__($this->title), '@'.$this->myRouteName);
      } else {
        return link_to($this->__($this->title), $this->myRouteName, sfObjectResolver::resolve($this->routeObject, $this->requireObjectClass));
      }
    }
  }
 
  /**
   * Check if the item is enabled or not.
   * An item will be disabled if it requires an object class
   * that cannot be found by the resolver.
   * 
   * @return boolean  True if the item is enabled
   */
  public function isEnabled() {
    return is_null($this->requireObjectClass) || !is_null(sfObjectResolver::resolve($this->routeObject, $this->requireObjectClass));
  }
 
  /**
   * Check if the item is currently selected.
   * An item will be selected if the current routeName matches
   * any route in the items allRouteNames property.
   * 
   * @return boolean  True if the item is currently selected in the menu
   */
  public function isCurrent() {
    return in_array($this->routeName, $this->allRouteNames);
  }
 
  /**
   * Wrap an item with the container that is set. If no container
   * is defined, just return the item.
   * 
   * @param string $text    Text content
   * @param array $options  Options array passed to content_tag() helper
   * 
   * @return string         Rendered content tag
   */
  protected function containerTag($text, $options = array()) {
    if ($this->container != '') {
      return content_tag($this->container, $text, $options);
    }
    return $text;
  }
 
  /**
   * Render the current menu item.
   * 
   * The item is rendered inside the element given as "container" parameter.
   * The container defaults to the HTML list element ("li").
   * 
   * Items that require an object route without existing object of that type
   * have their class attribute set to "disabled". Items that match the current
   * route have their class attribute set to "current".
   * 
   * @return string   Rendered menu item HTML code
   */
  public function render() {
    $text = $this->renderContent();
    if (!$this->isEnabled()) {
      return $this->containerTag($text, array('class' => 'disabled'));
    } elseif ($this->isCurrent()) {
      return $this->containerTag($text, array('class' => 'current'));
    }
    return $this->containerTag($text);
  }
 
  /**
   * Get the sfRoute object associated with all the menu items.
   * 
   * @return sfRoute  sfRoute object
   */
  public function getRoute() {
    return $this->route;
  }
 
  /**
   * Get the route name associated with all the menu items.
   * 
   * @return string   Route name
   */
  public function getRouteName() {
    return $this->routeName;
  }
 
  /**
   * Get the route object out of sfObjectRoute.
   * 
   * @return mixed    Route object generated by sfObjectRoute
   */
  public function getRouteObject() {
    return $this->routeObject;
  }
 
  /**
   * Render all menu items of a given child level related to this item.
   * 
   * The rendered items are added to the $rendered array parameter grouped 
   * by their position.
   * 
   * @param int $level          Level to render. 0 will return the current item, 1 all items of the first child level and so on.
   * @param array $rendered     Contains all items rendered so far. Rendered items will be appended to the array.
   * @param boolean $forceAll   Force the rendering of all sub items, even if their tree is not in the current route
   */
  public function renderLevel($level, array &$rendered, $forceAll = false) {
    if ($level == 0) {
      $rendered[$this->position][] = $this->render();
    } elseif ($level > 0 && ($forceAll || in_array($this->routeName, $this->allRouteNames))) {
      $level--;
      foreach ($this->children as $child) {
        $child->renderLevel($level, $rendered, $forceAll);
      }
    }
  }
 
  /**
   * Render all menu items into a tree structure.
   * 
   * @param string $container   The HTML container tag to use. Defaults to 'ul'.
   * 
   * @return string             Rendered item and child items, wrapped in container tag
   */
  public function renderTree($container = 'ul') {
    $children = '';
    foreach ($this->children as $child) {
      $children .= $child->renderTree($container);
    }
 
    $text = $this->renderContent();
    if ($children != '') {
      $text .= content_tag($container, $children);
    }
    if (!$this->isEnabled()) {
      return $this->containerTag($text, array('class' => 'disabled'));
    } elseif ($this->isCurrent()) {
      return $this->containerTag($text, array('class' => 'current'));
    }
    return $this->containerTag($text);
  }
}