alphabetical_paginate_uk 0.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4db868fdca4359e328dea8fad7a6218303c03d86
-  data.tar.gz: 64a40e3785b8e1f78a08b1f0471cf2073e4bc1f8
+  metadata.gz: 20c014f705ed4c606a723e1db2cbbe59c2c01712
+  data.tar.gz: e6e00c27c9b80f1d6586fa42cd241c376f9e4945
 SHA512:
-  metadata.gz: 3660eba7b61822344e4ea2c144cccc2720e38869baf900a9ca27189ea106f30ad43fdf41ce461916bccccf83799a92c67d04a0a3ad26f8cf209b8840d5693a34
-  data.tar.gz: f9e61cfb50fd0f327c9372ae2e8680680dab4500503fb9b1d107deac0464945777b95afec77c6c3cdc84b3e4bb9e82ca4689aff74305626190161023397ecb35
+  metadata.gz: f08d76a9082b4acc60bee32083bce9b942d033716a17f1959f3b42f47ed67a8d0e1cfd6201429a1666e94a11a5eb96f2467780082b8b45b710198ea42de33f60
+  data.tar.gz: 1b395b487c6cc97a5d5d15a18139cc4e2a1182cd3805fd2928222e74ffeb0b54c307fed3f7b5df4942b6b4166c5bb5f3d50bc68f1f910b7eb3d0f00885de526f

data/README.md

@@ -1,4 +1,4 @@
-# AlphabeticalPaginate
+# Alphabetical_Paginate_UK
 
 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. 
 
@@ -15,21 +15,13 @@ Some code was inspired by [will_paginate](https://github.com/mislav/will_paginat
 
 ## Installation
 
-Add this line to your application's Gemfile:  
-```
-    gem 'alphabetical_paginate'
-```
+Add this line to your application's Gemfile:
 
-And then execute:  
-```bash
-    $ bundle install
-```
+    gem 'alphabetical_paginate_uk'
 
-In case you're using the Rails 3.x assets pipeline remember to add it to your `production.rb` script:
+And then execute:
 
-```rb
-  config.assets.precompile += %w( alphabetical_paginate.js )
-```
+    $ bundle install
 
 ## Basic Setup
 
@@ -72,7 +64,7 @@ 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.
+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
@@ -108,17 +100,17 @@ 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_mode` | `Boolean` | `false` | Whether to activate low level SQL that are faster and more memory efficient (forces `:paginate_all` to enable)
 `: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.
+`:paginate_all` | `Boolean` | `false` | Whether you want empty fields to still render in pagination.
 `: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`).
+`:support_language` | `Symbol` | `:uk` | If you want latin letters support set this value to `:en` (only if `I18n.locale` in your application set to `:en`).
 `:bootstrap3` | `Boolean` | `false` | If you want to enable bootstrap 3 support
 
 ## Advanced Pagination
@@ -147,28 +139,6 @@ Also you can paginate by any array generally, it doesn't have to be a collection
   @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
-
+Author: https://github.com/lingz/alphabetical_paginate
 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/alphabetical_paginate_uk.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'alphabetical_paginate_uk/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "alphabetical_paginate_uk"
+  spec.version       = AlphabeticalPaginate::VERSION
+  spec.authors       = ["lingz"]
+  spec.email         = ["m.antevora@gmail.com"]
+  spec.description   = "Alphabetical Pagination Ukrainian"
+  spec.summary       = "Pagination by letters"
+  spec.homepage      = "https://github.com/refleckt/alphabetical_paginate_uk"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.6"
+  spec.add_development_dependency "rails"
+end

data/lib/{alphabetical_paginate → alphabetical_paginate_uk}/array.rb

@@ -3,10 +3,9 @@ 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}
+                                              js: true, support_language: :en, bootstrap3: false}
     params[:paginate_all] ||= false
-    params[:support_language] ||= :uk
+    params[:support_language] ||= :en
     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
