potrubi 0.0.1 → 0.0.2

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

@@ -0,0 +1,226 @@
+
+# potrubi contract recipes
+
+# to ease the creation of contracts, accessors, etc in class bodies
+
+#  These are *mixin* ('class') methods; not instance ones
+
+# Uses conventions for names etc dedined by (in) contract mixin
+
+require_relative '../bootstrap'
+
+requireList = %w(contract util)
+requireList.each {|r| require_relative "#{r}"}
+
+mixinContent = Module.new do
+
+  include Potrubi::Bootstrap
+  include Potrubi::Mixin::Util
+  
+  def standard_accessor_edit(k, v)
+    {ACCESSOR_NAME: k, ACCESSOR_CONTRACT: k}
+  end
+
+  def standard_mustbe_edit(k, v)
+    {MUSTBE_NAME: k, MUSTBE_SPEC: k}
+  end
+
+  # convenience methods
+  
+  def merge_edits(*edits)
+    Potrubi::Mixin::Dynamic.dynamic_merge_edits(*edits)
+  end
+
+  def merge_specs(*specs)
+    specs.flatten
+  end
+
+  def merge_spec_and_edit(spec, edit)
+    { edit: edit, spec: spec}
+  end
+  
+  # This method is peculair to accessors & mustbes
+  # not general purpose as e.g. hash treatment makes assumptions
+  
+  def standard_case_statement(k, v, s, edit, spec)
+    eye = :'rcp_std_case'
+    r = case v
+        when Symbol then  merge_spec_and_edit(spec, merge_edits(edit, {IS_VALUE_TEST: "testValue.is_a?(#{v.to_s.capitalize})"}))
+        when Class, String then merge_spec_and_edit(spec, merge_edits(edit, {IS_VALUE_TEST: "testValue.is_a?(#{v})"}))
+        when NilClass then  merge_spec_and_edit(spec, merge_edits(edit, {IS_VALUE_TEST: 'testValue'}))
+        when Array then v # dynamic_define_methods will parse
+        when Proc then
+          [ merge_spec_and_edit(spec, merge_edits(edit, {IS_VALUE_TEST: 'false'})), # error on default isValueText
+           {name: "is_value_#{k}?", spec: v}, # ... but override is_value method
+          ]
+        when Hash then merge_spec_and_edit(merge_specs([spec, v[:spec]]), merge_edits(edit,  {IS_VALUE_TEST: 'false'}, v[:edit]))
+        else
+          potrubi_bootstrap_surprise_exception(v, eye, "accessor name >#{k}< spec not expected")
+        end
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ca(eye, potrubi_bootstrap_logger_fmt_who(k: k, v: v, edit: edit), potrubi_bootstrap_logger_fmt_who(spec: spec), potrubi_bootstrap_logger_fmt_who(r: r))
+    r
+    #STOPCASEEXIT
+  end
+
+  def standard_accessor_recipe_block(s) # returns a lambda
+    ->(k, v) {
+      edit = standard_accessor_edit(k, v)
+      ###spec = {spec: s}
+      spec = s
+      r = standard_case_statement(k, v, s, edit, spec)
+      #puts("\n\n\nACCE RCP BLOK r >#{r}<\n\n\n")
+      r
+      #STOPACCEBLOK
+    }
+  end
+
+  def standard_mustbe_recipe_block(s) # returns a lambda
+    ->(k, v) {
+      edit = standard_mustbe_edit(k, v)
+      ###spec = {spec: s}
+      spec = s
+      r = standard_case_statement(k, v, s, edit, spec)
+      #puts("\n\n\nMUSTBE RCP BLOK r >#{r}<")
+      r
+    }
+  end
+  
+
+  def resolve_recipe_texts(*recipeTexts)
+    eye = :'rslv_rcp_texts'
+
+    utilityText = Potrubi::Mixin::Contract::CONTRACT_TEXTS
+    
+    resolvedTexts = recipeTexts.flatten.map do  | recipeText |
+      puts("recipeText >#{recipeText.class}< >#{recipeText}<")
+      case recipeText
+      when Symbol then utilityText[recipeText]
+      when Proc then recipeText
+      else
+        potrubi_bootstrap_surprise_exception(recipeText, eye, "recipeText is what?")
+        ###recipeText
+      end
+    end
+
+    resolvedTexts
+    
+  end
+  def resolve_recipe_texts(*recipeTexts)
+    recipeTexts.flatten
+  end
+  
+
+  def recipe_accessors(attrTarget, attrDefs, *attrTexts, &attrBlok)
+    eye = :'rcp_accessors'
+
+    ###STOPHEREACCS
+    
+    #puts("K0")
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, potrubi_bootstrap_logger_fmt_who(attrTarget: attrTarget, attrDefs: attrDefs, attrTexts: attrTexts))
+
+    #puts("K1")
+    
+    #textDefs = resolve_recipe_texts(attrTexts)
+    textDefs = resolve_recipe_texts(attrTexts.empty? ? :package_accessor_with_contract : attrTexts) # default is contract accessor
+
+    #puts("TEXT DEFS >#{textDefs.class}< >#{textDefs}<")
+
+    procBlok = Kernel.block_given? ? attrBlok : standard_accessor_recipe_block(textDefs)
+    
+    Potrubi::Mixin::Dynamic.dynamic_define_methods(attrTarget, attrDefs, &procBlok)
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, potrubi_bootstrap_logger_fmt_who(attrTarget: attrTarget, attrDefs: attrDefs, attrTexts: attrTexts))
+
+    self
+
+    ##STOPHEREACCSEXIT
+  end
+
+  def recipe_mustbes(attrTarget, attrDefs, *attrTexts, &attrBlok)
+    eye = :'rcp_mustbes'
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, potrubi_bootstrap_logger_fmt_who(attrTarget: attrTarget, attrDefs: attrDefs, attrTexts: attrTexts))
+
+    textDefs = resolve_recipe_texts(attrTexts.empty? ? :package_mustbe : attrTexts) # default is standard mustbe
+
+    procBlok = Kernel.block_given? ? attrBlok : standard_mustbe_recipe_block(textDefs)
+    
+    Potrubi::Mixin::Dynamic.dynamic_define_methods(attrTarget, attrDefs, &procBlok)
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, potrubi_bootstrap_logger_fmt_who(attrTarget: attrTarget, attrDefs: attrDefs, attrTexts: attrTexts))
+
+    self
+    
+  end
+  
+end
+
+module Potrubi
+  module Mixin
+    module ContractRecipes
+    end
+  end
+end
+
+Potrubi::Mixin::ContractRecipes.extend(mixinContent) # Make mixin methods
+
+__END__
+
+# quick tests
+
+require '../core'
+
+$DEBUG = true
+$DEBUG_POTRUBI_BOOTSTRAP = true
+
+testClass = Class.new do
+
+  include Potrubi::Core
+  
+  attrAccessors = {
+    #jmx_user: :string,
+    #jmx_pass: :string,
+    #jmx_host: :string,
+    ###jmx_port: :string,
+    #jmx_port: :fixnum,
+    #jmx_connection: nil,
+    #jmx_connection: 'JMX::MBeanServerConnectionProxy',
+    #beans_attributes: :hash,
+    #beans_specifications: :hash,
+    #jmx_host: ->(h) {h.is_a?(String)},
+
+    #jmx_orts: {spec: 'def is_value_jmx_orts?(v); v.is_a?(String); end'},
+
+    #jmx_keys: {edit: {ACCESSOR_KEYS: 'self.class.accessor_keys'},
+    #spec: :method_accessor_is_value_and_keys}
+
+    jmx_users1: {edit: {KEY_TYPE: :string, VALUE_TYPE: :jmx_user}, spec: :method_accessor_is_value_typed_collection},
+    jmx_users2: {edit: {KEY_TYPE: :string, VALUE_TYPE: :jmx_user, VALUE_IS_NIL_RESULT: 'true', KEY_NAMES: [:a, :b, :c]}, spec: :method_accessor_is_value_typed_collection_with_keys}
+
+    
+  }
+
+  attraccessorTexts = [:package_accessor_with_contract]
+
+  Potrubi::Mixin::ContractRecipes.recipe_accessors(self, attrAccessors, attraccessorTexts)
+
+
+  mustbeContracts = {
+    what1: :string,
+    what2: :hash,
+    what3: 'Riemann::Feed::Feeder'
+  }
+
+  #Potrubi::Mixin::ContractRecipes.recipe_mustbes(self, mustbeContracts)
+  
+end
+
+testInst = testClass.new
+
+#testInst.mustbe_jmx_host_or_croak('A string')
+#testInst.mustbe_jmx_host_or_croak(:symbol)
+#testInst.mustbe_jmx_orts_or_croak('A string')
+#testInst.mustbe_jmx_orts_or_croak(:symbol)
+__END__
+

