alphabetical_paginate 2.2.3 → 2.3.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 63b2a6f96a526fed8baa1276a837d11bff0a5064
+  data.tar.gz: fec8f3848297ceda6e5230c1dfb6b5777de21105
+SHA512:
+  metadata.gz: 88248d71f19d617dd2d34d1d633b55556d0dab449af255d8e1390b7fbbecd20e52783989cf93715acdbf4aea6f8b31fdadbc407c0514e04fb154c95f41b6d1c6
+  data.tar.gz: 3fbed90e8462cafc90b873eaab288675fec345c863fc4fa42077aa5002581befe2b8f27c113ded5705f656c9b919aaa93159bb3c97f2ee0acc8d7332b0f83d14

data/.rspec

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

data/README.md

@@ -15,13 +15,21 @@ Some code was inspired by [will_paginate](https://github.com/mislav/will_paginat
 
 ## Installation
 
-Add this line to your application's Gemfile:
-
+Add this line to your application's Gemfile:  
+```
     gem 'alphabetical_paginate'
+```
 
-And then execute:
-
+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
 
@@ -100,11 +108,11 @@ 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 (forces `:paginate_all` to enable)
+`: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.
+`: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.
@@ -156,3 +164,11 @@ Also, there is one line in vendor/assets/javascripts that needs to be changed fo
 # 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/lib/alphabetical_paginate/array.rb

@@ -3,7 +3,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: :en, bootstrap3: false}
+                                              js: true, support_language: :en, bootstrap3: false,
+                                              slugged_link: false, slug_field: "slug", all_as_link: true}
     params[:paginate_all] ||= false
     params[:support_language] ||= :en
     params[:language] = AlphabeticalPaginate::Language.new(params[:support_language])
@@ -13,21 +14,30 @@ class Array
     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 = {}
-    if current_field == nil
-      current_field = params[:default_field]
-    end
+
+    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
-          output << x if all || (current_field =~ params[:language].letters_regexp && field_letter == current_field)
+          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

data/lib/alphabetical_paginate/controller_helper.rb

@@ -4,13 +4,15 @@ module AlphabeticalPaginate
       base.extend(self)
     end
 
-    def alpha_paginate current_field, params = {enumerate:false, default_field: "a", 
+    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, 
+                                                batch_size: 500, db_mode: false,
                                                 db_field: "id", include_all: true,
                                                 js: true, support_language: :en,
-                                                bootstrap3: false}
+                                                bootstrap3: false, slugged_link: false,
+                                                slug_field: "slug", all_as_link: true}
+      params[:default_field] ||= "a"
       params[:paginate_all] ||= false
       params[:support_language] ||= :en
       params[:language] = AlphabeticalPaginate::Language.new(params[:support_language])
@@ -20,15 +22,30 @@ module AlphabeticalPaginate
       params[:js] = true if !params.has_key? :js
       params[:pagination_class] ||= "pagination-centered"
       params[:batch_size] ||= 500
-      params[:default_field] ||= params[:include_all] ? "all" : params[:language].default_letter
       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 current_field == nil
-        current_field = params[:default_field]
+      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"
 
@@ -36,38 +53,46 @@ module AlphabeticalPaginate
         if !ActiveRecord::Base.connection.adapter_name.downcase.include? "mysql"
           raise "You need a mysql database to use db_mode with alphabetical_paginate"
         end
-        params[:paginate_all] = true
-        params[:availableLetters] = []
 
         if all
           output = self
         else
-          case current_field
-          when params[:language].letters_regexp
-            output = self.where("LOWER(%s) REGEXP '^%s.*'" % [params[:db_field], current_field])
-          when /[0-9]/
-            if params[:enumerate]
-              output = self.where("LOWER(%s) REGEXP '^%s.*'" % [params[:db_field], current_field])
-            else
-              output = self.where("LOWER(%s) REGEXP '^[0-9].*'" % [params[:db_field], current_field])
-            end
+
+          # 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
-            output = self.where("LOWER(%s) REGEXP '^[^a-z0-9].*'" % [params[:db_field], current_field])
+            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
-              output << x if all || (current_field =~ params[:language].letters_regexp && field_letter == current_field)
+              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) 
+                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"
@@ -83,5 +108,39 @@ module AlphabeticalPaginate
       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 =~ /[A-Z]/).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 = Arel.sql("substr( %s, 1 , 1)" % db_field)
+      self.select(criteria).group(criteria).order(criteria).count(db_field)
+    end
   end
 end

data/lib/alphabetical_paginate/language.rb

@@ -1,6 +1,11 @@
 # coding: utf-8
 module AlphabeticalPaginate
   class Language
+    APPROXIMATIONS = {
+        "Э" => "je",
+        "Ю" => "yu"
+      }
+
     attr_reader :code
 
     def initialize(code)
@@ -15,6 +20,10 @@ module AlphabeticalPaginate
       russian? ? /[а-яА-Я]/ : /[a-zA-Z]/
     end
 
