potrubi 0.0.3 → 0.0.4

data/lib/potrubi/mixin/script.rb

@@ -3,9 +3,6 @@
 
 require_relative '../core'
 
-#requireList = %w(bootstrap)
-#requireList.each {|r| require_relative "#{r}"}
-
 mixinContent = Module.new do
 
   include Potrubi::Bootstrap
@@ -13,7 +10,6 @@ mixinContent = Module.new do
    # Script Methods
    # ##############
    
-   #=begin
    def find_script_name_or_croak(scriptPath=$0)
      File.basename(scriptPath, ".*")
    end
@@ -46,7 +42,6 @@ mixinContent = Module.new do
    def find_script_config_directory_or_croak(dirName='config', scriptPath=$0)
      find_script_peer_directory_or_croak(dirName, scriptPath)
    end
-   #=end
    
  end
 

data/lib/potrubi/mixin/{text-snippets → snippet-dictionaries}/methods-text-snippets.rb

@@ -1,9 +1,71 @@
 
-# potrubi text snippets
+# potrubi method text snippets
 
-# methods dictionary
+# dynamic methods dictionary
 
+# Procs
 
+Proc.new do
+  
+  isvaluecontractcollectionwithnilvaluesProc = ->(spec) {
+    eye = :'is_val_con_col'
+    
+    require 'potrubi/klass/syntax/braket'
+    
+    targetModule = potrubi_bootstrap_mustbe_module_or_croak(spec[:target], eye)
+    
+    specEdit = potrubi_bootstrap_mustbe_hash_or_croak(spec[:edit], eye)
+
+    mustbeContracts = potrubi_bootstrap_mustbe_hash_or_croak(specEdit[:VALUE_CONTRACTS], eye, 'CONTRACT_RECIPES not hash')
+
+    braketKls = Potrubi::Klass::Syntax::Braket
+
+    braketMethod = braketKls.new_method
+
+    braketDefBeg = braketKls.new_statement.push('def is_value_MUSTBE_NAME?(testValue)')
+
+    braketCollection = braketKls.new_statement.push('testValue.is_a?(Hash) &&')
+
+    braketItems = mustbeContracts.map do | key, contract |
+
+      #  if value is nil don't test
+      
+      braketKls.new_statement.push(
+                                   '((r = testValue[:',
+                                   key,
+                                   ']) ? ',
+                                   'is_value_',
+                                   key,
+                                   '?(r) : true)',
+                                   ' && '
+                                   )
+
+    end
+
+    braketResult = braketKls.new_statement.push('testValue')
+
+    braketDefEnd = braketKls.new_statement.push('end')
+    
+    braketMethod.push(braketDefBeg,
+                      braketCollection,
+                      braketItems,
+                      braketResult,
+                      braketDefEnd,
+                      )
+    
+    specText = braketMethod.to_s
+
+    # Generate the contracts for the allowed values
+    Potrubi::Mixin::ContractRecipes.recipe_mustbes(targetModule, mustbeContracts)
+
+    {edit: specEdit, spec: specText}
+    
+  }
+
+
+
+
+# Texts
 
         mustbeMethodOneArgText = <<-'ENDOFMUSTBESCALARMETHOD'
         def mustbe_MUSTBE_NAME_or_croak(testValue, *tellTales)
@@ -17,7 +79,6 @@
           Kernel.block_given? ? r.map {|v| procBlok.call(v) } : r
         end;
         def mustbe_MUSTBE_NAME_key_or_nil_with_proc_or_croak(testValue, keyName, *tellTales, &procBlok)
-          #(r = is_value_key?(testValue, keyName)) ? mustbe_MUSTBE_NAME_with_proc_or_croak(r, *tellTales, &procBlok) : nil
           (r = is_value_key?(testValue, keyName)) && mustbe_MUSTBE_NAME_with_proc_or_croak(r, *tellTales, &procBlok)
         end;
         ENDOFMUSTBEARRAYMETHOD
@@ -28,8 +89,7 @@
           Kernel.block_given? ? r.each_with_object({}) {|(k,v), h| h[k] = procBlok.call(v) } : r
         end;
         def mustbe_MUSTBE_NAME_key_or_nil_with_proc_or_croak(testValue, keyName, *tellTales, &procBlok)
