Manuel Rueda Blog's RSS Feed

TypeScript Complex Types

Wed, 03 Apr 2019 13:00:00 GMT

TypeScript’s type system is Turing Complete and give us the power to create powerful but complex type definitions to power our codebase. This is feasible thanks to mapped types, recursive types, conditional types, index accessible types, union types and generic types.

This is cool but there is not much documentation or practical example about it, the TypeScript Advanced Types article has minimal examples and explanations about how the use of these.

In this article I will show some “real life” examples to show what can be achievable with this.

Self reference type

Let say that we want to create an object that has a property foo of type string and a property bar that its type is defined based on the value of foo.

interface FooTypesMap {
    one: string;
    two: boolean;
    three: {
        one: Date
    };
}

type MyType = {
    [k in keyof FooTypesMap]: {
        foo: k,
        bar: FooTypesMap[k],
    }
}[keyof FooTypesMap]


const instanceOne: MyType = {
    foo: 'one',
    bar: 'some value',
}

const instanceTwo: MyType = {
    foo: 'two',
    bar: true,
}

const instanceThree: MyType = {
    foo: 'three',
    bar: {
        one: new Date()
    },
}

In this example we are using mapped types, index accessible types and union types to achieve type that can mutate based on the values of itself.

Specific self reference type

If you play around with the previous example you will find out that MyType is an union type of all possible combinations and when you define foo value TypeScript can narrow those possibilities to only the ones that match foo === X. But what about if you want to declare a variable of a specific possibility of that type? That is not possible in the previous example but here is how you can achieve it.

interface FooTypesMap {
    never: never;
    one: string;
    two: boolean;
    three: {
        one: Date
    };
}

type MyType<TType extends keyof FooTypesMap = 'never'> = {
    [k in keyof FooTypesMap]: {
        foo: TType extends 'never' ? k : TType,
        bar: FooTypesMap[TType extends 'never' ? k : TType],
    }
}[keyof FooTypesMap]

let instanceFour: MyType<'three'>;

instanceFour = {
    foo: 'three',
    bar: {
        one: new Date()
    }
}

The difference with the previous example is that new added an optional generic type with a default value of never and use it inside a conditional type to verify if is declared or is the default. If is declared we use that type to define foo’s type and to get the type for bar and if its not defined we use k like the previous example.

The only hacky thing here is that never: never definition in FooTypesMap, that allow us to keep the type constraint TType extends keyof FooTypesMap that defines that TType has to be a key of FooTypesMap.

Recursive self reference type

There is one more level of type complexity that we can add to our MyType, what if we need an extra optional property called baz that is type MyType. This will allow us to use recursive types.

Also I will add a property called qux that is a map of N number of optional properties of type MyType to show how powerful can be.

interface FooTypesMap {
    never: never;
    one: string;
    two: boolean;
    three: {
        one: Date
    };
}

type MyType<TType extends keyof FooTypesMap = 'never'> = {
    [k in keyof FooTypesMap]: {
        foo: TType extends 'never' ? k : TType,
        bar: FooTypesMap[TType extends 'never' ? k : TType],
        baz?: MyType,
        qux?: {
            [key: string]: MyType
        }
    }
}[keyof FooTypesMap]

let instance: MyType<'three'>;

instance = {
    foo: 'three',
    bar: {
        one: new Date()
    },
    baz: {
        foo: 'one',
        bar: 'some value'
    },
    qux: {
        myKey: {
            foo: 'two',
            bar: false,
        }
    }
}

Thanks Keshav for all the help with this typings!

TypeScript Tipos Complejos

Wed, 03 Apr 2019 13:00:00 GMT

El sistema de tipos de TypeScript es Turing Completo y eso nos da el poder de definir tipos complejos para alimentar nuestro código. Esto es posible gracias a tipos mapeados (mapped types), tipos recursivos (recursive types), tipos condicionales (conditional types), tipos accesibles por indice (index accesibles types), union de tipos(union types) y tipos genéricos (generic types).

Esto es genial, pero no hay mucha documentación o ejemplos prácticos al respecto, el articulo TypeScript Advanced Types tiene algunos ejemplos y explicaciones mínimas acerca de como usarlos.

