angular-ng-table-rails 0.5.4.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e39c7adb1a521d431e7778beba70284725ca92fa
+  data.tar.gz: 43823248579636a4b7856385273be86177403ff4
+SHA512:
+  metadata.gz: 57415fb4b68bc22fe4bdbd0aeb20933a4b6c6562ef60ab1d5a02666bcb7677a4ac979e4a7c36c642fa33da9801a661181286a9e3c8e4b89d1ce1f0c086201fd5
+  data.tar.gz: b9cb61a68e3c16da539074ae75652f0d4479713c7a9dad6171ba003b7c6bf1499194645a822b717118d02d371a4f8dd662bec2091c68e773a386b01f70166524

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Angular-UI-Bootstrap-Rails RubyGem Copyright (c) 2013 Chris Constantin
+
+Angular.JS and related components Copyright (c) 2010-2013 Google Inc.
+
+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 CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,25 @@
+# angular-ng-table-rails
+
+ng-table angular wraps the [Angular.js](https://github.com/esvit/ng-table) library for use in Rails 3.1 and above. Assets will minify automatically during production.
+
+## Usage
+
+Add the following to your gemfile:
+
+    gem 'angular-ng-table-rails'
+
+Add the following directive to your Javascript manifest file (application.js):
+
+    //= require ng-table
+    
+Add the following directive to your Stylesheets manifest file (application.css):
+
+    *= require ng-table
+
+    
+You may need to add 'ui.bootstrap' into your app declaration for example
+
+    app = angular.module('MyApp', ["ngTable"])
+
+Gem based on ng-table(https://github.com/esvit/ng-table) by Bazalt CMS
+

data/lib/angular-ng-table-rails.rb

@@ -0,0 +1,8 @@
+require "angular-ng-table-rails/version"
+
+module NgTable
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/angular-ng-table-rails/version.rb

@@ -0,0 +1,5 @@
+module NgTable
+  module Rails
+    VERSION = "0.5.4.1"
+  end
+end

data/vendor/assets/javascripts/ng-table.js

@@ -0,0 +1,973 @@
+
+(function(angular, factory) {
+    'use strict';
+ 
+    if (typeof define === 'function' && define.amd) {
+        define(['angular'], function(angular) {
+            return factory(angular);
+        });
+    } else {
+        return factory(angular);
+    }
+}(angular || null, function(angular) {
+    'use strict';
+/**
+ * ngTable: Table + Angular JS
+ *
+ * @author Vitalii Savchuk <esvit666@gmail.com>
+ * @url https://github.com/esvit/ng-table/
+ * @license New BSD License <http://creativecommons.org/licenses/BSD/>
+ */
+ 
+/**
+ * @ngdoc module
+ * @name ngTable
+ * @description ngTable: Table + Angular JS
+ * @example
+ <doc:example>
+ <doc:source>
+ <script>
+ var app = angular.module('myApp', ['ngTable']);
+ app.controller('MyCtrl', function($scope) {
+                    $scope.users = [
+                        {name: "Moroni", age: 50},
+                        {name: "Tiancum", age: 43},
+                        {name: "Jacob", age: 27},
+                        {name: "Nephi", age: 29},
+                        {name: "Enos", age: 34}
+                    ];
+                });
+ </script>
+ <table ng-table class="table">
+ <tr ng-repeat="user in users">
+ <td data-title="'Name'">{{user.name}}</td>
+ <td data-title="'Age'">{{user.age}}</td>
+ </tr>
+ </table>
+ </doc:source>
+ </doc:example>
+ */
+var app = angular.module('ngTable', []);
+/**
+ * ngTable: Table + Angular JS
+ *
+ * @author Vitalii Savchuk <esvit666@gmail.com>
+ * @url https://github.com/esvit/ng-table/
+ * @license New BSD License <http://creativecommons.org/licenses/BSD/>
+ */
+ 
+/**
+ * @ngdoc value
+ * @name ngTable.value:ngTableDefaultParams
+ * @description Default Parameters for ngTable
+ */
+app.value('ngTableDefaults', {
+    params: {},
+    settings: {}
+});
+ 
+/**
+ * @ngdoc service
+ * @name ngTable.factory:NgTableParams
+ * @description Parameters manager for ngTable
+ */
+ 
+app.factory('NgTableParams', ['$q', '$log', 'ngTableDefaults', function($q, $log, ngTableDefaults) {
+    var isNumber = function(n) {
+        return !isNaN(parseFloat(n)) && isFinite(n);
+    };
+    var NgTableParams = function(baseParameters, baseSettings) {
+        var self = this,
+            log = function() {
+                if (settings.debugMode && $log.debug) {
+                    $log.debug.apply(this, arguments);
+                }
+            };
+ 
+        this.data = [];
+ 
+        /**
+         * @ngdoc method
+         * @name ngTable.factory:NgTableParams#parameters
+         * @methodOf ngTable.factory:NgTableParams
+         * @description Set new parameters or get current parameters
+         *
+         * @param {string} newParameters      New parameters
+         * @param {string} parseParamsFromUrl Flag if parse parameters like in url
+         * @returns {Object} Current parameters or `this`
+         */
+        this.parameters = function(newParameters, parseParamsFromUrl) {
+            parseParamsFromUrl = parseParamsFromUrl || false;
+            if (angular.isDefined(newParameters)) {
+                for (var key in newParameters) {
+                    var value = newParameters[key];
+                    if (parseParamsFromUrl && key.indexOf('[') >= 0) {
+                        var keys = key.split(/\[(.*)\]/).reverse()
+                        var lastKey = '';
+                        for (var i = 0, len = keys.length; i < len; i++) {
+                            var name = keys[i];
+                            if (name !== '') {
+                                var v = value;
+                                value = {};
+                                value[lastKey = name] = (isNumber(v) ? parseFloat(v) : v);
+                            }
+                        }
+                        if (lastKey === 'sorting') {
+                            params[lastKey] = {};
+                        }
+                        params[lastKey] = angular.extend(params[lastKey] || {}, value[lastKey]);
+                    } else {
+                        params[key] = (isNumber(newParameters[key]) ? parseFloat(newParameters[key]) : newParameters[key]);
+                    }
+                }
+                log('ngTable: set parameters', params);
+                return this;
+            }
+            return params;
+        };
+ 
+        /**
+         * @ngdoc method
+         * @name ngTable.factory:NgTableParams#settings
+         * @methodOf ngTable.factory:NgTableParams
+         * @description Set new settings for table
+         *
+         * @param {string} newSettings New settings or undefined
+         * @returns {Object} Current settings or `this`
+         */
+        this.settings = function(newSettings) {
+            if (angular.isDefined(newSettings)) {
+                if (angular.isArray(newSettings.data)) {
+                    //auto-set the total from passed in data
+                    newSettings.total = newSettings.data.length;
+                }
+                settings = angular.extend(settings, newSettings);
+                log('ngTable: set settings', settings);
+                return this;
+            }
+            return settings;
+        };
+ 
+        /**
+         * @ngdoc method
+         * @name ngTable.factory:NgTableParams#page
+         * @methodOf ngTable.factory:NgTableParams
+         * @description If parameter page not set return current page else set current page
+         *
+         * @param {string} page Page number
+         * @returns {Object|Number} Current page or `this`
+         */
+        this.page = function(page) {
+            return angular.isDefined(page) ? this.parameters({
+                'page': page
+            }) : params.page;
+        };
+ 
+        /**
+         * @ngdoc method
+         * @name ngTable.factory:NgTableParams#total
+         * @methodOf ngTable.factory:NgTableParams
+         * @description If parameter total not set return current quantity else set quantity
+         *
+         * @param {string} total Total quantity of items
+         * @returns {Object|Number} Current page or `this`
+         */
+        this.total = function(total) {
+            return angular.isDefined(total) ? this.settings({
+                'total': total
+            }) : settings.total;
+        };
+ 
+        /**
+         * @ngdoc method
+         * @name ngTable.factory:NgTableParams#count
+         * @methodOf ngTable.factory:NgTableParams
+         * @description If parameter count not set return current count per page else set count per page
+         *
+         * @param {string} count Count per number
+         * @returns {Object|Number} Count per page or `this`
+         */
+        this.count = function(count) {
+            // reset to first page because can be blank page
+            return angular.isDefined(count) ? this.parameters({
+                'count': count,
+                'page': 1
+            }) : params.count;
+        };
+ 
+        /**
+         * @ngdoc method
+         * @name ngTable.factory:NgTableParams#filter
+         * @methodOf ngTable.factory:NgTableParams
+         * @description If parameter page not set return current filter else set current filter
+         *
+         * @param {string} filter New filter
+         * @returns {Object} Current filter or `this`
+         */
+        this.filter = function(filter) {
+            return angular.isDefined(filter) ? this.parameters({
+                'filter': filter,
+                'page': 1
+            }) : params.filter;
+        };
+ 
+        /**
+         * @ngdoc method
+         * @name ngTable.factory:NgTableParams#sorting
+         * @methodOf ngTable.factory:NgTableParams
+         * @description If 'sorting' parameter is not set, return current sorting. Otherwise set current sorting.
+         *
+         * @param {string} sorting New sorting
+         * @returns {Object} Current sorting or `this`
+         */
+        this.sorting = function(sorting) {
+            if (arguments.length == 2) {
+                var sortArray = {};
+                sortArray[sorting] = arguments[1];
+                this.parameters({
+                    'sorting': sortArray
+                });
+                return this;
+            }
+            return angular.isDefined(sorting) ? this.parameters({
+                'sorting': sorting
+            }) : params.sorting;
+        };
+ 
+        /**
+         * @ngdoc method
+         * @name ngTable.factory:NgTableParams#isSortBy
+         * @methodOf ngTable.factory:NgTableParams
+         * @description Checks sort field
+         *
+         * @param {string} field     Field name
+         * @param {string} direction Direction of sorting 'asc' or 'desc'
+         * @returns {Array} Return true if field sorted by direction
+         */
+        this.isSortBy = function(field, direction) {
+            return angular.isDefined(params.sorting[field]) && angular.equals(params.sorting[field], direction);
+        };
+ 
+        /**
+         * @ngdoc method
+         * @name ngTable.factory:NgTableParams#orderBy
+         * @methodOf ngTable.factory:NgTableParams
+         * @description Return object of sorting parameters for angular filter
+         *
+         * @returns {Array} Array like: [ '-name', '+age' ]
+         */
+        this.orderBy = function() {
+            var sorting = [];
+            for (var column in params.sorting) {
+                sorting.push((params.sorting[column] === "asc" ? "+" : "-") + column);
+            }
+            return sorting;
+        };
+ 
+        /**
+         * @ngdoc method
+         * @name ngTable.factory:NgTableParams#getData
+         * @methodOf ngTable.factory:NgTableParams
+         * @description Called when updated some of parameters for get new data
+         *
+         * @param {Object} $defer promise object
+         * @param {Object} params New parameters
+         */
+        this.getData = function($defer, params) {
+            if (angular.isArray(this.data) && angular.isObject(params)) {
+                $defer.resolve(this.data.slice((params.page() - 1) * params.count(), params.page() * params.count()));
+            } else {
+                $defer.resolve([]);
+            }
+            return $defer.promise;
+        };
+ 
+        /**
+         * @ngdoc method
+         * @name ngTable.factory:NgTableParams#getGroups
+         * @methodOf ngTable.factory:NgTableParams
+         * @description Return groups for table grouping
+         */
+        this.getGroups = function($defer, column) {
+            var defer = $q.defer();
+ 
+            defer.promise.then(function(data) {
+                var groups = {};
+                angular.forEach(data, function(item) {
+                    var groupName = angular.isFunction(column) ? column(item) : item[column];
+ 
+                    groups[groupName] = groups[groupName] || {
+                        data: []
+                    };
+                    groups[groupName]['value'] = groupName;
+                    groups[groupName].data.push(item);
+                });
+                var result = [];
+                for (var i in groups) {
+                    result.push(groups[i]);
+                }
+                log('ngTable: refresh groups', result);
+                $defer.resolve(result);
+            });
+            return this.getData(defer, self);
+        };
+ 
+        /**
+         * @ngdoc method
+         * @name ngTable.factory:NgTableParams#generatePagesArray
+         * @methodOf ngTable.factory:NgTableParams
+         * @description Generate array of pages
+         *
+         * @param {boolean} currentPage which page must be active
+         * @param {boolean} totalItems  Total quantity of items
+         * @param {boolean} pageSize    Quantity of items on page
+         * @returns {Array} Array of pages
+         */
+        this.generatePagesArray = function(currentPage, totalItems, pageSize) {
+            var maxBlocks, maxPage, maxPivotPages, minPage, numPages, pages;
+            maxBlocks = 11;
+            pages = [];
+            numPages = Math.ceil(totalItems / pageSize);
+            if (numPages > 1) {
+                pages.push({
+                    type: 'prev',
+                    number: Math.max(1, currentPage - 1),
+                    active: currentPage > 1
+                });
+                pages.push({
+                    type: 'first',
+                    number: 1,
+                    active: currentPage > 1,
+                    current: currentPage === 1
+                });
+                maxPivotPages = Math.round((maxBlocks - 5) / 2);
+                minPage = Math.max(2, currentPage - maxPivotPages);
+                maxPage = Math.min(numPages - 1, currentPage + maxPivotPages * 2 - (currentPage - minPage));
+                minPage = Math.max(2, minPage - (maxPivotPages * 2 - (maxPage - minPage)));
+                var i = minPage;
+                while (i <= maxPage) {
+                    if ((i === minPage && i !== 2) || (i === maxPage && i !== numPages - 1)) {
+                        pages.push({
+                            type: 'more',
+                            active: false
+                        });
+                    } else {
+                        pages.push({
+                            type: 'page',
+                            number: i,
+                            active: currentPage !== i,
+                            current: currentPage === i
+                        });
+                    }
+                    i++;
+                }
+                pages.push({
+                    type: 'last',
+                    number: numPages,
+                    active: currentPage !== numPages,
+                    current: currentPage === numPages
+                });
+                pages.push({
+                    type: 'next',
+                    number: Math.min(numPages, currentPage + 1),
+                    active: currentPage < numPages
+                });
+            }
+            return pages;
+        };
+ 
+        /**
+         * @ngdoc method
+         * @name ngTable.factory:NgTableParams#url
+         * @methodOf ngTable.factory:NgTableParams
+         * @description Return groups for table grouping
+         *
+         * @param {boolean} asString flag indicates return array of string or object
+         * @returns {Array} If asString = true will be return array of url string parameters else key-value object
+         */
+        this.url = function(asString) {
+            asString = asString || false;
+            var pairs = (asString ? [] : {});
+            for (var key in params) {
+                if (params.hasOwnProperty(key)) {
+                    var item = params[key],
+                        name = encodeURIComponent(key);
+                    if (typeof item === "object") {
+                        for (var subkey in item) {
+                            if (!angular.isUndefined(item[subkey]) && item[subkey] !== "") {
+                                var pname = name + "[" + encodeURIComponent(subkey) + "]";
+                                if (asString) {
+                                    pairs.push(pname + "=" + item[subkey]);
+                                } else {
+                                    pairs[pname] = item[subkey];
+                                }
+                            }
+                        }
+                    } else if (!angular.isFunction(item) && !angular.isUndefined(item) && item !== "") {
+                        if (asString) {
+                            pairs.push(name + "=" + encodeURIComponent(item));
+                        } else {
+                            pairs[name] = encodeURIComponent(item);
+                        }
+                    }
+                }
+            }
+            return pairs;
+        };
+ 
+        /**
+         * @ngdoc method
+         * @name ngTable.factory:NgTableParams#reload
+         * @methodOf ngTable.factory:NgTableParams
+         * @description Reload table data
+         */
+        this.reload = function() {
+            var $defer = $q.defer(),
+                self = this,
+                pData = null;
+ 
+            if (!settings.$scope) {
+                return;
+            }
+ 
+            settings.$loading = true;
+            if (settings.groupBy) {
+                pData = settings.getGroups($defer, settings.groupBy, this);
+            } else {
+                pData = settings.getData($defer, this);
+            }
+            log('ngTable: reload data');
+ 
+            if (!pData) {
+                // If getData resolved the $defer, and didn't promise us data,
+                //   create a promise from the $defer. We need to return a promise.
+                pData = $defer.promise;
+            }
+            return pData.then(function(data) {
+                settings.$loading = false;
+                log('ngTable: current scope', settings.$scope);
+                if (settings.groupBy) {
+                    self.data = data;
+                    if (settings.$scope) settings.$scope.$groups = data;
+                } else {
+                    self.data = data;
+                    if (settings.$scope) settings.$scope.$data = data;
+                }
+                if (settings.$scope) settings.$scope.pages = self.generatePagesArray(self.page(), self.total(), self.count());
+                settings.$scope.$emit('ngTableAfterReloadData');
+                return data;
+            });
+        };
+ 
+        this.reloadPages = function() {
+            var self = this;
+            settings.$scope.pages = self.generatePagesArray(self.page(), self.total(), self.count());
+        };
+ 
+        var params = this.$params = {
+            page: 1,
+            count: 1,
+            filter: {},
+            sorting: {},
+            group: {},
+            groupBy: null
+        };
+        angular.extend(params, ngTableDefaults.params);
+ 
+        var settings = {
+            $scope: null, // set by ngTable controller
+            $loading: false,
+            data: null, //allows data to be set when table is initialized
+            total: 0,
+            defaultSort: 'desc',
+            filterDelay: 750,
+            counts: [10, 25, 50, 100],
+            sortingIndicator: 'span',
+            getGroups: this.getGroups,
+            getData: this.getData
+        };
+        angular.extend(settings, ngTableDefaults.settings);
+ 
+        this.settings(baseSettings);
+        this.parameters(baseParameters, true);
+        return this;
+    };
+    return NgTableParams;
+}]);
+ 
+/**
+ * @ngdoc service
+ * @name ngTable.factory:ngTableParams
+ * @description Backwards compatible shim for lowercase 'n' in NgTableParams
+ */
+app.factory('ngTableParams', ['NgTableParams', function(NgTableParams) {
+    return NgTableParams;
+}]);
+ 
+/**
+ * ngTable: Table + Angular JS
+ *
+ * @author Vitalii Savchuk <esvit666@gmail.com>
+ * @url https://github.com/esvit/ng-table/
+ * @license New BSD License <http://creativecommons.org/licenses/BSD/>
+ */
+ 
+/**
+ * @ngdoc object
+ * @name ngTable.directive:ngTable.ngTableController
+ *
+ * @description
+ * Each {@link ngTable.directive:ngTable ngTable} directive creates an instance of `ngTableController`
+ */
+app.controller('ngTableController', ['$scope', 'NgTableParams', '$timeout', '$parse', '$compile', '$attrs', '$element',
+    'ngTableColumn',
+function($scope, NgTableParams, $timeout, $parse, $compile, $attrs, $element, ngTableColumn) {
+    var isFirstTimeLoad = true;
+    $scope.$filterRow = {};
+    $scope.$loading = false;
+ 
+    // until such times as the directive uses an isolated scope, we need to ensure that the check for
+    // the params field only consults the "own properties" of the $scope. This is to avoid seeing the params
+    // field on a $scope higher up in the prototype chain
+    if (!$scope.hasOwnProperty("params")) {
+        $scope.params = new NgTableParams();
+        $scope.params.isNullInstance = true;
+    }
+    $scope.params.settings().$scope = $scope;
+ 
+    var delayFilter = (function() {
+        var timer = 0;
+        return function(callback, ms) {
+            $timeout.cancel(timer);
+            timer = $timeout(callback, ms);
+        };
+    })();
+ 
+    function resetPage() {
+        $scope.params.$params.page = 1;
+    }
+ 
+    $scope.$watch('params.$params', function(newParams, oldParams) {
+ 
+        if (newParams === oldParams) {
+            return;
+        }
+ 
+        $scope.params.settings().$scope = $scope;
+ 
+        if (!angular.equals(newParams.filter, oldParams.filter)) {
+            var maybeResetPage = isFirstTimeLoad ? angular.noop : resetPage;
+            delayFilter(function() {
+                maybeResetPage();
+                $scope.params.reload();
+            }, $scope.params.settings().filterDelay);
+        } else {
+            $scope.params.reload();
+        }
+ 
+        if (!$scope.params.isNullInstance) {
+            isFirstTimeLoad = false;
+        }
+ 
+    }, true);
+ 
+    this.compileDirectiveTemplates = function () {
+        if (!$element.hasClass('ng-table')) {
+            $scope.templates = {
+                header: ($attrs.templateHeader ? $attrs.templateHeader : 'ng-table/header.html'),
+                pagination: ($attrs.templatePagination ? $attrs.templatePagination : 'ng-table/pager.html')
+            };
+            $element.addClass('ng-table');
+            var headerTemplate = null;
+            if ($element.find('> thead').length === 0) {
+                headerTemplate = angular.element(document.createElement('thead')).attr('ng-include', 'templates.header');
+                $element.prepend(headerTemplate);
+            }
+            var paginationTemplate = angular.element(document.createElement('div')).attr({
+                'ng-table-pagination': 'params',
+                'template-url': 'templates.pagination'
+            });
+            $element.after(paginationTemplate);
+            if (headerTemplate) {
+                $compile(headerTemplate)($scope);
+            }
+            $compile(paginationTemplate)($scope);
+        }
+    };
+ 
+    this.loadFilterData = function ($columns) {
+        angular.forEach($columns, function ($column) {
+            var def;
+            def = $column.filterData($scope, {
+                $column: $column
+            });
+            if (!def) {
+                delete $column.filterData;
+                return;
+            }
+ 
+            // if we're working with a deferred object, let's wait for the promise
+            if ((angular.isObject(def) && angular.isObject(def.promise))) {
+                delete $column.filterData;
+                return def.promise.then(function(data) {
+                    // our deferred can eventually return arrays, functions and objects
+                    if (!angular.isArray(data) && !angular.isFunction(data) && !angular.isObject(data)) {
+                        // if none of the above was found - we just want an empty array
+                        data = [];
+                    } else if (angular.isArray(data)) {
+                        data.unshift({
+                            title: '-',
+                            id: ''
+                        });
+                    }
+                    $column.data = data;
+                });
+            }
+            // otherwise, we just return what the user gave us. It could be a function, array, object, whatever
+            else {
+                return $column.data = def;
+            }
+        });
+    };
+ 
+    this.buildColumns = function (columns) {
+        return columns.map(function(col){
+            return ngTableColumn.buildColumn(col, $scope)
+        })
+    };
+ 
+    this.setupBindingsToInternalScope = function(tableParamsExpr){
+ 
+        // note: this we're setting up watches to simulate angular's isolated scope bindings
+ 
+        // note: is REALLY important to watch for a change to the ngTableParams *reference* rather than
+        // $watch for value equivalence. This is because ngTableParams references the current page of data as
+        // a field and it's important not to watch this
+        var tableParamsGetter = $parse(tableParamsExpr);
+        $scope.$watch(tableParamsGetter, (function (params) {
+            if (angular.isUndefined(params)) {
+                return;
+            }
+            $scope.paramsModel = tableParamsGetter;
+            $scope.params = params;
+        }), false);
+ 
+        if ($attrs.showFilter) {
+            $scope.$parent.$watch($attrs.showFilter, function(value) {
+                $scope.show_filter = value;
+            });
+        }
+        if ($attrs.disableFilter) {
+            $scope.$parent.$watch($attrs.disableFilter, function(value) {
+                $scope.$filterRow.disabled = value;
+            });
+        }
+    };
+ 
+    $scope.sortBy = function($column, event) {
+        var parsedSortable = $column.sortable && $column.sortable();
+        if (!parsedSortable) {
+            return;
+        }
+        var defaultSort = $scope.params.settings().defaultSort;
+        var inverseSort = (defaultSort === 'asc' ? 'desc' : 'asc');
+        var sorting = $scope.params.sorting() && $scope.params.sorting()[parsedSortable] && ($scope.params.sorting()[parsedSortable] === defaultSort);
+        var sortingParams = (event.ctrlKey || event.metaKey) ? $scope.params.sorting() : {};
+        sortingParams[parsedSortable] = (sorting ? inverseSort : defaultSort);
+        $scope.params.parameters({
+            sorting: sortingParams
+        });
+    };
+}]);
+ 
+ 
+/**
+ * @ngdoc service
+ * @name ngTable.factory:ngTableColumn
+ *
+ * @description
+ * Service to construct a $column definition used by {@link ngTable.directive:ngTable ngTable} directive
+ */
+app.factory('ngTableColumn', [function () {
+ 
+    var defaults = {
+        'class': function(){ return ''; },
+        filter: function(){ return false; },
+        filterData: angular.noop,
+        headerTemplateURL: function(){ return false; },
+        headerTitle: function(){ return ' '; },
+        sortable: function(){ return false; },
+        show: function(){ return true; },
+        title: function(){ return ' '; },
+        titleAlt: function(){ return ''; }
+    };
+ 
+    /**
+     * @ngdoc method
+     * @name ngTable.factory:ngTableColumn#buildColumn
+     * @methodOf ngTable.factory:ngTableColumn
+     * @description Creates a $column for use within a header template
+     *
+     * @param {Object} column an existing $column or simple column data object
+     * @param {Scope} defaultScope the $scope to supply to the $column getter methods when not supplied by caller
+     * @returns {Object} a $column object
+     */
+    function buildColumn(column, defaultScope){
+        // note: we're not modifying the original column object. This helps to avoid unintended side affects
+        var extendedCol = Object.create(column);
+        for (var prop in defaults) {
+            if (extendedCol[prop] === undefined) {
+                extendedCol[prop] = defaults[prop];
+            }
+            if(!angular.isFunction(extendedCol[prop])){
+                // wrap raw field values with "getter" functions
+                // - this is to ensure consistency with how ngTable.compile builds columns
+                // - note that the original column object is being "proxied"; this is important
+                //   as it ensure that any changes to the original object will be returned by the "getter"
+                (function(prop1){
+                    extendedCol[prop1] = function(){
+                        return column[prop1];
+                    };
+                })(prop);
+            }
+            (function(prop1){
+                // satisfy the arguments expected by the function returned by parsedAttribute in the ngTable directive
+                var getterFn = extendedCol[prop1];
+                extendedCol[prop1] = function(){
+                    if (arguments.length === 0){
+                        return getterFn.call(column, defaultScope);
+                    } else {
+                        return getterFn.apply(column, arguments);
+                    }
+                };
+            })(prop);
+        }
+        return extendedCol;
+    }
+ 
+    return {
+        buildColumn: buildColumn
+    };
+}]);
+ 
+/**
+ * ngTable: Table + Angular JS
+ *
+ * @author Vitalii Savchuk <esvit666@gmail.com>
+ * @url https://github.com/esvit/ng-table/
+ * @license New BSD License <http://creativecommons.org/licenses/BSD/>
+ */
+ 
+/**
+ * @ngdoc directive
+ * @name ngTable.directive:ngTable
+ * @restrict A
+ *
+ * @description
+ * Directive that instantiates {@link ngTable.directive:ngTable.ngTableController ngTableController}.
+ */
+app.directive('ngTable', ['$q', '$parse',
+    function($q, $parse) {
+        'use strict';
+ 
+        return {
+            restrict: 'A',
+            priority: 1001,
+            scope: true,
+            controller: 'ngTableController',
+            compile: function(element) {
+                var columns = [],
+                    i = 0,
+                    row = null;
+ 
+                // IE 8 fix :not(.ng-table-group) selector
+                angular.forEach(angular.element(element.find('tr')), function(tr) {
+                    tr = angular.element(tr);
+                    if (!tr.hasClass('ng-table-group') && !row) {
+                        row = tr;
+                    }
+                });
+                if (!row) {
+                    return;
+                }
+                angular.forEach(row.find('td'), function(item) {
+                    var el = angular.element(item);
+                    if (el.attr('ignore-cell') && 'true' === el.attr('ignore-cell')) {
+                        return;
+                    }
+ 
+                    var getAttrValue = function(attr){
+                        return el.attr('x-data-' + attr) || el.attr('data-' + attr) || el.attr(attr);
+                    };
+ 
+                    var parsedAttribute = function(attr) {
+                        var expr = getAttrValue(attr);
+                        if (!expr){
+                            return undefined;
+                        }
+                        return function(scope, locals) {
+                            return $parse(expr)(scope, angular.extend(locals || {}, {
+                                $columns: columns
+                            }));
+                        };
+                    };
+ 
+                    var titleExpr = getAttrValue('title-alt') || getAttrValue('title');
+                    if (titleExpr){
+                        el.attr('data-title-text', '{{' + titleExpr + '}}'); // this used in responsive table
+                    }
+                    // NOTE TO MAINTAINERS: if you add extra fields to a $column be sure to extend ngTableColumn with
+                    // a corresponding "safe" default
+                    columns.push({
+                        id: i++,
+                        title: parsedAttribute('title'),
+                        titleAlt: parsedAttribute('title-alt'),
+                        headerTitle: parsedAttribute('header-title'),
+                        sortable: parsedAttribute('sortable'),
+                        'class': parsedAttribute('header-class'),
+                        filter: parsedAttribute('filter'),
+                        headerTemplateURL: parsedAttribute('header'),
+                        filterData: parsedAttribute('filter-data'),
+                        show: (el.attr("ng-show") ? function (scope) {
+                            return $parse(el.attr("ng-show"))(scope);
+                        } : undefined)
+                    });
+                });
+                return function(scope, element, attrs, controller) {
+                    scope.$columns = columns = controller.buildColumns(columns);
+ 
+                    controller.setupBindingsToInternalScope(attrs.ngTable);
+                    controller.loadFilterData(columns);
+                    controller.compileDirectiveTemplates();
+                };
+            }
+        }
+    }
+]);
+ 
+/**
+ * @ngdoc directive
+ * @name ngTable.directive:ngTableDynamic
+ * @restrict A
+ *
+ * @description
+ * A dynamic version of the {@link ngTable.directive:ngTable ngTable} directive that accepts a dynamic list of columns
+ * definitions to render
+ */
+app.directive('ngTableDynamic', ['$parse', function ($parse){
+ 
+    function parseDirectiveExpression(attr) {
+        if (!attr || attr.indexOf(" with ") > -1) {
+            var parts = attr.split(/\s+with\s+/);
+            return {
+                tableParams: parts[0],
+                columns: parts[1]
+            };
+        } else {
+            throw new Error('Parse error (expected example: ng-table-dynamic=\'tableParams with cols\')');
+        }
+    }
+ 
+    return {
+        restrict: 'A',
+        priority: 1001,
+        scope: true,
+        controller: 'ngTableController',
+        compile: function(tElement) {
+            var row;
+ 
+            // IE 8 fix :not(.ng-table-group) selector
+            angular.forEach(angular.element(tElement.find('tr')), function(tr) {
+                tr = angular.element(tr);
+                if (!tr.hasClass('ng-table-group') && !row) {
+                    row = tr;
+                }
+            });
+            if (!row) {
+                return;
+            }
+ 
+            angular.forEach(row.find('td'), function(item) {
+                var el = angular.element(item);
+                var getAttrValue = function(attr){
+                    return el.attr('x-data-' + attr) || el.attr('data-' + attr) || el.attr(attr);
+                };
+ 
+                // this used in responsive table
+                var titleExpr = getAttrValue('title');
+                if (!titleExpr){
+                    el.attr('data-title-text', '{{$columns[$index].titleAlt(this) || $columns[$index].title(this)}}');
+                }
+                var showExpr = el.attr('ng-show');
+                if (!showExpr){
+                    el.attr('ng-show', '$columns[$index].show(this)');
+                }
+            });
+ 
+            return function(scope, element, attrs, controller) {
+                var expr = parseDirectiveExpression(attrs.ngTableDynamic);
+                var columns = $parse(expr.columns)(scope) || [];
+                scope.$columns = controller.buildColumns(columns);
+ 
+                controller.setupBindingsToInternalScope(expr.tableParams);
+                controller.loadFilterData(scope.$columns);
+                controller.compileDirectiveTemplates();
+            };
+        }
+    };
+}]);
+ 
+/**
+ * ngTable: Table + Angular JS
+ *
+ * @author Vitalii Savchuk <esvit666@gmail.com>
+ * @url https://github.com/esvit/ng-table/
+ * @license New BSD License <http://creativecommons.org/licenses/BSD/>
+ */
+ 
+/**
+ * @ngdoc directive
+ * @name ngTable.directive:ngTablePagination
+ * @restrict A
+ */
+app.directive('ngTablePagination', ['$compile',
+    function($compile) {
+        'use strict';
+ 
+        return {
+            restrict: 'A',
+            scope: {
+                'params': '=ngTablePagination',
+                'templateUrl': '='
+            },
+            replace: false,
+            link: function(scope, element, attrs) {
+ 
+                scope.params.settings().$scope.$on('ngTableAfterReloadData', function() {
+                    scope.pages = scope.params.generatePagesArray(scope.params.page(), scope.params.total(), scope.params.count());
+                }, true);
+ 
+                scope.$watch('templateUrl', function(templateUrl) {
+                    if (angular.isUndefined(templateUrl)) {
+                        return;
+                    }
+                    var template = angular.element(document.createElement('div'))
+                    template.attr({
+                        'ng-include': 'templateUrl'
+                    });
+                    element.append(template);
+                    $compile(template)(scope);
+                });
+            }
+        };
+    }
+]);
+angular.module('ngTable').run(['$templateCache', function ($templateCache) {
+    $templateCache.put('ng-table/filters/select-multiple.html', '<select ng-options="data.id as data.title for data in $column.data" ng-disabled="$filterRow.disabled" multiple ng-multiple="true" ng-model="params.filter()[name]" ng-show="filter==\'select-multiple\'" class="filter filter-select-multiple form-control" name="{{name}}"> </select>');
+    $templateCache.put('ng-table/filters/select.html', '<select ng-options="data.id as data.title for data in $column.data" ng-disabled="$filterRow.disabled" ng-model="params.filter()[name]" ng-show="filter==\'select\'" class="filter filter-select form-control" name="{{name}}"> </select>');
+    $templateCache.put('ng-table/filters/text.html', '<input type="text" name="{{name}}" ng-disabled="$filterRow.disabled" ng-model="params.filter()[name]" ng-if="filter==\'text\'" class="input-filter form-control"/>');
+    $templateCache.put('ng-table/header.html', '<tr> <th title="{{$column.headerTitle(this)}}" ng-repeat="$column in $columns" ng-class="{ \'sortable\': $column.sortable(this), \'sort-asc\': params.sorting()[$column.sortable(this)]==\'asc\', \'sort-desc\': params.sorting()[$column.sortable(this)]==\'desc\' }" ng-click="sortBy($column, $event)" ng-show="$column.show(this)" ng-init="template=$column.headerTemplateURL(this)" class="header {{$column.class(this)}}"> <div ng-if="!template" ng-show="!template" class="ng-table-header" ng-class="{\'sort-indicator\': params.settings().sortingIndicator==\'div\'}"> <span ng-bind="$column.title(this)" ng-class="{\'sort-indicator\': params.settings().sortingIndicator==\'span\'}"></span> </div> <div ng-if="template" ng-show="template" ng-include="template"></div> </th> </tr> <tr ng-show="show_filter" class="ng-table-filters"> <th data-title-text="{{$column.titleAlt(this) || $column.title(this)}}" ng-repeat="$column in $columns" ng-show="$column.show(this)" class="filter"> <div ng-repeat="(name, filter) in $column.filter(this)"> <div ng-if="filter.indexOf(\'/\') !==-1" ng-include="filter"></div> <div ng-if="filter.indexOf(\'/\')===-1" ng-include="\'ng-table/filters/\' + filter + \'.html\'"></div> </div> </th> </tr> ');
+    $templateCache.put('ng-table/pager.html', '<div class="ng-cloak ng-table-pager" ng-if="params.data.length"> <div ng-if="params.settings().counts.length" class="ng-table-counts btn-group pull-right"> <button ng-repeat="count in params.settings().counts" type="button" ng-class="{\'active\':params.count()==count}" ng-click="params.count(count)" class="btn btn-default"> <span ng-bind="count"></span> </button> </div> <ul class="pagination ng-table-pagination"> <li ng-class="{\'disabled\': !page.active && !page.current, \'active\': page.current}" ng-repeat="page in pages" ng-switch="page.type"> <a ng-switch-when="prev" ng-click="params.page(page.number)" href="">&laquo;</a> <a ng-switch-when="first" ng-click="params.page(page.number)" href=""><span ng-bind="page.number"></span></a> <a ng-switch-when="page" ng-click="params.page(page.number)" href=""><span ng-bind="page.number"></span></a> <a ng-switch-when="more" ng-click="params.page(page.number)" href="">&#8230;</a> <a ng-switch-when="last" ng-click="params.page(page.number)" href=""><span ng-bind="page.number"></span></a> <a ng-switch-when="next" ng-click="params.page(page.number)" href="">&raquo;</a> </li> </ul> </div> ');
+}]);
+    return app;
+}));

data/vendor/assets/stylesheets/ng-table.css

@@ -0,0 +1,137 @@
+
+.ng-table th {
+  text-align: center;
+  -webkit-touch-callout: none;
+  -webkit-user-select: none;
+  -khtml-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
+}
+.ng-table th.sortable {
+  cursor: pointer;
+}
+.ng-table th.sortable .sort-indicator {
+  padding-right: 18px;
+  position: relative;
+}
+.ng-table th.sortable .sort-indicator:after,
+.ng-table th.sortable .sort-indicator:before {
+  content: "";
+  border-width: 0 4px 4px;
+  border-style: solid;
+  border-color: #000 transparent;
+  visibility: visible;
+  right: 5px;
+  top: 50%;
+  position: absolute;
+  opacity: .3;
+  margin-top: -4px;
+}
+.ng-table th.sortable .sort-indicator:before {
+  margin-top: 2px;
+  border-bottom: none;
+  border-left: 4px solid transparent;
+  border-right: 4px solid transparent;
+  border-top: 4px solid #000;
+}
+.ng-table th.sortable .sort-indicator:hover:after,
+.ng-table th.sortable .sort-indicator:hover:before {
+  opacity: 1;
+  visibility: visible;
+}
+.ng-table th.sortable.sort-desc,
+.ng-table th.sortable.sort-asc {
+  background-color: rgba(141, 192, 219, 0.25);
+  text-shadow: 0 1px 1px rgba(255, 255, 255, 0.75);
+}
+.ng-table th.sortable.sort-desc .sort-indicator:after,
+.ng-table th.sortable.sort-asc .sort-indicator:after {
+  margin-top: -2px;
+}
+.ng-table th.sortable.sort-desc .sort-indicator:before,
+.ng-table th.sortable.sort-asc .sort-indicator:before {
+  visibility: hidden;
+}
+.ng-table th.sortable.sort-asc .sort-indicator:after,
+.ng-table th.sortable.sort-asc .sort-indicator:hover:after {
+  visibility: visible;
+  filter: alpha(opacity=60);
+  -khtml-opacity: 0.6;
+  -moz-opacity: 0.6;
+  opacity: 0.6;
+}
+.ng-table th.sortable.sort-desc .sort-indicator:after {
+  border-bottom: none;
+  border-left: 4px solid transparent;
+  border-right: 4px solid transparent;
+  border-top: 4px solid #000;
+  visibility: visible;
+  -webkit-box-shadow: none;
+  -moz-box-shadow: none;
+  box-shadow: none;
+  filter: alpha(opacity=60);
+  -khtml-opacity: 0.6;
+  -moz-opacity: 0.6;
+  opacity: 0.6;
+}
+.ng-table th.filter .input-filter {
+  margin: 0;
+  display: block;
+  width: 100%;
+  min-height: 30px;
+  -webkit-box-sizing: border-box;
+  -moz-box-sizing: border-box;
+  box-sizing: border-box;
+}
+.ng-table + .pagination {
+  margin-top: 0;
+}
+@media only screen and (max-width: 800px) {
+  .ng-table-responsive {
+    border-bottom: 1px solid #999999;
+  }
+  .ng-table-responsive tr {
+    border-top: 1px solid #999999;
+    border-left: 1px solid #999999;
+    border-right: 1px solid #999999;
+  }
+  .ng-table-responsive td:before {
+    position: absolute;
+    padding: 8px;
+    left: 0;
+    top: 0;
+    width: 50%;
+    white-space: nowrap;
+    text-align: left;
+    font-weight: bold;
+  }
+  .ng-table-responsive thead tr th {
+    text-align: left;
+  }
+  .ng-table-responsive thead tr.ng-table-filters th {
+    padding: 0;
+  }
+  .ng-table-responsive thead tr.ng-table-filters th form > div {
+    padding: 8px;
+  }
+  .ng-table-responsive td {
+    border: none;
+    border-bottom: 1px solid #eeeeee;
+    position: relative;
+    padding-left: 50%;
+    white-space: normal;
+    text-align: left;
+  }
+  .ng-table-responsive td:before {
+    content: attr(data-title-text);
+  }
+  .ng-table-responsive,
+  .ng-table-responsive thead,
+  .ng-table-responsive tbody,
+  .ng-table-responsive th,
+  .ng-table-responsive td,
+  .ng-table-responsive tr {
+    display: block;
+  }
+}

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: angular-ng-table-rails
+version: !ruby/object:Gem::Version
+  version: 0.5.4.1
+platform: ruby
+authors:
+- Daniel García-Gil
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-22 00:00:00.000000000 Z
+dependencies: []
+description: Injects ng-table Rails directives into your asset pipeline.
+email: 'danielgarciagil@gmail.com  '
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- lib/angular-ng-table-rails.rb
+- lib/angular-ng-table-rails/version.rb
+- vendor/assets/javascripts/ng-table.js
+- vendor/assets/stylesheets/ng-table.css
+homepage: https://github.com/danielgarciagil/angular-ng-table-rails.git
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: ng-table directive for angular on rails
+test_files: []