data/lib/potrubi/mixin/contract.rb

@@ -0,0 +1,105 @@
+
+# potrubi contract methods
+
+require_relative '../bootstrap'
+require_relative "dynamic"
+
+#requireList = %w(dynamic)
+#requireList.each {|r| require_relative "#{r}"}
+
+#$DEBUG = true
+#$DEBUG_POTRUBI_BOOTSTRAP = true
+
+mixinContent = Module.new do
+
+  # mustbe contracts
+  
+  mustbeDefaultSpec = [:package_mustbe]
+  mustbeLimited1OneArgSpec = [:method_mustbe_one_arg, :alias_is_value_value_is]
+  mustbeLimited2OneArgSpec = [mustbeLimited1OneArgSpec, :method_mustbe_key, :method_mustbe_one_arg_or_nil, :method_mustbe_collections].flatten
+  mustbeLimited1TwoArgSpec = [:method_mustbe_two_arg, :alias_is_value_value_is]
+  
+  mustbeMethods = {
+    :hash         => [:package_mustbe, :method_mustbe_hash_with_proc, :method_mustbe_one_arg_or_nil_with_proc].flatten,
+    #=begin
+    :array        => [:package_mustbe, :method_mustbe_array_with_proc, :method_mustbe_one_arg_or_nil_with_proc, :method_mustbe_subset].flatten,
+    :string	=> nil,
+    :symbol	=> nil,
+    :fixnum	=> nil,
+    :range	=> nil,
+    :proc	=> nil,
+    :class	=> nil,
+    :module	=> nil,
+    :time	=> nil,
+    :enumerator   => nil,
+    :regexp       => nil,
+    :struct       => nil,
+    :empty        => [{:name => :'is_value_empty?', :spec => ->(c) {(c.respond_to?(:empty?) && c.empty?) ? c : nil }}, mustbeLimited1OneArgSpec].flatten,
+    :not_empty    => [{:name => :'is_value_not_empty?', :spec => ->(c) {(c.respond_to?(:empty?) && (! c.empty?)) ? c : nil }}, mustbeLimited1OneArgSpec].flatten,
+    :not_nil      => [{:name => :'is_value_not_nil?', :spec => ->(c) { c }}, mustbeLimited1OneArgSpec].flatten,
+    :file         => [{:name => :'is_value_file?', :spec => ->(f) {(f.is_a?(String) && File.file?(f)) ? f : nil}}, mustbeLimited2OneArgSpec].flatten,
+    :directory    => [{:name => :'is_value_directory?', :spec => ->(d) {(f.is_a?(String) && File.directory?(d)) ? d : nil}}, mustbeLimited2OneArgSpec].flatten,
+    :file_or_directory => [{:name => :'is_value_file_or_directory?', :spec => ->(e) {(e.is_a?(String) && (File.file?(e) || File.directory?(e))) ? e : nil}}, mustbeLimited2OneArgSpec].flatten,
+    :key         => [{:name => :'is_value_key?', :spec => ->(h,k) {(h.respond_to?(:has_key?) && h.has_key?(k)) ? h[k] : nil}}, mustbeLimited1TwoArgSpec].flatten,
+    :not_key     => [{:name => :'is_value_not_key?', :spec => ->(h,k) {is_value_key?(h,k) ? nil : k}}, mustbeLimited1TwoArgSpec].flatten,
+    :any         => [{:name => :'is_value_any?', :spec => ->(v) {v} }].flatten,
+    :same_class  => [{:name => :'is_value_same_class?', :spec => ->(p,q) {((r = p.class) == q.class) ? r : nil}}, mustbeLimited1TwoArgSpec].flatten,
+    :instance_of => [{:name => :'is_value_instance_of?', :spec => ->(p,q) {p.instance_of?(q) ? p : nil}}, mustbeLimited1TwoArgSpec].flatten,
+    #=end
+  }
+
+  mustbeSpecs = mustbeMethods.each_with_object({}) { | (mustbeName, mustbeSpec), h | h[mustbeName] = mustbeSpec || mustbeDefaultSpec }
+
+  Potrubi::Mixin::Dynamic::dynamic_define_methods(self, mustbeSpecs) do |k, v|
+    edits = {
+      ###:MUSTBE_TEST => k.to_s.capitalize,
+      IS_VALUE_TEST: "testValue.is_a?(#{k.to_s.capitalize})",
+      MUSTBE_NAME: k,
+      ###MUSTBE_SPEC: v,
+    }
+    case v
+    when Hash then v.merge({:edit => [edits, v[:edit]]})
+    else
+      {:edit => edits, :spec => v}
+    end
+  end
+  
+
+  # Compare Contracts
+  
+  compareMethods = {
+    :eq => '==',
+    :equal => '==',
+    :lt => '<',
+    :le => '<=',
+    :less_or_equal => '<=',
+    # :less_than_or_equal => '<=',
+    # :lessthan_or_equal => '<=',
+    :gt => '>',
+    :ge => '>=',
+    :greater_or_equal => '>=',
+    # :greater_than_or_equal => '>=',
+    # :greaterthan_or_equal => '>=',
+    :identical => '===',
+    :ne => '!=',
+    :not_equal => '!=',
+    # :lessequal => '<=',
+  }
+
+  Potrubi::Mixin::Dynamic::dynamic_define_methods(self, compareMethods) do | mN, mO |
+    # puts "<=> #{eye} mN >#{mN.class}< >#{mN}< mO >#{mO.class}< >#{mO}< textValue >#{textValue.class}< >\n#{textValue}\n<"
+    {edit: {MUSTBE_NAME: mN, MUSTBE_SPEC: mO}, spec: :method_mustbe_compare}
+  end
+
+end
+
+module Potrubi
+  module Mixin
+    module Contract
+    end
+  end
+end
+
+Potrubi::Mixin::Contract.__send__(:include, mixinContent)  # Instance Methods
+
+__END__

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

