bootinq 1.7 → 2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab4d92e0581dec34e3b8c35ab842953fc6c488a7ff7a79aab4e155e0ec04b598
-  data.tar.gz: 8d1b03413cb95941d3c34fa33e5167ae717a1152fb824f9fc4ca4c95232e3374
+  metadata.gz: e1652380ae399a299061b4faa8b2372fec798e02ce9f1fc9b3ab3b1a035d779e
+  data.tar.gz: d2339a8385fad5b4aaca89a5c2992f0adf4c5205bb650a05eb2b92e52daa349f
 SHA512:
-  metadata.gz: 957af1a041fb5230543b149ae7bb3fa14b455e0070232c60afe617c6dfce34712d3d9ea118aad38d2fd824ef253cb6af38a1e4a115d9f5862a2680ce4d2a48e2
-  data.tar.gz: 3dcecd28f93e44b34e7401fb6c4702754f57cac19706996a74fdbc306a9251d0fd7f8360afcd07470d37627461af4ecf1ea45e03f626b52543123d1991453d72
+  metadata.gz: a08526e07966f344034a18f42d032a996ab5fc97db980b3a356a3b0b4173b6e6d98ecc345a6ab80d77ec7f9e30aca2641e75b029553a3c3d45bfbceaf1ab5c8d
+  data.tar.gz: 850ee258bc77e6889b7a3ee5969f4befdf1ff217cb5eb1f5e70af1a3bce7b0c6c0191d2c0a87a7e5ce3d6d8f42611a3480f19bde7b7b002695133d39413eca60

data/.yardopts

@@ -0,0 +1,8 @@
+--db .yardoc \
+--markup-provider commonmarker \
+--markup markdown \
+--no-single-db \
+--no-cache \
+--no-document \
+--embed-mixins \
+--hide-void-return

data/Gemfile

@@ -26,6 +26,8 @@ end
 group :development do
   # You don't need these, but I use them
   gem "awesome_print"
+  gem "commonmarker", require: false
+  gem "yard"
 end
 
 group :shared_boot do

data/lib/bootinq/mixins.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+class Bootinq
+  # When just required, hooks {Bootinq#enable_component} method to
+  # generate fast inline wrapping methods.
+  #
+  # @see Mixins#enable_component
+  #
+  # @example Usage
+  #   require 'bootinq'
+  #   require 'bootinq/mixins'
+  module Mixins
+    # @api private
+    module ComputeNameMethod
+      DASH = '_'
+
+      private_constant :DASH
+
+      def compute_name(component_name)
+        component_name.to_s.split(DASH).
+          each(&:capitalize!).
+          join << @name_suffix
+      end
+    end
+
+    private_constant :ComputeNameMethod
+
+    # @api private
+    class Enabled < ::Module
+      @name_suffix = 'EnabledMixin'
+      extend ComputeNameMethod
+
+      def initialize(module_name, component_name)
+        module_eval <<~RUBY, __FILE__, __LINE__ + 1
+        # Yields the block due to component is enabled
+        # @yield [void]
+        def on_#{component_name}(*)
+          yield
+        end
+
+        # Does nothing due to component is enabled
+        # @return [void]
+        def not_#{component_name}(*)
+        end
+        RUBY
+      end
+    end
+
+    private_constant :Enabled
+
+    # @api private
+    class Disabled < ::Module
+      @name_suffix = 'DisabledMixin'
+      extend ComputeNameMethod
+
+      def initialize(module_name, component_name)
+        define_method(:name, module_name.method(:itself))
+
+        module_eval <<~RUBY, __FILE__, __LINE__ + 1
+        # Does nothing due to component is disabled
+        # @return [void]
+        def on_#{component_name}(*)
+        end
+
+        # Yields the block due to component is disabled
+        # @yield [void]
+        def not_#{component_name}(*)
+          yield
+        end
+        RUBY
+      end
+    end
+
+    private_constant :Disabled
+
+    Builder = -> (component_name, enabled) do
+      klass = enabled ? Enabled : Disabled
+      module_name = klass.compute_name(component_name).freeze
+
+      if Bootinq.const_defined?(module_name)
+        Bootinq.const_get(module_name)
+      else
+        Bootinq.const_set(module_name, klass.new(module_name, component_name))
+      end
+    end
+
+    private_constant :Builder
+
+    # Generates {Enabled} or {Disabled} mixin and sets it to a constant once,
+    # bypassing if it has been already defined.
+    # @yield [component_name, enabled]
+    # @return [void]
+    def enable_component(name, **opts)
+      super(name, **opts) do |component_name, enabled|
+        Bootinq.extend Builder[component_name, enabled]
+        yield(component_name, enabled) if block_given?
+      end
+    end
+  end
+
+  prepend Mixins
+end

