potrubi 0.0.3 → 0.0.4

data/lib/potrubi/mixin/dynamic-recipes.rb

@@ -11,7 +11,6 @@ metaclassMethods = Module.new do
   include Potrubi::Bootstrap
   include Potrubi::Mixin::Dynamic
   
-  #=begin               
   def recipe_new(tgtMod, newSpecs, &block)
     dynamic_define_methods(tgtMod, newSpecs) do | newName, newKlass |
 
@@ -33,20 +32,15 @@ metaclassMethods = Module.new do
         
       end
     end
-    #=end 
-    #=begin               
+
     def recipe_rescue_croak(tgtMod, croakSpecs, &block)
       dynamic_define_methods(tgtMod, croakSpecs) { | rescueName, rescueValue | "def #{rescueName}(*a, &b); #{rescueName}_or_croak(*a, &b) rescue #{rescueValue || 'nil'}; end\n" }
     end
-    #=end
 
-  #=begin
   def recipe_aliases(tgtMod, aliasSpecs, &block)
     dynamic_define_methods(tgtMod, aliasSpecs) { | aliasName, realName | "alias_method :'#{aliasName}', :'#{realName}';\n" }
   end
-  #=end
 
-  #=begin
   def recipe_croak_rescue(targetModule, croakArgs={}, &croakBlok)
     eye = :rcp_crk_rsc
     
@@ -78,12 +72,8 @@ metaclassMethods = Module.new do
 
     self
   end
-  #=end
-
-
 
 end
-#=end
 
 module Potrubi
   module Mixin

data/lib/potrubi/mixin/dynamic.rb

@@ -12,21 +12,19 @@ metaclassMethods = Module.new do
   #=begin
   def dynamic_apply_edits(editSpecInput, *textValues, &block)
     eye = :dyn_apy_edts
-    #eyeTale = '"TEXT EDITS'
-    
-    #editSpec.is_a?(Hash) || editSpec.is_a?(Enumerator) || (raise ArgumentError,"editSpec >#{editSpec.class}< >#{editSpec}< not hash")
+    eyeTale = '"TEXT EDITS'
+
     editSpec = case editSpecInput
                when Hash then editSpecInput
                when Array then dynamic_merge_edits(editSpecInput)
                  when NilClass then nil 
                else
                  potrubi_bootstrap_surpise_exception(editSpecInput, eye, "editSpecInput not has, array or nil")
-                 ###nil # will error
                end
 
     editSpec && potrubi_bootstrap_mustbe_hash_or_croak(editSpec, "editSpec not hash")
 
-    #potrubi_bootstrap_logger_me(eye, eyeTale, "editSpec", editSpec, "textValues >\n#{textValues}")
+    potrubi_bootstrap_logger_me(eye, eyeTale, "editSpec", editSpec, "textValues >\n#{textValues}")
 
     textValue = textValues.flatten.compact.join("\n")
 
@@ -43,35 +41,26 @@ metaclassMethods = Module.new do
                     ((recurseCnt +=1) <= recurseMax) || potrubi_bootstrap_surprise_exception(recurseCnt, eye, "recurseMax >#{recurseMax}< exceeded")
                     
                     textValue = newtextValue || textValue