-          #(r = is_value_key?(testValue, keyName)) ? mustbe_MUSTBE_NAME_with_proc_or_croak(r, *tellTales, &procBlok) : nil
-          (r = is_value_key?(testValue, keyName)) && mustbe_MUSTBE_NAME_with_proc_or_croak(r, *tellTales, &procBlok)
+           (r = is_value_key?(testValue, keyName)) && mustbe_MUSTBE_NAME_with_proc_or_croak(r, *tellTales, &procBlok)
         end;
         ENDOFMUSTBEHASHMETHOD
         
@@ -40,9 +100,9 @@
         ENDOFMUSTBERESULTMETHOD
         
         mustbeMethodCollectionsText = <<-'ENDOFHERE'
-        def mustbe_MUSTBE_NAMEs_or_croak(*testValues, &procBlock)  # collections
+        def mustbe_MUSTBE_NAME_list_or_croak(testValues, &procBlock)  # collections
           haveBlock = Kernel.block_given? && procBlock
-          testValues.map {|v| r = mustbe_MUSTBE_NAME_or_croak(v, 'mustbe_MUSTBE_NAME_or_croak failed'); haveBlock ? haveBlock.call(r) : r}
+           testValues.map {|v| mustbe_MUSTBE_NAME_or_croak((haveBlock ? haveBlock.call(v) : v), 'mustbe_MUSTBE_NAME') }
         end;                                    
         ENDOFHERE
 
@@ -68,38 +128,31 @@
         
         isvalueMethodText = <<-'ENDOFISVALUEMETHOD'
         def is_value_MUSTBE_NAME?(testValue)
-          IS_VALUE_TEST ? testValue : nil
-        end;
+          r = IS_VALUE_TEST ? testValue : nil
+         end;
         ENDOFISVALUEMETHOD
 
         isvaluecollectionwithkeysMethodText = <<-'ENDOFHERE'
         def is_value_MUSTBE_NAME?(testValue)
-          #puts("\nCOLLECTION WITH KEYS MUSTBE_NAME KEY_NAMES >#{KEY_NAMES}< testValue >#{testValue}< >#{testValue}<")
-          #(testValue.is_a?(Hash) && is_value_subset?(testValue.keys, KEY_NAMES)) ? testValue : nil
-          testValue.is_a?(Hash) && is_value_subset?(testValue.keys, KEY_NAMES) && testValue
+           testValue.is_a?(Hash) && is_value_subset?(testValue.keys, KEY_NAMES) && testValue
         end;
         ENDOFHERE
 
         isvaluetypedarrayMethodText = <<-'ENDOFHERE'
         def is_value_MUSTBE_NAME?(testValue)
-          #puts("\nTYPED ARRAY MUSTBE_NAME VALUE_TYPE testValue >#{testValue}< >#{testValue}<")
-          #(testValue.is_a?(Array) && (testValue.all? {|v| v ? is_value_VALUE_TYPE?(v) : VALUE_IS_NIL_RESULT })) ? testValue : nil
-          testValue.is_a?(Array) && (testValue.all? {|v| v ? is_value_VALUE_TYPE?(v) : VALUE_IS_NIL_RESULT }) && testValue
+           testValue.is_a?(Array) && (testValue.all? {|v| v ? is_value_VALUE_TYPE?(v) : VALUE_IS_NIL_RESULT }) && testValue
         end;
         ENDOFHERE
         
-        isvaluetypedcollectionMethodText = <<-'ENDOFHERE'
+         isvaluetypedcollectionMethodText = <<-'ENDOFHERE'
         def is_value_MUSTBE_NAME?(testValue)
-          #puts("TYPED COLLECTION MUSTBE_NAME KEY_TYPE VALUE_TYPE testValue >#{testValue}< >#{testValue}<")
-          #(testValue.is_a?(Hash) && (testValue.all? {|k,v| is_value_KEY_TYPE?(k) && (v ? is_value_VALUE_TYPE?(v) : VALUE_IS_NIL_RESULT) })) ? testValue : nil
-          testValue.is_a?(Hash) && (testValue.all? {|k,v| is_value_KEY_TYPE?(k) && (v ? is_value_VALUE_TYPE?(v) : VALUE_IS_NIL_RESULT) }) && testValue
+           testValue.is_a?(Hash) && (testValue.all? {|k,v|  IS_COLLECTION_KEY_TEST && (v ? IS_COLLECTION_VALUE_TEST : VALUE_IS_NIL_RESULT) }) && testValue
         end;
         ENDOFHERE
