active_admin_filters_visibility 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ba40a984e58c7a130d4095d252e8cca24ae6fc61a113ddcf0e47054e50e0dff2
+  data.tar.gz: 17b98e349a820b26b492fa09d5b5aef630fabeb86034558f9ac6fcb0cd3f9e68
+SHA512:
+  metadata.gz: 2cb4576be45526b17a2ac122288316f19a86fa9aa91e80bea89caa02af212d10974d95c1151b41da48c72dfae2a85a0be46ffd5dc9a7225c371d4aa8bea2e575
+  data.tar.gz: 47dd06a5e6c3828607d4e9049350275a0793d0efc4c0ccdca11fe1e62772898809c4bf26d4514a49d8dd159178a5f6c9d602596cbb563089b4a75c12637dd26c

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Gena M. <workgena@gmail.com>
+
+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,145 @@
+# ActiveAdminFiltersVisibility
+
+ActiveAdmin plugin allows to hide any filter from Filters Sidebar.
+Useful when page has many filters, but admin user needs only some of them.
+Every filter saves its state using browser's LocalStorage. 
+
+![Demonstration](https://raw.githubusercontent.com/activeadmin-plugins/active_admin_filters_visibility/master/screen/example_aa_filters_visibility.gif "Visibility example")
+
+Also you can use drag&drop to change filters order
+
+![Demonstration](https://raw.githubusercontent.com/activeadmin-plugins/active_admin_filters_visibility/master/screen/example_aa_filters_ordering.gif "Ordering example")
+
+## Install
+
+In Gemfile add
+
+```ruby
+  gem 'active_admin_filters_visibility', git: 'https://github.com/activeadmin-plugins/active_admin_filters_visibility' 
+```
+
+in the 
+``` 
+  app/assets/javascript/active_admin.coffee
+```
+
+and 
+
+```coffeescript
+  #= require active_admin_filters_visibility
+```
+
+and initialize it with:
+
+```javascript 
+  $(document).ready(function() {
+    $('#filters_sidebar_section').activeAdminFiltersVisibility();
+  });
+```
+
+## Customization
+
+```coffeescript
+  $('.jquery-selector').activeAdminFiltersVisibility(options)
+```
+
+ActiveAdminFiltersVisibility is a standard jQuery Plugin, and accepts some "options" as a hash. 
+Default is:
+
+```javascript
+{
+    sidebarUniqId: function() {
+      return window.location.pathname;
+    },
+    icon: '☶',
+    iconClass: '',
+    iconStyle: '',
+    skipDefaultCss: false,
+    title: 'Visibility:',
+    ordering: false,
+    orderHint: 'Drag&Drop to reorder filters',
+    resetButtonTitle: 'Reset'
+}
+```
+
+You can change icon - this is a HTML text or symbol. You can pass empty string and customize it with your CSS.
+Or you can set class("iconClass") for icon or inline styles("iconStyle").
+
+This plugin has minimal CSS styling. 
+In case you want to use custom CSS, default styling can be ignored: 
+set ```skipDefaultCss``` to ```true```
+
+
+### Ordering
+
+By default ordering is disabled. You can turn it: set option ```ordering``` to ```true```.
+
+
+### Texts
+Change text in options: ```title```, ```orderHint``` and ```resetButtonTitle```
+
+
+### Dont hide filters which has selected value
+
+If filter has selected value - that filter will not be hidden on page reload. Even if "visibility checkbox" is unchecked.
+This was made for preventing unpredictable filtering: for example when user came to page by some link with predefined filtering params.
+All default filters types(string, numeric, date range, etc.) are implemented.
+But if you have some specific filter, you need to add custom handler.
+
+For example you have customized filter by ID.
+And you want to consider "1" as default value and allow hiding it.
+In this case you should add uniq class to wrapper.
+
+```ruby
+filter :id, wrapper_html: { class: 'filter_customized_id' }
+```
+
+```javascript
+    // return TRUE if this filter has value
+    // elWrapper is jQuery element "div.filter_form_field.filter_customized_id"
+    // if not "1" then consider this filter as active, and return TRUE to prevent hiding
+    $.fn.activeAdminFiltersVisibility.registerFilterType('customized_id', function(elWrapper) {
+        var inputValue = elWrapper.find('input').val();
+        return inputValue != '1';
+    });
+```
+
+
+### Saving state
+
+Plugin saves list of hidden filters in LocalStorage, using jQuery plugin "Lockr" https://github.com/tsironis/lockr
+If you need to save this in cookies or user profile, you should write your own implementation - rewrite "$.fn.activeAdminFiltersVisibility.storage".
+For example:
+
+```javascript
+$.fn.activeAdminFiltersVisibility.storage = function(storageUniqId) {
+    // initialize storage with "storageUniqId"
+    // every page(sidebar filters) must has its uniq storageUniqId
+    var myStorage = new MyCustomizedStorage(storageUniqId);
+
+    return {
+        add: function(labelText) {
+            // add hidden filter "labelText" to storage myStorage
+            myStorage.add(labelText);
+        },
+        remove: function(labelText) {
+            // drop hidden filter "labelText" to storage myStorage
+            // makes filter visible again
+            myStorage.remove(labelText);
+        },
+        has: function(labelText) {
+            // check if labelText already hidden(in storage)
+            // should return true if exists
+            return myStorage.find(labelText) ? true : false;
+        },
+        all: function() {
+            // return array of hidden labels(filters)
+            return myStorage.getAll(); // ['Id', 'Name', 'Created At']
+        },
+        any: function() {
+            // check if current Sidebar Filter has some hidden elements
+            return this.all().length > 0;
+        }
+    }
+};
+```

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/active_admin_filters_visibility.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'active_admin_filters_visibility/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'active_admin_filters_visibility'
+  s.version     = ActiveAdminFiltersVisibility::VERSION
+  s.authors     = ['Gena M.']
+  s.email       = ['workgena@gmail.com']
+  s.homepage    = 'https://github.com/workgena/active_admin_filters_visibility'
+  s.summary     = %q{active_admin_filters_visibility gem}
+  s.description = %q{extension for activeadmin gem to hide any filters from sidebar-filters panel}
+
+  s.add_dependency 'activeadmin'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+end

data/app/assets/javascripts/active_admin_filters_visibility.js

@@ -0,0 +1,517 @@
+(function($) {
+
+    // Plugin definition
+    $.fn.activeAdminFiltersVisibility = function(options) {
+        var settings = $.extend({}, $.fn.activeAdminFiltersVisibility.defaults, options || {});
+
+        var storageKey = settings.sidebarUniqId(),
+            storage = $.fn.activeAdminFiltersVisibility.storage(storageKey),
+            panel = $(this);
+
+        if (panel.length > 1) {
+            console.log('Cant be applied to multiple sidebars');
+            return panel;
+        }
+
+
+        function diffArray(arr1, arr2) {
+            return arr1.concat(arr2).filter(function (val) {
+                if (!(arr1.includes(val) && arr2.includes(val)))
+                    return val;
+            });
+        }
+
+
+
+        function findFilterWrapperByLabelText(labelText) {
+            return panel.find(".filter_form_field label").filter(function() {
+                var nodeText = $(this)[0].childNodes[0].textContent;
+                return nodeText === labelText;
+            }).closest('.filter_form_field');
+        }
+
+        function buildCheckboxesHtml() {
+            var html = '';
+
+            var labels = panel.find('.filter_form_field label:first-child').map(function() {
+                var text = $(this)[0].childNodes[0].textContent.trim()
+                $(this).closest('.filter_form_field').attr('data-pseudo-id', encodeURIComponent(text));
+                return text;
+            }).get();
+
+            var orderedLabels = storage.getOrder();
+
+            //diffArray
+            if (orderedLabels.length > 0) {
+                if (diffArray(labels, orderedLabels).length) {
+                    storage.reset();
+                } else {
+                    labels = orderedLabels;
+                }
+            }
+
+            $.each(labels, function(i, text) {
+                var checked = storage.has(text) ? '' : 'checked="checked"';
+                html += '<div><label data-pseudo-id="'+encodeURIComponent(text)+'"><input type="checkbox" value="'+text+'" ' + checked +'> ' + text + '</label></div>';
+            });
+
+            return html;
+        }
+
+        function renderNotice() {
+            var btn = panel.find('.filters-visibility-button');
+            if (storage.any()) {
+                btn.addClass('active');
+            } else {
+                btn.removeClass('active');
+            }
+        }
+
+        function render() {
+            // Button
+            panel.find('h3:first')
+                .append('<span class="filters-visibility-button" class="' + settings.iconClass + '" style="' + settings.iconStyle + '">' + settings.icon + '</span>');
+
+            // Settings Panel
+            panel.find('.panel_contents').prepend(
+                '<div class="filters-visibility-panel">' +
+                    '<div><strong>' + settings.title + '</strong></div>' +
+                    buildCheckboxesHtml() +
+                '</div>'
+            );
+
+            // Hide filters
+            $.each(storage.all(), function(i, labelText) {
+                var elWrapper = findFilterWrapperByLabelText(labelText);
+                if ( false == isFilterFilled(elWrapper) ) {
+                    elWrapper.hide();
+                }
+            });
+
+            // Mark button if some filters are hidden
+            renderNotice();
+        }
+
+
+
+        function hide(labelText) {
+            findFilterWrapperByLabelText(labelText).hide();
+            storage.add(labelText);
+            renderNotice();
+        }
+
+        function show(labelText) {
+            findFilterWrapperByLabelText(labelText).show();
+            storage.remove(labelText);
+            renderNotice();
+        }
+
+        // prevent hiding filter if it is no empty (triggers only on page render)
+        function isFilterFilled(elWrapper) {
+            if (elWrapper.length == 0) {
+                return false;
+            }
+            var klasses = elWrapper.attr('class').split(' ');
+
+            var filterTypeName = $.grep(klasses, function(v) {
+                return v != 'filter_form_field' && /^filter_/.test(v)
+            })[0].replace(/^filter_/, "");
+
+            function _detectIsFilled(filterTypeName, elWrapper) {
+                var functionOrString = $.fn.activeAdminFiltersVisibility.filtersTypesDefinitions[filterTypeName];
+
+                if (typeof functionOrString == 'string' && functionOrString != filterTypeName) {
+                    return $.fn.activeAdminFiltersVisibility.filtersTypesDefinitions[functionOrString].call(this, elWrapper);
+                } else if (typeof functionOrString == 'function') {
+                    return functionOrString.call(this, elWrapper);
+                } else {
+                    return $.fn.activeAdminFiltersVisibility.filtersTypesDefinitions['default'].call(this, elWrapper);
+                }
+            }
+
+            return _detectIsFilled(filterTypeName, elWrapper);
+        }
+
+
+        // apply styles
+        if (settings.skipDefaultCss == false) {
+            $.fn.activeAdminFiltersVisibility.css();
+        }
+
+
+        panel.on('click', '.filters-visibility-button', function() {
+            panel.find('.filters-visibility-panel').toggle();
+        });
+
+        panel.on('change', '.filters-visibility-panel input[type=checkbox]', function() {
+            var $this = $(this),
+                labelText = $this.parent().text().trim();
+
+            if ($this.prop('checked')) {
+                show(labelText);
+            } else {
+                hide(labelText);
+            }
+        });
+
+        render();
+
+        if (settings.ordering) {
+            $.fn.activeAdminFiltersVisibility.applyOrder(panel, storage);
+            var resetButtonHtml = '<a href="#" class="filters-visibility-reset-btn">' + settings.resetButtonTitle + '</a>';
+            panel.find('.filters-visibility-panel div:first')
+                .append(resetButtonHtml)
+                .after('<div><i>' + settings.orderHint + '</i></div>');
+
+            panel.on('click', '.filters-visibility-reset-btn', function(e) {
+                e.preventDefault();
+                storage.reset();
+                window.location.reload();
+            });
+        }
+
+        return panel;
+    };
+
+    // Ordering
+    $.fn.activeAdminFiltersVisibility.applyOrder = function(panel, storage) {
+
+        // re-render sidebar filters(even if they are not visible, show/hide event is independent and knows nothing about order)
+        function renderReorderedFilters() {
+            var wrapper = panel.find('form');
+            var order = storage.getOrder();
+
+            var existingOrder = panel.find('.filter_form_field label:first-child').map(function() {
+                return $(this)[0].childNodes[0].textContent.trim();
+            }).get();
+
+            if (order.length > 0 && JSON.stringify(order) != JSON.stringify(existingOrder)) {
+                var pos = 0;
+                $.each(order, function(i, text) {
+                    var textEncoded = encodeURIComponent(text);
+                    var el = wrapper.find('div[data-pseudo-id="' + textEncoded + '"]');
+                    if (el.length > 0) {
+                        var elOnThisPosition = wrapper.find('.filter_form_field').eq(pos);
+                        if (elOnThisPosition.data('pseudo-id') != textEncoded) {
+                            wrapper[0].insertBefore(el[0], elOnThisPosition[0]);
+                        }
+                        pos++;
+                    }
+                });
+            }
+        }
+
+
+        var isOrdered = storage.getOrder().length > 0;
+
+        // define draggable elements
+
+        panel.find('.filters-visibility-panel label').attr('draggable', 'true');
+
+        // Attach events
+        panel.on('drop', '.filters-visibility-panel label', function(e) {
+            e.preventDefault();
+            var drag_el_id = e.originalEvent.dataTransfer.getData("text"),
+                drag_el = panel.find('label[data-pseudo-id="' + drag_el_id + '"]'),
+                drop_el = $(this),
+                wrapper = panel.find('.filters-visibility-panel');
+
+            if (drag_el != drop_el) {
+                wrapper[0].insertBefore(drag_el.parent()[0], drop_el.parent()[0]);
+
+                var orderedList = wrapper.find('label').map(function() {
+                    return $(this).text().trim();
+                }).get();
+
+                storage.setOrder(orderedList);
+
+                renderReorderedFilters();
+            }
+        });
+
+        panel.on('dragover', '.filters-visibility-panel', function(e) {
+            e.preventDefault();
+        });
+
+        panel.find('.filters-visibility-panel label').on('dragstart', function(e) {
+            var key = $(this).data('pseudo-id');
+            e.originalEvent.dataTransfer.setData("text", key);
+        });
+
+
+        // Apply Order
+        if (isOrdered) {
+            // Apply reorder !!!
+            renderReorderedFilters();
+        }
+
+        return panel;
+    };
+
+
+
+    // Plugin Storage method
+    $.fn.activeAdminFiltersVisibility.storage = function(storageUniqId) {
+        // https://github.com/tsironis/lockr
+        var Lockr = function(){
+            if (!Array.prototype.indexOf) {
+                Array.prototype.indexOf = function(elt)
+                {
+                    var len = this.length >>> 0;
+
+                    var from = Number(arguments[1]) || 0;
+                    from = (from < 0)
+                        ? Math.ceil(from)
+                        : Math.floor(from);
+                    if (from < 0)
+                        from += len;
+
+                    for (; from < len; from++)
+                    {
+                        if (from in this &&
+                            this[from] === elt)
+                            return from;
+                    }
+                    return -1;
+                };
+            }
+
+            var Lockr = {};
+
+            Lockr.prefix = "";
+
+            Lockr._getPrefixedKey = function(key, options) {
+                options = options || {};
+
+                if (options.noPrefix) {
+                    return key;
+                } else {
+                    return this.prefix + key;
+                }
+
+            };
+
+            Lockr.set = function (key, value, options) {
+                var query_key = this._getPrefixedKey(key, options);
+
+                try {
+                    localStorage.setItem(query_key, JSON.stringify({"data": value}));
+                } catch (e) {
+                    if (console) console.warn("Lockr didn't successfully save the '{"+ key +": "+ value +"}' pair, because the localStorage is full.");
+                }
+            };
+
+            Lockr.get = function (key, missing, options) {
+                var query_key = this._getPrefixedKey(key, options),
+                    value;
+
+                try {
+                    value = JSON.parse(localStorage.getItem(query_key));
+                } catch (e) {
+                    if(localStorage[query_key]) {
+                        value = {data: localStorage.getItem(query_key)};
+                    } else{
+                        value = null;
+                    }
+                }
+                if(value === null) {
+                    return missing;
+                } else if (typeof value === 'object' && typeof value.data !== 'undefined') {
+                    return value.data;
+                } else {
+                    return missing;
+                }
+            };
+
+            Lockr.sadd = function(key, value, options) {
+                var query_key = this._getPrefixedKey(key, options),
+                    json;
+
+                var values = Lockr.smembers(key);
+
+                if (values.indexOf(value) > -1) {
+                    return null;
+                }
+
+                try {
+                    values.push(value);
+                    json = JSON.stringify({"data": values});
+                    localStorage.setItem(query_key, json);
+                } catch (e) {
+                    console.log(e);
+                    if (console) console.warn("Lockr didn't successfully add the "+ value +" to "+ key +" set, because the localStorage is full.");
+                }
+            };
+
+            Lockr.smembers = function(key, options) {
+                var query_key = this._getPrefixedKey(key, options),
+                    value;
+
+                try {
+                    value = JSON.parse(localStorage.getItem(query_key));
+                } catch (e) {
+                    value = null;
+                }
+
+                if (value === null)
+                    return [];
+                else
+                    return (value.data || []);
+            };
+
+            Lockr.sismember = function(key, value, options) {
+                return Lockr.smembers(key).indexOf(value) > -1;
+            };
+
+            Lockr.keys = function() {
+                var keys = [];
+                var allKeys = Object.keys(localStorage);
+
+                if (Lockr.prefix.length === 0) {
+                    return allKeys;
+                }
+
+                allKeys.forEach(function (key) {
+                    if (key.indexOf(Lockr.prefix) !== -1) {
+                        keys.push(key.replace(Lockr.prefix, ''));
+                    }
+                });
+
+                return keys;
+            };
+
+            Lockr.getAll = function () {
+                var keys = Lockr.keys();
+                return keys.map(function (key) {
+                    return Lockr.get(key);
+                });
+            };
+
+            Lockr.srem = function(key, value, options) {
+                var query_key = this._getPrefixedKey(key, options),
+                    json,
+                    index;
+
+                var values = Lockr.smembers(key, value);
+
+                index = values.indexOf(value);
+
+                if (index > -1)
+                    values.splice(index, 1);
+
+                json = JSON.stringify({"data": values});
+
+                try {
+                    localStorage.setItem(query_key, json);
+                } catch (e) {
+                    if (console) console.warn("Lockr couldn't remove the "+ value +" from the set "+ key);
+                }
+            };
+
+            Lockr.rm =  function (key) {
+                localStorage.removeItem(key);
+            };
+
+            Lockr.flush = function () {
+                if (Lockr.prefix.length) {
+                    Lockr.keys().forEach(function(key) {
+                        localStorage.removeItem(Lockr._getPrefixedKey(key));
+                    });
+                } else {
+                    localStorage.clear();
+                }
+            };
+            return Lockr;
+
+        }();
+
+        var storageIdForOrder = '__ordered__' + storageUniqId;
+
+        return {
+            setOrder: function(orderedList) {
+                Lockr.set(storageIdForOrder, orderedList);
+            },
+            getOrder: function() {
+                return Lockr.get(storageIdForOrder) || [];
+            },
+            reset: function() {
+                Lockr.rm(storageIdForOrder);
+                Lockr.rm(storageUniqId);
+            },
+            add: function(key) {
+                Lockr.sadd(storageUniqId, key);
+            },
+            remove: function(key) {
+                Lockr.srem(storageUniqId, key);
+            },
+            has: function(key) {
+                return Lockr.sismember(storageUniqId, key);
+            },
+            all: function() {
+                return Lockr.smembers(storageUniqId);
+            },
+            any: function() {
+                return this.all().length > 0;
+            }
+        }
+    };
+
+
+    // Style
+    $.fn.activeAdminFiltersVisibility.css = function() {
+        var lines = [];
+
+        lines.push('.filters-visibility-button { margin: 0 5px 0 5px; padding: 0 4px 0 4px; background-color: rgba(0, 0, 0, 0.05); float: right; cursor: pointer; }');
+        lines.push('.filters-visibility-button.active { color: #007ab8; }');
+        lines.push('.filters-visibility-panel { display: none; border-left: 10px solid rgba(0, 0, 0, 0.1); background-color: rgba(0, 0, 0, 0.02); margin-bottom: 10px; }');
+        lines.push('.filters-visibility-panel > div { margin-left: 5px; }');
+        lines.push('.filters-visibility-panel > div:first-child { display: flex; }');
+        lines.push('.filters-visibility-panel .filters-visibility-reset-btn { display: inline-block; margin-left: auto; }');
+
+        var sheet = document.createElement('style');
+        sheet.type = 'text/css';
+        sheet.innerHTML = lines.join(' ');
+        document.body.appendChild(sheet);
+    };
+
+
+    // Prevent filter from being hidden this filter is was used for filtering data
+    $.fn.activeAdminFiltersVisibility.filtersTypesDefinitions = {
+        'default': function (elWrapper) {
+            var notEmptyInput = elWrapper.find('input[id!=""][type!="hidden"][value][value!=""]');
+            return notEmptyInput.length > 0;
+        }
+    };
+
+    $.fn.activeAdminFiltersVisibility.registerFilterType = function(name, filterTypeDefinitionFunc) {
+        $.fn.activeAdminFiltersVisibility.filtersTypesDefinitions[name] = filterTypeDefinitionFunc;
+    };
+
+    $.fn.activeAdminFiltersVisibility.registerFilterType('check_boxes', function(elWrapper) {
+        return elWrapper.find('input[id!=""][type!="hidden"][value][value!=""]:checked').length > 0;
+    });
+
+    $.fn.activeAdminFiltersVisibility.registerFilterType('select', function(elWrapper) {
+        return elWrapper.find('select[id]:first').val().length > 0;
+    });
+
+    $.fn.activeAdminFiltersVisibility.registerFilterType('boolean', 'select');
+
+
+
+    // Plugin defaults
+    $.fn.activeAdminFiltersVisibility.defaults = {
+        sidebarUniqId: function() {
+            return window.location.pathname;
+        },
+        icon: '&#9782;',
+        iconClass: '',
+        iconStyle: '',
+        skipDefaultCss: false,
+        ordering: false,
+        title: 'Visibility:',
+        orderHint: 'Drag&Drop to reorder filters',
+        resetButtonTitle: 'Reset'
+    };
+
+})(jQuery);

data/lib/active_admin_filters_visibility.rb

@@ -0,0 +1,9 @@
+require 'activeadmin'
+require 'active_admin_filters_visibility/version'
+
+module ActiveAdminFiltersVisibility
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/active_admin_filters_visibility/version.rb

@@ -0,0 +1,3 @@
+module ActiveAdminFiltersVisibility
+  VERSION = '1.2.0'
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: active_admin_filters_visibility
+version: !ruby/object:Gem::Version
+  version: 1.2.0
+platform: ruby
+authors:
+- Gena M.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-02-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activeadmin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: extension for activeadmin gem to hide any filters from sidebar-filters
+  panel
+email:
+- workgena@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- active_admin_filters_visibility.gemspec
+- app/assets/javascripts/active_admin_filters_visibility.js
+- lib/active_admin_filters_visibility.rb
+- lib/active_admin_filters_visibility/version.rb
+- screen/example_aa_filters_ordering.gif
+- screen/example_aa_filters_visibility.gif
+homepage: https://github.com/workgena/active_admin_filters_visibility
+licenses: []
+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.7.7
+signing_key: 
+specification_version: 4
+summary: active_admin_filters_visibility gem
+test_files: []