+    def slugged_regexp
+      /^(#{slugged_letters.values.join("|")})$/
+    end
+
     def default_letter
       russian? ? "а" : "a" # First 'a' is russian, second - english
     end
@@ -22,14 +31,18 @@ module AlphabeticalPaginate
     # used in view_helper
     def letters_range
       if russian?
-        letters = []
-        "АБВГДЕЖЗИКЛМНОПРСТУФХЦЧШЭЮЯ".each_char{ |x| letters << x }
-        letters
+        ["А","Б","В","Г","Д","Е","Ж","З","И","К","Л","М","Н","О","П","Р","С","Т","У","Ф","Х","Ц","Ч","Ш","Э","Ю","Я"]
       else
-        ('A'..'Z').to_a
+        ["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
@@ -39,5 +52,15 @@ module AlphabeticalPaginate
     def all_field
       russian? ? 'Все' : "All"
     end
+
+    private
+
+    def normalize(letter)
+      if russian?
+        APPROXIMATIONS[letter] || letter.to_s.to_slug.normalize(transliterations: :russian).to_s
+      else
+        letter.to_s.to_slug.normalize.to_s
+      end
+    end
   end
 end

data/lib/alphabetical_paginate/version.rb

@@ -1,3 +1,3 @@
 module AlphabeticalPaginate
-  VERSION = "2.2.3"
+  VERSION = "2.3.4"
 end

data/lib/alphabetical_paginate/view_helpers.rb

@@ -1,62 +1,81 @@
 # coding: utf-8
 module AlphabeticalPaginate
   module ViewHelpers
-    def alphabetical_paginate params
+    def alphabetical_paginate(options = {})
       output = ""
       links = ""
+      output += javascript_include_tag 'alphabetical_paginate' if options[:js] == true
+      options[:scope] ||= main_app
 
-      output += javascript_include_tag 'alphabetical_paginate' if params[:js]
-
-      if params[:paginate_all]
-        range = params[:language].letters_range
-        if params[:others]
+      if options[:paginate_all]
+        range = options[:language].letters_range
+        if options[:others]
           range += ["*"]
         end
-        if params[:enumerate] && params[:numbers]
+        if options[:enumerate] && options[:numbers]
           range = (0..9).to_a.map{|x| x.to_s} + range
-        elsif params[:numbers]
+        elsif options[:numbers]
           range = ["0-9"] + range
         end
-        range.unshift "All" if (params[:include_all] && !range.include?("All"))
+        range.unshift "All" if (options[:include_all] && !range.include?("All"))
         range.each do |l|
-          value = params[:language].output_letter(l)
-          if l == params[:currentField]
-            links += '<li class="active"><a href="#" data-letter="' + l + '">' + value + "</a></li>"
-          elsif params[:db_mode] or params[:availableLetters].include? l
-            links += '<li><a href="?letter=' + l + '" data-letter="' + l + '">' + value + "</a></li>"
+          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 += '<li class="disabled"><a href="?letter=' + l + '" data-letter="' + l + '">' + value + "</a></li>"
+            links += content_tag(:li, link_to(value, url, "data-letter" => l), :class => "disabled")
           end
         end
       else
-        params[:availableLetters].sort!
-        params[:availableLetters] = params[:availableLetters][1..-1] + ["*"] if params[:availableLetters][0] == "*"
-        params[:availableLetters].unshift "All" if (params[:include_all] && !params[:availableLetters].include?("All"))
-        params[:availableLetters] -= (1..9).to_a.map{|x| x.to_s} if !params[:numbers]
-        params[:availableLetters] -= ["*"] if !params[:others]
+        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]
 
-        params[:availableLetters].each do |l|
-          value = params[:language].output_letter(l)
-          if l == params[:currentField]
-            links += '<li class="active"><a href="?letter=' + l + '" data-letter="' + l + '">' + value + '</a></li>'
-          else
-            links += '<li><a href="?letter=' + l + '" data-letter="' + l + '">' + value + "</a></li>"
+        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 = params[:bootstrap3] ? 'ul' : 'div'
-      if params[:pagination_class] != "none"
-        pagination = "<#{element} class='pagination %s alpha' style='height:35px;'>" % params[:pagination_class]
+      element = options[:bootstrap3] ? 'ul' : 'div'
+      if options[:pagination_class] != "none"
+        pagination = "<#{element} class='pagination %s alpha' style='height:35px;'>" % options[:pagination_class]
       else
         pagination = "<#{element} class='pagination alpha' style='height:35px;'>"
       end
       pagination +=
-        (params[:bootstrap3] ? "" : "<ul>") +
+        (options[:bootstrap3] ? "" : "<ul>") +
         links +
-        (params[:bootstrap3] ? "" : "</ul>") +
-        (params[:bootstrap3] ? "</ul>" : "</div>")
+        (options[:bootstrap3] ? "" : "</ul>") +
+        "</#{element}>"
 
       output += pagination
       output.html_safe

data/spec/alphabetical_paginate_spec.rb

@@ -13,6 +13,25 @@ class String
 	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
@@ -36,7 +55,7 @@ module AlphabeticalPaginate
           enumerate: false,
         }
         collection, params = @list.alpha_paginate("b")
