smart_listing 0.9.8 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e4fcf22c0d95a61711b265aa25f2a270a3f2b7e1
-  data.tar.gz: 723a731a8be9bd2b62db1dbf94fe3d2c9b06aeb2
+  metadata.gz: 41dcdfa429d72c12038175a0eb1252ad399b2a71
+  data.tar.gz: d277995fe1f1474795326b8db38c0fd07b307c0f
 SHA512:
-  metadata.gz: 665a03580d6ee2de1251f25623cac4bcb93ca469ca17a9fd60e81314b73cd7558503813d21a85ae687636ff8af701e009200b095e697e7a2988febad8d555b8d
-  data.tar.gz: 28091b9aa284ee8ae36e3e2b1837547231aeeddc3518dce04f320bc5ac416f86725c30971da4168fff89f44ee6391d5443941f87a270230398753ba3d9e3f9e2
+  metadata.gz: 6feb82a31cbe7dfdad359b3427325447a4ea63ad425189c752da1e93a9e1612ca32adb2d0f08f489193f9a29854721cf849b6e78f33c67f8789e8546d937e24c
+  data.tar.gz: c958ec953a3b49097490e90affb1785af82fa62c8318feafc7d3a72f37ebd86e8ca977dd9e47171dda0a289633e72c6819befa15995ce3ca0e857b526354544a

data/README.md

@@ -1,6 +1,8 @@
 # SmartListing
 