-                    newtextValue = editSpec.inject(textValue) { |txt, (key, val)| txt.gsub(/#{key}/,"#{val}") }
-                    ###puts("APY EDTS recurseCnt >#{recurseCnt}< newtestValue >#{newtextValue}<")
+
+                    newtextValue = editSpec.inject(textValue) { |txt, (key, val)| txt.gsub(/#{key.to_s}/,"#{val}") }
+
                   end
 
                   newtextValue
                   
                 end
 
-    # support for uniquenesses needed?
-    
-    #while (textFinal =~ /METHOD_UNIQUENESS/) 
-    #  textFinal = textFinal.sub(/METHOD_UNIQUENESS/, rand(1000000000000).to_s)  # Each UNQIUENESS is unique!
-    #end
-    
     #potrubi_bootstrap_logger_mx(eye, eyeTale, "textFinal >#{textFinal.class}< >\n#{textFinal}\n<")
 
     textFinal
     
   end
-  #=end
   
-  #=begin
-  def dynamic_merge_edits(*edits)
-    r = edits.flatten.compact.inject({}) {|s, h| s.merge(potrubi_bootstrap_mustbe_hash_or_croak(h))}
+  def dynamic_merge_edits(*edits, &editBlok)
+    r = edits.flatten.compact.inject({}) {|s, h| s.merge(potrubi_bootstrap_mustbe_hash_or_croak(h), &editBlok)}
     r.empty? ? nil : r
   end
-  #=end
 
-  #=begin
   def dynamic_define_methods(targetModule, methodDefs, dynArgs=nil, &dynBlok)
     eye = :dyn_def_mtds
     
@@ -85,8 +74,6 @@ metaclassMethods = Module.new do
     
     editArgs = dynArgs && dynArgs[:edit]
     
-    #methodTexts = nil  # will hold texts for methods, if any (could be all define_methods)
-    
     dynSpecsAll = methodDefs.map do | mtdKey, mtdVal |
       
       $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, "BEG MTH mtdKey >#{mtdKey.class}< >#{mtdKey}< mtdVal >#{mtdVal.class}< >#{mtdVal.class}< editArgs >#{editArgs .class}< >#{editArgs}<")
@@ -104,33 +91,8 @@ metaclassMethods = Module.new do
       $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, "CASE GEN mtdKey >#{mtdKey.class}< >#{mtdKey}< mtdVal >#{mtdVal.class}< >#{mtdVal}< dynResultsBlok >#{dynResultsBlok.class}< >#{dynResultsBlok}<")
 
       editMtd = nil  # no default edits
-
-      dynResultsNorm = [dynResultsBlok].flatten(1).map do | dynResult |
-        case dynResult
-        when NilClass then nil
-        when Array then
-          $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ms(eye, "CASE ARRAY mtdKey >#{mtdKey.class}< >#{mtdKey}< dynResult >#{dynResult.class}< >#{dynResult}<")
-          dynResult # expected to have got is all right
-        when String, Symbol then
-          $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ms(eye, "CASE STRING, SYMBOL mtdKey >#{mtdKey.class}< >#{mtdKey}< dynResult >#{dynResult.class}< >#{dynResult}<")
-          #{:edit => [editMtd, editArgs], :spec => dynResult}
-          {spec: dynResult}
-        when Proc then
-          $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ms(eye, "CASE PROC mtdKey >#{mtdKey.class}< >#{mtdKey}< dynResult >#{dynResult.class}< >#{dynResult}<")
-          {name: mtdKey, spec: dynResult}
-        when Hash then
-          $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ms(eye, "CASE HASH mtdVal >#{mtdKey.class}< >#{mtdKey}< dynResult >#{dynResult.class}< >#{dynResult}<")
-          dynResult # expected to have gotten it right
-        else
-          potrubi_bootstrap_surprise_exception(dynResult, eye, "dynResult is what?")
-        end
-        
-      end.flatten.compact
-
-
-      dynSpecs = [*dynResultsNorm].map do | dynResult |
-        
-        potrubi_bootstrap_mustbe_hash_or_croak(dynResult, eye, "dynResult not hash")
+    
+      dynSpecs = dynamic_define_methods_normalise_specifications(mtdKey, *dynResultsBlok) do | dynResult |
         
         editAll = case
                   when dynResult.has_key?(:edit) then # edit key set?
@@ -148,55 +110,197 @@ metaclassMethods = Module.new do
       
       $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ms(eye, "FIN MTH mtdKey >#{mtdKey.class}< >#{mtdKey}< dynSpecs >#{dynSpecs.class}< >#{dynSpecs}<")
 
-
-      #dynamic_define_methods_apply(targetModule, dynSpecs)
       dynSpecs
+      
     end
 
     dynamic_define_methods_apply(targetModule, dynSpecsAll)
 
-    
     $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, "targetModule >#{targetModule.class}< >#{targetModule}< specs >#{methodDefs.class}< >#{methodDefs.class}< dynArgs >#{dynArgs.class}< >#{dynArgs}<")
+
     self
     
   end
-  #=end
 
-  #=begin
-  def dynamic_define_methods_apply(targetModule, *methodSpecs, &dynBlok)
+  def dynamic_define_methods_normalise_specifications(specName, *specsNom, &specBlok)
+    eye = :ddm_nrm_specs
+    eyeTale = 'DDM NRM SPEC'
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, eyeTale, "specName >#{specName}< specsNom >#{specsNom.class}< >#{specsNom.size}< >#{specsNom}< specBlok >#{specBlok}<")
+
+    specsMap = specsNom.flatten(1).map.with_index do | specNom, specNdx |
+
+      case specNom
+      when NilClass then nil # convenient to allow nil
+      when Array then
+        $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ms(eye, "CASE ARRAY specName >#{specName.class}< >#{specName}< specNom >#{specNom.class}< >#{specNom}<")
+        specNom # expected to have got is all right
+      when String, Symbol then
+        $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ms(eye, "CASE STRING, SYMBOL specName >#{specName.class}< >#{specName}< specNom >#{specNom.class}< >#{specNom}<")
+        #{:edit => [editMtd, editArgs], :spec => specNom}
+        {spec: specNom}
+      when Proc then
+        $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ms(eye, "CASE PROC specName >#{specName.class}< >#{specName}< specNom >#{specNom.class}< >#{specNom}<")
+        {name: specName, spec: specNom}
+        #STOPHERECASEPROC
+      when Hash then
+        $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ms(eye, "CASE HASH specName >#{specName.class}< >#{specName}< specNom >#{specNom.class}< >#{specNom}<")
+        specNom # expected to have gotten it right
+      else
+        potrubi_bootstrap_surprise_exception(specNom, eye, "specName >#{specName.class}< >#{specName}< specNom is what?")
+      end
+      
+    end.flatten.compact
+
+    dynamic_define_methods_validate_specifications(*specsMap)
+
+    specsNrm = Kernel.block_given? ? specsMap.map {|s| specBlok.call(s)} : specsMap
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, eyeTale, "specName >#{specName}< specsNrm >#{specsNrm.class}< >#{specsNrm.size}< >#{specsNrm.class}< specBlok >#{specBlok}<")
+    potrubi_bootstrap_mustbe_array_or_croak(specsNrm, eye)
+
+  end
+
+  # reduction in this context is consolidating edist
+  # alos resolving snippets
+  
+  def dynamic_define_methods_reduce_specifications(targetModule, *specsNom, &specBlok)
+    eye = :ddm_rdc_specs
+    eyeTale = 'DDM RDC SPEC'
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, eyeTale, "specsNom >#{specsNom.class}< >#{specsNom.size}< >#{specsNom.class}< specBlok >#{specBlok}<")
+
+    specsVal = dynamic_define_methods_validate_specifications(*specsNom)
+    
+    specsNrm = specsVal.map do | specNom |
+
+      specEdit = specNom[:edit]
+      specSpec = specNom[:spec]
+
+      $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "EDIT & SPEC specEdit >#{specEdit}< specSpec >#{specSpec.class}< >#{specSpec}<")
+
+      # Resolve any snippets
+      specSnippets = Potrubi::Mixin::SnippetManager.map_snippets_or_croak(:dynamic_methods, *specSpec)
+      
+      $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "SNIP",  potrubi_bootstrap_logger_fmt_kls_size(specSnippets: specSnippets))
+
+      snipEdits = dynamic_merge_edits(specEdit) # cummlative edits
+      
+      snipItems = specSnippets.map do | snipItem |
+
+        $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "SNIP BEG",  potrubi_bootstrap_logger_fmt_kls(snipItem: snipItem))
+        
+        snipList = case snipItem
+                   when Hash
+
+                    if snipItem.has_key?(:edit) then
+                      # collect any edits e.g. defaults. specEdit takes prescedence of snipEdits
+                      snipEdits = dynamic_merge_edits(snipEdits, snipItem[:edit], specEdit)
+                     end
+
+                     case
+                     when snipItem.has_key?(:proc) then
+                       r = dynamic_define_methods_apply_procs(nil, snipItem.merge({edit: snipEdits, target: targetModule}))
+                       dynamic_define_methods_reduce_specifications(targetModule, *r) # recurse
+                     else
+                       snipItem.merge({edit: snipEdits}) # roll up all edits
+                     end
+                     
+                   when String then {edit: snipEdits, spec: snipItem}
+                   when Proc then specNom.merge({spec: snipItem})
+                   else
+                     potrubi_bootstrap_surprise_exception(snipItem, eye, "snipItem unexpected")
+                   end
+
+        
+        $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "SNIP FIN", potrubi_bootstrap_logger_fmt_kls(snipList: snipList))
+
+        snipList
+
+      end
+      
+    end.flatten
+
+    dynamic_define_methods_validate_specifications(*specsNrm)
+    
+    specsRdc = Kernel.block_given? ? specsNrm.map {|s| specBlok.call(s)} : specsNrm
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, eyeTale, "specsRdc >#{specsRdc.class}< >#{specsRdc.size}< >#{specsRdc.class}< specBlok >#{specBlok}<")
+
+    potrubi_bootstrap_mustbe_array_or_croak(specsRdc, eye)
+
+  end
+  
+  def dynamic_define_methods_validate_specifications(*specsNom, &specBlok)
+    eye = :ddm_val_specs
+    eyeTale = 'DDM VAL SPEC'
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, eyeTale, "specsNom >#{specsNom.class}< >#{specsNom.size}< >#{specsNom.class}< specBlok >#{specBlok}<")
+
+    specKeys = [:edit, :spec, :name, :proc, :target]
+    
+    specsNrm = specsNom.flatten.map.with_index do | specNom, specNdx |
+
+      $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ms(eye, eyeTale, "specNdx >#{specNdx}< spceSize >#{specNom.size}<",  potrubi_bootstrap_logger_fmt_kls(specNom: specNom))
+
+      potrubi_bootstrap_mustbe_hash_or_croak(specNom, eye)
+
+      potrubi_bootstrap_mustbe_empty_or_croak(specNom.keys - specKeys, eye)
+
+      specNom
+
+    end
+    
+    specsVal = Kernel.block_given? ? specsNrm.map {|s| specBlok.call(s)} : specsNrm
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, eyeTale, "specsNom >#{specsVal.class}< >#{specsVal.size}< >#{specsVal.class}< specBlok >#{specBlok}<")
+
+    potrubi_bootstrap_mustbe_array_or_croak(specsVal, eye)
+
+  end
+  
+  # expects an array of normalised and validated hashes
+  
+  def dynamic_define_methods_apply(targetModule, *methodSpecsNom, &dynBlok)
     eye = :ddm_apl
     eyeTale = 'DDM APL'
     
