bootinq 1.8 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70b36fe43d2052568352c6afd05fdc32f761bdb232dadaed96d3ba05f3a93f6b
-  data.tar.gz: 28d7999b1f29b41c87944da9b564b5641ba0582465ae703b8d582aa8814a8eca
+  metadata.gz: 6e377cd962a0467e2e6ea056674bae230612b823f667d780c9982d76ff4bbf0c
+  data.tar.gz: 402aef98700c975d26ef975c8e21fef639138dc03b5adb93c54f8e85e3b5a44f
 SHA512:
-  metadata.gz: 85a46c57dee491a7cd41997e79992befbe184439e0d49af40e980cf222d8f513eeda9c5874fdf8006eed7561715ab41cbe36f1de24a9a4efbe081601f1dbc69f
-  data.tar.gz: 66d7bbe52c5835ac53bd11e3413c26b7af08eabf7c06f19b3ccc88f4627d52c1e90341381ba2b5a180504580ed171afff4f5cbf4a58f03757f6722ea73f285fb
+  metadata.gz: 78dffcca879fd25017dc6d09fdd33f5bfdbd5878922a7c705d10f0ccd07cd703bede9e2d5e2e06ccc8c18bcdc21e091fc9efb7611e8f7d0b69193bfe4f951676
+  data.tar.gz: e6aeda4ed1293fb720a9998d79dd877bc36cff136fc78b9bcf420b8dd2f9a322fe573014303c4572c0bde882c327d6d66d7c127ec0983403fa0693ab43047d0e

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/component.rb

@@ -2,90 +2,306 @@
 
 class Bootinq
   class Component
-    attr_reader :intern, :id2name, :group
+    # @!attribute [r] intern
+    #   @return [Symbol]
 
-    alias :to_sym   :intern
-    alias :to_s     :id2name
-    alias :gem_name :id2name
-    alias :name     :id2name
+    attr_reader :intern
 
+    # @!attribute [r] id2name
+    #   @return [Symbol]
+
+    attr_reader :id2name
+
+    # @!attribute [r] group
+    #   @return [Symbol] Bundle group name
+
+    attr_reader :group
+
+    alias_method :to_sym, :intern
+    alias_method :to_s, :id2name
+    alias_method :gem_name, :id2name
+    alias_method :name, :id2name
+
+    # @see #initialize
+    # @param intern [String, Symbol]
+    # @return [Bootinq::Component] frozen
+    def self.new(intern)
+      super.freeze
+    end
+
+    # @param intern [String, Symbol]
+    # @return [self]
     def initialize(intern)
-      @intern  = intern.to_sym
+      @intern = intern.to_sym
       @id2name = intern.to_s.freeze
-      @group   = :"#@id2name\_boot"
-      freeze
+      @group = :"#{@id2name}_boot"
     end
 
+    # @return [Boolean]
     def mountable?
       false
     end
 
+    # @return [Symbol]
     def module_name
       @id2name.camelcase.to_sym
     end
 
+    # @return [Module]
+    def namespace
+      Object.const_get(module_name)
+    end
+
+    # @return [void]
     def engine
     end
 
+    # @param klass [Class]
+    # @return [Boolean]
     def kind_of?(klass)
       super || @intern.kind_of?(klass)
     end
 
-    def == other
+    ##
+    # @!group Coercing methods
+
+    # Coerces self to other value klass.
+    # @overload coerce_to(string)
+    #   @param string [String]
+    #   @return [String] {#id2name}
+    # @overload coerce_to(symbol)
+    #   @param symbol [Symbol]
+    #   @return [Symbol] {#intern}
+    # @overload coerce_to(other)
+    #   @param other [Any]
+    #   @return [self]
+    def coerce_to(other)
       case other
-      when String then other == @id2name
-      when Symbol then other == @intern
-                  else super
+      when String; @id2name
+      when Symbol; @intern
+      else self
       end
     end
 
