Schmalls blog

Install Trac As A Windows Service

2009-10-01T20:09:29-06:00

What follows is a how-to for installing Trac as a Windows service. The benefit of this is being able to log off of the server machine without stopping the tracd server.

The bulk of the information used to figure this out come from Microsoft's How To Create a User-Defined Service and a guide for Windows NT Tcl/Tk Server Installation.

The steps are actually pretty simple:

Download the Windows 2003 Resource Kit Tools

Run the following command (after making the appropriate path replacements):

C:\Program Files\Resource Kit\Instsrv.exe Tracd C:\Program Files\Resource Kit\Srvany.exe

Run regedit.
1. Add a new key: [HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Tracd\Parameters]
2. Add the following string values:
  1. Application with the path to the tracd executable.
  2. AppParameters with the parameters you use to run tracd.
  3. AppDirectory with the path to the directory which contains the tracd executable.
Open the Services panel.
1. Set the new Tracd service to automatic.
2. Start the Tracd service.

Now you should be able to log out and still access the Trac server.

Trac, Windows, Tips

Read or add comments to this article

Home Server Project - Part 1

2008-12-30T15:38:42-06:00

Explains the history behind and first steps of my home server project.

The History

I currently live in a house with three other guys (see bachelor pad). Between us we have 3 desktops, 3 laptops, 3 XBOX 360s, and 3 iPhones. The desktops and laptops are running ether XP or Vista. The first year in the house saw the addition of network connections to all of the bedrooms and the living room, serviced by a cable modem, wireless and wired routers, and an 8-port hub. The living room has one of the XBOXes, a projector, digital cable box, and a Pioneer receiver.

Over my Christmas vacation, instead of relaxing, I decided to start yet another project. I wanted to better integrate the home network and I also wanted to get my feet wet with home automation. So the idea was to setup some network shares and also to make a remote interface for the living room that can be used from the iPhone (or any web browser). After some research I settled on using Ubuntu Server with Samba for the shared drives (it was around this point I also decided to work on implementing Roaming Profiles), lirc and the IguanaWorks USB IR Transceiver for replacing all the remotes in the living room, and uShare to share media with the XBOX 360s. Of course the web interface for the living room remotes will be backed by PHP and jQuery.

The Hardware

The next step was to find some hardware to run all of this. My first stop was Newegg followed by a stop at IguanaWorks.

Total	$357.46
(1) MSI Wind PC Intel 945GC 1 x 200Pin Intel GMA 950 Black Barebone - Retail	$139.99
(1) Western Digital Caviar Black WD1001FALS 1TB 7200 RPM 32MB Cache SATA 3.0Gb/s Hard Drive - OEM	$119.99
(1) G.SKILL 2GB 200-Pin DDR2 SO-DIMM DDR2 533 (PC2 4200) Laptop Memory - Retail	$21.99
(1) Newegg Shipping	$20.49
(1) USB IR Transceiver	$40.00
(2) 5 foot wired IR emitters	$10.00
(1) IguanaWorks Shipping	$5.00

The Wait

Since I ordered all of the components, I have been waiting on the pieces to arrive. I also ordered a 4Gb flash drive from Newegg, because I couldn't find mine and I can use it to install the operating system (instead of getting an SATA or USB CD drive). While waiting I have just been reading up on all of the documentation to prepare myself for the installation process. Stay tuned for the next part in the series.

Computers

Read or add comments to this article

A Pluggable Preprocessor for PHP

2008-08-31T10:37:50-06:00

After reading Stan Vassilev's post on Practical Uses for the PHP Tokenizer, I got to thinking about his example of a preprocessor. It makes a lot of sense for the library developer. They could easily create multiple versions of their code depending on PHP version, target platform, backend database, etc. So I started working on my own implementation of a preprocessor with the goal of making it easy to add plugins for additional functionality. It was during the construction of the core of the preprocessor, that it hit me: why can't we implement new language features in the preprocessor. The first things that came to mind for me were traits and scalar type hints. So without further ado, I present version 0.1.0-dev of PPP (with its own doubly recursive meaning: PPP PHP PreProcessor).

The first version is very basic and only includes a plugin for traits handling (which is an ugly, but functional implementation). It also requires PHP 5.3 because of the use of namespaces. I plan on removing this limitation after I add a plugin for conditional macro statements (i.e. PPP will be able to preprocess itself). If you take a look at the tests folder, you will find some incomplete (sorry) PHPUnit tests of the functionality, which should give you an idea of how to interact with PPP.

