*0.3.2b*

* Small fixes.

* Refactored JS code.

* HTTP persistent connections are currently disabled.

* Refactored thread spawning in HTTP::Server for simplicity and performance. The server now limits the total amount of (green) threads in the process to 100. Any further requests are blocked until previous threads are done or reaped.

* Refactored Postgres::Dataset code to use row converters as Proc objects rather then redefine a convert_row method.

* Implemented custom time stamp parsing code in String#postgres_to_time. Time.parse apparently leaks memory for some reason.

* Renamed Dataset#hash and Model.hash to hash_column.

* Added Database.connect method for creating database instances from connection strings.

* Refactored HTTP::Connection into HTTP::Server. Removed deprecated http/connection.rb.

* Solved some more memory leaks and dead thread issues.

* Added thread reaping to HTTP::Server.

* Added logging facility.

* Renamed lib/serverside/json.rb to lib/serverside/js.rb.

* Rewrote method_missing for both JSON and XML classes. Turns out it's a problem to meta_def method which take blocks. Cargo-cult programming.

* Deprecated use of instance_eval in XML builder.

* Fixed nasty bug in ConnectionPool#release that caused a serious memory leak (and possibly a segmentation fault?).

* Improved Database#create_table to also accept a block for defining tables using the schema DSL.

* Wrapped Postgres result.clear in ensure for better error handling.

* Changed Template to use Erubis instead of ERB.

* Rewrote large parts of ConnectionPool. Now it works properly.

* Major refactoring to Postgres code. Now using PGconn#async_exec to allow multithreaded apps.

* Fixed Model.create to wrap record creation in a transaction.

* Added HTTP::Caching.cache method.

* Moved Static under ServerSide::HTTP module.

* Added MIME type for .ico files.

* Fixed rake doc task to cover all source files in lib.

* Added Process.exists? method to check if a process is alive.

* Added Model.each method.

* Fixed fetching of SQLite records using model instances.

*0.3.2a*

* Implemented SQLite adapter.

* Moved Postgres classes into ServerSide module.

* Removed Kernel.backtrace. Deprecated...

* Fixed exception in Daemon.stop if the daemon process is not running.

* Removed pathname conversion from String#camelize.

* Removed Symbol#to_s override.

* Re-enabled daemon spec testing.

* Renamed JSON to JS, and rewrote large parts thereof. Instead of the magic of instance_eval we now just pass self to the block.

* Fixed bug in PGconn#transaction.

* Rewrote connection pool code to actually work, duh.

* Refactored transaction support in Postgres adapter.

* Added JSON renderer.

* Fixed small bug where Postgres::Dataset#result_first returned @result instead of nil when the query result is empty.

* Fixed a small bug in postgres row fetcher compiler that prevented Postgres::Dataset#explain from working.

* Fixed Model.filter to work with any number of arguments.

* Added Model#map and Model#hash methods.

* Implemented Dataset#hash method for creating a hash out of a dataset using two columns (key and value).

* Added HTTP::Request#render_template method.

* Added String#camelize method.

* Added HTTP::StaticServer class for serving static files only.

* Refactored Postgres::Dataset row fetcher code.

* Refactored Dataset#where and Dataset#select_sql for slightly better performance.

* Added Model#== method for comparing records.

* Fixed bug in schema where default values would not be included in column definition if they were null or false.

* Refactored value list expression in Postgres adapter.

* Added support for boolean and timestamp columns in Postgres adapter.

* Added Model#model method to get the model's class.

* Changed Schema.drop_table_sql to use DROP <table> CASCADE.

* Fixed Postgres::Dataset#where_equal_condition to construct (NULL) subquery for empty arrays.

* Added Model.lock method.

* Fixed Model.one_to_many to accept :table option or use the relation name as default.

* Fixed Model#delete_all to delete each record separately only when before_delete hooks are defined.

* Fixed behavior of filter to be additive for hashes.

* Added support for <column> IN (<list>) syntax notation for arrays of values.

* Added Dataset#min and Dataset#max aggregate methods.

* Added Dataset#insert and Model.create with default (no) values.

* Added table option to one_to_one and one_to_many. This allows relations without defining custom classes.

* Added order option to one_to_many construct.

* Fixed Dataset#count when order is specified.

* Added Model#refresh and Model#exists? methods.

* Fixed Postgres row fetcher to return nil values correctly.