data/lib/bootinq/railtie.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'rails'
+
+class Bootinq
+  # Require `bootinq/railtie` in the `before_configuration` block of your
+  # application definition to allow load component-scoped config paths
+  # only when the named component is enabled:
+  #
+  #   - `config/routes.rb` → `config/routes.component.rb`
+  #   - `config/locales` → `config/locales.component`
+  #   - `config/initializers` → `config/initializers.component`
+  #
+  # It doesn't affect on the default paths without suffix.
+  #
+  # @example
+  #   # config/application.rb
+  #   module Example
+  #     class Application < Rails::Application
+  #       config.before_configuration do
+  #         require 'bootinq/railtie'
+  #       end
+  #     end
+  #   end
+  class Railtie < ::Rails::Railtie
+    initializer 'bootinq.add_locales', before: :add_locales do |app|
+      Bootinq.components.each do |component|
+        app.paths["config/locales"] << "config/locales.#{component.name}"
+      end
+    end
+
+    initializer 'bootinq.load_config_initializers', before: :load_config_initializers do |app|
+      Bootinq.components.each do |component|
+        app.paths["config/initializers"] << "config/initializers.#{component.name}"
+      end
+    end
+
+    initializer 'bootinq.add_routing_paths', before: :add_routing_paths do |app|
+      Bootinq.components.each do |component|
+        app.paths["config/routes.rb"] << "config/routes.#{component.name}.rb"
+      end
+    end
+  end
+end

data/lib/bootinq/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Bootinq
-  VERSION = "1.7"
+  VERSION = "2.0"
 end

data/lib/bootinq.rb

@@ -6,25 +6,21 @@ require "forwardable"
 require "bootinq/component"
 require "bootinq/switch"
 
-# = Bootinq
+# # Bootinq
 #
-# == Installation
+# ## Installation
 #
-# === Ruby on Rails
+# ### Ruby on Rails
 #
-# 1. Insert <tt>require "bootinq"</tt> in the top of <tt>config/application.rb</tt>
+#   1. insert `require "bootinq"` on top of `config/application.rb`;
+#   2. find and replace `Bundler.require(*Rails.groups)` with `Bootinq.require`
 #
-# 2. Find <tt>Bundler.require(*Rails.groups)</tt> line below and replace it
-#    with the <tt>Bootinq.require</tt>.
+# ### Other frameworks
 #
-# === Other
-#
-# 1. Locate <tt>Bundler.require(...)</tt> in your app and insert <tt>require "bootinq"</tt> above.
-#
-# 2. Replace located <tt>Bundler.require(...)</tt> line with the <tt>Bootinq.require(...)</tt>.
-#
-# For example, if you are using Grape:
+#   1. locate `Bundler.require(…)` in your app and insert `require "bootinq"` above it;
+#   2. replace previosly located `Bundler.require(…)` line with the `Bootinq.require(…)`.
 #
+# @example Grape
 #     # config/application.rb
 #
 #     require 'boot'
@@ -32,10 +28,8 @@ require "bootinq/switch"
 #
 #     # Bundler.require :default, ENV['RACK_ENV']
 #     Bootinq.require :default, ENV['RACK_ENV'], verbose: true
-#     ...
-#
-# == Example <tt>config/bootinq.yml</tt>:
 #
+# @example config/bootinq.yml
 #     env_key: BOOTINQ
 #     default: a
 #
@@ -49,7 +43,6 @@ require "bootinq/switch"
 #     deps:
 #       shared:
 #         in: af
-#
 class Bootinq
   include Singleton
 
@@ -75,51 +68,96 @@ class Bootinq
 
   private_constant :FilterNegValue
 