My implementation of traits is a simple one. I believe the goal of traits are to put the power into the programmers hands. So the trait syntax I use only allows renaming (not aliasing) or excluding methods. It isn't very strict currently (i.e. variables, constants, etc. in the trait definition will make it through). I plan on adding the ability to exclude all methods (* as null), to remove the only problem I can see with the implementation: if traits maintained by another individual or group add methods. With the ability to exclude all unaliased methods, the programmer can insure that only the methods (s)he expects can be included, at the expense of verbosity of the aliases.

My main goal for the future of the preprocessor is to reduce the amount of coding required by the programmer by adding syntactic sugar to PHP. You can download and let me know what you think in the comments.

PHP

Read or add comments to this article

2008-08-31T10:37:50-06:00

Solidworks Batch Runner

2008-05-05T13:03:40-06:00

In my everyday work, I spend a lot of time waiting on SolidWorks to finish a task. The SolidWorks task scheduler is able to remove some of these burdens by allowing them to be run overnight. The great thing about the task scheduler is that it allows me to select folders or groups of files and runs the task in a separate SolidWorks instance for each file it finds. It also has a timeout for each file to complete its task. This means it can keep churning through all of the files and recover from a problem with one of the files (SolidWorks 2008 is notoriously unstable).

The problem is that the number of tasks available is limited. There is the Custom Task which allows you to run a custom program or macro, but for some reason removes the file selection capability. It is for this reason that I set out to recreate the functionality of the task scheduler, but with the ability to run any macro (or multiple macros) in separate instances of SolidWorks for entire groups of files. I call it SolidWorksBatchRunner.

Let me start with the usage statement for SolidWorksBatchRunner and continue with some examples of its functionality.

Usage: SolidWorksBatchRunner /m:MacroFile[|MacroModule[|MacroProcedure]] ..
       [/l:LogFile] [/n] [/r] [/s [/q]] [/t:Timeout] FileSearch ..
Runs the specified macros on the files found from the specified file
searches.
       /m:MacroFile|MacroModule|MacroProcedure
              The macro(s) to run on the specified files. MacroModule
              defaults to MacroFile - extension + 1. MacroProcedure
              defaults to main
       /l:LogFile
              The log file to use. Defaults to the current date/time:
              yyy-MM-dd HH-mm-ss.log.
       /n
              Specifies that each macro should be ran in a new SolidWorks
              instance.
       /q
              Specifies that the files should be rebuilt after all macros
              have run. Cannot be used without /s switch.
       /r
              Searches will also include subdirectories.
       /s
              Specifies that the files should be saved after all macros
              have run.
       /t
              The time, in seconds, each macro is given to complete its
              task. The default is 300 seconds.
       /?
       /h
       /help
              Prints this usage statement and exits.

I have included several options that I have found useful to a task scheduler application. So lets say you want to take a group of drawings and run your “DXFExport” macro on all the files. We don't need to save the SolidWorks files afterward because we didn't change anything. A command to do this could look like:

SolidWorksBatchRunner /m:"C:\My SW Macro Folder\DXFExport.swp" "C:\My Drawings Folder\*.SLDDRW"

A couple of assumptions have been made.

The DXFExport module's name is DXFExport1.
The DXFExport1 module method's name is main.
*.SLDDRW will find all the SolidWorks drawings in “C:\My Drawings Folder”.
A file log with the current time and date is created to store log messages.

The previous example shows how to run one macro on one file search, but it is possible to do multiple of each. We can also specify the name of a log file to create.

SolidWorksBatchRunner ^
  /m:"C:\My SW Macro Folder\Macro1.swp|Macro11|main" ^
  /m:"C:\My SW Macro Folder\Macro1.swp|Macro11|alternate" ^
  /m:"C:\My SW Macro Folder\Macro2.swp" ^
  /s /q /r ^
  /l:"My Log File Name.log" ^
  "C:\My Drawings Folder\Folder 1\*.SLDDRW" ^
  "C:\My Drawings Folder\Folder 2\*.SLDDRW" ^
  "C:\My Drawings Folder\Folder 3\Start*End.SLDDRW"

With this example:

On each file Macro1 is called twice, once with the main method followed by the alternate method.
On each file Macro2 is then called. All the macros run within one SolidWorks instance per file which can be changed by adding the /n switch.
/s saves each file after the macros have run (like Ctrl-S).
/q rebuilds each file before saving (like Ctrl-Q).
/r causes the file searches to recursively search subdirectories on all of the file searches.
The first file search finds all drawings in Folder 1 and its subdirectories (because of the /r switch).
The second file search finds all drawings in Folder 2 and its subdirectories (because of the /r switch).
The third file search finds only the drawings whose filename begins with “Start” and ends with “End” in Folder 3 and its subdirectories (because of the /r switch)
Status information is written to the command line as well as to the “My Log File Name.log” file.

I have uploaded a zipped up Visual Studio Express project file used to make this program as well as a zipped up file of the executable and the SolidWorks libraries that it uses. The code is released under the ISC License. I have only tested it with SolidWorks 2008 SP3.1 and .NET framework 3.5 installed. If anyone runs into any problems or has a suggestion, let me know by posting a comment to this post.

Files

SolidWorks

Read or add comments to this article

Infinite Recursion (i.e. Hard To Spot Error)

2008-02-12T18:01:42-06:00

I ran into a hard to spot bug the other day and decided to share it. I worked on some code for a while and then fired up my browser to test it. I would be using Xdebug straight from Eclipse PDT, but I can't get it to work with the latest php snapshots for Windows. Anyway, when I went to test it, there was no output. It turns out that php-cgi had segfaulted. I spent the better half of a day trying to figure out the problem. When I thought I had figured it out, I would try to write up a test script for just that problem, and all of them ran just fine. Just when I was about to give up, I found the problem in this little class I was sure couldn't be wrong.

It is the base class for a graph edge. All the class does is constructs an object with references to its two vertices with a function to retrieve each. And here is the code (comments removed):

class Edge
{
    private $firstVertex;
 
    private $secondVertex;
 
    public function __construct( & $first_vertex, & $second_vertex )
    {
        $this->firstVertex = & $first_vertex;
        $this->secondVertex = & $second_vertex;
    }
 
    public function firstVertex()
    {
        return $this->firstVertex;
    }
 
    public function secondVertex()
    {
        return $this->secondVertex();
    }
}

The problem was in the last function. Instead of returning the private variable value, I called the function recursively. Since this is infinite recursion, the PHP interpreter will eventually crash (in under a second in most of my cases) and not output anything. At first, I thought this would be a bug, but these bogus bug reports say that it is the expected behavior. I wish I could get Xdebug working to catch something like this (one of the bug reports say it would). So if anyone knows how to get Xdebug working on Windows with the latest PHP snapshots, let me know.

PHP

Read or add comments to this article

Return to Prototype Based Programming in PHP

2007-10-29T18:19:26-06:00

With the implementation of the get_called_class() function in PHP, prototype based programming in PHP is possible. The new function is in both PHP5.3 and PHP6 snapshots. So, I went back to the drawing board and came up with a fully capable class. The $this keyword is usable, as well as being able to use the self, parent, and static (new with the late static binding patch) keywords. Code after the jump.

So let's get straight to the code that does it.

prototype.php

<?php
namespace com::schmalls::personal;
 
/**
 * This class holds the prototype capabilities
 * 
 * Extending this class makes it prototype capable.
 * Instantiating this class with the param and
 * method values allows a runtime method to be
 * added to a class.
 */
class prototype
{
  /**
   * Holds the object prototype methods for all subclasses
   */
  private static $_object_methods = array();
 
  /**
   * Holds the static prototype methods for all subclasses
   */
  private static $_static_methods = array();
 
  /**
   * Holds all of the local prototype methods for this object
   */
  private $_local_methods = array();
 
  /**
   * Holds an instance of the prototype class
   */
  private static $_prototype = null;
 
  /**
   * Method parameters
   */
  private $___params = null;
 
  /**
   * Method body
   */
  private $___method = null;
 
  /**
   * Whether the method has static method calls
   */
  private $___static_calls = null;
 
  /**
   * Holds the last called class
   */
  private $___class = null;
 
  /**
   * Whether the last call was static
   */
  private $___static = null;
 
