You have a repository in GIT. For some reason, your project produces artifacts that change all the time, for instance

• A filename is injected into them (Stupid Entity Framework EDMX changes) and this filename changes depending on who runs it
• A filename that continually gets injected with different line endings
• Any other reason

If you would just like to ignore it then you can try the following

git update-index --skip-worktree .\YourFileToIgnore.txt

And then if you change your mind use

git update-index --no-skip-worktree .\YourFileToIgnore.txt

to reverse it.

I'm using Intravenous more and more to implement the IOC pattern using Node at work. One of the issues with it however is that everything that you use with it either has to be:

1. An ES5 "class" with an $inject property (an array that allows Intravenous to reflect on your constructor arguments for the constructor. By the way, Intravenous doesn't do ES6. Have a look at mainliner it you want to do native ES6.
2. A plain old JavaScript object.

In order to support the normal IOC things like lifetime and constructor injection you need your code to be a ES5 class as per option 1. 9 times out of 10 this is what you so therefore it forces you to write your code exactly like it expects which isn't really the way things work in the real world. I mean, who on earth is going to publish a module exporting a class with a $inject property and even if they did, you would probably just need to over write it with different identifiers anyway unless you had a very, very controlled environment.

So, my implementation uses a pattern that looks a bit like this:

import Assert from "assert";
import Bacon from "bacon";
    
export default class BaconWrapper {
      
  constructor(logger) {

    Assert(logger, "logger is required");
    this.bacon_ = new Bacon(logger);
  }

  eatBacon(...args) {

    return this.bacon_.eatBacon(...args);
  }
}

BaconWrapper.$inject = ["logger"];

and after registering BaconWrapper in my container, it works a treat. The problem with this approach of course is that it is:

1. Incredibly manual and tedious.
2. Every time you change an interface the a wrapper needs to change too!

Also, all of this manual code gives you a tonne of new tests you have to write. Yuck.

I figured, especially as this is JavaScript, there must be a better way - and here it is.

function adaptToInjectable(ctrArgNames, ctrArgInjectNames, objectFactory, proxiedKeys) {

  const f = function () {

    // Assert that constructor is new'ed
    Assert(this && this.constructor === f, "constructor must be called with new");

    // Assert arguments
    for (let x = 0; x < ctrArgNames.length; x += 1) {
      Assert(arguments[x.toString()], `${ctrArgNames[x]} is required`);
    }

    // Constructor wrapper object
    const args = Array.from(arguments);
    this.wrappedObject_ = objectFactory.apply(null, args);

    // Proxy each key in proxiedKeys
    for (const key of proxiedKeys) {
      const actor = this.wrappedObject_[key];

      // Something is pertty wrong if we are proxying a key with an undefined value
      Assert(typeof actor !== "undefined", `proxiedKey ${key} does not exist`);

      // If the property is a function then bind it back to the wrappedObject,
      // otherwise just set one to the other
      if (typeof actor === "function") {
        this[key] = actor.bind(this.wrappedObject_);
      } else {
        this[key] = actor;
      }
    }
  }

  // Add $inject
  f.$inject = ctrArgInjectNames;

  return f;
}

So, as you can see this adaptor allows you to wrap a piece of arbitrary code (it doesn't even need to be a class) and with just a small piece of code get it up to a state that is easily injectable into a container.

So, given the following service

class CakeService {

	constructor(logger, cakeType) {

    Assert(logger);
    Assert(cakeType);
    this.logger_ = logger;
    this.cakeType_ = cakeType;
  }

  eat() {

    this.logger_.info(`Nom, nom, nom - I love ${this.cakeType_} cake`);
  }

  get cakeType() {

    return this.cakeType_
  }
}

We can adapt this using the following code

const sut = adaptToInjectable(
  ["logger"],
  ["myLogger"],
  (logger) => new CakeService(logger, "chocolate"),
  ["eat", "cakeType"]
);

And all of the following assertions should work on the class

  Assert.throws(() => sut(), /^AssertionError: constructor must be called with new$/,
    "Should assert that ctx called with new");
  Assert.throws(() => new sut(), /^AssertionError: logger is required$/, "Logger is a required argument");
  Assert.deepEqual(sut.$inject, ["myLogger"], "$inject is not set to required arguments");

  const mockLogger = {
    "info": Sinon.stub()
  };
  const actual = new sut(mockLogger);

  Assert(actual.cakeType, ".cakeType should be defined");
  Assert.strictEqual(actual.cakeType, "chocolate");

  Assert(actual.eat, ".eat should be defined");
  Assert(typeof actual.eat === "function", ".eat should be a function");
  Assert.doesNotThrow(() => actual.eat(), ".eat should not throw");
  Sinon.assert.calledWith(mockLogger.info);
  Sinon.assert.calledWithExactly(mockLogger.info, "Nom, nom, nom - I love chocolate cake");

I hope that this helps.

I am using Kodi (previously XMBC) on one of my Raspberry Pi as a small media centre. This is serving videos from my old SAN where I store and share my backed up DVD's via SMB. This works great except for one small problem. My Mac. Normally Mac's store a resource fork in another section of a file on a Mac filesystem (MFS, HFS and HFS Plus). It uses this to store metadata about the file. As SMB drives don't support resource forks this is performed using a file that looks like ._filename where filename is the name of the original file. By default Kodi picks this file up at scan time and thinks that it is a video file so it adds the TV-Show or Movie twice with only the one file working. This is annoying as you have to manually delete the wrong entry.

To get around this you can use the advancedsettings.xml file to stop Kodi from picking up these files when it does a scan.

Create or add the advancedsettings.xml with the following:

<advancedsettings>
	<video>
		<excludefromscan> <!-- Regular expressions that if evaluated to true won't be added to library. -->
			<regexp>[-\._ ](sample|trailer)[-\._ ]</regexp>
			<regexp>[-\._ ](sample|trailer)[-\._ ]</regexp>
			<regexp>\/\._</regexp>
		</excludefromscan>
		<excludetvshowsfromscan>
			<regexp>\/\._</regexp>
		</excludetvshowsfromscan>
		<excludefromlisting>
            <!-- Regular expressions that if evaluated to true won't be displayed in Files View -->
			<regexp>[-\._ ](sample|trailer)[-\._ ]</regexp>
			<!-- <regexp>/\._</regexp> -->
		</excludefromlisting>
	</video>
</advancedsettings>

After this add your libraries. This will stop Kodi from pickup up anything that starts with ._ and also the word sample or trailer (for good measure).

If you do this after you have added your files to your library then you will still have to delete the entries manually but at least it won't add any new ones.

Just a quick note for readers to check if they're details were in the recent Adobe leak which saw somewhere between 150 million and 38 million email addresses and encrypted passwords dumped onto the Internet by Hackers. You can check out [this password check page](LastPass adobe password check) provided by LastPass to see if you are affected.

If you are someone who uses the same password, over and over again then you might want to download LastPass, get an account and STOP USING A SINGLE PASSWORD!.

I've been using a [YubiKey and LastPass premium membership](YubiKey and premium membership) for a couple of years now and I love it. This makes using long, complex and most importantly unique passwords easy.

Thanks for reading,

I found a really neat little feature of the OS-X terminal today. You can display colourful little icons on the terminal by displaying a unicode character. You can enter a unicode character on the terminal with code such as the following (which works in the bash shell).

echo $'\xF0\x9F\x98\x83'

this example will display the emoticon of "U+1F603 SMILING FACE WITH OPEN MOUTH". The codes are the UTF-8 hex values for the character which you can see on the page.

Have a look at some of these pages for some more inspiration:

• Emoticons
• Miscellaneous symbols and pictographs

Find one that you like and replace the UTF-8 codes for the codes for the image you want to see.

Thanks for reading.

As I hinted in my last post I really like Markdown. So much so that when I am writing documentation, letters resumes or anything else, usually I will do anything to avoid having to write them up in Word or any of the many alternatives.

Write up the document

Byword 2 is great when working on large documents as you can put it in full screen and just see what it is that you are working on. It also has a Markdown preview so can instantly see what you are working on.

I then usually move to Vim for the last little updates (things like spacing can be a bit tricky in Byword as you can't turn on visible whitespace which is helpful for doing line breaks. The vim-markdown plugin is great for

Convert the markdown

Although you can then export either a PDF or HTML file from the formatted Markdown I prefer to use another application called Pandoc.

Pandoc is a library written in Haskell which can convert files from one markup language to another. It does this in a nice way in that it converts the input file into it's own internal format first so that the output filter then only has to know how to convert from one type of file - Pandoc's internal format, making writing new filter's easier.

I use it to convert my files into PDF (Using Latex) and DOCX formats usually but you can also convert your files to:

• HTML and HTML5
• OpenDocument XML
• ODT
• DocBook
• MediaWiki markup
• RTF

and many others. You can even convert them back into Markdown (if you wanted to).

It is a simple matter of calling running it at the command line to generate your files but I have created the following bash script to make creating the PDF and DOCX files even quicker.

#! /bin/bash

# Check for 1 argument
if [ "$#" != "1" ]
	then
		echo "You must include the name of the markdown file to process. Don't include the .md extension"
		exit 100
fi

# Check the filename argument
extension="${1##*.}"
filename="${1%.*}"
if [ "$extension" == "md" ]
	then
		filename="${1%.*}" 
elif [ -r "$1.md" ]
	then
		filename="$1" 
else 
		echo "File not found."
		exit 200
fi

# Generate Word document
if [ -f "$filename.docx" ]
	then
		rm "$filename.docx"
fi
echo Generating docx file
pandoc "$filename.md" -o "$filename.docx" -t docx

# Generate PDF document
if [ -f "$filename.pdf" ]
	then
		rm "$filename.pdf"
fi
echo Generating pdf file
pandoc "$filename.md" -V geometry:margin=1in -o "$filename.pdf" -t latex

# Done
echo Done.

process-md.sh

for this to work, make sure that the file has execute access and call it with the name of the .md file that you want to convert (it does expect that the files have an extension of md but that could be easily changed).

Thanks for reading.

I've been playing around with Node JS a little bit lately and at the same time had finally decided that I needed a blog to show off and record some stuff that I have been working on in my very meagre spare time.

I then found Ghost which solved both twitches at the same time. Even better, all of the content is written in Markdown which for me is a total win-win as I think Markdown is fantastic for writing and go to great lengths to enable myself to write things in Markdown when ever possible.

I went ahead and started installing it on my notebook. I already had the basics (node js and npm) installed so it was very easy. I then started looking into installing it on my Rackspace cloud server when I found an article talking about a great new Rackspace feature called deployments. If you want to get a specific product up and running very quickly and don't want to or need to do it yourself then it is a really quick way to get it up and running straight away. Basically it works like this

1. Log into your Rackspace account.
2. Click on Deployments.
3. Type in a name for for the deployment.
4. Select a region to host the server.
5. Select the application to be deployed (in my case Ghost).
6. Type in any additional information required by the application - in the case of Ghost it just requires a URL.
7. Hit "Next Step" and then select the size of the cloud server to create.
8. Wait for about 5 minutes.
9. Once it has finished, the IP address for the new cloud server and use those to create a new DNS record for it pointing at the URL that you used when setting it up.
10. Once the DNS has propagated then you are done.

Although I think that I will eventually redo this, this did save me a good chunk of time which is what really matters in the short term.

Thanks for reading.