@@ -14,30 +13,21 @@ 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 = {}
-
-    current_field ||= params[:default_field]
+    if current_field == nil
+      current_field = params[:default_field]
+    end
     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)
+          output << x if all || (current_field =~ params[:language].letters_regexp && field_letter == current_field)
         when /[0-9]/
           if params[:enumerate]
             availableLetters[field_letter] = true if !availableLetters.has_key? field_letter

data/lib/alphabetical_paginate_uk/controller_helper.rb

@@ -0,0 +1,87 @@
+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: :en,
+                                                bootstrap3: false}
+      params[:paginate_all] ||= false
+      params[:support_language] ||= :en
+      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[:default_field] ||= params[:include_all] ? "all" : params[:language].default_letter
+      params[:db_mode] ||= false
+      params[:db_field] ||= "id"
+
+      output = []
+
+      if current_field == nil
+        current_field = params[:default_field]
+      end
+      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
+        params[:paginate_all] = true
+        params[:availableLetters] = []
+
+        if all
+          output = self
+        else
+          case current_field
+          when /[а-їА-їa-zA-Z]/
+            output = self.where("LOWER(%s) REGEXP '^[^а-ї].*'" % [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
+          else
+            output = self.where("LOWER(%s) REGEXP '^[^а-їa-z].*'" % [params[:db_field], current_field])
+          end
+        end
+      else
+        availableLetters = {}
+        self.find_each({batch_size: params[:batch_size]}) do |x|
+          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)
+            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
+  end
+end

data/lib/alphabetical_paginate_uk/language.rb

@@ -0,0 +1,41 @@
+# coding: utf-8
+module AlphabeticalPaginate
+  class Language
+    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 default_letter
+      russian? ? "а" : "a" # First 'a' is russian, second - english
+    end
+
+    # used in view_helper
+    def letters_range
+      if russian?
+        ('А'..'ї').to_a
+      else
+        ('A'..'Z').to_a
+      end
+    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
+  end
+end

data/lib/{alphabetical_paginate → alphabetical_paginate_uk}/railtie.rb

@@ -1,5 +1,5 @@
-require 'alphabetical_paginate/view_helpers'
-require 'alphabetical_paginate/controller_helper'
+require 'alphabetical_paginate_uk/view_helpers'
+require 'alphabetical_paginate_uk/controller_helper'
 module AlphabeticalPaginate
   class Railtie < Rails::Railtie
     initializer "alphabetical_paginate.view_helpers" do

data/lib/{alphabetical_paginate → alphabetical_paginate_uk}/version.rb

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

data/lib/alphabetical_paginate_uk/view_helpers.rb

@@ -0,0 +1,65 @@
+# coding: utf-8
+module AlphabeticalPaginate
+  module ViewHelpers
+    def alphabetical_paginate params
+      output = ""
+      links = ""
+
+      output += javascript_include_tag 'alphabetical_paginate' if params[:js]
+      
+      if params[:paginate_all]
+        range = params[:language].letters_range
+        if params[:others]
+          range += ["*"]
+        end
+        if params[:enumerate] && params[:numbers]
+          range = (0..9).to_a.map{|x| x.to_s} + range
+        elsif params[:numbers]
+          range = ["0-9"] + range
+        end
+        range.unshift "All" if params[: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>"
+          else
+            links += '<li class="disabled"><a href="?letter=' + l + '" data-letter="' + l + '">' + value + "</a></li>"
+          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] -= (1..9).to_a.map{|x| x.to_s} if !params[:numbers]
+        params[:availableLetters] -= ["*"] if !params[: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>"
+          end
+        end
+      end
+      
+
+      element = params[:bootstrap3] ? 'ul' : 'div'
+      if params[:pagination_class] != "none"
+        pagination = "<#{element} class='pagination %s alpha'>" % params[:pagination_class]
+      else
+        pagination = "<#{element} class='pagination alpha'>"
+      end
+      pagination +=
+        (params[:bootstrap3] ? "" : "<ul>") +
+        links +
+        (params[:bootstrap3] ? "" : "</ul>") +
+        (params[:bootstrap3] ? "" : "</div>")
+
+      output += pagination
+      output.html_safe
+    end
+  end
+end

data/lib/alphabetical_paginate_uk.rb

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

data/spec/alphabetical_paginate_spec.rb

@@ -13,25 +13,6 @@ 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
@@ -201,18 +182,6 @@ 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,7 +3,6 @@ require 'alphabetical_paginate'
 
 module AlphabeticalPaginate
   describe Language do
-
     context "English language" do
       before(:all) do
         I18n.locale = :en
@@ -37,7 +36,7 @@ module AlphabeticalPaginate
       before(:all) do
         I18n.locale = :ru
         @language = AlphabeticalPaginate::Language.new(I18n.locale)
-        @russian_string = "АБВГДЕЄЖЗИІЇЙКЛМНОПРСТУФХЦЧШЩЮЯ"
+        @russian_string = "АБВГДЕЖЗИКЛМНОПРСТУФХЦЧШЭЮЯ"
         @russian_array = []
         @russian_string.each_char{ |x| @russian_array << x }
       end

data/vendor/assets/javascripts/alphabetical_paginate.js

@@ -1,6 +1,5 @@
 $(function() {
-  // deal with old browsers
-  var hasHistory = !!(window.history && window.history.pushState);
+  var once = false;
 
   var img = "<img src='/assets/aloader.gif' class='loading'/>";
   // RAILS 3.0 USERS -> Please delete the above line and uncomment the bottom line
@@ -13,52 +12,44 @@ $(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;
           }
       }
-      loadPage(url);
-      // deal with browser support
-      if(hasHistory){
-        history.pushState(null, document.title, url);
-      }
+      $(".pagination").html(img);
+      //$.load(url + " #pagination_table");
+      $.get(url, function(result) {
+          $(".pagination").html($(".pagination", result));
+          $("#pagination_table").html($("#pagination_table", result));
+      });
+      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);
+   // 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));
+          $("#pagination_table").html($("#pagination_table", result));
+        });
+      } else {
+        once = true;
       }