-    def ===(other)
+    # Coerces other value
+    # @overload coerce(symbol)
+    #   @param symbol [Symbol]
+    #   @return [Symbol] symbol
+    # @overload coerce(other)
+    #   @param other [String, Any]
+    #   @return [String] other
+    def coerce(other)
       case other
-      when String then other === @id2name
-      when Symbol then other === @intern
-                  else super
+      when String, Symbol; other
+      else other.to_s
       end
     end
 
+    # @!endgroup
+    ##
+
+    ##
+    # @!group Comparation methods
+
+    # @param other [Any]
+    # @return [Boolean]
+    def ==(other)
+      other = coerce(other)
+      other == coerce_to(other)
+    end
+
+    # @param other [Any]
+    # @return [Boolean]
+    def ===(other)
+      other = coerce(other)
+      other === coerce_to(other)
+    end
+
+    # @param other [Any]
+    # @return [Boolean]
     def casecmp(other)
-      case other
-      when String then @id2name.casecmp(other)
-      when Symbol then @intern.casecmp(other)
-      when self.class then casecmp(other.to_s)
-      end
+      other = coerce(other)
+      coerce_to(other).casecmp(other)
     end
 
+    # @param other [Any]
+    # @return [Boolean]
     def casecmp?(other)
-      case other
-      when String then @id2name.casecmp?(other)
-      when Symbol then @intern.casecmp?(other)
-      when self.class then casecmp?(other.to_s)
-      end
+      other = coerce(other)
+      coerce_to(other).casecmp?(other)
+    end
+
+    # @!endgroup
+    ##
+
+    ##
+    # @!group Symbol-delegated methods
+
+    # @return [String] representation of {#intern} as a symbol literal.
+    def inspect
+      @intern.inspect
+    end
+
+    # @return [Proc] responded to the given method by {#intern}
+    def to_proc
+      @intern.to_proc
     end
 