  /**
   * Default constructor
   * 
   * Child classes should not call this class. When called with the params
   * and method values, it can be used to set a new prototype method.
   * 
   * @param   mixed $params string input like create_user_function or array of argument names
   * @param   string $method method body
   */
  public function __construct( $params = null, $method = null )
  {
    // check if we are being used to make a prototype method
    if ( ( $params !== null ) && ( $method !== null ) ) {
      // check if this is an array
      if ( is_array( $params ) ) {
        // make the parameter string
        $params = implode( $params, ', ' );
      }
      // check if this method uses the this keyword
      if ( strpos( $method, '$this' ) !== false ) {
        // splits the method body by parts in which the this keyword should not be altered
        $regex =  '~' .                   // start regular expression
                    '(/\*.*?\*/)' .       // /* */ style comments
                    '|' .                 // or
                    '(#.*?$)' .           // # style comments
                    '|' .                 // or
                    '(//.*?$)' .          // // style comments
                    '|' .                 // or
                    '(\'.*?[^\\\\]\')' .  // single quote strings
                  '~' .                   // end regular expression
                  'i' .                   // match case insensitive
                  's' .                   // dot matches all characters including newlines
                  'm';                    // match multiline;
        $pieces = preg_split( $regex, $method, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_OFFSET_CAPTURE );
        // store how many keywords have been replaced
        $i = 0;
        // loop through each of the split pieces
        foreach( $pieces as $piece ) {
          // replace the this keyword with a safer name
          $method = substr_replace(                         // begin substring replace of piece section
                        $method,                            // the main method body
                        preg_replace(                       // begin preg replace of this keyword
                          '/' .                             // start regular expression
                            '\$this' .                      // match the this keyword
                            '(?![[a-zA-Z0-9_\x7f-\xff])' .  // not followed by another valid variable name character
                          '/' .                             // end regular expression
                          'i',                              // match case insensitive
                          '$___this',                       // replace with $___this
                          $piece[0],                        // the piece string
                          -1,                               // no limit
                          $j                                // number of matches
                        ),                                  // end preg replace
                        ( $piece[1] + ( $i * 3 ) ),         // offset to beginning of piece
                        strlen( $piece[0] )                 // length of piece
                      );                                    // end substring replace
          // increase how many keyword replacements have been made
          $i += $j;
        }
      }
      // set the method parameters string including space for the this reference
      $this->___params = trim( $params );
      if ( $this->___params === '' ) {
        $this->___params .= '&$___this = null';
      } else {
        $this->___params .= ', &$___this = null';
      }
      // set the method body string
      $this->___method = $method;
      // check whether this method makes static calls and therefore has to be recreated on each call
      $this->___static_calls = ( strpos( $method, 'self' ) ||
          strpos( $method, 'parent' ) ||
          strpos( $method, 'static' ) )
          !== false;
    }
  }
 
  /**
   * Allows the prototype variable to be used within objects as well as setting up the called class
   * 
   * @param   string $name
   * @return  prototype
   */
  public function __get( $name )
  {
    // see if we are getting the prototype
    if ( $name === 'prototype' ) {
      // see if the static prototype variable has been instantiated
      if ( self::$_prototype === null ) {
        self::$_prototype = new prototype( get_called_class() );
      }
      // set the calling class and set to dynamic
      self::$_prototype->___class = get_called_class();
      self::$_prototype->___static = false;
 
      return self::$_prototype;
    }
  }
 
  /**
   * This is where the magic happens for dynamic prototype method calls
   * 
   * @param   string $name
   * @param   array $arguments
   * @return  mixed
   */
  public function __call( $name, $arguments )
  {
    // fix name
    $name = strtolower( $name );
    $class = get_called_class();
    // add this to arguments
    $arguments[] = &$this;
    // check if this is a local class method
    if ( isset( $this->_local_methods[$name] ) ) {
      // check if the method has static calls
      if ( is_array( $this->_local_methods[$name] ) ) {
        $method = create_function(                            // create function with static calls
                    $this->_local_methods[$name]['params'],   // parameters
                    self::_fixStaticMethodCalls(              // fix static calls
                      $this->_local_methods[$name]['method'], // method body
                      $class,                                 // self
                      get_parent_class( $class ),             // parent
                      $class                                  // static
                    )                                         // end fix static calls
                  );                                          // end create function
      } else {
        // use previously created function
        $method = $this->_local_methods[$name];
      }
      // call the method
      return call_user_func_array( $method, $arguments );
    } else {
      // try object method
      $chain = &self::_getCallingChain( $class );
      do {
        // get the current chain location
        $cur = &self::_getCur( $chain, self::$_object_methods );
        if ( isset( $cur['_methods'][$name] ) ) {
          // check if the method has static calls
          if ( is_array( $cur['_methods'][$name] ) ) {
            $method = create_function(                        // create function with static calls
                        $cur['_methods'][$name]['params'],    // parameters
                        self::_fixStaticMethodCalls(          // fix static calls
                          $cur['_methods'][$name]['method'],  // method body
                          $chain[count( $chain ) - 1],        // self
                          $chain[count( $chain ) - 2],        // parent
                          $class                              // static
                        )                                     // end fix static calls
                      );                                      // end create function
          } else {
            // use previously created method
            $method = $cur['_methods'][$name];
          }
          // call the method
          return call_user_func_array( $method, $arguments );
        }
      } while ( array_pop( $chain ) );
      // apparently no object method, try static method
      return self::_staticCall( $name, $arguments, $class );
    }
  }
 