-    });
-  }
-
-  function loadPage(url){
-    $(".pagination").html(img);
-    $.get(url, function (result) {
-      $(".pagination").html($(".pagination", result).html());
-      $("#pagination_table").html($("#pagination_table", result).html());
-    });
-  }
+  });
 
 
 });

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: alphabetical_paginate_uk
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: 1.0.0
 platform: ruby
 authors:
 - lingz
@@ -66,33 +66,31 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Alphabetical Pagination UK
+description: Alphabetical Pagination Ukrainian
 email:
-- lz781@nyu.edu
+- m.antevora@gmail.com
 executables: []
 extensions: []
 extra_rdoc_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
+- alphabetical_paginate_uk.gemspec
+- lib/alphabetical_paginate_uk.rb
+- lib/alphabetical_paginate_uk/array.rb
+- lib/alphabetical_paginate_uk/controller_helper.rb
+- lib/alphabetical_paginate_uk/engine.rb
+- lib/alphabetical_paginate_uk/language.rb
+- lib/alphabetical_paginate_uk/railtie.rb
+- lib/alphabetical_paginate_uk/version.rb
+- lib/alphabetical_paginate_uk/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
@@ -118,10 +116,9 @@ rubyforge_project:
 rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
-summary: Pagination
+summary: Pagination by letters
 test_files:
 - spec/alpha_example.rb
 - spec/alphabetical_paginate_spec.rb
 - spec/language_spec.rb
-- spec/spec_helper.rb
 - spec/support/helpers.rb

data/.rspec

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

data/lib/alphabetical_paginate/controller_helper.rb

@@ -1,145 +0,0 @@
-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/language.rb

@@ -1,66 +0,0 @@
-# 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/view_helpers.rb

@@ -1,84 +0,0 @@
-# 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

@@ -1,8 +0,0 @@
-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/spec_helper.rb

@@ -1,18 +0,0 @@
-# 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