* Added Database#create_table, drop_table and table_exists? methods. Implemented Postgres#table_exists?.

* Added Schema#create and Schema#drop methods.

* Added Schema::Generator#create_sql drop_sql methods.

* Added Schema::Generator#foreign_key construct.

* Refactored Schema slightly to allow Schema instances that make sense.

* Removed Model.schemas - schema should be unrelated.

* Added foreign key support in Schema.

* Changed Postgres#synchronize to acquire connection from connection pool, and be re-entrant.

* Refactored Postgres to use ConnectionPool.

* Implemented ConnectionPool class.

* Refactored Postgres#connected? into PGconn.

* Fixed Postgres::Database#transaction for re-entrancy.

* Renamed Model.database to Model.db.

* Fixed Model.one_to_many construct.

* Added before_delete and after_create hooks.

* Fixed Postgres spec.

* Added PGconn.quote method implementation for pure-ruby postgres adapter.

* Added Postgres.tables to query existing tables.

* Added filter_by_XXX and fixed find_by_XXX methods.

* Added Model.schemas and Model.recreate_schemas.

* Fixed Model.recreate_table.

* Added Postgres literal respresentation for Time objects (as float). 

* Fixed schema generation and added Model.recreate_table.

* Better integration of Schema generator with Model.

* Refactored postgres select code and wrapped db calls with db.synchronize.

