Oops! I committed to the wrong branch

by David on June 26, 2017July 6, 2017

It is common when working with git to use lots of branches. Occasionally you might accidentally commit to the wrong branch but thankfully git makes it easy to put these commits in the right place.

It’s worth noting that the fixes described here are only for when you haven’t pushed anything to a remote branch otherwise you will be changing history that someone else might have already pulled.You don’t want to do that.

There are two scenarios we will consider.

Move recent commits into new <branch> instead of <master>

This is when you made a couple of commits to master but now realise they should have been split into a separate branch.

This is easy to fix: first make a copy of the current state of your master branch, then roll it back to the previous commit. For example, if the commit hash before your changes was a6b4c974:

git branch <branch>
git reset --hard a6b4c974
git checkout <branch>

git branch <branch>

git reset --hard a6b4c974

git checkout <branch>

Accidentally committed on <master> instead of <branch>

This is when you should have committed to an existing branch but accidentally committed to master; a similar situation to the first but requires some different voodoo to fix.

Again, we make a copy of the current state in a tmp branch and reset master. Then we use the three argument form of git rebase –onto to remove the offending commits. We want to get the commits that are now in <tmp> into <branch>. We want to make <branch> the new base of <tmp> starting at the point where <tmp> diverged from master. We then merge these changes into <branch> where they should have been committed originally.

git branch <tmp>
git reset --hard a6b4c974
git rebase --onto <branch> <master> <tmp>
git checkout <branch>
git merge <tmp>
git branch -d <tmp>

git branch <tmp>

git reset --hard a6b4c974

git rebase --onto <branch> <master> <tmp>

git checkout <branch>

git merge <tmp>

git branch -d <tmp>

Time zone conversion in Google Sheets

by David on January 31, 2017July 6, 2017

Google Sheets does not have a built in way of converting time zone data but by using the power of Moment.js and Google’s script editor we can add time zone functionality to any sheet.

First, we need to add the Moment.js code as a library that can be shared between different documents. This is the javascript library that adds date and time zone manipulation support. A good way to do this is to create it from Google Drive so it can be easily edited and shared with all your sheets.

In Google Drive, go to New > More > Connect more apps and choose Google Apps Script. Now, create a new Google Apps Script document. This will open the Google script editor. Call the project ‘Moment’ and create two files in the project called moment.js and moment-timezone.js using the moment and moment-timezone libraries. Make sure you choose one of the moment-timezone files with time zone data. You should end up with a project something like this:

To easily use this in multiple sheets we can publish it as a library. Go to File > Manage versions and save a new version. We are nearly finished here but before we move on go to File > Project properties and make a note of the project key, you will need this to refer to your library in your sheets.

In our test we are going to use our new library to convert times in a local time zone to UTC.

Create a new Google sheet and enter a date in A1 and a time zone in B1, like this:

Go to Tools > Script editor and create a project called Functions. In the script editor, go to Resources > Libraries and using the project key you made a note of before add your Moment library and select version 1. I prefer to use a shorter identifier like ‘m’. Click save and your library is now accessible to your sheet’s script. We can create a function to convert to UTC like this:

function toUtc(dateTime, timeZone) {
  var from = m.moment.tz(dateTime, timeZone);
  return from.tz("Etc/UTC").format('YYYY-MM-DD HH:mm:ss');
}

function toUtc(dateTime, timeZone) {

var from = m.moment.tz(dateTime, timeZone);

return from.tz("Etc/UTC").format('YYYY-MM-DD HH:mm:ss');

}

Save your project and you can now use this function in your sheets like this:

=toUtc(TEXT(A1, "YYYY-MM-DD HH:mm:ss"), B1)

1	=toUtc(TEXT(A1, "YYYY-MM-DD HH:mm:ss"), B1)

Loading test data with ScalaTest + Play

by David on September 19, 2016July 6, 2017