-SmartListing helps creating sortable lists of ActiveRecord collections with pagination, filtering and inline editing.
+SmartListing helps creating AJAX-enabled lists of ActiveRecord collections or arrays with pagination, filtering, sorting and in-place editing.
+
+[See it in action](http://showcase.sology.eu/smart_listing)
 
 ## Installation
 
@@ -16,23 +18,228 @@ Then run:
 $ bundle install
 ```
 
+Also, you need to add SmartListing to your asset pipeline:
+
+```
+//= require smart_listing
+```
+
+### Initializer
+
 Optionally you can also install some configuration initializer:
 
 ```sh
 $ rails generate smart_listing:install
 ```
 
-and views in order to customize them:
+It will be placed in `config/initializers/smart_listing.rb` and will allow you to tweak some configuration settings like HTML classes and data attributes names.
+
+### Custom views
+
+SmartListing comes with some built-in views which are by default compatible with Bootstrap 3. You can easily change them after installing:
 
 ```sh
 $ rails generate smart_listing:views
 ```
 
+Files will be placed in `app/views/smart_listing`.
+
 ## Usage
 
-Pending...
+Let's start with a controller. In order to use SmartListing, in most cases you need to include controller extensions and SmartListing helper methods:
+
+```ruby
+include SmartListing::Helper::ControllerExtensions
+helper  SmartListing::Helper
+```
+
+Next, put following code in controller action you desire:
+
+```ruby
+@users = smart_listing_create(:users, User.active, partial: "users/listing")
+```
+
+This will create SmartListing named `:users` consisting of ActiveRecord scope `User.active` elements and rendered by partial `users/listing`. You can also use arrays instead of ActiveRecord collections. Just put @array: true@ option just like for Kaminari.
+
+In the main view (typically something like `index.html.erb` or `index.html.haml`), use this method to render listing:
+
+```ruby
+smart_listing_render(:users)
+```
+
+`smart_listing_render` does some magic and renders `users/listing` partial which may look like this (in HAML):
+
+```haml
+- unless smart_listing.empty?
+  %table
+    %thead
+      %tr 
+        %th User name
+        %th Email
+    %tbody
+      - smart_listing.collection.each do |user|
+        %tr
+          %td= user.name
+          %td= user.email
+
+  = smart_listing.paginate 
+- else
+  %p.warning No records!
+```
+
+You can see that listing template has access to special `smart_listing` local variable which is basically an instance of `SmartListing::Helper::Builder`. It provides you with some helper methods that ease rendering of SmartListing:
+
+* `Builder#paginate` - renders Kaminari pagination,
+* `Builder#pagination_per_page_links` - display some link that allow you to customize Kaminari's `per_page`,
+* `Builder#collection` - accesses underlying list of items,
+* `Builder#empty?` - checks if collection is empty,
+* `Builder#count` - returns collection count,
+* `Builder#render` - basic template's `render` wrapper that automatically adds `smart_listing` local variable,
+
+There are also other methods that will be described in detail below.
+
+If you are using SmartListing with AJAX on (by default), one last thing required to make pagination (and other features) work is to create JS template for main view (typically something like `index.js.erb`):
+
+```erb
+<%= smart_listing_update(:users) %>
+```
+
+### Sorting
+
+SmartListing supports two modes of sorting: implicit and explicit. Implicit mode is enabled by default. In this mode, you define sort columns directly in the view:
+
+```haml
+- unless smart_listing.empty?
+  %table
+    %thead
+      %tr 
+        %th= smart_listing.sortable "User name", "name"
+        %th= smart_listing.sortable "Email", "email"
+    %tbody
+      - smart_listing.collection.each do |user|
+        %tr
+          %td= user.name
+          %td= user.email
+
+  = smart_listing.paginate 
+- else
+  %p.warning No records!
+```
+
+In this case `"name"` and `"email"` are sorting column names. `Builder#sortable` renders special link containing column name and sort order (either `asc`, `desc`, or empty value). 
+
+You can also specify default sort order in the controller:
+
+```ruby
+@users = smart_listing_create(:users, User.active, partial: "users/listing", default_sort: {:name: "asc"})
+```
+
+Implicit mode is convenient with simple data sets. In case you want to sort by joined column names, we advise you to use explicit sorting:
+```ruby
+@users = smart_listing_create :users, User.active.joins(:stats), partial: "users/listing", 
+                              sort_attributes: [[:last_signin, "stats.last_signin_at"]],
+                              default_sort: {last_signin: "desc"}
+```
+
+Note that `:sort_attributes` are array which of course means, that order of attributes matters.
+
+### List item management and in-place editing
+
+In order to allow managing and editing list items, we need to reorganize our views a bit. Basically, each item needs to have its own partial:
+
+```haml
+- unless smart_listing.empty?
+  %table
+    %thead
+      %tr 
+        %th= smart_listing.sortable "User name", "name"
+        %th= smart_listing.sortable "Email", "email"
+        %th
+    %tbody
+      - smart_listing.collection.each do |user|
+        %tr.editable{data: {id: user.id}}
+          = smart_listing.render partial: 'users/user', locals: {user: user}
+      = smart_listing.item_new colspan: 3, link: new_user_path 
+
+  = smart_listing.paginate 
+- else
+  %p.warning No records!
+```
+
+`<tr>` has now `editable` class and `data-id` attribute. These are essential to make it work. We've used also a new helper: `Builder#new_item`. It renders new row which is used for adding new items. `:link` needs to be valid url to new resource action which renders JS:
+
+```ruby
+<%= smart_listing_item :users, :new, @new_user, "users/form" %>
+```
+
+Note that `new` action does not need to create SmartListing (via `smart_listing_create`). It just initializes `@new_user` and renders JS view. 
+
+New partial for user (`users/user`) may look like this:
+```haml
+%td= user.name
+%td= user.email
+%td.actions= smart_listing_item_actions [{name: :edit, url: edit_user_path(user)}, {name: :destroy, url: user_path(user)}]
+```
+
+`smart_listing_item_actions` renders here links that allow to edit and destroy user item. `:edit` and `:destroy` are built-in actions, you can also define your `:custom` actions. Again. `<td>`'s class `actions` is important.
+
+Controller actions referenced by above urls are again plain Ruby on Rails actions that render JS like:
+
+```erb
+<%= smart_listing_item :users, :new, @user, "users/form" %>
+<%= smart_listing_item :users, :edit, @user, "users/form" %>
+<%= smart_listing_item :users, :destroy, @user %>
+```
+
+Partial name supplied to `smart_listing_item` (`users/form`) references `@user` as `object` and may look like this:
+
+```haml
+%td{colspan: 3}
+  - if object.persisted?
+    %p Edit user
+  - else
+    %p Add user
+
+  = form_for object, url: object.new_record? ? users_path : user_path(object), remote: true do |f|
+    %p
+      Name: 
+      = f.text_field :name
+    %p
+      Email: 
+      = f.text_field :email
+    %p= f.submit "Save"
+```
+
+And one last thing are `create` and `update` controller actions JS view:
+
+```ruby
+<%= smart_listing_item :users, :create, @user, @user.persisted? ? "users/user" : "users/form" %>
+<%= smart_listing_item :users, :update, @user, @user.valid? ? "users/user" : "users/form" %>
+```
+
+### Controls (filtering)
+
+SmartListing controls allow you to change somehow presented data. This is typically used for filtering records. Let's see how view with controls may look like:
+
+```haml
+= smart_listing_controls_for(:users) do
+  .filter.input-append
+    = text_field_tag :filter, '', class: "search", placeholder: "Type name here", autocomplete: "off"
+    %button.btn.disabled{type: "submit"}
+      %i.icon.icon-search
+```
+
+This gives you nice Bootstrap-enabled filter field with keychange handler. Of course you can use any other form fields in controls too.
+
+When form field changes its value, form is submitted and request is made. This needs to be handled in controller:
+
+```ruby
+users_scope = User.active.joins(:stats)
+users_scope = users_scope.like(params[:filter]) if params[:filter]
+@users = smart_listing_create :users, users_scope, partial: "users/listing"
+```
 
-### View
+Then, JS view is rendered and your SmartListing updated. That's it!
 
 ## Credits
 

data/app/assets/javascripts/{smart_listing/smart_listing.coffee.erb → smart_listing.coffee.erb}

@@ -1,6 +1,6 @@
 # Useful when SmartListing target url is different than current one
 $.rails.href = (element) ->
-  element.attr('href') || element.data('<% SmartListing.config.data_attributes(:href) %>')
+  element.attr('href') || element.data('<%= SmartListing.config.data_attributes(:href) %>')
 
 class SmartListing
   constructor: (e) ->
@@ -25,6 +25,8 @@ class SmartListing
         else
           editable.remove()
 
+          @container.trigger("smart_listing:destroy", editable)
+
         @changeItemCount(-1)
         @refresh()
 
@@ -45,16 +47,7 @@ class SmartListing
       false
 
     @container.on 'click', '.<%= SmartListing.config.classes(:item_actions) %> a[data-<%= SmartListing.config.data_attributes(:confirmation) %>]', (event) =>
-      # Check if we are confirming the right element
-      if(@confirmed != event.currentTarget)
-        # We need confirmation
-        $.fn.smart_listing.showConfirmation $(event.currentTarget), $(event.currentTarget).data('<%= SmartListing.config.data_attributes(:confirmation) %>'), (confirm_elem) =>
-          @confirmed = confirm_elem[0]
-        false
-      else
-        # Confirmed, reset flag and go ahead with deletion
-        @confirmed = null
-        true
+      $.fn.smart_listing.confirm $(event.currentTarget), $(event.currentTarget).data('<%= SmartListing.config.data_attributes(:confirmation) %>')
 
     @container.on 'click', '.<%= SmartListing.config.classes(:item_actions) %> a[data-<%= SmartListing.config.data_attributes(:popover) %>]', (event) =>
       name = $(event.currentTarget).data('<%= SmartListing.config.data_attributes(:popover) %>')
@@ -92,7 +85,7 @@ class SmartListing
     parseInt(@container.data('<%= SmartListing.config.data_attributes(:max_count) %>'))
 
   setAutoshow: (v) =>
-    @container.find('.<%= SmartListing.config.classes(:new_item_placeholder) %>').data('<%= SmartListing.config.data_attributes(:autoshow) %>', v)
+    @container.data('<%= SmartListing.config.data_attributes(:autoshow) %>', v)
 
   changeItemCount: (value) =>
     @container.find('.<%= SmartListing.config.classes(:pagination_per_page) %> .<%= SmartListing.config.classes(:pagination_count) %>').html(@itemCount() + value)
@@ -123,7 +116,7 @@ class SmartListing
         @container.find('.<%= SmartListing.config.classes(:new_item_placeholder) %>').addClass('<%= SmartListing.config.classes(:hidden) %>')
         @container.find('.<%= SmartListing.config.classes(:new_item_action) %>').addClass('<%= SmartListing.config.classes(:hidden) %>')
       else
-        if @container.find('.<%= SmartListing.config.classes(:new_item_placeholder) %>').data('<%= SmartListing.config.data_attributes(:autoshow) %>')
+        if @container.data('<%= SmartListing.config.data_attributes(:autoshow) %>')
           @container.find('.<%= SmartListing.config.classes(:new_item_placeholder) %>').removeClass('<%= SmartListing.config.classes(:hidden) %>')
           @container.find('.<%= SmartListing.config.classes(:new_item_action) %>').addClass('<%= SmartListing.config.classes(:hidden) %>')
         else
@@ -146,7 +139,7 @@ class SmartListing
 
   registerPopover: (name, callback) =>
     @popovers[name] = callback
-  
+
   #################################################################################################
   # Methods executed by rails UJS:
 
@@ -178,11 +171,15 @@ class SmartListing
       new_item.html(content)
       new_item_placeholder.before(new_item)
 
+      @container.trigger("smart_listing:create:success", new_item)
+
       @changeItemCount(1)
       @refresh()
     else
       new_item_placeholder.html(content)
 
+      @container.trigger("smart_listing:create:fail", new_item_placeholder)
+
     @fadeLoaded()
 
   edit: (id, content) =>
@@ -196,6 +193,8 @@ class SmartListing
     editable.html(content)
     editable.addClass('<%= SmartListing.config.classes(:inline_editing) %>')
 
+    @container.trigger("smart_listing:edit", editable)
+
     @fadeLoaded()
 
   update: (id, success, content) =>
@@ -205,10 +204,14 @@ class SmartListing
       editable.removeData('<%= SmartListing.config.data_attributes(:inline_edit_backup) %>')
       editable.html(content)
 
+      @container.trigger("smart_listing:update:success", editable)
+
       @refresh()
     else
       editable.html(content)
 
+      @container.trigger("smart_listing:update:fail", editable)
+
     @fadeLoaded()
   
   destroy: (id, destroyed) =>
@@ -217,6 +220,8 @@ class SmartListing
   remove: (id) =>
     editable = @container.find(".<%= SmartListing.config.classes(:editable) %>[data-<%= SmartListing.config.data_attributes(:id) %>=#{id}]").first()
     editable.remove()
+
+    @container.trigger("smart_listing:remove", editable)
   
   update_list: (content, data) =>
     $.each data, (key, value) =>
@@ -294,6 +299,17 @@ $.fn.smart_listing.showConfirmation = (confirmation_elem, msg, confirm_callback)
 
   $.fn.smart_listing.showPopover confirmation_elem, buildPopover(confirmation_elem, msg)
 
+$.fn.smart_listing.confirm = (elem, msg) ->
+  if !elem.data("confirmed")
+    # We need confirmation
+    $.fn.smart_listing.showConfirmation elem, msg, (confirm_elem) =>
+      confirm_elem.data("confirmed", true)
+    false
+  else
+    # Confirmed, reset flag and go ahead with deletion
+    elem.data("confirmed", false)
+    true
+
 $.fn.smart_listing.onLoading = (content, loader) ->
   content.stop(true).fadeTo(500, 0.2)
   loader.show()
@@ -335,9 +351,9 @@ $.fn.smart_listing_controls = () ->
 
 $.fn.smart_listing_controls.filter = (filter) ->
   form = filter.closest('form')
-  button = filter.find('button')
-  icon = filter.find('<%= SmartListing.config.selectors(:filtering_icon) %>')
-  field = filter.find('input')
+  button = form.find('<%= SmartListing.config.selectors(:filtering_button) %>')
+  icon = form.find('<%= SmartListing.config.selectors(:filtering_icon) %>')
+  field = form.find('<%= SmartListing.config.selectors(:filtering_input) %>')
 
   $.fn.smart_listing.observeField(field,
     onFilled: ->
@@ -352,10 +368,11 @@ $.fn.smart_listing_controls.filter = (filter) ->
       form.submit()
   )
 
-  icon.click ->
+  button.click ->
     if field.val().length > 0
       field.val('')
       field.trigger('keydown')
+    return false
 
 $ ->
   $('.<%= SmartListing.config.classes(:main) %>').smart_listing()

data/app/helpers/smart_listing/helper.rb

@@ -30,7 +30,7 @@ module SmartListing
 
       def paginate options = {}
         if @smart_listing.collection.respond_to? :current_page
-          @template.paginate @smart_listing.collection, {:remote => true, :param_name => @smart_listing.param_names[:page], :params => UNSAFE_PARAMS}.merge(@smart_listing.kaminari_options)
+          @template.paginate @smart_listing.collection, {:remote => @smart_listing.remote?, :param_name => @smart_listing.param_name(:page), :params => UNSAFE_PARAMS}.merge(@smart_listing.kaminari_options)
         end
       end
 
@@ -38,6 +38,7 @@ module SmartListing
         @smart_listing.collection
       end
 
+      # Check if smart list is empty
       def empty?
         @smart_listing.count == 0
       end
@@ -59,7 +60,7 @@ module SmartListing
 
       def pagination_per_page_link page
         if @smart_listing.per_page.to_i != page
-          url = @template.url_for(sanitize_params(@template.params.merge(@smart_listing.param_names[:per_page] => page, @smart_listing.param_names[:page] => 1)))
+          url = @template.url_for(sanitize_params(@template.params.merge(@smart_listing.all_params(:per_page => page, :page => 1))))
         end
 
         locals = {
@@ -71,17 +72,16 @@ module SmartListing
       end
 
       def sortable title, attribute, options = {}
-        extra = options.delete(:extra)
+        dirs = [nil, "asc", "desc"]
+        next_index = (dirs.index(@smart_listing.sort_order(attribute)) + 1) % dirs.length
 
         sort_params = {
-          @smart_listing.param_names[:sort_attr] => attribute, 
-          @smart_listing.param_names[:sort_order] => (@smart_listing.sort_order == "asc") ? "desc" : "asc", 
-          @smart_listing.param_names[:sort_extra] => extra
+          attribute => dirs[next_index]
         }
 
         locals = {
-          :ordered => @smart_listing.sort_attr == attribute && (!@smart_listing.sort_extra || @smart_listing.sort_extra == extra.to_s),
-          :url => @template.url_for(sanitize_params(@template.params.merge(sort_params))),
+          :order => @smart_listing.sort_order(attribute),
+          :url => @template.url_for(sanitize_params(@template.params.merge(@smart_listing.all_params(:sort => sort_params)))),
           :container_classes => [SmartListing.config.classes(:sortable)],
           :attribute => attribute,
           :title => title
@@ -125,10 +125,10 @@ module SmartListing
         locals = {
           :colspan => options.delete(:colspan),
           :no_items_classes => no_records_classes,
-          :no_items_text => options.delete(:no_items_text),
+          :no_items_text => options.delete(:no_items_text) || @template.t("smart_listing.msgs.no_items"),
           :new_item_button_url => options.delete(:link),
           :new_item_button_classes => new_item_button_classes,
-          :new_item_button_text => options.delete(:text),
+          :new_item_button_text => options.delete(:text) || @template.t("smart_listing.actions.new"),
           :new_item_autoshow => block_given?,
           :new_item_content => nil,
         }
@@ -149,9 +149,8 @@ module SmartListing
         end
       end
 
-      # Check if smart list is empty
-      def empty?
-        @smart_listing.count == 0
+      def count
+        @smart_listing.count
       end
 
       # Check if smart list reached its item max count
@@ -173,6 +172,7 @@ module SmartListing
 
     # Outputs smart list container
     def smart_listing_for name, *args, &block
+      puts args.to_yaml
       raise ArgumentError, "Missing block" unless block_given?
       name = name.to_sym
       options = args.extract_options!
@@ -202,46 +202,54 @@ module SmartListing
       output
     end
 
+    def smart_listing_render name, *args
+      smart_listing_for(name, *args) do |smart_listing|
+        concat(smart_listing.render_list)
+      end
+    end
+
+    def smart_listing_controls_for name, *args, &block
+      smart_listing = @smart_listings.try(:[], name)
+
+      classes = [SmartListing.config.classes(:controls), args.first.try(:[], :class)]
+
+      form_tag(smart_listing.try(:href) || {}, :remote => smart_listing.try(:remote?) || true, :method => :get, :class => classes, :data => {:smart_listing => name}) do
+        concat(content_tag(:div, :style => "margin:0;padding:0;display:inline") do
+          concat(hidden_field_tag("#{smart_listing.try(:base_param)}[_]", 1, :id => nil)) # this forces smart_listing_update to refresh the list
+        end)
+        concat(capture(&block))
+      end
+    end
+
     # Render item action buttons (ie. edit, destroy and custom ones)
     def smart_listing_item_actions actions = []
       content_tag(:span) do
         actions.each do |action|
           next unless action.is_a?(Hash)
 
-          if action.has_key?(:if)
-            unless action[:if]
-              concat(render(:partial => 'smart_listing/action_inactive'))
-              next
-            end
-          end
+          locals = {
+            :action_if => action.has_key?(:if) ? action[:if] : true, 
+            :url => action.delete(:url),
+            :icon => action.delete(:icon),
+            :title => action.delete(:title),
+          }
+          locals[:icon] = [locals[:icon], SmartListing.config.classes(:muted)] if !locals[:action_if]
 
           action_name = action[:name].to_sym
           case action_name
           when :show
-            locals = {
-              :url => action.delete(:url),
-              :icon => action.delete(:icon),
-            }
 						concat(render(:partial => 'smart_listing/action_show', :locals => locals))
           when :edit
-            locals = {
-              :url => action.delete(:url),
-              :icon => action.delete(:icon),
-            }
 						concat(render(:partial => 'smart_listing/action_edit', :locals => locals))
           when :destroy
-            locals = {
-              :url => action.delete(:url),
-              :icon => action.delete(:icon),
+            locals.merge!(
               :confirmation => action.delete(:confirmation),
-            }
+            )
 						concat(render(:partial => 'smart_listing/action_delete', :locals => locals))
           when :custom
-            locals = {
-              :url => action.delete(:url),
-              :icon => action.delete(:icon),
+            locals.merge!(
               :html_options => action,
-            }
+            )
 						concat(render(:partial => 'smart_listing/action_custom', :locals => locals))
           else
 						concat(render(:partial => "smart_listing/action_#{action_name}", :locals => {:action => action}))
@@ -261,9 +269,15 @@ module SmartListing
     # JS helpers:
 
     # Updates the smart list
-    def smart_listing_update name
+    def smart_listing_update name, options = {}
       name = name.to_sym
       smart_listing = @smart_listings[name]
+
+      # don't update list if params are missing (prevents interfering with other lists)
+      if params.keys.select{|k| k.include?("smart_listing")}.any? && !params[smart_listing.base_param]
+        return unless options[:force]
+      end
+
       builder = Builder.new(name, smart_listing, self, {}, nil)
       render(:partial => 'smart_listing/update_list', :locals => {
         :name => smart_listing.name, 

data/app/views/kaminari/smart_listing/_first_page.html.erb

@@ -0,0 +1,13 @@
+<%# Link to the "First" page
+  - available local variables
+    url:           url to the first page
+    current_page:  a page object for the currently displayed page
+    total_pages:   total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<% unless current_page.first? %>
+  <li class="first">
+  <%= link_to_unless current_page.first?, raw(t 'views.pagination.first'), url, :remote => remote %>
+  </li>
+<% end %>

data/app/views/kaminari/smart_listing/_gap.html.erb

@@ -0,0 +1,8 @@
+<%# Non-link tag that stands for skipped pages...
+  - available local variables
+    current_page:  a page object for the currently displayed page
+    total_pages:   total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<li class="page gap disabled"><a href="#" onclick="return false;"><%= raw(t 'views.pagination.truncate') %></a></li>

data/app/views/kaminari/smart_listing/_last_page.html.erb

@@ -0,0 +1,13 @@
+<%# Link to the "Last" page
+  - available local variables
+    url:           url to the last page
+    current_page:  a page object for the currently displayed page
+    total_pages:   total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<% unless current_page.last? %>
+  <li class="last next"><%# "next" class present for border styling in twitter bootstrap %>
+  <%= link_to_unless current_page.last?, raw(t 'views.pagination.last'), url, {:remote => remote} %>
+  </li>
+<% end %>

data/app/views/kaminari/smart_listing/_next_page.html.erb

@@ -0,0 +1,13 @@
+<%# Link to the "Next" page
+  - available local variables
+    url:           url to the next page
+    current_page:  a page object for the currently displayed page
+    total_pages:   total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<% unless current_page.last? %>
+  <li class="next_page">
+  <%= link_to_unless current_page.last?, raw(t 'views.pagination.next'), url, :rel => 'next', :remote => remote %>
+  </li>
+<% end %>

data/app/views/kaminari/smart_listing/_page.html.erb

@@ -0,0 +1,12 @@
+<%# Link showing page number
+  - available local variables
+    page:          a page object for "this" page
+    url:           url to this page
+    current_page:  a page object for the currently displayed page
+    total_pages:   total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<li class="page<%= ' active' if page.current? %>">
+  <%= link_to page, url, opts = {:remote => remote, :rel => page.next? ? 'next' : page.prev? ? 'prev' : nil} %>
+</li>

data/app/views/kaminari/smart_listing/_paginator.html.erb

@@ -0,0 +1,25 @@
+<%# The container tag
+  - available local variables
+    current_page:  a page object for the currently displayed page
+    total_pages:   total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+    paginator:     the paginator that renders the pagination tags inside
+-%>
+<%= paginator.render do -%>
+  <div class="text-center">
+    <ul class="pagination">
+      <%= first_page_tag unless current_page.first? %>
+      <%= prev_page_tag unless current_page.first? %>
+      <% each_page do |page| -%>
+          <% if page.left_outer? || page.right_outer? || page.inside_window? -%>
+            <%= page_tag page %>
+        <% elsif !page.was_truncated? -%>
+            <%= gap_tag %>
+        <% end -%>
+      <% end -%>
+      <%= next_page_tag unless current_page.last? %>
+      <%= last_page_tag unless current_page.last? %>
+    </ul>
+  </div>
+<% end -%>

data/app/views/kaminari/smart_listing/_prev_page.html.erb

@@ -0,0 +1,13 @@
+<%# Link to the "Previous" page
+  - available local variables
+    url:           url to the previous page
+    current_page:  a page object for the currently displayed page
+    total_pages:   total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<% unless current_page.first? %>
+<li class="prev">
+  <%= link_to_unless current_page.first?, raw(t 'views.pagination.previous'), url, :rel => 'prev', :remote => remote %>
+</li>
+<% end %>

data/app/views/smart_listing/_action_custom.html.erb

@@ -7,4 +7,4 @@
     html_options:       custom html options
 -%>
 
-<%= link_to(url, html_options) do %><%= content_tag(:i, '', :class => icon) %><% end %>
+<%= link_to_if(action_if, content_tag(:span, '', :class => icon, :title => title), url, html_options) %>

data/app/views/smart_listing/_action_delete.html.erb

@@ -5,6 +5,7 @@
     url:                destroy url
     icon
     confirmation:       confrimation text
+    title
 -%>
 
-<%= link_to(url, :remote => true, :class => "destroy", :method => :delete, :title => t("smart_listing.actions.destroy"), :data => {:confirmation => confirmation || t("smart_listing.msgs.destroy_confirmation")} ) do %><%= content_tag(:i, "", :class => icon || SmartListing.config.classes(:icon_trash)) %><% end %>
+<%= link_to_if(action_if, content_tag(:i, "", :class => icon || SmartListing.config.classes(:icon_trash)), url, :remote => true, :class => "destroy", :method => :delete, :title => title || t("smart_listing.actions.destroy"), :data => {:confirmation => confirmation || t("smart_listing.msgs.destroy_confirmation")} ) %>

data/app/views/smart_listing/_action_edit.html.erb

@@ -4,6 +4,7 @@
   Available local variables:
     url
     icon
+    title
 -%>
 
-<%= link_to(url, :remote => true, :class => "edit", :title => t("smart_listing.actions.edit") ) do %><%= content_tag(:i, '', :class => icon || SmartListing.config.classes(:icon_edit)) %><% end %>
+<%= link_to_if(action_if, content_tag(:i, '', :class => icon || SmartListing.config.classes(:icon_edit)), url, :remote => true, :class => "edit", :title => title || t("smart_listing.actions.edit") ) %>

data/app/views/smart_listing/_action_show.html.erb

@@ -4,6 +4,7 @@
   Available local variables:
     url
     icon
+    title
 -%>
 
-<%= link_to(url, :class => "show", :title => t("smart_listing.actions.show") ) do %><%= content_tag(:i, '', :class => icon || SmartListing.config.classes(:icon_show)) %><% end %>
+<%= link_to_if(action_if, content_tag(:i, '', :class => icon || SmartListing.config.classes(:icon_show)), url, :class => "show", :title => title || t("smart_listing.actions.show") ) %>

data/app/views/smart_listing/_pagination_per_page_link.html.erb

@@ -9,4 +9,4 @@
 -%>
 
 <% name = page == 0 ? t('views.pagination.unlimited') : page %>
-<%= url ? link_to(name, url, :remote => true) : content_tag(:span, name) %>
+<%= url ? link_to(name, url, :remote => smart_listing.remote?) : content_tag(:span, name) %>

data/app/views/smart_listing/_sortable.html.erb

@@ -6,15 +6,15 @@
     url:                sortable link url
     attribute:          current attribute name
     title:              current attribute title
-    ordered:            defines whether column is sorted or not
+    order:              defines column sort order
     smart_listing:      current SmartListing instance
     builder:            current builder instance
 -%>
 
 <%= link_to url, :class => container_classes, :data => {:attr => attribute}, :remote => true do %>
   <%= title %>
-  <% if ordered %>
-    <span class="<%= smart_listing.sort_order == "asc" ? SmartListing.config.classes(:icon_sort_up) : SmartListing.config.classes(:icon_sort_down) %>"></span>
+  <% if order %>
+    <span class="<%= order == "asc" ? SmartListing.config.classes(:icon_sort_up) : SmartListing.config.classes(:icon_sort_down) %>"></span>
   <% else %>
     <span class="<%= SmartListing.config.classes(:icon_sort_none) %>"></span>
   <% end %>

data/app/views/smart_listing/item/_create.js.erb

@@ -1,2 +1,3 @@
 var smart_listing = $('#<%= name %>').smart_listing();
+smart_listing.setAutoshow(false);
 smart_listing.create(<%= id || 0 %>, <%= object.persisted? %>, "<%= escape_javascript(render(:partial => part, :locals => {object_key => object})) %>");

data/app/views/smart_listing/item/_create_continue.js.erb

@@ -1,6 +1,6 @@
 var smart_listing = $('#<%= name %>').smart_listing();
-smart_listing.create(<%= id || 0 %>, <%= object.persisted? %>, "<%= escape_javascript(render(:partial => part, :locals => {object_key => object})) %>");
 smart_listing.setAutoshow(true);
+smart_listing.create(<%= id || 0 %>, <%= object.persisted? %>, "<%= escape_javascript(render(:partial => part, :locals => {object_key => object})) %>");
 <% if object.persisted? %>
   smart_listing.new_item("<%= escape_javascript(render(:partial => new.last, :locals => {object_key => new.first})) %>");
 <% end %>

data/config/locales/en.yml

@@ -2,10 +2,12 @@ en:
   smart_listing:
     msgs:
       destroy_confirmation: Destroy?
+      no_items: No items
     actions:
       destroy: Destroy
       edit: Edit
       show: Show
+      new: New item
   views:
     pagination:
       per_page: Per page

data/lib/generators/smart_listing/templates/initializer.rb

@@ -1,4 +1,19 @@
 SmartListing.configure do |config|
+  config.global_options({
+    #:param_names  => {                                              # param names
+      #:page                         => :page,
+      #:per_page                     => :per_page,
+      #:sort                         => :sort,
+    #},
+    #:array                          => false,                       # controls whether smart list should be using arrays or AR collections
+    #:max_count                      => nil,                         # limit number of rows
+    #:unlimited_per_page             => false,                       # allow infinite page size
+    #:paginate                       => true,                        # allow pagination
+    #:memorize_per_page              => false,                       # save per page settings in the cookie
+    #:page_sizes                     => DEFAULT_PAGE_SIZES,          # set available page sizes array
+    #:kaminari_options               => {:theme => "smart_listing"}, # Kaminari's paginate helper options
+  })
+
   config.constants :classes, {
     #:main                  => "smart-listing",
     #:editable              => "editable",
@@ -12,7 +27,7 @@ SmartListing.configure do |config|
     #:hidden                => "hidden",
     #:autoselect            => "autoselect",
     #:callback              => "callback",
-    #:pagination_per_page   => "pagination-per-page",
+    #:pagination_per_page   => "pagination-per-page text-center",
     #:pagination_count      => "count",
     #:inline_editing        => "info",
     #:no_records            => "no-records",

data/lib/smart_listing.rb

@@ -2,6 +2,23 @@ require 'smart_listing/config'
 require "smart_listing/engine"
 require "kaminari"
 
+# Fix parsing nester params
+module Kaminari
+  module Helpers
+    class Tag
+      def page_url_for(page)
+        @template.url_for @params.deep_merge(page_param(page)).merge(:only_path => true)
+      end
+
+      private
+
+      def page_param(page)
+        Rack::Utils.parse_nested_query("#{@param_name}=#{page <= 1 ? nil : page}").symbolize_keys
+      end
+    end
+  end
+end
+
 module SmartListing
   class Base
     if Rails.env.development?
@@ -10,32 +27,19 @@ module SmartListing
       DEFAULT_PAGE_SIZES = [10, 20, 50, 100]
     end
 
-    attr_reader :name, :collection, :options, :per_page, :page, :sort_attr, :sort_order, :sort_extra, :partial, :count
+    attr_reader :name, :collection, :options, :per_page, :sort, :page, :partial, :count
 
     def initialize name, collection, options = {}
       @name = name
 
       @options = {
-        :param_names  => {                                      # param names
-          :page                         => "#{@name}_page".to_sym,
-          :per_page                     => "#{@name}_per_page".to_sym,
-          :sort_attr                    => "#{@name}_sort_attr".to_sym,
-          :sort_order                   => "#{@name}_sort_order".to_sym,
-          :sort_extra                   => "#{@name}_sort_extra".to_sym,
-        },
-        :partial                        => @name,               # smart list partial name
-        :array                          => false,               # controls whether smart list should be using arrays or AR collections
-        :max_count                      => nil,                 # limit number of rows
-        :unlimited_per_page             => false,               # allow infinite page size
-        :sort                           => true,                # allow sorting
-        :paginate                       => true,                # allow pagination
-        :href                           => nil,                 # set smart list target url (in case when different than current url)
-        :callback_href                  => nil,                 # set smart list callback url (in case when different than current url)
-        :default_sort_attr              => nil,                 # default sort by
-        :memorize_per_page              => false,
-        :page_sizes                     => DEFAULT_PAGE_SIZES,  # set available page sizes array
-        :kaminari_options               => {},                  # Kaminari's paginate helper options
-      }.merge!(options)
+        :partial                        => @name,                       # SmartListing partial name
+        :sort_attributes                => :implicit,                   # allow implicitly setting sort attributes
+        :default_sort                   => {},                          # default sorting
+        :href                           => nil,                         # set SmartListing target url (in case when different than current url)
+        :remote                         => true,                        # SmartListing is remote by default
+        :callback_href                  => nil,                         # set SmartListing callback url (in case when different than current url)
+      }.merge(SmartListing.config.global_options).merge(options)
 
       if @options[:array]
         @collection = collection.to_a
@@ -45,14 +49,16 @@ module SmartListing
     end
 
     def setup params, cookies
-      @page = params[param_names[:page]]
-      @per_page = !params[param_names[:per_page]] || params[param_names[:per_page]].empty? ? (@options[:memorize_per_page] && cookies[param_names[:per_page]].to_i > 0 ? cookies[param_names[:per_page]].to_i : page_sizes.first) : params[param_names[:per_page]].to_i
-      @per_page = DEFAULT_PAGE_SIZES.first unless DEFAULT_PAGE_SIZES.include?(@per_page)
-      @sort_attr = params[param_names[:sort_attr]] || @options[:default_sort_attr]
-      @sort_order = ["asc", "desc"].include?(params[param_names[:sort_order]]) ? params[param_names[:sort_order]] : "desc"
-      @sort_extra = params[param_names[:sort_extra]]
+      @params = params
+
+      @page = get_param :page
+      @per_page = !get_param(:per_page) || get_param(:per_page).empty? ? (@options[:memorize_per_page] && get_param(:per_page, cookies).to_i > 0 ? get_param(:per_page, cookies).to_i : page_sizes.first) : get_param(:per_page).to_i
+      @per_page = page_sizes.first unless page_sizes.include?(@per_page)
 
-      cookies[param_names[:per_page]] = @per_page if @options[:memorize_per_page]
+      @sort = parse_sort(get_param(:sort)) || @options[:default_sort]
+      sort_keys = (@options[:sort_attributes] == :implicit ? @sort.keys.collect{|s| [s, s]} : @options[:sort_attributes])
+
+      set_param(:per_page, @per_page, cookies) if @options[:memorize_per_page]
 
       @count = @collection.size
       @count = @count.length if @count.is_a?(Hash)
@@ -64,26 +70,29 @@ module SmartListing
       end
 
       if @options[:array]
-        @collection = @collection.sort do |x, y|
-          xval = x
-          yval = y
-          @sort_attr.split(".").each do |m|
-            xval = xval.try(m)
-            yval = yval.try(m)
-          end
-          xval = xval.upcase if xval.is_a?(String)
-          yval = yval.upcase if yval.is_a?(String)
-
-          if xval.nil? || yval.nil?
-            xval.nil? ? 1 : -1
-          else
-            if @sort_order == "asc"
-              (xval <=> yval) || (xval && !yval ? 1 : -1)
-            else
-              (yval <=> xval) || (yval && !xval ? 1 : -1)
+        if @sort && @sort.any? # when array we sort only by first attribute
+          i = sort_keys.index{|x| x[0] == @sort.first[0]}
+          @collection = @collection.sort do |x, y|
+            xval = x
+            yval = y
+            sort_keys[i][1].split(".").each do |m|
+              xval = xval.try(m)
+              yval = yval.try(m)
             end
-          end
-        end if @options[:sort] && @sort_attr && !@sort_attr.empty?
+            xval = xval.upcase if xval.is_a?(String)
+            yval = yval.upcase if yval.is_a?(String)
+
+            if xval.nil? || yval.nil?
+              xval.nil? ? 1 : -1
+            else
+              if @sort.first[1] == "asc"
+                (xval <=> yval) || (xval && !yval ? 1 : -1)
+              else
+                (yval <=> xval) || (yval && !xval ? 1 : -1)
+              end
+            end 
+          end 
+        end
         if @options[:paginate] && @per_page > 0
           @collection = ::Kaminari.paginate_array(@collection).page(@page).per(@per_page)
           if @collection.length == 0
@@ -91,7 +100,9 @@ module SmartListing
           end
         end
       else
-        @collection = @collection.order("#{@sort_attr} #{@sort_order}") if @options[:sort] && @sort_attr && !@sort_attr.empty? && @collection.column_names.include?(@sort_attr) && @sort_order
+        # let's sort by all attributes
+        @collection = @collection.order(sort_keys.collect{|s| "#{s[1]} #{@sort[s[0]]}" if @sort[s[0]]}.compact) if @sort && @sort.any?
+
         if @options[:paginate] && @per_page > 0
           @collection = @collection.page(@page).per(@per_page)
         end
@@ -106,6 +117,10 @@ module SmartListing
       @options[:param_names]
     end
 
+    def param_name key
+      "#{base_param}[#{param_names[key]}]"
+    end
+
     def unlimited_per_page?
       !!@options[:unlimited_per_page]
     end
@@ -122,6 +137,10 @@ module SmartListing
       @options[:callback_href]
     end
 
+    def remote?
+      @options[:remote]
+    end
+
     def page_sizes
       @options[:page_sizes]
     end
@@ -130,12 +149,65 @@ module SmartListing
       @options[:kaminari_options]
     end
 
-    def all_params
-      ap = {}
+    def all_params overrides = {}
+      ap = {base_param => {}}
       @options[:param_names].each do |k, v|
-        ap[v] = self.send(k)
+        if overrides[k]
+          ap[base_param][v] = overrides[k]
+        else
+          ap[base_param][v] = self.send(k)
+        end
       end
       ap
     end
+
+    def sort_order attribute
+      @sort && @sort[attribute].present? ? @sort[attribute] : nil
+    end
+
+    def base_param
+      "#{name}_smart_listing"
+    end
+
+    private
+
+    def get_param key, store = @params
+      if store.is_a?(ActionDispatch::Cookies::CookieJar)
+        store["#{base_param}_#{param_names[key]}"]
+      else
+        store[base_param].try(:[], param_names[key])
+      end
+    end
+
+    def set_param key, value, store = @params
+      if store.is_a?(ActionDispatch::Cookies::CookieJar)
+        store["#{base_param}_#{param_names[key]}"] = value
+      else
+        store[base_param] ||= {}
+        store[base_param][param_names[key]] = value
+      end
+    end
+
+    def parse_sort sort_params
+      sort = nil
+
+      if @options[:sort_attributes] == :implicit
+        sort = sort_params.dup if sort_params.present?
+      elsif @options[:sort_attributes]
+        @options[:sort_attributes].each do |a|
+          k, v = a
+          if sort_params && sort_params[k.to_s]
+            dir = ["asc", "desc", ""].delete(sort_params[k.to_s])
+
+            if dir
+              sort ||= {}
+              sort[k] = dir
+            end
+          end
+        end
+      end
+
+      sort
+    end
   end
 end

data/lib/smart_listing/config.rb

@@ -8,7 +8,27 @@ module SmartListing
   end
 
   class Configuration
+    if Rails.env.development?
+      DEFAULT_PAGE_SIZES = [3, 10, 20, 50, 100]
+    else
+      DEFAULT_PAGE_SIZES = [10, 20, 50, 100]
+    end
+
     DEFAULTS = {
+      :global_options => {
+        :param_names  => {                                      # param names
+          :page                         => :page,
+          :per_page                     => :per_page,
+          :sort                         => :sort,
+        },
+        :array                          => false,                       # controls whether smart list should be using arrays or AR collections
+        :max_count                      => nil,                         # limit number of rows
+        :unlimited_per_page             => false,                       # allow infinite page size
+        :paginate                       => true,                        # allow pagination
+        :memorize_per_page              => false,
+        :page_sizes                     => DEFAULT_PAGE_SIZES,          # set available page sizes array
+        :kaminari_options               => {:theme => "smart_listing"}, # Kaminari's paginate helper options
+      },
       :constants => {
         :classes => {
           :main => "smart-listing",
@@ -23,7 +43,7 @@ module SmartListing
           :hidden => "hidden",
           :autoselect => "autoselect",
           :callback => "callback",
-          :pagination_per_page => "pagination-per-page",
+          :pagination_per_page => "pagination-per-page text-center",
           :pagination_count => "count",
           :inline_editing => "info",
           :no_records => "no-records",
@@ -39,11 +59,12 @@ module SmartListing
           :icon_new => "glyphicon glyphicon-plus",
           :icon_edit => "glyphicon glyphicon-pencil",
           :icon_trash => "glyphicon glyphicon-trash",
-          :icon_inactive => "glyphicon glyphicon-circle",
+          :icon_inactive => "glyphicon glyphicon-remove-circle text-muted",
           :icon_show => "glyphicon glyphicon-share-alt",
           :icon_sort_none => "glyphicon glyphicon-resize-vertical",
           :icon_sort_up => "glyphicon glyphicon-chevron-up",
           :icon_sort_down => "glyphicon glyphicon-chevron-down",
+          :muted => "text-muted",
         },
         :data_attributes => {
           :main => "smart-listing",
@@ -64,7 +85,9 @@ module SmartListing
           :edit_cancel => "button.cancel",
           :row => "tr",
           :head => "thead",
-          :filtering_icon => "i"
+          :filtering_button => "button",
+          :filtering_icon => "button span",
+          :filtering_input => ".filter input"
         }
       }
     }
@@ -78,11 +101,10 @@ module SmartListing
     end
     
     def constants key, value = nil
-      if value == nil
-        @options[:constants][key]
-      else
+      if value
         @options[:constants][key].merge!(value)
       end
+      @options[:constants][key]
     end
 
     def classes key
@@ -96,5 +118,12 @@ module SmartListing
     def selectors key
       @options[:constants][:selectors][key]
     end
+
+    def global_options value = nil
+      if value
+        @options[:global_options].merge!(value)
+      end
+      @options[:global_options]
+    end
   end
 end

data/lib/smart_listing/version.rb

@@ -1,3 +1,3 @@
 module SmartListing
-  VERSION = "0.9.8"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smart_listing
 version: !ruby/object:Gem::Version
-  version: 0.9.8
+  version: 1.0.0
 platform: ruby
 authors:
 - Sology
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-03 00:00:00.000000000 Z
+date: 2014-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.15.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.15.1
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -76,15 +76,19 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- app/assets/javascripts/smart_listing/application.js
-- app/assets/javascripts/smart_listing/smart_listing.coffee.erb
-- app/assets/stylesheets/smart_listing/application.css
+- app/assets/javascripts/smart_listing.coffee.erb
 - app/helpers/smart_listing/application_helper.rb
 - app/helpers/smart_listing/helper.rb
+- app/views/kaminari/smart_listing/_first_page.html.erb
+- app/views/kaminari/smart_listing/_gap.html.erb
+- app/views/kaminari/smart_listing/_last_page.html.erb
+- app/views/kaminari/smart_listing/_next_page.html.erb
+- app/views/kaminari/smart_listing/_page.html.erb
+- app/views/kaminari/smart_listing/_paginator.html.erb
+- app/views/kaminari/smart_listing/_prev_page.html.erb
 - app/views/smart_listing/_action_custom.html.erb
 - app/views/smart_listing/_action_delete.html.erb
 - app/views/smart_listing/_action_edit.html.erb
-- app/views/smart_listing/_action_inactive.html.erb
 - app/views/smart_listing/_action_show.html.erb
 - app/views/smart_listing/_item_new.html.erb
 - app/views/smart_listing/_pagination_per_page_link.html.erb

data/app/assets/javascripts/smart_listing/application.js

@@ -1,14 +0,0 @@
-// This is a manifest file that'll be compiled into application.js, which will include all the files
-// listed below.
-//
-// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
-// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
-//
-// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
-// compiled file.
-//
-// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
-// about supported directives.
-//
-//= require_tree .
-//= require smart_listing/smart_listing

data/app/assets/stylesheets/smart_listing/application.css

@@ -1,13 +0,0 @@
-/*
- * This is a manifest file that'll be compiled into application.css, which will include all the files
- * listed below.
- *
- * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
- * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
- *
- * You're free to add application-wide styles to this file and they'll appear at the top of the
- * compiled file, but it's generally better to create a new file per style scope.
- *
- *= require_self
- *= require_tree .
- */

data/app/views/smart_listing/_action_inactive.html.erb

@@ -1,5 +0,0 @@
-<%# 
-  Inactive action.
--%>
-
-<%= content_tag(:i, '', :class => SmartListing.config.classes(:icon_inactive)) %>