potrubi 0.0.1 → 0.0.2

data/lib/potrubi/mixin/script.rb

@@ -0,0 +1,59 @@
+
+# potrubi  methods for top level scripts
+
+require_relative '../core'
+
+#requireList = %w(bootstrap)
+#requireList.each {|r| require_relative "#{r}"}
+
+mixinContent = Module.new do
+
+  include Potrubi::Bootstrap
+
+   # Script Methods
+   # ##############
+   
+   #=begin
+   def find_script_name_or_croak(scriptPath=$0)
+     File.basename(scriptPath, ".*")
+   end
+   def find_script_directory_or_croak(scriptPath=$0)
+     potrubi_bootstrap_mustbe_directory_or_croak(File.dirname(scriptPath))
+   end
+   
+   def find_script_home_directory_or_croak(scriptPath=$0)
+     potrubi_bootstrap_mustbe_directory_or_croak(File.expand_path(File.join(find_script_directory_or_croak(scriptPath), '/../')))
+   end
+   alias_method :find_script_home_or_croak, :find_script_home_directory_or_croak
+   
+   def find_script_lib_directory_or_croak(scriptPath=$0)
+     potrubi_bootstrap_mustbe_directory_or_croak(File.join(find_script_home_directory_or_croak(scriptPath), 'lib'))
+   end
+   alias_method :find_script_lib_or_croak, :find_script_lib_directory_or_croak
+
+   def find_script_peer_directory_or_croak(peerName, scriptPath=$0)
+     potrubi_bootstrap_mustbe_directory_or_croak(File.expand_path(File.join(find_script_home_directory_or_croak(scriptPath), peerName, find_script_name_or_croak(scriptPath))))
+   end
+   
+   def find_script_data_directory_or_croak(dirName='data', scriptPath=$0)
+     find_script_peer_directory_or_croak(dirName, scriptPath)
+   end
+   
+   def find_script_results_directory_or_croak(dirName='results', scriptPath=$0)
+     find_script_peer_directory_or_croak(dirName, scriptPath)
+   end
+   
+   def find_script_config_directory_or_croak(dirName='config', scriptPath=$0)
+     find_script_peer_directory_or_croak(dirName, scriptPath)
+   end
+   #=end
+   
+ end
+
+mixinConstant = Potrubi::Core.assign_mixin_constant_or_croak(mixinContent, __FILE__)
+ 
+mixinConstant.extend(mixinContent) # Class Methods - more likely use case
+
+__END__
+
+ 

data/lib/potrubi/mixin/text-snippets.rb

@@ -0,0 +1,182 @@
+
+# potrubi text snippets
+
+# looks up sniipets 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
+
+  def dictionary_index
+    @dictionary_index ||= {}
+  end
+  def dictionary_index=(dictNew)
+    @dictionary_index = potrubi_bootstrap_mustbe_hash_or_croak(dictNew)
+  end
+
+  def add_dictionaries_to_index(snipDicts)
+    potrubi_bootstrap_mustbe_hash_or_croak(snipDicts)
+    snipIndex = dictionary_index
+    newsnipIndex = snipIndex.merge(snipDicts.each_with_object({}) {|(k,v),h| h[normalise_dictionary_name(k)] = potrubi_bootstrap_mustbe_hash_or_croak(v) })
+    self.dictionary_index = newsnipIndex
+  end
+  
+  def normalise_dictionary_name(dictName)
+    dictName.to_s.to_sym
+  end
+  
+  def is_value_dictionary_name?(dictName)
+    dictionary_index[normalise_dictionary_name(dictName)]
+  end
+    
+  def find_dictionary_or_croak(dictName, &dictBlok)
+    eye = :'f_dict'
+    eyeTale = 'FIND SNIP DICT'
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, eyeTale, "dictName >#{dictName.class}< >#{dictName.class}< dictBlok >#{dictBlok}<")
+
+    dictHash = case dictName
+               when Hash then dictName
+               when String, Symbol then
+                 case
+                 when (r = is_value_dictionary_name?(dictName)) then r
+                 else
+                 potrubi_bootstrap_surprise_exception(dictName, "dictName is not a dictionary")
+                 end
+               else
+                 potrubi_bootstrap_surprise_exception(dictName, "dictName is what?")
+               end
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, eyeTale, "dictName >#{dictName.class}< >#{dictName}< dictHash >#{dictHash.size}<")
+
+    # dictionaries must be hashes
+    
+    potrubi_bootstrap_mustbe_hash_or_croak(dictHash, eye, "dictName >#{dictName}< not a hash")
+    
+  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
+  
+  def load_dictionary_or_croak(dictName, dictPath, &dictBlok)
+    eye = :'l_dict'
+    eyeTale = 'LOAD DICT FILE'
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, eyeTale, "dictName >#{dictName.class}< >#{dictName}< dictPath >#{dictPath.class}< >#{dictPath}< dictBlok >#{dictBlok}<")
+
+    ### 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")))
+
+    dictNameNrm = normalise_dictionary_name(dictName)
+    
+    add_dictionaries_to_index(dictNameNrm => dictHash)
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, eyeTale, "dictName >#{dictNameNrm.class}< >#{dictNameNrm}< dictHash >#{dictHash.size}< >#{dictHash}<")
+    
+    dictHash
+    
+  end
+
+  def map_snippets_or_croak(dictName, *snippetList, &snipBlok)
+    eye = :'map_snippets'
+    eyeTale = 'MAP SNIPPETS'
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, eyeTale, "dictName >#{dictName}< snippetList >#{snippetList}<  snipBlok >#{snipBlok}<")
+
+    snippetHash = find_snippets_or_croak(dictName, *snippetList)
+
+    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}<")
+    
+    potrubi_bootstrap_mustbe_array_or_croak(snippetMaps, eye)
+    
+  end
+
+  # looks up a array of possible snippets
+  # retruns a hash of snippetName, snippetValue pairs
+
+  # if snippetName not Symbol, ignores
+
+  # if snippetName not present, calls block if given, else exception
+  
+  def find_snippets_or_croak(dictName, *snippetList, &snipBlok)
+    eye = :'f_snippets'
+    eyeTale = 'FIND SNIPPETS'
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, eyeTale, "dictName >#{dictName}< snippetList >#{snippetList}<  snipBlok >#{snipBlok}<")
+
+    dictHash = find_dictionary_or_croak(dictName)
+
+    snippetMaps = snippetList.flatten(1).uniq.each_with_object({}) do | snippetName, h |
+      case snippetName
+      when Symbol then
+        case
+        when dictHash.has_key?(snippetName) then h[snippetName] = dictHash[snippetName]
+        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
+      else
+        ###snippetName   # ignore 
+      end
+    end
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, eyeTale, "dictName >#{dictName}< snippetMaps >#{snippetMaps}<")
+    
+    potrubi_bootstrap_mustbe_hash_or_croak(snippetMaps, eye)
+    
+  end
+end
+module Potrubi
+  module Mixin
+    module TextSnippets
+    end
+  end
+end
+
+##Potrubi::Mixin::TextSnippets.__send__(:include, mixinContent)  # Instance Methods
+Potrubi::Mixin::TextSnippets.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
+
+
+__END__
+