-
+         
         isvaluetypedcollectionwithkeysMethodText = <<-'ENDOFHERE'
         def is_value_MUSTBE_NAME?(testValue)
-          #puts("\nTYPED COLLECTION WITH KEYS MUSTBE_NAME KEY_TYPE VALUE_TYPE KEY_NAMES >#{KEY_NAMES}< testValue >#{testValue}< >#{testValue}<")
-          (testValue.is_a?(Hash) && is_value_subset?(testValue.keys, KEY_NAMES) && (testValue.all? {|k,v| is_value_KEY_TYPE?(k) && (v ? is_value_VALUE_TYPE?(v) : VALUE_IS_NIL_RESULT) })) ? testValue : nil
+           (testValue.is_a?(Hash) && is_value_subset?(testValue.keys, KEY_NAMES) && (testValue.all? {|k,v| is_value_KEY_TYPE?(k) && (v ? is_value_VALUE_TYPE?(v) : VALUE_IS_NIL_RESULT) })) ? testValue : nil
         end;
         ENDOFHERE
         
@@ -109,7 +162,6 @@
 
         isvaluevalueisAliasText = '' # TURN OFF ALIAS - TOO DNAGEROUS IF IS_VALUE OVERRIDDEN
 
-
         mustbeMethodKeyText = <<-'ENDOFMUSTBEKEYMETHOD'
         def mustbe_MUSTBE_NAME_key_or_croak(testValue, keyName, *tellTales)
           mustbe_MUSTBE_NAME_or_croak(mustbe_key_or_croak(testValue, keyName, *tellTales), *tellTales)
@@ -119,13 +171,39 @@
         end;
         ENDOFMUSTBEKEYMETHOD
 
+        findMethodKeyText = <<-'ENDOFHERE'
+        def find_MUSTBE_NAME_key_or_croak(testValue, *tellTales)
+          mustbe_MUSTBE_NAME_or_croak(mustbe_key_or_croak(testValue, :MUSTBE_KEY_NAME, *tellTales), *tellTales)
+        end;
+        def find_MUSTBE_NAME_key_or_nil_or_croak(testValue, *tellTales)
+          mustbe_MUSTBE_NAME_key_or_nil_or_croak(testValue, :MUSTBE_KEY_NAME, *tellTales)
+        end;
+        ENDOFHERE
+
+        setMethodKeyText = <<-'ENDOFHERE'
+        def set_MUSTBE_NAME_key_or_croak(setHash, setValue, *tellTales)
+          mustbe_hash_or_croak(setHash)[:MUSTBE_KEY_NAME] = mustbe_MUSTBE_NAME_or_croak(setValue, *tellTales)
+          setHash
+        end;
+        ENDOFHERE
+
+        getMethodKeyNameText = <<-'ENDOFHERE'
+        def get_MUSTBE_NAME_key_name
+          :MUSTBE_KEY_NAME
+        end;
+        ENDOFHERE
+        
+        mergeMethodKeyText = <<-'ENDOFHERE'
+        def merge_MUSTBE_NAME_key_or_croak(mergeHash, mergeValue, *tellTales)
+          mustbe_hash_or_croak(mergeHash).merge(:MUSTBE_KEY_NAME => mustbe_MUSTBE_NAME_or_croak(mergeValue, *tellTales))
+        end;
+        ENDOFHERE
+        
         mustbeMethodSubsetText = <<-'ENDOFMUSTBESUBSETMETHOD'
         def mustbe_subset_or_croak(subSet, superSet, *tellTales)
-          ###mustbe_empty_or_croak(mustbe_array_or_croak(subSet, :mustbe_subset1, *tellTales) - mustbe_array_or_croak(superSet, :mustbe_subset2, *tellTales), :mustbe_subset, *tellTales)
           (r = is_value_subset?(subSet, superSet)) ? r : contract_exception(subSet, "value failed is_value_subset? test on superSet >#{superSet}<", *tellTales)
         end;
         def is_value_subset?(subSet, superSet)
