alphabetical_paginate_uk 0.1 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d5788477e3ec4838f47c0b7788650b193851955
-  data.tar.gz: d95d3dcf8427f509e4d451ce2e2b2678d9054b2b
+  metadata.gz: 4db868fdca4359e328dea8fad7a6218303c03d86
+  data.tar.gz: 64a40e3785b8e1f78a08b1f0471cf2073e4bc1f8
 SHA512:
-  metadata.gz: 1ad8cd2e1314d0bfcee339cf1e2a5c2bbd979c97becfca2f9043537b699eb2cbb4f882c29ba53df30de0793f734f94a0557f159c822932d217390b808f447d4d
-  data.tar.gz: 6b27c55bc02b2b782267f88cba7bc5952628d6832ff24542a3c2cce2f51fcb0a624ad62598d7edca317100f1e00022f3c8483f318191f713b3833fc1b8abc215
+  metadata.gz: 3660eba7b61822344e4ea2c144cccc2720e38869baf900a9ca27189ea106f30ad43fdf41ce461916bccccf83799a92c67d04a0a3ad26f8cf209b8840d5693a34
+  data.tar.gz: f9e61cfb50fd0f327c9372ae2e8680680dab4500503fb9b1d107deac0464945777b95afec77c6c3cdc84b3e4bb9e82ca4689aff74305626190161023397ecb35

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.swp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in alphabetical_paginate.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 lingz
+
+MIT License
+
+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,174 @@
+# AlphabeticalPaginate
+
+A lightweight and highly customizable pagination gem for Ruby on Rails that generates alphabetic pagination categories from Collections or Arrays. It allows you to select the field you want to paginate on. 
+
+By default, it works with [Bootstrap Pagination](http://twitter.github.io/bootstrap/components.html#pagination) CSS and it is also fully compatible with the [will_paginate](https://github.com/mislav/will_paginate) in case you want to use both. 
+
+AlphabeticalPaginate incorporates efficient javascript partial page rerendering techniques and loading animations but also is non-obtrusive and falls back to standard href links.
+
+It has two modes - if you're working with MySQL, it allows for low level database regex queries. Otherwise, it uses a buffered search to build an array. You should be able to easily modify the gem to work with other SQL databases (please make a pull-request if you do!).
+
+We also now have Russian language support and Bootstrap 3 support.
+
+Some code was inspired by [will_paginate](https://github.com/mislav/will_paginate).
+
+
+## Installation
+
+Add this line to your application's Gemfile:  
+```
+    gem 'alphabetical_paginate'
+```
+
+And then execute:  
+```bash
+    $ bundle install
+```
+
+In case you're using the Rails 3.x assets pipeline remember to add it to your `production.rb` script:
+
+```rb
+  config.assets.precompile += %w( alphabetical_paginate.js )
+```
+
+## Basic Setup
+
+Basic Pagination is as simple as adding a few lines to the controller and the view.
+
+### Controller
+You simply need to call alpha_paginate on the desired Active Record Collection (i.e. `User.alpha_paginate`) or on any array (`User.all.alpha_paginate`). This method takes two parameters, the first always being `params[:letter]` and the second being an optional options hash. 
+
+Also, it takes a block in which you can specify the field you wish to paginate by (it can even be in another table). It returns the paginated subset of the collection, sorted by the pagination field. The method returns two values (the paginated array subsection, and an options hash), both of which must be stored as class variables. 
+
+It has a :db_mode parameter which tells the gem to perform low level SQL queries, which are both faster, and take up less memory. This is only supported for MySQL databases at this point.
+
+*An example of its use is as such:*
+#### If you are using MySQL / MySQL2
+```ruby
+#app/controllers/users_controllers.rb
+class UsersController < ApplicationController
+
+  def index
+    @users, @alphaParams = User.alpha_paginate(params[:letter], {db_mode: true, db_field: "name"})
+  end
+  
+  ...
+end
+```
+
+#### If you are not using MySQL
+```ruby
+#app/controllers/users_controllers.rb
+class UsersController < ApplicationController
+
+  def index
+    @users, @alphaParams = User.all.alpha_paginate(params[:letter]){|user| user.name}
+  end
+  
+  ...
+end
+```
+
+### View
+You need to call `alphabetical_paginate` that we just generated in the controller (i.e `<%= alphabetical_paginate @alphaParams %>`) in the view, whereever you would like to render the pagination selector div. You also **must wrap the content you want paginated in a div with id="pagination_table"**.
+
+You can place as many `<%= alphabetical_paginate @alphaParams %>` as you wish on the page, if you want to render multiple pagination divs.
+
+*An example is as such:*
+```html
+#app/controllers/users/index.html.erb
+
+<%= alphabetical_paginate @alphaParams %>
+
+<div id="pagination_table">
+  <% User.all.each do |user| %>
+    ...
+  <% end %>
+</div>
+```
+
+## Customization
+
+### Options
+The gem is highly customizable. The `alpha_paginate ` method takes a hash as an optional second parameter like such:
+
+```ruby
+#app/controllers/users_controllers.rb
+class UsersController < ApplicationController
+
+  def index
+    @users, @alphaParams = User.all.alpha_paginate(params[:letter], {:enumerate => false}){|user| user.name}
+  end
+  
+  ...
+end
+```
+
+The available options are as follows:
+
+Key | Value | Default |Description
+--- | --- | --- | ---
+`:db_mode` | `Boolean` | `false` | Whether to activate low level SQL that are faster and more memory efficient
+`:db_field` | `String` | `id` | Required if `db_mode` is `true`. The field to paginate / sort by (on the same collection).
+`:enumerate` | `Boolean` | `false` | Whether you want the number field collapsed (all numbers go into `0`) or separate (`0`, `1`, `2`...).
+`:default_field` | `String` | `"a"` | Which field you want the page to default to on first load (`"0"`, `"a"`. `"*"`).
+`:paginate_all` | `Boolean` | `false` | Whether you want empty fields to still render in pagination. If it's falsy and `db_mode` is thruty is will perform one more aggregation query: set it to true if performances matter.
+`:include_all` | `Boolean` | `true` | Whether you want `all` selector to be included in the pagination.
+`:numbers` | `Boolean` | `true` | Whether you want numbers to be included in the pagination at all, either collapsed, or expanded (depending on `:enumerate`).
+`:others` | `Boolean` | `true` | Whether you want all other characters (non alphanumeric) to be included in the pagination at all.
+`:pagination_class` | `String` | `"pagination-centered"` | All the classes you would like to add to the rendered pagination selector div (for CSS purposes).
+`:js` | `Boolean` | `"true"` | If you want the javascript with page-rerendering to be enabled.
+`:support_language` | `Symbol` | `:en` | If you want russian letters support set this value to `:ru` (only if `I18n.locale` in your application set to `:ru`).
+`:bootstrap3` | `Boolean` | `false` | If you want to enable bootstrap 3 support
+
+## Advanced Pagination
+
+You can select a complex field to paginate by. Be careful, as this may be slow in large data sets. This only works if db_mode is disabled.
+
+For instance, the following example paginates posts by the author's group's name (jumping across two tables).
+It still returns the Post objects despite whatever field you use to paginate / sort it by (It still auto-sorts by the pagination field).
+```ruby
+#app/controllers/users_controllers.rb
+class UsersController < ApplicationController
+
+  def index
+    @posts, @alphaParams = Post.all.alpha_paginate(params[:letter]) do |post|
+      author = post.author
+      group = author.group
+    end
+  end
+  
+  ...
+end
+```
+
+Also you can paginate by any array generally, it doesn't have to be a collection.
+```ruby
+  @friends, @params = friends.alpha_paginate(params[:letter]){|x| x}
+```
+
+## Rails 3.0 and Lower
+
+The gem makes use of the Asset Pipeline, introduced in Rails 3.1. It still works with lower versions of Rails, however, you need to copy the assets over manually.
+
+Copy the contents of `vendor/assets/javascripts` of this repo into the `public/javascripts` of your app
+and also copy the contents of `vendor/assets/images` of this repo into the `public/images` of your app.
+
+Also, there is one line in vendor/assets/javascripts that needs to be changed for Rails 3.0 support. That is, renaming the image path:
+```javascript
+  var img = "<img src='/assets/aloader.gif' class='loading'/>";
+  // RAILS 3.0 USERS -> Please delete the above line and uncomment the bottom line
+  //var img = "<img src='/images/aloader.gif' class='loading'/>";
+```
+
+# Support
+
+Please feel free to reach out and contact if you find the gem useful at all! Also, feel free to report / fix any bugs or add features.
+
+## To run tests
+
+    rspec
+
+## To publish the gem
+
+    rake release

data/Rakefile

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

data/lib/alphabetical_paginate/array.rb

@@ -0,0 +1,61 @@
+# coding: utf-8
+class Array
+  def alpha_paginate current_field, params = {enumerate:false, default_field: "a", 
+                                              paginate_all: false, numbers: true, include_all: true,
+                                              others: true, pagination_class: "pagination-centered",
+                                              js: true, support_language: :uk, bootstrap3: false,
+                                              slugged_link: false, slug_field: "slug", all_as_link: true}
+    params[:paginate_all] ||= false
+    params[:support_language] ||= :uk
+    params[:language] = AlphabeticalPaginate::Language.new(params[:support_language])
+    params[:include_all] = true if !params.has_key? :include_all
+    params[:numbers] = true if !params.has_key? :numbers
+    params[:others] = true if !params.has_key? :others
+    params[:js] = true if !params.has_key? :js
+    params[:default_field] ||= params[:include_all] ? "all" : params[:language].default_letter
+    params[:pagination_class] ||= "pagination-centered"
+    params[:slugged_link] ||= false
+    params[:slugged_link] = params[:slugged_link] && defined?(Babosa)
+    params[:slug_field] ||= "slug"
+    params[:all_as_link] = true if !params.has_key? :all_as_link
+
+    output = []
+    availableLetters = {}
+
+    current_field ||= params[:default_field]
+    current_field = current_field.mb_chars.downcase.to_s
+    all = params[:include_all] && current_field == "all"
+
+    self.each do |x|
+      slug = eval("x.#{params[:slug_field]}") if params[:slugged_link]
+
+      field_val = block_given? ? yield(x).to_s : x.id.to_s
+      field_letter = field_val[0].mb_chars.downcase.to_s
+
+      case field_letter
+        when params[:language].letters_regexp
+          availableLetters[field_letter] = true if !availableLetters.has_key? field_letter
+          regexp = params[:slugged_link] ? params[:language].slugged_regexp : params[:language].letters_regexp
+          field = params[:slugged_link] ? slug : field_letter
+          output << x if all || (current_field =~ regexp && current_field == field)
+        when /[0-9]/
+          if params[:enumerate]
+            availableLetters[field_letter] = true if !availableLetters.has_key? field_letter
+            output << x if all || (current_field =~ /[0-9]/ && field_letter == current_field)
+          else
+            availableLetters['0-9'] = true if !availableLetters.has_key? 'numbers'
+            output << x if all || current_field == "0-9"
+          end
+        else
+          availableLetters['*'] = true if !availableLetters.has_key? 'other'
+          output << x if all || current_field == "*"
+      end
+    end
+
+    params[:availableLetters] = availableLetters.collect{ |k,v| k.mb_chars.capitalize.to_s }
+    params[:currentField] = current_field.mb_chars.capitalize.to_s
+    output.sort! {|x, y| block_given? ? (yield(x).to_s <=> yield(y).to_s) : (x.id.to_s <=> y.id.to_s) }
+    return output, params
+  end
+end
+

data/lib/alphabetical_paginate/controller_helper.rb

@@ -0,0 +1,145 @@
+module AlphabeticalPaginate
+  module ControllerHelpers
+    def self.included(base)
+      base.extend(self)
+    end
+
+    def alpha_paginate current_field, params = {enumerate:false, default_field: "a",
+                                                paginate_all: false, numbers: true,
+                                                others: true, pagination_class: "pagination-centered",
+                                                batch_size: 500, db_mode: false,
+                                                db_field: "id", include_all: true,
+                                                js: true, support_language: :uk,
+                                                bootstrap3: false, slugged_link: false,
+                                                slug_field: "slug", all_as_link: true}
+      params[:paginate_all] ||= false
+      params[:support_language] ||= :uk
+      params[:language] = AlphabeticalPaginate::Language.new(params[:support_language])
+      params[:include_all] = true if !params.has_key? :include_all
+      params[:numbers] = true if !params.has_key? :numbers
+      params[:others] = true if !params.has_key? :others
+      params[:js] = true if !params.has_key? :js
+      params[:pagination_class] ||= "pagination-centered"
+      params[:batch_size] ||= 500
+      params[:db_mode] ||= false
+      params[:db_field] ||= "id"
+      params[:slugged_link] ||= false
+      params[:slugged_link] = params[:slugged_link] && defined?(Babosa)
+      params[:slug_field] ||= "slug"
+      params[:all_as_link] = true if !params.has_key? :all_as_link
+
+      output = []
+
+      if params[:db_mode]
+        letters = nil
+        if !params[:paginate_all]
+          letters = filter_by_cardinality( find_available_letters(params[:db_field]) )
+          set_default_field letters, params
+        end
+        params[:availableLetters] = letters.nil? ? [] : letters
+      end
+
+      if params[:include_all]
+        current_field ||= 'all'
+        all = current_field == "all"
+      end
+
+      current_field ||= params[:default_field]
+      current_field = current_field.mb_chars.downcase.to_s
+      all = params[:include_all] && current_field == "all"
+
+      if params[:db_mode]
+        if !ActiveRecord::Base.connection.adapter_name.downcase.include? "mysql"
+          raise "You need a mysql database to use db_mode with alphabetical_paginate"
+        end
+
+        if all
+          output = self
+        else
+
+          # In this case we can speed up the search taking advantage of the indices
+          can_go_quicker = (current_field =~ params[:language].letters_regexp) || (current_field =~ /[0-9]/ && params[:enumerate])
+
+
+          # Use LIKE the most as you can to take advantage of indeces on the field when available
+          # REGEXP runs always a full scan of the table!
+          # For more information about LIKE and indeces have a look at
+          # http://myitforum.com/cs2/blogs/jnelson/archive/2007/11/16/108354.aspx
+
+          # Also use some sanitization from ActiveRecord for the current field passed
+          if can_go_quicker
+            output = self.where("LOWER(%s) LIKE ?" % params[:db_field], current_field+'%')
+          else
+            regexp_to_check = current_field =~ /[0-9]/ ? '^[0-9]' : '^[^a-z0-9]'
+            output = self.where("LOWER(%s) REGEXP '%s.*'" % [params[:db_field], regexp_to_check])
+          end
+        end
+      else
+        availableLetters = {}
+        self.find_each({batch_size: params[:batch_size]}) do |x|
+          slug = eval("x.#{params[:slug_field]}") if params[:slugged_link]
+
+          field_val = block_given? ? yield(x).to_s : x.id.to_s
+          field_letter = field_val[0].mb_chars.downcase.to_s
+
+          case field_letter
+            when params[:language].letters_regexp
+              availableLetters[field_letter] = true if !availableLetters.has_key? field_letter
+              regexp = params[:slugged_link] ? params[:language].slugged_regexp : params[:language].letters_regexp
+              field = params[:slugged_link] ? slug : field_letter
+              output << x if all || (current_field =~ regexp && current_field == field)
+            when /[0-9]/
+              if params[:enumerate]
+                availableLetters[field_letter] = true if !availableLetters.has_key? field_letter
+                output << x if all || (current_field =~ /[0-9]/ && field_letter == current_field)
+              else
+                availableLetters['0-9'] = true if !availableLetters.has_key? 'numbers'
+                output << x if all || current_field == "0-9"
+              end
+            else
+              availableLetters['*'] = true if !availableLetters.has_key? 'other'
+              output << x if all || current_field == "*"
+          end
+        end
+        params[:availableLetters] = availableLetters.collect{ |k,v| k.mb_chars.capitalize.to_s }
+        output.sort! {|x, y| block_given? ? (yield(x).to_s <=> yield(y).to_s) : (x.id.to_s <=> y.id.to_s) }
+      end
+      params[:currentField] = current_field.mb_chars.capitalize.to_s
+      return ((params[:db_mode] && params[:db_field]) ? output.order("#{params[:db_field]} ASC") : output), params
+    end
+
+    private
+
+    def set_default_field(letters, params)
+      if letters.any?
+        params[:default_field] = letters.first
+      elsif params[:include_all]
+        params[:default_field] = 'all'
+      else
+        params[:default_field] = params[:language].default_letter
+      end
+    end
+
+    def filter_by_cardinality(letters)
+      letters.collect do |letter, count|
+        if count > 0
+          letter = letter.mb_chars.capitalize.to_s
+          (letter =~ /[а-і]/).nil? ? '*' : letter
+        else
+          nil
+        end
+      # repass again to filter duplicates *
+      end.uniq
+    end
+
+    def find_available_letters(db_field)
+      # safe the field (look for the ActiveRecord valid attributes)
+      # but allow explict table name prefixes in order to avoid 'field list is ambiguous' errors
+      if db_field.nil? || !self.attribute_names.include?(db_field.to_s.split('.').last)
+        db_field = 'id'
+      end
+      criteria = "substr( %s, 1 , 1)" % db_field
+      self.select(criteria).group(criteria).order(criteria).count(db_field)
+    end
+  end
+end

data/lib/alphabetical_paginate/engine.rb

@@ -0,0 +1,6 @@
+require 'rails'
+
+module AlphabeticalPaginate
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/alphabetical_paginate/language.rb

@@ -0,0 +1,66 @@
+# coding: utf-8
+module AlphabeticalPaginate
+  class Language
+    APPROXIMATIONS = {
+        "Є" => "je",
+        "Ю" => "yu",
+      }
+
+    attr_reader :code
+
+    def initialize(code)
+      @code = code
+    end
+
+    def russian?
+      defined?(I18n) && I18n.locale == :uk && code == :uk
+    end
+
+    def letters_regexp
+      russian? ? /[а-іА-іa-zA-Z]/ : /[a-zA-Z]/
+    end
+
+    def slugged_regexp
+      /^(#{slugged_letters.values.join("|")})$/
+    end
+
+    def default_letter
+      russian? ? "а" : "a" # First 'a' is russian, second - english
+    end
+
+    # used in view_helper
+    def letters_range
+      if russian?
+        ["А","Б","В","Г","Д","Е","Є","Ж","З","И","І","Й","К","Л","М","Н","О","П","Р","С","Т","У","Ф","Х","Ц","Ч","Ш","Щ","Ю","Я"]
+      else
+        ["A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"]
+      end
+    end
+
+    def slugged_letters
+      hash = { "All" => "all" }
+      letters_range.each{ |x| hash[x] = normalize(x) }
+      hash
+    end
+
+    # used in view_helper
+    def output_letter(l)
+      (l == "All") ? all_field : l
+    end
+
+    # used in view_helper
+    def all_field
+      russian? ? 'Усі' : "All"
+    end
+
+    private
+
+    def normalize(letter)
+      if russian?
+        APPROXIMATIONS[letter] || letter.to_s.to_slug.normalize(transliterations: :ukrainian).to_s
+      else
+        letter.to_s.to_slug.normalize.to_s
+      end
+    end
+  end
+end

data/lib/alphabetical_paginate/railtie.rb

@@ -0,0 +1,13 @@
+require 'alphabetical_paginate/view_helpers'
+require 'alphabetical_paginate/controller_helper'
+module AlphabeticalPaginate
+  class Railtie < Rails::Railtie
+    initializer "alphabetical_paginate.view_helpers" do
+      ActionView::Base.send :include, ViewHelpers
+    end
+    initializer "alphabetical_paginate.controller_helpers" do
+      ActiveRecord::Relation.send :include, ControllerHelpers
+      ActiveRecord::Base.send :include, ControllerHelpers
+    end
+  end
+end

data/lib/alphabetical_paginate/version.rb

@@ -0,0 +1,3 @@
+module AlphabeticalPaginate
+  VERSION = "2.3.2"
+end

data/lib/alphabetical_paginate/view_helpers.rb

@@ -0,0 +1,84 @@
+# coding: utf-8
+module AlphabeticalPaginate
+  module ViewHelpers
+    def alphabetical_paginate(options = {})
+      output = ""
+      links = ""
+      output += javascript_include_tag 'alphabetical_paginate' if options[:js] == true
+      options[:scope] ||= main_app
+      
+      if options[:paginate_all]
+        range = options[:language].letters_range
+        if options[:others]
+          range += ["*"]
+        end
+        if options[:enumerate] && options[:numbers]
+          range = (0..9).to_a.map{|x| x.to_s} + range
+        elsif options[:numbers]
+          range = ["0-9"] + range
+        end
+        range.unshift "All" if (options[:include_all] && !range.include?("All"))
+        range.each do |l|
+          link_letter = l
+          if options[:slugged_link] && (l =~ options[:language].letters_regexp || l == "All")
+            link_letter = options[:language].slugged_letters[l]
+          end
+          letter_options = { letter: link_letter }
+          if !options[:all_as_link] && (l == "All")
+            letter_options[:letter] = nil
+          end
+
+          url = options[:scope].url_for(letter_options)
+          value = options[:language].output_letter(l)
+          if l == options[:currentField]
+            links += content_tag(:li, link_to(value, "#", "data-letter" => l), :class => "active")
+          elsif options[:db_mode] or options[:availableLetters].include? l
+            links += content_tag(:li, link_to(value, url, "data-letter" => l))
+          else
+            links += content_tag(:li, link_to(value, url, "data-letter" => l), :class => "disabled")
+          end
+        end
+      else
+        options[:availableLetters].sort!
+        options[:availableLetters] = options[:availableLetters][1..-1] + ["*"] if options[:availableLetters][0] == "*"
+        #Ensure that "All" is always at the front of the array
+        if options[:include_all]
+          options[:availableLetters].delete("All") if options[:availableLetters].include?("All")
+          options[:availableLetters].unshift("All")
+        end
+        options[:availableLetters] -= (1..9).to_a.map{|x| x.to_s} if !options[:numbers]
+        options[:availableLetters] -= ["*"] if !options[:others]
+        
+        options[:availableLetters].each do |l|
+          link_letter = l
+          if options[:slugged_link] && (l =~ options[:language].letters_regexp || l == "All")
+            link_letter = options[:language].slugged_letters[l]
+          end
+          letter_options = { letter: link_letter }
+          if !options[:all_as_link] && (l == "All")
+            letter_options[:letter] = nil
+          end
+
+          url = options[:scope].url_for(letter_options)
+          value = options[:language].output_letter(l)
+          links += content_tag(:li, link_to(value, url, "data-letter" => l), :class => ("active" if l == options[:currentField] ))
+        end
+      end
+
+      element = options[:bootstrap3] ? 'ul' : 'div'
+      if options[:pagination_class] != "none"
+        pagination = "<#{element} class='pagination %s alpha'>" % options[:pagination_class]
+      else
+        pagination = "<#{element} class='pagination alpha'>"
+      end
+      pagination +=
+        (options[:bootstrap3] ? "" : "<ul>") +
+        links +
+        (options[:bootstrap3] ? "" : "</ul>") +
+        (options[:bootstrap3] ? "" : "</div>")
+
+      output += pagination
+      output.html_safe
+    end
+  end
+end

data/lib/alphabetical_paginate.rb

@@ -0,0 +1,8 @@
+require "alphabetical_paginate/version"
+require "alphabetical_paginate/array"
+require "alphabetical_paginate/language"
+require "alphabetical_paginate/railtie" if defined?(Rails)
+
+module AlphabeticalPaginate
+  require 'alphabetical_paginate/engine'
+end

data/spec/alpha_example.rb

@@ -0,0 +1,15 @@
+module AlphabeticalPaginate
+  class AlphaExample
+    attr_accessor :id, :word
+
+    def initialize(letter)
+      @id = letter
+      @word = letter.reverse
+    end
+
+    def to_s
+      "{%s, %s}" % [@id, @word]
+    end
+
+  end
+end

data/spec/alphabetical_paginate_spec.rb

@@ -0,0 +1,244 @@
+# coding: utf-8
+require 'alpha_example'
+require 'alphabetical_paginate'
+require_relative '#{File.dirname(__FILE__)}/../../lib/alphabetical_paginate/view_helpers'
+
+# stub methods
+def javascript_include_tag x
+	return ""
+end
+class String
+	def html_safe
+		return self
+	end
+end
+
+class RouterMock
+  def url_for(options)
+    options[:letter] ? '?letter='+options[:letter] : '/'
+  end
+end
+
+def main_app
+  RouterMock.new()
+end
+
+def link_to(value, url, options)
+  "<a href='#{url}' data-letter=\"#{options["data-letter"]}\">#{value}</a>"
+end
+
+def content_tag(type, el, html_options={})
+  "<#{type.to_s} class='#{html_options[:class] || ''}'>#{el}</#{type.to_s}>"
+end
+
+
+module AlphabeticalPaginate
+
+  describe AlphabeticalPaginate do
+
+    describe "#alpha_paginate" do
+      before :each do
+        @list = ["aa", "ab", "ac",
+          "ba", "bb", "bg",
+          "ca", "cd", "ce"].map do |x|
+          AlphaExample.new(x)
+        end
+      end
+
+      it "should paginate by id automatically" do
+        expectedCollection = ["ba", "bb", "bg"].map do |x|
+          AlphaExample.new(x)
+        end
+        expectedParams = {
+          availableLetters: ["a", "b", "c"],
+          currentField: "b",
+          enumerate: false,
+        }
+        collection, params = @list.alpha_paginate("b")
+        collection.to_s.should == 
+          expectedCollection.to_s
+        params.to_s.should include
+          expectedParams.to_s
+      end
+
+      it "should paginate by block when needed" do
+        expectedCollection = ["ab", "bb"].map do |x|
+          AlphaExample.new(x)
+        end
+        expectedParams = {
+          availableLetters: ["a", "b", "c", "g", "d", "e"],
+          currentField: "b",
+          enumerate: false,
+        }
+        collection, params = @list.alpha_paginate("b") do |x|
+          x.word
+        end
+        collection.to_s.should == 
+          expectedCollection.to_s
+        params.to_s.should include
+          expectedParams.to_s
+      end
+    end
+
+    describe "#alpha_paginate in russian characters" do
+      before :each do
+        I18n.locale = :ru
+        @list = ["аа", "аб", "ас",
+          "ба", "бб", "бв",
+          "са", "сд", "се"].map do |x|
+          AlphaExample.new(x)
+        end
+      end
+
+      it "should paginate by id automatically" do
+        expectedCollection = ["са", "сд", "се"].map do |x|
+          AlphaExample.new(x)
+        end
+        expectedParams = {
+          availableLetters: ["а", "б", "с"],
+          currentField: "с",
+          enumerate: false,
+        }
+        collection, params = @list.alpha_paginate("с", { support_language: :ru })
+        collection.to_s.should == 
+          expectedCollection.to_s
+        params.to_s.should include
+          expectedParams.to_s
+      end
+
+      it "should paginate for russian characters with default 'a' character" do
+        expectedCollection = ["аа", "аб", "ас"].map do |x|
+          AlphaExample.new(x)
+        end
+        expectedParams = {
+          availableLetters: ["а", "б", "с"],
+          currentField: "а",
+          enumerate: false,
+        }
+        collection, params = @list.alpha_paginate(nil, { include_all: false, support_language: :ru })
+        collection.to_s.should == 
+          expectedCollection.to_s
+        params.to_s.should include
+          expectedParams.to_s
+      end
+    end
+
+    include ViewHelpers
+
+    describe "#alphabetical_paginate" do
+      before :each do
+        @list = []
+        (["@!#"] + (0..9).to_a.map{|x| x.to_s} + ("A".."Z").to_a).each do |x|
+          ("A".."Y").to_a.each do |y|
+            @list << x + y
+          end
+        end
+        @list.map! do |x|
+          AlphaExample.new(x)
+        end
+      end
+
+      it "should have div tags and pagination classes" do
+        index, params = @list.alpha_paginate(nil)
+        pagination = alphabetical_paginate(params)
+        pagination.should include "div", "pagination"
+      end
+
+      it "should include a numbers and others field" do
+        index, params = @list.alpha_paginate(nil)
+        pagination = alphabetical_paginate(params)
+        (["*"] + ["0-9"] + ("A".."Z").to_a.map{|x|
+          'data-letter="%s"'%x}).each do |x|
+          pagination.should include x
+        end
+      end
+
+      it "should default all values when necessary" do
+        index, params = @list.alpha_paginate(nil, {})
+        pagination = alphabetical_paginate(params)
+        (["*"] + ["0-9"] + ("A".."Z").to_a.map{|x|
+          'data-letter="%s"'%x}).each do |x|
+          pagination.should include x
+        end
+      end
+
+      it "should hide values that don't exist" do
+        index, params = @list.alpha_paginate(nil){|x| x.word}
+        pagination = alphabetical_paginate(params)
+        (("A".."Y").to_a.map{|x|
+          'data-letter="%s"'%x}).each do |x|
+          pagination.should include x
+        end
+        pagination.should_not include 'data-letter="Z"', 'data-letter="*"',
+          'data-letter="0-9"'
+      end
+
+      it "should enumerate when asked" do
+        index, params = @list.alpha_paginate(nil, {enumerate: true})
+        pagination = alphabetical_paginate(params)
+        (("0".."9").to_a.map{|x|
+          'data-letter="%s"'% x.to_s }).each do |x|
+          pagination.should include x
+        end
+
+      end
+
+      it "should display all when asked" do
+        index, params = @list.alpha_paginate(nil, {paginate_all: true,
+                                             enumerate: true}){|x| x.word}
+        pagination = alphabetical_paginate(params)
+        (["*"] + (0..9).to_a.map{|x| x.to_s} + ("A".."Z").to_a.map{|x|
+          'data-letter="%s"'%x}).each do |x|
+          pagination.should include x
+        end
+      end
+
+      it "should include 'all' and '0-9' fields" do
+        index, params = @list.alpha_paginate(nil, { include_all: true })
+        pagination = alphabetical_paginate(params)
+        (["All", "0-9"].map{|x|
+          'data-letter="%s"'%x}).each do |x|
+          pagination.should include x
+        end
+      end
+
+      it "should include All as link" do
+        index, params = @list.alpha_paginate("A", { include_all: true })
+        pagination = alphabetical_paginate(params)
+        pagination.should include "href='?letter=All'"
+      end
+
+      it "should not include All as link" do
+        index, params = @list.alpha_paginate("A", { include_all: true, all_as_link: false })
+        pagination = alphabetical_paginate(params)
+        pagination.should_not include "href='?letter=All'"
+      end
+    end
+
+    describe "#alphabetical_paginate in russian characters" do
+      before :each do
+        @list = []
+        ("А".."Я").to_a.each do |x|
+          ("А".."Т").to_a.each do |y|
+            @list << x + y
+          end
+        end
+        @list.map! do |x|
+          AlphaExample.new(x)
+        end
+        @russian_array = []
+        "АБВГДЕЖЗИКЛМНОПРСТУФХЦЧШЭЮЯ".each_char{ |x| @russian_array << x }
+      end
+
+      it "should display russian characters through additional attribute(language)" do
+        I18n.locale = :ru
+        index, params = @list.alpha_paginate(nil, { paginate_all: true, others: false, support_language: :ru }){|x| x.word}
+        pagination = alphabetical_paginate(params)
+        (["0"] + @russian_array.map{|x|
+          'data-letter="%s"'%x}).each do |x|
+          pagination.should include x
+        end
+      end
+    end
+  end
+end

data/spec/language_spec.rb

@@ -0,0 +1,68 @@
+# coding: utf-8
+require 'alphabetical_paginate'
+
+module AlphabeticalPaginate
+  describe Language do
+
+    context "English language" do
+      before(:all) do
+        I18n.locale = :en
+        @language = AlphabeticalPaginate::Language.new(I18n.locale)
+      end
+
+      it "should return false on russian? method" do
+        @language.russian?.should be_false
+      end
+
+      it "should return /[a-zA-Z]/ regexp" do
+        @language.letters_regexp.should eq(/[a-zA-Z]/)
+      end
+
+      it "should return array of english letters" do
+        @language.letters_range.should eq(("A".."Z").to_a)
+      end
+
+      it "should return english representation of 'All' field and other english letters (for view helper)" do
+        (["All"] + ("A".."Z").to_a).map do |l|
+          @language.output_letter(l).should eq(l)
+        end
+      end
+
+      it "should return english representation of 'a' letter" do
+        @language.default_letter.should eq("a")
+      end
+    end
+
+    context "Russian language" do
+      before(:all) do
+        I18n.locale = :ru
+        @language = AlphabeticalPaginate::Language.new(I18n.locale)
+        @russian_string = "АБВГДЕЄЖЗИІЇЙКЛМНОПРСТУФХЦЧШЩЮЯ"
+        @russian_array = []
+        @russian_string.each_char{ |x| @russian_array << x }
+      end
+
+      it "should return true on russian? method" do
+        @language.russian?.should be_true
+      end
+
+      it "should return /[а-яА-Я]/ regexp" do
+        @language.letters_regexp.should eq(/[а-яА-Я]/)
+      end
+
+      it "should return array of russian letters" do
+        @language.letters_range.should eq(@russian_array)
+      end
+
+      it "should return russian representation of 'All' field and other russian letters (for view helper)" do
+        (["Все"] + @russian_array).map do |l|
+          @language.output_letter(l).should eq(l)
+        end
+      end
+
+      it "should return russian representation of 'а' letter" do
+        @language.default_letter.should eq("а")
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.include Rails.application.routes.url_helpers
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/support/helpers.rb

@@ -0,0 +1,4 @@
+module Helpers
+  include ActionView::Base::ViewHelpers
+  include ActionView::Helpers::AssetTagHelper
+end

data/vendor/assets/javascripts/alphabetical_paginate.js

@@ -0,0 +1,64 @@
+$(function() {
+  // deal with old browsers
+  var hasHistory = !!(window.history && window.history.pushState);
+
+  var img = "<img src='/assets/aloader.gif' class='loading'/>";
+  // RAILS 3.0 USERS -> Please delete the above line and uncomment the bottom line
+  // ensure that the image directory matches
+  // var img = "<img src='/img/aloader.gif' class='loading'/>";
+
+  var navbar = $(".pagination.alpha a");
+  // Pick the handler list: just a quick check for the jQuery version (see here: http://bugs.jquery.com/ticket/10589)
+  var handlers = navbar.data ? navbar.data('events') : jQuery._data(navbar[0], 'events');
+
+  if (!handlers || -1 !== $.inArray(onNavbarClick, handlers.click)) {
+      $(document).on("click", ".pagination.alpha a", onNavbarClick);
+      if(hasHistory){
+        // bind the popstate
+        bindPopState(location.href);
+      }
+  }
+
+  function onNavbarClick(e) {
+      e.preventDefault();
+      var url = location.href,
+          letter = $(this).data("letter");
+      if (/letter/.test(url)) {
+          url = url.replace(/letter=[^&]*/, "letter=" + letter);
+      } else {
+          if (/\?/.test(url)) {
+              url += "&letter=" + letter;
+          } else {
+              url += "?letter=" + letter;
+          }
+      }
+      loadPage(url);
+      // deal with browser support
+      if(hasHistory){
+        history.pushState(null, document.title, url);
+      }
+  }
+
+  // let navigate the browser throught the ajax history
+  function bindPopState(initialUrl){
+    $(window).bind("popstate", function() {
+      var newUrl = location.href;
+      var diff = newUrl.replace(initialUrl, '');
+      // skip initial popstate
+      // skip anchor links (used for JS links)
+      if (diff !== '' && diff !== '#') {
+        loadPage(newUrl);
+      }
+    });
+  }
+
+  function loadPage(url){
+    $(".pagination").html(img);
+    $.get(url, function (result) {
+      $(".pagination").html($(".pagination", result).html());
+      $("#pagination_table").html($("#pagination_table", result).html());
+    });
+  }
+
+
+});

data/vendor/assets/javascripts/index.js

@@ -0,0 +1 @@
+//= require ./alphabetical_paginate

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: alphabetical_paginate_uk
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.2'
 platform: ruby
 authors:
-- refleckt
+- lingz
 autorequire: 
 bindir: bin
 cert_chain: []
@@ -66,13 +66,35 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Alphabetical Pagination for UK
+description: Alphabetical Pagination UK
 email:
-- m.antevora@gmail.com
+- lz781@nyu.edu
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/alphabetical_paginate.rb
+- lib/alphabetical_paginate/array.rb
+- lib/alphabetical_paginate/controller_helper.rb
+- lib/alphabetical_paginate/engine.rb
+- lib/alphabetical_paginate/language.rb
+- lib/alphabetical_paginate/railtie.rb
+- lib/alphabetical_paginate/version.rb
+- lib/alphabetical_paginate/view_helpers.rb
+- spec/alpha_example.rb
+- spec/alphabetical_paginate_spec.rb
+- spec/language_spec.rb
+- spec/spec_helper.rb
+- spec/support/helpers.rb
+- vendor/assets/images/aloader.gif
+- vendor/assets/javascripts/alphabetical_paginate.js
+- vendor/assets/javascripts/index.js
 homepage: https://github.com/refleckt/alphabetical_paginate_uk
 licenses:
 - MIT
@@ -97,4 +119,9 @@ rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Pagination
-test_files: []
+test_files:
+- spec/alpha_example.rb
+- spec/alphabetical_paginate_spec.rb
+- spec/language_spec.rb
+- spec/spec_helper.rb
+- spec/support/helpers.rb