  /**
   * Static call method
   * 
   * @param   string $name
   * @param   array $arguments
   * @return  mixed
   */
  public static function __callStatic( $name, $arguments )
  {
    // fix name
    $name = strtolower( $name );
    $class = get_called_class();
 
    return self::_staticCall( $name, $arguments, $class );
  }
 
  /**
   * This is where the magic happens for setting prototype functions
   * 
   * Child classes should call this if it is overridden
   * 
   * @param   string $name
   * @param   mixed $value
   */
  public function __set( $name, $value )
  {
    // check if this is an instance of the prototype class with the correct format
    if ( $value instanceof self && ( isset( $value->___params ) && isset( $value->___method ) ) ) {
      // fix name
      $name = strtolower( $name );
      // check for this keyword in non-object context
      if ( $this->___static && ( strpos( $value->___method, '$___this' ) !== false ) ) {
        trigger_error( 'Using $this when not in object context', E_USER_ERROR );
        return;
      }
      $class = get_called_class();
      // if we have static calls, we have to delay creation
      if ( $value->___static_calls ) {
        $method = array( 'params' => $value->___params, 'method' => $value->___method );
      } else {
        $method = create_function( $value->___params, $value->___method );
      }
      // check if this was through the prototype object
      if ( $class === __CLASS__ ) {
        // get the calling chain
        $chain = &self::_getCallingChain( $this->___class );
        // check if the prototype object was called statically
        if ( $this->___static ) {
          $methods = &self::$_static_methods;
        } else {
          $methods = &self::$_object_methods;
        }
        // get current location in calling chain
        $cur = &self::_getCur( $chain, $methods );
        // set the method
        $cur['_methods'][$name] = $method;
      } else {
        $this->_local_methods[$name] = $method;
      }
    } else {
      // this wasn't a prototype method
      $this->$name = $value;
    }
  }
 
  /**
   * Returns the prototype holder class
   * 
   * The prototype holder is used to add prototype methods to
   * child classes that are global to all objects. The functions
   * also allow inheritance. This function should only be called
   * statically (i.e. mySubClass::prototype()->newMethod = new
   * prototype( '$arg', 'echo $arg;' ) ). To create object
   * methods, use the prototype variable (i.e. $my_object->
   * prototype->newMethod = new prototype( '$arg', 'echo $arg;' )
   * ). To create a local object method, don't use prototype
   * (i.e. $my_object->newMethod = new prototype( '$arg',
   * 'echo $arg;' ) ).
   * 
   * @return  prototype
   */
  public static function prototype()
  {
    // see if the static prototype variable has been instantiated
    if ( self::$_prototype === null ) {
      self::$_prototype = new prototype( get_called_class() );
    }
    // set the calling class and set to static
    self::$_prototype->___class = get_called_class();
    self::$_prototype->___static = true;
 
    return self::$_prototype;
  }
 
  /**
   * Walks though parent classes and returns an array of the
   * calling chain
   * 
   * @param   string $class
   * @return  array
   */
  private static function &_getCallingChain( $class )
  {
    $chain = array( $class );
    // get classes until we hit the prototype class
    while ( $class !== __CLASS__ ) {
      $class = get_parent_class( $class );
      $chain[] = $class;
    }
    // reverse the array to get the calling chain
    $chain = array_reverse( $chain );
 
    return $chain;
  }
 
  /**
   * Gets the current location in the function holding array
   * 
   * @param   array &$chain
   * @param   array &$cur
   * @return  array
   */
  private static function &_getCur( &$chain, &$cur )
  {
    // loop until we have the current location
    foreach ( $chain as $class ) {
      $cur = &$cur[$class];
    }
 
    return $cur;
  }
 