-          #(subSet.is_a?(Array) && superSet.is_a?(Array) && (subSet - superSet).empty?) ? subSet : nil
           subSet.is_a?(Array) && superSet.is_a?(Array) && (subSet - superSet).empty? && subSet
         end
         ENDOFMUSTBESUBSETMETHOD
@@ -139,39 +217,39 @@
 
         mustbeMethodCompareText = <<-'ENDOFMETHOD'
           def mustbe_MUSTBE_NAME_or_croak(arg1, arg2, *args)
-            #eye = :MUSTBE_NAME
             arg1.is_a?(arg2.class) || contract_exception(arg1, :MUSTBE_NAME, "DIFFERNT CLASSES arg1 >#{arg1.class}< >#{arg1}< arg2 >#{arg2.class}< >#{arg2}< opr >MUSTBE_SPEC<", *args)
             argC = (arg1 MUSTBE_SPEC arg2)
-            # puts "<=> #{eye} argC >#{argC.class}< >#{argC}< arg1 >#{arg1.class}< >#{arg1}< arg2 >#{arg2.class}< >#{arg2}< opr >MUSTBE_SPEC<"
             argC ? arg1 : contract_exception(argC, "argC >#{argC.class}< >#{argC}< arg1 >#{arg1.class}< >#{arg1}< arg2 >#{arg2.class}< >#{arg2}< opr >MUSTBE_SPEC<", *args)
           end;                            
           ENDOFMETHOD
 
-        
-        snippetAccessor = <<-'ENDOFHERE'
+        # accessors
+
+        snippetBaseAccessor = <<-'ENDOFHERE'
           def ACCESSOR_NAME
-            @ACCESSOR_NAME ||= nil
+            @ACCESSOR_NAME ||= ACCESSOR_DEFAULT
           end;
-          def ACCESSOR_NAME=(value)
+          def reset_ACCESSOR_NAME
+            @ACCESSOR_NAME = nil
+          end;         
+          alias_method :'get_ACCESSOR_NAME', :'ACCESSOR_NAME'
+        ENDOFHERE
+
+        snippetAccessor = <<-'ENDOFHERE'
+           def ACCESSOR_NAME=(value)
             @ACCESSOR_NAME = value
           end;
+          alias_method :'set_ACCESSOR_NAME', :'ACCESSOR_NAME='
         ENDOFHERE
           
         snippetAccessorWithContractText = <<-'ENDOFHERE'
-          def ACCESSOR_NAME
-            @ACCESSOR_NAME ||= nil
-          end;
-          def reset_ACCESSOR_NAME
-            @ACCESSOR_NAME = nil
-          end;
-          def find_ACCESSOR_NAME_or_croak
-            mustbe_ACCESSOR_CONTRACT_or_croak(ACCESSOR_NAME, :f_ACCESSOR_NAME, "value not ACCESSOR_CONTRACT")
-          end;
           def ACCESSOR_NAME=(value)
             @ACCESSOR_NAME = mustbe_ACCESSOR_CONTRACT_or_croak(value, :s_ACCESSOR_NAME, "value not ACCESSOR_CONTRACT")
           end;
           alias_method :'set_ACCESSOR_NAME', :'ACCESSOR_NAME='
