[ANN] Halcyon 0.5.0 Released!

[Matt Todd]

Halcyon version 0.5.0 has been released!

== DESCRIPTION

Halcyon is a framework for developing service-oriented applications.

== ANNOUNCEMENT

Halcyon has gone through a major refactoring: the codebase has been
completely restructured and developed from scratch. Halcyon apps
behave much more like applications and the framework has separated
itself completely from the server domain.

== EVOLUTION

The 0.4.0 branch had numerous design and implementation deficiencies,
mainly due to a lack of experience and understanding on my part.
Putting applications into production has revealed numerous flaws and
prompted a complete rewrite, which is where Halcyon 0.5.0 has come
from.

Not only are Halcyon applications more app-like than previously,
Halcyon itself has matured and separated itself from any type of
server-specific functionality which Rack's handlers and the servers
themselves are far more capable of handling.

In addition to these changes, applications look more app-like with a
proper implementation of an MVC pattern (though the view is still just
JSON responses and the models are not explicitly factored in by
default).

I'm really proud to announce this iteration of Halcyon and can only
see great improvement hereon!

== CHANGES

* major refactor, completely incompatible with 0.4.0 applications
* new application-centric structure and design [#13 resolved]
* remove coupled server code, completely Rack-based
* full Rack handler support (Thin/Mongrel/etc), daemonization [#12 resolved]
* application structure split into controllers [#17 resolved]
* application initialize improved greatly, structured
* new configurable attributes with config hooks [#31 resolved]
* configurable paths [#33 resolved]
* new commandline interface for application tasks
* new application generation from commandline
* able to run application interactively in IRB shell [#18 resolved]
* logging configuration improved, more loggers supported [#4 resolved]
* added JavaScript, PHP, and Java clients [#27 resolved]
* enhanced debugging output [#15 resolved]
* fixed changed merb/core_ext dependencies [#16 resolved]
* DateTime et al return ISO 8601 format for to_json [#19 resolved/deferred]
* much improved documentation, API and otherwise [#7 resolved]
* generated applications include better inline documentation [#21 resolved]
* improved specs with more thorough testing [#2 resolved]
* new examples [#23 resolved]
* app init can specify to initialize new Git repo for new app [#25 resolved]
* fixed bug with interactive shell not loading the correct paths [#39 resolved]
* extended status codes to provide more extensive errors/states

== SYNOPSIS

A great example of an SOA is the Twitter API service, accessed via
sending requests to URLs and parsing the data returned. Halcyon
utilizes the widely used HTTP protocol and JSON format for handling
requests and responses, making its overall footprint light and sending
complex data trivial.

Halcyon is built on top of Rack which means it can be folded into
existing Rack application stacks, can be run on any kind of server
supported (including Thin, Mongrel, etc), and provides a great deal of
flexibility for injecting functionality.

Several example applications exist within the repository. Check them
out at http://github.com/mtodd/halcyon/tree/master/examples/.

== INSTALLATION

Halcyon can be installed with RubyGems with:

$ sudo gem install halcyon

The latest development gem can be downloaded from with:

$ sudo gem install halcyon --source=http://halcyon.rubyforge.org/latest/

If you're feeling adventurous, you can also clone the repository and
install directly from the Rake task:

$ git clone git://github.com/mtodd/halcyon.git
$ cd halcyon; rake install

NOTE: Because of platform limitations with dependencies, Halcyon by
default only ensures that the JSON pure-Ruby variant is installed. To
install the faster C-based extension, try:

$ sudo gem install json

== DOCUMENTATION

Halcyon has been under a complete overhaul of its documentation (and
is still being worked on). New articles have been written for getting
started, writing controllers, defining routes, etc, and even more
advanced topics have been touched on (or are planned), such as
integrating databases into the development of your application as well
as taking full advantage of the Rack features.

Check out the documentation at http://halcyon.rubyforge.org/docs/

== LICENSE

Halcyon is licensed under the MIT License.

 

[George Malamidis]

Hi,

Does anyone know if there's a hook, or other means for capturing the
methods added to an instance when the instance extends a module? I'm
looking for something similar to Object#singleton_method_added, but
for the following scenario:

module Bar
def whatever;end
end

foo = Foo.new
foo.extend(Bar)

(Capture the addition of "whatever")

Thanks,
George

 

[Pit Capitain]

Does anyone know if there's a hook, or other means for capturing the methods
added to an instance when the instance extends a module? (...)

None that I know. There's the Module#extended hook:

module Bar
def whatever;end
def self.extended(obj)
p obj, self, instance_methods
end
end

foo = Foo.new
foo.extend(Bar)

which give the following output:

#<Foo:0x2aea054>
Bar
["whatever"]

But I suppose you want it the other way round and define this behavior
on the class Foo or on one of its instances. If so, you could simply
override the Object#extend method:

class Foo
def extend(mod)
super
p self, mod, mod.instance_methods
end
end

which gives the same output as above.

Regards,
Pit