smart_listing 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ce2c7ca9fc4d41156fec07c92a1c9cca87c31d49
+  data.tar.gz: 77aa5bdd86f016a2252c0e42c2fd2fc68e981b28
+SHA512:
+  metadata.gz: 6383baf287499b38bf6c4216c52883ce29b223d4168f57f700f2e89d1cb11936232d13e6c0895622d8cb86fd3e64b5b839255097c810afdaf2b0d2bd04832adf
+  data.tar.gz: cfc2fd5a53332a3546e26f70b2f72943392989e7828bf2a5b4843a28639b42b0789d21d1ddd923e4a9028c7ad4e07f0b36e8beeb16cbcdf8d5fe2d35a642d05d

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Sology
+
+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,4 @@
+smart_listing
+==========
+
+Smart listing utility gem

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("../test/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/application.js

@@ -0,0 +1,14 @@
+// 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/javascripts/smart_listing/smart_listing.coffee

@@ -0,0 +1,317 @@
+# Useful when smart list target url is different than current one
+$.rails.href = (element) ->
+	element.attr('href') || element.data('href')
+
+$.fn.observeField = (opts = {}) ->
+   field = $(this)
+   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('observed', true)
+ 
+   field.bind 'keydown', (e) ->
+     if(key_timeout)
+       clearTimeout(key_timeout)
+ 
+     key_timeout = setTimeout(->
+       keyChange()
+     , 400)
+
+class SmartListing
+	constructor: (e) ->
+		@container = e
+		@name = @container.attr('id')
+		@loading = @container.find('.loading')
+		@content = @container.find('.content')
+		@status = $(".smart_listing_status[data-smart-list='#{@name}']")
+		@confirmed = null
+
+		createPopover = (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('.editable')
+					@confirmed = confirmation_elem
+					$(confirmation_elem).click()
+					$(confirmation_elem).popover('destroy')
+				)
+				.append($('<button/>').html('No').addClass('btn btn-small').click (event) =>
+					editable = $(event.currentTarget).closest('.editable')
+					$(confirmation_elem).popover('destroy')
+				)
+			)
+
+		@container.on 'ajax:before', () =>
+			@fadeLoading()
+
+		@container.on 'ajax:success', (e) =>
+			if $(e.target).is('.actions a.destroy')
+				# handle HEAD OK response for deletion request
+				editable = $(e.target).closest('.editable')
+				if @container.find(".editable").length == 1
+					@reload()
+					return false
+				else
+					editable.remove()
+
+				@changeItemCount(-1)
+				@refresh()
+
+				@fadeLoaded()
+				return false
+
+		@container.on 'click', 'button.cancel', (event) =>
+			editable = $(event.currentTarget).closest('.editable')
+			if(editable.length > 0)
+				# Cancel edit
+				@cancelEdit(editable)
+			else
+				# Cancel new record
+				@container.find('.new_item_placeholder').addClass('disabled')
+				@container.find('.new_item_action').removeClass('disabled')
+			false
+
+		@container.on 'click', '.actions a[data-confirmation]', (event) =>
+			# Check if we are confirming the right element
+			if(@confirmed != event.currentTarget)
+				# We need confirmation
+				@container.find('.actions a').popover('destroy')
+				$(event.currentTarget).popover(content: createPopover(event.currentTarget, $(event.currentTarget).data('confirmation')), html: true, trigger: 'manual')
+				$(event.currentTarget).popover('show')
+				false
+			else
+				# Confirmed, reset flag and go ahead with deletion
+				@confirmed = null
+				true
+
+		@container.on 'click', 'input[type=text].autoselect', (event) ->
+			$(this).select()
+
+	fadeLoading: =>
+		@content.stop(true).fadeTo(500, 0.2)
+		@loading.show()
+		@loading.stop(true).fadeTo(500, 1)
+
+	fadeLoaded: =>
+		@content.stop(true).fadeTo(500, 1)
+		@loading.stop(true).fadeTo 500, 0, () =>
+			@loading.hide()
+
+		@content.find('.play').each () ->
+			self.loadAudio($(this).data('key'), $(this).data('target'))
+	
+	itemCount: =>
+		parseInt(@container.find('.pagination_per_page .count').html())
+
+	maxCount: =>
+		parseInt(@container.data('max-count'))
+
+	changeItemCount: (value) =>
+		@container.find('.pagination_per_page .count').html(@itemCount() + value)
+
+	cancelEdit: (editable) =>
+		if editable.data('smart_listing_edit_backup')
+			editable.html(editable.data('smart_listing_edit_backup'))
+			editable.removeClass('info')
+			editable.removeData('smart_listing_edit_backup')
+	
+	# Callback called when record is added/deleted using ajax request
+	refresh: () =>
+		header = @content.find('thead')
+		footer = @content.find('.pagination_per_page')
+		no_records = @content.find('.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()
+				if @itemCount()
+					@container.find('.new_item_action').addClass('disabled')
+				@container.find('.new_item_action .btn').addClass('disabled')
+			else
+				@container.find('.new_item_action').removeClass('disabled')
+				@container.find('.new_item_action .btn').removeClass('disabled')
+
+		@status.each (index, status) =>
+			$(status).find('.smart_listing_limit').html(@maxCount() - @itemCount())
+			if @maxCount() - @itemCount() == 0
+				$(status).find('.smart_listing_limit_alert').show()
+			else
+				$(status).find('.smart_listing_limit_alert').hide()
+	
+	# Trigger AJAX request to reload the list
+	reload: () =>
+		$.rails.handleRemote(@container)
+	
+	params: () =>
+		@container.data('params')
+	
+  #################################################################################################
+	# Methods executed by rails UJS:
+
+	new_item: (content) =>
+		new_item_action = @container.find('.new_item_action')
+		new_item_placeholder = @container.find('.new_item_placeholder').addClass('disabled')
+
+		@container.find('.editable').each (i, v) =>
+			@cancelEdit($(v))
+
+		new_item_action.addClass('disabled')
+		new_item_placeholder.removeClass('disabled')
+		new_item_placeholder.html(content)
+		new_item_placeholder.addClass('info')
+
+		@fadeLoaded()
+
+	create: (id, success, content) =>
+		new_item_action = @container.find('.new_item_action')
+		new_item_placeholder = @container.find('.new_item_placeholder')
+
+		if success
+			new_item_placeholder.addClass('disabled')
+			new_item_action.removeClass('disabled')
+
+			new_item = $('<tr />').addClass('editable')
+			new_item.attr('data-id', id)
+			new_item.html(content)
+			new_item_placeholder.before(new_item)
+
+			@changeItemCount(1)
+			@refresh()
+		else
+			new_item_placeholder.html(content)
+
+		@fadeLoaded()
+
+	edit: (id, content) =>
+		@container.find('.editable').each (i, v) =>
+			@cancelEdit($(v))
+		@container.find('.new_item_placeholder').addClass('disabled')
+		@container.find('.new_item_action').removeClass('disabled')
+
+		editable = @container.find(".editable[data-id=#{id}]")
+		editable.data('smart_listing_edit_backup', editable.html())
+		editable.html(content)
+		editable.addClass('info')
+
+		@fadeLoaded()
+
+	update: (id, success, content) =>
+		editable = @container.find(".editable[data-id=#{id}]")
+		if success
+			editable.removeClass('info')
+			editable.removeData('smart_listing_edit_backup')
+			editable.html(content)
+
+			@refresh()
+		else
+			editable.html(content)
+
+		@fadeLoaded()
+	
+	destroy: (id, destroyed) =>
+		# No need to do anything here, already handled by ajax:success handler
+	
+	update_list: (content, data) =>
+		$.each data, (key, value) =>
+			@container.data(key, value)
+
+		@content.html(content)
+
+		@refresh()
+		@fadeLoaded()
+
+$.fn.smart_listing = () ->
+	map = $(this).map () ->
+		if !$(this).data('smart-list')
+			$(this).data('smart-list', new SmartListing($(this)))
+		$(this).data('smart-list')
+	if map.length == 1
+		map[0]
+	else
+		map
+
+$.fn.handleSmartListingControls = () ->
+	$(this).each () ->
+		controls = $(this)
+		smart_listing = $("##{controls.data('smart-list')}")
+
+		controls.submit ->
+			# Merges smart list params with the form action url before submitting.
+			# This preserves smart list settings (page, sorting etc.).
+
+			prms = $.extend({}, smart_listing.smart_listing().params())
+			if $(this).data('reset')
+				prms[$(this).data('reset')] = null
+
+			if $.rails.href(smart_listing)
+				# If smart list has different target url than current one
+				controls.attr('action', $.rails.href(smart_listing) + "?" + jQuery.param(prms))
+			else
+				controls.attr('action', "?" + jQuery.param(prms))
+
+			smart_listing.trigger('ajax:before')
+			true
+
+		controls.find('input, select').change () ->
+			unless $(this).data('observed') # do not submit controls form when changed field is observed (observing submits form by itself)
+				controls.submit()
+
+$.fn.handleSmartListingFilter = () ->
+	filter = $(this)
+	form = filter.closest('form')
+	button = filter.find('button')
+	icon = filter.find('i')
+	field = filter.find('input')
+
+	field.observeField(
+		onFilled: ->
+			console.log('onfilled')
+			icon.removeClass('icon-search')
+			icon.addClass('icon-remove')
+			button.removeClass('disabled')
+		onEmpty: ->
+			console.log('onempty')
+			icon.addClass('icon-search')
+			icon.removeClass('icon-remove')
+			button.addClass('disabled')
+		onChange: ->
+			console.log('onchange')
+			form.submit()
+	)
+
+	button.click ->
+		if field.val().length > 0
+			field.val('')
+			field.trigger('keydown')
+
+$ ->
+	$('.smart_listing').smart_listing()
+	$('.smart_listing_controls').handleSmartListingControls()
+	$('.smart_listing_controls .filter').handleSmartListingFilter()

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

@@ -0,0 +1,13 @@
+/*
+ * 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/helpers/smart_listing/application_helper.rb

@@ -0,0 +1,5 @@
+require 'smart_listing/smart_listing_helper'
+module SmartListing
+	module ApplicationHelper
+	end
+end

data/app/helpers/smart_listing/helper.rb

@@ -0,0 +1,259 @@
+module SmartListing
+	module Helper
+		module ControllerExtensions
+			def smart_listing_create name, collection, options = {}
+				name = name.to_sym
+
+				list = SmartListing::Base.new(name, collection, options)
+				list.setup(params, cookies)
+
+				@smart_listings ||= {}
+				@smart_listings[name] = list
+
+				list.collection
+			end
+
+			def smart_listing name
+				@smart_listings[name.to_sym]
+			end
+		end
+
+		class Builder
+			# Params that should not be visible in pagination links (pages, per-page, sorting, etc.)
+			UNSAFE_PARAMS = {:authenticity_token => nil, :utf8 => nil}
+
+			class_attribute :smart_listing_helpers
+
+			def initialize(smart_listing_name, smart_listing, template, options, proc)
+				@smart_listing_name, @smart_listing, @template, @options, @proc = smart_listing_name, smart_listing, template, options, proc
+			end
+
+			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
+				end
+			end
+
+			def collection
+				@smart_listing.collection
+			end
+
+			def pagination_per_page_links options = {}
+				@template.content_tag(:div, :class => "pagination_per_page #{'disabled' if empty?}") do
+					if @smart_listing.count > SmartListing::Base::PAGE_SIZES.first
+						@template.concat(@template.t('views.pagination.per_page'))
+						per_page_sizes = SmartListing::Base::PAGE_SIZES.clone
+						per_page_sizes.push(0) if @smart_listing.unlimited_per_page?
+						per_page_sizes.each do |p|
+							name = p == 0 ? @template.t('views.pagination.unlimited') : p
+							if @smart_listing.per_page.to_i != p
+								@template.concat(@template.link_to(name, sanitize_params(@template.params.merge(@smart_listing.param_names[:per_page] => p, @smart_listing.param_names[:page] => 1)), :remote => true))
+							else 
+								@template.concat(@template.content_tag(:span, name))
+							end
+							break if p > @smart_listing.count
+						end
+						@template.concat ' | '
+					end if @smart_listing.options[:paginate]
+					@template.concat(@template.t('views.pagination.total'))
+					@template.concat(@template.content_tag(:span, @smart_listing.count, :class => "count"))
+				end
+			end
+
+			def sortable title, attribute, options = {}
+				extra = options.delete(:extra)
+
+				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
+				}
+
+				@template.link_to(sanitize_params(@template.params.merge(sort_params)), :class => "sortable", :data => {:attr => attribute}, :remote => true) do
+					@template.concat(title)
+					if @smart_listing.sort_attr == attribute && (!@smart_listing.sort_extra || @smart_listing.sort_extra == extra.to_s)
+						@template.concat(@template.content_tag(:span, "", :class => (@smart_listing.sort_order == "asc" ? "glyphicon glyphicon-chevron-up" : "glyphicon glyphicon-chevron-down"))) 
+					else
+						@template.concat(@template.content_tag(:span, "", :class => "glyphicon glyphicon-resize-vertical"))
+					end
+				end
+			end
+
+			def update options = {}
+				part = options.delete(:partial) || @smart_listing.partial || @smart_listing_name
+
+				@template.render(:partial => 'smart_listing/update_list', :locals => {:name => @smart_listing_name, :part => part, :smart_listing => self})
+			end
+
+			# Renders the main partial (whole list)
+			def render_list
+				if @smart_listing.partial
+					@template.render :partial => @smart_listing.partial, :locals => {:smart_listing => self}
+				end
+			end
+
+			# Basic render block wrapper that adds smart_listing reference to local variables
+			def render options = {}, locals = {}, &block
+				if locals.empty?
+					options[:locals] ||= {}
+					options[:locals].merge!(:smart_listing => self)
+				else
+					locals.merge!({:smart_listing => self})
+				end
+				@template.render options, locals, &block
+			end
+
+			# Add new item button & placeholder to list
+			def item_new options = {}
+				@template.concat(@template.content_tag(:tr, '', :class => "info new_item_placeholder disabled"))
+				@template.concat(@template.content_tag(:tr, :class => "info new_item_action #{'disabled' if !empty? && max_count?}") do
+					@template.concat(@template.content_tag(:td, :colspan => options.delete(:colspan)) do
+						@template.concat(@template.content_tag(:p, :class => "no_records pull-left #{'disabled' unless empty?}") do
+							@template.concat(options.delete(:no_items_text))
+						end)
+						@template.concat(@template.link_to(options.delete(:link), :remote => true, :class => "btn pull-right #{'disabled' if max_count?}") do
+							@template.concat(@template.content_tag(:i, '', :class => "glyphicon glyphicon-plus"))
+							@template.concat(" ")
+							@template.concat(options.delete(:text))
+						end)
+					end)
+				end)
+				nil
+			end
+
+			# Check if smart list is empty
+			def empty?
+				@smart_listing.count == 0
+			end
+
+			# Check if smart list reached its item max count
+			def max_count?
+				return false if @smart_listing.max_count.nil?
+				@smart_listing.count >= @smart_listing.max_count
+			end
+
+			private
+
+			def sanitize_params params
+				params.merge(UNSAFE_PARAMS)
+			end
+		end
+
+		# Outputs smart list container
+		def smart_listing_for name, *args, &block
+			raise ArgumentError, "Missing block" unless block_given?
+			name = name.to_sym
+			options = args.extract_options!
+			bare = options.delete(:bare)
+
+			builder = Builder.new(name, @smart_listings[name], self, options, block)
+
+			output =""
+
+			data = {}
+			data['max-count'] = @smart_listings[name].max_count if @smart_listings[name].max_count && @smart_listings[name].max_count > 0
+			data['href'] = @smart_listings[name].href if @smart_listings[name].href
+
+			if bare
+				output = capture(builder, &block)
+			else
+				output = content_tag(:div, :class => "smart_listing", :id => name, :data => data) do
+					concat(content_tag(:div, "", :class => "loading"))
+					concat(content_tag(:div, :class => "content") do
+						concat(capture(builder, &block))
+					end)
+				end
+			end
+
+			output
+		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(content_tag(:i, '', :class => "glyphicon glyphicon-remove-circle"))
+							next
+						end
+					end
+
+					case action.delete(:name).to_sym
+					when :edit
+						url = action.delete(:url)
+						html_options = {
+							:remote => true, 
+							:class => "edit",
+							:title => t("smart_listing.actions.edit")
+						}.merge(action)
+
+						concat(link_to(url, html_options) do
+							concat(content_tag(:i, '', :class => "glyphicon glyphicon-pencil"))
+						end)
+					when :destroy
+						url = action.delete(:url)
+						icon = action.delete(:icon) || "glyphicon glyphicon-trash"
+						html_options = {
+							:remote => true, 
+							:class => "destroy",
+							:method => :delete,
+							:title => t("smart_listing.actions.destroy"),
+							:data => {:confirmation => action.delete(:confirmation) || t("smart_listing.msgs.destroy_confirmation")},
+						}.merge(action)
+
+						concat(link_to(url, html_options) do
+							concat(content_tag(:i, '', :class => icon))
+						end)
+					when :custom
+						url = action.delete(:url)
+						icon = action.delete(:icon)
+						html_options = action
+
+						concat(link_to(url, html_options) do
+							concat(content_tag(:i, '', :class => icon))
+						end)
+					end
+				end
+			end
+		end
+
+		def smart_listing_limit_left name
+			name = name.to_sym
+			smart_listing = @smart_listings[name]
+
+			smart_listing.max_count - smart_listing.count
+		end
+
+		#################################################################################################
+		# JS helpers:
+
+		# Updates the smart list
+		def smart_listing_update name
+			name = name.to_sym
+			smart_listing = @smart_listings[name]
+			builder = Builder.new(name, smart_listing, self, {}, nil)
+			render(:partial => 'smart_listing/update_list', :locals => {
+				:name => smart_listing.name, 
+				:part => smart_listing.partial, 
+				:smart_listing => builder, 
+				:smart_listing_data => {
+					:params => smart_listing.all_params,
+					'max-count' => smart_listing.max_count,
+				}
+			})
+		end
+
+		# Renders single item (i.e for create, update actions)
+		def smart_listing_item name, item_action, object = nil, partial = nil, options = {}
+			name = name.to_sym
+			type = object.class.name.downcase.to_sym if object
+			id = object.id if object
+			object_key = options.delete(:object_key) || :object
+
+			render(:partial => "smart_listing/item/#{item_action.to_s}", :locals => {:name => name, :id => id, :object_key => object_key, :object => object, :part => partial})
+		end
+	end
+end

data/config/routes.rb

@@ -0,0 +1,2 @@
+SmartListing::Engine.routes.draw do
+end

data/lib/smart_listing/engine.rb

@@ -0,0 +1,5 @@
+module SmartListing
+  class Engine < ::Rails::Engine
+    isolate_namespace SmartListing
+  end
+end

data/lib/smart_listing/version.rb

@@ -0,0 +1,3 @@
+module SmartListing
+  VERSION = "0.9.0"
+end

data/lib/smart_listing.rb

@@ -0,0 +1,116 @@
+require "smart_listing/engine"
+require "kaminari"
+module SmartListing
+	class Base
+		if Rails.env.development?
+			PAGE_SIZES = [3, 10, 20, 50, 100]
+		else
+			PAGE_SIZES = [10, 20, 50, 100]
+		end
+
+		attr_reader :name, :collection, :options, :per_page, :page, :sort_attr, :sort_order, :sort_extra, :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)
+				:default_sort_attr  => nil,         # default sort by
+				:memorize_per_page  => false,
+			}.merge!(options)
+
+			if @options[:array]
+				@collection = collection.to_a
+			else 
+				@collection = collection
+			end
+		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
+			@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]]
+
+			cookies[param_names[:per_page]] = @per_page if @options[:memorize_per_page]
+
+			@count = @collection.size
+
+			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)
+						end
+					end
+				end if @options[:sort] && @sort_attr && !@sort_attr.empty?
+				if @options[:paginate] && @per_page > 0
+					@collection = ::Kaminari.paginate_array(@collection).page(@page).per(@per_page)
+					if @collection.length == 0
+						@collection = @collection.page(@collection.num_pages)
+					end
+				end
+			else
+				@collection = @collection.order("#{@sort_attr} #{@sort_order}") if @options[:sort] && @sort_attr && !@sort_attr.empty? && @sort_order
+				if @options[:paginate] && @per_page > 0
+					@collection = @collection.page(@page).per(@per_page)
+				end
+			end
+		end
+
+		def partial
+			@options[:partial]
+		end
+
+		def param_names
+			@options[:param_names]
+		end
+
+		def unlimited_per_page?
+			!!@options[:unlimited_per_page]
+		end
+
+		def max_count
+			@options[:max_count]
+		end
+
+		def href
+			@options[:href]
+		end
+
+		def all_params
+			ap = {}
+			@options[:param_names].each do |k, v|
+				ap[v] = self.send(k)
+			end
+			ap
+		end
+	end
+end

data/lib/tasks/smart_list_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :smart_list do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: smart_listing
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Sology
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: coffee-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: kaminari
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Description of SmartList.
+email:
+- contact@sology.eu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- app/assets/stylesheets/smart_listing/application.css
+- app/assets/javascripts/smart_listing/smart_listing.coffee
+- app/assets/javascripts/smart_listing/application.js
+- app/helpers/smart_listing/application_helper.rb
+- app/helpers/smart_listing/helper.rb
+- config/routes.rb
+- lib/tasks/smart_list_tasks.rake
+- lib/smart_listing/engine.rb
+- lib/smart_listing/version.rb
+- lib/smart_listing.rb
+- LICENSE
+- Rakefile
+- README.md
+homepage: http://www.sology.eu
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.10
+signing_key: 
+specification_version: 4
+summary: Summary of SmartList.
+test_files: []