RubyGems - module-cluster - Versions diffs - 1.4.8 → 2.0.0 - Mend

module-cluster 1.4.8 → 2.0.0

Files changed (108) hide show

data/lib/module-cluster/ModuleCluster/Suspend/WithoutHooks.rb DELETED Viewed

@@ -1,153 +0,0 @@
-module ::ModuleCluster::Suspend::WithoutHooks
-  include ::ModuleCluster::Suspend::Hooks
-  #######################
-  #  without_any_hooks  #
-  #######################
-  def without_any_hooks( description = nil )
-    if description
-      # we don't want to end up unsuspending any sets that were already suspended
-      # so we add to the description only sets that are not suspended
-      description[ :suspended ] = false
-      sets = cluster_stack.all_hooks.hooks_with( description )
-      sets.suspend
-      yield
-      sets.resume
-    else
-      cluster_stack.suspend_any_hooks
-      yield
-      cluster_stack.resume_any_hooks
-    end
-    return self
-  end
-  ###############################
-  #  without_any_include_hooks  #
-  ###############################
-  def without_any_include_hooks( description = nil )
-    if description
-      # we don't want to end up unsuspending any sets that were already suspended
-      # so we add to the description only sets that are not suspended
-      description[ :suspended ] = false
-      sets = cluster_stack.all_include_hooks.hooks_with( description )
-      sets.suspend
-      yield
-      sets.resume
-    else
-      cluster_stack.suspend_any_include_hooks
-      yield
-      cluster_stack.resume_any_include_hooks
-    end
-    return self
-  end
-  ##############################
-  #  without_any_extend_hooks  #
-  ##############################
-  def without_any_extend_hooks( description = nil )
-    if description
-      # we don't want to end up unsuspending any sets that were already suspended
-      # so we add to the description only sets that are not suspended
-      description[ :suspended ] = false
-      sets = cluster_stack.all_extend_hooks.hooks_with( description )
-      sets.suspend
-      yield
-      sets.resume
-    else
-      cluster_stack.suspend_any_extend_hooks
-      yield
-      cluster_stack.resume_any_extend_hooks
-    end
-    return self
-  end
-  ###########################
-  #  without_include_hooks  #
-  ###########################
-  def without_include_hooks( description = nil )
-    if description
-      # we don't want to end up unsuspending any sets that were already suspended
-      # so we add to the description only sets that are not suspended
-      description[ :suspended ] = false
-      sets = cluster_stack.include_hooks.hooks_with( description )
-      sets.suspend
-      yield
-      sets.resume
-    else
-      cluster_stack.suspend_include_hooks
-      yield
-      cluster_stack.resume_include_hooks
-    end
-    return self
-  end
-  ##########################
-  #  without_extend_hooks  #
-  ##########################
-  def without_extend_hooks( description = nil )
-    if description
-      # we don't want to end up unsuspending any sets that were already suspended
-      # so we add to the description only sets that are not suspended
-      description[ :suspended ] = false
-      sets = cluster_stack.extend_hooks.hooks_with( description )
-      sets.suspend
-      yield
-      sets.resume
-    else
-      cluster_stack.suspend_extend_hooks
-      yield
-      cluster_stack.resume_extend_hooks
-    end
-    return self
-  end
-  ###################################
-  #  without_prepend_include_hooks  #
-  ###################################
-  def without_prepend_include_hooks( description = nil )
-    if description
-      # we don't want to end up unsuspending any sets that were already suspended
-      # so we add to the description only sets that are not suspended
-      description[ :suspended ] = false
-      sets = cluster_stack.prepend_include_hooks.hooks_with( description )
-      sets.suspend
-      yield
-      sets.resume
-    else
-      cluster_stack.suspend_prepend_include_hooks
-      yield
-      cluster_stack.resume_prepend_include_hooks
-    end
-    return self
-  end
-  ##################################
-  #  without_prepend_extend_hooks  #
-  ##################################
-  def without_prepend_extend_hooks( description = nil )
-    if description
-      # we don't want to end up unsuspending any sets that were already suspended
-      # so we add to the description only sets that are not suspended
-      description[ :suspended ] = false
-      sets = cluster_stack.prepend_extend_hooks.hooks_with( description )
-      sets.suspend
-      yield
-      sets.resume
-    else
-      cluster_stack.suspend_prepend_extend_hooks
-      yield
-      cluster_stack.resume_prepend_extend_hooks
-    end
-    return self
-  end
-end

