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.












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 froogle.com".

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.

like

class project_controller
def delete
#choose project to delete
project_to_delete = users_choice()
#now display the associated tasks with this project
task_controller_object.display_tasks_for_project(project_to_delete)
#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
task_controller_object.delete(all_tasks_associated_with_this_project)
...
...
blah blah blah
end
-- 
Posted via http://www.ruby-forum.com/.