-  # :call-seq:
-  #   Bootinq.require(*groups, verbose: false, &block)
-  #
-  # Invokes the <tt>Bootinq.init</tt> method with the given verbose key argument & block,
-  # and, finally, makes Bundler to require the given groups.
-  def self.require(*groups, verbose: false, &block) # :yields: Bootinq.instance
-    init(verbose: verbose, &block)
+  # Invokes the {init} method with the given options and block,
+  # then calls {Bundler.require} with the enabled groups.
+  # @see init
+  # @see Bundler.require
+  # @param groups [Array<Symbol>]
+  # @param options [Hash]
+  #   initialization options
+  # @option options [Boolean] verbose
+  #   track inquired components
+  # @option options [Proc] on_ready
+  #   optional ready callback proc
+  # @return [void]
+  def self.require(*groups, **options, &on_ready)
+    init(**options, &on_ready)
     Bundler.require(*instance.groups(*groups))
   end
 
-  # :call-seq:
-  #   Bootinq.setup(*groups, verbose: false, &block)
-  #
-  # Invokes the <tt>Bootinq.init</tt> method with the given verbose key argument & block,
-  # and, finally, makes Bundler to setup the given groups.
-  def self.setup(*groups, verbose: false, &block) # :yields: Bootinq.instance
-    init(verbose: verbose, &block)
+  # Invokes the {init} method with the given options and block,
+  # then calls {Bundler.require} with the enabled groups.
+  # @see init
+  # @see Bundler.setup
+  # @param groups [Array<Symbol>]
+  # @param options [Hash]
+  #   initialization options
+  # @option options [Boolean] verbose
+  #   track inquired components
+  # @option options [Proc] on_ready
+  #   optional ready callback proc
+  # @yield [instance]
+  # @return [void]
+  def self.setup(*groups, **options, &on_ready) # :yields: Bootinq.instance
+    init(**options, &on_ready)
     Bundler.setup(*instance.groups(*groups))
   end
 
-  # :call-seq:
-  #   Bootinq.init(verbose: false, &block) -> true or false
-  #
-  # Initializes itself. Sets the BOOTINQ_PATH enviroment variable if it is missing.
-  # To track inquired components use <tt>verbose: true</tt> key argument.
-  # Optionally yields block within the own instance's binding.
-  def self.init(verbose: false, &block) # :yields: Bootinq.instance
+  # Sets `BOOTINQ_PATH` enviroment variable if it is missing & initializes itself
+  # @overload init(verbose: false, on_ready:)
+  # @overload init(verbose: false, &on_ready)
+  # @param verbose [Boolean]
+  #   track inquired components
+  # @param on_ready [Proc]
+  #   optional ready callback proc
+  # @return [instance]
+  def self.init(verbose: false, on_ready: nil, &block)
     ENV['BOOTINQ_PATH'] ||= File.expand_path('../bootinq.yml', caller_locations(2, 1)[0].path)
 
     instance
-    instance.instance_variable_set(:@_on_ready, block.to_proc) if block_given?
+    on_ready = block.to_proc if on_ready.nil? && block_given?
+    instance.instance_variable_set(:@_on_ready, on_ready.to_proc) if on_ready
+
     puts "Bootinq: loading components #{instance.components.join(', ')}" if verbose
+
     instance.ready!
   end
 
-  # Reads config from the given or default path, deserializes it and returns as a hash.
+  # Reads config
+  # @param path [String]
+  #   path to yaml config (default: ENV['BOOTINQ_PATH'])
+  # @return [Hash]
+  #   deserializes yaml config
   def self.deserialized_config(path: nil)
     bootinq_yaml = File.read(path || ENV.fetch('BOOTINQ_PATH'))
-    YAML.safe_load(bootinq_yaml, [Symbol])
+    psych_safe_load(bootinq_yaml, [Symbol])
+  end
+
+  # @api private
+  if RUBY_VERSION >= '3.1.0'
+    def self.psych_safe_load(path, permitted_classes)
+      YAML.safe_load(path, permitted_classes: permitted_classes)
+    end
+  else
+    def self.psych_safe_load(*args)
+      YAML.safe_load(*args)
+    end
   end
 
+  private_class_method :psych_safe_load
+
+  # @!attribute flags [r]
+  #   @return [Array<String>]
+
   attr_reader :flags
+
+  # @!attribute components [r]
+  #   @return [Array<String>]
+
   attr_reader :components
 