En este articulo les voy a mostrar ejemplos “de la vida real” para demostrar que se puede obtener con esto.

Tipo de auto-referencia

Digamos que quiero crear un objeto que tiene una propiedad foo de tipo string y a una propiedad bar la cual tendra su tipo definido en base al valor de foo.

interface FooTypesMap {
    one: string;
    two: boolean;
    three: {
        one: Date
    };
}

type MyType = {
    [k in keyof FooTypesMap]: {
        foo: k,
        bar: FooTypesMap[k],
    }
}[keyof FooTypesMap]


const instanceOne: MyType = {
    foo: 'one',
    bar: 'algún valor',
}

const instanceTwo: MyType = {
    foo: 'two',
    bar: true,
}

const instanceThree: MyType = {
    foo: 'three',
    bar: {
        one: new Date()
    },
}

En este ejemplo estamos usando tipos mapeados (mapped types), tipos accesibles por indice (index accesibles types) y union de tipos(union types) para obtener un tipo que cambia en base al valor de una propiedad de la instancia.

Tipo de auto-referencia especifico

Si juegan un poco con el ejemplo anterior ser darán cuenta que MyType es una union de tipos(union types) de todos las posibles combinaciones y cuando el valor de foo es definido, TypeScript puede reducir el numero de posibilidades a solo las que respetan foo === X. Pero como hacemos si queremos declarar una variable con una de esas posibilidades específicamente? Eso no es posible con este ejemplo pero se puede obtener con el siguiente.

interface FooTypesMap {
    never: never;
    one: string;
    two: boolean;
    three: {
        one: Date
    };
}

type MyType<TType extends keyof FooTypesMap = 'never'> = {
    [k in keyof FooTypesMap]: {
        foo: TType extends 'never' ? k : TType,
        bar: FooTypesMap[TType extends 'never' ? k : TType],
    }
}[keyof FooTypesMap]

let instanceFour: MyType<'three'>;

instanceFour = {
    foo: 'three',
    bar: {
        one: new Date()
    }
}

La diferencia con el ejemplo aterior es que agregamos un nuevo tipo genérico opcional (optional generic type) con un valor predeterminado never y es usado dentro de un tipo condicional (conditional type) para verificar si fue declarado o usa el valor predeterminado. Si esta declarado se usara ese tipo para definir el tipo de foo y con ese se obtendrá el valor de bar y si no esa definido se usara k como el ejemplo anterior.

Lo único raro en este código es la definición never: never es FooTypesMap, esto nos permite mantener la restricción de tipo TType extends keyof FooTypesMap que define que TType tiene que ser una propiedad en FooTypesMap.

Tipo de auto-referencia recursivo

Hay un nivel mas de complejidad que podemos agregar a MyType, que pasas si queremos una propiedad extra llamada baz que sea de tipo MyType. Para hacer esto debemos usa tipos recursivos (recursive types).

Ademas quiero agregar una propiedad llamada qux que sea un mapa con N cantidad de propiedades donde todas deben ser de tipo MyType, para mostrar el podes de los tipos tipos recursivos (recursive types).

interface FooTypesMap {
    never: never;
    one: string;
    two: boolean;
    three: {
        one: Date
    };
}

type MyType<TType extends keyof FooTypesMap = 'never'> = {
    [k in keyof FooTypesMap]: {
        foo: TType extends 'never' ? k : TType,
        bar: FooTypesMap[TType extends 'never' ? k : TType],
        baz?: MyType,
        qux: {
            [key: string]: MyType
        }
    }
}[keyof FooTypesMap]

let instance: MyType<'three'>;

instance = {
    foo: 'three',
    bar: {
        one: new Date()
    },
    baz: {
        foo: 'one',
        bar: 'algún valor'
    },
    qux: {
        myKey: {
            foo: 'two',
            bar: false,
        }
    }
}

Gracias Keshav por la ayuda con los tipos!

Schematics

Sun, 03 Mar 2019 00:00:00 GMT

Schematics is a tool for scaffolding created by the Angular Team to make Angular adoption more easy, but end up being a bigger tool than that. Thanks to how is built, it allow to automate any type of scaffolding, directory creation or file modification.

Schematics itself is really small, but powerful, it adopts only a few concepts to allow us to do the modifications or create whatever we want.

