rails_pagination_ultimate 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 465576ccd1cde103ef4befb850236d17d3105ef14c61cbba792f8ceff7f2aa6e
+  data.tar.gz: 9f35198d69e339ea5fd7c6535198cdb3bdd068338d65d074afd00cd33e3429fc
+SHA512:
+  metadata.gz: 77e93931d1fbf86e6e3476438a726aaa15aeb6482183040ca7b2f57324c2334bf621ac060dc64a9da78aa981c57f45ca75041abc1ab6508b97fdbed0c7a49ed9
+  data.tar.gz: b70adad1aab1788d8626ffb6605d30bd64e1464c9ed79c6c17a4783939923fe262e5d405e7b4feb3ff5a677b3638bbfef944adc3a783566af0d3f2df25aa49a2

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-06-03
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shiboshree Roy
+
+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,193 @@
+# 💎 RailsPaginationUltimate
+
+**The ultra-premium, high-performance pagination powerhouse for modern Rails applications.**
+
+RailsPaginationUltimate is built for developers who need more than just simple page links. It is a feature-rich, "Best-in-Class" replacement for Kaminari and WillPaginate, offering pro-grade UI components, native Tailwind CSS support, and advanced interactivity out of the box.
+
+---
+
+## 🚀 Key Features
+
+*   **⚡ Pro Performance**: `without_count` mode for lightning-fast paging on multi-million row tables.
+*   **🎨 Premium UI Styles**: Standard numbers, "Load More" buttons, and automated "Infinite Scroll".
+*   **🌊 Native Tailwind Support**: First-class support for Tailwind CSS utility classes.
+*   **⌨️ Keyboard Navigation**: Use Left/Right arrows to flip through pages.
+*   **🔄 History API**: AJAX updates automatically sync with the browser's URL and Back button.
+*   **🌍 100% Localizable**: Full I18n support for all labels, icons, and result strings.
+*   **🛠 Advanced Helpers**: Integrated `page_entries_info` and `per_page_select` components.
+*   **🧩 Total Customization**: Easy-to-use generator to export and modify HTML templates.
+
+---
+
+## 📦 Installation
+
+Add this line to your application's `Gemfile`:
+
+```ruby
+gem 'rails_pagination_ultimate', github: 'shiboshreeroy/rails_pagination_ultimate'
+```
+
+And then execute:
+```bash
+bundle install
+```
+
+---
+
+## 📖 Usage
+
+### 1. Basic Pagination
+In your controller:
+```ruby
+@posts = Post.page(params[:page]).per(25)
+```
+
+In your view:
+```erb
+<%= paginate @posts %>
+```
+
+### 2. Pro Navigation Modes
+
+#### 📱 Infinite Scroll (Modern Feed)
+Automatically loads content as the user scrolls. Requires a `target` CSS selector.
+```erb
+<div id="posts-container">
+  <%= render @posts %>
+</div>
+
+<%= paginate @posts, type: :infinite_scroll, target: "#posts-container" %>
+```
+
+#### 🖱 "Load More" Button
+A premium button that appends results without a full page reload.
+```erb
+<%= paginate @posts, type: :load_more, target: "#posts-container" %>
+```
+
+#### ⌨️ Keyboard & History Support
+Enable pro-level accessibility and shareable URLs for AJAX pagination:
+```erb
+<%= paginate @posts, theme: :tailwind, keyboard: true, history: true %>
+```
+
+---
+
+## ⚡ Performance Optimization
+
+### Fast Mode (`without_count`)
+Traditional pagination runs a `COUNT(*)` query which can be slow on large tables. RailsPaginationUltimate's "Fast Mode" skips this count entirely and uses an efficient look-ahead check for the next page.
+
+```ruby
+# Controller
+@posts = Post.without_count.page(params[:page]).per(50)
+```
+
+---
+
+## 🎨 Customization & Theming
+
+### A. Tailwind CSS (Recommended)
+Use pro-grade Tailwind components by simply passing `theme: :tailwind`. No extra CSS files required!
+```erb
+<%= paginate @posts, theme: :tailwind, first_last: true, window: 3 %>
+```
+
+### B. CSS Variables (Default Theme)
+If you're not using Tailwind, the default theme is built with clean CSS variables for instant global styling:
+```css
+:root {
+  --rp-primary-color: #3b82f6; /* Your Brand Color */
+  --rp-border-radius: 0.5rem;
+  --rp-text-color: #1f2937;
+  --rp-bg-color: #ffffff;
+}
+```
+
+### C. Total UI Control (Generator)
+Need to change the HTML? Export the Pro Tailwind template to your app:
+```bash
+rails generate rails_pagination_ultimate:tailwind
+```
+This creates `app/views/rails_pagination_ultimate/_pagination.html.erb`. You can then use it like this:
+```erb
+<%= paginate @posts, template: "rails_pagination_ultimate/pagination" %>
+```
+
+---
+
+## 🛠 Results Management
+
+### Detailed Information
+Displays "Showing 1-25 of 150 results".
+```erb
+<%= page_entries_info @posts %>
+```
+
+### Dynamic "Per Page" Selector
+Let users choose how many items they want to see.
+```erb
+<%= per_page_select @posts, choices: [25, 50, 100], label: "Items per page:" %>
+```
+
+---
+
+## 🌍 Localization (I18n)
+
+Everything is translatable in `config/locales/en.yml`:
+
+```yaml
+en:
+  rails_pagination_ultimate:
+    previous: "← Previous"
+    next: "Next →"
+    first: "« First"
+    last: "Last »"
+    info:
+      other: "Showing <b>%{first}-%{last}</b> of <b>%{total}</b> results"
+      without_count: "Showing <b>%{first}-%{last}</b> results"
+```
+
+---
+
+## 📋 Options Reference
+
+| Option | Type | Default | Description |
+| :--- | :--- | :--- | :--- |
+| `theme` | Symbol | `nil` | Set to `:tailwind` for Tailwind UI. |
+| `type` | Symbol | `:standard` | `:standard`, `:load_more`, or `:infinite_scroll`. |
+| `target` | String | `nil` | CSS selector for where to append new items (AJAX). |
+| `window` | Integer | `2` | Number of page links around the current page. |
+| `first_last`| Boolean | `false` | Show "First" and "Last" page links. |
+| `keyboard` | Boolean | `false` | Enable Left/Right arrow key navigation. |
+| `history` | Boolean | `false` | Update browser URL/history on AJAX paging. |
+| `template` | String | `nil` | Path to a custom partial for rendering. |
+
+---
+
+## ⚖️ Why switch from Kaminari?
+
+| Feature | RailsPaginationUltimate | Kaminari |
+| :--- | :---: | :---: |
+| **Native Tailwind UI** | ✅ Built-in | ❌ No |
+| **Infinite Scroll** | ✅ Built-in | ❌ No |
+| **Fast Mode (No Count)** | ✅ Native | ❌ Plugin required |
+| **Keyboard Shortcuts** | ✅ Built-in | ❌ No |
+| **History API Sync** | ✅ Built-in | ❌ No |
+| **Interactive Per-Page** | ✅ Built-in | ❌ No |
+| **Modern Flexbox CSS** | ✅ Yes | ❌ No |
+
+---
+
+## 👨‍💻 Author & Credits
+
+**RailsPaginationUltimate** is developed and maintained by **Shiboshree Roy**.
+
+- **Developer & Author**: [Shiboshree Roy](https://github.com/shiboshreeroy)
+- **Powered By**: Shiboshree Roy
+
+Built with ❤️ for the Rails community.
+
+## 📄 License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/app/assets/javascripts/rails_pagination_ultimate/loader.js

@@ -0,0 +1,133 @@
+(function() {
+  document.addEventListener("click", function(event) {
+    const target = event.target.closest("[data-type='load-more']");
+    if (!target) return;
+
+    event.preventDefault();
+    const url = target.href;
+    const targetSelector = target.dataset.target;
+
+    if (!targetSelector) {
+      console.warn("RailsPaginationUltimate: No target selector provided for load-more button.");
+      return;
+    }
+
+    target.classList.add("loading");
+    target.innerText = "Loading...";
+
+    fetch(url, {
+      headers: {
+        "Accept": "text/vnd.turbo-stream.html, text/html, application/xhtml+xml"
+      }
+    })
+    .then(response => response.text())
+    .then(html => {
+      const parser = new DOMParser();
+      const doc = parser.parseFromString(html, "text/html");
+      const newItems = doc.querySelector(targetSelector);
+      const newButton = doc.querySelector(".rp-load-more-container");
+
+      if (newItems) {
+        document.querySelector(targetSelector).insertAdjacentHTML("beforeend", newItems.innerHTML);
+      }
+
+      const container = target.closest(".rp-load-more-container");
+      if (newButton) {
+        container.outerHTML = newButton.outerHTML;
+      } else {
+        container.remove();
+      }
+    })
+    .catch(error => {
+      console.error("RailsPaginationUltimate error:", error);
+      target.classList.remove("loading");
+      target.innerText = "Load More";
+    });
+  });
+
+  // Infinite Scroll Implementation
+  const initInfiniteScroll = () => {
+    const containers = document.querySelectorAll("[data-controller='rp-infinite-scroll']");
+    
+    containers.forEach(container => {
+      if (container.dataset.observed) return;
+      
+      const url = container.dataset.rpInfiniteScrollUrlValue;
+      const targetSelector = container.dataset.rpInfiniteScrollTargetValue;
+
+      const observer = new IntersectionObserver((entries) => {
+        if (entries[0].isIntersecting) {
+          observer.unobserve(container);
+          
+          fetch(url, {
+            headers: { "Accept": "text/html" }
+          })
+          .then(response => response.text())
+          .then(html => {
+            const parser = new DOMParser();
+            const doc = parser.parseFromString(html, "text/html");
+            const newItems = doc.querySelector(targetSelector);
+            const newContainer = doc.querySelector("[data-controller='rp-infinite-scroll']");
+
+            if (newItems) {
+              document.querySelector(targetSelector).insertAdjacentHTML("beforeend", newItems.innerHTML);
+            }
+
+            if (newContainer) {
+              container.outerHTML = newContainer.outerHTML;
+              initInfiniteScroll(); // Re-init for the new container
+            } else {
+              container.remove();
+            }
+          });
+        }
+      }, { threshold: 0.1 });
+
+      observer.observe(container);
+      container.dataset.observed = "true";
+    });
+  };
+
+  // Keyboard Navigation & History Support
+  const initAdvancedFeatures = () => {
+    const navs = document.querySelectorAll("[data-controller='rails-pagination']");
+    
+    navs.forEach(nav => {
+      if (nav.dataset.advancedObserved) return;
+
+      // Keyboard Navigation
+      if (nav.dataset.keyboard === "true") {
+        document.addEventListener("keydown", (event) => {
+          if (event.key === "ArrowLeft") {
+            const prev = nav.querySelector("[data-rel='prev']");
+            if (prev) prev.click();
+          } else if (event.key === "ArrowRight") {
+            const next = nav.querySelector("[data-rel='next']");
+            if (next) next.click();
+          }
+        });
+      }
+
+      // History API for AJAX links
+      if (nav.dataset.history === "true") {
+        nav.querySelectorAll("a").forEach(link => {
+          link.addEventListener("click", () => {
+            if (!link.dataset.remote && !link.dataset.turbo) return;
+            window.history.pushState({}, "", link.href);
+          });
+        });
+      }
+
+      nav.dataset.advancedObserved = "true";
+    });
+  };
+
+  document.addEventListener("turbo:load", () => {
+    initInfiniteScroll();
+    initAdvancedFeatures();
+  });
+  document.addEventListener("DOMContentLoaded", () => {
+    initInfiniteScroll();
+    initAdvancedFeatures();
+  });
+})();

data/app/assets/stylesheets/rails_pagination_ultimate/main.css

@@ -0,0 +1,113 @@
+:root {
+  --rp-primary-color: #3b82f6;
+  --rp-primary-hover: #2563eb;
+  --rp-text-color: #374151;
+  --rp-bg-color: #ffffff;
+  --rp-border-color: #e5e7eb;
+  --rp-border-radius: 0.5rem;
+  --rp-gap-color: #9ca3af;
+  --rp-disabled-color: #d1d5db;
+}
+
+.rp-pagination {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.5rem;
+  font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+  margin: 2rem 0;
+  user-select: none;
+}
+
+.rp-page {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  min-width: 2.5rem;
+  height: 2.5rem;
+  padding: 0 0.5rem;
+  border: 1px solid var(--rp-border-color);
+  border-radius: var(--rp-border-radius);
+  background-color: var(--rp-bg-color);
+  color: var(--rp-text-color);
+  text-decoration: none;
+  font-size: 0.875rem;
+  font-weight: 500;
+  transition: all 0.2s;
+  cursor: pointer;
+}
+
+.rp-page:hover:not(.disabled):not(.current):not(.gap) {
+  border-color: var(--rp-primary-color);
+  color: var(--rp-primary-color);
+  background-color: #f8fafc;
+}
+
+.rp-page.current {
+  background-color: var(--rp-primary-color);
+  border-color: var(--rp-primary-color);
+  color: white;
+  cursor: default;
+}
+
+.rp-page.disabled {
+  color: var(--rp-disabled-color);
+  border-color: var(--rp-border-color);
+  cursor: not-allowed;
+}
+
+.rp-page.gap {
+  border: none;
+  color: var(--rp-gap-color);
+  cursor: default;
+}
+
+.rp-page-links {
+  display: flex;
+  gap: 0.25rem;
+}
+
+.rp-prev, .rp-next {
+  padding: 0 1rem;
+}
+
+.rp-load-more-container {
+  display: flex;
+  justify-content: center;
+  margin: 2rem 0;
+}
+
+.rp-load-more-button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0.75rem 2rem;
+  background-color: var(--rp-primary-color);
+  color: white;
+  border-radius: var(--rp-border-radius);
+  font-weight: 600;
+  text-decoration: none;
+  transition: background-color 0.2s;
+  border: none;
+  cursor: pointer;
+}
+
+.rp-load-more-button:hover {
+  background-color: var(--rp-primary-hover);
+}
+
+.rp-load-more-button.loading {
+  opacity: 0.7;
+  cursor: wait;
+}
+
+@media (max-width: 640px) {
+  .rp-page-links {
+    display: none;
+  }
+  
+  .rp-pagination {
+    justify-content: space-between;
+    width: 100%;
+  }
+}