  /**
   * Fixes static method calls (self, parent, and static keywords)
   * 
   * @param   string $method
   * @param   string $self
   * @param   string $parent
   * @param   string $static
   * @return  string
   */
  private static function _fixStaticMethodCalls( $method, $self, $parent, $static )
  {
    // splits the method body by parts in which the keywords should not be altered
    $regex =  '~' .                   // start regular expression
                '(/\*.*?\*/)' .       // /* */ style comments
                '|' .                 // or
                '(#.*?$)' .           // # style comments
                '|' .                 // or
                '(//.*?$)' .          // // style comments
                '|' .                 // or
                '(\'.*?[^\\\\]\')' .  // single quote strings
              '~' .                   // end regular expression
              'i' .                   // match case insensitive
              's' .                   // dot matches all characters including newlines
              'm';                    // match multiline
    $pieces = preg_split( $regex, $method, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_OFFSET_CAPTURE );
    $i = 0;
    // build the search array
    $search = array(
                '/' .
                  '(?<=$|[^a-zA-Z0-9_\x7f-\xff])' . // match beginning of line or any non variable character
                  'self' .                          // match the self keyword
                  '(?=\s*::|$)' .                   // match paamayim nekudotayim or end of string
                '/' .                               // end regular expression
                'i',                                // match case insensitive
                // same for parent keyword
                '/(?<=$|[^a-zA-Z0-9_\x7f-\xff])parent(?=\s*::|$)/i',
                // same for static keyword
                '/(?<=$|[^a-zA-Z0-9_\x7f-\xff])static(?=\s*::|$)/i'
              );
    // build the replace array
    $replace = array( $self, $parent, $static );
    // loop thorugh each piece
    foreach( $pieces as $piece ) {
      // replace the static calls
      $updated = preg_replace( $search, $replace, $piece[0], -1, $j );
      // get the length of the original
      $length = strlen( $piece[0] );
      // replace the piece
      $method = substr_replace( $method, $updated, ( $piece[1] + $i ), $length );
      // update how much has been added (or removed) from the method
      $i += ( strlen( $updated ) - $length );
    }
    return $method;
  }
 
  /**
   * This is where the magic happens for static prototype method calls
   * 
   * @param   string $name
   * @param   array $arguments
   * @param   string $class
   * @return  mixed
   */
  private static function _staticCall( $name, $arguments, $class )
  {
    $chain = &self::_getCallingChain( $class );
    do {
      // get the current chain location
      $cur = &self::_getCur( $chain, self::$_static_methods );
      if ( isset( $cur['_methods'][$name] ) ) {
        // check if the method has static calls
        if ( is_array( $cur['_methods'][$name] ) ) {
          $method = create_function(                        // create function with static calls
                      $cur['_methods'][$name]['params'],    // parameters
                      self::_fixStaticMethodCalls(          // fix static calls
                        $cur['_methods'][$name]['method'],  // method body
                        $chain[count( $chain ) - 1],        // self
                        $chain[count( $chain ) - 2],        // parent
                        $class                              // static
                      )                                     // end fix static calls
                    );                                      // end create function
        } else {
          // use previously created method
          $method = $cur['_methods'][$name];
        }
        // call the method
        return call_user_func_array( $method, $arguments );
      }
    } while ( array_pop( $chain ) );
    // the method doesn't exist
    trigger_error( 'Call to undefined method ' . $class . '::' . $name . '()', E_USER_ERROR );
  }
}

I tried to document it as much as possible in the code, so I won't explain it too much. I will point out that all of the regular expression calls have to do with runtime created functions not being able to use the $this keyword directly as well as allowing the static keywords to be used.

Now let's do some sample code usage.

<?php
include 'com/schmalls/personal/prototype.php';
import com::schmalls::personal::prototype;
 
class A extends prototype
{
  public $monkey = 'monkey';
  const yes = 'yes';
}
class C extends A {}
 
$a = new A();
$b = new A();
$c = new C();
// create an object method that calls a static method
$a->prototype->objectMethod = new prototype( '$test', '
  /**
   * comment
   */
  echo $test, \' $this\', \'<br />\', "\n"; // test
  echo $this->monkey, \'<br />\', "\n";
  # monkey
  $this->monkey = "cool";
  self::staticMethod();
  '
);
// create a static method that uses self
A::prototype()->staticMethod = new prototype( '', '
  echo self::yes, \'<br />\', "\n";
  echo \'<br />\', "\n";
  '
);
// create a local method
$a->localMethod = new prototype( '$test', '
  // call the object method
  $this->objectMethod( $test );
  '
);
 
