Thank you!

On Sep 8, 11:45 pm, Relsi Hur <[email protected]> wrote:
> 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-F41N6HHvqx87S3GTHQ...
>
> Relsihttp://www.tuxtilt.com
>
> On 8 set, 23:13, mdipierro <[email protected]> wrote:
>
> > thanks. can you take charge and post it on a google doc? I can help
> > editing.
>
> > On Sep 8, 9:08 pm, weheh <[email protected]> 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/indexgetsmappedinto 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
>
> ...
>
> read more »

Reply via email to