Bob Gilmore

Trim the Fastlane Snapfile for Debugging

Tue, 18 Sep 2018 18:30:00 -0400

The default Snapfile that fastlane init creates for you is fine, with one exception.

Once you have your UI test files written, complete with snapshot() calls, you run

fastlane snapshot

at the shell to generate the screenshots. But the debug cycle is way too long - it takes forever to finish and show you what’s wrong. That’s because the default Snapfile runs a bunch of Simulators.

Do yourself a favor and restrict it to run in one Simulator during the debugging process.

To do this, I change the default devices list from the completely commented-out (and therefore ineffective) default list

# A list of devices you want to take the screenshots from
# devices([
#   "iPhone 8",
#   "iPhone 8 Plus",
#   "iPhone SE",
#   "iPhone X",
#   "iPad Pro (12.9-inch)",
#   "iPad Pro (9.7-inch)",
#   "Apple TV 1080p"
# ])

to a single-entry list:

# A list of devices you want to take the screenshots from
devices([
  "iPhone 8",
#   "iPhone 8 Plus",
#   "iPhone SE",
#   "iPhone X",
#   "iPad Pro (12.9-inch)",
#   "iPad Pro (9.7-inch)",
#   "Apple TV 1080p"
])

Expand it back out to hit all Simulators after you’ve finished your basic debugging. But when you’re debugging, be sure to shrink it back down to one device type.

Similarly, if your “production” Snapfile uses multiple languages, trim the language list down while debugging.

First, trim it down to your development language and get thing working there.
Then, replace your development language with a different supported language, and fix the bugs related to other languages. Trust me, you’ll have some.
Once you’re finished, expand back out to the full language list.

Using the "Full" Fastlane Snapshot Install

Wed, 12 Sep 2018 18:30:00 -0400

There are two ways to install fastlane snapshot in your project - a “standalone” way (snapshot-only), or as part of the fastlane “suite” of products. The second is better, here’s why…

So-So: Snapshot-only

fastlane snapshot init

dumps your Snapfile and any associated files into the top level of your project. Some day, when you want to use more fastlane tools and a Fastfile, you’ll regret that all of the files are dumped into the project’s top level.

Better: Part of the fastlane suite

fastlane init

and then selecting the “Automate screenshots” option creates a fastlane subdirectory in your project. All of the files (including a Fastfile) are created in there. As you add more fastlane tools to your project (and you will!), they’ll all live together there. Nice and centralized, with everything fastlane-related in the same directory as the Fastfile

No matter what you do…

Move the generated SnapshotHelper.swift file into the appropriate target directory (probably *UITests) and include it from there. Don’t make your UI target’s compilation rely on source code in that fastlane directory. It will work, but it’s going to confuse someone, someday.

Testing from Working Copy

Tue, 08 May 2018 18:00:00 -0400

I’m doing more and more on the iPad these days, so I want to try moving to some system that lets me write and publish from here.

I’m following the lead of a bunch of iOS bloggers at MacStories, giving Working Copy and Pretext a try.

We’ll see how this goes!

Capture Lists and Weak References

Thu, 25 Jan 2018 17:00:00 -0500

Tonight I gave a presentation at the Swift Office Hours meetup (@SwiftHours) at Intrepid Pursuits (@intpd).

I talked about “Swift Closures, Capture Lists, and Weak References”.

In particular, I was interested in talking about capture lists, especially how they can be used to create new variables in the closure.

Here are the slides:

Strong Params and Arrays of Values

Fri, 12 Feb 2016 05:35:00 -0500

The Strong Parameters #permit method only allows permitted scalar values by default. See the documentation on permitted scalar values.

Here’s the important bit that I always forget:

To declare that the value in params must be an array of permitted scalar values map the key to an empty array:

params.permit(:id => [])

Postman and Authorization Bearer tokens

Fri, 12 Jun 2015 09:30:00 -0400