The ScalaTest + Play library provides a couple of useful traits for when your ScalaTest Play Framework functional tests need a running application for context. The OneAppPerSuite trait will share the same Application instance across all tests in a class whereas the OneAppPerTest trait gives each test its own Application instance.

These traits will ensure you have a running application for your tests but if you want to test code that operates on a database it can be helpful to load some known test data before each test and clean it up afterwards. For this, we can mix in a ScalaTest before-and-after trait.

The BeforeAndAfter trait lets you define a piece of code to run before each test with before and/or after each test with after. There is also a BeforeAndAfterAll trait which invokes methods before and after executing the suite but resetting the database for each test makes for better test isolation.

Here is a base test class that sets up a running application and uses the Evolutions companion object to load and clean up the database. Note this class uses Guice dependency injection to retrieve the database object but you can also easily connect to a database using the Database companion object.

We also override the db.default.url config value to point to a test database.

import org.scalatest.BeforeAndAfter
import org.scalatestplus.play.{OneAppPerSuite, PlaySpec}
import play.api.Application
import play.api.db.Database
import play.api.db.evolutions.{Evolution, Evolutions, SimpleEvolutionsReader}
import play.api.inject.guice.GuiceApplicationBuilder

abstract class IntegrationSpec extends PlaySpec with OneAppPerSuite with BeforeAndAfter {

  implicit override lazy val app: Application = new GuiceApplicationBuilder()
    .configure("db.default.url" -> sys.env.getOrElse("DB_TEST_URL", "jdbc:mysql://localhost:3306/my_test_db?useSSL=false"))
    .build

  before {
    val db = app.injector.instanceOf[Database]

    // Load the database schema
    Evolutions.applyEvolutions(db)

    // Insert test data
    Evolutions.applyEvolutions(db, SimpleEvolutionsReader.forDefault(
      Evolution(
        999,
        "insert into test (name, amount) values ('test', 0.0);",
        "delete from test;"
      )
    ))
  }

  after {
    val db = app.injector.instanceOf[Database]
    Evolutions.cleanupEvolutions(db)
  }
}

import org.scalatest.BeforeAndAfter

import org.scalatestplus.play.{OneAppPerSuite, PlaySpec}

import play.api.Application

import play.api.db.Database

import play.api.db.evolutions.{Evolution, Evolutions, SimpleEvolutionsReader}

import play.api.inject.guice.GuiceApplicationBuilder