-    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, eyeTale, "targetModule >#{targetModule.class}< >#{targetModule}< specs >#{methodSpecs.class}< >#{methodSpecs.size}< >#{methodSpecs.class}< dynBlok >#{dynBlok}<")
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, eyeTale, "targetModule >#{targetModule.class}< >#{targetModule}< specs >#{methodSpecsNom.class}< >#{methodSpecsNom.size}< >#{methodSpecsNom.class}< dynBlok >#{dynBlok}<")
 
+    # validate specs
+    methodSpecsRdc = dynamic_define_methods_reduce_specifications(targetModule, *methodSpecsNom)
+    
+    # any methods specs with logic to apply?
+    methodSpecs = methodSpecsRdc
+    
     # try to merge all the text methods together
 
     textMethods = []
     
-    methodSpecs.flatten.compact.each_with_index do | methodSpec, methodNdx |
+    methodSpecs.each_with_index do | methodSpec, methodNdx |
 
-      $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ms(eye, eyeTale, "methodNdx >#{methodNdx}< methodSpec >#{methodSpec.class}< >#{methodSpec}<")
+      $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ms(eye, eyeTale, "methodNdx >#{methodNdx}< methodSpec >#{methodSpec.class}< >#{methodSpec.class}<")
 
       potrubi_bootstrap_mustbe_hash_or_croak(methodSpec)
       
       case (specType = methodSpec[:spec])
       when Proc then
 