The Jawbone API (among others) uses an Authorization Bearer token in the header to specify the user’s access_token .

So if you’re using Postman to debug your API access, how do you use the Postman UI specify a Bearer token in the Authorization header?

Click the Headers button
Set a Header to Authorization
Set its Value to Bearer USERSACCESSTOKENGOESHERE . That is,
- Bearer
- followed by a space
- followed by the user’s access token

Here’s a screencap of Postman in action:

Swift @autoclosure and Lazy Evaluation

Thu, 12 Feb 2015 11:00:00 -0500

Wow, this is a bit late to the party, but I just read about Swift’s @autoclosure attribute on Apple’s Swift blog.

It’s mentioned in the context of assert functions, but using it to allow users to create lazy-evaluation functions, a la ||? Mind. Blown.

Also, the description caused a subtle shift in my understanding of closures, in the context of “lazy evaluation.” Gonna have to sleep on that!

It's a Markdown Christmas

Wed, 17 Dec 2014 03:00:00 -0500

We finished our Christmas letter to friends and family. As web nerd-ily as possible, of course. I…

Wrote a draft in Markdown
Edited it with the wife via email. She doesn’t have a Markdown editor, or even a reader, but who cares? It’s plain text. That’s the point.
When we finished editing I checked it into a new git repo. Because who doesn’t?
Then I dove into the CSS. Because I’m a web developer.
- Got the margin right for our Christmas stationary.
- Chose a font-family and font-size.
Ran it through Marked to print.

Hooray for another Microsoft Word-free (and troff-free) Christmas!

The Christmas letter repo will eventually appear on GitHub. Not yet, though - I want to mail them first!

FactoryGirl and after_initalize

Fri, 05 Dec 2014 03:00:00 -0500

I use FactoryGirl for testing, and found a major problem and solution last week.

The Problem

We use Rails after_initialization callbacks in object construction, but Rails was acting as if the parameters that we passed to FactoryGirl build or create calls weren’t there.

Well, they weren’t, at least not at object initialization..

What’s Going On

Turns out that FactoryGirl’s default behavior is to new or create the object with no arguments, and then set the properties after object initialization. Hey, guess what? That’s too late for use in after_initialization callbacks.

Solution

You can customize a Factory’s constructor to pass certain (or all) parameters to a particular factory. I had the best luck using the big hammer of

initialize_with { new(attributes) }

Your results may vary.

Thanks to @typed for pointing this out!

An Auto-Expanding CDPATH

Wed, 03 Dec 2014 03:00:00 -0500

$CDPATH is a great tool on Unix (including Mac). It’s an environment variable that improves cd, by letting you go to certain “far-away” directories without typing the whole path to get there.

There’s a good, succinct description from our neighbors at Bocoup. It also mentions using bash-completion to make it even more useful. Check out the Pivotal Labs blog for details.

$CDPATH is good on its own, but not great. To use it, you have to hard-code the parents of the directories that you want easy access to (yeesh!) into one of your bash (or zsh) dotfiles. That’s a pain, especially since I share dotfiles across machines.

But wait… standardization to the rescue!

Remember last time, when I mentioned that I keep my code projects in a predictable hierarchy? They’re all of the form $HOME/code/organization_name/project_name. So, I put this in my ~/.bashrc:

# Add all code repos (if they exist) to the end of CDPATH
if [ -d "$HOME/code" ]; then
    export CDPATH=".:$(find $HOME/code -type d -depth 1 -maxdepth 1 | tr '\n' ':')"
fi
# Initialize bash_completion if it's available
if [ -f $(brew --prefix)/etc/bash_completion ]; then
    . $(brew --prefix)/etc/bash_completion
fi

That export CDPATH line expands out to include all of the directories one level deep in $HOME/code. Since those directories include all of my coding projects, well, now they’re all just one cd away. Between that and bash_completion, command line navigation just got super-easy!