@@ -0,0 +1,100 @@
+
+# potrubi mixin dynamic
+
+# dynamic method, etc generation
+
+require_relative '../bootstrap'
+require_relative 'dynamic'
+
+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 |
+
+      edits = {
+        :et_new_name => newName.to_s.downcase,
+        :et_new_class => newKlass.to_s,
+        :et_new_eyecatcher => "new_#{newName}".downcase,
+      }
+
+      newText = <<-'ENDOFMETHOD'
+	def new_et_new_name_or_croak(*a, &b)
+          r = et_new_class.new(*a, &b)
+          logger_ca(:et_new_eyecatcher, logger_fmt_who(:'et_new_name' => r))
+          r
+        end
+        ENDOFMETHOD
+
+        {:edit => edits, :spec => newText}
+        
+      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
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, "targetModule >#{targetModule.class}< >#{targetModule}< croakArgs >#{croakArgs}<")
+
+    potrubi_bootstrap_mustbe_module_or_croak(targetModule, eye)
+    
+    knownMethods = targetModule.instance_methods.map(&:to_s)
+
+    includeMethods = (r = croakArgs[:include]) ? [r].flatten.compact.uniq.map(&:to_s) : knownMethods
+    excludeMethods = (r = croakArgs[:exclude]) ? [r].flatten.compact.uniq.map(&:to_s) : []
+
+    wantedMethods = includeMethods - excludeMethods
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ms(eye, "wantedMethods >#{wantedMethods}< knownMethods >#{knownMethods}< includeMethods >#{includeMethods}< excludeMethods >#{excludeMethods}<")
+    
+    croakRegexp = Regexp.new(/(.*)_or_croak\?*/)
+    croakMethods = wantedMethods.map {|m| (mD = m.match(croakRegexp)) ? mD[1] : nil }.compact
+
+    croakUndefinedMethods = croakMethods.reject {|m| knownMethods.include?(m) } # method already defined?
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ms(eye, "croakUndefinedMethods >#{croakUndefinedMethods.class}< >#{croakUndefinedMethods}< croakMethods >#{croakMethods}<")
+
+    croakUndefinedMethodsHash = Hash[*croakUndefinedMethods.map {|m| [m, nil]}.flatten]
+    
+    recipe_rescue_croak(targetModule, croakUndefinedMethodsHash)
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, "targetModule >#{targetModule.class}< >#{targetModule}< croakUndefinedMethods >#{croakUndefinedMethodsHash}<")
+
+    self
+  end
+  #=end
+
+
+
+end
+#=end
+
+module Potrubi
+  module Mixin
+    module DynamicRecipes
+    end
+  end
+end
+
+Potrubi::Mixin::DynamicRecipes.extend(metaclassMethods)
+Potrubi::Mixin::DynamicRecipes.__send__(:include, metaclassMethods)  # Instance Methods
+
+
+__END__
+

