Adam Wróbel

Protocol-based dependency injection in Swift

Tue, 21 Jun 2016 00:00:00 GMT

I’ve been using protocols for dependency injection in Swift for a while, but recently I came up with a nifty little function that helps with the task using generics. Using protocols for dependency injection is a great way to abstract your code and make it more flexible. Say you get an unnamed view controller as a segue.destinationViewController property. In Swift you don’t need to cast it to specific class instance. Instead you can check for protocol conformance. “Is this X” vs “is this something that wants Y” – identity versus function. If later you add a segue to another conforming controller you won’t have to add a line of code.

So here’s that generic function that helps with this pattern:

func injectDependencies<Protocol>(
  into viewController: UIViewController,
  @noescape block: (Protocol) -> Void
) {
  if let conformingController = viewController as? Protocol {
    block(conformingController)
  }
  for controller in viewController.childViewControllers {
    injectDependencies(into: controller, block: block)
  }
}

This will traverse any table or collection view controllers that you might be using.

So in my app any controller that talks to the network does so through CacheManager which handles the requests and returns results using NSFetchedResultsController from the cache. I create the cache manager once in AppDelegate and propagate it to any controller that might need it.

func application(
  application: UIApplication,
  didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?
) -> Bool {
  cacheManager = CacheManager()

  injectDependencies(into: window!.rootViewController!) {
    (controller: ControllerWithNetworkAccess) in
    controller.cacheManager = cacheManager
  }

  return true
}

And then in segues of controllers that reference cacheManager:

override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
  injectDependencies(into: segue.destinationViewController) {
    (controller: ControllerWithNetworkAccess) in
    controller.cacheManager = cacheManager
  }
}

Swift wrapper for Grand Central Dispatch

Sun, 08 May 2016 00:00:00 GMT

I’ve written another Swift wrapper for GCD. Original C API does not fit Swift at all. It’s tedious and not very readable. Until recently I’ve been using this great gist by Tom Adriaenssen, but now I needed to use other QoS queues beside main and the background queue. Other default global queues available in GCD are: “Interactive”, “User Initiated” and “Utility”.

Problem with Tom’s implementation was that it declared three class-level methods for every queue it supported. This approach is untenable for more than two queues. Luckily with Swift we can extend types like dispatch_queue_t or dispatch_group_t and define methods that will reference self. This way we can implement sync, async, after methods that will be available on every queue including custom queues created by user.

Don’t worry about performance when compared with static definitions. I’ve declared the methods final giving the compiler hint that it can optimize and inline these calls. There won’t be any type checking or vtable lookups at runtime. So using dispatch.interactive.async {/*code*/} should generate the same binary as:

dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INTERACTIVE, 0)) {
  /* code */
}

One problem I encountered was protection against deadlock when calling sync on the currently running queue. Tom had this small check only in the main queue sync implementation (background queue wasn’t protected):

class func main(block: dispatch_block_t) {
  if NSThread.isMainThread {
    block()
  }
  else {
    dispatch_sync(dispatch_get_main_queue(), block)
  }
}

This solution obviously works only for the main queue. But I needed to implement a method that will work with any queue. At first I thought about using dispatch_get_current_queue and comparing it with self, but it turns out that the method is deprecated in C and is not available in Swift at all. I decided I can tag queues using queue specific context and check the tag using dispatch_get_specific. I admit it’s a bit of a hack but it works for any queue. Since it adds a few extra cycles I’ve limited this to a separate method which I’ve called safeSync. If you don’t need this extra protection then stick to sync and you’ll get the same safety and performance as when calling dispatch_sync directly.

So finally here’s a usage overview:

// this will wait for completion and will deadlock when called from main queue
dispatch.main.sync {
  print("hello from main queue")
}

// this will return immediately
dispatch.utility.async {
  print("working with the Utility QoS")
}

// a safe sync operation that can be sent from any queue to any queue
dispatch.main.safeSync {
  print("safety in mind")
}

// this schedules a delayed block
dispatch.main.after(2.5) {
  printWithTime("hello from main after 2.5 seconds")
}