-    %i(inspect to_proc __id__ hash).
-      each { |sym| class_eval %(def #{sym}; @intern.#{sym}; end), __FILE__, __LINE__ + 1 }
+    # @return [Integer] identifier for {#intern}
+    def __id__
+      @intern.__id__
+    end
 
-    %i(encoding empty? length).
-      each { |sym| class_eval %(def #{sym}; @id2name.#{sym}; end), __FILE__, __LINE__ + 1 }
+    # @return [Integer] {#intern}'s hash
+    def hash
+      @intern.hash
+    end
 
-    %i(match match? =~ []).
-      each { |sym| class_eval %(def #{sym}(*args); @id2name.#{sym}(*args); end), __FILE__, __LINE__ + 1 }
+    # @!endgroup
+    ##
 
-    %i(upcase downcase capitalize swapcase succ next).
-      each { |sym| class_eval %(def #{sym}; self.class.new(@intern.#{sym}); end), __FILE__, __LINE__ + 1 }
+    ##
+    # @!group String-delegated methods
 
-    alias :slice :[]
-    alias :size :length
+    # @return [Encoding] of {#id2name}
+    def encoding
+      @id2name.encoding
+    end
+
+    # @return [Boolean]
+    def empty?
+      @id2name.empty?
+    end
+
+    # @return [Integer] length of {#id2name}
+    def length
+      @id2name.length
+    end
+
+    # @param pattern [Regexp, String]
+    # @param start_from [Integer] position in {#id2name} to begin the search
+    # @yield [MatchData] if match succeed
+    # @yieldreturn [Any]
+    # @return [MatchData] unless block given
+    # @return [Any] returned by the given block
+    def match(*args, &block)
+      @id2name.match(*args, &block)
+    end
+
+    # @param pattern [Regexp, String]
+    # @param start_from [Integer] position in {#id2name} to begin the search
+    # @return [Boolean] indicates whether the regexp is matched or not
+    def match?(*args)
+      @id2name.match?(*args)
+    end
+
+    # @overload =~(pattern)
+    #   @param pattern [Regexp]
+    #   @return [Integer] if matched, the position the match starts
+    #   @return [nil] if there is no match
+    # @overload =~(arg)
+    #   @param arg [Object]
+    #   @see Object#=~
+    def =~(arg)
+      @id2name =~ arg
+    end
+
+    # Element reference
+    # @see String#slice
+    def slice(*args)
+      @id2name[*args]
+    end
+
+    alias_method :[], :slice
+
+    # @!endgroup
+    ##
+
+    ##
+    # @!group Symbol-delegated mutation methods
+
+    # @see Symbol#upcase
+    # @return [Bootinq::Component] new instance with upcased {#intern}
+    def upcase
+      self.class.new(@intern.upcase)
+    end
+
+    # @see Symbol#downcase
+    # @return [Bootinq::Component] new instance with downcased {#intern}
+    def downcase
+      self.class.new(@intern.downcase)
+    end
+
+    # @see Symbol#capitalize
+    # @return [Bootinq::Component] new instance with capitalized {#intern}
+    def capitalize
+      self.class.new(@intern.capitalize)
+    end
+
+    # @see Symbol#swapcase
+    # @return [Bootinq::Component] new instance with swapcased {#intern}
+    def swapcase
+      self.class.new(@intern.swapcase)
+    end
+
+    # @see Symbol#succ
+    # @return [Bootinq::Component] new instance with the successor {#intern}
+    def succ
+      self.class.new(@intern.succ)
+    end
+
+    # @see Symbol#next
+    # @return [Bootinq::Component] new instance with the next {#intern}
+    def next
+      self.class.new(@intern.next)
+    end
+
+    # @endgroup
+    ##
   end
 
   class Mountable < Component
+    # @!attribute [r] module_name
+    #   @return [Symbol]
+
+    # @!attribute [r] namespace
+    #   @return [Module]
+
+    def initialize(intern)
+      super
+      @module_name = module_name()
+      @namespace = namespace()
+    end
+
     def mountable?
       true
     end
 
+    def module_name
+      return @module_name if frozen? || defined?(@module_name)
+      super
+    end
+
+    def namespace
+      if frozen? || defined?(@namespace)
+        @namespace.is_a?(Proc) ? @namespace.call : @namespace
+      elsif namespace_defined?
+        super
+      else
+        proc { super }
+      end
+    end
+
+    # @return [Class]
     def engine
-      Object.const_get(module_name)::Engine
+      namespace::Engine
+    end
+
+    private
+
+    # @api private
+    def namespace_defined?
+      Object.const_defined?(module_name)
     end
   end
 end

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.8"
+  VERSION = "2.0.1"
 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,47 +68,72 @@ 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'))
     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)
@@ -126,10 +144,20 @@ class Bootinq
     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 }
 
@@ -145,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
+  # @overload on(name)
+  #   @yield [void] (if component is enabled)
+  #   @param name [Symbol] single component's name
   #
-  # Takes a component's name or single-key options hash as an argument and
-  # yields a given block if the target components are enabled.
+  # @overload on(any:)
+  #   @see on_any
+  #   @yield [void] (if _any_ matching component is enabled)
+  #   @param any [Array<Symbol>] list of components' names
   #
-  # See examples for a usage.
+  # @overload on(all:)
+  #   @see on_all
+  #   @yield [void] (if _all_ matching components are enabled)
+  #   @param all [Array<Symbol>] list of components' names
   #
-  # ==== Example:
+  # @return [Boolean] matching status
   #
-  #   Bootinq.on :frontend do
-  #     # make frontend thing...
-  #   end
-  #
-  #   Bootinq.on any: %i(frontend backend) do
-  #     # do something when frontend or backend is enabled
-  #   end
-  #
-  #   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
@@ -321,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.8'
+  version: 2.0.1
 platform: ruby
 authors:
 - Anton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-09-30 00:00:00.000000000 Z
+date: 2022-10-27 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
@@ -79,7 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.0.3
 signing_key:
 specification_version: 4
 summary: Rails Boot Inquirer