-          alias_method :'get_ACCESSOR_NAME', :'ACCESSOR_NAME'
+          def find_ACCESSOR_NAME_or_croak
+            mustbe_ACCESSOR_CONTRACT_or_croak(ACCESSOR_NAME, :f_ACCESSOR_NAME, "value not ACCESSOR_CONTRACT")
+          end;
         ENDOFHERE
 
           accessorEdits = {
@@ -182,30 +260,39 @@
 
           valueisnilresultEdits = {VALUE_IS_NIL_RESULT: 'false'}  # default for typed collections is not ok if nil
           
-          packageMustbeText = [mustbeMethodOneArgText, mustbeMethodKeyText, mustbeCommonText, isvalueMethodText, isvaluevalueisAliasText].flatten.join
+          packageMustbeText = [mustbeMethodOneArgText, mustbeMethodKeyText, findMethodKeyText, setMethodKeyText, getMethodKeyNameText, mergeMethodKeyText, mustbeCommonText, isvalueMethodText, isvaluevalueisAliasText].flatten.join
 
-          packageAccessorSpec = [snippetAccessor].flatten
+          packageAccessorSpec = [snippetBaseAccessor, snippetAccessor].flatten
           
           packageAccessorWithContractBaseSpec = [mustbeMethodOneArgText, mustbeMethodKeyText,  mustbeMethodOneArgOrNilText, isvaluevalueisAliasText].flatten
           packageAccessorWithContractSpec = [isvalueMethodText, packageAccessorWithContractBaseSpec].flatten
           packageAccessorWithContractNoIsValueSpec = packageAccessorWithContractBaseSpec
           
           packageAccessorText = Potrubi::Mixin::Dynamic::dynamic_apply_edits(accessorEdits, packageAccessorSpec)
-          packageAccessorWithContractText = Potrubi::Mixin::Dynamic::dynamic_apply_edits(accessorEdits, snippetAccessorWithContractText, packageAccessorWithContractSpec)
-          packageAccessorWithContractNoIsValueText = Potrubi::Mixin::Dynamic::dynamic_apply_edits(accessorEdits, snippetAccessorWithContractText, packageAccessorWithContractNoIsValueSpec) 
+          packageAccessorWithContractText = Potrubi::Mixin::Dynamic::dynamic_apply_edits(accessorEdits, snippetBaseAccessor, snippetAccessorWithContractText, packageAccessorWithContractSpec)
+          packageAccessorWithContractNoIsValueText = Potrubi::Mixin::Dynamic::dynamic_apply_edits(accessorEdits, snippetBaseAccessor, snippetAccessorWithContractText, packageAccessorWithContractNoIsValueSpec) 
 
+          packageAccessorEdit = {
+            'ACCESSOR_DEFAULT' => 'nil',
+          }
+          
           dynamicMethodTexts = {
 
             # accessors
             
-            package_accessor: packageAccessorText,
-            package_accessor_with_contract: packageAccessorWithContractText,
-            package_accessor_with_contract_no_is_value: packageAccessorWithContractNoIsValueText,
+            package_accessor: {edit: packageAccessorEdit, spec: packageAccessorText},
+            package_accessor_with_contract: {edit: packageAccessorEdit, spec: packageAccessorWithContractText},
+            package_accessor_with_contract_no_is_value: {edit: packageAccessorEdit, spec: packageAccessorWithContractNoIsValueText},
 
             method_accessor_is_value_collection_with_keys: {edit: valueisnilresultEdits, spec: Potrubi::Mixin::Dynamic::dynamic_apply_edits(accessorEdits, isvaluecollectionwithkeysMethodText)},
             method_accessor_is_value_typed_collection: {edit: valueisnilresultEdits, spec: Potrubi::Mixin::Dynamic::dynamic_apply_edits(accessorEdits, isvaluetypedcollectionMethodText)},
             method_accessor_is_value_typed_collection_with_keys: {edit: valueisnilresultEdits, spec: Potrubi::Mixin::Dynamic::dynamic_apply_edits(accessorEdits, isvaluetypedcollectionwithkeysMethodText)},
 
+            method_accessor_is_value_typed_hash: {edit: valueisnilresultEdits, spec: Potrubi::Mixin::Dynamic::dynamic_apply_edits(accessorEdits, isvaluetypedcollectionMethodText)},
+            method_accessor_is_value_typed_hash_with_keys: {edit: valueisnilresultEdits, spec: Potrubi::Mixin::Dynamic::dynamic_apply_edits(accessorEdits, isvaluetypedcollectionwithkeysMethodText)},
+            
+            method_accessor_is_value_typed_array: {edit: valueisnilresultEdits, spec: Potrubi::Mixin::Dynamic::dynamic_apply_edits(accessorEdits, isvaluetypedarrayMethodText, mustbeArrayWithProcText)},
+            
             # contracts
             
             package_mustbe: packageMustbeText,
@@ -224,6 +311,8 @@
             method_mustbe_is_value_typed_array: {edit: valueisnilresultEdits, spec: [isvaluetypedarrayMethodText, mustbeArrayWithProcText]},
             
             method_mustbe_is_value_typed_collection_with_keys: {edit: valueisnilresultEdits, spec: isvaluetypedcollectionwithkeysMethodText},
+
+            method_mustbe_is_value_contract_collection_with_nil_values: {proc: isvaluecontractcollectionwithnilvaluesProc},
             
             method_mustbe_hash_with_proc: mustbeHashWithProcText,
             method_mustbe_array_with_proc: mustbeArrayWithProcText,
@@ -250,5 +339,5 @@
           
 
 
+end
 __END__
-        

data/lib/potrubi/mixin/{text-snippets.rb → snippet-manager.rb}

@@ -1,19 +1,19 @@
 
 # potrubi text snippets
 
-# looks up sniipets by name in dictionaries
+# looks up snippets by name in dictionaries
 
 # values normally code to be dynamically dused by e.g. Dynamic and COntract
 
 require_relative '../bootstrap'
 
-#requireList = %w(dynamic)
-#requireList.each {|r| require_relative "#{r}"}
-
 mixinContent = Module.new do
   
   include Potrubi::Bootstrap
 
+  # Dictionary Methods
+  # ##################
+
   def dictionary_index
     @dictionary_index ||= {}
   end
@@ -35,7 +35,14 @@ mixinContent = Module.new do
   def is_value_dictionary_name?(dictName)
     dictionary_index[normalise_dictionary_name(dictName)]
   end
-    
+
+  def find_dictionary_home_or_croak
+    eye = :'f_dict_home'
+    dictHome = File.expand_path(__FILE__ + "/../snippet-dictionaries")
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ca(eye, "dictHome >#{dictHome.class}< >#{dictHome}<")
+    dictHome
+  end
+  
   def find_dictionary_or_croak(dictName, &dictBlok)
     eye = :'f_dict'
     eyeTale = 'FIND SNIP DICT'
@@ -62,8 +69,13 @@ mixinContent = Module.new do
     
   end
 
+  def load_home_dictionaries_or_croak(snipDicts)
+    dictHome = find_dictionary_home_or_croak
+    snipDictsHome = potrubi_bootstrap_mustbe_hash_or_croak(snipDicts).each_with_object({}) { | (k,v), h| h[k] = File.join(dictHome, "#{v}.rb") }
+    load_dictionaries_or_croak(snipDictsHome)
+  end
+  
   def load_dictionaries_or_croak(snipDicts)
-    #potrubi_bootstrap_mustbe_hash_or_croak(snipDicts).each {|k,v| puts("LOAD DICT k >#{k}< v >#{v}<"); load_dictionary_or_croak(k, v) }
     potrubi_bootstrap_mustbe_hash_or_croak(snipDicts).each {|k,v| load_dictionary_or_croak(k, v) }
   end
   
@@ -75,8 +87,17 @@ mixinContent = Module.new do
 
     ### let require work it ok potrubi_bootstrap_mustbe_file_or_croak(dictPath, eye, "dictPath not a file")
 
-    dictHash = potrubi_bootstrap_mustbe_hash_or_croak(instance_eval(File.open(dictPath).readlines.join("\n")))
+    dictResult = instance_eval(File.read(dictPath))
 
+    dictHash = case dictResult
+               when Hash then dictResult
+               when Proc then dictResult.call
+               else
+                 potrubi_bootstrap_surprise_exception(dictResult, eye, "dictResult is what?")
+               end
+
+    potrubi_bootstrap_mustbe_hash_or_croak(dictHash, eye)
+    
     dictNameNrm = normalise_dictionary_name(dictName)
     
     add_dictionaries_to_index(dictNameNrm => dictHash)
@@ -87,6 +108,9 @@ mixinContent = Module.new do
     
   end
 
+  # Snippet Methods
+  # ###############
+  
   def map_snippets_or_croak(dictName, *snippetList, &snipBlok)
     eye = :'map_snippets'
     eyeTale = 'MAP SNIPPETS'
@@ -97,7 +121,7 @@ mixinContent = Module.new do
 
     snippetMaps = snippetList.flatten(1).map { | snippetName | snippetHash.has_key?(snippetName) ? snippetHash[snippetName] : snippetName }
     
-    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, eyeTale, "dictName >#{dictName}< snippetMaps >#{snippetMaps}<")
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, eyeTale, "dictName >#{dictName}<", potrubi_bootstrap_logger_fmt_kls_size(snippetMaps: snippetMaps))
     
     potrubi_bootstrap_mustbe_array_or_croak(snippetMaps, eye)
     