-        specName = potrubi_bootstrap_mustbe_string_or_croak((r = methodSpec[:name]) ? r.to_s : nil)
+        specName = potrubi_bootstrap_mustbe_string_or_croak((r = methodSpec[:name]) ? r.to_s : nil, eye, "proc name is nil")
         specProc = specType # potrubi_bootstrap_mustbe_proc_or_croak(mustbe_key_or_croak(methodSpec, :proc))
         
         $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "PROC BEG specName >#{specName.class}< >#{specName}< specProc >#{specProc.class}< >#{specProc}<")
 
-        textMethods.empty? || begin      # any text methods "waiting"; must be serial defined before proc
-                                dynamic_define_methods_apply_texts(targetModule, *textMethods)
-                                textMethods.clear  # none wating now
-                              end
+        if (! textMethods.empty?) then      # any text methods "waiting"; must be defined before proc
+          dynamic_define_methods_apply_texts(targetModule, *textMethods)
+          textMethods.clear  # none wating now
+        end
         
         targetModule.__send__(:define_method, specName.to_sym, &specProc) 
 
         $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "PROC FIN specName >#{specName.class}< >#{specName}< specProc >#{specProc.class}< >#{specProc}<")
-        
-      when String, Symbol then textMethods << methodSpec
+
+      when String then textMethods << methodSpec 
       when Array then textMethods << methodSpec
       else
         potrubi_bootstrap_surprise_exception(specType, "methodSpec >#{methodSpec.class}< >#{methodSpec.class}< specType >#{specType.class}< is what?")
