Grok 1.0 Web Development

Table of Contents

• Preface

• Chapter 1: Getting to Know Grok
  • Why Grok?
  • Distinguishing Grok concepts
    • The Zope Component Architecture
    • Object database
    • Object publishing and traversal
  • Other Grok features
    • Integrated security model
    • Easy use of existing Python libraries and modules
    • Static resources
    • Relational database access
    • Python Web Server Gateway Interface compatibility
  • How Grok compares to other web frameworks
    • PHP
    • Java frameworks
    • Ruby on Rails
    • Django
    • Pylons
  • Summary

• Chapter 2: Getting Started with Grok
  • Getting a C compiler
  • Installing Python
    • Installing Python on Unix/Linux
    • Installing Python on Mac OS X
    • Installing Python on Windows
  • EasyInstall and the Python Package Index (PyPI)
  • Grok and the Python environment
  • Virtualenv
    • Installing Grok using grokproject
    • Creating our first project
    • Running the default application
  • What's inside a Grok project?
    • Overview of the application structure
    • Creating our first template
  • The Grok admin UI
    • Applications
    • Server control
    • Documentation
  • Summary

• Chapter 3: Views
  • Grok views
  • Zope Page Templates (ZPT)
    • The Template Attribute Language (TAL)
    • Expression types
    • Inserting text
    • Repeating tags
    • Conditional elements
    • Variables
    • Special variables
    • Modifying HTML tag attributes
    • Inserting structure
    • Multiple statements in one tag
    • Macros and slots
    • Going beyond ZPT basics
  • The to-do list application
  • Handling form data
  • Adding static resources
  • Putting in some JavaScript flourish
  • Summary

• Chapter 4: Models
  • Models and applications
  • Storing model data
    • The ZODB
    • Changing the title dynamically
    • The rules of persistence
  • Display logic and application logic
    • Separating display and application logic
  • Using containers and multiple models
    • Adding containers to our application
    • Adding behavior to the models
    • The TodoList model
    • Reorganizing the views
    • Introducing class annotations
    • Setting view names explicitly
    • Redirecting views
  • The Grok introspector
  • Summary

• Chapter 5: Forms
  • A quick demonstration of automatic forms
  • Interfaces
    • Example of an interface
    • Interfaces in Grok
  • Schemas
    • Available schema attributes and field types
  • Form fields and widgets
  • Form components
    • Adding a project container at the root of the site
    • Form actions
    • Trying out the application
  • Filtering fields
  • Using grok.EditForm
  • Modifying individual form fields
  • Form validation
  • Customizing the form template
  • Summary

• Chapter 6: The Catalog: An Object-Oriented Search Engine
  • Catalogs and indexes
  • Adding a simple search function to the application
    • Defining a simple index
    • Creating the search view
    • Creating a template to display the search results
  • A brief diversion: Structuring our application for search
  • Back to search: Using multiple indexes
  • Indexing different kinds of objects
  • The catalog admin UI
  • Types of indexes
  • Summary

• Chapter 7: Security
  • Authentication and authorization
  • Principals, permissions, and roles
  • Security policies
    • Default Grok security policy definition
    • Modifying the security policy
      • Modifying the default view permissions
      • Adding a new user
      • Protecting a view
  • Setting up a custom security policy
    • Creating permissions
    • Roles
  • Adding authentication
    • The Pluggable Authentication Utility
    • Registering PAU with our application
    • Adding a credentials plugin
      • The login form
      • The logout view
    • The UserAuthenticator plugin
      • Adding users
      • Basic user management
  • Summary

• Chapter 8: Application Presentation and Page Layout
  • Viewlets and viewlet managers
    • Viewlets
    • Viewlet managers
  • Understanding how the pieces fit together
    • View methods and attributes
    • Viewlet methods and attributes
    • Viewlet manager methods and attributes
  • To-do list manager layout
    • Defining viewlet managers in application code
    • Registering viewlets
    • Modifying existing views to use the master template
    • Inserting forms into viewlets
    • Using viewlets to insert different static resources
  • Layers and skins
    • Skins in Grok
  • Adding themes to our application
    • Overriding a viewlet
    • Using the new skins
  • Summary