-  def initialize # :no-doc:
+  # @return [self]
+  def initialize
     config = self.class.deserialized_config
     config.merge!(DEFAULT) { |_, l, r| l.nil? ? r : l }
 
@@ -135,172 +173,235 @@ class Bootinq
     config['mount'].each { |flag, name| enable_component(name, flag: flag.to_s, as: Mountable) }
   end
 
-  def ready? # :no-doc:
+  # @return [Boolean]
+  def ready?
     !!@ready
   end
 
-  # :call-seq:
-  #   Bootinq.ready! -> nil or self
-  #
-  # At the first call marks Bootinq as ready and returns the instance,
-  # otherwise returns nil.
+  # Once-only set {Bootinq} to ready state firing the `@_on_ready` callback.
+  # @return [self] on the first call
+  # @return [void] after
   def ready!
     return if ready?
     @ready = true
     if defined?(@_on_ready)
-      instance_exec(&@_on_ready)
+      Bootinq.class_exec(&@_on_ready)
       remove_instance_variable :@_on_ready
     end
     freeze
   end
 
-  # :call-seq:
-  #   Bootinq.enable_component(name, flag: [, as: Component])
-  #
+  # Enables the given component if it is required by flag or
+  # when another enabled component depends it.
+  # @param name [String]
+  #   of the component
+  # @param flag [String]
+  #   the component's assigned char flag
+  # @param as [Class]
+  #   the component's constructor class
+  # @yield [name, is_enabled]
+  # @return [void]
   def enable_component(name, flag:, as: Component)
     if is_dependency?(name) || @_value.include?(flag)
       @flags      << flag
       @components << as.new(name)
+      yield(name, true) if block_given?
+    else
+      yield(name, false) if block_given?
     end
+
+    nil
   end
 
-  # :call-seq:
-  #   Bootinq.enabled?(name) -> true or false
-  #
-  # Checks if a component with the given name (i.e. the same gem group)
-  # is enabled
+  # Checks if a component with the given name (i.e. the same gem group)  is enabled
+  # @return [Boolean]
   def enabled?(name)
-    ALL.include?(name) || components.include?(name)
+    ALL.include?(name) || @components.include?(name)
   end
 
-  # :call-seq:
-  #   Bootinq.component(name) -> Bootinq::Component
-  #   Bootinq[name] -> Bootinq::Component
-  #
-  # Returns a <tt>Bootinq::Component</tt> object by its name
+  # @param name [String, Symbol]
+  # @return [Bootinq::Component]
   def component(name)
-    components[components.index(name)]
+    @components[@components.index(name)]
   end
 
-  alias :[] :component
+  alias_method :[], :component
 
-  # :call-seq:
-  #   Bootinq.each_mountable { |part| block } -> Array
-  #   Bootinq.each_mountable -> Enumerator
-  #
-  # Calls the given block once for each enabled mountable component
-  # passing that part as a parameter. Returns the array of all mountable components.
-  #
-  # If no block is given, an Enumerator is returned.
-  def each_mountable(&block) # :yields: part
-    components.select(&:mountable?).each(&block)
+  # Checks if a component with the given name (i.e. the same gem group)  is disabled
+  # @return [Boolean]
+  def disabled?(name)
+    !@components.include?(name)
   end
 
-  # :call-seq:
-  #   Bootinq.groups(*groups)
-  #
-  # Merges enabled Bootinq's groups with the given groups and, if loaded with Rails,
-  # passes them to <tt>Rails.groups</tt> method, otherwise just returns the merged list
-  # to use with <tt>Bundler.require</tt>.
+  # Enumerates enabled mountable components
+  # @overload each_mountable()
+  # @overload each_mountable(&block)
+  #   @yield [component]
+  # @return [Enumerator]
+  def each_mountable
+    return enum_for(:each_mountable) unless block_given?
+
+    @components.each do |component|
+      yield(component) if component.mountable?
+    end
+  end
+
+  # Merges groups of enabled components with the given ones.
+  # When loaded with Rails, it passes them to {Rails.groups} method,
+  # otherwise just returns the merged list to use it with {Bundler.require}.
+  # @param groups [Array<String, Symbol>]
+  # @return [Array<String, Symbol>] merged groups
   def groups(*groups)