@@ -204,7 +308,7 @@ metaclassMethods = Module.new do
 
     end
 
-    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "TXTS textMethods >#{textMethods.class}< >#{textMethods}<")
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "TXTSZ", potrubi_bootstrap_logger_fmt_kls(textMethods: textMethods))
     
     textMethods.empty? || dynamic_define_methods_apply_texts(targetModule, *textMethods)
     
@@ -213,67 +317,73 @@ metaclassMethods = Module.new do
     self
     
   end
-  #=end
 
-  def dynamic_define_methods_apply_texts(targetModule, *methodSpecs, &dynBlok)
-    eye = :ddm_apl_txt
-    eyeTale = 'DDM APL TXTS'
+  # do any of the method specification have a proc key?
+  # Implies pass whole method meth to proc and use result
+  # allow for logic in e.g. method text createion
+  # result must be array of method spec hashes
+  
+  def dynamic_define_methods_apply_procs(targetModule, *specsNom, &specBlok)
+    eye = :ddm_apl_prcs
+    eyeTale = 'DDM APL PROCS'
 
-    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, eyeTale, "targetModule >#{targetModule.class}< >#{targetModule}< specs >#{methodSpecs.class}< >#{methodSpecs}<")
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, eyeTale, "targetModule >#{targetModule.class}< >#{targetModule}< specs >#{specsNom.class}< >#{specsNom}<")
 
-    #STOPAPPLYTEXTS
+    specsVal = dynamic_define_methods_validate_specifications(*specsNom)
     
-    begin
+    specsNrm = specsVal.map.with_index do | specNom, specNdx |
+      
+      puts("#{eye} #{eyeTale} specNdx >#{specNdx}< specNom >#{specNom.class}< >#{specNom}<")
+      
+      case
+      when specNom.has_key?(:proc) then
+        r = potrubi_bootstrap_mustbe_proc_or_croak(specNom[:proc], eye).call(specNom)
+      else
+        specNom
+      end
 
-      methodTexts = methodSpecs.flatten.compact.map do | methodSpec |
+    end.flatten.compact
+    
+    dynamic_define_methods_validate_specifications(*specsNrm)
+    
+    specsPrc = Kernel.block_given? ? specsNrm.map {|s| specBlok.call(s)} : specsNrm
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, eyeTale, "targetModule >#{targetModule.class}< >#{targetModule}< specsPrc >#{specsPrc.class}< >#{specsPrc.size}<")
+
+    specsPrc.each_with_index {|s,i| puts("#{eye} #{eyeTale} i >#{i}< s >#{s.class}< >#{s}<") }
+    
+    potrubi_bootstrap_mustbe_array_or_croak(specsPrc, eye)
+
+  end
+    
+  def dynamic_define_methods_apply_texts(targetModule, *methodSpecsNom, &dynBlok)
+    eye = :ddm_apl_txt
+    eyeTale = 'DDM APL TXTS'
 
-        $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "BEG methodSpec >#{methodSpec.class}< >#{methodSpec}<\n\n\n")
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, eyeTale, "targetModule >#{targetModule.class}< >#{targetModule}<",  potrubi_bootstrap_logger_fmt_kls_size(specs: methodSpecsNom))
 