data/app/views/rails_pagination_ultimate/_tailwind_pro.html.erb

@@ -0,0 +1,35 @@
+<nav class="flex items-center justify-between border-t border-gray-200 px-4 sm:px-0">
+  <div class="-mt-px flex w-0 flex-1">
+    <% unless collection.first_page? %>
+      <%= link_to template.url_for(template.params.to_unsafe_h.merge(page: collection.prev_page)), class: "inline-flex items-center border-t-2 border-transparent pr-1 pt-4 text-sm font-medium text-gray-500 hover:border-gray-300 hover:text-gray-700" do %>
+        <svg class="mr-3 h-5 w-5 text-gray-400" viewBox="0 0 20 20" fill="currentColor" aria-hidden="true">
+          <path fill-rule="evenodd" d="M18 10a.75.75 0 01-.75.75H4.66l2.1 1.95a.75.75 0 11-1.02 1.1l-3.5-3.25a.75.75 0 010-1.1l3.5-3.25a.75.75 0 111.02 1.1l-2.1 1.95h12.59A.75.75 0 0118 10z" clip-rule="evenodd" />
+        </svg>
+        Previous
+      <% end %>
+    <% end %>
+  </div>
+  
+  <div class="hidden md:-mt-px md:flex">
+    <% windowed_page_numbers.each do |n| %>
+      <% if n == :gap %>
+        <span class="inline-flex items-center border-t-2 border-transparent px-4 pt-4 text-sm font-medium text-gray-500">...</span>
+      <% elsif n == collection.current_page %>
+        <span class="inline-flex items-center border-t-2 border-blue-500 px-4 pt-4 text-sm font-medium text-blue-600" aria-current="page"><%= n %></span>
+      <% else %>
+        <%= link_to n, template.url_for(template.params.to_unsafe_h.merge(page: n)), class: "inline-flex items-center border-t-2 border-transparent px-4 pt-4 text-sm font-medium text-gray-500 hover:border-gray-300 hover:text-gray-700" %>
+      <% end %>
+    <% end %>
+  </div>
+
+  <div class="-mt-px flex w-0 flex-1 justify-end">
+    <% unless collection.last_page? %>
+      <%= link_to template.url_for(template.params.to_unsafe_h.merge(page: collection.next_page)), class: "inline-flex items-center border-t-2 border-transparent pl-1 pt-4 text-sm font-medium text-gray-500 hover:border-gray-300 hover:text-gray-700" do %>
+        Next
+        <svg class="ml-3 h-5 w-5 text-gray-400" viewBox="0 0 20 20" fill="currentColor" aria-hidden="true">
+          <path fill-rule="evenodd" d="M2 10a.75.75 0 01.75-.75h12.59l-2.1-1.95a.75.75 0 111.02-1.1l3.5 3.25a.75.75 0 010 1.1l-3.5 3.25a.75.75 0 11-1.02-1.1l2.1-1.95H2.75A.75.75 0 012 10z" clip-rule="evenodd" />
+        </svg>
+      <% end %>
+    <% end %>
+  </div>
+</nav>