data/lib/potrubi/mixin/dynamic.rb

@@ -0,0 +1,315 @@
+
+# potrubi mixin dynamic
+
+# dynamic method, etc generation
+
+require_relative '../bootstrap'
+
+metaclassMethods = Module.new do
+
+  include Potrubi::Bootstrap
+
+  #=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")
+    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}")
+
+    textValue = textValues.flatten.compact.join("\n")
+
+    textFinal = case editSpec
+                when NilClass then textValue
+                else
+                  
+                  newtextValue = nil
+
+                  recurseMax = 16
+                  recurseCnt = 0
+                  until (textValue == newtextValue)
+
+                    ((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}<")
+                  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))}
+    r.empty? ? nil : r
+  end
+  #=end
+
+  #=begin
+  def dynamic_define_methods(targetModule, methodDefs, dynArgs=nil, &dynBlok)
+    eye = :dyn_def_mtds
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, "targetModule >#{targetModule.class}< >#{targetModule}< specs >#{methodDefs.class}< >#{methodDefs}< dynArgs >#{dynArgs.class}< >#{dynArgs}< dynBlok >#{dynBlok}<")
+
+    potrubi_bootstrap_mustbe_module_or_croak(targetModule, eye, "targetModule not module")
+
+    potrubi_bootstrap_mustbe_hash_or_croak(methodDefs, eye, "methodDefs not hash")
+
+    dynArgs && potrubi_bootstrap_mustbe_hash_or_croak(dynArgs, eye, "dynArgs not hash")
+    
+    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}<")
+
+      mtdValCollection = case mtdVal
+                         when Array then mtdVal
+                         when Hash, String, Symbol, Proc then [mtdVal]
+                         when NilClass then [mtdKey]
+                         else
+                           potrubi_bootstrap_surprise_exception(mtdVal, eye, "mtdVal is what?")
+                         end
+
+      dynResultsBlok = Kernel.block_given? ? mtdValCollection.map {|v| dynBlok.call(mtdKey, v) } : mtdValCollection
+      
+      $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")
+        
+        editAll = case
+                  when dynResult.has_key?(:edit) then # edit key set?
+                    editLocal = dynResult[:edit]
+                    # if edit key is nil =>  NO EDITS AT ALL
+                    editLocal ? [editMtd, editArgs, editLocal] : nil
+                  else
+                    # wants defaults; there was no point returning hash
+                    [editMtd, editArgs] 
+                  end
+        
+        editAll ? dynResult.merge({:edit => editAll}) : dynResult
+
+      end
+      
+      $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)
+    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}<")
+
+    # try to merge all the text methods together
+
+    textMethods = []
+    
+    methodSpecs.flatten.compact.each_with_index do | methodSpec, methodNdx |
+
+      $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ms(eye, eyeTale, "methodNdx >#{methodNdx}< methodSpec >#{methodSpec.class}< >#{methodSpec}<")
+
+      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)
+        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
+        
+        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 Array then textMethods << methodSpec
+      else
+        potrubi_bootstrap_surprise_exception(specType, "methodSpec >#{methodSpec.class}< >#{methodSpec.class}< specType >#{specType.class}< is what?")
+      end
+
+    end
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "TXTS textMethods >#{textMethods.class}< >#{textMethods}<")
+    
+    textMethods.empty? || dynamic_define_methods_apply_texts(targetModule, *textMethods)
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, eyeTale, "targetModule >#{targetModule.class}< >#{targetModule}< specs >#{methodSpecs.class}< >#{methodSpecs.size}<")
+
+    self
+    
+  end
+  #=end
+
+  def dynamic_define_methods_apply_texts(targetModule, *methodSpecs, &dynBlok)
+    eye = :ddm_apl_txt
+    eyeTale = 'DDM APL TXTS'
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, eyeTale, "targetModule >#{targetModule.class}< >#{targetModule}< specs >#{methodSpecs.class}< >#{methodSpecs}<")
+
+    #STOPAPPLYTEXTS
+    
+    begin
+
+      methodTexts = methodSpecs.flatten.compact.map do | methodSpec |
+
+        $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "BEG methodSpec >#{methodSpec.class}< >#{methodSpec}<\n\n\n")
+
+        potrubi_bootstrap_mustbe_hash_or_croak(methodSpec)
+
+        ###methodTextNom = potrubi_bootstrap_mustbe_string_or_croak([methodSpec[:spec]].flatten.compact.join)
+
+        methodEdit = methodSpec[:edit]
+        methodText = methodSpec[:spec]
+
+        $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "EDIT & SPEC methodEdit >#{methodEdit}< methodText >#{methodText.class}< >#{methodText}<")
+
+        #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}<")
+
+        #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
+
+        end
+      
+        methodText = dynamic_apply_edits([snipEdits, methodEdit], snipTexts) # note order of edits
+
+        $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "FIN methodEdit >#{methodEdit}< snipEdits >#{snipEdits}< methodText >#{methodText}<\n\n\n")
+
+        #STOPMETHODFIN
+        
+        methodText
+        
+      end.flatten.compact.join("\n")
+    rescue Exception => e
+      $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye,"exception >#{e}<")
+      stopINDYNAPP3RESCUE
+    end
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "METHODS targetModule >#{targetModule.class}< >#{targetModule}< methodTexts >#{methodTexts.class}< >\n#{methodTexts}\n<")
+
+    methodTexts && targetModule.module_eval(methodTexts)
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger(eye, eyeTale, "targetModule >#{targetModule.class}< >#{targetModule}< specs >#{methodSpecs.class}< >#{methodSpecs.size}<")
+
+    self
+    
+  end
+  #=end
+
+end
+#=end
+
+module Potrubi
+  module Mixin
+    module Dynamic
+    end
+  end
+end
+
+Potrubi::Mixin::Dynamic.extend(metaclassMethods) # Module methods
+Potrubi::Mixin::Dynamic.__send__(:include, metaclassMethods)  # Instance Methods
+
+# must be after dynamic is up
+
+requireList = %w(text-snippets)
+requireList.each {|r| require_relative "#{r}"}
+
+__END__
+
+