Ruby on Rails Foundations

Create a new Ruby on Rails application with rails new, and name the app for your project. Then cd into the app and verify the generated files with ls.

Explore the different Rails app creation options, including database choices like Postgres, skipping unit tests for RSpec, and skipping Turbolinks for custom javascript.

Run the Rails app by creating the database with rake db:create:all, migrating with rake db:migrate, and starting the server to view at localhost:3000, understanding Webrick in development.

Explore Ruby on Rails database tasks with rake, including db:create, db:migrate, db:seed, and db:setup. Learn how to migrate, seed, reset, and rollback changes.

Learn to set up and use sublime text as a Rails text editor, speed development with shortcut keys, and launch from the command line, while noting editor alternatives.

Explore the Rails file system from assets, controllers, models, and views to the application layout with yield, and learn how config, locales, and routes structure the app.

Explore the Rails file system, focusing on db, schema, seeds, and config; learn about custom rake tasks, dot keep files, and the roles of gem files, logs, and readme.

Explore scaffolding versus generators in Rails, comparing auto-generated code with manual writing. See how generators create models and controllers with create, update, and delete functionality while avoiding wasted code.

Explore rails scaffold generators by creating a project scaffold with title and description, and observe decimal percent complete and full create, read, update, delete functionality out of the box.

The scaffold generator automatically creates models, migrations, controllers, views, routes, tests, and assets, leveraging Active record and dry principles, and enabling json APIs via Jbuilder.

Learn to use the Rails console for quick data access, test queries, and in-console method calls. Explore starting Rails C, sandbox mode, and how changes are rolled back.

Start the Rails server, open the Rails console, and create ten project records with ten.times and create!, using string interpolation for titles project 0 through project 9.

Master querying, updating, and deleting records in the Rails console using ActiveRecord, storing records in a variable, using bang updates, and inspecting the generated SQL.

Learn the basics of Rails routes, how routes connect browser requests to actions, and how /projects and /projects/new render project lists and forms.

Discover how Rails uses resources to provide seven RESTful routes, map http verbs to index, create, update, and destroy, and inspect routes with rake routes for prefixes.

Create a custom Rails pages controller with views for contact, about, and home, using automated code. Run the server to view pages and explore custom routes.

Create custom routes for non CRUD pages in Rails by mapping get 'about' and get 'contact' to the pages controller, enabling clean /about and /contact URLs with a dynamic title.

Set the home page by routing to the pages controller home and verify it in the browser, then print project titles using an instance variable and embedded ruby.

Identify how to add custom routes in Rails, implement a redirect, and set up a catch-all 404 with a dedicated air action and view. Use link_to and root_path for navigation.

Explore how embedded Ruby in Rails views and the master application layout file manages navigation across pages, using path helpers for root, about, blog, and projects.

Create a shared navigation partial named _nav.html.erb and render it across pages to keep the app layout clean, reduce duplication, and update navigation in one place.

Explore embedded Ruby in Rails views, comparing IRB and Haml, and learn to render iterators, debug with inspect, and use string interpolation with if and unless checks for nil values.

Learn to integrate images in a Rails app by storing them in the asset pipeline under images, organizing into folders like logos, and rendering with image_tag and width options.

Learn to integrate styling in a Rails app by updating CSS in app/assets/stylesheets through the asset pipeline, using require_tree and require_self to manage global and page-specific styles.

Learn to apply web safe fonts in a Rails app by setting font-family for headers and paragraphs, using built-in css fonts, and previewing changes in the running app.

Integrate a custom font by adding a fonts directory under app/assets, enabling assets, updating config.assets.paths, and declaring a font-face for Hunger Games, then restart the server.

Learn the purpose of Rails controllers, avoid common anti-patterns, and use before_action with set_project to share data with views, enabling index, show, edit, update, and destroy actions.

Discover how Rails controllers customize responses with a respond_to block for html and json, and enforce strong parameters to whitelist fields for create and update.

Identify and avoid messy controllers in legacy Rails apps by moving logic from controllers to models or separate classes, keeping controllers skinny and clarifying data flow between view and model.

Learn how to customize queries in rails controllers using limit and where, with active record generating sql and filtering by current user, plus a preview of scopes for cleaner code.

