ramaze 0.1.0 → 0.1.1

data/doc/README

@@ -49,6 +49,11 @@ Ramaze offers following features at the moment:
       CGI is the Common Gateway Interface and is one of the most basic ways
       to integrate into Webservers like Apache, Lighttpd or Nginx.
 
+    * FCGI
+
+      Improvment of CGI as it doesn't start up a new connection to Ramaze on
+      every request.
+
 
 * Templates
   * [Amrita2](http://amrita2.rubyforge.org/)
@@ -69,13 +74,18 @@ Ramaze offers following features at the moment:
     Liquid's syntax and parse model are inspired by Django templates, as well
     as PHP's smarty.
 
+  * [Remarkably](http://rubyforge.org/projects/remarkably)
+
+    Remarkably is a very tiny Markaby-like XML builder
+
   * [Markaby](http://code.whytheluckystiff.net/markaby/)
 
     Markaby means Markup as Ruby.
 
   * Ezamar
 
-    A simple homage to [Nitro](http://nitroproject.org)s templating.
+    A simple homage to [Nitro](http://nitroproject.org)s templating, is shipped
+    together with Ramaze.
 
 * Cache
   * Hash
@@ -83,22 +93,81 @@ Ramaze offers following features at the moment:
   * MemCache
 
 * Helper
-  * Aspect
-  * Auth
-  * Cache
-  * Feed
-  * Flash
-  * Form
-  * Link
-  * OpenID
-  * Redirect
-  * Stack
+  * Active by default 
+    * CGI
+
+      Shortcuts for escape/unescape of the CGI module.
+
+    * File
+
+      Helps you serving files from your Controller.
+
+    * Flash
+
+      Store a couple of values for one request associated with a session.
+
+    * Link
+
+      Easier linking to the various parts of your applications Controllers and
+      Actions.
+
+    * Redirect
+
+      Easy redirection.
+
+  * Optional
+    * Aspect
+
+      Allows you to wrap different Actions on your Controller with code.
+
+    * Auth
+
+      Simple way to add basic authentication.
+
+    * Cache
+
+      Easy caching Actions and values.
+
+    * Feed
+
+      Programmatically generate feeds from any Class.
+
+    * Form
+
+      In development, help appreciated.
+
+    * Identity
+
+      For ease of use of the OpenID authentication mechanism.
+
+    * Inform
+
+      Wrapping the functionality of Ramazes logging facilities.
+
+    * Markaby
+
+      Allows you to use Markaby in your Controller without having it as the
+      default templating engine.
+
+    * Nitroform
+
+      Hooks up on nitros form builder to help you creating forms from Og
+      objects.
+
+    * OpenID
+
+      Authentication via OpenID made easy.
+
+    * Stack
+
+      Allows you to use a call/answer mechanism for things like redirection to the
+      site a user entered login-forms from.
 
 * Various
   * Sessions
   * Global configuration system
   * Simple request/response handling
-  * Custom Error-handling
+  * Custom sophisticated Error-handling
 
 
 = Basic Principles
@@ -170,7 +239,6 @@ There are some basic principles that Ramaze tries to follow:
     $ gem install ramaze
 
   in case you have RubyGems installed.
-  (this will work as soon as I have registered on RubyForge ;)
 
 
 * via darcs

data/doc/meta/announcement.txt

@@ -1,17 +1,62 @@
-This is a one-time post to announce the creation of the Ramaze project, an open
-source web framework with the aim to be light and modular.
-Ramaze is already relatively stable and we decided that it is time to give it
-broader exposure to find new users and contributors.
+This time we are proud to announce Version 0.1.2 of the Ramaze framework, an
+open source web framework with the aim to be light and modular.
+
+Since the 0.1.0 release we have made a lot of progress and the overall API has
+mostly settled down. An extensive set of tests is covering almost every detail
+of the implementation and usage.
+
+It is developed by by several people and already in production-use at some
+companies.
+
 
 Home page: http://ramaze.rubyforge.org
 IRC: #ramaze on irc.freenode.net
 
+
+New Features in Version 0.1.2: ( review and remove unimportant stuff )
+
+ - Restructuring of Ramaze internals, featuring a cleaner overall layout.
+
+ - Add Ramaze::Record to easily record requests fitting particular patterns.
+
+ - Support for the Remarkably templating engine.
+
+ - Adapted for Rack 0.2
+
+ - Easier caching.
+
+ - replacing autoreload with the almighty SourceReload.
+
+ - tiny DSL for settings.
+
+ - Global is now a Struct, no OpenStruct.
+
+ - Default logger is now LogHub with Inform
+
+ - Lightweight error-page.
+
+ - Central API for caches.
+
+ - Reviewed and largely improved tutorial and examples.
+
+ - Even less patches to the Ruby core, mostly for compatibility with the
+   upcoming Ruby 1.9 and tested with older versions down to 1.8.2.
+
+ - Largely improved Spec-framework for any kind of web-application.
+
+ - Through some benchmarking and refactoring the overall speed has improved
+   around the factor 2.
+
+A complete Changelog is available at [ insert URL ]
+
+
 Features:
   - Builds on top of the recently released Rack library, which provides easy use
     of adapters like Mongrel, WEBrick, CGI or FCGI.
 
   - Supports a wide range of templating-engines like:
-      Amrita2, Erubis, HAML, Liquid, Markaby and its own engine called Ezamar.
+      Amrita2, Erubis, HAML, Liquid, Markaby, Remarkably and its own engine
+      called Ezamar.
 
   - Highly modular structure, you can just use the parts you like. This also
       means that it's very simple to add your own customizations.
@@ -36,9 +81,7 @@ Features planned:
   - Unified FormHelper for ORMs, making the framework mostly independent of the
       underlying model.
 
-  - Improved configuration system, providing an way to totally change options
-      during runtime and link that with the CLI-parameter automatically.
-
+  - Support for distributed deployment over DRb.
 
 For more information please come to http://ramaze.rubyforge.org or ask directly
 on IRC (irc://irc.freenode.net/#ramaze)

data/doc/meta/configuration.txt

@@ -6,10 +6,8 @@ This chapter covers how to do configuration in Ramaze for your application.
 The object holding most configuration is called Global. It resides in the Ramaze
 module/name space.
 
-Global is a subclass of OpenStruct and behaves mostly like it, so you can assign
-your own key/value pairs to do your own configuration. Just ensure you don't
-change key/value pairs by accident that Ramaze itself uses (doing it intentional
-is OK of course).
+Global is an instance of GlobalStruct, which itself is an instance of Struct.
+There have been some changes to it to suit its purpose.
 
 Before covering some of the available options let us see how to actually use it.
 
@@ -20,17 +18,15 @@ Global with Ramaze so it is written Ramaze::Global.
 
 #### Basic assignment:
 
-  Global.ports = (7000..7010)
+  Global.spawn = 10
 
-if you do that before calling Ramaze::start Ramaze will spawn one server on each
-port in that Range. The first value of this Range is also assigned to
-Global.port during the startup procedure.
+if you do that before calling Ramaze::start Ramaze will spawn the given number of servers.
 
 
 #### Multiple assignment:
 
   Global.setup :adapter => :mongrel,
-               :cache   => MemcachedCache
+               :cache   => :memcached
 
 So you can pass a Hash of all the options you want to change.
 In this case you would use Mongrel as the adapter and use memcached for your
@@ -61,24 +57,24 @@ useful to quickly test some configuration.
 
 ### Global options
 
-Since this document is especially prone to be outdated at times make sure you
-check lib/ramaze/global.rb in case you run into trouble, we will try to keep at
-least the RDocs up to date. This update is from 2007/04/16.
-
 This listing is here to provide you with descriptions of the most common
 configurations in alphabetical order per section showing the default value next
 to the key.
 
+This chapter has been shrunk a lot to cover only essentials, please look at
+lib/ramaze/global.rb to see all available options.
+
+Date of last update: 2007-05-20
 
 #### General Configuration:
 
-:autoreload => 5
+:sourcereload => 3
 
-Autoreload is a nifty mechanism that takes advantage of the dynamics of Ruby,
+SourceReload is a nifty mechanism that takes advantage of the dynamics of Ruby,
 it's basically a Thread that runs in the background and polls for files in the
 application and framework that have changed (using mtime). The value specifies
-roughly how fast your changes are going to be loaded and should be a usual
-Fixnum.
+roughly how fast your changes are going to be loaded and should be a number.
+If you set this to false, it will not start.
 
 
 :adapter => :webrick
@@ -91,19 +87,13 @@ additional libraries to be installed, webrick and cgi run out of the box.
 Generally the most supported and recommended for deployment is Mongrel.
 
 
-:backtrace_size => 10
-
-This option doesn't have a large impact and is most likely left on its default
-value, it controls how long the backtrace shown in your log and on the error
-page should be.
-
-
-:cache => MemoryCache
+:cache => :memory
 
+Possible: :memory, :memcached, :yaml
 The cache is one of the more important things for deployment, the default for
 this is MemoryCache, a simple Hash.
-The class you specify here is used throughout Ramaze to cache various things,
-like sessions, page- and value-caching.
+What you specify here will be used by Ramaze::Cache and is used throughout
+Ramaze to cache various things, like sessions, page- and value-caching.
 Included in Ramaze are the MemoryCache and YAMLStoreCache, after you install
 'memcached' you can also use the much more performant MemcachedCache that also
 makes it easy to use the same cache between different applications (sharing
@@ -140,13 +130,6 @@ Tell the adapter where it accepts requests from, 0.0.0.0 says that every
 IP will be accepted, 127.0.0.1 would accept only requests from loopback.
 
 
-:logger => Ramaze::Informer
-
-The logger is used during startup to set Ramaze::Inform, you may set this
-to Ramaze::Syslog or in case you have 'analogger' installed, you can use
- Ramaze::Analogger.
-
-
 :mapping => {}
 
 This is a very central and special setting, it contains key/value pairs

data/doc/meta/internals.txt

@@ -18,10 +18,40 @@ limitations and features are.
 Ramaze is also the main module or so-called namespace that the framework lives
 in. It has 
 
-startup
-shutdown
-initial tasks
-exiting tasks
+Tasks on require
+
+* Inform
+  * LogHub.new(Informer)
+* Global
+  * GlobalStruct.new
+
+
+Tasks on startup
+
+* Global.startup
+  * passed options to Ramaze.start
+  * CLI options from bin/ramaze (treat as passed.merge)
+  * Global options set before startup (fake Global?)
+
+* Controller.startup
+  * mapping of all subclassed Controller
+  * validation of mapping
+  * validation of template_root
+
+* Adapter.startup
+  * interpret Global.adapter
+  * add every created adapter to Global.adapters
+
+* SourceReload.startup
+  * start with Global.reload_interval
+  * assign Global.sourcereload
+
+
+Tasks on shutdown
+
+* Adapter.shutdown (iterates Global.adapters)
+* Inform.shutdown (iterates all in LogHub)
+
 
 
 #### Global configuration

data/doc/migrate/1110_to_1111.txt

@@ -0,0 +1,131 @@
+= Explanation of the changes of patch 1110-1111
+
+What this patch is all about.
+Due to a general cleanup and preparation for further extension there has been a
+lot of moving of code into more appropriate positions.
+Another goal was the reimplementation of Global, away from OpenStruct to the
+faster Struct.
+Some smaller improvments will follow on both areas, but as with the last
+Controller refactoring, this aimed to be finished as soon as possible to get
+Ramaze bulletproof again before the next release.
+
+
+== Ramaze
+=== What happened to the module
+
+The whole module has now only two methods, :startup and :shutdown
+
+startup sends .startup to the classes in
+Ramaze.trait[:essentials]
+shutdown sends .shutdown to these classes.
+
+Other methods changed:
+
+force_start
+  removed -> not used anywhere and easily done with a passed option.
+
+execute
+  removed -> there may be a replacement coming though.
+
+kill_threads
+  delegated -> this is handled over the shutdown of the responsible classes now.
+
+setup_controllers
+  delegated -> has been moved to Controller::startup
+
+init_sourcereload
+  delegated -> moved to SourceReload::startup
+
+init_global
+  delegated -> moved to Global::startup
+
+init_adapter, run_adapter, test_connections, connection_possible
+  delegated -> moved to Adapter::startup
+
+require_adapter
+  delegated -> is now the mask Global.adapter
+
+parse_port
+  delegated -> is now the mask Global.ports
+
+
+== Global
+=== New functionality and layout
+
+Global is now a Struct instead of an OpenStruct, which means two things:
+The general API is hardened now, assigning new accessors is not as simple as
+just setting them via method_missing anymore.
+The GlobalStruct::DEFAULT hash defines what contents the Struct has.
+This has on one hand a improved performance, on the other hand it unifies the
+API for further versions, collecting the setting of Global accessors into one
+place.
+We could add method_missing in further revisions if need arises.
+The other important improvement is the masking of internals of Global. This means
+that we can now define a method over the internal value and present something
+different than it actually contains. Also hooks on setting a value are now
+possible.
+
+Controller.trait[:ramaze_public] has moved here as Global.public_root to match
+the Controller.public_root setting.
+
+
+== Controller
+=== template_root and public_root
+
+These are no traits anymore. Now the resolution of templates should be a little
+bit faster, but more importantly they will give you a warning when setting a
+path that does not exist.
+To remove the 'self.' boilerplate they take an optional argument and act as
+getter only if no argument is given.
+
+
+== Cache
+=== Unified API for new Caches
+
+We now take advantage of the ages-old idea of having a unified Ramaze::Cache to
+spawn new instances of caches instead of relying on Global.cache.new which posed
+many problems with configuring them.
+To retrieve a new cache, simply use Cache.new now, setting Global.cache will
+define which class is used for this. You can set strings/symbols like :memory,
+:memcached or :yaml.
+
+Cache also specifies a unified API, at the moment consisting of:
+#[](key), #[]=(key, value), #clear, #delete(*keys)
+
+To make interacting easier, all keys are stored/retrieved as strings
+automatically so you can use either symbols or strings to access values.
+
+
+== Adapter
+=== Adapter::( startup | shutdown )
+
+The stuff from Ramaze has moved here, it basically still works the same way.
+However, we are now wrapping less threads around one adapter, which may or may
+not affect performance.
+
+
+== Request
+=== Outsourcing of methods to Rack
+
+Following methods have been moved to the latest version of Rack:
+#fullpath #[](key), #[]=(key, value), #values_at(*keys), #referer/#referer
+
+=== Change from module to subclass
+
+== Response
+=== Change from module to subclass
+
+Same as Request
+
+
+== STATUS_CODE
+=== Usage of Rack::Utils::HTTP_STATUS_CODES
+
+We are now using the hash from Rack, assigned to Ramaze::STATUS_CODE and have
+removed ramaze/http_status.rb
+The major change is that the keys are now strings like
+"Not Found" or "Internal Server Error". Most of the time guessing will work.
+
+
+== Informing
+=== Added #debug? for WEBrick, set to false.