// all three objects can call the object method,
// but none of the static calls work
$a->objectMethod( '$a->objectMethod' );
$b->objectMethod( '$b->objectMethod' );
$c->objectMethod( '$c->objectMethod' );
//A::objectMethod( 'A::objectMethod' );
//C::objectMethod( 'B::objectMethod' );
 
// all three objects can call the static method,
// and all static calls work
$a->staticMethod();
$b->staticMethod();
$c->staticMethod();
A::staticMethod();
C::staticMethod();
 
// only the $a object can call this one
$a->localMethod( '$a->localMethod' );
//$b->localMethod( '$b->localMethod' );
//$c->localMethod( '$c->localMethod' );
//A::localMethod( 'A::localMethod' );
//C::localMethod( 'C::localMethod' );

PHP

Read or add comments to this article

Eclipse PHP IDE

2006-12-28T23:36:48-06:00

I have been using PHPEclipse for quite some time. I have used the Eclipse Java debugger and was impressed with how much debugging time it saved. However, when I tried to get the debugger working in PHPEclipse, I ran into some problems. This might have something to do with using the latest version of Eclipse, but I never spent the time to figure it all out. I had some spare time today, and decided to try out the Eclipse PHP IDE.

So I went over to the Zend site and downloaded the all-in-one package (keeps my PHPEclipse install safe) and the debugger extension (just followed the instructions in the readme). After a quick install of Subversive and a checkout of ANJEL, I was off to test the debugger.

ANJEL is an extension for Joomla so during development I run an Ant task to copy the files to the Joomla server directory for testing. There was an option to Publish files to server in the debug options, but no way to selectively publish the files (at least not that I could see). Since I don't want to copy all of the files over, I decided to go ahead and run the Ant task as I have been doing, but add the Joomla server directory as a PHP Project so I can add breakpoints and do some debugging. So far this works just fine.

I was able to get the breakpoints to work successfully, and I have to say I am very impressed with the PHP IDE. Some features that I have missed or not been able to get to work correctly in PHPEclipse are here. One of these is including projects in another project. I can add the Joomla project as a dependency of ANJEL and links (CTRL+click) in ANJEL source can take me to the Joomla code. It saves a lot of lookup time. You also get all the hover documentation along with it. Also, extended classes are shown directly in the file outline for quick access to inherited methods and properties.

There are still a few minor things missing from the configuration. The syntax highlighting is not as fine grained as I would like. There are not options for function or method highlight colors, etc. Also, the PHP file templates need a few more variables to be useful. For example, a file or path variable could help in automatic class naming for new files and documentation. The file templates also don't use the PHP editor like they do in PHPEclipse. This can be solved by writing the template in the editor and copying it, but it shouldn't be too hard to implement it.

One more big issue is the time required to build the “php model” on each start of Eclipse. It can take a lot of time depending on how big and how many projects are open. Hopefully as it matures, it will get better performance. Also, if you just leave Eclipse open, this won't be a problem.

As of right now, I would say the pros outweigh the cons, and I will probably be spending some development time with the PHP IDE in the future. And since we haven't even gotten to the 0.7 release yet (should be in February), I would expect this to become the Eclipse user's PHP IDE of choice, especially as the documentation for it becomes available.

PHP

Read or add comments to this article

Prototype-based programming in PHP

2006-11-06T21:33:22-06:00

For those who have been doing a lot of Javascript programming, you know what prototype-based programming is all about. The basic idea is that functions can be added to classes dynamically. In Javascript functions can be added to a static class (using prototype) and it will be added to all instances of the class, or they can be added to a specific instance and only be added to that instance.

Anyway, lets get to the point. I decided to try adding this functionality to PHP. I'm not sure why its a good idea, or if it even is, but I'll let you be the judge of that.

So here is the class I came up with:

/**
 * @copyright   (C) 2006, Schmalls / Joshua Thompson, All Rights Reserved
 * @license     http://www.opensource.org/licenses/bsd-license.php New BSD
 * @author      Joshua Thompson <spam.goes.in.here@gmail.com>
 * @version     1.0.0
 * @link        http://www.countercubed.com
 */
 
/**
 * This class holds the prototype capabilities
 * 
 * Extending this class makes it prototype capable
 */
class Prototype
{
    /**
     * Holds prototype functions
     * 
     * @var		array
     */
    private $_functions = array();
 