* Added true.to_i and false.to_i methods (these will be used by Dataset#literal.)

* Added ServerSide::Model method, so one can do class node < ServerSide::Model(:nodes).

* Refactored Postgres::Dataset#select.

* Added Postgres::Dataset#for_update and for_share methods.

* Added XML generator.

* Added schema generation code.

* Fixed Dataset#map to return array of field values if no block specified.

* Added support for filtering using regular expressions in postgres dataset.

* Added Postgres::Dataset#explain method.

* Added Postgres::Dataset#lock method.

* Added support for SELECT FOR UPDATE and SELECT FOR SHARE in postgres dataset.

* Added db/console.rb example.

* Removed join clause from delete and update sql methods.

* Added db/threads.rb example.

* Added examples directory.

* Refactored postgres code for better performance.

* Added join capabilities.

* Implemented ServerSide::Model class.

* Implemented Postgres::Dataset class.

* Added Dataset class.

* Added Postgres::Database class.

* Added basic functionality for ServerSide::Database class, and created lib/db directory for database-related code.

* Fixed bug in HTTP::Caching.expiry_tag - the expiration stamp was incorrect (based off stamp instead of Time.now.)

* Added documentation for http/caching.rb.

* Moved HTTP-related code to lib/http.

*0.3.1*

* Removed application.rb file and fixed serverside script.

* Fixed bug in Caching.validate_stamp where the expiry stamp would be the file stamp + max_age - leading to stale resources.

*0.3.0*

* Disabled cluster_spec and parts of daemon_spec for now due to strange forking behavior.

* Removed static file cache from Static.

* Fixed daemon_spec to work correctly.

* Removed all tests, moved specs to /spec, and fixed rakefile.

* Converted cluster_test to cluster_spec.

* Converted daemon_test to daemon_spec.

* Updated specs to work with RSpec 0.7.

* Changed rake spec task to do coverage as well.

* Renamed controller.rb to controllers.rb.

* Added String.underscore method.

* Renamed ServerSide::Controller.process to response.

* Improved HTTP caching code to better conform to the HTTP spec. Also improved the validate_cache method to work without a block as well.

* Removed unit tests that were converted to specs.

* Router now expects handlers to return non-nil if the request was handled. Otherwise, the request goes to the next handler with an appropriate rule.

* Improved spec coverage for caching.

* Wrote Server spec.

* Wrote Router spec.

* Refactored HTTP::Server to allow creating instances without starting them.

* Fixed Router.routes_defined? to return non-nil if default route is defined.

* Renamed Router.has_routes? to routes_defined?.

* Fixed Static.serve_template and Static.serve_static to work correctly (render templates.)

* Removed deprecated code in Template.render.

* Wrote Static spec.

* Fixed bug in serverside script - wrong call to route_default instead of default_route.

* Refactored ServerSide::Template and wrote template spec.

* Added documentation to Controller.

* Fixed Controller.mount to build a self.inherited method, and do the routing there.

==0.2.9

* Improved rake clean task.

* Added HTTP::Request.send_file method.

* Added basic rendering capabilities to ServerSide::Controller.

* Added support for lambda rules in ServerSide::Controller.mount.

* Start work on controller class.

* Renamed Router.route_default to default_route.

* Fixed small errors in documentation.

* Changed ServerSide::Static.serve_static to look for index.html inside directory before serving the directory.

* Added HTTP::Caching.cache_etags and cache_stamp methods.

* Fixed bug in doc_rforge rake task.

* Rewrote request unit test into request spec.

==0.2.8

* Refactored ServerSide::Static to use HTTP::Caching code.

* Added spec coverage rake task.

* Added HTTP::Caching module.

* Added response_headers attribute to HTTP::Request.

* Refactored ServerSide::Static constants.

* Renamed ServerSide::StaticFiles to ServerSide::Static.

* Added static_server.rb script.

==0.2.7

* Wrote spec for HTTP::Connection.

* Added spec files to rake stats reporting.

* Changed @conn to @socket in both HTTP::Connection and HTTP::Request for better readability.

* Wrote functional test for request body (but at least some of the testing should be in a unit test.)

* Added request body parsing (both URL-encoded and multipart.)

* Moved all HTTP::Const constants into HTTP::Request.

* Added Date to response headers. This is needed for caching to work correctly.

* Fixed bug in serverside script that caused an exception when specifying port number.

==0.2.6

* Refactored HTTP-related code into a new HTTP::Request class and a simplified HTTP::Connection.

* Another small change to docs.

* Fixed small error in Rakefile that prevented doc_rforge task from updating the docs.

* Fixed minor documentation error.

==0.2.5

* Added template serving to static file module.

* Wrote a simple ERB template system.

* More documentation tweaks.

* Changed how response cookies are formatted for somewhat better performance.

* Updated documentation.

* Removed deprecated code in lib/serverside/application.rb.

* Added HTTP cookie functionality (parse, set and delete.)

* Updated rakefile to include a spec task, as well as an rcov task. Updated test task to include spec and rcov tasks.

* Started writing RSpec tests. This looks like a very interesting concept.

* Added /test/spec directory.

==0.2.0

* Updated RFuzz script to work, but it doesn't still do anything interesting.

* Added a serve command to serverside script.

* Changed substition of embedded parameters from (.*) to (.+).

* Added rule compilation after setting the default handler.

* Added doc_rforge rake task (for updating the docs on rubyforge.org).

* Added stats and svn_add rake tasks.

* Fixed routing unit tests.

* Added Router.has_routes? method.

* Finished unit tests for routing.

* Added Connection::Base.redirect.

* Added routing code from /research/routing, implemented functional test.

* Learned about the (?:) modifier and fixed the request parsing regexp.

* Added a profiled version of a static server - /test/functional/static_profile.rb.

* Added freezing of HTTP headers.

* Small change to documentation.
 
* Changed filename for cluster pid file to serverside_cluster.pid.

* Added documentation.

* Fixed require in serverside script to load the gem.

* Fixed the Daemon pid file for static file server mode.

* Added directory listing to static file server.

* Fixed request header parsing Regexp so a trailing slash would be ignored. 

* Added static application. Using the binary script in static mode works.

* Added cluster class with unit tests.

* Added unit tests for static server.

* Added static server functional test.

* Added static file serving code.

* Renamed ServerSide::Request to ServerSide::Connection. This is more appropriate.

* Added functional static server test.

* Added test/functional for functional tests. Updated Rakefile.

* Added Request.send_response and stream.

* Added faster Symbol.to_s to core_ext.

* Added HTTP parsing code with unit tests.

* More unit tests for application code.

* Basic server code works with unit tests.

* Added option parsing to serverside script.

* Added daemon code and unit tests.

==0.1

* Added host attribute to Controller::Request.

* Added ability to create rules on any request attribute, not just path.

* Added ability to mount controllers with a block for a rule.

* Wrote object extensions to create frozen constants on the fly.

* Changed DirHandler to use frozen strings for cache header.

* Hooked Mongrel server to Controller::Router.

* Imported request code with unit tests.

* Wrote unit tests for daemon module.

* Wrote unit tests for controller routing code.

* Refactored controller routing code.

* Imported unit tests for extensions.

* Created Rakefile.

* Prototypical routing code.

* Fixed location of daemon pid files.

* Imported Mongrel code from Reality project.

* Imported extensions from Reality project.

* Implemented daemon and server cluster.