data/lib/potrubi/mixin/text-snippets/methods-text-snippets.rb

@@ -0,0 +1,254 @@
+
+# potrubi text snippets
+
+# methods dictionary
+
+
+
+        mustbeMethodOneArgText = <<-'ENDOFMUSTBESCALARMETHOD'
+        def mustbe_MUSTBE_NAME_or_croak(testValue, *tellTales)
+          is_value_MUSTBE_NAME?(testValue) ? testValue : contract_exception(testValue, "value failed is_value_MUSTBE_NAME?", *tellTales)
+        end;
+        ENDOFMUSTBESCALARMETHOD
+
+        mustbeArrayWithProcText = <<-'ENDOFMUSTBEARRAYMETHOD'
+        def mustbe_MUSTBE_NAME_with_proc_or_croak(testValue, *tellTales, &procBlok)
+          r =  mustbe_MUSTBE_NAME_or_croak(testValue, *tellTales)
+          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
+
+        mustbeHashWithProcText = <<-'ENDOFMUSTBEHASHMETHOD'
+        def mustbe_MUSTBE_NAME_with_proc_or_croak(testValue, *tellTales, &procBlok)
+          r = mustbe_MUSTBE_NAME_or_croak(testValue, *tellTales, &procBlok)
+          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)
+        end;
+        ENDOFMUSTBEHASHMETHOD
+        
+        mustbeMethodResultText = <<-'ENDOFMUSTBERESULTMETHOD'
+        def mustbe_MUSTBE_NAME_or_croak(testValue, *tellTales)
+          (r = is_value_MUSTBE_NAME?(testValue)) ? r : contract_exception(testValue, "value failed is_value_MUSTBE_NAME? test", *tellTales)
+        end;
+        ENDOFMUSTBERESULTMETHOD
+        
+        mustbeMethodCollectionsText = <<-'ENDOFHERE'
+        def mustbe_MUSTBE_NAMEs_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}
+        end;                                    
+        ENDOFHERE
+
+        mustbeMethodOneArgOrNilText = <<-'ENDOFHERE'
+        def mustbe_MUSTBE_NAME_or_nil_or_croak(argOne, *tellTales) # or nil method
+          argOne && mustbe_MUSTBE_NAME_or_croak(argOne, *tellTales)
+        end;
+        ENDOFHERE
+        
+        mustbeMethodTwoArgOrNilText = <<-'ENDOFHERE'
+        def mustbe_MUSTBE_NAME_or_nil_or_croak(argOne, argTwo, *tellTales) # or nil method
+          argOne && mustbe_MUSTBE_NAME_or_croak(argOne, argTwo, *tellTales)
+        end;
+        ENDOFHERE
+        
+        mustbeCommonText = [mustbeMethodOneArgOrNilText, mustbeMethodCollectionsText].join
+        
+        mustbeMethodOneArgOrNilWithProcText = <<-'ENDOFHERE'
+        def mustbe_MUSTBE_NAME_or_nil_with_proc_or_croak(argOne, *tellTales, &procBlok) # or nil method
+          argOne && mustbe_MUSTBE_NAME_with_proc_or_croak(argOne, *tellTales, &procBlok)
+        end;                                    
+        ENDOFHERE
+        
+        isvalueMethodText = <<-'ENDOFISVALUEMETHOD'
+        def is_value_MUSTBE_NAME?(testValue)
+          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
+        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
+        end;
+        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
+        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
+        end;
+        ENDOFHERE
+        
+        isvaluevalueisAliasText = <<-'ENDOFISVALUEALIAS'        
+        alias_method :'value_is_MUSTBE_NAME?', :'is_value_MUSTBE_NAME?'
+        ENDOFISVALUEALIAS
+
+        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)
+        end;
+        def mustbe_MUSTBE_NAME_key_or_nil_or_croak(testValue, keyName, *tellTales)
+          (r = is_value_key?(testValue, keyName)) && mustbe_MUSTBE_NAME_or_nil_or_croak(r, *tellTales)
+        end;
+        ENDOFMUSTBEKEYMETHOD
+
+        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
+        
+        mustbeMethodTwoArgText = <<-'ENDOFMUSTBEMETHODS'
+        def mustbe_MUSTBE_NAME_or_croak(argOne, argTwo, *tellTales)
+          (r = is_value_MUSTBE_NAME?(argOne, argTwo)) ? r : contract_exception(argTwo, "argOne >#{argOne.class}< argTwo failed is_value_MUSTBE_NAME?", *tellTales)
+        end;
+        ENDOFMUSTBEMETHODS
+
+
+        mustbeMethodCompareText = <<-'ENDOFMETHOD'
+          def mustbe_MUSTBE_NAME_or_croak(arg1, arg2, *args)
+            eye = :MUSTBE_NAME
+            arg1.is_a?(arg2.class) || contract_exception(arg1, "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'
+          def ACCESSOR_NAME
+            @ACCESSOR_NAME ||= nil
+          end;
+          def ACCESSOR_NAME=(value)
+            @ACCESSOR_NAME = value
+          end;
+        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'
+        ENDOFHERE
+
+          accessorEdits = {
+            'MUSTBE_NAME' => 'ACCESSOR_NAME',
+            'MUSTBE_SPEC' => 'ACCESSOR_CONTRACT',
+            'MUSTBE_KEYS' => 'ACCESSOR_KEYS',
+          }
+
+          valueisnilresultEdits = {VALUE_IS_NIL_RESULT: 'false'}  # default for typed collections is not ok if nil
+          
+          packageMustbeText = [mustbeMethodOneArgText, mustbeMethodKeyText, mustbeCommonText, isvalueMethodText, isvaluevalueisAliasText].flatten.join
+
+          packageAccessorSpec = [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) 
+
+          dynamicMethodTexts = {
+
+            # accessors
+            
+            package_accessor: packageAccessorText,
+            package_accessor_with_contract: packageAccessorWithContractText,
+            package_accessor_with_contract_no_is_value: 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)},
+
+            # contracts
+            
+            package_mustbe: packageMustbeText,
+            method_mustbe_one_arg_or_nil: mustbeMethodOneArgOrNilText,
+            method_mustbe_one_arg: mustbeMethodOneArgText,
+            method_mustbe_two_arg: mustbeMethodTwoArgText,
+            method_mustbe_key: mustbeMethodKeyText,
+            method_mustbe_one_arg_or_nil: mustbeMethodOneArgOrNilText,
+
+            method_mustbe_is_value_collection_with_keys: {edit: valueisnilresultEdits, spec: isvaluecollectionwithkeysMethodText},
+            method_mustbe_is_value_typed_collection: {edit: valueisnilresultEdits, spec: isvaluetypedcollectionMethodText},
+
+            method_mustbe_is_value_hash_with_keys: {edit: valueisnilresultEdits, spec: isvaluecollectionwithkeysMethodText},
+            method_mustbe_is_value_typed_hash: {edit: valueisnilresultEdits, spec: isvaluetypedcollectionMethodText},
+
+            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_hash_with_proc: mustbeHashWithProcText,
+            method_mustbe_array_with_proc: mustbeArrayWithProcText,
+            method_mustbe_one_arg_or_nil_with_proc: mustbeMethodOneArgOrNilWithProcText,
+            method_mustbe_subset: mustbeMethodSubsetText,
+            method_mustbe_compare: mustbeMethodCompareText,
+            
+            method_mustbe_collections: mustbeMethodCollectionsText,
+
+            # assertion
+            
+            method_is_value: isvalueMethodText,
+
+            # aliases
+            
+            alias_is_value_value_is: isvaluevalueisAliasText,
+            
+            # testing
+
+            test1: 'def ACCESSOR_NAME(testValue); IS_VALUE_TEST ? 99 : nil; end;',
+          }
+
+          dynamicMethodTexts  # return value
+          
+
+
+__END__
+