Getting Stuff Done with Laravel 4
Getting Stuff Done with Laravel 4
$19.99
Minimum price
$29.99
Suggested price
Getting Stuff Done with Laravel 4

This book is 100% complete

Completed on 2014-02-02

About the Book

LEARN THE FRAMEWORK taking the PHP community by storm. This practical, hands-on guide takes you through application design, building console applications, and developing web applications. Perfect for the intermediate developer, yet accessible to the beginner, Getting Stuff Done with Laravel makes learning Laravel fun. And when you finish you'll have a handy productivity tool to fit into your own workflow, allowing you to: Get More Stuff Done.

10% of every purchase will be donated to the Laravel Project!

This is not a typical reference book. It's a process book with an emphasis on design. The focus is to show a true picture of how an application is designed and implemented from start to finish. Laravel components not needed for this application are not covered. If you're looking at an honest look at developing applications using Laravel, then this is the book for you.

About the Author

Chuck Heintzelman
Chuck Heintzelman

Chuck Heintzelman spends his days architecting software systems for businesses ranging from Fortune 500 companies to Mom and Pop stores. He believes in simple and eloquent software which hides internal complexities from the user.

Chuck spends his nights plotting crimes. Not to commit personally, but for characters in his stories to solve. Even with dozens of stories published he still gets excited and stays up too late at night creating new tales. He believes writing is like software development: a process of creation, fusing art and craft.

He lives in the Pacific Northwest with his beautiful wife and three children.