-        collection.to_s.should == 
+        collection.to_s.should ==
           expectedCollection.to_s
         params.to_s.should include
           expectedParams.to_s
@@ -54,7 +73,7 @@ module AlphabeticalPaginate
         collection, params = @list.alpha_paginate("b") do |x|
           x.word
         end
-        collection.to_s.should == 
+        collection.to_s.should ==
           expectedCollection.to_s
         params.to_s.should include
           expectedParams.to_s
@@ -81,7 +100,7 @@ module AlphabeticalPaginate
           enumerate: false,
         }
         collection, params = @list.alpha_paginate("с", { support_language: :ru })
-        collection.to_s.should == 
+        collection.to_s.should ==
           expectedCollection.to_s
         params.to_s.should include
           expectedParams.to_s
@@ -97,7 +116,7 @@ module AlphabeticalPaginate
           enumerate: false,
         }
         collection, params = @list.alpha_paginate(nil, { include_all: false, support_language: :ru })
-        collection.to_s.should == 
+        collection.to_s.should ==
           expectedCollection.to_s
         params.to_s.should include
           expectedParams.to_s
@@ -125,6 +144,20 @@ module AlphabeticalPaginate
         pagination.should include "div", "pagination"
       end
 
+      it "should open and close the div tag" do
+        index, params = @list.alpha_paginate(nil)
+        pagination = alphabetical_paginate(params)
+        pagination.start_with?('<div').should be_truthy
+        pagination.end_with?('</div>').should be_truthy
+      end
+
+      it "should open and close the ul tag when run in bootstrap3 mode" do
+        index, params = @list.alpha_paginate(nil)
+        pagination = alphabetical_paginate(params.merge(bootstrap3: true))
+        pagination.start_with?('<ul').should be_truthy
+        pagination.end_with?('</ul>').should be_truthy
+      end
+
       it "should include a numbers and others field" do
         index, params = @list.alpha_paginate(nil)
         pagination = alphabetical_paginate(params)
@@ -182,6 +215,18 @@ module AlphabeticalPaginate
           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

data/spec/language_spec.rb

@@ -3,6 +3,7 @@ require 'alphabetical_paginate'
 
 module AlphabeticalPaginate
   describe Language do
+
     context "English language" do
       before(:all) do
         I18n.locale = :en

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/vendor/assets/javascripts/alphabetical_paginate.js

@@ -1,5 +1,6 @@
 $(function() {
-  var once = false;
+  // 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
@@ -12,44 +13,52 @@ $(function() {
 
   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");
+      var url = location.href,
+          letter = $(this).data("letter");
       if (/letter/.test(url)) {
           url = url.replace(/letter=[^&]*/, "letter=" + letter);
-      } 
-      else {
+      } else {
           if (/\?/.test(url)) {
               url += "&letter=" + letter;
-          } 
-          else {
+          } else {
               url += "?letter=" + letter;
           }
       }
-      $(".pagination").html(img);
-      //$.load(url + " #pagination_table");
-      $.get(url, function(result) {
-          $(".pagination").html($(".pagination", result).html());
-          $("#pagination_table").html($("#pagination_table", result).html());
-      });
-      history.pushState(null, document.title, url);
+      loadPage(url);
+      // deal with browser support
+      if(hasHistory){
+        history.pushState(null, document.title, url);
+      }
   }
 
-   // let navigate the browser throught the ajax history
-  $(window).bind("popstate", function() {
-    if (once) {
-      $(".pagination").html(img);
-      $.get(location.href, function(result) {
-        $(".pagination").html($(".pagination", result).html());
-          $("#pagination_table").html($("#pagination_table", result).html());
-        });
-      } else {
-        once = true;
+  // 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());
+    });
+  }
 
 
 });

metadata

@@ -1,78 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: alphabetical_paginate
 version: !ruby/object:Gem::Version
-  version: 2.2.3
-  prerelease: 
+  version: 2.3.4
 platform: ruby
 authors:
 - lingz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-13 00:00:00.000000000 Z
+date: 2019-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.6'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Alphabetical Pagination
@@ -82,7 +73,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
+- ".rspec"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -99,6 +91,7 @@ files:
 - 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
@@ -106,30 +99,30 @@ files:
 homepage: https://github.com/lingz/alphabetical_paginate
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.6.14
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Pagination
 test_files:
 - spec/alpha_example.rb
 - spec/alphabetical_paginate_spec.rb
 - spec/language_spec.rb
+- spec/spec_helper.rb
 - spec/support/helpers.rb