data/config/locales/en.yml

@@ -0,0 +1,12 @@
+en:
+  rails_pagination_ultimate:
+    previous: "« Previous"
+    next: "Next »"
+    first: "« First"
+    last: "Last »"
+    truncate: "..."
+    info:
+      one: "Displaying <b>1</b> %{entry_name}"
+      other: "Displaying %{entry_name} <b>%{first}&nbsp;-&nbsp;%{last}</b> of <b>%{total}</b>"
+      all: "Displaying <b>all %{total}</b> %{entry_name}"
+      without_count: "Displaying %{entry_name} <b>%{first}&nbsp;-&nbsp;%{last}</b>"

data/lib/generators/rails_pagination_ultimate/tailwind_generator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module RailsPaginationUltimate
+  module Generators
+    class TailwindGenerator < Rails::Generators::Base
+      source_root File.expand_path("../../../app/views/rails_pagination_ultimate", __dir__)
+
+      desc "Copies RailsPaginationUltimate Tailwind views to your application."
+
+      def copy_views
+        copy_file "_tailwind_pro.html.erb", "app/views/rails_pagination_ultimate/_pagination.html.erb"
+      end
+    end
+  end
+end

data/lib/rails_pagination_ultimate/action_view_helper.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module RailsPaginationUltimate
+  module ActionViewHelper
+    def paginate(collection, options = {})
+      return unless collection.respond_to?(:total_pages)
+      
+      paginator = Paginator.new(self, collection, options)
+      paginator.render
+    end
+
+    def page_entries_info(collection, options = {})
+      entry_name = options[:entry_name] || collection.model_name.human.downcase
+      entry_name = entry_name.pluralize if collection.total_count != 1
+      
+      if collection.total_pages == Float::INFINITY
+        first = collection.offset_value + 1
+        last = collection.offset_value + collection.length
+        return I18n.t("rails_pagination_ultimate.info.without_count", first: first, last: last, entry_name: entry_name).html_safe
+      end
+
+      if collection.total_pages < 2
+        I18n.t("rails_pagination_ultimate.info.all", total: collection.total_count, entry_name: entry_name).html_safe
+      else
+        first = collection.offset_value + 1
+        last = [collection.offset_value + collection.limit_value, collection.total_count].min
+        I18n.t("rails_pagination_ultimate.info.other", first: first, last: last, total: collection.total_count, entry_name: entry_name).html_safe
+      end
+    end
+
+    def per_page_select(collection, options = {})
+      choices = options[:choices] || [10, 25, 50, 100]
+      current_per = collection.limit_value
+      
+      template.content_tag(:div, class: "rp-per-page-container #{options[:class]}") do
+        template.concat template.content_tag(:span, options[:label] || "Show", class: "rp-label")
+        template.concat template.select_tag(:per, template.options_for_select(choices, current_per), 
+          class: "rp-select", 
+          onchange: "const url = new URL(window.location.href); url.searchParams.set('per', this.value); url.searchParams.set('page', 1); window.location.href = url.toString();")
+      end
+    end
+  end
+
+  class Paginator
+    attr_reader :template, :collection, :options, :current_page, :total_pages
+
+    def initialize(template, collection, options = {})
+      @template = template
+      @collection = collection
+      @options = options
+      @current_page = collection.current_page
+      @total_pages = collection.total_pages
+    end
+
+    def render
+      return "" if total_pages <= 1 && total_pages != Float::INFINITY
+
+      if options[:template]
+        return template.render(partial: options[:template], locals: { 
+          collection: collection, 
+          options: options, 
+          template: template,
+          windowed_page_numbers: windowed_page_numbers
+        })
+      end
+
+      case options[:type]
+      when :load_more
+        render_load_more
+      when :infinite_scroll
+        render_infinite_scroll
+      else
+        render_standard
+      end
+    end
+
+    private
+
+    def render_standard
+      nav_class = options[:theme] == :tailwind ? "flex items-center justify-center space-x-2 my-8" : "rp-pagination rp-standard #{options[:class]}"
+      
+      data = { 
+        controller: "rails-pagination",
+        keyboard: options[:keyboard],
+        history: options[:history]
+      }
+
+      template.content_tag(:nav, class: nav_class, aria: { label: "Pagination" }, data: data) do
+        template.concat first_link if options[:first_last] && total_pages != Float::INFINITY
+        template.concat prev_link
+        template.concat page_links if total_pages != Float::INFINITY
+        template.concat next_link
+        template.concat last_link if options[:first_last] && total_pages != Float::INFINITY
+      end
+    end
+
+    def first_link
+      label = options[:first_label] || I18n.t("rails_pagination_ultimate.first").html_safe
+      if collection.first_page?
+        cls = options[:theme] == :tailwind ? "px-4 py-2 border rounded-md text-gray-400 cursor-not-allowed hidden sm:inline-flex" : "rp-page rp-first disabled"
+        template.content_tag(:span, label, class: cls)
+      else
+        cls = options[:theme] == :tailwind ? "px-4 py-2 border rounded-md text-gray-700 hover:bg-gray-50 transition hidden sm:inline-flex" : "rp-page rp-first"
+        template.link_to(label, template.url_for(template.params.to_unsafe_h.merge(page: 1)), class: cls, data: { rel: "first" })
+      end
+    end
+
+    def last_link
+      label = options[:last_label] || I18n.t("rails_pagination_ultimate.last").html_safe
+      if collection.last_page?
+        cls = options[:theme] == :tailwind ? "px-4 py-2 border rounded-md text-gray-400 cursor-not-allowed hidden sm:inline-flex" : "rp-page rp-last disabled"
+        template.content_tag(:span, label, class: cls)
+      else
+        cls = options[:theme] == :tailwind ? "px-4 py-2 border rounded-md text-gray-700 hover:bg-gray-50 transition hidden sm:inline-flex" : "rp-page rp-last"
+        template.link_to(label, template.url_for(template.params.to_unsafe_h.merge(page: total_pages)), class: cls, data: { rel: "last" })
+      end
+    end
+
+    def render_load_more
+      return if collection.last_page?
+
+      template.content_tag(:div, class: "rp-pagination rp-load-more-container #{options[:class]}") do
+        template.link_to("Load More", template.url_for(template.params.to_unsafe_h.merge(page: collection.next_page)), 
+          class: "rp-load-more-button", 
+          remote: true,
+          data: { 
+            type: "load-more",
+            target: options[:target],
+            turbo_frame: options[:turbo_frame]
+          }
+        )
+      end
+    end
+
+    def render_infinite_scroll
+      return if collection.last_page?
+
+      template.content_tag(:div, class: "rp-pagination rp-infinite-scroll-container #{options[:class]}", 
+        data: { 
+          controller: "rp-infinite-scroll",
+          rp_infinite_scroll_url_value: template.url_for(template.params.to_unsafe_h.merge(page: collection.next_page)),
+          rp_infinite_scroll_target_value: options[:target]
+        }) do
+        template.content_tag(:div, options[:loading_text] || "Loading more...", class: "rp-infinite-scroll-loader")
+      end
+    end
+
+    def prev_link
+      label = options[:prev_label] || I18n.t("rails_pagination_ultimate.previous").html_safe
+      if collection.first_page?
+        cls = options[:theme] == :tailwind ? "px-4 py-2 border rounded-md text-gray-400 cursor-not-allowed" : "rp-page rp-prev disabled"
+        template.content_tag(:span, label, class: cls)
+      else
+        cls = options[:theme] == :tailwind ? "px-4 py-2 border rounded-md text-gray-700 hover:bg-gray-50 transition" : "rp-page rp-prev"
+        template.link_to(label, template.url_for(template.params.to_unsafe_h.merge(page: collection.prev_page)), class: cls, data: { turbo_frame: options[:turbo_frame], rel: "prev" })
+      end
+    end
+
+    def next_link
+      label = options[:next_label] || I18n.t("rails_pagination_ultimate.next").html_safe
+      if collection.last_page?
+        cls = options[:theme] == :tailwind ? "px-4 py-2 border rounded-md text-gray-400 cursor-not-allowed" : "rp-page rp-next disabled"
+        template.content_tag(:span, label, class: cls)
+      else
+        cls = options[:theme] == :tailwind ? "px-4 py-2 border rounded-md text-gray-700 hover:bg-gray-50 transition" : "rp-page rp-next"
+        template.link_to(label, template.url_for(template.params.to_unsafe_h.merge(page: collection.next_page)), class: cls, data: { turbo_frame: options[:turbo_frame], rel: "next" })
+      end
+    end
+
+    def page_links
+      container_cls = options[:theme] == :tailwind ? "flex space-x-1" : "rp-page-links"
+      template.content_tag(:div, class: container_cls) do
+        windowed_page_numbers.each do |n|
+          if n == :gap
+            cls = options[:theme] == :tailwind ? "px-4 py-2 text-gray-400" : "rp-page gap"
+            template.concat template.content_tag(:span, "...", class: cls)
+          elsif n == current_page
+            cls = options[:theme] == :tailwind ? "px-4 py-2 bg-blue-600 text-white rounded-md font-medium" : "rp-page current"
+            template.concat template.content_tag(:span, n, class: cls)
+          else
+            cls = options[:theme] == :tailwind ? "px-4 py-2 border rounded-md text-gray-700 hover:border-blue-600 hover:text-blue-600 transition" : "rp-page"
+            template.concat template.link_to(n, template.url_for(template.params.to_unsafe_h.merge(page: n)), class: cls, data: { turbo_frame: options[:turbo_frame] })
+          end
+        end
+      end
+    end
+
+    def windowed_page_numbers
+      return [] if total_pages == Float::INFINITY
+      window = options[:window] || 2
+      pages = []
+      
+      (1..total_pages).each do |n|
+        if n <= 1 || n >= total_pages || (n - current_page).abs <= window
+          pages << n
+        else
+          pages << :gap if pages.last != :gap
+        end
+      end
+      pages
+    end
+  end
+end

