Getting Stuff Done with Laravel 4
$19.99
Minimum price
$29.99
Suggested price
Getting Stuff Done with Laravel 4
A journey through application design and development using PHP's hottest new framework
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
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?
-
Chapter 1 - This book’s purpose
-
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
-
Chapter 18 - What application will we create?
-
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
-
Chapter 34 - Artisan Tightening
-
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
-
Chapter 56 - Setting up the Web Server
-
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 60 Day 100% Happiness Guarantee
Within 60 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.
Now, this is technically risky for us, since you'll have the book or course files either way. But we're so confident in our products and services, and in our authors and readers, that we're happy to offer a full money back guarantee for everything we sell.
You can only find out how good something is by trying it, and because of our 100% money back guarantee there's literally no risk to do so!
So, there's no reason not to click the Add to Cart button, is there?
See full terms...
Earn $8 on a $10 Purchase, and $16 on a $20 Purchase
We pay 80% royalties on purchases of $7.99 or more, and 80% royalties minus a 50 cent flat fee on purchases between $0.99 and $7.98. You earn $8 on a $10 sale, and $16 on a $20 sale. So, if we sell 5000 non-refunded copies of your book for $20, you'll earn $80,000.
(Yes, some authors have already earned much more than that on Leanpub.)
In fact, authors have earnedover $13 millionwriting, publishing and selling on Leanpub.
Learn more about writing on Leanpub
Free Updates. DRM Free.
If you buy a Leanpub book, you get free updates for as long as the author updates the book! Many authors use Leanpub to publish their books in-progress, while they are writing them. All readers get free updates, regardless of when they bought the book or how much they paid (including free).
Most Leanpub books are available in PDF (for computers) and EPUB (for phones, tablets and Kindle). The formats that a book includes are shown at the top right corner of this page.
Finally, Leanpub books don't have any DRM copy-protection nonsense, so you can easily read them on any supported device.
Learn more about Leanpub's ebook formats and where to read them