    /**
     * Default constructor
     * 
     * This is here so that php doesn't complain about the prototype function
     */
    public function __construct()
    {
    }
 
    /**
     * Sets the prototype functions or variables
     * 
     * @param   string $name
     * @param   mixed $value
     */
    public function __set( $name, $value )
    {
        if ( function_exists( $value ) ) :
            $this->_functions[$name] = $value;
        else :
            $this->$name = $value;
        endif;
    }
 
    /**
     * Gets static prototype variables if they exist
     * 
     * @param	string $name
     * @return	mixed
     */
    public function __get( $name )
    {
        if ( isset( $this->prototype()->$name ) ) :
            return $this->prototype()->$name;
        else :
            trigger_error( 'Undefined property: ' . __CLASS__ . '::' . $name, E_USER_NOTICE );
        endif;
    }
 
    /**
     * Calls a static prototype function
     * 
     * @param   string $name
     * @param   array $arguments
     * @return  mixed
     */
    public function __call( $name, $arguments )
    {
        if ( isset( $this->_functions[$name] ) ) :
            return call_user_func_array( $this->_functions[$name], $arguments );
        elseif ( $this->prototype()->isCallable( $name ) ) :
            return call_user_func_array( array( $this->prototype(), $name ), $arguments );
        else :
            trigger_error( 'Call to undefined method ' . __CLASS__ . '::' . $name . '()', E_USER_ERROR );
        endif;
    }
 
    /**
     * Returns the static prototype holder
     * 
     * @return	Prototype
     */
    public static function prototype()
    {
        static $prototype = null;
 
        if ( $prototype === null ) :
            $prototype = new Prototype();
        endif;
 
        return $prototype;
    }
 
    /**
     * Needed for the static calling functionality
     * 
     * @return	boolean
     */
    public function isCallable( $name )
    {
        return ( isset( $this->_functions[$name] ) );
    }
}

Now all a class needs to do is extend the Prototype class. A sample of its use follows:

// make some prototype classes
class Test1 extends Prototype
{
}
class Test2 extends Prototype
{
}
class Test3 extends Test1
{
}
 
// lets create some test static functions
Test1::prototype()->fun1 = create_function( '$arg1', '
	echo \'Static Test1::fun1 \' . $arg1 . "\n";
');
Test2::prototype()->fun2 = create_function( '$arg1', '
	echo \'Static Test2::fun2 \' . $arg1 . "\n";
');
// now instantiate the objects
$test1 = new Test1();
$test2 = new Test2();
// and make some more functions
$test1->fun3 = create_function( '$arg2', '
	echo \'Test1::fun3 \' . $arg2 . "\n";
');
$test2->fun4 = create_function( '$arg2', '
	echo \'Test2::fun4 \' . $arg2 . "\n";
');
// output: Static Test1::fun1 bob
$test1->fun1( 'bob' );
// create another function
Test1::prototype()->fun2 = create_function( '$arg1', '
	echo \'Static Test1::fun2 \' . $arg1 . "\n";
');
// output: Static Test1::fun2 bobby
$test1->fun2( 'bobby' );
// output: Static Test2::fun2 robert
$test2->fun2( 'robert' );
// output: Test1::fun3 robby
$test1->fun3( 'robby' );
// output: Test2::fun4 rob
$test2->fun4( 'rob' );
// another instance still has the static functions
$test1_2 = new Test1();
// output: Static Test1::fun1 bob
$test1_2->fun1( 'bob' );
 
$test3 = new Test3();
// this will give an error because prototype functions do not extend down to a child class
$test3->fun1( 'roberto' );

Once again, I don't know how useful it is, but let me know what you think.

PHP

Read or add comments to this article

Double Your DVD Collection

2006-02-14T08:55:34-06:00

I was having a conversation with my friend the other day when he suggested that the best thing about getting married was merging the two DVD collections. This was funny by itself, until my other friend gave his counter-argument of the other obvious benefits of being married. I won't give you the exact words, because it would make it less funny for me, and I believe it will be more humorous to you if you just imagine what he said.

Anyway, the conversation didn't end here. Then I said something about my DVD collection, and he said that it may be the reason I am single, because everyone knows that women are just looking for a guy with all the right DVDs. I thought about arguing against this, but then I realized the DVD collection is a perfect scapegoat for singleness. Just blame it on the DVD collection, not your other inadequacies. So for all the single people out there, its not your fault, its your DVD collection's.

Random Thoughts

Read or add comments to this article