data/lib/module-cluster/_private_/ModuleCluster/CascadeFeatures.rb DELETED Viewed

@@ -1,77 +0,0 @@
-module ::ModuleCluster::CascadeFeatures
-  extend ::ModuleCluster::CascadeFeatures::PerformCascades
-  #####################
-  #  append_features  #
-  #####################
-  def append_features( hooked_instance )
-    ::ModuleCluster::CascadeFeatures.perform_cascades( self,
-                                                       :prepend_include,
-                                                       hooked_instance,
-                                                       cluster_stack.prepend_include_hooks )
-    super
-  end
-  ##############
-  #  included  #
-  ##############
-  def included( hooked_instance )
-    super
-    ::ModuleCluster::CascadeFeatures.perform_cascades( self,
-                                                      :include,
-                                                      hooked_instance,
-                                                      cluster_stack.include_hooks )
-    # if we are included in a class and we have cascading inherit hooks we need to move them over
-    # append_features and included are both called for an inlucde, so we only need to do this in one
-    if hooked_instance.is_a?( Class )
-      unless cluster_stack.inherited_hooks.empty?
-        hooked_instance.extend( ::ModuleCluster::Define::Block::Subclass )
-        hooked_instance.cluster_stack.inherited_hooks.concat( cluster_stack.inherited_hooks )
-      end
-    end
-  end
-  ###################
-  #  extend_object  #
-  ###################
-  def extend_object( hooked_instance )
-    ::ModuleCluster::CascadeFeatures.perform_cascades( self,
-                                                       :prepend_extend,
-                                                       hooked_instance,
-                                                       cluster_stack.prepend_extend_hooks )
-    super
-  end
-  ##############
-  #  extended  #
-  ##############
-  def extended( hooked_instance )
-    super
-    ::ModuleCluster::CascadeFeatures.perform_cascades( self,
-                                                       :extend,
-                                                       hooked_instance,
-                                                       cluster_stack.extend_hooks )
-  end
-end

data/lib/module-cluster/_private_/ModuleCluster/CascadeFeatures/ClusterStack.rb DELETED Viewed

@@ -1,44 +0,0 @@
-module ::ModuleCluster::CascadeFeatures::ClusterStack
-  #########################
-  #  self.cluster_stacks  #
-  #########################
-  def self.cluster_stacks
-    return @cluster_stacks ||= Hash.new
-  end
-  ########################
-  #  self.cluster_stack  #
-  ########################
-  def self.cluster_stack( class_or_module )
-    cluster_stack_for_class_or_module = nil
-    unless cluster_stack_for_class_or_module = cluster_stacks[ class_or_module ]
-      cluster_stack_for_class_or_module = ::ModuleCluster::ClusterStack.new
-      cluster_stacks[ class_or_module ] = cluster_stack_for_class_or_module
-    end
-    return cluster_stack_for_class_or_module
-  end
-  ###################
-  #  cluster_stack  #
-  ###################
-  def cluster_stack
-    return ::ModuleCluster::CascadeFeatures::ClusterStack.cluster_stack( self )
-  end
-end

data/lib/module-cluster/_private_/ModuleCluster/CascadeFeatures/PerformCascades.rb DELETED Viewed

