Contents
Chapter 1: Building a Drupal 7 Site
Planning: Setting Parameters and Knowing Where You're Going
Discovery: Why Should This Site Be Built?
Information Architecture: Exactly What Will You Build?
Appearance: Changing a Core Theme's Color Scheme
Extending Functionality with Modules
Allowing People to Register and Log In with OpenID
Creating Content Types and Adding Content
Blocks: Creating a Mission Statement
Taxonomy: Categorizing Content
Time for a Celebratory Beverage
Chapter 2: Essential Tools: Drush and Git
A Beginner's Guide to Installing Drush
Part II: Site Building Foundations
Chapter 3: Building Dynamic Pages Using Views
Download, Enable, and Configure Permissions for the Views Module(s)
Change Which Available Views Are Listed
Understanding What Type of Content Will Be Output: Views Filters
Advanced Filter Criteria Groups: Combining Sorts with Logical Operators
Understanding the Order in Which Content Will Be Output: Views Sort Criteria
Understanding What Pieces of Content Will Be Output: Views Format Settings
Set Up the Basics for Your Views
Define the Administrative Information
Define What Type of Content You Want to Display
Define What Elements of the Content You Want to Display
Define the Order in Which You Want Your Content to Display
Handling the Use Case of Zero Results
One Page, Multiple Displays to Highlight First Result
Using Tabs for Unique Displays
Cloning and Making Administrative Tables Using Exposed Filters
Advanced Views Implementations
Chapter 4: There's a Module for That
Modules for Drupal Are Constantly Evolving
How to Find and Choose a Module
What to Do When Something's Wrong with a Module
Where to Store Contributed Modules
Other Modules That May Prove Useful
Administrative Interface and Content Entry
Community Building and Social Networking
Chapter 5: Creating Community Web Sites with Organic Groups
Installing and Configuring Organic Groups
Using Views with Organic Modules
Members, Roles, and Permissions
Setting Up a Secure Drupal Site
Reserve User 1 for Administration Purposes Only
Be Cautious When Assigning Permissions
Keep Text Formats Tight and Secure
Avoid Using the PHP Filter Module
Choosing Modules and Themes: How Secure Are Contributed Projects?
Follow the Steps in UPGRADE.txt
Drupal's Automated Module Installer
Chapter 8: Extending Your Site
Showcasing Authors with Profile Pages
Giving Authors a Headshot Image
Linking from Profiles to Web Sites
Authors' Other Homes on the Internet
A Non-displaying Data Field: Approximate Pages
Connecting Author Profiles to Authors' User Accounts
Giving Authors Permission to Create Profiles
Building the Authors Headshot View
Building an Author Biographies View Page, Reachable As a Tab on the Authors View
Using View Modes to Display the Same Content in Different Ways
Modifying Teaser Display and Setting Trim Length
Making the Table of Contents with Book Module
Setting Permissions for Organizing and Writing Chapters
Adding Metadata to the Chapter Content Type with Fields
Setting How the Chapter Content Type Displays Its Fields
Using Menu Block to Display a Better Table of Contents
Adding the Table of Contents to the Main Menu
Linking Chapters to Their Authors
Adding a Resource Content Type That References Chapters
Allowing People to Attach Generic Files to Content
Connecting Content Types with a Node Reference
Managing Resource Content Type Display
Showing Content That References the Post Being Viewed
Giving Faces to the People Posting on Your Site
Adding a Text Format That Allows Images
Bonus: Making It Easy to Insert Images into Posts
Limiting Access to the Suggestion Status Field
Autogenerating Human-readable URLs with Pathauto
Part III: Making Your Life Easier
Chapter 9: Drupal Community: Getting Help and Getting Involved
How to Get the Most from Your Participation
Reading, Listening, and Watching
Chapter 10: Planning and Managing a Drupal Project
Putting Down Your Concept on Paper
4. Development and Implementation
Project Management Methodologies and Drupal
Taking the Lifecycle into Account on Paper
Minimum Viable Project/Product
Project Manager Tasks Beyond Development
Information Architecture/Design Meetings
Other Tasks for Project Managers
Implementing Tasks and Task Workflow
Chapter 11: Documenting for End Users and the Production Team
What Makes Good Documentation?
Getting Clients into Content Entry Early
Creating End-User Documentation Post-Launch
The Anatomy of Good Client Documentation
Documenting for the Development Team
Chapter 12: Development Environment
Enhancing Your Existing Dev Environment
Working with Rendered HTML, CSS, and JavaScript
Browser and Device Compatibility Testing
The Most Basic Development Environment
Chapter 13: Putting a Site Online and Deploying New Features
3. Create a Database on the Server and Import Your Database
4. Set the Database Settings in settings.php
5. Point Incoming Traffic for Your Domain(s) to Your Site on the Server
Before You Go Any Further, Back Up
Bringing Content from Production to Development (and Stage/QA)
Bring Code Changes from Development to Stage, then Live
How to Put “Everything In Code”
Chapter 14: Developing from a Human Mindset
Part IV: Front-End Development
Enabling and Setting a Default Theme
Defining Theme Metadata (.info Files)
Using Regions vs. Hard-coding Variables in Template Files
How Theme Functions Are Created
Theme Hooks and Theme Hook Suggestions
Suggestions and Template Files
Suggestions and Theme Functions
Finding Available Variables in the Theme Layer
Using the Theme Developer Module
Preprocess and Process Functions
Implementing Preprocess and Process Hooks
Finding the Contents of $variables
Preprocess Functions in Action
Manipulating the Output of Render Elements
Notable Render Arrays in Core Templates
Introducing render(), hide(), and show()
Theming Forms with Theme Functions
Theming Forms with Template Files
Modifying Forms Using Alter Hooks
Patterns and Naming Conventions
Adding, Removing, and Replacing CSS Files
Working with Base and Subthemes
Tips for Creating Your Own Base Themes
Sustainability and Best Practices
Override Template Files with Purpose
Do My Changes Belong in a Module?
Implementing jQuery and JavaScript
Degrading JavaScript/jQuery Nicely
Chapter 18: Introduction to Module Development
Create a Repository for Your Module
Operators and Conditional Statements
Development Tip #1: When Something Isn't Working, Clear Caches
Development Tip #2: When Anything's Missing, Check Permissions
Development Tip #3: Set Your Site to Show All Errors
Chapter 19: Using Drupal's APIs in a Module
Localization with t() and format_plural()
Finding a Drupal Function That Does What You Need
Investigating What the Function Gives You
Creating a Page with hook_menu()
Choosing a Path for an Administration Page
Defining a Page with a Normal Menu Item
Defining a Tab with a Local Task Menu Item
Declaring Menu Items for X-ray Module
Using Existing Permissions in Your Module
Finding Permissions' System Names in the Database
Finding Permissions' System Names in Code
A Second Local Task to Complement the Default Local Task
Call All Implementations of a Hook
Format Data for Display as a Table
Documenting Themeable Code with @ingroup themeable
Resources for Theming in Modules
A More Drupal 7 Approach: Leveraging the Power of Render Arrays
Calling a Drupal Function Directly
Styling Your Module: Adding a CSS File
Fetching Data with a Select Query
Fetching Data with a Static Query with a Join on Two tables
A Non-Database Interlude: Displaying the Same Data in Two Locations
Using variable_get() and Another Static Select Counting and Grouping Query
Displaying Data in a Sortable Table
Drupal Entities: Common Structure Behind Site Components
Chapter 20: Refining Your Module
Creating a Configuration Page for Your Module
Conditionally Taking Action Based on Configuration or User Access
Writing a Utility Function when Drupal APIs Miss Your Need
Listing Data as Human-Readable, Properly-Punctuated Text
Making Mistakes and Embracing Error Messages
Tracking Down the Cause of Errors and Warnings
Using hook_help() as Drupal Intended
Chapter 21: Porting Modules to Drupal 7
Keeping Track of What You Need to Know
Automating (Part of) the Module Upgrade
Contributing the Upgrade to Drupal.org
Chapter 22: WritingProject-Specific Code
What is it that I need to modify and why am I doing it?
How can I modify existing functionality for my own needs?
An Example: Changing the Label of a Submit Button
Hiding Elements from the User Interface
Adding Dynamic Front-End Interaction
Make Functionality Configurable
Follow Drupal's Coding Standards
Chapter 23: Introduction to Functional Testing with Simpletest
Advantages (and Caveats) of Using Simpletest
What Is Test-Driven Development (TDD)?
The Simpletest API and Further Reading
Submitting a Patch to Drupal.org
Chapter 24: Writing a Major Module
Know the Tools Drupal Gives You
Should Your Module Provide an API?
Unleashing the Power of Hooking Into Your Module
Progressive Enhancement: Making Use of Other Modules If They Are Enabled
Getting Started with a Test Environment
Sharing Your Code in a Sandbox on Drupal.org
How to Store the Data and How to Edit It in the UI
Defining an Entity Access Callback Function
Giving Your Entities an Administrative Interface
Programmatically Creating and Attaching Fields
Part VI: Advanced Site-Building Topics
Building a Product Display Node Type
Summarizing the Main Components
Contributed Module Dependencies
Drupal Site Selection in Drush Commands
Drush Alias Files (aliases.drushrc.php)
Applying Code Updates with Drush
Going In-Depth with Drush Configuration Options and Aliases
Using Remote Commands to Deploy Sites with Drush
Making a Local Copy of a Remote Drupal Site
Using sql-sync Without Installing Drush on the Remote System
Using the Drush Site Context to Control sql-sync Options
Processing Script Command Line Arguments and Options
Processing Invoke Process Results
Providing the Command Implementation Function
Return an Array to Pass Structured Data to Other Drush Scripts
Manually Specify the Command Function with a Callback Item
Placing the Command Implementation in a Separate File
Altering Drush Command Behavior
Do You Need to Care About Scaling?
Disabling Caching During Development
Chapter 28: Spice Your Content Up With Tasty Semantics
Linking Data at the Global Web Scale
RDFa, or How HTML Can Be Augmented with Semantics
RDFa, Microformats andMicrodata
Understanding the Structure of RDF Mappings
Working with RDF Mapping Structures
Using RDF Beyond Drupal Core with the Contributed Modules
Chapter 29: The Menu System and the Path Into Drupal
Drupal’s Menu System by Example
Modifying Existing Router Items
Chapter 30: Under the Hood: Inside Drupal When It Displays a Page
First Bootstrap Phase: Initialize Configuration
Second Bootstrap Phase: Try to Serve a Cached Page
Third Bootstrap Phase: Initialize the Database Layer
Fourth Bootstrap Phase: Initialize the Variable System
Fifth Bootstrap Phase: Initialize Session Handling
Sixth Bootstrap Phase: Set up the Page Header
Seventh Bootstrap Phase: Find out the Language of the Page
Final Bootstrap Phase: Load Modules and Initialize Theme
Execution of the Page Callback
Chapter 31: Search and Apache Solr Integration
Search Module Administrative Options
Search Results and Facet Blocks
Hooks Implementations Required to Create a Search
Additional Search Module Hooks
Apache Solr Search Configuration
Apache Solr Search Customization
Hooks for Getting Data into Solr
Hooks for Altering Queries and Results
Integrating with the Apache Solr Server
Managing Data in the Solr Index
Concept: What Exactly Are You Building?
Build: Build an Alpha and Verify with Users
Optimize: Observations and New Versions
Release: Project Page and Documentation
Chapter 33: Completing a Site: The Other 90%
Creating a Custom Theming Template
Modifying the Chapter Number Field's Display
Linking to Drupal.org and Twitter Accounts with Field Formatters
Caching Simple Data Using Drupal's Default Cache Table
Streamlining an Awkward Form Element with CSS
Contextual “Add New” Links for Content Types
Noticing and Adopting a Better Way
Looking for a Module that Does What You Need
Finding an Example (Hint: the Examples Project)
Giving a Module an Interim Name
Start a Repository for Your Module
Making the Tags and Replacement Markup Form
Conditionally Including a Stylesheet for an Administration Page
Adding a Container Form Element with a Specified Class
Sharing Your Module on Drupal.org
Making a Site-Specific Module that Uses Your API
Adding Custom Markup for Output
Making Next and Previous Links That Mimic Book Navigation
Creating a View to Make User Pages Have Hackable URLs
Chapter 34: Drupal Distributions and Installation Profiles
An Example Distribution: Drune
Creating Installation Profiles
Structure of an Installation Profile
Dealing with Configuration: Features
Using Installation Profiles and Features as a Development Tool
Chapter 35: Drupal’s Story: A Chain of Many Unexpected Events
The Extended Weekend from Hell
If You Have a Problem, Please Search Before Posting a Question
Chapter 36: Now You’re in Business: Making a Living with Drupal
Building a Drupal Site: New Rules for New Technologies
“I Hate Drupal:” Things That Can Go Wrong
Out on Your Own: Building a Drupal Business
Building Drupal: Making a Living as a Contributor
Chapter 37: Maintaining a Project
Set Up Your Drupal.org Account for Contributing
From Sandboxville to Projectopolis
About Branches and Tags on Drupal.org
Preparing a Branch for Your Application
Preparing Your Project for Review
Chapter 38: Contributing to the Community
Without Contributions, There Is No Drupal
1. Providing Non-Technical Support
3. Answering Questions in Forums, Groups, Mailing Lists, Meetups, and IRC
4. Writing Documentation for Drupal.org
6. Contributing Code and Design
8. Reviewing the Contributions of Others
10. Hosting and Organizing Meetups, Camps, Summits, and More
12. Making the Drupal Community Welcoming
Appendix A: Upgrading a Drupal Site from 6 to 7
Run the Upgrade (Again and Again)
Drush Aliases for All Sites Involved in the Upgrade
Capturing Additional Upgrade Steps in Update Hooks
Consider Creating a Base Feature Module
Adding Feature Modules to the Automatic Upgrade
Appendix B: Profiling Drupal and Optimizing Performance
Appendix C: Page Rendering and Altering
Step 2: The Page Callback Is Fired
Appendix D: Visual Design for Drupal
Why Designers Should Work with Drupal
Designing for Drupal: What It Means
Making Your Life Easier As a Drupal Designer
Remember—The Purpose of Design Is Communication
Understand Site Architecture and Content Strategy
Clearly Review the Requirements and Outline the Intended Functionality of Special Features
Design for the Entire User Experience
Nine Ways to Make Your Site Accessible
Schedule Regular Reviews of New and Old Pages
Appendix F: Windows Development Environment
phpMyAdmin and MySQL Connector
Appendix G: Installing Drupal on Ubuntu
Running Ubuntu on Windows or Mac OS X
Customizing Ubuntu for Drupal Development with Drubuntu
Appendix H: Mac OSX Installation
Appendix I: Setting Up a Drupal Environment with the Acquia Dev Desktop