data/lib/rails_pagination_ultimate/active_record_extension.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module RailsPaginationUltimate
+  module ActiveRecordExtension
+    extend ActiveSupport::Concern
+
+    included do
+      scope :page, ->(num) {
+        num = num.to_i
+        num = 1 if num < 1
+        limit(default_per_page).offset(default_per_page * (num - 1)).extending(ActiveRecordModelExtension)
+      }
+
+      scope :without_count, -> {
+        extending(WithoutCountExtension)
+      }
+    end
+
+    module WithoutCountExtension
+    end
+
+    module ClassMethods
+      def default_per_page
+        RailsPaginationUltimate.config.default_per_page
+      end
+    end
+
+    module ActiveRecordModelExtension
+      def is_without_count?
+        singleton_class.included_modules.include?(WithoutCountExtension)
+      end
+
+      def per(num)
+        num = num.to_i
+        limit(num).offset(num * (current_page - 1))
+      end
+
+      def current_page
+        limit_val = limit_value || RailsPaginationUltimate.config.default_per_page
+        offset_val = offset_value || 0
+        (offset_val / limit_val) + 1
+      rescue StandardError
+        1
+      end
+
+      def total_pages
+        return Float::INFINITY if is_without_count?
+        
+        limit_val = limit_value || RailsPaginationUltimate.config.default_per_page
+        (total_count.to_f / limit_val).ceil
+      rescue StandardError
+        0
+      end
+
+      def total_count
+        return 0 if is_without_count?
+        
+        @total_count ||= begin
+          c = except(:offset, :limit, :order)
+          c = c.count
+          c.is_a?(Hash) ? c.count : c
+        end
+      end
+
+      def first_page?
+        current_page == 1
+      end
+
+      def last_page?
+        if is_without_count?
+          return !has_next_page?
+        end
+        current_page >= total_pages
+      end
+
+      def next_page
+        current_page + 1 unless last_page?
+      end
+
+      def prev_page
+        current_page - 1 unless first_page?
+      end
+
+      private
+
+      def has_next_page?
+        @_has_next_page ||= begin
+          limit_val = limit_value || RailsPaginationUltimate.config.default_per_page
+          # Fetch one extra record to see if there is a next page
+          records_count = except(:limit).limit(limit_val + 1).offset(offset_value).to_a.length
+          records_count > limit_val
+        end
+      end
+    end
+  end
+end