abstract class IntegrationSpec extends PlaySpec with OneAppPerSuite with BeforeAndAfter {

implicit override lazy val app: Application = new GuiceApplicationBuilder()

.configure("db.default.url" -> sys.env.getOrElse("DB_TEST_URL", "jdbc:mysql://localhost:3306/my_test_db?useSSL=false"))

.build

before {

val db = app.injector.instanceOf[Database]

// Load the database schema

Evolutions.applyEvolutions(db)

// Insert test data

Evolutions.applyEvolutions(db, SimpleEvolutionsReader.forDefault(

Evolution(

999,

"insert into test (name, amount) values ('test', 0.0);",

"delete from test;"

)

))

}

after {

val db = app.injector.instanceOf[Database]

Evolutions.cleanupEvolutions(db)

}

You can also load evolutions from the file system if you don’t want to define them in the code.

A systemd unit file for Play Framework

by David on June 15, 2016July 6, 2017

New for Ubuntu 16.04 (Xenial Xerus) is systemd which replaces Upstart as the default init system.

systemd basics

The basic object that systemd manages is the unit which can be of different types but when it comes to running our Play app we will need to create a service.

The systemctl command is used to manage systemd services, similar to the old service command. E.g. to start Nginx you now type:

sudo systemctl start nginx.service

1	sudo systemctl start nginx.service

Custom unit files should go in the /etc/systemd/system directory and you should always run the following command after creating new unit files or modifying existing ones:

sudo systemctl daemon-reload

1	sudo systemctl daemon-reload

Run levels have been replaced with systemd units called targets. Target unit files end with the .target file extension and they are used to group other units.

A Play Framework unit file

Here is a basic Play Framework systemd unit file. It makes use of the EnvironmentFile directive which can be used to set environment variables. It is possible to set environment variables in the unit file directly but using a separate file takes some of the clutter out.

Deploying the unit file

Create the env file in your app’s conf directory and unit file in /etc/systemd/system
Set the file permissions

sudo chmod 664 /etc/systemd/system/play.service

1	sudo chmod 664 /etc/systemd/system/play.service

Reload systemd

sudo systemctl daemon-reload

1	sudo systemctl daemon-reload

You can now start and stop your play app using systemctl

sudo systemctl start play.service
sudo systemctl stop play.service

1 2	sudo systemctl start play.service sudo systemctl stop play.service

Rich Interfaces In Java

by David on March 14, 2016March 11, 2016

One of the new features added to Java 8 is default methods. In previous versions of Java, adding a new method to an interface would break existing implementations. This made it very hard to evolve your public API without disrupting your clients. Java 8 now allows implementations of methods in an interface. This was needed because Java 8 introduced many new methods on existing interfaces such as sort in List or stream in Collection .

Thin versus rich interfaces

When creating an interface you face a trade-off in either making it rich or thin. A rich interface has many methods which makes it convenient for the caller while a thin interface has only a few methods which makes it easy to implement but not quite as useful for the caller.

Traditionally Java interfaces have been thin rather than rich. Scala, on the other hand, has traits which allow concrete implementations and so tend to be very rich. Now that Java 8 has default methods we can take the same rich interface approach in our Java code as Scala does with traits.

To create a rich interface, define a small number of abstract methods and a large number of concrete methods defined in terms of the abstract methods. Implementors of your interface need only implement the thin abstract part of your interface and thereby gain access to the richer part without having to write any more code.

An example

As a simple example I have implemented the Rational class and Ordered trait from the Programming in Scala book. We don’t get the symbolic method names and implicit conversions but the rich interface concept remains the same.

Here is our rich Ordered interface. It declares one abstract method compare but also implements a number of convenience methods in terms of this abstract method.

/**
 * A 'rich' interface for data that have a single, natural ordering.
 * Clients need only implement the compare method.
 */
public interface Ordered<T> {

    /**
     * Result of comparing `this` with operand `that`.
     *
     * Implement this method to determine how instances of T will be sorted.
     *
     * Returns `x` where:
     *
     *   - `x < 0` when `this < that`
     *
     *   - `x == 0` when `this == that`
     *
     *   - `x > 0` when  `this > that`
     */
    int compare(T that);

    /**
     * Returns true if `this` is less than `that`
     */
    default boolean lessThan(T that) {
        return compare(that) < 0;
    }

    /**
     * Returns true if `this` is greater than `that`.
     */
    default boolean greaterThan(T that) {
        return compare(that) > 0;
    }

    /**
     * Returns true if `this` is less than or equal to `that`.
     */
    default boolean lessThanOrEqual(T that) {
        return compare(that) <= 0;
    }

    /**
     * Returns true if `this` is greater than or equal to `that`.
     */
    default boolean greaterThanOrEqual(T that) {
        return compare(that) >= 0;
    }

