JQuery expand collapse logic

In many places I started to face expand-collapse behavior these days.
So here is how I handle it;

$('.exp-col-trigger').bind('click', function (e, options) {
e.preventDefault();

var view = $(this).attr('data-selector');
$(view).toggle();

return false;
});

So since I use jQuery, why not use selectors here and make it really flexible to use. You could pass ids like '#crazy-monkeys' or classes like '.match' or even you could pass ".match[data-status='2']".

An example would be..

REGION 1

REGION 2

REGION 3

Also maybe it makes sense to make this a a plugin where could do.

$('#container').expandCollapse();

Where it only adds the functionality for the elements under a container, but any reason for it?

Grails, Google App Engine deployment trick

I just spent some time enough to call a waste on this issue so I wanted the next generations to go out have some fun instead.

When you try to do 'grails app-engine deploy', it will ask you for your google appengine email and password. After asking your email, intuitively you will type in your email and press on enter. When you do so, you will see that a shockingly suprising thing happens; NOTHING! And as a curious human being you will click enter again, then you will be asked for you password but once you enter it the appengine plugin will fail.

Well, here is the trick.

When you are asked for your email, FIRST press on ENTER and then type your email in the new line. For the password you don't have to do this.

Hope that helps.

Later,
Bilsay

jQuery table row accumulator(sum, average)

I needed some simple plugin just to add up and take the average of numeric columns and since I couldn't find a lightweight one I just wrote it myself. I'm sure it can be extended to work in a more general way but I just needed it to be simple. It can be a good start so you can play with it.

Here is the plugin:

(function($) {

   $.fn.accumulate = function(options) {

       options = options || {};



       function view(row) {

           var t = [];



           t.push('');



           for (var i = 0; i < row.meta.columnCount; i++) {                 t.push('');

               t.push('');



               if (columnHasFixedDisplay(i)) {

                   t.push(options["col" + i].display);

               }

               else {

                   if (row.data[i]) {

                       var value = columnHasAverageValue(i) ? (row.data[i].total / (row.data[i].count)) : row.data[i].total;



                       t.push(columnHasFixedDisplayFunction(i) ? options["col" + i].displayFunction(value) : value);

                   }

               }



               t.push('');

               t.push('');

           }



           t.push('');



           return t.join('');

       }



       //defaults to sum

       function columnHasAverageValue(i) {

           return options["col" + i] && "average" == options["col" + i].type;

       }

      

       function columnHasFixedDisplay(i) {

           return options["col" + i] && options["col" + i].display;

       }



       function columnHasFixedDisplayFunction(i) {

           return options["col" + i] && options["col" + i].displayFunction;

       }



       function columnHasAccumulatorFunction(i) {

           return options["col" + i] && options["col" + i].accumulatorFunction;

       }



       return this.each(function() {

           var $this = $(this);



           var rows = $("tbody tr", $this);



           var accumulatedRow = {

               meta: {

                   rowCount: rows.length,

                   columnCount: 0

               },

               data: {}

           };



           rows.each(function() {

               var $columns = $('td', $(this));

               accumulatedRow.meta.columnCount = $columns.length;



               for (var i = 0; i < $columns.length; i++) {                     var value = $columns[i].innerHTML;                      if (columnHasAccumulatorFunction(i)) {                         accumulatedRow.data[i] = options["col" + i].accumulatorFunction(accumulatedRow.data[i], value)                     }                     else{                         if (NG.isNumeric(value)) {                             if (!accumulatedRow.data[i]) {                                 accumulatedRow.data[i] = {                                     count: 0,                                     total: (NG.isFloat(value) ? 0 : 0.0)                                 };                             }                              accumulatedRow.data[i].count++;                             accumulatedRow.data[i].total +=  NG.isFloat(value) ? parseFloat(value) : parseInt(value);                         }                     }                 }             });              $("tbody", $this).append(view(accumulatedRow));         });     }; })(jQuery);  

Here are the helper methods, you can keep them under a namespace maybe, thats how I do:

isNumeric: function(input) {

var RE = /^-{0,1}\d*\.{0,1}\d+$/;

return (RE.test(input));

}



isFloat: function(input) {

return /\./.test(input.toString());

}

Here is the usage, the jquery object is the table structured well with tbody:

