priloo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 27caed3d2c1d94e1656f03f7a386f08743bc171a756c947e740fab37cc72dfcc
+  data.tar.gz: 97ac72a743a851842af6857114d6da6432c5b3b0c019f82d168013090a0997f7
+SHA512:
+  metadata.gz: 00f271d5ce1ade1f0759eae909ab030791e39125f23ff05a2e961e149641f75443b79762677c2d47facb099fd6b77280d7debab81f5add72bfa45c4b76863025
+  data.tar.gz: 1271bc3bacd58921bf52d69d3f2e324bd8bdb5b0dc92ead5deaed107608046130d653398a6bc7d6c10595a9740159e7dbf3613c8ddfb7700bc194a988af1f2e7

data/lib/preloader.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Preloader
+    module_function
+
+    def preload(*params)
+        ::Preloader::RecursiveInjector.new.inject(*params)
+    end
+
+    class PreloadFailure < BannermanException; end
+end

data/lib/priloo.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+require 'priloo/version'
+require 'priloo/recursive_injector'
+require 'priloo/preloadable'
+require 'priloo/dependencies'
+require 'priloo/preloaders/base_preloader'
+require 'priloo/preloaders/ar_association_preloader'
+require 'priloo/preloaders/bm_injector_preloader'
+require 'priloo/preloaders/collection_preloader'
+require 'priloo/preloaders/generic_preloader'
+require 'priloo/preloaders/navigating_preloader'
+require 'priloo/preloaders/nil_preloader'
+
+ActiveSupport.on_load(:active_record) do
+    require 'priloo/active_record_support'
+end
+
+module Priloo
+    def self.preload(*params)
+        RecursiveInjector.new.inject(*params)
+    end
+end
+
+module Enumerable
+    def priload(*args)
+        Priloo.preload(self, args)
+    end
+end

data/lib/priloo/active_record_support.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'active_record'
+
+module Priloo
+    module ActiveRecordSupport
+        def method_missing(method, *)
+            generate_priloo_method(method) || super
+        end
+
+        def respond_to_missing?(method, _)
+            !generate_priloo_method(method).nil? || super
+        end
+
+        PRILOO_SUFFIX_REGEX = /__priloo__\z/
+
+        def generate_priloo_method(method)
+            index = method =~ PRILOO_SUFFIX_REGEX
+            return unless index
+
+            property = method.slice(0, index).to_sym
+
+            preloader =
+                case
+                when self.class.reflect_on_association(property)
+                    Preloaders::ArAssociationPreloader.new(self.class, property)
+                when self.class.respond_to?("#{property}_sql")
+                    Preloaders::BmInjectorPreloader.new(self.class, property)
+                end
+
+            self.class.define_method(method) { preloader }
+
+            preloader
+        end
+
+        def _preloadable_target
+            self
+        end
+    end
+
+    ActiveRecord::Base.include(ActiveRecordSupport)
+end

data/lib/priloo/dependencies.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'tsort'
+
+module Priloo
+    class Dependencies
+        include TSort
+
+        def initialize(defs)
+            @defs = defs
+        end
+
+        def tsort_each_node(&block)
+            @defs.each_key(&block)
+        end
+
+        def tsort_each_child(node, &block)
+            @defs.fetch(node).each(&block)
+        end
+
+        def self.resolve(defs)
+            new(defs).tsort
+        end
+    end
+end

