# RESTful Philosophy

**URL:** <https://www.ruby-forum.com/t/restful-philosophy/141090>\
**Category:** Rails\
**Created:** [June 21, 2008, 11:31pm UTC](https://www.ruby-forum.com/t/restful-philosophy/141090 "2008-06-21T23:31:26Z")\
**Posts on this page:** 1\
**Page:** 1

<div class="post-metadata">

**Author:** ![smurfherder](https://www.ruby-forum.com/letter_avatar_proxy/v4/letter/s/a88e57/32.png) [@smurfherder](https://www.ruby-forum.com/u/smurfherder)\
**Post date:** [June 21, 2008, 11:31pm UTC](https://www.ruby-forum.com/t/restful-philosophy/141090/1 "2008-06-21T23:31:26Z")

</div>

So… a philosophical question about application organization and  
REST.

Generally speaking, all my models represent tangible, model-ish  
things. For such things, REST makes perfect sense to me, and the  
indications for how to implement using REST with Rails are very clear.

However, there are lots of things that are not very tangible, and seem  
to not be good REST candidates. For instance, if I have the  
equivalent of a druid or wizard or whatever, where I am sequentially  
collecting data necessary for some ultimate update, I would prefer to  
have several different actions, one for each step, rather than include  
state and checks for the same in a single action. Either way, though,  
I am outside of the normal REST magic 7 actions. In this case, the  
state is part of a single logical action that comprises several  
physical (for lack of a better name) actions. The variables that I am  
collecting along the way are in the session state.

I am not sure what is RESTful here or not.

The ultimate goal is to invoke a CREATE or UPDATE action at some point  
that changes state in a model. Assuming I don’t care if I lose  
anything along the way (dead druid?), then I need to use forms and  
POST actions to get the data from my forms to Rails. Of course, I  
shouldn’t do that, since POST’s are supposed to change things. But,  
the thing I am changing is not really part of the target model yet…  
see the issue?

Should I create a larger model that comprises a model for each state  
of the collection process, and then read from all those records once I  
am ready to do the ultimate update? Seems like having a model for  
each part is overkill.

Or, I could implement a state field that indicates if a record is  
“ready” or not. The first stage of the druid finds any records that  
are available to be used for creating a new record (timed-out sessions  
from previous attempts, records in a parallel, identical “buddy”  
table, etc.) and allocates it for use, the final stage updates it and  
removes it from the available pool by marking it as a full-fledged  
member of the table. This seems better, but essentially solves the  
problem by making the model “modal” (and illiterative!), which also  
seems not so very RESTful.

I supposed the base questions are these:

```
* Is it bad to have actions other than the magic 7 for RESTful

```

interfaces?  
\* Either way, is there a way to organize them (subclassing,  
proxies, etc.) that is considered clean? If so, what is it?  
\* How does organize multi-step behavior in a RESTful way? Has  
this already been solved, and are there plugins for modal models or  
wizard-like controllers that are considered RESTful?

I found acts\_as\_wizard, but it seems pretty old and is clearly not  
very RESTful.

Any ideas appreciated!

-ns