data/lib/rails_pagination_ultimate/configuration.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RailsPaginationUltimate
+  class Configuration
+    attr_accessor :default_per_page
+
+    def initialize
+      @default_per_page = 25
+    end
+  end
+
+  class << self
+    attr_accessor :configuration
+
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration)
+    end
+
+    def config
+      self.configuration ||= Configuration.new
+    end
+  end
+end

data/lib/rails_pagination_ultimate/engine.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RailsPaginationUltimate
+  class Engine < ::Rails::Engine
+    isolate_namespace RailsPaginationUltimate
+
+    initializer "rails_pagination_ultimate.active_record" do
+      ActiveSupport.on_load(:active_record) do
+        include RailsPaginationUltimate::ActiveRecordExtension
+      end
+    end
+
+    initializer "rails_pagination_ultimate.action_view" do
+      ActiveSupport.on_load(:action_view) do
+        require_relative "action_view_helper"
+        include RailsPaginationUltimate::ActionViewHelper
+      end
+    end
+  end
+end

data/lib/rails_pagination_ultimate/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RailsPaginationUltimate
+  VERSION = "1.0.1"
+end

data/lib/rails_pagination_ultimate.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "rails_pagination_ultimate/version"
+require_relative "rails_pagination_ultimate/configuration"
+require_relative "rails_pagination_ultimate/active_record_extension"
+require_relative "rails_pagination_ultimate/engine" if defined?(Rails)
+
+module RailsPaginationUltimate
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: rails_pagination_ultimate
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Shiboshree Roy
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: RailsPaginationUltimate provides a powerful and easy-to-use pagination
+  solution with modern UI/UX, responsive designs, and seamless Turbo/Hotwire integration.
+email:
+- shiboshreeroy169@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- app/assets/javascripts/rails_pagination_ultimate/loader.js
+- app/assets/stylesheets/rails_pagination_ultimate/main.css
+- app/views/rails_pagination_ultimate/_tailwind_pro.html.erb
+- config/locales/en.yml
+- lib/generators/rails_pagination_ultimate/tailwind_generator.rb
+- lib/rails_pagination_ultimate.rb
+- lib/rails_pagination_ultimate/action_view_helper.rb
+- lib/rails_pagination_ultimate/active_record_extension.rb
+- lib/rails_pagination_ultimate/configuration.rb
+- lib/rails_pagination_ultimate/engine.rb
+- lib/rails_pagination_ultimate/version.rb
+homepage: https://github.com/shiboshreeroy/rails_pagination_ultimate
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/shiboshreeroy/rails_pagination_ultimate
+  source_code_uri: https://github.com/shiboshreeroy/rails_pagination_ultimate
+  changelog_uri: https://github.com/shiboshreeroy/rails_pagination_ultimate/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.11
+specification_version: 4
+summary: A premium, responsive, and advanced pagination gem for Rails.
+test_files: []