Concepts

All conceptos are officially explained here, but i will do a few extra notes on some that deserve more elavoration.

Tree

Schematics will hold a in-memory basic system that will materialed into the real file system when all Rules are applied to it.

Schematics is really strict about avoid the real file system until everything runs, there is no more pending changes and no errors.

New Trees can be created by a Rule and them be merged to the origin Tree.

Rule

Rules are actions will be applied to a Tree and will modify the files on that Tree.

They can be synchronous or asynchronous, using (Observables)[https://github.com/ReactiveX/rxjs] for asynchronous ones.

Now that we have a better understanding of the basic pieces

Hello, how are ya?!

Wed, 12 Jul 2017 17:12:33 GMT

das das dasd as d as dasdasd asd as dasdasda s da s

Minificates angular.js with less worries

Fri, 20 Nov 2015 00:18:41 GMT

The pain!

We (the web devs at least) know the fears and how careful we must be when we code to avoid error in the minified version of the code.

You forget a semicolon and half of a day goes into an endless search of the point of the error. With time and practice, this half day can be reduce to minutes, but not all the developers have that experience and less when must work with teams with different backgrounds.

To that, there is no so much to do… keep being careful! (There are linters and stuff…)

A new angle of pain

With angular.js and his dependency injection (DI for now on), a new things came to bother us.

The most widespread way of use the DI is the simplest way but this it is impossible to minify. Lets see this example:

angular
  .module('SuperModule')
  .controller('AwesomeCrtl', function($scope, $timeout) {

  });

This code is clean and nice but there is a problem. angular.js, to execute DI, parses the function as a string to extract the parameter’s name and use them to import the services, values, etc. When you minify the code, the names are replaced with letters and that names have no meaning to angular.js.

To perform a minification to the code you must use the DI with one of the following method.

Dependencies Array

This way it’s the most spreaded in tutorials and blogs. It’s simple to understand, but it’s hard to read and follow when there is a lot of injections. The idea is to put the dependencies’s names as string in the array and then the function.

angular
  .module('SuperModule')
  .controller('AwesomeCrtl', ['$scope', '$timeout', function($scope, $timeout) {

  }]);

The $inject

This method uses a specific property of the controller’s function to specify, as an array of string, the names of the dependencies. Works with the same fundaments of the dependencies array, but it’s most clean.

var AwesomeCrtl = function($scope, $timeout) {

};

AwesomeCrtl.$inject = ['$scope', '$timeout'];
angular.module('SuperModule').controller('AwesomeCrtl', AwesomeCrtl);

Share the pain

When you have to manage a work team with different backgrounds, as i mentioned before, this kind of thing can create a problem. Some developers forget this rules and send code to CI that breaks everything.

My first attempt to resolve that, was an awareness meeting of the subject. Worked for some but others keep breaking the CI environment.

My (almost) solution

Last week the solution came to me in a JavaScript news feed. A module, ng-annotate is a processor of angular.js code that searches for unsecure DI functions and replace it with the dependencies array method.

This module doesn’t solve all the problems, can detect a lot of DI examples but there are some very weird ones that escape from it. Still is an excellent idea implement it in your development flow.

There is plugins for the most common task runners and asset pipeline:

There is more… check the GitHub page of ng-annotate.

A gift to test it

This week i made a very small implementation of this module with a browserified version of it. You can put you angular.js code and view how will be the DI output of ng-annotate.

Check it at : ng-annotate-online

Code review tales

Thu, 12 Nov 2015 23:32:57 GMT

First of all… I’M BACK! i had a hard weeks at home and office as well. But after all that stuff, i’m back with a small story.

I think that the post’s photo summarizes all the code review stories, but i want to share this experience.

The little project…

Today was the day… the day to make the code review of a few coworkers for the annually performance report.

A little bit of background, for the last few month me and 2 architects were working on a new and exciting project, we were able to use a lot of new technologies, design the base of something big. The dreaming project…

Then the day to put all that code to work arrived, 2 teams of 2 devs were assigned to work with us, one guy to make the backend and the other to make the frontend. The two teams were going to do the same module, to compare times, test the architecture, etc… After two small sprints of two weeks, we had enough code to review and then it is when we got surprised.

The session

Today after lunch me and other guy from the arch team reserved a room of the office for 4 hours to review the code of the other 4 guys. I was like ‘4 hours.. nah you are exaggerating’, then i realized the naive of my thoughts.. the code review never ends.

We build all the base projects and tools to validate a lot of thing like code styles, file naming, tests coverage, code comments, etc. So we were very convinced that we are going to find only a few things.

We end up amazed of the things that we saw in 4 hours. The most common thing was the damned cope&paste. We made a lots of examples code to avoid questions and make a record of examples. But this generated a bad behavior in the team, they copy and change a few things and thats all. The idea is not totally bad… but you need to change the name of the functions and variables… at least…

Update without thinking

Sat, 24 Oct 2015 23:27:00 GMT

This week was a little bit bored, there was nothing interesting in my work to write about, no weird technical issue to investigate. Also this weekend are elections here in Argentina, so my sunday will be busy and i don’t have hopes to have a fresh idea before monday hahah. But anyway i want to write something…

The last tuesday the new version of Ubuntu (15.10) went out and because of my addiction of being on the edge of everything, i felt the need to update my OS.

Yesterday I updated my current OS, but this morning i noticed a few problems and then remembered that with the previous update i end up suffering the same problem. So i have decided to make a clean installation.

I have all my data on external drives, so that wasn’t a problem. But i have a bunch of tools and customization.

To avoid to configure all that again by hand, i create a script that configures all the OS in the way i like, applications, themes, icons, system configs, NPM packages, IDE extensiones, etc.

I put it in a Github repository so everyone can fork it and make their own. https://github.com/ManRueda/ubuntu-initializer

Warning: The title is only a title, never update with out thinking!!! hahah

Agile Keychain decryption with JavaScript

Mon, 19 Oct 2015 00:23:53 GMT

On this publication I’m going to talk about Agile Keychain Design. Its structure, decryption flow and implementation.

A little bit of history

This sensitive data storage was created by AgileBits in 2008 to replace the OS X Keychain in 1Password. The main benefits of replacing OS X Keychain was:

Multi OS support
Change DES to AES as encryption standard
Performance improvement compared to OS X KeyChain.

The structure

The storage is based on a zip-like file with the .agilekeychain_zip extension. It have an internal folder structure like this:

myStorage.agilekeychain_zip
+-- config
    +-- domains
    +-- use-thumbnails
    +-- version
+-- data
    +-- default
        +-- 1password.keys
        +-- *.1password
        +-- content.js
        +-- encryptionKeys.js
    +-- <more profiles>

encryptionKeys.js

Let’s take a look to encryptionKeys.js:

{
  "list": [{
    "data": "U2FsdGVkX19cm85vzXmRCZyaVYd...",
    "validation": "U2FsdGVkX1/YdmmuN6l2tJ6...",
    "identifier": "30737A49AF124394B4CF97F65761769D",
    "level": "SL5",
    "iterations": 10000
  }, {
    "data": "U2FsdGVkX19s+dZpjkrrUeUsNWO...",
    "validation": "U2FsdGVkX1/8LVqKXktw5MULM1...",
    "identifier": "A866C664DD424046A26487AAB677308F",
    "level": "SL3",
    "iterations": 10000
  }],
  "SL3": "A866C664DD424046A26487AAB677308F",
  "SL5": "30737A49AF124394B4CF97F65761769D"
}

The list property lists all the keys to decrypt the passwords.
The level represent the security level related to the password content.
The data contains a BASE-64 representation of the content key encrypted with the master key with PBKDF2 the number of iterations defined in iterations.
The validation is the decrypted key encrypted with it self, to validate the decryption process.

The 1password.keys contains the same information but in a XML format

content.js

This JSON lists all the content available in the keychain, this file only give you the UUID, Type and Name.

*.1password

All the files with this extension are content keys and are a JSON with this properties:

keyID: UUID of the content key to decrypt the password.
uuid: UUID of the password.
securityLevel: Define with content key need to decrypt.
encrypted: BASE-64 data of the password to decrypt.

There are other properties of 1Password, like types, names, URLs, etc. But there are not critical to the decrypt process.

{
  "keyID": "30737A49AF124394B4CF97F65761769D",
  "locationKey": "someSite.com",
  "typeName": "webforms.WebForm",
  "location": "https://someSite.com/Account/Login",
  "uuid": "CD4D7DE21F414354A01A6ABA626CA2AB",
  "createdAt": 1429537038,
  "title": "someSite.com",
  "securityLevel": "SL5",
  "openContents": {
    "autosubmit": "default"
  },
  "updatedAt": 1429537040,
  "txTimestamp": 1429537040,
  "contentsHash": "1836a185",
  "encrypted": "U2FsdGVkX1/rlHC..."
}

Decryption process

To decrypt a password you need to follow this steps.

Convert the master password, content key and content data into buffers.
Divide the content key into the salt and data.
Generate the derived key with PBKDF2, using the iterations number and the master key.
Divide the derived key in the AES key and the AES IV.
Decrypt the content key data with AES-128-CBC using the AES Key and AES IV to get the Raw Key.
Divide the content data in the salt and the data.
Derive the Raw Key with MD5 using the content data salt to get the key and iv.
Decrypt the ‘content data’ data with AES-128-CBC using the key and iv just created.
Parse the result data as JSON.

This explanation could be a little bit hard to understand, because of that… here is this implemented in Node.js.

var crypto = require('crypto');

var content = 'U2FsdGVkX1/rlHCO4K1g3M...';
var contentKey = 'U2FsdGVkX19s+dZpjkrrUeU...';
var masterKey = 'MyMasterKey';
var iterations = 10000;
var result;

var masterKeyBuffer = new Buffer(masterKey);
var contentKeyBuffer = new Buffer(contentKey, 'base64');
var contentBuffer = new Buffer(content, 'base64');

var derivedKey = crypto.pbkdf2Sync(masterKeyBuffer, contentKeyBuffer.slice(8, 16), iterations, 32);

var decryptedContentKey = decrypt(contentKeyBuffer.slice(16),  derivedKey.slice(0, 16), derivedKey.slice(16, 32));

var passwordAux = deriveKey(decryptedContentKey, contentBuffer.slice(8, 16));

result = JSON.parse(decrypt(contentBuffer.slice(16), passwordAux.key, passwordAux.iv));

console.log(result);

function decrypt(data, key, iv){
  var cipher = crypto.createDecipheriv('aes-128-cbc', key, iv);

  var upBuf = cipher.update(data);
  var finBuf = cipher.final();

  return Buffer.concat([upBuf, finBuf]);
}

function deriveKey(key, salt){
  var rounds = 2;
  var data = Buffer.concat([key, salt]);
  var md5Hashes = [[],[]];
  var md5sum = crypto.createHash('md5');
  md5sum.update(data);
  var sum = md5sum.digest();
  md5Hashes[0] = sum;
  for(var i = 1; i < rounds; i++){
    md5sum = crypto.createHash('md5');
    md5sum.update(Buffer.concat([md5Hashes[i - 1], data]));
    sum = md5sum.digest();
    md5Hashes[i] = sum;
  }
  return {
    key:md5Hashes[0],
    iv: md5Hashes[1]
  };

}

The result logged in the console will be something like this, the result can be different for different types of passwords.

{
  htmlAction: 'https://mysite.com/',
  htmlID: 'passwordExpired',
  htmlName: 'passwordExpired',
  htmlMethod: 'POST',
  passwordHistory: [{
    value: '4FgrFhedhewgM8k78gd8G_',
    time: 1435664836
  }, {
    value: 'MyRealPassword',
    time: 1443537200
  }],
  URLs: [{
    url: 'https://mysite.com/'
  }],
  fields: [{
    type: 'P',
    name: 'stateBean.nuPassword1',
    value: 'MyRealPassword',
    designation: 'password'
  }]
}

In this GitHub repo is an real implementation of this in a basic Key Chain manager. https://github.com/ManRueda/1password-manager

Environment variable string encoding

Sat, 10 Oct 2015 20:59:00 GMT

When i start working on this blog (based in ghost), i put a bunch of sensitive data in environment variables in the heroku configuration.

The problem was a key of google drive API, the content is a multi-line string and can’t make it work in one line. When i put the new line character into the string \n, it wasn’t interpreted by node.

The only solution that i found for this problem was this, convert the string to a buffer and then to string again.

      
        // set the TEST environment variable with TEST=first line\\n\\nsecond line\\n
      
        // you need to duplicate the \ to scape it
      
        function parseEnvVarible(envVar){
      
          return new Buffer(envVar.split('\\n').join(require('os').EOL), 'UTF-8').toString('UTF-8');
      
        }
      
        console.log('Wrong: ' + process.env.TEST);
      
        console.log('Right: ' + parseEnvVarible(process.env.TEST));

view raw example.js hosted with ❤ by GitHub

Keep you NPM dependecies updated

Fri, 09 Oct 2015 22:46:22 GMT

A few days ago, surfing on the web, i saw a site of a service that called my attention and made me think “that’s a great idea”.

The idea was… “don’t worry about update your npm’s dependencies, we will do it…“.

The service that i’m talking about is greenkeeper.

This service, periodically, will analyze the package.json of a GitHub repo, will check for dependencies updates and make a Pull Request with the changes. It’s simple but powerful. If you have a good set of hooks for validation, like travis/jenkins builder, you can check if the new version of the dependencies breaks your code.

Greenkeeper provide three plans and one is free!!

Open Source (FREE):
- Unlimited public repos
- Public queue (might take a while to update)
Individual ($14/month):
- Unlimited privates repos
- Faster queue
- Online support
Organisations ($50-$90/month):
- 20-50 privates repos
- Fastest queue
- Online support

About the plan, using the free one for now, the response time of the queue is really good. In a few (2-4) minutes i had the pull request in my repo, so far the time is not a problem. Perhaps when the service has more demand this time will increase, i hope not!

Now the implementation, there is no need of extra instructions. The Getting started of the official site is more than enough. You only need to install a global NPM package, authorize greenkeeper on GitHub and that’s all.

There is only one thing about this service that not convince me at a 100%, when the service updates the package.json versions, removes all the semver prefixes and puts a fixed version. This is not totally wrong, because the service will update when detects a new version. But is a little detail that does not convince me completely.

In short, it is a very good alternative for those who forgets about the updates and ends with old and obsolete projects.

TFS Grunt custom policy

Tue, 22 Sep 2015 03:11:00 GMT

On the last few weeks i was working in a new project and everything was awesome… but we only were 4 devs coding. On the last week more people start coding over our code and we need to put a bunch of rules and validations to keep the project on rails.

The project it’s a SPA made it with angular.js, all our code rules validations are made with JSHint, JSCS, HTMLHint, etc and we have test made with jasmin. We run all this stuff with grunt’s tasks… so far was great, the build fails when any validation fails. So i decide to not have failed builds because of that. So i put my mind in custom policies research and end up with a policy that run a grunt task and reject the check-in if grunt fails.

Because of the custom polices runs locally, we don’t have a performance issue in the TFS build controller.

Policy class structure

The policy class must inherit from PolicyBase and have the Serializable attribute. This force you to overwrite some methods.

[Serializable]
public class GruntRunnerPolicy: PolicyBase {

  public override string Description {
    get {
      //Description of the policy
    }
  }

  public override string InstallationInstructions {
    get {
      //Text to display to the user when he doesn't have the policy in his system.
    }
  }

  public override string Type {
    get {
      //Type of policy, this string will be displayed in the policies combo
    }
  }

  public override string TypeDescription {
    get {
      //Description of the type of policy
    }
  }

  public override bool Edit(IPolicyEditArgs args) {
    return true;
  }

  public override PolicyFailure[] Evaluate() {
    //This method performance the check-in evaluation
  }

  public override void Activate(PolicyFailure failure) {
    //This method is executed when the user double-clicks the UI of the policy
  }

  public override void DisplayHelp(PolicyFailure failure) {
    //This method is executed when the user ask for the policy help (F1)
  }
}

Policy evaluation

The idea is to run the task and evaluate the exit code to evaluate the result of the execution. To accomplish this the policy needs to:

Found the Grunt’s executable (maybe it’s not in the PATH)
Found the Gruntfile.js that affects the check-in files
Detect the task to run
Run it and evaluate the result

With this method we can find for the Grunt executable

private string FindGruntDirectory() {
  Process whereProcess = new Process();
  whereProcess.StartInfo.FileName = "where.exe";
  whereProcess.StartInfo.Arguments = "grunt";
  whereProcess.StartInfo.UseShellExecute = false;
  whereProcess.StartInfo.CreateNoWindow = true;
  whereProcess.StartInfo.RedirectStandardOutput = true;
  whereProcess.StartInfo.WorkingDirectory = System.Environment.SystemDirectory;
  whereProcess.Start();

  var path = string.Empty;
  while (!whereProcess.StandardOutput.EndOfStream) {
    String s = whereProcess.StandardOutput.ReadLine();
    if (s != "") {
      if (path == string.Empty) {
        path = s;
      }
      if (s.EndsWith(".cmd")) {
        path = s;
      }
    }
  }
  whereProcess.WaitForExit();
  return path;
}

To find the Gruntfile.js that contains the task, the idea is put a .json file at the same level of the Gruntfile.js, let say… GruntRunnerPolicy.json.

That said, the policy needs to search up to the root of the file system for each check-in file, searching for the .json file and at the same level can find the Gruntfile.js.

public static string SearchGruntParentDirectory(string path) {
  if (path == Path.GetFullPath(path + "\\..")) {
    return null;
  }

  var files = Directory.GetFiles(path, "GruntRunnerPolicy.json");
  if (files.Length == 0) {
    return SearchGruntParentDirectory(Path.GetFullPath(path + "\\.."));
  } else {
    return path;
  }
}

My idea was to put the name of the task in the GruntRunnerPolicy.json, maybe was a justification to put this files in the TFS. Something simple like this:

{
  "GruntTask":"validateMyCheckIn"
}

The last thing to do is run the task and expect for the result:

public int Run(string GruntDirectory, string WorkingDirectory, string Task, List<string> Parameters) {
  var log = String.Empty;
  var errLog = String.Empty;

  var processInfo = new ProcessStartInfo("cmd.exe", "/c " + GruntDirectory + " --no-color " + Task + " " + String.Join(" ", Parameters));
  processInfo.CreateNoWindow = true;
  processInfo.UseShellExecute = false;
  processInfo.RedirectStandardError = true;
  processInfo.RedirectStandardOutput = true;
  processInfo.WorkingDirectory = WorkingDirectory;

  var process = Process.Start(processInfo);
  process.OutputDataReceived += (object sender, DataReceivedEventArgs e) =>
    log = log + e.Data + System.Environment.NewLine;

  process.BeginOutputReadLine();
  process.ErrorDataReceived += (object sender, DataReceivedEventArgs e) =>
    errLog = errLog + (String.IsNullOrEmpty(e.Data) ? string.Empty : e.Data + System.Environment.NewLine);

  process.BeginErrorReadLine();
  process.WaitForExit();

  var success = process.ExitCode;
  process.Close();
  return success;
}

This method returns the exit code to analyze it, saves the console output and error output. The console log can be use to return to the user the error generated by the task.

I leave the source of this package in this repository: GruntRunnerPolicy

The Beginning

Sun, 20 Sep 2015 21:06:49 GMT

Hi everyone, i hope there is someone there…

Recently i was working a lot with TFS-Grunt integration and stuff like that and noticed that there is not too much documentation or examples out there, even there is almost nothing about some TFS libraries for server side… it’s like a dark side of the Microsoft doc.

So this last Friday i was bored at home and decided to start a blog (something new for me) to put all this things that i learned on my work.

But… i didn’t want to create a Wordpress or Blogger (i’m not against those…) but it seemed so simple to me… i wanted to do some work. So i searched for a customizable blogging platform to play with it.

That why i end up with Ghost running in a Heroku dyno… so the idea it’s share the stuff i can and also play with this platform…

I hope that all the things that are going to end up here helps you at some point…

	// set the TEST environment variable with TEST=first line\\n\\nsecond line\\n
	// you need to duplicate the \ to scape it
	function parseEnvVarible(envVar){
	return new Buffer(envVar.split('\\n').join(require('os').EOL), 'UTF-8').toString('UTF-8');
	}


	console.log('Wrong: ' + process.env.TEST);

	console.log('Right: ' + parseEnvVarible(process.env.TEST));