$("#table-id").accumulate({

           "col0": {

               display: "Total",

               style: "text-align: left;"

           },

           "col1": {

               accumulatorFunction: function(accumulatedValue, value) {

                   if (!accumulatedValue) {

                       accumulatedValue = {

                           total: {

                               firstEleven: 0,

                               sub: 0

                           },

                           count: 0

                       }

                   }



                   var s = value.replace(' ', '').replace(')', '').split('(');



                   accumulatedValue.count++;

                   accumulatedValue.total.firstEleven += parseInt(s[0]);

                   accumulatedValue.total.sub += 1 <>   

Default behaviour is to sum up every numeric value, you can specify a fix display for a column, to play with the display value, I added a display function and as I had values like 9 (10) in some columns and since they are not numeric I had to add a accumulator function. Anyway I ll update it if I ever need to add more functionality.



Later.

C#: Xml to Array Serializer

This is a simple code that I wrote to serialize Xml.

@XmlSerializer: all the business logic to serialize
@Array: resulting wrapped up string as an array abstraction that becomes handy.
@EmptyArray
@IArrayItem, @ArrayItem: Values inserted in an of the array
@ArrayCharacter: String characters that construct an array

@XmlSerializer:

public class XmlToArraySerializer : ISerializer
{
public string Serialize(XElement xml)
{
return ConvertXElementToArray(xml).ToString();
}

private ArrayItem ConvertXElementToArray(XElement element)
{
Array array = new Array();

array.Start();
array.Insert(SerializeAttributes(element));

if (element.HasElements)
{
array.Insert(SerializeChildElements(element));
}
else
{
array.Insert(SerializeValue(element));
}

array.End();

return new ArrayItem(array);
}

private ArrayItem SerializeChildElements(XElement element)
{
Array array = new Array();
IEnumerable elements = element.Elements();

array.Start();

foreach (XElement childElement in elements)
{
array.Insert(ConvertXElementToArray(childElement));
}

array.End();
return new ArrayItem(array);
}

private ArrayItem SerializeValue(XElement element)
{
if(string.IsNullOrEmpty(element.Value)) return null;

Array array = new Array();

array.Start();
array.Insert(new ArrayItem(element.Value));
array.End();

return new ArrayItem(array);
}

private IArrayItem[] SerializeAttributes(XElement element)
{
IEnumerable attributes = element.Attributes();

IArrayItem[] values = new ArrayItem[attributes.Count()];

int index = 0;

foreach (XAttribute attribute in attributes)
{
values[index++] = new ArrayItem(attribute.Value);
}

return values;
}
}

@Array

public class Array
{
private StringBuilder _array;
private bool _canPutSeperator;

public Array()
{
_array = new StringBuilder();
}

public void Start()
{
InsertArrayCharacter(ArrayCharacter.Start);

_canPutSeperator = false;
}

public void End()
{
InsertArrayCharacter(ArrayCharacter.End);

_canPutSeperator = false;
}

public void InsertEmptyItem()
{
if(_canPutSeperator)
{
InsertArrayCharacter(ArrayCharacter.Seperator);
}

_canPutSeperator = true;
}

public void Insert(IArrayItem arrayItem)
{
if(null == arrayItem) return;

if(arrayItem.IsEmtpy())
{
InsertEmptyItem();
return;
}

EnterNewItem();

_array.Append(arrayItem);

ExitNewItem();
}

public void Insert(IArrayItem[] arrayItems)
{
foreach (IArrayItem item in arrayItems)
{
Insert(item);
}
}

public string EmptyValue()
{
return string.Format("{0}{1}", ArrayCharacter.Start.Value, ArrayCharacter.End.Value);
}

public override string ToString()
{
return !string.IsNullOrEmpty(_array.ToString()) ? _array.ToString() : EmptyValue();
}

public override int GetHashCode()
{
return _array.GetHashCode();
}

public bool IsEmpty()
{
return string.IsNullOrEmpty(_array.ToString());
}

private void EnterNewItem()
{
if (_canPutSeperator)
{
InsertArrayCharacter(ArrayCharacter.Seperator);
}
}

private void ExitNewItem()
{
_canPutSeperator = true;
}

private void InsertArrayCharacter(ArrayCharacter arrayCharacter)
{
_array.Append(arrayCharacter.Value);
}
}

@EmptyArray:

public class EmptyArray
{
public override string ToString()
{
Array emptyArray = new Array();

emptyArray.Start();
emptyArray.End();

return emptyArray.ToString();
}
}

@ArrayItem:

public class ArrayItem : IArrayItem
{
private T _value;

public ArrayItem(T value)
{
_value = value;
}

public bool IsArray()
{
return typeof(T).Equals(typeof(Array)) || typeof(T).Equals(typeof(EmptyArray));
}

public bool IsValue()
{
return typeof (T).Equals(typeof (string))
|| typeof (T).IsPrimitive
|| typeof (T).Equals(typeof (DateTime))
|| typeof (T).Equals(typeof (DateTime?));
}

public bool IsEmtpy()
{
if(null == _value) return true;
if(!IsArray() && !IsValue()) return true;

return IsArray() ? (_value as Array).IsEmpty() : string.IsNullOrEmpty(_value.ToString());
}

private bool NeedsToBeWrappedInQuotes()
{
return !IsArray() && !IsNumeric();
}

private bool IsNumeric()
{
double value;
return double.TryParse(_value.ToString(), out value);
}

public override string ToString()
{
return NeedsToBeWrappedInQuotes() ?
ArrayCharacter.Quote.Value + _value.ToString() + ArrayCharacter.Quote.Value
: _value.ToString();
}

public override int GetHashCode()
{
return _value.GetHashCode();
}
}

public interface IArrayItem
{
bool IsArray();
bool IsValue();
bool IsEmtpy();
}

@ArrayCharacter
public class ArrayCharacter
{
private char _value;

public ArrayCharacter(char value)
{
_value = value;
}

public char Value
{
get { return _value; }
}

public static ArrayCharacter Start = new ArrayCharacter('[');
public static ArrayCharacter End = new ArrayCharacter(']');
public static ArrayCharacter Seperator = new ArrayCharacter(',');
public static ArrayCharacter Quote = new ArrayCharacter('\'');
}