data/lib/priloo/preloadable.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'decors'
+
+module Priloo
+    module Preloadable
+        def self.included(base)
+            base.extend ClassMethods
+        end
+
+        # This method in only called in Preloaders::GenericPreloader
+        #
+        # Its purpose is to make sure instance variables are injected in the right instance,
+        # if it is behind a proxy (for instance, a SimpleDelegator). We cannot be 100% sure
+        # that the proxy will forward Object#instance_variable_set() properly
+        def _preloadable_target
+            self
+        end
+
+        def priloo_clearall
+            return unless instance_variable_defined?(Preloaders::GenericPreloader::PRIVATE_STORE_NAME)
+
+            remove_instance_variable(Preloaders::GenericPreloader::PRIVATE_STORE_NAME)
+        end
+
+        class PreloadDependencies < ::Decors::DecoratorBase
+            def initialize(*)
+                super
+
+                @preloader = Preloaders::GenericPreloader.new(
+                    decorated_method_name,
+                    dependencies: [*decorator_args, **decorator_kwargs]
+                ) { |list| list.map { |inst| undecorated_method.bind(inst._preloadable_target).call } }
+
+                decorated_class.declare_preloader(decorated_method_name, preloader)
+            end
+
+            def call(instance, *)
+                return preloader.extract(instance) if preloader.injected?(instance)
+
+                preloader.preload([instance].bm_preload(*decorator_args, **decorator_kwargs)).first
+            end
+
+            private
+
+            attr_reader :preloader
+        end
+
+        class PreloadBatch < ::Decors::DecoratorBase
+            def initialize(*)
+                super
+
+                clazz = ObjectSpace.each_object(decorated_class).first
+
+                preloader = Preloaders::GenericPreloader.new(
+                    decorated_method_name,
+                    dependencies: [*decorator_args, **decorator_kwargs]
+                ) { |list| undecorated_method.bind(clazz).call(list) }
+
+                clazz.declare_preloader(decorated_method_name, preloader)
+
+                clazz.send(:define_method, decorated_method_name) do
+                    return preloader.extract(self) if preloader.injected?(self)
+
+                    preloader.preload([self]).first
+                end
+            end
+        end
+
+        module ClassMethods
+            def preload_define(name, *dependencies, &block)
+                preloader = Preloaders::GenericPreloader.new(name, dependencies: dependencies, &block)
+                declare_preloader(name, preloader)
+
+                define_method(name) do
+                    return preloader.extract(self) if preloader.injected?(self)
+
+                    preloader.preload([self]).first
+                end
+            end
+
+            def preload_delegate(*names, to:, allow_nil: false, prefix: false)
+                names.each do |name|
+                    prefixed_name = prefix ? :"#{to}_#{name}" : name
+
+                    preload_define prefixed_name, to => name do |items|
+                        items.map do |item|
+                            through = item.send(to)
+                            raise "Cannot delegate #{name} to #{to} because Nil is not allowed" if !allow_nil && through.nil?
+
+                            through&.send(name)
+                        end
+                    end
+                end
+            end
+
+            def preload_ar(name, primary_key, ar_class_name, foreign_key)
+                preload_define name do |items|
+                    ids = items.map { |item| item.send(primary_key) }.compact.uniq
+                    data = ar_class_name.constantize.where(foreign_key => ids).map { |c| [c.send(foreign_key), c] }.to_h
+                    items.map { |item| data[item.send(primary_key)] }
+                end
+            end
+
+            def preload_many_ar(name, primary_keys, ar_class_name, foreign_key)
+                preload_define name do |items|
+                    ids = items.map { |item| item.send(primary_keys) }.flatten.compact.uniq
+                    data = ar_class_name.constantize.where(foreign_key => ids).map { |c| [c.send(foreign_key), c] }.to_h
+                    items.map { |item| item.send(primary_keys)&.map { |pk| data[pk] } }
+                end
+            end
+
+            extend Decors::DecoratorDefinition
+
+            define_mixin_decorator :PreloadDependencies, PreloadDependencies
+            define_mixin_decorator :PreloadBatch, PreloadBatch
+
+            def declare_preloader(name, preloader)
+                define_method(:"#{name}__priloo__") { preloader }
+            end
+        end
+    end
+end

data/lib/priloo/preloaders/ar_association_preloader.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Priloo
+    module Preloaders
+        # This class implements preloading for ActiveRecord associations
+        class ArAssociationPreloader < BasePreloader
+            attr_reader :ar_class, :name
+
+            def initialize(ar_class, name)
+                super([self.class, ar_class, name])
+
+                @name = name
+                @ar_class = ar_class
+            end
+
+            def injected?(target)
+                target.association_cached?(name)
+            end
+
+            def extract(target)
+                target.send(name)
+            end
+
+            def preload(ar_list)
+                # Rails does not provide any way to preload an association without immediately
+                # storing the result in the instances.
+                ActiveRecord::Associations::Preloader.new.preload(ar_list.map(&:_preloadable_target), name)
+                ar_list.map(&name)
+            end
+        end
+    end
+end