-    groups.unshift(*components.map(&:group))
-    if defined?(Rails)
-      Rails.groups(*groups)
-    else
-      groups
+    @components.each do |component|
+      next if groups.include?(component.group)
+      groups.unshift(component.group)
     end
+
+    defined?(Rails) ? Rails.groups(*groups) : groups
   end
 
-  # :call-seq:
-  #   Bootinq.on(name) { block } -> true or false
-  #   Bootinq.on(any: [names]) { block } -> true or false
-  #   Bootinq.on(all: [names]) { block } -> true or false
-  #
-  # Takes a component's name or single-key options hash as an argument and
-  # yields a given block if the target components are enabled.
-  #
-  # See examples for a usage.
+  # @overload on(name)
+  #   @yield [void] (if component is enabled)
+  #   @param name [Symbol] single component's name
   #
-  # ==== Example:
+  # @overload on(any:)
+  #   @see on_any
+  #   @yield [void] (if _any_ matching component is enabled)
+  #   @param any [Array<Symbol>] list of components' names
   #
-  #   Bootinq.on :frontend do
-  #     # make frontend thing...
-  #   end
+  # @overload on(all:)
+  #   @see on_all
+  #   @yield [void] (if _all_ matching components are enabled)
+  #   @param all [Array<Symbol>] list of components' names
   #
-  #   Bootinq.on any: %i(frontend backend) do
-  #     # do something when frontend or backend is enabled
-  #   end
+  # @return [Boolean] matching status
   #
-  #   Bootinq.on all: %i(frontend backend) do
-  #     # do something when frontend and backend are enabled
-  #   end
-  def on(name = nil, any: nil, all: nil) # :yields:
-    if ALL.include?(name)
+  # @example single
+  #   Bootinq.on(:frontend) { puts 'frontend' }
+  # @example any
+  #   Bootinq.on(any: %i[frontend backend]) { puts 'frontend or backend' }
+  # @example all
+  #   Bootinq.on(all: %i[frontend backend]) { puts 'both' }
+  def on(name = nil, any: nil, all: nil)
+    if name && ALL.include?(name)
       yield
       return true
     end
 
-    if name.nil? && any.nil? && all.nil?
-      raise ArgumentError, "wrong arguments (given 0, expected 1)"
-    elsif (any && all) || (name && (any || all))
-      raise ArgumentError, "expected single argument or one of keywords: `all' or `any'"
-    end
-
     is_matched =
       name ? enabled?(name) :
       any  ? on_any(*any) :
       all  ? on_all(*all) : false
+
     yield if is_matched
+
     is_matched
   end
 
-  # :call-seq:
-  #   Bootinq.on_all(*names) { block } -> true or false
-  #
-  # Takes a list of component names and yields a given block (optionally)
-  # if all of them are enabled. Returns boolean matching status.
+  # @yield [void]
+  #   if _all_ matching components are enabled
+  # @param parts [Array<String, Symbol>]
+  #   list of components' names
+  # @return [Boolean]
+  #   matching status
   def on_all(*parts) # :yields:
-    is_matched = parts.all? { |part| enabled?(part) }
+    is_matched = parts.reduce(true) { |m, part| m && enabled?(part) }
     yield if is_matched && block_given?
     is_matched
   end
 
-  # :call-seq:
-  #   Bootinq.on_all(*names) { block } -> true or false
-  #
-  # Takes a list of component names and yields a given block  (optionally)
-  # if any of them are enabled. Returns boolean matching status.
+  # @yield [void]
+  #   if _any_ matching component is enabled
+  # @param parts [Array<String, Symbol>]
+  #   list of components' names
+  # @return [Boolean]
+  #   matching status
   def on_any(*parts) # :yields:
-    is_matched = parts.any? { |part| enabled?(part) }
+    is_matched = parts.reduce(false) { |m, part| m || enabled?(part) }
     yield if is_matched && block_given?
     is_matched
   end
 
-  # :call-seq:
-  #   Bootinq.switch(*parts) { block } -> nil
+  # @overload not(name)
+  #   @yield [void] (if component is disabled)
+  #   @param name [Symbol] single component's name
   #
-  # Collector method.
+  # @overload not(any:)
+  #   @see not_any
+  #   @yield [void] (if _any_ matching component is disabled)
+  #   @param any [Array<Symbol>] list of components' names
   #