Table of Contents

    • Thank You
    • Revision History
      • A special thank you
    • Help Wanted
    • Source Code on GitHub
  • Welcome
    • Chapter 1 - This book’s purpose
      • What’s not in this book
      • What’s in this book
    • Chapter 2 - Who are you?
    • Chapter 3 - Who am I?
    • Chapter 4 - What is Laravel?
    • Chapter 5 - How to justify Laravel
    • Chapter 6 - Why programmers like Laravel
    • Chapter 7 - Wordpress: The Good, The Bad, The Ugly
    • Chapter 8 - Conventions Used in this Book
      • What OS am I using?
  • Part 1 - Design Philosophies and Principles
    • Chapter 9 - Yee Haw! Cowboy Coding is Great.
    • Chapter 10 - Every Programmer Is Different
      • A Quick Litmus Test
    • Chapter 11 - Decoupling is Good
      • It’s All About Hair Loss
      • A Simple Decoupling Example
    • Chapter 12 - Don’t Be a WET Programmer
    • Chapter 13 - Dependency Injection
      • Step 1 - Move the dependency decision to the class level
      • Step 2 - Use manual injection
      • Step 3 - Use automatic injection
    • Chapter 14 - Inversion of Control
      • A General Example
      • The IoC Container
    • Chapter 15 - Interface As Contract
      • Interfaces hide code
    • Chapter 16 - SOLID Object Design
      • Single Responsibility Principle
      • Open/Closed Principle
      • Liskov Substitution Principle
      • Interface Segregation Principle
      • Dependency Inversion Principle
    • Chapter 17 - A Dirty, Little Design Secret
      • Programming like a Novelist
  • Part 2 - Designing the Application
    • Chapter 18 - What application will we create?
      • Naming the application
      • What is GTD
    • Chapter 19 - Installing Laravel
      • Creating the project
      • The project hierarchy
      • Delete unneeded directories
      • Create the Source directories
      • Update Composer
      • Test Your Installation
    • Chapter 20 - Designing a Todo List
      • Configuration Data
      • Laravel’s Configuration and Environments
      • What’s our todo list look like
      • Initial List and Task objects
      • TodoRepositoryInterface
    • Chapter 21 - Thinking about the Tasks
      • TodoTaskInterface
      • TaskCollectionInterface
      • The Wonderful World of Facades
    • Chapter 22 - Creating the TaskListInterface
      • TaskListInterface
      • A Mini-Recap
    • Chapter 23 - Format of the text file
      • File formatting rules
      • Rules about the tasks in a list
      • How individual lists are sorted
    • Chapter 24 - Application Functions
      • Laundry list of functions
      • Using a Todo Facade
    • Chapter 25 - Facade Planning
      • Facade Components
      • The Todo Facade Class Shell
      • The Todo Facade Implementation
      • Testing the Todo Facade Implementation
      • Tying things together
      • Testing the Todo Facade
    • Chapter 26 - Midstream Refactoring
      • In the foggy woods
      • TaskListInterface
      • TaskCollectionInterface
      • TodoTaskInterface
      • Finishing Up and Testing
    • Chapter 27 - Starting the TodoManager class
      • TodoManager::makeList()
      • Installing Mockery
      • Testing TodoManager::makelist()
    • Chapter 28 - Finishing the TodoManager class
      • Creating TodoManager::allLists()
      • Testing TodoManager::allLists()
      • Creating TodoManager::get()
    • Chapter 29 - Implementing ListInterface
      • Creating a TodoList shell
      • Binding the ListInterface
      • The TodoList::__construct()
      • Implementing TodoList::save()
      • Implementing TodoList::set() and TodoList::get()
      • Testing TodoList::set() and TodoList::get()
      • Testing TodoList::save()
    • Chapter 30 - Finishing the TodoList class
      • Finishing the “List Attribute” methods
      • Removing TodoList::load()
      • Implementing TodoList::archive()
      • Implementing TodoList::taskAdd()
      • The final three TodoList::tasks(), TodoList::taskSet(), and TodoList::taskRemove()
    • Chapter 31 - The TaskCollection and Task classes
      • The TaskCollection class
      • The Task class
      • Binding the Interfaces
    • Chapter 32 - Testing the TaskCollection and Task classes
      • Testing the Task class
      • Fixing the mistake in the Task class
      • Fixing Timezone in the Configuration
      • Testing the TaskCollection class
    • Chapter 33 - Implementing the TodoRepository
      • A dab of Refactoring
      • TodoRepository
      • Creating Test data
      • Testing the Repository
  • Part 3 - The Console Application
    • Chapter 34 - Artisan Tightening
      • Artisan in 30 Seconds
      • Where are these commands?
      • Removing default commands
    • Chapter 35 - Planning Our Commands
      • Planning on Planning … Let’s Get Meta
      • The List of commands in our application
      • Create a new list
      • List All Lists
      • Edit List
      • Archive list
      • Rename List
      • Add a task
      • Marking a task complete
      • Listing Tasks
      • Edit Task
      • Remove task
      • Move Tasks
      • Final List of all Commands
    • Chapter 36 - Pseudo-coding
      • Create List Pseudo-code
      • Uncreate List Pseudo-code
      • List all Lists Pseudo-code
      • Edit List Pseudo-code
      • Archive List Pseudo-code
      • Unarchive List Pseudo-code
      • Rename List Pseudo-code
      • Add Task Pseudo-code
      • Do Task Pseudo-code
      • Listing Tasks Pseudo-code
      • Edit Task Pseudo-code
      • Remove Task Pseudo-code
      • Move Task Pseudo-code
      • Final Thoughts on Pseudo-coding
    • Chapter 37 - Using Helper Functions
      • The Most Frequent Functions
      • Creating Helper Functions
      • Unit Testing Our Helper Functions
      • Creating pick_from_list()
      • Testing pick_from_list()
    • Chapter 38 - The ListAllCommand
      • The Plan
      • Creating the ListAllCommand
      • Telling Artisan About the ListAllCommand
      • Fleshing out the fire() method a bit
      • Using Symfony’s Table Helper
      • Refactoring taskCount()
      • Sorting the List ids
    • Chapter 39 - The CreateCommand
      • The Plan
      • Creating the CreateCommand
      • Adding the all_null() Helper
      • Expanding CommandBase
      • Implementing fire()
    • Chapter 40 - The UncreateCommand
      • The Plan
      • Creating the UncreateCommand
      • Getting Stack Traces on Your Command
      • Implementing askForListId() for existing lists
      • A Little Cleanup
      • Fixing the unit tests
    • Chapter 41 - The EditListCommand
      • The Plan
      • Updating CommandBase
      • Creating the EditListCommand
      • Telling Artisan About EditListCommand
      • Pretesting EditListCommand
      • Finishing EditListCommand::fire()
    • Chapter 42 - Refactoring Files and Config
      • Refactoring the Config
      • Refactoring to use Laravel’s File class
    • Chapter 43 - The AddTaskCommand
      • The Plan
      • Creating the AddTaskCommand
      • Adding the code to the fire() method
      • Manually testing
    • Chapter 44 - The DoTaskCommand
      • The Plan
      • Creating the DoTaskCommand
      • Updating CommandBase
      • Testing DoTaskCommand
      • Killing the Bug
    • Chapter 45 - The ListTasksCommand
      • The Plan
      • Creating the ListTasksCommand
      • Testing the ListTasksCommand
    • Chapter 46 - Eating Our Own Dog Food
      • What is Eating Your Own Dog Food
      • Setting up the gsd todo list
    • Chapter 47 - The EditTaskCommand
      • The Plan
      • Adding a str2bool() helper
      • Creating the EditTaskCommand
      • Refactoring TodoList save()
      • Testing EditTask
      • Dogfooding
    • Chapter 48 - ArchiveListCommand and UnarchiveListCommand
      • The Plan
      • Creating the Commands
      • Updating ArchiveListCommand
      • Fixing the CommandBase bug
      • Updating UnarchiveListCommand
      • Dogfooding
    • Chapter 49 - The RenameListCommand
      • Blank line after gsd:list title
      • The Plan for RenameListCommand
      • Creating the RenameListCommand
      • Implementing ListInterface::delete()
      • Dogfooding
    • Chapter 50 - Refactoring again
      • Adding CommandBase::abort()
      • Add to askForListId()
      • Check gsd help consistency
      • Use ListInterface::delete()
      • The Changed Files
      • Dogfooding
    • Chapter 51 - The RemoveTaskCommand
      • The Plan
      • Creating the RemoveTaskCommand
      • Dogfooding
    • Chapter 52 - The MoveTaskCommand
      • The Plan
      • Creating the MoveTaskCommand
      • Dogfooding
    • Chapter 53 - Listing Tasks Across Lists
      • The Plan
      • Update ListAllCommand
      • Dogfooding
    • Chapter 54 - Command Aliases and the gsd shell script
      • Command Aliases
      • Planning the aliases and macros
      • Implementing the aliases
      • The Bash Script
      • Dogfooding
    • Chapter 55 - What’s Next with the Console Application
  • Part 4 - The Web Application
    • Chapter 56 - Setting up the Web Server
      • Web server permissions
      • Using Apache
      • Using Nginx
      • Using PHP’s built in server
      • You have arrived
    • Chapter 57 - Planning the Web Application
      • Initial Ideas
      • Planning the AJAX calls
      • Designing the Javascript Objects
      • Dogfooding
    • Chapter 58 - Mocking Up the Web Page
      • Setting Up Bootstrap
      • Build a basic template
      • Expand template to our mockup
      • Dogfooding
    • Chapter 59 - Adding Feedback to the User
      • Structuring the Views
      • Building the Skeleton
      • Adding gsd style and javascript
      • Adding a message box
      • Making message box a function
      • Implementing the Error Message function
      • Dogfooding
    • Chapter 60 - Setting up the AJAX routes
      • Using a Resource Controller
      • Finish the routes
      • Creating the Controller
      • Finishing the ListController skeleton
      • Testing a ListController method
      • Dogfooding
    • Chapter 61 - Adding the Top Nav Bar
      • Creating the partial
      • Loading the default list
      • Structuring the Nav Bar
      • Making our first AJAX call
      • Doing the server side of the REST
      • Dogfooding
    • Chapter 62 - Finishing the Top Nav Bar
      • Assigning javascript functions to the navbar
      • Loading the result into the navbar
      • Dogfooding
    • Chapter 63 - The Side Navigation
      • Updating the layout
      • Creating the sidebar
      • Finishing the AJAX call.
      • Updating the Javascript
      • Dogfooding
    • Chapter 64 - The Tasks
      • Iteration #1 - Basic structure
      • Iteration #2 - Showing Open Tasks
      • Iteration #3 - Showing completed tasks.
      • Dogfooding
    • Chapter 65 - Deleting a Task
      • Refactoring TaskInterface
      • Updating the Controller
      • Update the doDelete() javascript method.
      • Toggling the Completed Flag
      • Dogfooding
    • Chapter 66 - Adding and Editing Tasks
      • The Modal Task Form
      • The Javascript
      • Finishing taskboxSave
      • Dogfooding
    • Chapter 67 - Archiving and Unarchiving Lists
      • Implementing the AJAX archive method
      • Calling the AJAX archive() method
      • Implementing the AJAX unarchive method
      • Calling the AJAX unarchive() method
      • Dogfooding
    • Chapter 68 - Creating and Renaming Lists
      • Adding List Modal
      • Adding Create List Javascript
      • Implenting AJAX store call
      • Implementing Rename Javascript
      • Implementing AJAX rename call
      • Dogfooding
    • Chapter 69 - Move and Beyond
      • The Move Task Command
      • Where to go next
      • A Final Thank You
  • Appendices
    • Appendix I - Composer
    • Appendix II - PHP Unit
    • Appendix III - Apache Setup
      • Installing Apache
      • Fixing Permissions
      • Using Named Virtual Hosts
      • Adding an entry to /etc/hosts
      • Setup up a VirtualHost on UbuntuMint
    • Appendix IV - Nginx Setup
      • Installing Nginx
      • Fixing Permissions
      • Adding an entry to /etc/hosts
      • Setup up a VirtualHost on UbuntuMint

The Leanpub 45-day 100% Happiness Guarantee

Within 45 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.

See full terms...

Write and Publish on Leanpub

Authors, publishers and universities use Leanpub to publish amazing in-progress and completed books and courses, just like this one. You can use Leanpub to write, publish and sell your book or course as well! Leanpub is a powerful platform for serious authors, combining a simple, elegant writing and publishing workflow with a store focused on selling in-progress ebooks. Leanpub is a magical typewriter for authors: just write in plain text, and to publish your ebook, just click a button. It really is that easy.

Learn more about writing on Leanpub