@@ -111,7 +135,7 @@ mixinContent = Module.new do
   # if snippetName not present, calls block if given, else exception
   
   def find_snippets_or_croak(dictName, *snippetList, &snipBlok)
-    eye = :'f_snippets'
+    eye = :f_snips
     eyeTale = 'FIND SNIPPETS'
 
     $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, eyeTale, "dictName >#{dictName}< snippetList >#{snippetList}<  snipBlok >#{snipBlok}<")
@@ -122,7 +146,15 @@ mixinContent = Module.new do
       case snippetName
       when Symbol then
         case
-        when dictHash.has_key?(snippetName) then h[snippetName] = dictHash[snippetName]
+        when dictHash.has_key?(snippetName) then
+          snippetValueNom = dictHash[snippetName]
+          snippetValueNrm = case snippetValueNom
+                            when Proc then
+                              dictHash[snippetName] = snippetValueNom.call # update dict
+                            else
+                              snippetValueNom
+                            end
+          h[snippetName] = snippetValueNrm
         else
           h[snippetName] = Kernel.block_given? ? snipBlok.call(dictHash, snippetName) : potrubi_bootstrap_mustbe_not_nil_or_croak(dictHash[snippetName], eye, "snippetName >#{snippetName}< not found")
         end
@@ -131,52 +163,32 @@ mixinContent = Module.new do
       end
     end
     