Discover how model files serve as the logic backbone of a Ruby on Rails app, housing algorithms, validations, defaults, callbacks, scopes, and database relationships.

Create plain old Ruby classes in Rails for auxiliary logic, using a class method calculate_percent_complete to compute percent complete from completed and total tasks.

Create custom scopes in Rails models to filter by percent complete using where with a lambda and an alias like almost completed; call these scopes from the controller.

Compare setting defaults via SQL migrations versus a model callback using after initialize to set sensible defaults like percent_complete to 0.0, with a preference for code over migrations.

Learn how to implement validations in Ruby on Rails models using validates presence of to ensure required fields like title, description, and percent complete are filled before creation.

Generate a Rails model named Task with title, description, and a project reference, run migrations, and define the belongs_to association to tie each task to a project.

Wire up database relations by declaring has_many and belongs_to between project and task, enabling two-way binding to access related tasks and their project via Rails console and dot notation.

learn how to extend a tasks table with a new boolean column named completed using Rails migrations, including creating the migration, running rake db migrate, and validating the updated schema.

Implement a conditional after save callback on tasks to update the project's percent complete whenever a task is completed, counting completed versus total tasks and updating via a counter.

Learn database manipulation and migrations in a Rails project by adding a stage integer column to the projects table and running the migration.

Learn to change a column’s data type in Rails by using a migration with change_column to convert stage from integer to string in the projects table, then run rake db:migrate.

Ruby on Rails foundations teach you to remove a column from the projects table by generating a migration with remove column division, then run rake db:migrate to apply the change.

Understand what Ruby gems are and how to balance using them with custom code. Learn how Devise streamlines authentication and how to locate and integrate gems into Rails apps.

Learn how to add gems to a Rails app's Gemfile to handle file uploads, using Carrierwave, mini magic, Fog, and Figaro, and run bundle install to install dependencies.

Secure API credentials by installing Figaro to create config/application.yml and update gitignore; store AWS access key ID and AWS secret access key privately, with separate development and production buckets.

Configure a Rails file uploader with CarrierWave for the task file, using Fog storage to support asset pipeline and Heroku deployment, with unique naming.

Create an initializer fog.rb to connect Rails to the AWS API using fog and Carrierwave, configuring credentials from application.yml and environment variables, and specifying the provider, directory, and public setting.

Generate a Rails tasks controller manually, add a file upload field to tasks with type text, run rake db:migrate, and implement show, new, and edit actions.

Follow along as you implement a Rails controller with before_action set_task for show, edit, update, and destroy, add new actions, and build strong parameters for create and update.

Discover how to add private methods in a Rails controller, implement set_task and task_params, whitelist params with require and permit, and protect data while supporting CRUD actions.

Explore customizing routes and nest resources in a Rails app by nesting tasks under projects, replacing top-level tasks routes, and updating controllers and views accordingly.

Integrate nested forms in Rails by moving tasks under projects and using a shared _form partial for new and edit actions, including fields for title, description, completed, and task file.

Nest tasks under projects by updating the tasks controller, loading the parent project with before_action, setting task.project_id from project_id, and updating the form for nested creation.

Test nested resources in Rails by creating tasks under a project, validating routing, and updating percent complete via callbacks; plan to add a project tasks interface.

Wire nested routes to create a link that adds a new task for a project by passing the project id and using the new_project_task_path.

Learn how to display a project's tasks on its show page by fetching tasks in the controller, iterating with tasks.each, and linking to nested task show pages via project_task routes.

Explore conditional logic in Rails views by building a task show page that displays title, description, and timestamps, links to the project, and an edit path via nested routes.

Finalize file uploads in a Rails app by mounting the uploader on the task model, wiring nested tasks under projects, and applying advanced debugging to validate callbacks.

Enable authentication in a Rails app using the Devise gem and its installer, then configure default url options, flash messages, and the generated sign in and password reset views.

Create the Devise user model with Rails by running rails g devise user to generate a users table, a user model, tests, and a route.

Test registration and sign-in in a Rails app by running the server, signing up on localhost 3000, and signing in via the browser, with devise-encrypted passwords.

Learn to use the current_user method from Devise to conditionally render sign out, sign in, and register links in the navigation, based on user sign-in state.

Learn how to let users edit their details in Rails, enforce current password for updates, and customize devise messages via config locales yaml file.