data/lib/priloo/preloaders/base_preloader.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Priloo
+    module Preloaders
+        class BasePreloader
+            attr_reader :merge_key
+
+            def initialize(merge_key)
+                @merge_key = merge_key
+            end
+
+            def multiplicity
+                0
+            end
+
+            def injected?(_target)
+                false
+            end
+
+            def preload(instances)
+                instances
+            end
+
+            def inject(_target, _value); end
+
+            def dependencies
+                []
+            end
+        end
+    end
+end

data/lib/priloo/preloaders/bm_injector_preloader.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Priloo
+    module Preloaders
+        # This class implements preloading for Bannerman's custom ActiveRecord injectors
+        class BmInjectorPreloader < BasePreloader
+            attr_reader :ar_class, :name
+
+            def initialize(ar_class, name)
+                super([self.class, ar_class, name])
+
+                @name = name
+                @ar_class = ar_class
+            end
+
+            def preload(ar_list)
+                ids = ar_list.map { |ar| ar.send(primary_key) }
+                injector_sql = ar_class.send("#{name}_sql")
+                sql_query = Arel.sql <<~SQL
+                    #{quote_table_column(ar_class.table_name, primary_key)} AS id,
+                    (#{injector_sql}) AS val
+                SQL
+
+                fetched_data = ar_class.where(primary_key => ids.uniq).pluck(sql_query).to_h
+                ar_list.map { |ar| fetched_data[ar.send(primary_key)] }
+            end
+
+            def inject(target, value)
+                target._preloadable_target.send(:write_attribute_without_type_cast, name, value)
+            end
+
+            def injected?(target)
+                target.has_attribute?(name)
+            end
+
+            def extract(target)
+                target.instance_variable_get(:@attributes).[](name).value
+            end
+
+            private
+
+            def quote_identifier(str)
+                ar_class.connection.quote_column_name str.to_s
+            end
+
+            def quote_table_column(table, column)
+                quote_identifier(table) + '.' + quote_identifier(column)
+            end
+
+            def primary_key
+                @primary_key ||= ar_class.primary_key.to_sym
+            end
+        end
+    end
+end

data/lib/priloo/preloaders/collection_preloader.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module Priloo
+    module Preloaders
+        class CollectionPreloader < BasePreloader
+            include Singleton
+
+            def initialize
+                super(self.class)
+            end
+
+            def multiplicity
+                1
+            end
+        end
+    end
+end

data/lib/priloo/preloaders/generic_preloader.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Priloo
+    module Preloaders
+        class GenericPreloader < BasePreloader
+            attr_reader :name, :block, :dependencies
+
+            PRIVATE_STORE_NAME = :@preloader_private_store
+
+            def initialize(name, dependencies: [], &block)
+                super(self)
+                @name = name
+                @dependencies = dependencies
+                @block = block
+            end
+
+            def preload(instances)
+                block[instances]
+            end
+
+            def injected?(target)
+                fetch_store(target)&.key?(name) || false
+            end
+
+            def extract(target)
+                fetch_store(target).fetch(name)
+            end
+
+            def inject(target, value)
+                fetch_or_create_store(target)[name] = value
+            end
+
+            private
+
+            def fetch_store(target)
+                target._preloadable_target.instance_variable_get(PRIVATE_STORE_NAME)
+            end
+
+            def fetch_or_create_store(target)
+                obj = target._preloadable_target
+                return fetch_store(target) if obj.instance_variable_defined?(PRIVATE_STORE_NAME)
+
+                store = {}
+                obj.instance_variable_set(PRIVATE_STORE_NAME, store)
+                store
+            end
+        end
+    end
+end

data/lib/priloo/preloaders/navigating_preloader.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Priloo
+    module Preloaders
+        class NavigatingPreloader < BasePreloader
+            attr_reader :name
+
+            def initialize(name)
+                super([self.class, name])
+
+                @name = name
+            end
+
+            def preload(instances)
+                instances.map { |inst| extract(inst) }
+            end
+
+            def extract(target)
+                return target[name] if target.is_a?(Hash)
+                return target.send(name) if target.respond_to?(name)
+            end
+        end
+    end
+end

data/lib/priloo/preloaders/nil_preloader.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Priloo
+    module Preloaders
+        class NilPreloader < BasePreloader
+            include Singleton
+
+            def initialize
+                super(self)
+            end
+
+            def preload(instances)
+                Array.new(instances.size)
+            end
+        end
+    end
+end

data/lib/priloo/recursive_injector.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Priloo
+    class RecursiveInjector
+        def inject(list, *path)
+            inject_deep(list.to_a, canonicalize(path))
+            list
+        end
+
+        private
+
+        # Little wrapper for 'inject_deep' implementing support for list-of-lists.
+        # The input list will be flattened 'multiplicity' times.
+        #
+        # 1- Flatten the input 'list' such that it can be handled by 'inject_deep'
+        # 2- Call 'inject_deep'
+        # 3- Un-flatten the preloaded output
+        def inject_deep_flat(list, remaining_path, multiplicity)
+            return inject_deep(list, remaining_path) if multiplicity == 0
+
+            flat_input = list.flat_map { |v| v.nil? ? [] : v }
+            flat_output = inject_deep_flat(flat_input, remaining_path, multiplicity - 1)
+            item_index = -1
+            list.map { |v| v&.map { flat_output[item_index += 1] } }
+        end
+
+        # Extract the necessary preloads & resolve their dependencies.
+        #
+        # Return:
+        # - A new 'resolved_paths' including all recursively resolved dependencies, ordered appropriately.
+        # - A two-level list of preloaders[key_index][item_index] (every key/item couple gets its own preloader)
+        def resolve_dependencies(list, paths)
+            dependencies = {}
+            preloaders = {}
+            undiscovered = paths.keys
+
+            until undiscovered.empty?
+                undiscovered.each do |dep|
+                    dependencies[dep] = Set.new
+                    preloaders[dep] = list.map { |item| find_preloader(item, dep) }
+
+                    deps = preloaders[dep].uniq(&:merge_key)
+                                          .reject { |preloader| preloader.is_a?(Preloaders::NilPreloader) }
+                                          .map { |p| canonicalize(p.dependencies) }
+                                          .uniq
+
+                    if deps.size > 1
+                        # This is a limitation of the current implementation, and at some point we will have to
+                        # fix it otherwise it could prevent some things to be done.
+                        raise NotImplementedError, 'Different dependencies at the same level are not supported'
+                    end
+
+                    deps.each do |d|
+                        dependencies[dep] += d.keys
+                        paths = paths.deep_merge(d)
+                    end
+                end
+
+                undiscovered = paths.keys - dependencies.keys
+            end
+
+            order = Dependencies.resolve(dependencies)
+
+            resolved_paths = order.map { |key| [key, paths[key]] }.to_h
+            preloaders = order.map { |key| preloaders[key] }
+
+            [resolved_paths, preloaders]
+        end
+
+        PreloadedValue = Struct.new(:multiplicity, :index, :value)
+
+        def preload_single_key(list, preloaders)
+            list.each_with_index
+                .group_by { |_item, item_idx| preloaders[item_idx].merge_key }
+                .flat_map do |_merge_key, indexed_items|
+                    preloader = preloaders[indexed_items.first.last]
+                    items = indexed_items.map(&:first)
+                    preload_items(preloader, items).each_with_index.map do |value, value_idx|
+                        PreloadedValue.new(preloader.multiplicity, indexed_items[value_idx][1], value)
+                    end
+                end
+        end
+
+        def preload_items(preloader, items)
+            map_by_group items,
+                group_by: ->(x) { preloader.injected?(x) },
+                map_to: ->(injected, filtered_items) {
+                    next filtered_items.map { |x| preloader.extract(x) } if injected
+
+                    preloader.preload(filtered_items).tap do |preloaded_values|
+                        filtered_items.each_with_index do |item, index|
+                            preloader.inject(item, preloaded_values[index])
+                        end
+                    end
+                }
+        end
+
+        def preload_next_level(preloaded_values, next_level)
+            next_values = Array.new(preloaded_values.size)
+
+            preloaded_values.group_by(&:multiplicity)
+                            .flat_map do |multiplicity, grouped_preloaded_values|
+                values = grouped_preloaded_values.map(&:value)
+                results = inject_deep_flat(values, next_level, multiplicity)
+
+                results.each_with_index do |result, result_index|
+                    next_values[grouped_preloaded_values[result_index].index] = result
+                end
+            end
+
+            next_values
+        end
+
+        # Preload dependencies at top level and recursively preload next levels
+        def inject_deep(list, paths)
+            resolved_paths, preloaders = resolve_dependencies(list, paths)
+
+            resolved_paths.each_with_index do |(_key, next_level), key_idx|
+                # We preload the key for every item
+                preloaded_values = preload_single_key(list, preloaders[key_idx])
+
+                # We recursively preload the next level
+                preload_next_level(preloaded_values, next_level)
+            end
+
+            list
+        end
+
+        def map_by_group(list, group_by: proc { nil }, map_to: proc { |_g, v| v })
+            output = Array.new(list.size)
+
+            list.each_with_index.group_by { |item, _idx| group_by[item] }
+                .each do |group_key, input_items|
+                    input_items_values = input_items.map(&:first)
+                    result = map_to[group_key, input_items_values]
+
+                    raise 'Mapper should return same number of rows' unless result.size == input_items.size
+
+                    result.each_with_index do |result_item, result_idx|
+                        input_item = input_items[result_idx]
+                        input_item_idx = input_item.last
+
+                        output[input_item_idx] = result_item
+                    end
+                end
+
+            output
+        end
+
+        # Find a preloader for any object
+        def find_preloader(item, property)
+            return Preloaders::NilPreloader.instance if item.nil?
+
+            method = :"#{property}__priloo__"
+            preloader = item.send(method) if item.respond_to? method
+            preloader ||= Preloaders::CollectionPreloader.instance if property == :__each__ && item.is_a?(Enumerable)
+            preloader ||= Preloaders::NavigatingPreloader.new(property)
+            raise "Cannot find any preloader for property '#{property}' of #{item}" unless preloader
+
+            preloader
+        end
+
+        # Transform a user-friendly path into a canonicalized form more suitable to further processing (idempotent)
+        #
+        # User-friendly: [:a, :b, {c: [:d], b: :x}]
+        # Canonicalized: {:a=>{}, :b=>{:x=>{}}, :c=>{:d=>{}}}
+        def canonicalize(path)
+            case path
+            when Array then path.reduce({}) { |a, p| a.merge(canonicalize(p)) }
+            when Hash then path.map { |k, v| [k.to_sym, canonicalize(v)] }.to_h
+            else { path.to_sym => {} }
+            end
+        end
+    end
+end

data/lib/priloo/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Priloo
+    VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,170 @@
+--- !ruby/object:Gem::Specification
+name: priloo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Frederic Terrazzoni
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-11-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bm-typed
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.59.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.59.2
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.1
+- !ruby/object:Gem::Dependency
+  name: decors
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+description: A generalized Rails-like preloader
+email:
+- frederic.terrazzoni@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/preloader.rb
+- lib/priloo.rb
+- lib/priloo/active_record_support.rb
+- lib/priloo/dependencies.rb
+- lib/priloo/preloadable.rb
+- lib/priloo/preloaders/ar_association_preloader.rb
+- lib/priloo/preloaders/base_preloader.rb
+- lib/priloo/preloaders/bm_injector_preloader.rb
+- lib/priloo/preloaders/collection_preloader.rb
+- lib/priloo/preloaders/generic_preloader.rb
+- lib/priloo/preloaders/navigating_preloader.rb
+- lib/priloo/preloaders/nil_preloader.rb
+- lib/priloo/recursive_injector.rb
+- lib/priloo/version.rb
+homepage: https://github.com/getbannerman/priloo
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: A generalized Rails-like preloader
+test_files: []