-        potrubi_bootstrap_mustbe_hash_or_croak(methodSpec)
+    methodSpecs = dynamic_define_methods_validate_specifications(*methodSpecsNom)
+    
+    begin
 
-        ###methodTextNom = potrubi_bootstrap_mustbe_string_or_croak([methodSpec[:spec]].flatten.compact.join)
+      methodTexts = methodSpecs.map do | specHash |
 
-        methodEdit = methodSpec[:edit]
-        methodText = methodSpec[:spec]
+        #$DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "BEG specHash >#{specHash.class}< >#{specHash}<\n\n\n")
+        $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "BEG",  potrubi_bootstrap_logger_fmt_kls_size(specHash: specHash))
 
-        $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "EDIT & SPEC methodEdit >#{methodEdit}< methodText >#{methodText.class}< >#{methodText}<")
+        potrubi_bootstrap_mustbe_hash_or_croak(specHash)
 
-        #STOPEDITANDTEXT
-        
-        # Resolve any snippets
-      
-        #methodSnipNom = potrubi_bootstrap_mustbe_string_or_croak(Potrubi::Mixin::TextSnippets.map_snippets_or_croak(:dynamic_methods, *methodText).flatten.compact.join)
-        methodSnippets = Potrubi::Mixin::TextSnippets.map_snippets_or_croak(:dynamic_methods, *methodText)
-        
-        $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "SNIP methodSnippets >#{methodSnippets.class}< >#{methodSnippets}<")
+        specEdit = specHash[:edit]
+        specSpec = specHash[:spec]
 
-        #STOPMETHODSNIPNOM
-        
-        snipEdits = []
-        
-        snipTexts = methodSnippets.inject([]) do | textList, snipItem |
-
-          ###puts("\nSNIP ITEM >#{snipItem.class}< >#{snipItem}<")
-               
-          textList << case snipItem
-                      when Hash
-                        snipEdits << snipItem[:edit] # collect any edits e.g. defaults
-                        ###potrubi_bootstrap_mustbe_string_or_croak(snipItem[:spec]) # return the text
-                        snipItem[:spec]
-                      when String then snipItem
-                      else
-                        potrubi_bootstrap_surprise_exception(methodTextNom, eye, "methodTextNom unexpected")
-                      end
+        $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "EDIT & SPEC specEdit >#{specEdit}< specSpec >#{specSpec.class}< >#{specSpec.class}<")
+        #$DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "EDIT & SPEC specEdit >#{specEdit}< specSpec >#{specSpec.class}< >#{specSpec}<")
 
-        end
-      
-        methodText = dynamic_apply_edits([snipEdits, methodEdit], snipTexts) # note order of edits
+        specText = dynamic_apply_edits(specEdit, specSpec) # note order of edits
 
-        $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "FIN methodEdit >#{methodEdit}< snipEdits >#{snipEdits}< methodText >#{methodText}<\n\n\n")
+        $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "FIN specEdit >#{specEdit}< specText >#{specText}<\n\n\n")
 
-        #STOPMETHODFIN
-        
-        methodText
+        specText
         
       end.flatten.compact.join("\n")
     rescue Exception => e
@@ -282,6 +392,7 @@ metaclassMethods = Module.new do
     end
     
     $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "METHODS targetModule >#{targetModule.class}< >#{targetModule}< methodTexts >#{methodTexts.class}< >\n#{methodTexts}\n<")
+    ###puts("#{eye} #{eyeTale} METHODS targetModule >#{targetModule.class}< >#{targetModule}< methodTexts >#{methodTexts.class}< >\n#{methodTexts}\n<")
 
     methodTexts && targetModule.module_eval(methodTexts)
 
@@ -290,10 +401,8 @@ metaclassMethods = Module.new do
     self
     
   end
-  #=end
 
 end
-#=end
 
 module Potrubi
   module Mixin
@@ -307,9 +416,8 @@ Potrubi::Mixin::Dynamic.__send__(:include, metaclassMethods)  # Instance Methods
 
 # must be after dynamic is up
 
-requireList = %w(text-snippets)
+requireList = %w(snippet-manager)
 requireList.each {|r| require_relative "#{r}"}
 
 __END__
 
-