-    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, eyeTale, "dictName >#{dictName}< snippetMaps >#{snippetMaps}<")
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, eyeTale, "dictName >#{dictName}< snippetMaps >#{snippetMaps.size}<")
     
     potrubi_bootstrap_mustbe_hash_or_croak(snippetMaps, eye)
     
   end
+
+  
 end
+
 module Potrubi
   module Mixin
-    module TextSnippets
+    module SnippetManager
     end
   end
 end
 
-##Potrubi::Mixin::TextSnippets.__send__(:include, mixinContent)  # Instance Methods
-Potrubi::Mixin::TextSnippets.extend(mixinContent)  # Module  Methods
+##Potrubi::Mixin::SnippetManager.__send__(:include, mixinContent)  # Instance Methods
+Potrubi::Mixin::SnippetManager.extend(mixinContent)  # Module  Methods
 
 # load some dictionaries
 
 #$DEBUG = true
 #$DEBUG_POTRUBI_BOOTSTRAP = true
 
-snipDicts = {dynamic_methods: File.expand_path(__FILE__ + "/../text-snippets/methods-text-snippets.rb")}
-Potrubi::Mixin::TextSnippets.load_dictionaries_or_croak(snipDicts)
-
-#STOPHERELOADSNIPDICTS
-
-__END__
-
-# quick test
-
-
-$DEBUG = true
-$DEBUG_POTRUBI_BOOTSTRAP = true
-
-Potrubi::Mixin::TextSnippets.find_dictionary_or_croak(:dynamic_methods)
-
-#Potrubi::Mixin::TextSnippets.load_dictionary_or_croak('.x/y') # fail
-
-snipLook = Potrubi::Mixin::TextSnippets.find_snippets_or_croak(:dynamic_methods, :package_mustbe)
-
-puts("snipLook >#{snipLook.class}< >#{snipLook}<")
-
-snipLook = Potrubi::Mixin::TextSnippets.find_snippets_or_croak(:dynamic_methods, :package_mustbe) { |d,s| s } # will work
-
-snipLook = Potrubi::Mixin::TextSnippets.find_snippets_or_croak(:dynamic_methods, :xxxxxxpackage_mustbe) # will fail
 
+snipDicts = {dynamic_methods: :'methods-text-snippets'}
+Potrubi::Mixin::SnippetManager.load_home_dictionaries_or_croak(snipDicts)
 
 __END__
-