-  # Example:
+  # @overload not(all:)
+  #   @see not_all
+  #   @yield [void] (if _all_ matching components are disabled)
+  #   @param all [Array<Symbol>] list of components' names
   #
+  # @return [Boolean] matching status
+  #
+  # @example single
+  #   Bootinq.not(:frontend) { puts 'not frontend' }
+  # @example any
+  #   Bootinq.not(any: %i[frontend backend]) { puts 'neither frontend nor backend' }
+  # @example all
+  #   Bootinq.on(all: %i[frontend backend]) { puts 'both disabled' }
+  def not(name = nil, any: nil, all: nil)
+    is_matched =
+      name ? disabled?(name) :
+      any  ? not_any(*any) :
+      all  ? not_all(*all) : false
+
+    yield if is_matched
+
+    is_matched
+  end
+
+  # @yield [void]
+  #   if _all_ matching components are disabled
+  # @param parts [Array<String, Symbol>]
+  #   list of components' names
+  # @return [Boolean]
+  #   matching status
+  def not_all(*parts) # :yields:
+    is_matched = parts.reduce(true) { |m, part| m && disabled?(part) }
+    yield if is_matched && block_given?
+    is_matched
+  end
+
+  # @yield [void]
+  #   if _any_ matching component is disabled
+  # @param parts [Array<String, Symbol>]
+  #   list of components' names
+  # @return [Boolean]
+  #   matching status
+  def not_any(*parts) # :yields:
+    is_matched = parts.reduce(false) { |m, part| m || disabled?(part) }
+    yield if is_matched && block_given?
+    is_matched
+  end
+
+  # Collector method.
+  # @example
   #   Bootinq.switch do |part|
   #     part.frontend { … }
   #     part.backend { … }
   #   end
-  def switch # :yields: Bootinq::Switch.new
+  # @yield [switch]
+  # @see Bootinq::Switch
+  # @return [void]
+  def switch
     yield(Switch.new)
     nil
   end
 
-  # :call-seq:
-  #   is_dependency?(part_name) -> true or false
-  #
-  # Checks if the named component is a dependency of the enabled one.
+  # Checks if the named component is dependent by another enabled one.
+  # @param name [String, Symbol]
+  # @return [Boolean]
   def is_dependency?(name)
-    @_deps.key?(name) && @_value.count(@_deps[name]['in'].to_s) > 0
+    @_deps.key?(name.to_s) &&
+    @_value.count(@_deps.dig(name.to_s, 'in').to_s) > 0
   end
 
-  # Freezes every instance variables and the instance itself.
+  # @api private
   def freeze
     @_value.freeze
     @_neg
@@ -311,20 +412,22 @@ class Bootinq
 
   extend SingleForwardable
 
-  delegate %I[
-    component
-    components
-    each_mountable
-    enabled?
-    enable_component
-    flags
-    groups
-    on
-    on_all
-    on_any
-    ready!
-    ready?
-    switch
-    []
-  ] => :instance
+  def_delegator :instance, :component
+  def_delegator :instance, :components
+  def_delegator :instance, :each_mountable
+  def_delegator :instance, :enabled?
+  def_delegator :instance, :enable_component
+  def_delegator :instance, :disabled?
+  def_delegator :instance, :flags
+  def_delegator :instance, :groups
+  def_delegator :instance, :on
+  def_delegator :instance, :on_all
+  def_delegator :instance, :on_any
+  def_delegator :instance, :not
+  def_delegator :instance, :not_all
+  def_delegator :instance, :not_any
+  def_delegator :instance, :ready!
+  def_delegator :instance, :ready?
+  def_delegator :instance, :switch
+  def_delegator :instance, :[]
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bootinq
 version: !ruby/object:Gem::Version
-  version: '1.7'
+  version: '2.0'
 platform: ruby
 authors:
 - Anton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-03-12 00:00:00.000000000 Z
+date: 2022-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -48,6 +48,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- ".yardopts"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -58,6 +59,8 @@ files:
 - lib/bootinq.rb
 - lib/bootinq.yml
 - lib/bootinq/component.rb
+- lib/bootinq/mixins.rb
+- lib/bootinq/railtie.rb
 - lib/bootinq/switch.rb
 - lib/bootinq/version.rb
 homepage: https://github.com/estum/bootinq