Lazy Load

HexaPDF is a pure Ruby library with an accompanying application for working with PDF files. In short, it allows creating new PDF files, manipulating existing PDF files, merging multiple PDF files into one, extracting meta information, text, images and files from PDF files, securing PDF files by encrypting them and optimizing PDF files for smaller file size or other criteria. HexaPDF was designed with ease of use and performance in mind. It uses lazy loading and lazy computing when possible and tries to produce small PDF files by default.

lazyload-rails integrates jQuery's Lazy Load Plugin with Rails image_tag helpers

A Rails plugin that defers loading the whole bloody routes so the app can spin up quickly

Uses custom html elements with attached IntersectionObserver to automatically lazy load partials via websockets

This plugin lets you define specific columns in ActiveRecord models to be loaded lazily

Loading Lazy automatically adds loading="lazy" to <img> and <iframe> tags on your Jekyll site.

An extension of Ruby's core OpenStruct, providing deep objectification and lazy loading.

Why make the browser load images that the user isn't going to see? This Rails engine prevents images from loading until they're actually going to be displayed. This saves bandwidth, reduces server load, and helps the user stay under their data quota.

Lazy loaded vertical code slices based on ActiveSupport Dependencies.

Lazy loaded images for rails

A DataMapper adapter for Amazon's SimpleDB service. Features: * Full set of CRUD operations * Supports all DataMapper query predicates. * Can translate many queries into efficient native SELECT operations. * Migrations * DataMapper identity map support for record caching * Lazy-loaded attributes * DataMapper Serial property support via UUIDs. * Array properties * Basic aggregation support (Model.count("...")) * String "chunking" permits attributes to exceed the 1024-byte limit Note: as of version 1.0.0, this gem supports supports the DataMapper 0.10.* series and breaks backwards compatibility with DataMapper 0.9.*.

Edit img tag optimized lazy load images for your Jekyll site

angular-translate is an AngularJS module that makes your life much easier when it comes to i18n and l10n including lazy loading and pluralization This gem allows for its easy inclusion into the rails asset pipeline.

easy to use File loader that allow directories/project both Lazy Load and Eager load for files and constants. The Eager load for relative directory made for gems by default

LittleBoxes is a light library that provides a dependency tree that represents your application configuration. It automatically configures your dependencies and lazy-loads by default.

It delays loading of partial or actions in views.

Makes Activerecord Observers lazy, do not load model on startup and only listen once a model got loaded.

Gem that adds lazy method delegation methods. Using this gem you can easily define lazy loading or asynchronous versions of specific methods. Lazy loading is useful when used with caching systems while asynchronous methods can improve throughput on I/O bound processes like making several HTTP calls in row.

A lazy-loading, Array-like collection proxy for ActiveRecord that understands conditions and paging.

A belongs to-like field that lazily loads candidates from a custom endpoint.

Simple parametable object creator with lazy loading options. Objects can be hashable and optionally convert all values to strings.

It is very easy to enable lazy loading of partial with scroll in views

LazyLoad is a slightly more elaborate alternative to the autoload method. It provides custom callbacks, "best available" dependency selection, and an optional simple wrapper mechanism.

lazy loading image will be helpful to improve performance

lazy load bootstrap modal when needed!

Lazy loading of 'interesting' ActiveRecord model id's, thread-safely and with easy cache reset and lazy creation in testing

"LJAX" (= Lazy load Ajax) on Rails

A little gem for Rails that provides the ability to specify attributes that will not be loaded when the record is loaded from the database, until you explicitly refer to those attributes. This is useful when you have a lot of text columns in your table; in this case lazy-loading the text attributes is a good way to lend your server a hand and cut down on database access time.

A lazy-loading, Array-like collection proxy for ActiveRecord that understands conditions and paging.

Lazy executor for activerecord associations and graphql gem.

This gem is an Object.descendants and Object.subclasses loader. The desired classes will have an autoload of its hierarchy. This aims a problem with lazy loading ruby classes (usually under development environment). For more information please check README.

Custom renderer of the redcarpet to add loading attribute to <img>. "lazy", "auto", and "eager" are available.

The applied usage of the Jquery LazyImage plugin. Block container with lazy &lt;img&gt; inside has transparent background and animated loader.gif placed in its center. User sees loader.gif til the original image is loaded. It's supposed that the placeholder given by the src attribute of the lazy &lt;img&gt; is fully transparent gif which width and height are equivalented to width and height of original image (to avoid jumping layout). You can find the sample of described code snippet on the gem`s homepage.

LazyLoadingPage loads heay pages lazily as and when required. Single heavy request is broken in small requests, so no timeouts and no congestion of requests. The gem reduces page load time and reduces server ram by loading important content of the page in the first call and then by triggering calls to load the remaining page. The gem gives Reactjs like functionality in your ruby-on-rails application.

Memoize attributes in a thread-safe way. This ruby gem adds a `#attr_memoized` class method, that provides a lazy-loading mechanism for initializing "heavy" attributes, but in a thread-safe way. Instances thus created can be shared among threads.

You've seen Getopt::Long, OptionParser, Thor? What the world needs now is one more command-line parser. This serves as a backend command line parser that passes the option-parsing portion of it off to OptionParser, Trollop, or any other option-parser that has an adapter[^adapter]. But the parts it *does* do are really exciting: It features arbitrarily deeply nested subcommands, optionally colorized help screens with smart formatting, automatically generated usage syntaxes, manpage generation[^maybe2], lazy-loading of subcommands, and (get this:) you can turn your command line app into a web app. (is processing a form then displaying a record really that different from CLI that does the same?)[^maybe3]

lazy loading, e.g. Simple::Lazy.new(1) { |id| User.find(id) }

ActiveRecord plugin to load specified attributes lazyly

Avoid high server loads by making images load lazily

Adds browser-native loading="lazy" attribute to images and iframes rendered by Camaleon CMS.

LazyLoadingPage loads heavy pages lazily that is as and when required. Single heavy request is broken in small requests, so no timeouts and no congestion of requests. The gem reduces page load time and reduces server ram by loading important content of the page in the first call and then by triggering calls to load the remaining page. The gem give Reactjs like functionality in your ruby-on-rails application.

Ensure load hooks can be called more than once with different contexts

Make your website faster by deferring loading of images.

A has many to-like field that lazily loads candidates from a custom endpoint.

Lazy As Json A simple and concise way to use as_json with “only”, “except” and other options without using them literally. Instead of using this - `User.as_json(only: [:id, :first_name, profiles: [:company, :location]])` You can perhaps use this - `User.as_json(only_keys: ‘_,first_name,profiles(p),p.company,p.location’)` As simple as this. You can control what your API response should include through a flexible parameter string. i.e. - “/api/v1/users/me?_keys=_,last_name,profiles(p),p.company,p.location” This parameter string could dig through the nested objects and their nesting too. Just to reduce the API response size significantly, you can use this parameter control over wherever it is used. However it might seems quite trivial but frankly speaking it saves lot in response data hence faster loading time at client side. Moreover as it uses Hash.new and constructs attribute on runtime, you can throttle calling from the expensive method by using this parameter string.

angular-translate is an AngularJS module that makes your life much easier when it comes to i18n and l10n including lazy loading and pluralization This gem allows for its easy inclusion into the rails asset pipeline.

Infinite scroll page lazy loading plugin for Ruby on Rails

Lazy load your attributes for any class object

RailheadLazyColumns lets load columns lazy

Gem for loading images lazily using echo js library