I’ve also thrown in support for grouping tasks:

let group = dispatch.createGroup()

// schedule some asynchronous tasks
dispatch.interactive.async(group) {
  print("part of the job")
}
dispatch.user.async(group) {
  print("another part of the job")
}

// schedule asynchronous finalizer
group.notify {
  print("this will be executed when all of the group tasks complete")
}

// or synchronously wait for the group to complete
group.wait()

print("group completed")

Below is the entire implementation. It’s so small that there’s no point making it an external dependency. Just drop the code somewhere in your project and enjoy. You can also star this gist to get notified about any updates I make.

//
//  dispatch.swift
//
//  Created by Adam Wróbel. Read more at:
//  http://adamwrobel.com/blog/2016/05/08/swift-gcd-wrapper/
//

import Foundation

internal extension dispatch_queue_t {
  /// Submits a block for asynchronous execution on this queue and returns
  /// immediately.
  final func async(block: dispatch_block_t) {
    dispatch_async(self, block)
  }

  /// Submits a block for asynchronous execution on this queue and associates
  /// the block with given group.
  final func async(group: dispatch_group_t, block: dispatch_block_t) {
    dispatch_group_async(group, self, block)
  }

  /// Submits a block object for execution on this queue and waits until that
  /// block completes.
  ///
  /// Calling this method on the current queue results in deadlock.
  final func sync(block: dispatch_block_t) {
    dispatch_sync(self, block)
  }

  /// Submits a block object for execution on this queue and waits until that
  /// block completes.
  ///
  /// Prevents deadlock by executing the block immediately if called on the
  /// current queue. Performing this safety check adds a little overhead when
  /// compared with `sync`.
  final func safeSync(block: dispatch_block_t) {
    isCurrent() ? block() : sync(block)
  }

  /// Enqueue a block for execution after specified number of seconds.
  final func after(seconds: Double, block: dispatch_block_t) {
    let when = dispatch_time(DISPATCH_TIME_NOW, Int64(seconds * 1_000_000_000))
    dispatch_after(when, self, block)
  }

  /// Asynchronously runs a block on this queue when the group's tasks are
  /// complete.
  final func after(group: dispatch_group_t, block: dispatch_block_t) {
    group.notify(self, block: block)
  }
}

internal extension dispatch_group_t {
  /// Waits until all of the group's tasks are complete.
  final func wait() {
    dispatch_group_wait(self, DISPATCH_TIME_FOREVER)
  }

  /// Asynchronously runs a block on the main queue when the group's tasks are
  /// complete.
  final func notify(block: dispatch_block_t) {
    dispatch_group_notify(self, dispatch.main, block)
  }

  /// Asynchronously runs a block on the given queue when the group's tasks are
  /// complete.
  final func notify(queue: dispatch_queue_t, block: dispatch_block_t) {
    dispatch_group_notify(self, queue, block)
  }
}

final internal class dispatch {
  /// Serial queue associated with the application's main thread.
  class var main: dispatch_queue_t {
    return dispatch_get_main_queue()
  }

  /// Parallel queue used for work that is not user initiated or visible.
  class var bg: dispatch_queue_t {
    return dispatch_get_global_queue(QOS_CLASS_BACKGROUND, 0)
  }

  /// Parallel queue used for work which the user is unlikely to be immediately
  /// waiting for the results.
  class var utility: dispatch_queue_t {
    return dispatch_get_global_queue(QOS_CLASS_UTILITY, 0)
  }

  /// Parallel queue used for work that has been explicitly requested by the
  /// user, and for which results must be immediately presented in order to
  /// allow for further user interaction.
  class var user: dispatch_queue_t {
    return dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0)
  }

  /// Parallel queue used for work directly involved in providing an
  /// interactive UI.
  class var interactive: dispatch_queue_t {
    return dispatch_get_global_queue(QOS_CLASS_USER_INTERACTIVE, 0)
  }

  /// Creates a new group with which block objects can be associated.
  class func createGroup() -> dispatch_group_t {
    return dispatch_group_create()
  }
}

// Private extensions used exclusively to support `safeSync`

