peentar-smart_listing 1.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0c9945c464be02df429975a97ffeb2a2fbd3e9e1
+  data.tar.gz: 80b5ad364b9a8cf5789edb8345d812a1602ae401
+SHA512:
+  metadata.gz: 91c4a5b7ee56ba8c688b273dcffa64e379332fe6686101e3075c3957b97710277bf775d7f3a8cbc257980dee1def579fc570aa25be2552b5ef351839f3ab2468
+  data.tar.gz: 4a391032b898acd2ee6af810bcde7e871abd3350fc7d7c7c3b6b33445fab216c8ebbbac39a78ac598c71a0baa1203a736d8fbe162ac4d13c09edeca3d500d7b0

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Peentar Pervasive Asia (www.peentar.com)
+Copyright (c) 2013 Sology (www.sology.eu)
+
+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,279 @@
+# SmartListing
+
+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)
+
+Original smart_listing seems no longer maintained. We fork our own version (and hopefully make it better).
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "smart_listing"
+```
+
+Then run:
+
+```sh
+$ 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
+```
+
+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
+
+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.
+
+There's also a possibility to specify available sort directions using `:sort_dirs` option which is by default `[nil, "asc", "desc"]`.
+
+### 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: :show, url: user_path(user)}, {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. `:show`, `: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"
+```
+
+Then, JS view is rendered and your SmartListing updated. That's it!
+
+### Simplified views
+
+You don't need to create all the JS views in case you want to simply use one SmartListing per controller. Just use helper methods without their first attribute (name) ie. `smart_listing_create(User.active, partial: "users/listing")`. Then define two helper methods:
+
+ * `smart_listing_resource` returning single object,
+ * `smart_listing_collection` returning collection of objects.
+
+SmartListing default views will user these methods to render your list properly.
+
+### More customization
+
+Apart from standard SmartListing initializer, you can also define custom config profiles. In order to do this, use following syntax:
+
+```ruby
+SmartListing.configure(:awesome_profile) do |config|
+  # put your definitions here
+end
+```
+
+In order to use this profile, create helper method named `smart_listing_config_profile` returning profile name and put into your JS `SmartListing.config.merge()` function call. `merge()` function expects parameter with config attributes hash or reads body data-attribute named `smart-listing-config`. Hash of config attributes can be obtained by using helper method `SmartListing.config(:awesome_profile).to_json`. 
+
+## Not enough?
+
+For more information and some use cases, see the [Showcase](http://showcase.sology.eu/smart_listing)
+
+## Credits
+
+SmartListing uses great pagination gem Kaminari https://github.com/amatsuda/kaminari
+
+Created by Sology http://www.sology.eu
+
+Initial development sponsored by Smart Language Apps Limited http://smartlanguageapps.com/

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'SmartListing'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/assets/javascripts/smart_listing.coffee.erb

@@ -0,0 +1,438 @@
+# Useful when SmartListing target url is different than current one
+$.rails.href = (element) ->
+  element.attr("href") || element.data("<%= SmartListing.config.data_attributes(:href) %>") || window.location.pathname
+
+class window.SmartListing
+  class Config
+    @options: <%= SmartListing.config.dump_json %>
+
+    @merge: (d) ->
+      $.extend true, @options, d || $("body").data("smart-listing-config")
+
+    @class: (name)->
+      @options["constants"]["classes"][name]
+
+    @class_name: (name) ->
+      ".#{@class(name)}"
+
+    @data_attribute: (name)->
+      @options["constants"]["data_attributes"][name]
+
+    @selector: (name)->
+      @options["constants"]["selectors"][name]
+
+    @element_template: (name)->
+      @options["constants"]["element_templates"][name]
+
+  @config: Config
+
+
+  constructor: (e) ->
+    @container = e
+    @name = @container.attr("id")
+    @loading = @container.find(SmartListing.config.class_name("loading"))
+    @content = @container.find(SmartListing.config.class_name("content"))
+    @status = $("#{SmartListing.config.class_name("status")} [data-#{SmartListing.config.data_attribute("main")}='#{@name}']")
+    @confirmed = null
+    @popovers = {}
+
+    @container.on "ajax:before", "#{SmartListing.config.class_name("item_actions")}, #{SmartListing.config.class_name("pagination_container")}", (e) =>
+      @fadeLoading()
+
+    @container.on "ajax:success", (e) =>
+      if $(e.target).is("#{SmartListing.config.class_name("item_actions")} #{SmartListing.config.selector("item_action_destroy")}")
+        # handle HEAD OK response for deletion request
+        editable = $(e.target).closest(SmartListing.config.class_name("editable"))
+        if @container.find(SmartListing.config.class_name("editable")).length == 1
+          @reload()
+          return false
+        else
+          editable.remove()
+
+          @container.trigger("smart_listing:destroy", editable)
+
+        @changeItemCount(-1)
+        @refresh()
+
+        @fadeLoaded()
+        return false
+
+    @container.on "click", SmartListing.config.selector("edit_cancel"), (event) =>
+      editable = $(event.currentTarget).closest(SmartListing.config.class_name("editable"))
+      if(editable.length > 0)
+        # Cancel edit
+        @cancelEdit(editable)
+      else
+        # Cancel new record
+        @container.find(SmartListing.config.class_name("new_item_placeholder")).addClass(SmartListing.config.class("hidden"))
+        @container.find(SmartListing.config.class_name("new_item_action")).removeClass(SmartListing.config.class("hidden"))
+
+      @setAutoshow(false)
+      false
+
+    @container.on "click", "#{SmartListing.config.class_name("item_actions")} a[data-#{SmartListing.config.data_attribute("confirmation")}]", (event) =>
+      $.fn.smart_listing.confirm $(event.currentTarget), $(event.currentTarget).data(SmartListing.config.data_attribute("confirmation"))
+
+    @container.on "click", "#{SmartListing.config.class_name("item_actions")} a[data-#{SmartListing.config.data_attribute("popover")}]", (event) =>
+      name = $(event.currentTarget).data(SmartListing.config.data_attribute("popover"))
+      if jQuery.isFunction(@popovers[name])
+        @popovers[name]($(event.currentTarget))
+        false
+
+
+    @container.on "click", "input[type=text]#{SmartListing.config.class_name("autoselect")}", (event) ->
+      $(this).select()
+
+    @container.on "change", SmartListing.config.class_name("callback"), (event) =>
+      checkbox = $(event.currentTarget)
+      id = checkbox.closest(SmartListing.config.selector("row")).data(SmartListing.config.data_attribute("id"))
+      data = {}
+      data[checkbox.val()] = checkbox.is(":checked")
+      $.ajax({
+        beforeSend: (xhr, settings) ->
+          xhr.setRequestHeader "accept", "*/*;q=0.5, " + settings.accepts.script
+        url: @container.data(SmartListing.config.data_attribute("callback_href")),
+        type: "POST",
+        data: data,
+      })
+
+  fadeLoading: =>
+    $.fn.smart_listing.onLoading(@content, @loading)
+
+  fadeLoaded: =>
+    $.fn.smart_listing.onLoaded(@content, @loading)
+  
+  itemCount: =>
+    parseInt(@container.data(SmartListing.config.data_attribute("item_count")))
+
+  maxCount: =>
+    parseInt(@container.data(SmartListing.config.data_attribute("max_count")))
+
+  setAutoshow: (v) =>
+
+    @container.data(SmartListing.config.data_attribute("autoshow"), v)
+
+  changeItemCount: (value) =>
+    count = @container.data(SmartListing.config.data_attribute("item_count")) + value
+    @container.data(SmartListing.config.data_attribute("item_count"), count)
+    @container.find(SmartListing.config.selector("pagination_count")).html(count)
+
+  cancelEdit: (editable) =>
+    if editable.data(SmartListing.config.data_attribute("inline_edit_backup"))
+      editable.html(editable.data(SmartListing.config.data_attribute("inline_edit_backup")))
+      editable.removeClass(SmartListing.config.class("inline_editing"))
+      editable.removeData(SmartListing.config.data_attribute("inline_edit_backup"))
+  
+  # Callback called when record is added/deleted using ajax request
+  refresh: () =>
+    header = @content.find(SmartListing.config.selector("head"))
+    footer = @content.find(SmartListing.config.class_name("pagination_per_page"))
+    no_records = @content.find(SmartListing.config.class_name("no_records"))
+
+    if @itemCount() == 0
+      header.hide()
+      footer.hide()
+      no_records.show()
+    else
+      header.show()
+      footer.show()
+      no_records.hide()
+
+    if @maxCount()
+      if @itemCount() >= @maxCount()
+        @container.find(SmartListing.config.class_name("new_item_placeholder")).addClass(SmartListing.config.class("hidden"))
+        @container.find(SmartListing.config.class_name("new_item_action")).addClass(SmartListing.config.class("hidden"))
+      else
+        if @container.data(SmartListing.config.data_attribute("autoshow"))
+          @container.find(SmartListing.config.class_name("new_item_placeholder")).removeClass(SmartListing.config.class("hidden"))
+          @container.find(SmartListing.config.class_name("new_item_action")).addClass(SmartListing.config.class("hidden"))
+        else
+          @container.find(SmartListing.config.class_name("new_item_placeholder")).addClass(SmartListing.config.class("hidden"))
+          @container.find(SmartListing.config.class_name("new_item_action")).removeClass(SmartListing.config.class("hidden"))
+
+    @status.each (index, status) =>
+      $(status).find(SmartListing.config.class_name("limit")).html(@maxCount() - @itemCount())
+      if @maxCount() - @itemCount() == 0
+        $(status).find(SmartListing.config.class_name("limit_alert")).show()
+      else
+        $(status).find(SmartListing.config.class_name("limit_alert")).hide()
+  
+  # Trigger AJAX request to reload the list
+  reload: () =>
+    $.rails.handleRemote(@container)
+  
+  params: (value) =>
+    if value
+      @container.data(SmartListing.config.data_attribute("params"), value)
+    else
+      @container.data(SmartListing.config.data_attribute("params"))
+
+  registerPopover: (name, callback) =>
+    @popovers[name] = callback
+
+  editable: (id) =>
+    @container.find("#{SmartListing.config.class_name("editable")}[data-#{SmartListing.config.data_attribute("id")}=#{id}]")
+
+  #################################################################################################
+  # Methods executed by rails UJS:
+
+  new_item: (content) =>
+    if !@maxCount() || (@itemCount() < @maxCount())
+      new_item_action = @container.find(SmartListing.config.class_name("new_item_action"))
+      new_item_placeholder = @container.find(SmartListing.config.class_name("new_item_placeholder")).addClass(SmartListing.config.class("hidden"))
+
+      @container.find(SmartListing.config.class_name("editable")).each (i, v) =>
+        @cancelEdit($(v))
+
+      new_item_action.addClass(SmartListing.config.class("hidden"))
+      new_item_placeholder.removeClass(SmartListing.config.class("hidden"))
+      new_item_placeholder.html(content)
+      new_item_placeholder.addClass(SmartListing.config.class("inline_editing"))
+
+      @container.trigger("smart_listing:new", new_item_placeholder)
+
+      @fadeLoaded()
+
+  create: (id, success, content) =>
+    new_item_action = @container.find(SmartListing.config.class_name("new_item_action"))
+    new_item_placeholder = @container.find(SmartListing.config.class_name("new_item_placeholder"))
+
+    if success
+      new_item_placeholder.addClass(SmartListing.config.class("hidden"))
+      new_item_action.removeClass(SmartListing.config.class("hidden"))
+
+      new_item = $(SmartListing.config.element_template("row")).addClass(SmartListing.config.class("editable"))
+      new_item.attr("data-#{SmartListing.config.data_attribute("id")}", id)
+      new_item.html(content)
+
+      if new_item_placeholder.length != 0
+        if new_item_placeholder.data("insert-mode") == "after"
+          new_item_placeholder.after(new_item)
+        else
+          new_item_placeholder.before(new_item)
+      else
+        @content.append(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) =>
+    @container.find(SmartListing.config.class_name("editable")).each (i, v) =>
+      @cancelEdit($(v))
+    @container.find(SmartListing.config.class_name("new_item_placeholder")).addClass(SmartListing.config.class("hidden"))
+    @container.find(SmartListing.config.class_name("new_item_action")).removeClass(SmartListing.config.class("hidden"))
+
+    editable = @editable(id)
+    editable.data(SmartListing.config.data_attribute("inline_edit_backup"), editable.html())
+    editable.html(content)
+    editable.addClass(SmartListing.config.class("inline_editing"))
+
+    @container.trigger("smart_listing:edit", editable)
+
+    @fadeLoaded()
+
+  update: (id, success, content) =>
+    editable = @editable(id)
+    if success
+      editable.removeClass(SmartListing.config.class("inline_editing"))
+      editable.removeData(SmartListing.config.data_attribute("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) =>
+    # No need to do anything here, already handled by ajax:success handler
+
+  remove: (id) =>
+    editable = @editable(id)
+    editable.remove()
+
+    @container.trigger("smart_listing:remove", editable)
+  
+  update_list: (content, data) =>
+    @container.data(SmartListing.config.data_attribute("params"), $.extend(@container.data(SmartListing.config.data_attribute("params")), data[SmartListing.config.data_attribute("params")]))
+    @container.data(SmartListing.config.data_attribute("max_count"), data[SmartListing.config.data_attribute("max_count")])
+    @container.data(SmartListing.config.data_attribute("item_count"), data[SmartListing.config.data_attribute("item_count")])
+
+    @content.html(content)
+
+    @refresh()
+    @fadeLoaded()
+
+    @container.trigger("smart_listing:update_list", @container)
+
+$.fn.smart_listing = () ->
+  map = $(this).map () ->
+    if !$(this).data(SmartListing.config.data_attribute("main"))
+      $(this).data(SmartListing.config.data_attribute("main"), new SmartListing($(this)))
+    $(this).data(SmartListing.config.data_attribute("main"))
+  if map.length == 1
+    map[0]
+  else
+    map
+
+$.fn.smart_listing.observeField = (field, opts = {}) ->
+   key_timeout = null
+   last_value = null
+   options =
+     onFilled: () ->
+     onEmpty: () ->
+     onChange: () ->
+   options = $.extend(options, opts)
+ 
+   keyChange = () ->
+     if field.val().length > 0
+       options.onFilled()
+     else
+       options.onEmpty()
+
+     if field.val() == last_value && field.val().length != 0
+       return
+     lastValue = field.val()
+ 
+     options.onChange()
+ 
+   field.data(SmartListing.config.data_attribute("observed"), true)
+ 
+   field.bind "keydown", (e) ->
+     if(key_timeout)
+       clearTimeout(key_timeout)
+ 
+     key_timeout = setTimeout(->
+       keyChange()
+     , 400)
+
+$.fn.smart_listing.showPopover = (elem, body) ->
+  elem.popover("destroy")
+  elem.popover(content: body, html: true, trigger: "manual", title: null)
+  elem.popover("show")
+
+$.fn.smart_listing.showConfirmation = (confirmation_elem, msg, confirm_callback) ->
+  buildPopover = (confirmation_elem, msg) ->
+    deletion_popover = $("<div/>").addClass("confirmation_box")
+    deletion_popover.append($("<p/>").html(msg))
+    deletion_popover.append($("<p/>")
+      .append($("<button/>").html("Yes").addClass("btn btn-danger ").click (event) =>
+        # set @confirmed element and emulate click on icon
+        editable = $(event.currentTarget).closest(SmartListing.config.class_name("editable"))
+        confirm_callback(confirmation_elem)
+        $(confirmation_elem).click()
+        $(confirmation_elem).popover("destroy")
+      )
+      .append(" ")
+      .append($("<button/>").html("No").addClass("btn btn-small").click (event) =>
+        editable = $(event.currentTarget).closest(SmartListing.config.class_name("editable"))
+        $(confirmation_elem).popover("destroy")
+      )
+    )
+
+  $.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()
+  loader.stop(true).fadeTo(500, 1)
+
+$.fn.smart_listing.onLoaded = (content, loader) ->
+  content.stop(true).fadeTo(500, 1)
+  loader.stop(true).fadeTo 500, 0, () =>
+    loader.hide()
+
+$.fn.smart_listing_controls = () ->
+  reload = (controls) ->
+    container = $("##{controls.data(SmartListing.config.data_attribute("main"))}")
+    smart_listing = container.smart_listing()
+
+    # serialize form and merge it with smart listing params
+    prms = {}
+    $.each controls.serializeArray(), (i, field) ->
+      if Array.isArray(prms[field.name])
+        prms[field.name].push field.value
+      else if prms[field.name]
+        prms[field.name] = [prms[field.name], field.value]
+      else
+        prms[field.name] = field.value
+    prms = $.extend(smart_listing.params(), prms)
+    smart_listing.params(prms)
+
+    smart_listing.fadeLoading()
+    smart_listing.reload()
+
+  $(this).each () ->
+    # avoid double initialization
+    return if $(this).data(SmartListing.config.data_attribute("controls_initialized"))
+    $(this).data(SmartListing.config.data_attribute("controls_initialized"), true)
+
+    controls = $(this)
+    smart_listing = $("##{controls.data(SmartListing.config.data_attribute("main"))}")
+    reset = controls.find(SmartListing.config.class_name("controls_reset"))
+
+    controls.submit ->
+      # setup smart listing params, reload and don"t actually submit controls form
+      reload(controls)
+      false
+
+    controls.find("input, select").change () ->
+      unless $(this).data(SmartListing.config.data_attribute("observed")) # do not submit controls form when changed field is observed (observing submits form by itself)
+        reload(controls)
+
+    $.fn.smart_listing_controls.filter(controls.find(SmartListing.config.class_name("filtering")))
+
+$.fn.smart_listing_controls.filter = (filter) ->
+  form = filter.closest("form")
+  button = form.find(SmartListing.config.selector("filtering_button"))
+  icon = form.find(SmartListing.config.selector("filtering_icon"))
+  field = form.find(SmartListing.config.selector("filtering_input"))
+
+  $.fn.smart_listing.observeField(field,
+    onFilled: ->
+      icon.removeClass(SmartListing.config.class("filtering_search"))
+      icon.addClass(SmartListing.config.class("filtering_cancel"))
+      button.removeClass(SmartListing.config.class("filtering_disabled"))
+    onEmpty: ->
+      icon.addClass(SmartListing.config.class("filtering_search"))
+      icon.removeClass(SmartListing.config.class("filtering_cancel"))
+      button.addClass(SmartListing.config.class("filtering_disabled"))
+    onChange: ->
+      form.submit()
+  )
+
+  button.click ->
+    if field.val().length > 0
+      field.val("")
+      field.trigger("keydown")
+    return false
+
+ready = ->
+  $(SmartListing.config.class_name("main")).smart_listing()
+  $(SmartListing.config.class_name("controls")).smart_listing_controls()
+
+$(document).ready ready
+$(document).on "page:load", ready