@@ -1,292 +0,0 @@
-module ::ModuleCluster::CascadeFeatures::PerformCascades
-  ######################
-  #  perform_cascades  #
-  ######################
-  def perform_cascades( module_self, action, hooked_instance, set_stack )
-    # This method is called when a ::ModuleCluster module is included or extended.
-    # It determines what modules should be included/extended and which should cascade.
-    unless module_self.hooks_suspended?( action )
-      # for each set:
-      set_stack.each do |this_set|
-        # if this particular set is suspended, skip to the next
-        next if this_set.suspended
-        # Block sets simply run a block at a hook.
-        # They do not include or extend returns from the block.
-        # The hooked module will not be extended by ::ModuleCluster.
-        if this_set.is_a?( ::ModuleCluster::ClusterStack::Block::Set )
-          # if our blocks are set to cascade then we need to copy inherit hooks
-          if this_set.dependency_module.should_cascade?( hooked_instance )
-            cascade_block_into_hooked_instance( module_self, action, hooked_instance, this_set )
-          end
-          if this_set.dependency_module.should_run_block?( hooked_instance )
-            case this_set.runtime_block.arity
-              when 0
-                module_self.instance_eval( & this_set.runtime_block )
-              else
-                module_self.instance_exec( hooked_instance, & this_set.runtime_block )
-            end
-          end
-        # Other sets take parameters and an optional block. The optional block returns are included
-        # or extended like the parameters provided.
-        else
-          if should_cascade = this_set.dependency_module.should_cascade?( hooked_instance )
-            # cascade parameter modules as appropriate
-            cascade_modules_into_hooked_instance( module_self,
-                                                  hooked_instance,
-                                                  this_set,
-                                                  this_set.modules )
-          end
-          # dependency modules can cause instances to be included/extended and/or cascade
-          should_include = this_set.dependency_module.should_include_or_extend?( hooked_instance )
-          # include/extend parameter modules as appropriate
-          if should_include
-            include_extend_modules( module_self, hooked_instance, this_set, this_set.modules )
-          end
-          # process runtime block if present
-          if this_set.runtime_includes_or_extends_block
-            # if we have a runtime block, run block and collect returns as appropriate
-            if runtime_modules = collect_block_runtime_result_modules( module_self,
-                                                                       hooked_instance,
-                                                                       this_set )
-              # cascade return modules if appropriate
-              if should_cascade
-                cascade_modules_into_hooked_instance( module_self,
-                                                      hooked_instance,
-                                                      this_set,
-                                                      runtime_modules )
-              end
-              # include/extend return modules if appropriate
-              if should_include
-                include_extend_modules( module_self, hooked_instance, this_set, runtime_modules )
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-  ############################
-  #  include_extend_modules  #
-  ############################
-  def include_extend_modules( module_self, hooked_instance, set, modules )
-    # Collect include/extend modules from this set into our eventual include/extend order.
-    case set.include_or_extend
-      when :include_and_extend
-        include_or_extend_hooked_instance( hooked_instance, set, true, true, modules )
-      when :include
-        include_or_extend_hooked_instance( hooked_instance, set, true, false, modules )
-      when :extend
-        include_or_extend_hooked_instance( hooked_instance, set, false, true, modules )
-    end
-  end
-  ##########################################
-  #  cascade_modules_into_hooked_instance  #
-  ##########################################
-  def cascade_modules_into_hooked_instance( module_self, hooked_instance, set, modules )
-    # if we are supposed to cascade we need to extend with the ::ModuleCluster dependency module
-    hooked_instance.extend( set.dependency_module )
-    # and we call the set's definition method to cascade
-    hooked_instance.__send__( set.method, *modules )
-  end
-  ########################################
-  #  cascade_block_into_hooked_instance  #
-  ########################################
-  def cascade_block_into_hooked_instance( module_self, action, hooked_instance, set )
-    hooked_instance.extend( set.dependency_module )
-    if hooked_instance.is_a?( Class )
-      if action == :inherited
-        unless set.dependency_module == ::ModuleCluster::CascadeFeatures::Subclass
-          hooked_instance.extend( ::ModuleCluster::CascadeFeatures::Subclass )
-        end
-        hooked_instance.subclass( & set.runtime_block )
-      end
-    else
-      # and we call the set's definition method to cascade
-      hooked_instance.__send__( set.method, & set.runtime_block )
-    end
-  end
-  #######################################
-  #  include_or_extend_hooked_instance  #
-  ######################################
-  def include_or_extend_hooked_instance( hooked_instance,
-                                         set,
-                                         should_include,
-                                         should_extend,
-                                         modules )
-    # We have collected includes, extends, transparent cascades.
-    # Now we want to actually include/extend/cascade as appropriate.
-    # If we have a module (a class is a module):
-    module_self = self
-    if hooked_instance.is_a?( Module )
-      hooked_instance.module_eval do
-        if should_include                                                                    and
-           module_self.should_include_or_extend_instance?( set.module_class_instance_or_all,
-                                                           hooked_instance )                 and
-           ! modules.empty?
-          include( *modules.reverse )
-        end
-        if should_extend                                                                     and
-           module_self.should_include_or_extend_instance?( set.module_class_instance_or_all,
-                                                           hooked_instance )                 and
-           ! modules.empty?
-          extend( *modules.reverse )
-        end
-      end
-    # Otherwise we have an instance:
-    else
-      if should_extend                                                                       and
-         module_self.should_include_or_extend_instance?( set.module_class_instance_or_all,
-                                                         hooked_instance )                   and
-         ! modules.empty?
-        hooked_instance.extend( *modules.reverse )
-      end
-    end
-  end
-  ########################################
-  #  should_include_or_extend_instance?  #
-  ########################################
-  def should_include_or_extend_instance?( module_class_instance_or_all, into_instance )
-    # The set stack already corresponds to include or extend or both,
-    # we are testing all_module_class_or_instance for:
-    #
-    # * any include/extend
-    # * module include/extend
-    # * class include/extend
-    # * instance extend
-    should_include_or_extend_instance = false
-    case module_class_instance_or_all
-      when :all, :module_or_class_or_instance, :module_and_class_and_instance,
-           :module_class_or_instance, :module_class_and_instance, :module_class_instance
-        should_include_or_extend_instance = true
-      when :module_or_class, :module_and_class, :module_class
-        should_include_or_extend_instance = into_instance.is_a?( Module )
-      when :module_or_instance, :module_and_instance, :module_instance
-        should_include_or_extend_instance = ( ! into_instance.is_a?( Module ) or
-                                              ( into_instance.is_a?( Module ) &&
-                                                ! into_instance.is_a?( Class ) ) )
-      when :class_or_instance, :class_and_instance, :class_instance
-        should_include_or_extend_instance = ( into_instance.is_a?( Class ) or
-                                              ! into_instance.is_a?( Module ) )
-      when :module
-        should_include_or_extend_instance = ( into_instance.is_a?( Module ) &&
-                                              ! into_instance.is_a?( Class ) )
-      when :class
-        should_include_or_extend_instance = into_instance.is_a?( Class )
-      when :instance
-        should_include_or_extend_instance = ! into_instance.is_a?( Module )
-    end
-    return should_include_or_extend_instance
-  end
-  ##########################################
-  #  collect_block_runtime_result_modules  #
-  ##########################################
-  def collect_block_runtime_result_modules( module_self, hooked_instance, set )
-    runtime_block_result_modules = nil
-    block = set.runtime_includes_or_extends_block
-    case block.arity
-      when 0
-        runtime_block_result_modules = module_self.instance_eval( & block )
-      else
-        runtime_block_result_modules = module_self.instance_exec( hooked_instance,
-                                                                  & block )
-    end
-    if runtime_block_result_modules
-      # make sure we have an array as a result
-      unless runtime_block_result_modules.is_a?( Array )
-        runtime_block_result_modules = [ runtime_block_result_modules ]
-      end
-      # make sure members of our result array are modules
-      runtime_block_result_modules.delete_if do |this_result_instance|
-        ! this_result_instance.is_a?( Module )
-      end
-      runtime_block_result_modules = nil if runtime_block_result_modules.empty?
-    end
-    return runtime_block_result_modules
-  end
-end