Hi Massimo, I have here an editable version of the document which I will translate to Portuguese soon, if you want to catch:
https://docs.google.com/document/edit?id=14jfi7HUf-F41N6HHvqx87S3GTHQNku_q75RdySsoib8&hl=pt_BR&authkey=CJafieIG Relsi http://www.tuxtilt.com On 8 set, 23:13, mdipierro <mdipie...@cs.depaul.edu> wrote: > thanks. can you take charge and post it on a google doc? I can help > editing. > > On Sep 8, 9:08 pm, weheh <richard_gor...@verizon.net> wrote: > > > Here's the text of the pdf document, courtesy one of my websites, > > YAKiToMe!http://www.yakitome.com. > > > --------------------------- > > > web frameworks design comparison > > draft - please help me improve it focus on Model-View-Controller > > frameworks > > > Controllers > > In Rails class MyTestController < ApplicationController def index > > render_text "Hello World" end end > > > The name of the class has to match the name of the controller file. > > > Controllers > > In Django from django.http import HttpResponse def index(request): > > return HttpResponse("Hello World") > > > Django is explicit, you need to import all functions you use. > > > Controllers > > In Cherrypy and TurboGears 1.0 import cherrypy class MyRoot: > > @cherrypy.expose() def index(self): return "Hello World" > > > Cherrypy, Turbogears, and Pylons are also explicit. You need to import > > all functions you want to use. > > > Controllers > > In web2py def index(): return "Hello World" > > > web2py is similar to Rails. It imports for you all the web2py keyword. > > Often, like in this case, you do not need any. > > > Get/Post requests > > In Rails class MyTestController < ApplicationController def index > > render_text "Hello "+params[:who] end end > > > GET and POST variables are passed via params but other request > > parameters (client ip for example) are passed via a different > > mechanism. > > > Get/Post requests > > In Django from django.http import HttpResponse def index(request): > > return HttpResponse("Hello World %s" % request.REQUEST[`who’]) > > > Nice, simple. The request contains all the info. You can use .GET > > or .POST instead of .REQUEST to be more specific. > > > Get/Post requests > > In Cherrypy and TurboGears 1.0 import cherrypy class MyRoot: > > @cherrypy.expose() def index(self,who): return "Hello %s" % who > > > GET and POST variables are passed via arguments of the action, but > > other request parameters (client ip for example) are passed via a > > different mechanism. > > > Get/Post requests > > In web2py def index(): return "Hello %s" % request.vars.who > > > Similar to Django. All request data is in one place. You can > > use .get_vars and .post_vars instead of .vars to be more specific. > > > Dispatching > > In Rails URLhttp://hostname/MyTest/indexgetsmapped into class > > MyTestController < ApplicationController def index render_text "Hello > > World" end end > > > By default Rails does not allow running multiple apps without running > > multiple copies of Rails, since the name of the app is not in the URL, > > only the controller name (MyTest) and the action name (index) appear. > > This can be changed by configuring routes. > > > Dispatching > > In Django you need to edit url.py to map URLs into actions from > > django.conf.urls.defaults import * urlpatterns = patterns(’’, (r’^index > > $’, myapp.mycontroller.index), ) > > > This is the equivalent of Rails’ routes and it requires using regular > > expressions. There is no default. You need one entry in url.py for > > every action. > > > Dispatching > > In Cherrypy and TurboGears 1.0 import cherrypy class MyRoot: > > @cherrypy.expose() def index(self,who): return "Hello %s" % who > > > Works very much like Rails and default mapping between URL and action > > can be overwritten. > > > Dispatching > > In web2py a URL likehttp://hostname/myapp/mycontroller/indexcalls > > def index(): return "Hello %s" % request.vars.who > > > Similar to Rails and Charrypy but, by default the URL requires that > > you specify the name of the app. This allows web2py to run multiple > > apps without using routes. Web2py has its own version of routes that > > supports two different syntaxes (with and without regular expression) > > to overwrite the mapping and reverse mapping as well. > > > Calling Views > > In Rails class MyTestController < ApplicationController def index > > @message="Hello World" end end > > > It calls the default view (MyTest/index) which renders the page. The > > variables marked by @ are global vars and are passed to the view. > > Notice that if the view is not defined, this results in an error > > message. > > > Calling Views > > In Django from django.shortcuts import render_to_response def > > index(request): return render_to_response("index.html", > > {`message’:’Hello World’}) > > > This is the short way of doing it in Django. You have to specify the > > view name "index.html" since there is no default. Parameters are > > passed via a dictionary. You get an error message if the view is not > > defined. Notice that in Django a view is called a template and a > > controller is called a view. > > > Calling Views > > In TurboGears 1.0 with Cherrypy import turbogears from turbogears > > import controllers, expose class MyRoot(controllers.RootController): > > @expose(template="MyApp.MyRoot.index") def index(self): return > > dict(message="Hello World") > > > The view is specified in the expose decorator. > > > Calling Views > > In web2py def index(): return dict(message="Hello World") > > > The last line works like Cherrypy but by default it looks for a view > > called "mycontroller/index.html" in "myapp". If this view does not > > exist it uses a generic view to show all variables returned in the > > dictionary. The default can be overwritten with > > response.view=’filename.html’ > > > Views > > In Rails <% @recipes.each do |recipe| %> <%= recipe.name %> <% end %> > > > It allows full Ruby in views but: - it does not escape strings by > > default (unsafe) - <% %> requires a special editor since < > are > > special in HTML > > > Views > > In Django {% for recipe in recipes %} {{recipe.name}} {% endfor %} > > > The choice of {% %} and {{ }} tags is good because any HTML editor can > > deal with them. The code looks like Python code but it is not (notice > > the "endfor" which is not a python keyword. This limits what you can > > do in views. > > > Views > > Kid or Genshi in TurboGears 1.0 or Cherrypy ... > > > This allows full Python quotes py:for="..." but it can only be used to > > generate HTML/XML views, not dynamical JavaScript for example. > > > Views > > In web2py {{for recipe in recipes:}}> {{=recipe.name}} {{pass}} > > > Similar to Django but full Python in the code (notice "pass" is a > > Python keyword) without indentation requirements (web2py indents the > > code for you at runtime). Only one type of escape sequence {{ }} which > > is transparent to all HTML editors. All string are escaped (unless > > otherwise specified, like in Django and Kid). It can be used to > > generate JavaScript (like Django and Rails). > > > Escaping in Views > > In Rails <%%= message> > > > The double %% indicate the text has to be escaped. This is off by > > default, hence unsafe. Should be the opposite. > > > Escaping in Views > > In Django {% filter safe %} {{ message }} {% endfilter %} > > > Since Django 1.0 all text is escaped by default. You mark it as safe > > if you do not want it to be escaped. > > > Escaping in Views > > Kid or Genshi in TurboGears 1.0 or Cherrypy > > > Text is escaped by default. If text should not be escaped it has to be > > marked with XML > > > Escaping in Views > > In web2py {{=XML(recipe.name,sanitize=False)}} > > > Text is escaped by default. If text should not be escaped it has to be > > marked with XML. The optional sanitize option perform XML sanitization > > by selective escaping some tags and not others. Which tags have to be > > escaped and which tag attributes can be specified via arguments of > > XML. > > > Views Hierarchy > > In Rails Layout Example <%= yield %> and in controller: > > render :layout=’filename.html.erb’ > > > The rendered page is inserted in the <%= yield %> tag in the layout. > > One can include other views with <%= render ... %> Notice that > > also :layout follow a naming convention and there is a default. > > > Views Hierarchy > > In Django Layout Example {% block main %} {% endblock %} and in view: > > {%block main%}body{%endblock%} > > > Views can be extended and included using blocks that have names. > > > Views Hierarchy > > Kid or Genshi in TurboGears 1.0 or Cherrypy ... > > > Views Hierarchy > > In web2py Layout Example {{include}} and in view: {{extend > > `layout.html’}} body > > > Notation similar to Rails but called like in Kid. The body replaces > > {{include}} in the layout. layouts can extend other layouts. Views can > > include other views. > > > Forms > > In Rails <%= form_tag :action => "update" dp %> Name: <%= text_field > > "item", "name" %> > > Value: <%= text_field "item", "value" %> > > <%= submit_tag %> <%= end %> > > > Rails has helpers to create forms but that’s it. As far as I know > > there is no standard mechanism to automatically create forms from > > models (database tables). Perhaps there are Rails add-on to do this. > > There is a mechanism to validate submitted forms. > > > Forms > > In Django # in model class ArticleForm(ModelForm): class Meta: model = > > Article # in controller def contact(request): if request.method == > > ’POST’: form = ContactForm(request.POST) if form.is_valid(): return > > HttpResponseRedirect(’/thanks/’) else: form = ContactForm() # An > > unbound form return render_to_response(’contact.html’, { ’form’: > > form,}) In Django, you can create a Form (ArticleForm) from a model > > (Article). The Form knows how to serialize itself and validate the > > input on selfsubmission, but the errors are not automatically inserted > > in the form. > > > Forms > > Kid or Genshi in TurboGears 1.0 or Cherrypy ? > > > I believe you need to use a library like ToscaWidgets. Sorry, I am not > > familiar with them. If you know how to fill this page please let me > > know. > > > Forms > > In web2py def contact(request): form = SQLFORM(Article) if > > form.accepts(request.vars): redirect(’thanks’) return dict(form=form) > > > This is the same as the previous > > ... > > mais »