    /**
     * Result of comparing `this` with operand `that`.
     */
    default int compareTo(T that) {
        return compare(that);
    }
}

/**

* A 'rich' interface for data that have a single, natural ordering.

* Clients need only implement the compare method.

public interface Ordered<T> {

/**

* Result of comparing `this` with operand `that`.

* Implement this method to determine how instances of T will be sorted.

* Returns `x` where:

* - `x < 0` when `this < that`

* - `x == 0` when `this == that`

* - `x > 0` when `this > that`

int compare(T that);

/**

* Returns true if `this` is less than `that`

default boolean lessThan(T that) {

return compare(that) < 0;

}

/**

* Returns true if `this` is greater than `that`.

default boolean greaterThan(T that) {

return compare(that) > 0;

}

/**

* Returns true if `this` is less than or equal to `that`.

default boolean lessThanOrEqual(T that) {

return compare(that) <= 0;

}

/**

* Returns true if `this` is greater than or equal to `that`.

default boolean greaterThanOrEqual(T that) {

return compare(that) >= 0;

}

/**

* Result of comparing `this` with operand `that`.

default int compareTo(T that) {

return compare(that);

}

Here is our Rational class which implements Ordered. Apart from overriding equals and hashCode, the only method we need to implement is compare and we get lessThan, greaterThan, lessThanOrEqual, greaterThanOrEqual and compareTo “for free”.

public class Rational implements Ordered<Rational> {

    public final int numerator;
    public final int denominator;

    public Rational(int numerator, int denominator) {
        if (denominator == 0) {
            throw new IllegalArgumentException("Denominator cannot be 0");
        }
        int g = gcd(Math.abs(numerator), Math.abs(denominator));
        this.numerator = numerator / g;
        this.denominator = denominator / g;
    }

    private int gcd(int a, int b) {
        if (b == 0) {
            return a;
        } else {
            return gcd(b, a % b);
        }
    }

    @Override
    public boolean equals(Object that) {
        if (that == this) {
            return true;
        }

        if (!(that instanceof Rational)) {
            return false;
        }

        Rational r = (Rational) that;
        return r.numerator == this.numerator && r.denominator == this.denominator;
    }

    @Override
    public int hashCode() {
        int result = 17;
        result = 31 * result + numerator;
        result = 31 * result + denominator;
        return result;
    }

    @Override
    public String toString() {
        return numerator + "/" + denominator;
    }

    @Override
    public int compare(Rational that) {
        return (this.numerator * that.denominator) - (this.numerator * this.denominator);
    }

    public Rational add(Rational that) {
        return new Rational(this.numerator * that.denominator + that.numerator * this.denominator,
                this.denominator * that.denominator);
    }

    public Rational times(Rational that) {
        return new Rational(this.numerator * that.numerator, this.denominator * that.denominator);
    }
}

public class Rational implements Ordered<Rational> {

public final int numerator;

public final int denominator;

public Rational(int numerator, int denominator) {

if (denominator == 0) {

throw new IllegalArgumentException("Denominator cannot be 0");

}

int g = gcd(Math.abs(numerator), Math.abs(denominator));

this.numerator = numerator / g;

this.denominator = denominator / g;

}

private int gcd(int a, int b) {

if (b == 0) {

return a;

} else {

return gcd(b, a % b);

}

@Override

public boolean equals(Object that) {

if (that == this) {

return true;

}

if (!(that instanceof Rational)) {

return false;

}

Rational r = (Rational) that;

return r.numerator == this.numerator && r.denominator == this.denominator;

}

@Override

public int hashCode() {

int result = 17;

result = 31 * result + numerator;

result = 31 * result + denominator;

return result;

}

@Override

public String toString() {

return numerator + "/" + denominator;

}

@Override

public int compare(Rational that) {

return (this.numerator * that.denominator) - (this.numerator * this.denominator);

}

public Rational add(Rational that) {

return new Rational(this.numerator * that.denominator + that.numerator * this.denominator,

this.denominator * that.denominator);

}

public Rational times(Rational that) {

return new Rational(this.numerator * that.numerator, this.denominator * that.denominator);

}

Here’s a unit test that exercises the class.

import org.junit.Test;

import static org.junit.Assert.*;

public class RationalTest {

    private final Rational half = new Rational(1, 2);
    private final Rational third = new Rational(1, 3);
    private final Rational twoThirds = new Rational(2, 3);
    private final Rational twoFourths = new Rational(2, 4);

    @Test(expected = IllegalArgumentException.class)
    public void divideByZero() throws Exception {
        new Rational(1, 0);
    }

    @Test
    public void testEquals() throws Exception {
        assertEquals(twoFourths, twoFourths);
        assertEquals(half, twoFourths);
        assertEquals(twoFourths, half);
        assertFalse(half.equals(twoThirds));
    }

    @Test
    public void testHashCode() throws Exception {
        assertEquals(twoFourths.hashCode(), new Rational(2, 4).hashCode());
        assertEquals(half.hashCode(), twoFourths.hashCode());
        assertFalse(half.hashCode() == twoThirds.hashCode());
    }

    @Test
    public void testString() throws Exception {
        assertEquals("2/5", new Rational(2, 5).toString());
        assertEquals("1/2", new Rational(3, 6).toString());
    }

    @Test
    public void compare() throws Exception {
        assertFalse(half.lessThan(third));
        assertTrue(third.lessThan(half));

        assertFalse(third.greaterThan(half));
        assertTrue(half.greaterThan(third));

        assertTrue(half.lessThanOrEqual(half));
        assertTrue(half.lessThanOrEqual(twoFourths));

        assertTrue(third.greaterThanOrEqual(third));
        assertTrue(twoFourths.greaterThanOrEqual(half));
    }

    @Test
    public void compareTo() throws Exception {
        assertTrue(third.compareTo(half) < 0);

        assertTrue(half.compareTo(half) == 0);
        assertTrue(half.compareTo(twoFourths) == 0);

        assertTrue(half.compareTo(third) > 0);
    }

    @Test
    public void add() throws Exception {
        Rational sevenSixths = half.add(twoThirds);

        assertEquals(7, sevenSixths.numerator);
        assertEquals(6, sevenSixths.denominator);
    }

    @Test
    public void times() throws Exception {
        Rational twoSixths = half.times(twoThirds);

        assertEquals(1, twoSixths.numerator);
        assertEquals(3, twoSixths.denominator);
    }
}

import org.junit.Test;

import static org.junit.Assert.*;

public class RationalTest {

private final Rational half = new Rational(1, 2);

private final Rational third = new Rational(1, 3);

private final Rational twoThirds = new Rational(2, 3);

private final Rational twoFourths = new Rational(2, 4);

@Test(expected = IllegalArgumentException.class)

public void divideByZero() throws Exception {

new Rational(1, 0);

}

@Test

public void testEquals() throws Exception {

assertEquals(twoFourths, twoFourths);

assertEquals(half, twoFourths);

assertEquals(twoFourths, half);

assertFalse(half.equals(twoThirds));

}

@Test

public void testHashCode() throws Exception {

assertEquals(twoFourths.hashCode(), new Rational(2, 4).hashCode());

assertEquals(half.hashCode(), twoFourths.hashCode());

assertFalse(half.hashCode() == twoThirds.hashCode());

}

@Test

public void testString() throws Exception {

assertEquals("2/5", new Rational(2, 5).toString());

assertEquals("1/2", new Rational(3, 6).toString());

}

@Test

public void compare() throws Exception {

assertFalse(half.lessThan(third));

assertTrue(third.lessThan(half));

assertFalse(third.greaterThan(half));

assertTrue(half.greaterThan(third));

assertTrue(half.lessThanOrEqual(half));

assertTrue(half.lessThanOrEqual(twoFourths));

assertTrue(third.greaterThanOrEqual(third));

assertTrue(twoFourths.greaterThanOrEqual(half));

}

@Test

public void compareTo() throws Exception {

assertTrue(third.compareTo(half) < 0);

assertTrue(half.compareTo(half) == 0);

assertTrue(half.compareTo(twoFourths) == 0);

assertTrue(half.compareTo(third) > 0);

}

@Test

public void add() throws Exception {

Rational sevenSixths = half.add(twoThirds);

assertEquals(7, sevenSixths.numerator);

assertEquals(6, sevenSixths.denominator);

}

@Test

public void times() throws Exception {

Rational twoSixths = half.times(twoThirds);

assertEquals(1, twoSixths.numerator);

assertEquals(3, twoSixths.denominator);

}

This is a very simple example but shows how we can introduce Scala’s rich interface style of traits into our Java 8 code.