private extension dispatch {
  static var identityKey = UnsafePointer<Int8>(bitPattern: 1234)

  class var currentIdentity: UnsafeMutablePointer<Void> {
    return dispatch_get_specific(identityKey)
  }
}

private extension dispatch_queue_t {
  /// Uses queue specific context to determine if we're executing on this queue.
  func isCurrent() -> Bool {
    var ourIdentity = identity

    if ourIdentity == nil {
      ourIdentity = UnsafeMutablePointer<Void>(label)
      dispatch_queue_set_specific(self, dispatch.identityKey, ourIdentity, nil)
    }

    return ourIdentity == dispatch.currentIdentity
  }

  var label: UnsafePointer<Int8> {
    return dispatch_queue_get_label(self)
  }

  var identity: UnsafeMutablePointer<Void> {
    return dispatch_queue_get_specific(self, dispatch.identityKey)
  }
}

P.S. You’ll notice that I like to put all private methods in separate private extensions. This way you keep these methods away from the public interface and you don’t have to separately mark each of them as private.

P.S.S. I think the block parameter in dispatch_sync should be marked with noescape attribute, but GCD is a C API and noescape is only supported in Swift and Objective-C.

Open text editor on offenses found by RuboCop

Sat, 17 Oct 2015 00:00:00 GMT

I’ve recently added RuboCop to one of my existing, large Ruby projects. A lot of the style adjustments RuboCop was able to apply automatically, but a significant number of files was still left for me to fix.

Opening each file manually seemed like a hassle so I’ve prepared this script that opens $EDITOR on each offense, waits for user to modify the file and goes to the next offense. It’s tuned for MacVim/Vim, but any editor that doesn’t detach from shell should work. This saved me tremendous amounts of time.

require "rubocop"

class OpenEditor < RuboCop::Formatter::ProgressFormatter
  VimFamily = %w{vim gvim mvim}

  def report_file file, offenses
    super

    if editor_supports_lines?
      offenses.each do |offense|
        run_editor file, offense unless offense.corrected?
      end
    else
      run_editor file
    end
  end

  def editor
    ENV["EDITOR"]
  end

  def editor_supports_lines?
    VimFamily.include? editor
  end

  def run_editor file, offense = nil
    if offense
      args = args_with_offense file, offense
    else
      args = args_without_offense file
    end

    original_modification_time = File.mtime file

    system editor, *args

    return if original_modification_time != File.mtime(file)

    output.puts "No changes made to the file. Aborting."
    exit 1
  end

  def args_with_offense file, offense
    case editor
    when *VimFamily
      # Text vim will hide our console output, so we need to echo the message again
      # inside vim.
      message = offense.message.to_s
        .gsub('"', "double quote")
        .gsub("'", "quote")

      [
        "+#{offense.line}",           # go to line
        "-f",                         # gvim/mvim will not detach from shell
        "-c", "echomsg '#{message}'",
        file
      ]
    else
      [file]
    end
  end

  def args_without_offense file
    [file]
  end
end

And use it like this:

rubocop -r ./editor.rb -f OpenEditor

Converting or fixing MySql table character set

Mon, 27 Dec 2010 00:00:00 GMT

Recently I had to migrate some very old website to a new server. When that website was first deployed the MySql server was at version 4.0 and had no internal support for character sets. When MySql 4.1 first appeared and assigned each table and column their own character set it was very common for applications to store data with different actual encoding than the meta data specified in the database schema.

This led to problems during data migrations and also when browsing database with clients that specify their connection encoding. Whenever a connection encoding different than default (latin1) was specified MySql would try to convert the table contents to the requested coding and fail miserably if the data’s real encoding was different than what was stored in table definition. In my case I was storing utf8 data while MySql was convinced it was latin1. When in a situation like this you have two options.

If you’re able to SSH to the machine with the database then you can work around this problem during export by specifying default character set during mysqldump. If it matches the table’s character set then MySql doesn’t perform any conversion. Then you have to adjust the meta data in the data definition statements inside the sql dump. Something like this might work:

mysqldump -u user --default-character-set=latin1 -p database | \
sed -e "s/ DEFAULT CHARSET=latin1;$/ DEFAULT CHARSET=utf8;/" | \
sed -e "s/!40101 SET NAMES latin1 /!40101 SET NAMES utf8 /" > \
  good-encoding.sql

This is a safe procedure because you’re not modifying any data on the server only creating a separate dump.

Unfortunately I didn’t have shell access to the machine that was running my app, so I had to modify the data in place before doing the export with phpMyAdmin.

The documentation mentions a command in ALTER TABLE statement that can change table’s character encoding, but that command also performs data conversion and can corrupt data if it’s meta information is incorrect. That same page mentions that if you want to skip the conversion then you have to add an intermediate step and convert the column to BINARY/VARBINARY/BLOB type, change the table encoding and then convert the column back to it’s normal type. Like this:

ALTER TABLE `pages` MODIFY `title` varbinary(30) NOT NULL default '';
ALTER TABLE `pages` CHARACTER SET utf8;
ALTER TABLE `pages` MODIFY `title` varchar(30) NOT NULL default '';

After executing these statements the only thing modified should be the meta information stored in table definition. The data will remain unchanged.

I’ve written a little Ruby script that parses data definition statements generated by mysqldump or phpMyAdmin (select “no-data” option during export) and prepares these statements automatically. Note that it will not convert columns that have explicit character set definition (don’t use table default).

#!/usr/bin/ruby

targetEnc = 'utf8'
targetEnc = ARGV[0] unless ARGV.size < 1

f = $stdin
f = File.new(ARGV[1], 'r') unless ARGV.size < 2

table_name = ''
to_binary = []
to_text = []

while not f.eof? do
  line = f.readline

  # Read table name and clear sql statements
  if /^CREATE TABLE.*`([a-z_]*)`.*$/i =~ line then
    table_name = $1
    to_binary = []
    to_text = []
  end

  # prepare conversion statements for char, varchar and text
  if /^ *`([a-z_]*)` (char|varchar|text)([^,]*),?$/i =~ line then
    case $2
    when 'char' then newcol = 'binary'
    when 'varchar' then newcol = 'varbinary'
    when 'text' then newcol = 'blob'
    end

    # don't convert columns with explicit character set
    type = $3.downcase
    next if type.include? "character" or type.include? "collate"

    to_binary << "ALTER TABLE `#{table_name}` MODIFY `#{$1}` #{newcol}#{$3};"
    to_text << "ALTER TABLE `#{table_name}` MODIFY `#{$1}` #{$2}#{$3};"
  end

  # At the end of table definition puts sql statements
  if /^\) ENGINE=.*$/ =~ line then
    to_binary.each { |s| puts s }
    puts "ALTER TABLE `#{table_name}` CHARACTER SET #{targetEnc};"
    to_text.each { |s| puts s }
  end
end

This worked for me perfectly, but be careful – you’re modifying your original data.

Trigger AdWords conversion on JavaScript event

Thu, 23 Dec 2010 00:00:00 GMT

When creating ChoiceVoice we wanted to greatly simplify the order process. Wojtek decided to fit it all on single page powered by Ajax. This worked out great, but at the end of the implementation we faced a minor problem. Google’s Adwords don’t support programmatic conversion tracking. With the snippet provided by Google the user triggers conversion by navigating to a site - like a “Thank you for your order” page. This wasn’t good for us, because our clients are taken to PayPal immediately after filling out the form.

The snippet that Google provides is really simple. Most of it is JavaScript itself, so why not execute it from our own code? Let’s take a look:

<script type="text/javascript">
/* <![CDATA[ */
var google_conversion_id = 1234567890;
var google_conversion_language = "en";
var google_conversion_format = "3";
var google_conversion_color = "ffffff";
var google_conversion_label = "ABCDEFGHIJKlmnop-qr";
var google_conversion_value = 0;
/* ]]> */
</script>
<script type="text/javascript" src="http://www.googleadservices.com/pagead/conversion.js">
</script>
<noscript>
<div style="display:inline;">
<img height="1" width="1" style="border-style:none;" alt="" src="http://www.googleadservices.com/pagead/conversion/1234567890/?label=ABCDEFGHIJKlmnop-qr&amp;guid=ON&amp;script=0"/>
</div>
</noscript>

