Here’s a (work in progress) list of useful (Mac) Browser DevTools tips, tricks and keyboard shortcuts for my reference and yours. This is a work in progress and I’ll update it as I go.
Console Panel
Return currently selected element to work with
$0
Then you can execute its methods or inspect its attribute values, for example:
$0.offsetParent
Debug event-based behaviour
In Chrome, right-click on the relevant element (e.g. a button) and select “Inspect Element”. By default, the Styles panel is selected but instead select the Event Listeners panel. In there you can see all events (e.g. click) currently being listened for on that element (and its parent elements so as to include instances of event delegation).
Each event can be expanded to show which element has the event listener attached – for example it might be the current element or might be document. From here you can get to the script containing the code. Click a line number within the code to add a breakpoint. This will pause code execution on that line until you click the play button to continue. You might also log the current value of a variable here.
Pause JavaScript execution
Cmd + backslash
Firefox
Get responsive img element’s currentSrc
Inspect the element, right click and select Show DOM Properties from the context menu.
Google Chrome
Open the Command Menu
Command+Shift+P
Disable JavaScript
Open the Command Menu then type “disable” and you’ll see the option.
Get responsive img element’s currentSrc
Inspect the element, click the properties tab, toggle open the top item.
Throttle network/bandwidth
Go to tab Network then change Throttling to your desired setting, for example “Slow 3G”, or “offline”.
Here’s a list of useful Screen Reader commands and tips for my reference and yours. This is a work in progress and I’ll update it as I go.
VoiceOver (Mac)
Initial setup:
Open Safari > Preferences > Advanced; then
check the checkbox “Press tab to highlight each item on a webpage”.
Usage
Open the page you want to test in your web browser (you might favour Safari for VoiceOver).
Cmd-F5 to turn VoiceOver on.
Cmd-F5 (again) to turn VoiceOver off.
Get Cmd-F5 for “toggling on and off” into your muscle memory!
Then:
Ctrl-Option-A to have VoiceOver read the entire page.
Ctrl to pause VoiceOver, and Ctrl again to resume.
Find any unexpected issues by
Tabbing
Tab through items on the page using the tab key. This will move to the next focusable item (button, link, input). You can verify all interactive elements have a focus style, all interactive elements are reachable by keyboard, all off-screen or hidden elements don’t get focused when they shouldn’t and that the spoken label for each interactive element has sufficient context to understand it (“click here” and “menu” isn’t sufficient).
Navigating with the right-pointing arrow key
Navigate through all the content using Ctrl-Option-→. While this is not how most screen reader users will read the page, it doesn’t take long and lets you confirm that everything VoiceOver announces makes sense.
Using Rotor to scan and jump to specific elements
Ctrl-Option-U to open Rotor
Browse categories using left and right arrows. This includes the Landmarks menu.
Down arrow to browse within the categories
press Return to select an item
This is a great way to check if your content structure makes sense to a screen reader. Checking the headings illustrates the outline of the page. Viewing the links helps ensure they all have a name that makes sense without visual context. Checking landmarks helps ensure that the proper ARIA roles have been applied. You might find that a list of articles is not titled appropriately or that headings are not properly nested.
Tables
Navigate to a table using Ctrl-Option-Cmd-T
It should read a caption and give you info about the size of the table
I’m finding Codepen to be more and more valuable not only for testing out new code and ideas, but also – when working on large applications – as a time-saving rapid prototyping environment which sidesteps the overhead of back-end set-up. Here are some tips which I’ve found useful, for future reference.
Control the Editor View layout
Append /left/, /right/, or /top/ to the URL to set the editor layout.
Append ?editors=1111 (change numbers as appropriate) to the URL to set which panels are maximised (in order of HTML, CSS, JavaScript, and console).
Note: the Emmet ones are really useful for code autocompletion.
Additional Emmet Settings
To add a keyboard shortcut for adding an arbitrary wrapper element (say, div.wrap) around some selected code:
Open the Command Palette then search “emmet wrap”. When you see the option “Emmet: wrap with abbreviation”, click the settings icon beside it. Enter your preferred keyboard shortcut. I currently use:
Command-Shift-A
Open current terminal directory in VS Code
code .
Toggle Terminal
Ctrl-`
Toggle sidebar visibility
Command-B
Edit multiple rows simultaneously
Select one instance of the text that appears in multiple locations. Use Command-D to select all, then edit.
I’m no Ruby engineer however even as a front-end developer I’m sometimes called upon to work on Rails applications that require me to know my way around. Here are my notes and reminders.
This is not intended to be an authoritative guide but merely my notes from various lessons. It’s also a work-in-progress and a living, changing document.
The console command lets you interact with your Rails application from the command line.
# launch a console (short version)
rails c
# long version
bundle exec rails console
Quickly find where a method is located:
Myobj.method(:methodname).source_location
# Returns a file and line which you can command-click=>["/local/path/to/mymodelname/model.rb", 99]
See an object’s methods:
Myobj.methods
# Search for a method using a search string# this returns all of the object methods containing string “/pay/“
Myobj.methods.grep(/pay/)
Rspec
Run it like so:
bin/rspec spec/path/to/foo_spec.rb
# Run a particular line/method
bin/rspec spec/path/to/foo_spec.rb:195
If adding data variables to use in tests, declare them in a let block so as to keep them isolated and avoid them leaking elsewhere.
let(:example_data_obj){{foo:"bar",baz:"bat",
…
}}
Note: if you need multiple data variables so as to handle different scenarios, it’s generally more readable to define the data being tested right next to the test.
Debugging
I’ll cover debugging related to more specific file types later but here’s a simple tip. You can check the value of a variable or expression at a given line in a method by:
add byebug on a line of its own at the relevant place in your file, then save file
switch to the browser and reload your page
in the terminal tab that’s running the Rails server (which should now be stopped at the debugging breakpoint), at the bottom type the variable name of interest. You won’t see any text but just trust that your typing is taking effect. Press return
you’ll now see the value of that variable as it is at the debugging breakpoint
When you’re done, remove your byebug. You may need to type continue (or c for short) followed by return at the command prompt to get the server back on track.
Helpers
Helper methods are to there to support your views. They’re for extracting into methods little code routines or logic that don’t belong in a controller and are too complex or reusable to be coded literally into your view. They’re reusable across views because they become available to all your views automatically.
Don’t copy and reuse method names from other helpers. You’ll get conflicts because Helpers are leaky. Instead, start your helper methods with an appropriate namespace.
Unlike object methods (e.g. myobj.do_something) helper methods (e.g. render_something) are not available for us to use in the Rails console.
Helper specs
Basic format:
# frozen_string_literal: truerequire"rails_helper"
RSpec.describe Foos::BarHelper do
let(:foo){ FactoryBot.create(:foo)}
describe "#foo_bars_sortable_link"do
context "when bat is not true"do
it "does a particular thing"do
expect(helper.foo_bars_sortable_link(foo,bat:"false")).to have_link(# …)endend
context "when bat is true"do
it "does something else"do
expect(helper.foo_bars_sortable_link(foo,bat:"true")).to have_link(# …a different link from previous test)endendendend
Notes:
start with describe: it’s a good top-level.
describe a helper method using hash (describe "#project_link" do)
Helper methods should not directly access controller instance variables because it makes them brittle, less reusable and less maintainable. If you find you’re doing that you might see it as an opportunity to refactor your helper method.
Debugging Helper methods
If you want to debug a helper method by running it and stepping through it at the command line you should lean on a test to get into the method’s context.
# in foo_helper.rb, insert above line of interest
binding.pry # or byebug# at command line, run helper’s spec (at relevant line/assertion)
bin/rspec spec/path/to/foo_helper_spec.rb:195
# the “debugger” drops you in at the line where you added your breakpoint# and shows the body of the function being run by the line of the spec we requested.
From: /path/to/app/helpers/foo_helper.rb:26 FooHelper#render_foo:# you’re now debugging in the context of the running helper method…# with the arguments passed in by the test available to manipulate.# this means you can run constituent parts of the method at the debugger prompt…# for example…# run this to get back the HTML being rendered.
render_user_profile(user)
blank? versus empty?
If you want to test whether something is “empty” you might use empty? if you’re testing a string, however it’s not appropriate for testing object properties (such as person.nickname) because objects can be nil and the nil object has no empty? method. (Run nil.empty? at the console for proof.) Instead use blank? e.g. person.nickname.blank?.
frozen_string_literal: true
I’ll often see this at the top of files, for example Ruby classes. This is just a good practice. It makes things more efficient and thereby improves performance.
frozen_string_literal:true
Class-level methods
They’re called class-level methods because they are methods which are never called by the instance, i.e. never called outside of the class. They are also known as macros.
Examples include attr_reader and ViewComponent’s renders_one.
Constants
Here’s an example where we define a new constant and assign an array to it.
ALLOWED_SIZES=[nil,:medium,:large]
Interestingly while the constant cannot be redefined later—i.e. it could not later be set to something other than an array—elements can still be added or removed. We don’t want that here. The following would be better because it locks things down which is likely what we want.
ALLOWED_SIZES=[nil,:medium,:large].freeze
Symbols
They’re not variables. They’re more like strings than variables however Strings are used to work with data whereas Symbols are identifiers.
You should use symbols as names or labels for things (for example methods). They are often used to represent method & instance variable names:
# here, :title is a symbol representing the @title instance variable
attr_reader :title# refer to the render_foo method using a symbol
Myobj.method(:render_foo).source_location
# you can also use symbols as hash keys
hash ={a:1,b:2,c:3}
From what I can gather, colons identify something as a Symbol and the colon is at the beginning when its a method name or instance variable but at the end when its a hash key.
Hashes
A Hash is a dictionary-like collection of unique keys and their values. They’re also called associative arrays. They’re similar to Arrays, but where an Array uses integers as its index, a Hash allows you to use any object type.
Example:
hash =
The fetch method for Hash
Use the fetch method as a neat one-liner to get the value of a Hash key or return something (such as false) if it doesn’t exist in the hash.
@options.fetch(:flush,false)
ViewComponents
ViewComponents (specifically the my_component.rb file) are just controllers which do not access the database.
They use constructors like the following:
definitialize(size:nil,full_height:false,data:nil)super@size= allowed_value?(ALLOWED_CARD_SIZES, size)@full_height= full_height
@data= data
end
(Note that you would never include a constructor in a Rails controller or model.)
In the above example @foo is an instance variable. These are available to an instance of the controller and private to the component. (This includes ViewComponents, which are also controllers.)
In a view, you can refer to it using @foo.
In a subsequent method within the controller, refer to it simply as foo. There’s no preceding colon (it’s not a symbol; in a conditional a symbol would always evaluate to true) and no preceding @.
defclasses
classes =["myThing"]
classes <<"myThing-foo"if foo
classes
end
Making instance variables publicly available
The following code makes some instance variables of a ViewComponent publicly available.
attr_reader :size,:full_height,:data
Using attr_reader like this automatically generate a “getter” for a given instance variable so that you can refer to that instead of the instance variable inside your class methods. My understanding is that doing so is better than accessing the instance variable direct because, among other benefits, it provides better error messages. More about using attr_reader.
Every method returns a value. You don’t need to explicitly use return, because without it it will be assumed that you’re returning the last thing in the method.
defhello
"hello world”
end
Define private methods
Add private above the instance methods which are only called from within the class in which they are defined and not from outside. This makes it clear for other developers that they are internal and don’t affect the external interface. This lets them know, for example, that these method names could be changed without breaking things elsewhere.
Also: keep your public interface small.
Naming conventions
The convention I have worked with is that any method that returns a boolean should end with a question mark. This saves having to add prefixes like “is-” to method names. If a method does not return a boolean, its name should not end with a question mark.
Parameters
The standard configuration of method parameters (no colon and no default value) sets them as required arguments that must be passed in order when you call the method. For example:
defwrite(file, data, mode)
…
end
write("cats.txt","cats are cool!","w")
By setting a parameter to have a default value, it becomes an optional argument when calling the method.
defwrite(file, data, mode ="w")
…
end
write("shopping_list.txt","bacon")
Named Parameters
Configuring your method with named parameters makes the method call read a little more clearly (via the inclusion of the keywords in the call) and increases flexibility because the order of arguments is not important. After every parameter, add a colon. Parameters are mandatory unless configured with a default value.
Here’s an example.
defwrite(file:,data:,mode:"ascii")
…
end
write(data:123,file:"test.txt")
And here’s how you might do things for a Card ViewComponent.
My understanding is that when you pass **foo as a parameter to a method call then it represents the hash that will be returned from a method def foo elsewhere. The contents of that hash might be different under different circumstances which is why you’d use the double-splat rather than just specifying literal attributes and values. If there are multiple items in the hash, it’ll spread them out as multiple key-value pairs (e.g. as multiple HTML attribute name and attribute value pairs). This is handy when you don’t know which attributes you need to include at the time of rendering a component and want the logic for determining that to reside in the component internals. Here’s an example, based on a ViewComponent for outputting accessible SVG icons:
In the icon_component.html.erb template:
<%= tag.svg(class: svg_class,fill:"currentColor",**aria_role
)do%>
…
<% end %>
In IconComponent.rb:
defaria_role
title ?{role:"img"}:{aria:{hidden:true}}end
The **aria_role argument resolves to the hash output by the aria_role method, resulting in valid arguments for calling Rails’s tag.svg.
require
require allows you to bring other resources into your current context.
Blocks
The do…end structure in Ruby is called a “block”, and more specifically a multi-line block.
<%= render CardComponent.newdo|c|%>
Card stuff in here.
<% end %>
Blocks are essentially anonymous functions.
When writing functions where we want a block passed in, we can specify that the block is required. For example:
defdo_something(param,&block)
Here, the ampersand (&) means that the block is required.
yield
When you have a method with a yield statement, it is usually running the block that has been passed to it.
You can also pass an argument to yield e.g. yield(foo) and that makes foo available to be passed into the block.
The above two lines really just construct a “string” of the component and let you test for the presence of things in it.
Rendering HTML
We have the content_tag helper method for rendering HTML elements. However you are arguably just as well coding the actual HTML rather than bothering with it, especially for the likes of div and span elements.
link_to is a little more useful and makes more sense to use.
Multi-line HTML string
Return a multi-line HTML string like so:
output = "<p>As discussed on the phone, the additional work would involve:</p>
<ol>
<li>Item 1</li>
<li>Item 2</li>
<li>Item 3</li>
</ol>
<p>This should get your historic accounts into a good shape.</p>".html_safe
output
Interpolation
Here’s an example where we use interpolation to return a string that has a text label alongside an inline SVG icon, both coming from variables.
"#{link[:text]} #{icon_svg}".html_safe
tag.send()
send() is not just for use on tag. It’s a means of calling a method dynamically i.e. using a variable. I’ve used it so as to have a single line create either a th or a td dymamically dependent on context.
Only use it when you are in control of the arguments. Never use it with user input or something coming from a database.
Random IDs or strings
object_id gives you the internal ruby object id for what you’re working on. I used this in the past to append a unique id to an HTML id attribute value so as to automate an accessibility feature. However don’t use it unintentionally like I did there.
It’s better to use something like rand, or SecureRandom or SecureRandom.hex.
Views
If you have logic you need to use in a view, this would tend to live in a helper method rather than in the controller.
Policies
You might create a method such as allowed_to? for purposes of authorisation.
Start (local) Rails server
Note: the following is shorthand for bin/rails server -b 0.0.0.0.
rails s
Miscellaneous
Use Ruby to create a local web server.
# to serve your site at localhost:5000 run this in the project’s document root
ruby -run-e httpd .-p5000
Web fonts: where to put them in the Rails file structure
See https://gist.github.com/anotheruiguy/7379570.
The Database
Reset/wipe the database.
bundle exec rake db:reset
Routing
Get routes for model from terminal
Let’s say you’re working on the index page for pet_foods and want to create a sort-by-column anchors where each link’s src points to the current page with some querystring parameters added. You’re first going to need the route for the current page and in the correct format.
To find the existing routes for pet_foods you can run:
I’ve used Git for many years but it can still trip me up. At times I’ve worked primarily in a GUI (like Sourcetree or Fork), and other times directly on the command line. I’ve worked on projects where I’ve been the sole developer and others where I’m part of a large team. Regardless of the tools or context, I’ve learned there are certain need-to-knows. Here’s a list of useful Git concepts and commands for my reference and yours.
Note: the following is not an exhaustive list but rather the thing I keep coming back to and/or regularly forget. For deeper explanations, see the list of resources at the foot of the article.
Option 1: Create a new repo in your Github account
This generates a new, empty repo (optionally initialised with a README).
Do this when you will be working on a new, dedicated project rather than contributing changes to a pre-existing one.
Option 2: Create repo from a “template repository” (owned by you or someone else)
This generates a new repo with the same directory structure and files as the template. It’s a good option for starting your own new, potentially long-lived project from a solid starting point.
Unlike a fork it does not include the entire commit history of the parent repository. Instead it starts with a single commit.
Option 3: Fork an existing repo (usually owned by someone else)
This generates a new repo which is a copy of another repo, including its commit history. Your commits will update your copy rather than the original repo.
Do this by clicking the Fork button in the header of a repository.
This is good for (often short-lived) collaboration on an existing repo. You can contribute code to someone else’s project, via PRs.
Alternatively you might want to keep the original remote available so you can pull in its future project updates, but reset the origin remote to your new/target repo.
git remote rename origin upstream
git remote add origin https://github.com/mygithubusername/mynewproject.git
git push origin master
git pull origin master
# in the future the original repo gets an updategit pull upstream master
The source repo is my fork of a project to which I want to contribute
Duplicating (also knows as “duplicate without forking”)
This is a special type of clone. I know this is an option, but it‘s not one I’m familiar with or have had call to use. I can refer to Duplicating a repository if need be.
Start locally from a blank slate
Although cloning is the easiest way to get started locally, ocassionally I start by coding from scratch instead.
mkdir myproject &&cd myproject
echo"# Welcome to My Project Repo">> README.md
git init
gitadd README.md
git commit -m"first commit"# go to Github and create an empty repo, if you haven’t already.# then add as a remotegit remote add origin https://github.com/mygitusername/myproject.git
# push up, passing -u to set the remote branch as the default upstream branch our local branch will track# this saves typing out ‘origin master’ repeatedly in future.git push -u origin master
Remotes
Remove a remote from your local settings:
git remote rm<name>
Rename a remote:
git remote rename oldname newname
Configuration
Configure your favourite editor to be used for commit messages:
git config --global core.editor "nano"
Use git st as a shortcut for git status (to stop me mistyping as “statsu”):
Stage and commit all changes in a single command (note: doesn’t work with new, untracked files):
git commit -am"fix: typo in heading"
Branches
Show all local branches:
git branch
Show all local and remote branches:
git branch -a
Show branches you last worked on (most recently commited to):
git branch --sort=-committerdate
Save current state to new branch but don’t yet switch to it (useful after committing to wrong branch):
git branch newbranchname
Create and switch to new branch (main or whatever branch you want to branch off):
git checkout -b mynewbranch
Note that if you branch off foo_feature then when creating a PR in GitHub for your changes in mynewbranch you can change the Base branch from the default of main to foo_feature. This specifies that you are requesting your changes be merged into foo_feature rather than main and makes the comparison of changes relative to foo_feature rather than main.
Switch to an existing branch:
git checkout branchname
Save typing by setting the upstream remote branch for your local branch:
# git branch -u remotename/branchnamegit branch -u fuzzylogic/v3
# now there’s no need to type origin mastergit pull
Delete local branch:
git branch -d name_of_branch
# need to force it because of some merge issue or similar?git branch -D name_of_branch
Save changes temporarily
stash is like a clipboard for git.
# Before changing branch, save changes you’re not ready to commitgit stash
# change branch, do other stuff. Then when return:git stash pop
Staying current and compatible
fetch remote branch and merge simultaneously:
git pull remotename branchname
# common use case is to update our local copy of mastergit pull origin master
# shorthand when a default upstream branch has been setgit pull
# an alternative is to update (fetch) which does not auto-merge, then 'reset' to the latest commit on the remote# https://stackoverflow.com/questions/55731891/effects-of-git-remote-update-origin-prune-on-local-changesgit checkout master
git remote update --prunegit reset --hard origin/master
Merge another branch (e.g. master) into current branch:
git merge otherbranch
# a common requirement is to merge in mastergit merge master
Rebasing
git rebase can be used as:
an alternative to merge; and
a means of tidying up our recent commits.
As an alternative to merge its main pro is that it leads to a more linear therefore easier-to-read history. Note however that it is potentially more disruptive therefore not right for every situation.
Say I’ve been working on a feature branch and I think it’s ready.
I might want to just tidy up my feature branch’s commits and can do this with an “interactive rebase”. This technique allows me to tidy my feature branch work to remove trivial, exploratory and generally less relevant commits so as to keep the commit history clean.
I might also want to bring in master to ensure synchronicity and compatibility. rebase sets the head of my feature branch to the head of master then adds my feature branch’s commits on top.
While it’s a good idea to rebasebefore making a PR, don’t use it after making a PR because from that point on the branch is public and rebasing a public branch can cause problems for collaborators on the branch. (The only exception to the previous rule is if you’re likely to be the only person working on the PR branch)
Rebuild your feature branch’s changes on top of master:
Force push your rebased branch (again, only when you’re unlikely to have/require collaborators on the PR):
git push --force origin myfeaturebranch
Tidy a feature branch before making a PR:
git checkout myfeaturebranch
git rebase -i master
# just tidy the last few (e.g. 3) commitsgit rebase -i HEAD~3
# this opens a text editor listing all commits due to be moved, e.g.:
pick 33d5b7a Message for commit #1
pick 9480b3d Message for commit #2
pick 5c67e61 Message for commit #3# change 'pick' to 'fixup' to condense commits, say if #2 was just a small fix to #1
pick 33d5b7a Message for commit #1
fixup 9480b3d Message for commit #2
pick 5c67e61 Message for commit #3# alternatively if use 'squash', after saving it will open an editor# and prompt you to set a new commit message for the combined stuff.
pick 33d5b7a Message for commit #1
squash 9480b3d Message for commit #2
squash 5c67e61 Message for commit #3
Show commit history (most recent first; q to quit):
git log
# compact versiongit log --oneline# limit scope to commits on a branchgit log branchname
Check if your feature branch is trailing behind:
# show commits in master that are not yet in my feature branchgit log --oneline my-feature..master
# show commits on remote branch that are not yet in my local branchgit log --pretty='format:%h - %an: %s' new-homepage..origin/new-homepage
# show commits by me that included “heroku” and that changed file Gemfilegit log --author=Demaree --grep=heroku --oneline Gemfile
Show changes that occurred in the most recent commit or a given commit.
git show
# show changes in a given commit
git show 591672e
Review differences between staged changes and last commit:
gitdiff--cached
Review changes between a given version/commit and the latest:
gitdiff 591672e..master
Fixing Things
Discard all your as-yet uncommitted changes:
git restore .
Get your local feature branch out of a problem state by resetting to the state it is on the remote (e.g. at last push).
git reset --hard origin/my-branch
Undo all the changes in a given commit:
git revert 591672e
Alter the previous commit (change the message and/or include further updates):
# we are amending the previous commit rather than creating a new commit.# if file changes are staged, it amends previous commit to include those.# if there are no staged changes, it lets us amend the previous commit’s message only.git commit --amend
Move current branch tip backward to a given commit, reset the staging area to match, but leave the working directory alone:
git reset 591672e
# additionally reset the working directory to match the given commitgit reset --hard 591672e
See what the app/site was like (e.g. whether things worked or were broken) at a given previous commit, noting the following:
You’re now “detatched”, in that your computer’s HEAD is pointing at a commit rather than a branch.
You’re expected to merely review, not to make commits. Any commits you make would be “homeless”, since commits are supposed to go in branches. (However you could then branch off.)
git checkout 591672e
Return one or more files to the state they were in at a previous commit, without reverting everything else.
git checkout 3aa647dac9a8a251ca223a693d4c140fd3c1db11 /path/to/file.md /path/to/file2.erb
# if happy you then need to commit those changesgit commit
When git st reveals a list of staged files including lots of strange files you don’t want there mixed with others you do…
# add those you want to stay modified and stagedgitadd path/to/file-I-want-1.rb path/to/file-I-want-2.md
# this will clear all others out of the stagegit checkout .
Grab one or more commits from elsewhere and drop into your current branch:
git cherry-pick 591672e
# grab the last commit from a branch e.g. mastergit cherry-pick master
Fix a pull that went wrong / shouldn’t have been done:
git pull origin branchname
# whoops!git reflog
# shows a list of every thing you've# done in git, across all branches!# each one has an index HEAD@{index}# find the one before you broke everythinggit reset HEAD@{index}# magic time machine
If you are fixing something that was raised in a GitHub issue, link that issue in your fix PR’s sidebar under Linked Issues (rather than just mentioning it in the PR) and it will automatically close the issue when you merge.