Hi --

On Sat, 29 Nov 2008, Adam Akhtar wrote:

> Ive created a simple todo list app for the console and tried to
> implement mvc using my very very very limited mvc knowledge. In the app
> users can create single tasks. they can also group tasks with a similiar
> theme together into a project. I thought id learn more about mvc and oop
> than just reading or using some framework.
>
> So i have two basic class definitions
>
> class Project_controller
> class Task_controller
>
> Ive added basic CRUD functionality to them. But now they need to
> interact with one anohter in a few situations. For example, when a user
> wants to delete a project they might also want to delete the associated
> tasks with that project. So in project_controller.delete() I want to be
> able to access the task objects delete method. I thought about passing
> the object itself as a parameter e.g
>
> class Project_controller
> def delete a_task_controller
> #blah blah blah
> #user says yes delete the associated tasks
> a_task_controller.delete
> end
>
> but that doesnt seem pratical because if i start adding other
> controllers such as say "Category" i could end up with a huge parameter
> list
>
> I then thought about using initialize like this
>
> class Project_controller
> def initialize a_task_controller
> @a_task_controller = a_task_controller
> end
> end
>
> but then ill also need to do the same with Task_controller and that will
> lead to a run error due to the ole what comes first the chicken or the
> egg.
>
> task_cntr = Task_controller.new (proj_cntr) #proj_cntr doesnt exist yet
> so boom!
> proj_cntr = Project_controller.new (task_cntr) #this is ok though
>
> Whats teh best way of doing this, is there a way i make all controller
> objects be able to access other controllers methods? Is the observer
> pattern useful here? Ive never used it but know a bit about it.

It looks like you're trying to accomplish the M part of MVC in the C
part. You should think about having not just controller classes, but a
Task class and a Project class. The Task and Project objects would
have knowledge of their relation (a task is part of a project, etc.),
so that when you delete a project, it can delete the tasks that were
part of it.

The controllers should just be firing off the high-level commands,
like telling a project to die. What happens when a project dies is
really in the purview of the Project object itself.


David

-- 
Rails training from David A. Black and Ruby Power and Light:
INTRO TO RAILS (Jan 12-15) | ADVANCING WITH RAILS (Jan 19-22) *
Both in Fort Lauderdale, FL      * Co-taught with Patrick Ewing
See http://www.rubypal.com for details
Coming in 2009: The Well-Grounded Rubyist (http://manning.com/black2)