One way of triggering the conversion would be to insert the image that Google falls back to in the <noscript> tag. This would work, but I assume that this fallback method is somehow inferior to the functionality offered by the included conversion.js script (I’ve noticed that it is requesting some additional resources).

The other method would be to add something like this to your JavaScript files:

var google_conversion_id = 1234567890;
var google_conversion_language = "en";
var google_conversion_format = "3";
var google_conversion_color = "ffffff";
var google_conversion_label = "";
var google_conversion_value = 0;

var conversionLabels = {
  'voice-order': "ABCDEFGHIJKlmnop-12",
  'copy-order': "ABCDEFGHIJKlmnop-23"
};


function trackConversion(label) {
  google_conversion_label = conversionLabels[label];
  $.getScript('https://www.googleadservices.com/pagead/conversion.js');
};

/* then somewhere in your UI code: */
trackConversion('voice-order');

This code assumes that you’re using jQuery or something that provides the $.getScript() function. And also… it does not work. If you use this code to execute the conversion on user interaction, your page will end up blank. The user will be left with a white screen. Obviously not what we want him to see after placing an order with us.

After some digging around I found out that the problem was Google’s conversion.js calling document.write(). This function usually appends text to the document’s body, but there’s a catch. If the document is fully loaded it won’t append, but instead it will start a new document replacing the one currently displayed. There’s a reason for that

you probably don’t want to append anything after the </html> tag.

But Google’s conversion.js assumes that it is included inside the document’s body and while the document is still being loaded. A solution is to overwrite the default document.write() method. A fairly simple task and surprisingly safe.

In the end our trackConversion() function should look like this:

function trackConversion(label) {
  google_conversion_label = conversionLabels[label];

  document.write = function(text) {
    $('#content').append(text);
  };
  $.getScript('https://www.googleadservices.com/pagead/conversion.js');
};

The code allows you to have different conversions and select which one you want to trigger. With little effort you can add a second argument to trackConversion that will assign conversion value.

Soft hyphen and in-page search in different browsers

Mon, 20 Dec 2010 00:00:00 GMT

When creating my main page I wanted to hyphenate words in some places. This can be especially useful when putting content in narrow, justified columns. Unfortunately this rather rudimentary technique in paper media is rarely seen on the web. Currently the best way to break words on your web page is to literally[^1] add the soft-hyphen characters to your text. Soft hyphen in html is encoded with a  entity.

Fortunately, unlike how some posts dated a few years back describe it, this entity now displays properly in all modern browsers. Properly means that  displays a hyphen when there is a need to break a word, but doesn’t display anything when the word fits the line. There are other issues though.

<div style="border: 1px solid #000; width: 15em; display: inline-block;">
an&shy;tidis&shy;es&shy;tab&shy;lish&shy;ment
</div>
<div style="border: 1px solid #000; width: 3em; display: inline-block;">
an&shy;tidis&shy;es&shy;tab&shy;lish&shy;ment
</div>

antidisestablishment

It’s not perfect though. Beside some text selection and copying quirks that you might notice there’s also a major problem. Some browsers do not handle in-page search correctly. Try searching for “antidisestablishment” on this page.

Two browsers that I’ve tested seem to handle this correctly. All the other not only do not find a word that had hyphen inserted, but don’t even find a word that fits the line if it contains some  entities inside it. I’m going to lay it out in a table including both possible behaviors even though there’s currently no browser that demonstrates partial support for searching for words with soft hyphens.

	Finds a word that fits	Finds a hyphenated word
Chrome 8	✓	✓
Firefox 3.6	✓	✓
Safari 5	✗	✗
Opera 11	✗	✗
IE 8	✗	✗

You might also be interested how search engines handle this. This post suggests that at least google doesn’t have any problem with the  entity.

[^1]: Literally doesn’t mean you have to type them in manually. I use patched Text::Hyphen Ruby gem and a Rails block helper to calculate and insert the hyphens for me.