listpress 0.1.11

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3695595a23f6a3377c6248a0c9e01d9c6702e1a526567daebbb9d4724392f226
+  data.tar.gz: 0fb82ad6524ed2a9c80d8cf6f8d78751c4b5c14f80adce353e127e37e5098573
+SHA512:
+  metadata.gz: f3d0826640b1c3e4ba011a71ea41e0bd4203ffe98b730aca7535d48a9b0809e39d05ae4a374aab133ca295aba71d2d62c1ef20a8612bbfb452276b5a9a3e8982
+  data.tar.gz: ad69433776dbf5fc5d008416277df82556bc2a9d628301c609eda730b7c139dd80be1715206520d221bbc49c1a979c1f906d945f77e61cbd9e257b70ff839582

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in listpress.gemspec
+gemspec

data/README.md

@@ -0,0 +1,94 @@
+# Listpress
+
+Listing helper for Timepress projects
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'listpress', :git => 'git@git.timepress.cz:timepress/listpress.git', :branch => "master"
+```
+
+And then execute:
+
+    $ bundle install
+
+Add include to your `application.js`
+
+    //= require listpress
+
+And styles to your `application.scss`
+
+    @import 'listpress';
+
+## Usage
+
+In your view:
+
+```erb
+<%= listing @messages, per_page: 100, default_sort: "date:desc", default_filter: { resolved: false }, table_options: { class: "compact"} do |l| %>
+  <%# :code filter will use where(code: filter_value), because model has this attribute %>
+  <% l.filter :code, as: :select, collection: Message.distinct.order(:code).pluck(:code).collect{|c| [c, c]}  %>
+  
+  <%# :resolved filter will call method "resolved" on collection passing filter value as argument, (instead of attribute :resolved) %>
+  <% l.filter :resolved, as: :boolean, method: :resolved %>
+  
+  <%# will use search method %>
+  <% l.filter :search, as: :search %>
+
+  <%# set attributes for whole row %>
+  <% l.row_attributes {|item| { class: item.red? "red" : "" }} %>
+
+  <%# add class "nowrap", allow sorting by :date, custom output specified with a block %>
+  <% l.column(:date, class: "nowrap", sort: true, th_options: {title: "Wow such dates"}, td_options: {title: "Very short"}) {|m| lf m.date, format: :short} %>
+  
+  <%# passes the output (even if given by block) through format_helper() %>
+  <% l.column(:number, class: "num", helper: :format_number) %>
+  
+  <%# custom field label and output %>
+  <% l.column("!", class: "nowrap") do |m| %>
+    <span title="Status" style="color: red"><%= m.status %></span>
+  <% end %>
+  
+  <% sort by custom SQL %>
+  <% l.column(:customer, sort: Arel.sql("customers.name")) {|m| m.customer.name} %>
+  
+  <% l.column(:subject, sort: true) do |m| %>
+    <% if m.resolved? %>
+      <%= link_to m.subject, ote_msg_path(m, type: 'dec') %>
+    <% else %>
+      <b><%= link_to m.subject, ote_msg_path(m, type: 'dec') %></b>
+    <% end %>
+  <% end %>
+<% end %>
+```
+
+In your controller:
+
+```ruby
+  def index
+    @messages = Message.all  # listing gets the whole collection and it will apply sorting, filtering and paging on it's own
+    
+    respond_with_listing  # just as render :index, but with some tricks to manage AJAX requests
+  end
+```
+
+### Config
+
+You can change some setting in `Listpress::Config` class (for example in initializers).
+
+```ruby
+Listpress::Config.color = "green" # affects class of paginate links
+Listpress::Config.paginate_links_renderer = MaterializePaginateRenderer  # affects how WillPaginate renders the paging links
+```
+
+## Overriding views
+
+You can copy and override these templates:
+
+```
+app/views/shared/_listing.html.erb
+app/views/shared/_listing_filters.html.erb
+app/views/shared/_listing_table.html.erb
+```

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/app/assets/javascript/listpress.js

@@ -0,0 +1,130 @@
+$(document).ready(function () {
+    function updateUrlWithParams(url, params) {
+        var query;
+
+        // split query from url
+        var pos = url.indexOf('?');
+        if (pos > 0) {
+            query = url.substring(pos + 1);
+            url = url.substr(0, pos);
+        } else {
+            query = "";
+        }
+
+        // parse query into an object
+        var parsed_query = {};
+        query.replace(/&*([^=&]+)=([^=&]*)/gi, function(str,key,value) {parsed_query[decodeURIComponent(key.replace(/\+/g, ' '))] = decodeURIComponent(value.replace(/\+/g, ' '))});
+
+        // update query with params
+        $.each(params, function (i, param) {
+            parsed_query[param[0]] = param[1];
+        });
+
+        // create new URL
+        var sep = '?';
+        $.each(parsed_query, function (k, val) {
+            url += sep + encodeURIComponent(k) + '=' + encodeURIComponent(val);
+            sep = '&'
+        });
+
+        return url;
+    }
+
+    // timeout used so URL is not updated too often on typing
+    var pushStateTimeout = null;
+
+    // url that represents the last known state
+    var currentStateUrl = location.href;
+
+    // currently running AJAX
+    var currentXhr = null;
+
+    $('.listing').each(function () {
+        var $listing = $(this);
+        var $filters = $listing.find('.filters');
+        var $table = $listing.find('.table');
+        var $pages = $listing.find('.pages');
+        var name = $listing.data('name');
+
+        // factory for success function
+        var updateFn = function (delayedPush) {
+            return function (data) {
+                // update html
+                $table.html(data.table);
+                $pages.html(data.pages);
+
+                // update current state according to params sent from Rails
+                currentStateUrl = updateUrlWithParams(location.href, data.params);
+
+                // push state to history
+                if (pushStateTimeout) clearTimeout(pushStateTimeout);
+                if (delayedPush) {
+                    pushStateTimeout = setTimeout(function () {history.pushState(location.href, "listing", currentStateUrl)}, 300);
+                } else {
+                    history.pushState(location.href, "listing", currentStateUrl);
+                }
+
+                $listing.trigger('update', currentStateUrl);
+            }
+        };
+
+        // makes AJAX request and handles the response
+        var doRequest = function (url, delayedPush) {
+            if (currentXhr) currentXhr.abort();
+
+            currentXhr = $.ajax(url, {
+                method: 'GET',
+                dataType: 'json',
+                success: updateFn(delayedPush),
+                error: function (xhr, status, error) {
+                    if (status != "abort") {
+                        console.log("AJAX failed:", xhr, status, error);
+                        window.location = url;
+                    }
+                }
+            });
+        };
+
+        // handle paging links
+        $pages.on('click', 'a[href]', function () {
+            doRequest(updateUrlWithParams(currentStateUrl, [["listing", name], [name + "[page]", $(this).data('page')]]));
+            return false;
+        });
+
+        // handle sorting links
+        $table.on('click', 'a.sort', function () {
+            doRequest(updateUrlWithParams(currentStateUrl, [["listing", name], [name + "[sort]", $(this).data('sort')]]));
+            return false;
+        });
+
+        // handle filters
+        var filterTimeout = null;
+
+        $filters.on('submit', 'form', function () {return false;}); // prevent manual form submit
+
+        var submitFilters = function () {
+            // collect form data as params
+            var data = [];
+            $.each($filters.find('form').serializeArray(), function (i, o) {
+                if (o.name.substr(0, name.length + 8) == name + '[filter]') {
+                    data.push([o.name, o.value])
+                }
+            });
+            data.push(['listing', name]);
+            data.push([name + '[page]', 1]);
+
+            // send
+            doRequest(updateUrlWithParams(currentStateUrl, data), true);
+        };
+
+        $filters.on('input', 'input[type=text],textarea', function () {
+            if (filterTimeout) clearTimeout(filterTimeout);
+            filterTimeout = setTimeout(submitFilters, 200);
+        });
+        $filters.on('change', 'select', submitFilters);
+    });
+
+    $(window).on('popstate', function (e) {
+        location.reload()
+    })
+});

data/app/assets/stylesheets/listpress.scss

@@ -0,0 +1,13 @@
+.listing {
+  .sort-direction { font-size: 0.8rem; position: relative; top: -2px; }
+  .pages { padding: 15px 0;
+    .pagination { margin: 0; }
+    .pagination-info { float: right; font-size: 1.1rem; line-height: 2.0; margin: 0px 0; }
+  }
+
+  form { float: right; clear: right;
+    .input-field.inline { margin-top: -5px; margin-bottom: 0; }
+  }
+  table { clear: both; }
+  .list-empty td {height: 100px;line-height: 100px;text-align: center;vertical-align: middle;}
+}

data/app/views/shared/_listing.html.erb

@@ -0,0 +1,28 @@
+<div class="listing <%= list.options[:class] %>" data-name="<%= list.name %>">
+  <div class="filters">
+    <%# render and capture filters %>
+    <%= list.captures[:filters] = capture do %>
+      <% if list.filters.any? %>
+        <%= render "shared/listing_filters", list: list %>
+      <% end %>
+    <% end %>
+  </div>
+
+  <div class="table">
+    <%# render and capture table %>
+    <%= list.captures[:table] = capture do %>
+      <%= render "shared/listing_table", list: list %>
+    <% end %>
+  </div>
+
+  <div class="pages">
+    <%# render and capture pages %>
+    <%= list.captures[:pages] = capture do %>
+      <% if list.paginate? %>
+        <div class="pagination-info"><%= page_entries_info list.collection, model: list.collection.model %></div>
+        <%= will_paginate list.collection, renderer: Listpress::Config.paginate_link_renderer, param_name: list.page_param_name %>
+      <% end %>
+    <% end %>
+  </div>
+</div>
+

data/app/views/shared/_listing_filters.html.erb

@@ -0,0 +1,34 @@
+<%= form_with url: request.params, method: :get do |f| %>
+  <%# make hidden fields with all the GET params so they don't get lost on submit %>
+  <% list.flatten_params(request.GET).each do |k, v| %>
+    <%= f.hidden_field k, value: v unless ['utf8', list.page_param_name].include?(k) %>
+  <% end %>
+
+  <%# reset page when changing filters %>
+  <%= f.hidden_field list.page_param_name, value: 1 %>
+
+  <%# render filter fields %>
+  <% list.filters.each do |filter| %>
+    <% field_name = "#{list.name}[filter][#{filter[:name]}]" %>
+    <% field_value = list.filter_value(filter[:name]) %>
+    <% case filter[:as] %>
+<% when :boolean %>
+      <div class="input-field inline">
+        <%= f.select field_name, [[t('listpress.do_not_filter'), nil], [t('listpress.yes'), true], [t('listpress.no'), false]], selected: field_value %>
+        <label><%= list.human_name(filter[:name]) %></label>
+      </div>
+    <% when :select %>
+      <div class="input-field inline">
+        <%= f.select field_name, [[t('listpress.do_not_filter'), ""]] + filter[:collection], selected: field_value %>
+        <label><%= list.human_name(filter[:name]) %></label>
+      </div>
+    <% when :search %>
+      <div class="input-field inline">
+        <i class="material-icons prefix">search</i>
+        <%= f.text_field field_name, value: field_value, placeholder: t('listpress.search') %>
+      </div>
+    <% else %>
+      Unknown filter type <%= filter[:as] %>
+    <% end %>
+  <% end %>
+<% end %>

data/app/views/shared/_listing_table.html.erb

@@ -0,0 +1,37 @@
+<%= content_tag :table, list.options[:table_options] do %>
+  <thead>
+  <tr>
+    <%# render column headers with sorting indicator and links %>
+    <% sort_attr, sort_dir = list.sort %>
+    <% list.columns.each do |col| %>
+      <%= content_tag :th, (col[:th_options] || {}).merge(class: col[:class]) do %>
+        <% if col[:sort] %>
+          <% sort = sort_attr == col[:attr] && sort_dir == :asc ? "#{col[:attr]}:desc" : "#{col[:attr]}:asc" %>
+          <%= link_to list.human_name(col[:attr]), request.params.deep_merge(list.name => {sort: sort}), class: "sort", "data-sort": sort %>
+          <% if col[:attr] == sort_attr %>
+            <span class="sort-direction"><%= sort_dir == :asc ? "▲" : "▼" %></span>
+          <% end %>
+        <% else %>
+          <%= list.human_name(col[:attr]) %>
+        <% end %>
+      <% end %>
+    <% end %>
+  </tr>
+  </thead>
+  <tbody>
+  <% list.collection.each do |item| %>
+    <%= content_tag :tr, list.row_attributes[:proc]&.call(item) || list.row_attributes do %>
+      <%# render each row according to it's definition %>
+      <% list.columns.each do |col| %>
+        <%= content_tag :td, (col[:td_options] || {}).merge(class: col[:class]) do %>
+          <% v = col[:proc] ? capture { col[:proc].call(item).to_s } : item.public_send(col[:attr]) %>
+          <%= col[:helper] ? send(col[:helper], v) : v %>
+        <% end %>
+      <% end %>
+    <% end %>
+  <% end %>
+  <% if list.collection.empty? %>
+    <tr class="list-empty"><td colspan="<%= list.columns.size %>"><%= t('listpress.no_results') %></td></tr>
+  <% end %>
+  </tbody>
+<% end %>

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "listpress"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/listpress/bootstrap_paginate_renderer.rb

@@ -0,0 +1,47 @@
+require 'will_paginate'
+require 'will_paginate/view_helpers/action_view'
+
+module Listpress
+  class BootstrapPaginateRenderer < WillPaginate::ActionView::LinkRenderer
+    def html_container(html)
+      tag(:nav, tag(:ul, html, class: "pagination"))
+    end
+
+    def page_number(page)
+      if page == current_page
+        "<li class=\"page-item active\">" + link(page, page, rel: rel_value(page), "data-page": page) + "</li>"
+      else
+        "<li class=\"page-item\">" + link(page, page, rel: rel_value(page), "data-page": page) + "</li>"
+      end
+    end
+
+    def previous_page
+      num = @collection.current_page > 1 && @collection.current_page - 1
+      previous_or_next_page(num, "<i class=\"fas fa-chevron-left\"></i>")
+    end
+
+    def next_page
+      num = @collection.current_page < total_pages && @collection.current_page + 1
+      previous_or_next_page(num, "<i class=\"fas fa-chevron-right\"></i>")
+    end
+
+    def previous_or_next_page(page, text)
+      if page
+        "<li class=\"page-item\">" + link(text, page, "data-page": page) + "</li>"
+      else
+        "<li class=\"page-item disabled\"><span class=\"page-link\">" + text + "</span></li>"
+      end
+    end
+
+    def link(text, target, attributes = {})
+      if target.is_a?(Integer)
+        attributes[:rel] = rel_value(target)
+        target = url(target)
+      end
+      attributes[:href] = target
+      attributes[:class] = 'page-link'
+      tag(:a, text, attributes)
+    end
+
+  end
+end

data/lib/listpress/config.rb

@@ -0,0 +1,10 @@
+module Listpress
+  class Config
+    @color = "green"
+    @paginate_link_renderer = MaterializePaginateRenderer
+
+    class << self
+      attr_accessor :color, :paginate_link_renderer
+    end
+  end
+end

data/lib/listpress/default_resolver.rb

@@ -0,0 +1,66 @@
+module Listpress
+  class DefaultResolver
+    attr_reader :listing
+
+    def initialize(collection, listing)
+      @collection = collection
+      @listing = listing
+    end
+
+    # apply filters to collection
+    def filter(collection)
+      listing.filters.each do |filter|
+        val = listing.filter_value(filter[:name])
+
+        next if val.nil? || val == ""  # beware of false (valid filter value)
+
+        if filter[:proc]
+          collection = filter[:proc].call(collection, val)
+        elsif filter[:method]
+          collection = collection.public_send(filter[:method], val)
+        elsif filter[:column]
+          collection = collection.where(filter[:column] => val)
+        else
+          if collection.respond_to?(filter[:name]) && !collection.model.column_names.include?(filter[:name].to_s)
+            collection = collection.public_send(filter[:name], val)
+          elsif
+          collection = collection.where(filter[:name] => val)
+          end
+        end
+      end
+
+      collection
+    end
+
+    # apply sort to collection
+    def sort(collection)
+      attr, dir = listing.sort
+      if attr && column = listing.columns.detect {|c| c[:attr] == attr}
+        case column[:sort]
+        when true
+          collection = collection.order(attr => dir)
+        when Symbol, String
+          collection = collection.order(column[:sort] => dir)
+        when Hash
+          collection = collection.order(column[:sort][dir] || (raise ArgumentError, "When using hash as a :sort option for a column, :asc and :desc keys are expected."))
+        else
+          # do not sort
+        end
+      end
+
+      collection
+    end
+
+    def page(collection)
+      if listing.paginate?
+        collection = collection.paginate(page: listing.params[:page] || 1, per_page: listing.options[:per_page])
+      end
+
+      collection
+    end
+
+    def collection
+      @_collection_cache ||= page(sort(filter(@collection)))
+    end
+  end
+end

data/lib/listpress/engine.rb

@@ -0,0 +1,15 @@
+module Listpress
+  class Engine < ::Rails::Engine
+    initializer 'listpress' do
+      ActiveSupport.on_load(:action_view) do
+        include Listpress::Helper
+      end
+
+      ActiveSupport.on_load :i18n do
+        I18n.load_path.concat(Dir[File.join(File.dirname(__FILE__), 'locale', '*.yml')])
+      end
+
+      ActionController::Base.send :include, Helper
+    end
+  end
+end

data/lib/listpress/helper.rb

@@ -0,0 +1,74 @@
+module Listpress
+  module Helper
+    # Used to define and render Listing.
+    #
+    # Usage:
+    # <%= listing collection, options do |l| %>
+    #   <% l.column :id %>
+    #   ...
+    # <% end %>
+    #
+    # Options:
+    #   name: Identifies listing within a page - required for multiple listings on one page, (default: :list)
+    #   per_page: Limit output to this many items and turn paging on
+    #   params: Use these params instead of parsing them from request
+    #   default_sort: Use this sort if none specified in params (eg: "id:asc")
+    #
+    def listing(collection, options = {}, &block)
+      options = options.dup
+
+      name = options.delete(:name)&.to_sym || :list
+      pars = options.delete(:params) || params[name] || {}
+
+      if @_listing_only.nil? || @_listing_only == name
+        list = Listing.new(name, collection, options, pars)
+        yield list
+        output = render 'shared/listing', list: list
+
+        if controller.respond_to?(:listing_content)
+          controller.listing_content[name] = list.captures
+        end
+        if controller.respond_to?(:listing_instances)
+          controller.listing_instances[name] = list
+        end
+
+        output
+      else
+        ""
+      end
+    end
+
+    # Use in controller's index action to automatically handle AJAX response for listing
+    #
+    # Responds as usually for HTML requests, renders only the selected listing for AJAX.
+    def respond_with_listing(action = :index)
+      respond_to do |format|
+        format.html { render action }
+        format.json {
+          render_listing(action, name = params[:listing].presence&.to_sym || :list)
+          render json: listing_content[name].merge(params: Listing.flatten_params(request.GET.except(:listing)))
+        }
+      end
+    end
+
+    def render_listing(action = :index, name = nil)
+      list_only(name)
+      render_to_string action: action, formats: [:html], layout: nil
+    end
+
+    # Used in controller to store rendered listing content for JSON response
+    def listing_content
+      @_listing_content ||= {}
+    end
+
+    # Used in controller to retrieve rendered listing instance
+    def listing_instances
+      @_listing_instances ||= {}
+    end
+
+    # Used in controller to limit listing rendering only for +name+
+    def list_only(name)
+      @_listing_only = name
+    end
+  end
+end

data/lib/listpress/listing.rb

@@ -0,0 +1,161 @@
+module Listpress
+  class Listing
+    attr_reader :name, :collection, :filters, :options, :columns, :captures, :params
+
+    def initialize(name, collection, options = {}, params = {})
+      @name = name
+      @collection = collection
+      @options = options
+      @params = params
+      @columns = []
+      @filters = []
+      @captures = {}
+      @row_attributes = {}
+    end
+
+    # Defines a column
+    #
+    # Usage:
+    #     <%= listing collection, options do |l| %>
+    #       <% l.column :id, class: "right-align", sort: true %>
+    #       <% l.column :name, sort: true, helper: :shorten %>
+    #       <% l.column :special, th_options: { title: "Special column"}, td_options: { title: "With special cells" } %>
+    #
+    # Options:
+    #   class: Used as HTML class for this column's cells
+    #   sort: Allows sorting by this attribute
+    def column(*args, &block)
+      opts = args.extract_options!
+      attr = args[0] || ""
+
+      column = opts.merge(attr: attr)
+      column[:proc] = block if block_given?
+
+      @columns << column
+    end
+
+    # Defines attributes for each row (tr)
+    #
+    # Usage:
+    #     <%= listing collection, options do |l| %>
+    #       <% l.row_attributes {|item| { class: item.red? "red" : "" }} %>
+    #       ...
+    def row_attributes(*args, &block)
+      if block_given?
+        @row_attributes[:proc] = block
+      elsif !args.empty?
+        @row_attributes = args.extract_options!
+      else
+        @row_attributes
+      end
+    end
+
+    # Defines a filter
+    #
+    # Usage:
+    # <%= listing collection, options do |l| %>
+    #   <% l.filter :search, as: :search %>
+    #   <% l.filter :name, as: :text %>
+    #   <% l.filter(:active, as: :boolean) {|collection, value| collection.where(active: value)} %>
+    #   ...
+    # <% end %>
+    #
+    # Filter value is either used on collection method with the same name as the filter (ie. the first filter calls `collection.search(filter_value)`)
+    # or you can use block to alter your collection
+    #
+    def filter(*args, &block)
+      opts = args.extract_options!
+      name = args[0] || ""
+
+      filter = opts.merge(name: name)
+      filter[:proc] = block if block_given?
+
+      @filters << filter
+    end
+
+    # finds human_name (using I18n) for column +attr+
+    def human_name(attr)
+      return "" unless attr.present?
+
+      return attr if attr.is_a?(String)
+
+      if @collection.respond_to?(:model)
+        @collection.model.human_attribute_name(attr)
+      elsif @collection.respond_to?(:human_attribute_name)
+        @collection.human_attribute_name(attr)
+      else
+        attr.to_s.humanize
+      end
+    end
+
+    # return resolver object which decides how to filter, sort and page a collection according to listing params and options
+    def resolver
+      @resolver ||= (options[:resolver] || DefaultResolver).new(@collection, self)
+    end
+
+    # returns filtered, sorted and paged collection
+    def collection
+      resolver.collection
+    end
+
+    def paginate?
+      options[:per_page]
+    end
+
+    def page_param_name
+      "#{name}[page]"
+    end
+
+    # returns representation of arbitrarily nested params as list of pairs [field_name, value], that
+    # can be used in forms to recreate the params
+    def self.flatten_params(params, level=0)
+      out = []
+
+      case params
+      when Array
+        params.each do |v|
+          out += flatten_params(v, level+1).collect {|kk, vv| ['[]' + kk, vv]}
+        end
+      when Hash
+        params.each do |k, v|
+          k = level > 0 ? "[#{k}]" : k.to_s
+          out += flatten_params(v, level+1).collect {|kk, vv| [k + kk, vv]}
+        end
+      else
+        out << ['', params]
+      end
+
+      out
+    end
+
+    def flatten_params(*args)
+      self.class.flatten_params(*args)
+    end
+
+    # returns current sorting as [+attr+, +dir+] (both symbols) or nil if not set
+    def sort
+      s = params[:sort].presence || options.dig(:default_sort)
+
+      if s.present?
+        attr, dir = s.split(':', 2)
+
+        if %w(asc desc).include?(dir)
+          return attr.to_sym, dir.to_sym
+        end
+      end
+
+      nil
+    end
+
+    # return current value of filter +filter_name+
+    def filter_value(filter_name)
+      if params[:filter].respond_to?(:dig)
+        params[:filter].dig(filter_name)
+      elsif options[:default_filter]
+        options[:default_filter][filter_name]
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/listpress/locale/cs.yml

@@ -0,0 +1,7 @@
+cs:
+  listpress:
+    no_results: Nebyly nalezeny žádné výsledky.
+    do_not_filter: "- nefiltrovat -"
+    "yes": Ano
+    "no": Ne
+    search: Hledat

data/lib/listpress/locale/en.yml

@@ -0,0 +1,7 @@
+en:
+  listpress:
+    no_results: No results found.
+    do_not_filter: "- do not filter -"
+    "yes": Yes
+    "no": No
+    search: Search

data/lib/listpress/materialize_paginate_renderer.rb

@@ -0,0 +1,36 @@
+require 'will_paginate'
+require 'will_paginate/view_helpers/action_view'
+
+module Listpress
+  class MaterializePaginateRenderer < WillPaginate::ActionView::LinkRenderer
+    def html_container(html)
+      tag(:ul, html, class: "pagination")
+    end
+
+    def page_number(page)
+      if page == current_page
+        "<li class=\"#{Config.color} active\">" + link(page, page, rel: rel_value(page), "data-page": page) + "</li>"
+      else
+        "<li class=\"waves-effect\">" + link(page, page, rel: rel_value(page), "data-page": page) + "</li>"
+      end
+    end
+
+    def previous_page
+      num = @collection.current_page > 1 && @collection.current_page - 1
+      previous_or_next_page(num, "<i class=\"material-icons\">chevron_left</i>")
+    end
+
+    def next_page
+      num = @collection.current_page < total_pages && @collection.current_page + 1
+      previous_or_next_page(num, "<i class=\"material-icons\">chevron_right</i>")
+    end
+
+    def previous_or_next_page(page, text)
+      if page
+        "<li class=\"waves-effect\">" + link(text, page, "data-page": page) + "</li>"
+      else
+        "<li class=\"disabled\"><a>" + text + "</a></li>"
+      end
+    end
+  end
+end

data/lib/listpress/version.rb

@@ -0,0 +1,3 @@
+module Listpress
+  VERSION = "0.1.11"
+end

data/lib/listpress.rb

@@ -0,0 +1,13 @@
+require "listpress/version"
+require "listpress/materialize_paginate_renderer"
+require "listpress/bootstrap_paginate_renderer"
+
+require "listpress/config"
+require "listpress/engine"
+require "listpress/default_resolver"
+require "listpress/listing"
+require "listpress/helper"
+
+module Listpress
+
+end

data/listpress.gemspec

@@ -0,0 +1,37 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "listpress/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "listpress"
+  spec.version       = Listpress::VERSION
+  spec.authors       = ["Petr Sedivy"]
+  spec.email         = ["petr@timepress.cz"]
+
+  spec.summary       = %q{Listing helper for Timepress projects}
+  spec.homepage      = "https://git.timepress.cz/timepress/listpress"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://git.timepress.cz/timepress/listpress"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_runtime_dependency "will_paginate", "~> 3.1"
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: listpress
+version: !ruby/object:Gem::Version
+  version: 0.1.11
+platform: ruby
+authors:
+- Petr Sedivy
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2021-11-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: will_paginate
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: 
+email:
+- petr@timepress.cz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- app/assets/javascript/listpress.js
+- app/assets/stylesheets/listpress.scss
+- app/views/shared/_listing.html.erb
+- app/views/shared/_listing_filters.html.erb
+- app/views/shared/_listing_table.html.erb
+- bin/console
+- bin/setup
+- lib/listpress.rb
+- lib/listpress/bootstrap_paginate_renderer.rb
+- lib/listpress/config.rb
+- lib/listpress/default_resolver.rb
+- lib/listpress/engine.rb
+- lib/listpress/helper.rb
+- lib/listpress/listing.rb
+- lib/listpress/locale/cs.yml
+- lib/listpress/locale/en.yml
+- lib/listpress/materialize_paginate_renderer.rb
+- lib/listpress/version.rb
+- listpress.gemspec
+homepage: https://git.timepress.cz/timepress/listpress
+licenses: []
+metadata:
+  homepage_uri: https://git.timepress.cz/timepress/listpress
+  source_code_uri: https://git.timepress.cz/timepress/listpress
+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: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Listing helper for Timepress projects
+test_files: []