Forum: Ruby accessing one objects methods from within another object

Announcement (2017-05-07): is now read-only since I unfortunately do not have the time to support and maintain the forum any more. Please see and for other Rails- und Ruby-related community platforms.
Adam A. (Guest)
on 2008-11-29 07:44
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

but that doesnt seem pratical because if i start adding other
controllers such as say "Category" i could end up with a huge parameter

I then thought about using initialize like this

class Project_controller
def initialize a_task_controller
@a_task_controller = a_task_controller

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

task_cntr = (proj_cntr) #proj_cntr doesnt exist yet
so boom!
proj_cntr = (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.

Sorry if the titles vague. Im trying to develop a simple todo list
console app and decided to try and use mvc principles with what limited
knowledge of mvc i have.

in the apps a user can define projects such as "Buy a new PC" and then
assign new tasks to this project such as "Research Anandtech for best
value parts", "find cheapest price of parts on".

Hence i have a projects controller class and a tasks controller class.
At the moment they are defined as seperate classes but i can see now
that they could inheirt from an abstract parent "Controller" class but
at the time i didnt know what the common code would be as im a newb.

Alls gone well as i created pretty much each respective items basic CRUD
code and they didnt interact. However when it comes to deleting a
project i realised that the user should be able to decide if they want
to delete the tasks associated with it as well. I dont want to copy and
paste my delete code from my tasks controller over the project
controller as its duplication and contradicts oop.

I want to be able to do just call the task controller objects delete
method from within the project controller objects delete method.


class project_controller
def delete
#choose project to delete
project_to_delete = users_choice()
#now display the associated tasks with this project
#find out if user wants to delete tasks as well..
user_wants_to_delete = get_response()
if user_wants_to_delete == true
#use the task cntr object once again to do its own dirty work
blah blah blah
Adam A. (Guest)
on 2008-11-29 07:45
sorry the bottom part of that mail was a previous version of my message,
forgot to delete it
David A. Black (Guest)
on 2008-11-29 09:34
(Received via mailing list)
Hi --

On Sat, 29 Nov 2008, Adam A. wrote:

> #user says yes delete the associated tasks
> def initialize a_task_controller
> proj_cntr = (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.

This topic is locked and can not be replied to.