system/classes/options.php

<?php
namespace Habari;
class Options extends Singleton
{
  private $options = null;

  protected static function instance()
  {
    return self::getInstanceOf( __CLASS__ );
  }

  public static function get( $name, $default_value = null )
  {
    if ( is_array( $name ) ) {
      $results = array();
      foreach ( $name as $key ) {
        $results[ $key ] = Options::get( $key );  // recursively wrap around ourselves!
      }
      return $results;
    }
    
    if ( isset( self::instance()->$name ) ) {
      return self::instance()->$name;
    }
    else {
      return $default_value;
    }
  }

  public static function get_group( $prefix )
  {

    if ( substr( $prefix, -2 ) != '__' ) {
      $prefix .= '__';
    }
    
    $results = array();
    foreach ( array_keys( self::instance()->options ) as $key ) {
      
      if ( strpos( $key, $prefix ) === 0 ) {
        $results[ substr( $key, strlen( $prefix ) ) ] = Options::get( $key );
      }
      
    }
    
    return $results;
    
  }
  
  public static function set_group ( $prefix, $values )
  {
    
    if ( substr( $prefix, -2 ) != '__' ) {
      $prefix .= '__';
    }
    
    // loop through each option, setting it
    foreach ( $values as $k => $v ) {
      
      Options::set( $prefix . $k, $v );
      
    }
    
  }
  
  public static function delete_group ( $prefix )
  {
    
    if ( substr( $prefix, -2 ) != '__' ) {
      $prefix .= '__';
    }
    
    foreach ( array_keys( self::instance()->options ) as $key ) {
      
      if ( strpos( $key, $prefix ) === 0 ) {
        Options::delete( $key );
      }
      
    }
    
  }

  public static function out( $name )
  {
    echo self::instance()->get( $name );
  }

  public static function set( $name, $value = '' )
  {
    
    if ( is_array( $name ) ) {
      foreach ( $name as $k => $v ) {
        Options::set( $k, $v ); // recursively wrap around ourselves!
      }
    }
    else {
      self::instance()->$name = $value;
    }
    
  }


  public static function delete( $name )
  {
    
    if ( is_array( $name ) ) {
      foreach ( $name as $key ) {
        Options::delete( $key ); // recursively wrap around ourselves!
      }
    }
    else {
      unset( self::instance()->$name );
    }
    
  }

  public function __get( $name )
  {
    if ( ! isset( $this->options ) ) {
      $this->get_all_options();
    }
    $option_value = isset( $this->options[$name] ) ? $this->options[$name] : null;
    $option_value = Plugins::filter( 'option_get_value', $option_value, $name );
    return $option_value;
  }

  public function __isset ( $name ) {

    if ( !isset( $this->options ) ) {
      $this->get_all_options();
    }

    return isset( $this->options[ $name ] );

  }

  public function get_all_options()
  {
    // Set some defaults here
    $this->options = array(
      'pagination' => 10,
      'comments_require_id' => false,
    );
    if(Config::exists('default_options')) {
      $this->options = array_merge($this->options, Config::get('default_options'));
    }
    if(DB::is_connected()) {
      $results = DB::get_results( 'SELECT name, value, type FROM {options}', array() );
      foreach ( $results as $result ) {
        if ( $result->type == 1 ) {
          $this->options[$result->name] = unserialize( $result->value );
        }
        else {
          $this->options[$result->name] = $result->value;
        }
      }
    }
    if(Config::exists('static_options')) {
      $this->options = array_merge($this->options, Config::get('static_options'));
    }
  }

  public function __set( $name, $value )
  {
    if ( ! isset( $this->options ) ) {
      $this->get_all_options();
    }

    // if the option already exists and has the same value, there is nothing to update and we shouldn't waste a db hit
    // i can't think of any negative implications of this, but that's no guarantee
    if ( isset( $this->options[ $name ] ) && $this->options[ $name ] == $value ) {
      return;
    }

    $value = Plugins::filter( 'option_set_value', $value, $name, isset( $this->options[$name] ) ? $this->options[$name] : null );
    $this->options[$name] = $value;

    // we now serialize everything, not just arrays and objects
    $result = DB::update( DB::table( 'options' ), array( 'name' => $name, 'value' => serialize( $value ), 'type' => 1 ), array( 'name' => $name ) );

    if ( Error::is_error( $result ) ) {
      $result->out();
      die();
    }
  }

  public function __unset( $name )
  {
    unset( $this->options[$name] );
    DB::delete( DB::table( 'options' ), array( 'name' => $name ) );
  }

  public static function clear_cache()
  {
    self::instance()->options = null;
  }

  public static function is_static($name)
  {
    if($static_options = Config::exists('static_options')) {
      if(isset($static_options[$name])) {
        return true;
      }
    }
    return false;
  }

}

?>