automagically-sort-selectedlayers-by-name.jsx

/**
 * This script tries to sort layers by name
 * more a proof of concept thingy
 * using this technique can hold some problems
 * - in this case the "et" gets found in "consectetur" "et" "amet"
 * - the last matching pattern will be the one that gets executed
 */

// Copyright (c)  2013
// Fabian "fabiantheblind" Morón Zirfas
// Permission is hereby granted, free of charge, to any
// person obtaining a copy of this software and associated
// documentation files (the "Software"), to deal in the Software
// without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to  permit persons to
// whom the Software is furnished to do so, subject to
// the following conditions:
// The above copyright notice and this permission notice
// shall be included in all copies or substantial portions of the Software.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF  CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTIO
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

// see also http://www.opensource.org/licenses/mit-license.php

/**
 * get unique Array content
 * does not work on mixed arrays
 * http://stackoverflow.com/questions/1960473/unique-values-in-an-array
 * @return {Array} [description]
 */
Array.prototype.getUnique = function(){
   var u = {}, a = [];
   for(var i = 0, l = this.length; i < l; ++i){
      if(u.hasOwnProperty(this[i])) {
         continue;
      }
      a.push(this[i]);
      u[this[i]] = 1;
   }
   return a;
};

/**
 * LayerSet Class
 * @param {String} _name The name of the class corresponds to the pattern
 */
function LayerSet(_name){
  this.name = _name;
  this.collection = [];// will hold layers

  this.add = function(layer){
    this.collection.push(layer);
  };
}
/**
 * A Pattern Class
 * @param {a regex string} _reg String
 */
function Pattern(_reg){
  this.reg = escapeRegExp(_reg);
}


function automagically_sort(){


app.beginUndoGroup("automagically sort by name");
/**
 * prerequisites check if thete is a comp
 * @type {[type]}
 */
var curComp = app.project.activeItem;
   if (!curComp || !(curComp instanceof CompItem)){
        // alert("noComp");
        // return;
    curComp = app.project.items.addComp("automagically sort", 500, 500, 1, 10, 25);
    }

var names = ["Lorem", "ipsum", "dolor", "sit", "amet", "consectetur", "adipisicing", "elit", "sed", "do", "eiusmod", "tempor", "incididunt", "ut", "labore", "et", "dolore", "magna", "aliqua","Lorem", "ipsum", "dolor", "sit", "amet", "consectetur", "adipisicing", "elit", "sed", "do", "eiusmod", "tempor", "incididunt", "ut", "labore", "et", "dolore", "magna", "aliqua"];// some random names
var layers = [];// holds the layers
for(var l = 0; l < names.length;l++){
  var lay = curComp.layers.addNull();// add a null
  lay.name = makeid(4) + " " +  names[l] + " " + makeid(5); // give it a name
  layers.push(lay);// push to array
} // close l create layers loop. // this shoudl be a space seprated field or something like that


var unique_names = names.getUnique(); // use the prototype functiion
var patterns = []; // this will hold the patterns
for (var n = 0; n < unique_names.length; n++) {
  patterns.push( new Pattern( unique_names[n]));
} // close ncreate patterns from names loop

var sets = []; // will hold all the layer sets
for(var r =0;r < patterns.length;r++){
      var set = new LayerSet(patterns[r].reg);// make a new set per pattern
    for (var i = 0; i < layers.length; i++) {
      var layer = layers[i];//isolate
        var reg = new RegExp( patterns[r].reg  ,'g');// make a regex
        if(reg.test(layer.name) === true){
          set.add(layer);// Yes found something push to LayerSet
        } // close regex check
    } // close i layers loop
    if(set.collection.length > 0){
    sets.push(set);
    }
}// close r pattern loop



/**
 * Now the sorting
 * We need to get every item from the set and move it to the top
 */

// alert(sets.toSource());
for (var s = 0; s < sets.length; s++) {
  var curSet =  sets[s];// isolate
  if(curSet.collection.length > 0){
    // continue;
  // we have something in the set loop the collection
  var collabel = (s)%16;
  for (var cl = 0; cl < curSet.collection.length; cl++) {
    var curLayer = curSet.collection[cl];
    curLayer.moveToBeginning();
    if(parseInt (app.version, 10) > 10){
      // CS6+ feature
    curLayer.label = collabel;
    }
  } // end cl collection loop
  }// if there are no layers move to the next set
} // end s sets loop
app.endUndoGroup();
}


/**
 * [escapeRegExp description]
 * @param  {[type]} str [description]
 * @return {[type]}     [description]
 * http://stackoverflow.com/questions/3446170/escape-string-for-use-in-javascript-regex
 */
function escapeRegExp(str) {
  return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
}


/**
 * Make pseudo random text found here
 * http://stackoverflow.com/questions/1349404/generate-a-string-of-5-random-characters-in-javascript
 * @return {String} [Pseudo random string]
 */
function makeid(num){
    var text = "";
    var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

    for( var i=0; i < num; i++ )
        text += possible.charAt(Math.floor(Math.random() * possible.length));

    return text;
}


  //  _   _  ______          _______  _    _ _   _ _____       _______ _______ _____ _   _  _____
  // | \ | |/ __ \ \        / /  __ \| |  | | \ | |  __ \   /\|__   __|__   __|_   _| \ | |/ ____|
  // |  \| | |  | \ \  /\  / /| |__) | |  | |  \| | |  | | /  \  | |     | |    | | |  \| | |  __
  // | . ` | |  | |\ \/  \/ / |  _  /| |  | | . ` | |  | |/ /\ \ | |     | |    | | | . ` | | |_ |
  // | |\  | |__| | \  /\  /  | | \ \| |__| | |\  | |__| / ____ \| |     | |   _| |_| |\  | |__| |
  // |_| \_|\____/   \/  \/   |_|  \_\\____/|_| \_|_____/_/    \_\_|     |_|  |_____|_| \_|\_____|

automagically_sort();