• Chapter 9: Grok and the ZODB
  • How the ZODB works
    • Transparency
    • ACID properties
    • Other ZODB features
    • ZEO
  • Using the ZODB
    • The rules of persistence
    • Traversal
    • How Grok uses the ZODB
  • Adding Blob support to our application
    • Adding messages to projects
      • The megrok.form package
      • Adding an external package to our project
      • How blob support is configured in Grok
      • The messaging class and schema
      • The message viewlet
      • The message list template
      • Downloading an attachment
      • Testing the Blob support
  • Taking advantage of transactions
    • Using zope.app.undo
    • Testing the undo functionality
  • ZODB maintenance
    • File storage
    • Automatic packing
    • Backing up
    • Using the ZODB without Grok
  • Summary

• Chapter 10: Grok and Relational Databases
  • Object Relational Mappers
    • SQLAlchemy
    • Including SQLAlchemy in our Grok project
      • Using SQLAlchemy
  • Using a relational database for authentication
  • Handling database transactions securely
  • Creating database-backed models and containers
    • The megrok.rdb package
    • Making an application database backed
  • When to use the ZODB versus a relational database
  • Summary

• Chapter 11: Key Concepts Behind Grok
  • The Zope Component Architecture
    • Interfaces
    • Adapters
      • Real-world adapters
      • Defining and using an adapter
      • Adapters that we have used in our application
    • Utilities
      • Global utilities
      • Local utilities
    • Events
  • Extending a Grok application from the outside
    • Preparing the original application
    • The to-do plus package
      • Creating the new package
    • Adding a skin chooser form to the application
      • Adding a new skin
      • The skin chooser form
      • Using events to show the selected skin
    • Sending e-mail notifications on content creation
      • Object annotations
      • Creating the form
      • Sending the e-mail
    • Displaying additional navigation links
  • Summary

• Chapter 12: Grokkers, Martian, and Agile Configuration
  • Agile configuration
  • The Martian library
  • Understanding grokkers
    • The grokked class
    • The directives
    • The class grokker
    • The only ZCML you'll ever need
  • Creating our own grokker for zope.sendmail configuration
    • Creating the package
    • Writing our grokker
    • Using mailgrokker
  • Summary

• Chapter 13: Testing and Debugging
  • Testing
    • Unit testing
    • Functional tests
  • Testing in Grok
    • Doctests
    • Default test setup for Grok projects
      • Test configuration
      • Test files
      • Running the tests
    • The test runner
      • Test layers
      • Invoking the test runner
    • Looking at the test code
      • ftesting.zcml
      • tests.py
      • app.txt
    • Adding our own tests
      • The Browser class
      • Our first to-do application tests
      • Adding unit tests
      • Extending the test suite
  • Debugging
    • Debugging in Grok
      • The default Ajax debugger
      • Post-mortem debugging with the Python debugger
  • Summary

• Chapter 14: Deployment
  • Moving an application to production mode
  • Running the paster server in the background
  • Running Grok behind the Apache web server
    • Using mod_rewrite to serve our application from Apache
    • Installing and setting up Grok under mod_wsgi
      • WSGI: The Python Web Server Gateway Interface
      • Grok and WSGI
      • Why use Apache and mod_wsgi for Grok?
      • Setting up a clean Linux server
      • Installing and configuring mod_wsgi
      • Configuring a Grok site under mod_wsgi
      • Getting the to-do application ready for mod_wsgi
      • Configuring an Apache site to use mod_wsgi
      • Running the application
    • Adding a ZEO server
      • Buildout recipe for the ZEO configuration
      • Configuring the ZEO client
      • Launching the ZEO server
      • Augmenting the number of processes
  • More scalability: Adding caching and load balancing
    • Caching proxies
    • Load balancers
    • A high-traffic architecture for Grok
  • Summary

• Index

Carlos de la Guardia

I can easily see myself grabbing this book when I want to refresh my Zope memory before I head over to the Zope site. Read more

All in all it’s been a pleasant read and I think it’s a great introduction to Grok web framework. Read more

Sample chapters

You can view our sample chapters and prefaces of this title on PacktLib or download sample chapters in PDF format.

Code Downloads

Download the code and support files for this book.

Errata

Submit Errata

Please let us know if you have found any errors not listed on this list by completing our errata submission form. Our editors will check them and add them to this list. Thank you.