potrubi 0.0.3 → 0.0.4

data/lib/potrubi/klass/syntax/alias.rb

@@ -0,0 +1,150 @@
+
+# potrubi contract dsl
+
+# syntax methods
+
+# to ease the creation of new methods using text snippets
+
+#require_relative '../../bootstrap'
+
+requireList = %w(super ./mixin/new_statements ./mixin/statement_management)
+requireList.each {|r| require_relative "#{r}"}
+###require "potrubi/klass/syntax/braket"
+
+
+
+instanceMethods = Module.new do
+
+  include Potrubi::Bootstrap
+  ##include Potrubi::Mixin::Util
+  include Potrubi::Klass::Syntax::Mixin::NewStatements
+  #include Potrubi::Klass::Syntax::Mixin::NameGeneration
+  include Potrubi::Klass::Syntax::Mixin::StatementManagement
+  
+  ###attr_accessor :name, :type, :key, :value, :variant, :spec, :edit,
+  ###:blok, :key_names, :default
+  
+  attr_accessor :source_name, :target_name
+  
+  def to_s
+    syntax
+  end
+
+  def inspect
+    @to_inspect ||= potrubi_bootstrap_logger_fmt(potrubi_bootstrap_logger_instance_telltale('DSLSynAli'))
+  end
+
+  # Accessor Methods
+  # ################
+
+  # Name Methods
+  # ###########
+
+  def set_source_name(nameValue)
+    self.source_name = nameValue
+    self # fluent
+  end
+
+  def set_target_name(nameValue)
+    self.target_name = nameValue
+    self # fluent
+  end
+
+
+  # New to Add Statements Mapping
+  # #############################
+  
+  newToAddMap = [
+                 :method_alias,
+                ]
+
+
+  newToAddTexts = newToAddMap.map {|s| "def add_statement_#{s}(*a, &b); add_statements_or_croak(new_statement_#{s}(*a, &b)); end;"}
+  ###newToAddTexts << "def add_statement(*a, &b); add_statements_or_croak(new_statement(*a, &b)); end;"
+  newToAddText = newToAddTexts.flatten.compact.join("\n")
+  puts("ALIAS NEW TO ADD STATEMENT MAP >\n#{newToAddText}")
+  module_eval(newToAddText)
+  
+  
+  # Syntax Methods
+  # ##############
+  
+  def syntax
+    eye = :'PotKlsSynAli::syn'
+    eyeTaleME = '>>>>>>>>>>>>>>>>>> SYN ALI'
+    eyeTaleMX = '<<<<<<<<<<<<<<<<<< SYN ALI'
+    ###nameMethod = name
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, eyeTaleME)
+
+    aliasStms = statements
+    
+    syntaxAliases = case
+                   when aliasStms.empty? then nil
+                   else
+
+                     braketAliases = new_braket_snippet
+                     
+                     braketAliases.push(###make_syntax_def,
+                                       ###make_syntax_eye,
+                                       ###statements.map {|s| s.syntax },
+                                       aliasStms,
+                                       ###make_syntax_result,
+                                       ###make_syntax_end
+
+                                       )
+                     
+                     braketAliases.to_s
+                     
+                   end
+    
+    puts("#{eye} SYNTAX ALIAS syntax \n#{syntaxAliases}")
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, eyeTaleMX, potrubi_bootstrap_logger_fmt_who_only(synAli: syntaxAliases))
+
+    syntaxAliases
+  end
+
+
+  
+
+  
+end
+
+module Potrubi
+  class Klass
+    module Syntax
+      class Alias < Super
+      end
+    end
+  end
+end
+
+Potrubi::Klass::Syntax::Alias.__send__(:include, instanceMethods)  # Instance Methods
+
+__END__
+
+Potrubi::Klass::Syntax::Alias.extend(classMethods)  # Class Methods
+
+__END__
+
+m = Potrubi::DSL::Syntax::Method.new_method
+
+__END__
+
+classMethods = Module.new do
+
+  def new_contract(dslArgs=nil, &dslBlok) # class method
+    eye = :'DSLAcc::KLS new_cxt'
+    #potrubi_bootstrap_mustbe_symbol_or_croak(dslAttr, eye, "dslAttr is what?")
+    newContract = self.new(dslArgs, &dslBlok)
+    #$DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ca(eye, potrubi_bootstrap_logger_fmt_who(newContract: newContract), potrubi_bootstrap_logger_fmt_who(dslAttr: dslAttr, dslArgs: dslArgsNrm, dslBlok: dslBlok))
+    newContract
+    ###STOPHERENEWCONTRACTEXIT
+  end
+end
+
+Potrubi::Mixin::Contract::DSL.extend(classMethods)  # CLass Methods
+
+__END__
+

data/lib/potrubi/klass/syntax/braket.rb

@@ -8,35 +8,105 @@ defined?($DEBUG_POTRUBI_KLASS_SYNTAX_BRAKET) ||
     $DEBUG_POTRUBI_KLASS_SYNTAX_BRAKET ||= nil
   end
 
-require "potrubi/core"
-require 'potrubi/mixin/dynamic-recipes'
+#require "potrubi/core"
+#require 'potrubi/mixin/dynamic-recipes'
 
-klassContent = Class.new do
+requireList = %w(../../bootstrap ../../mixin/dynamic-recipes)
+requireList.each {|r| require_relative "#{r}"}
 
-  include Potrubi::Core
+
+klassMethods = Module.new do
+
+  include Potrubi::Bootstrap
   ###include Potrubi::Mixin::DynamicRecipes
   
   # Class Methods
   # #############
   
-  def self.new_method
+  def new_method
     new(:pos_text => "\n")
+    #new
   end
 
-  def self.new_stanza
+  def new_snippet
     new(:pos_text => "\n")
+    ###new
   end
   
-  def self.new_statement
+  def new_statement
+    #puts("BRAKET NEW STATEMENT")
     #self.new(nil, nil)
     new
   end
   
+end
+
+instanceMethods = Module.new do
+
+  include Potrubi::Bootstrap
+  
   attr_accessor :pre_text, :pos_text
 
+  def inspect
+    @to_inspect ||= potrubi_bootstrap_logger_fmt(potrubi_bootstrap_logger_instance_telltale('KlsSynBkt'))
+  end
+  
   def initialize(initArgs=nil)
-    initArgs && mustbe_hash_or_croak(initArgs, :'braket i').each {|k,v| self.__send__("#{k}=", v)}
+    initArgs && potrubi_bootstrap_mustbe_hash_or_croak(initArgs, :'braket i').each {|k,v| self.__send__("#{k}=", v)}
+  end
+
+  def zzzto_ary
+    self
   end
+
+  def west_midl_east
+    [
+    defined?(@west) ? @west : nil,
+    defined?(@midl) ? @midl : nil,
+    defined?(@east) ? @east : nil
+    ]
+  end
+  alias_method :to_a, :west_midl_east
+  ###alias_method :to_ary, :west_midl_east
+
+  def zzzflatten
+    to_a.inject([]) {|s,a| a ? s.concat(a.flatten) : s}
+  end
+
+  def empty?
+    to_a.inject(true) {|s,a| a ? (s && a.empty?) : s}
+  end
+
+  def clear
+    to_a.each {|a| a && a.clear }
+  end
+
+  
+
+  
+  def zzzflatten
+    result = []
+    defined&&(@west) && result.concat(@west.flatten)
+    defined&&(@midl) && result.concat(@midl.flatten)
+    defined&&(@east) && result.concat(@east.flatten)
+    result
+  end
+
+    
+  def zzzempty?
+    p = defined?(@west) ? @west.empty? : true
+    q = defined?(@midl) ? @midl.empty? : true
+    r = defined?(@east) ? @east.empty? : true
+    (p && q && r) ? true : false
+  end
+  
+  def zzzclear
+    defined?(@west) && @west.clear 
+    defined?(@midl) && @midl.clear
+    defined?(@east) && @east.clear
+    self
+  end
+  alias_method :reset, :clear
   
   def to_s
     eye = :'bkt to_s'
@@ -44,12 +114,12 @@ klassContent = Class.new do
     posText = pos_text
 
     fullText = [ 
-                defined?(@head) && head_text(preText, posText), 
+                defined?(@west) && west_text(preText, posText), 
                 defined?(@midl) && midl_text(preText, posText), 
-                defined?(@tail) && tail_text(preText, posText), 
+                defined?(@east) && east_text(preText, posText), 
                ].flatten.compact.join
 
-    $DEBUG_POTRUBI_KLASS_SYNTAX_BRAKET && logger_ca(eye, "self >#{self.object_id}< fulText >#{fullText.class}< >\n#{fullText}\n< ")
+    $DEBUG_POTRUBI_KLASS_SYNTAX_BRAKET && potrubi_bootstrap_logger_ca(eye, "self >#{self.object_id}< fulText >#{fullText.class}< >\n#{fullText}\n< ")
     
     fullText
     
@@ -61,11 +131,11 @@ klassContent = Class.new do
     fulText = to_s
     edtText = case editList
               when NilClass then fulText
-              when Hash, Array then  Potrubi::Core.dynamic_apply_edits(editList, fullText)
+              when Hash, Array then  Potrubi::Core.dynamic_apply_edits(editList, fulText)
               else
-                surprise_exception(editList, eye, "editList >#{editList.whoami_debug}< is what?")
+                potrubi_bootstrap_surprise_exception(editList, eye, "editList >#{editList.whoami_debug}< is what?")
               end
-    $DEBUG_POTRUBI_KLASS_SYNTAX_BRAKET && logger_ca(eye, "self >#{self.object_id} edtText >\n#{edtText}\n<")
+    $DEBUG_POTRUBI_KLASS_SYNTAX_BRAKET && potrubi_bootstrap_logger_ca(eye, "self >#{self.object_id} edtText >\n#{edtText}\n<")
     edtText
   end
   
@@ -74,7 +144,7 @@ klassContent = Class.new do
   textMethodText =
     'def METHOD_NAME_text(preText=nil, posText=nil)
       METHOD_NAMEText = defined?(@METHOD_NAME) ? (@METHOD_NAME.map {|i| [preText, i.to_s, posText]}.flatten.compact.join) : nil
-      $DEBUG_POTRUBI_KLASS_SYNTAX_BRAKET && logger_ca(:METHOD_NAME_text, "self >#{self.object_id}< METHOD_NAMEText >#{METHOD_NAMEText.class}< >#{METHOD_NAMEText}<")
+      $DEBUG_POTRUBI_KLASS_SYNTAX_BRAKET && potrubi_bootstrap_logger_ca(:METHOD_NAME_text, "self >#{self.object_id}< METHOD_NAMEText >#{METHOD_NAMEText.class}< >#{METHOD_NAMEText}<")
       METHOD_NAMEText
     end'
 
@@ -92,25 +162,25 @@ klassContent = Class.new do
      alias_method :cons_METHOD_NAME, :unshift_METHOD_NAME
      def pop_METHOD_NAME
        r = defined?(@METHOD_NAME) ? @METHOD_NAME.pop : nil
-       $DEBUG_POTRUBI_KLASS_SYNTAX_BRAKET && logger_ca(:pop_METHOD_NAME, "self >#{self.object_id}< r >#{r}<")
+       $DEBUG_POTRUBI_KLASS_SYNTAX_BRAKET && potrubi_bootstrap_logger_ca(:pop_METHOD_NAME, "self >#{self.object_id}< r >#{r}<")
        r
      end
      def shift_METHOD_NAME
        r = defined?(@METHOD_NAME) ? @METHOD_NAME.shift : nil
-       $DEBUG_POTRUBI_KLASS_SYNTAX_BRAKET && logger_ca(:shift_METHOD_NAME, "self >#{self.object_id}< r >#{r}<")
+       $DEBUG_POTRUBI_KLASS_SYNTAX_BRAKET && potrubi_bootstrap_logger_ca(:shift_METHOD_NAME, "self >#{self.object_id}< r >#{r}<")
        r
      end'
 
   defTextList = [textMethodText, baseMethodText]
-  ###puts("TEXT TEST TEXT >#{defTextList}<")
+  #puts("TEXT TEST TEXT >#{defTextList}<")
 
   braketMethods = {
-    :tail => defTextList,
-    :head => defTextList,
+    :east => defTextList,
+    :west => defTextList,
     :midl => defTextList,
   }
 
-  Potrubi::Core.dynamic_define_methods(self, braketMethods) do |k, v|
+  Potrubi::Mixin::Dynamic.dynamic_define_methods(self, braketMethods) do |k, v|
     edits = {
      ARGS_SPEC: 'args.flatten(1)',
      METHOD_NAME: k,
@@ -129,8 +199,13 @@ klassContent = Class.new do
     :unshift  => :unshift_midl,
     :cons     => :cons_midl,
     :tail     => :tail_midl,
+
+    :cons_head => :cons_west,
+    :push_tail => :tail_east,
+
   }
 
+  ###$DEBUG_POTRUBI_BOOTSTRAP = true
   #Potrubi::Core.dynamic_define_methods_aliases(self, aliasMethods)
   Potrubi::Mixin::DynamicRecipes.recipe_aliases(self, aliasMethods)
 
@@ -141,7 +216,7 @@ klassContent = Class.new do
   def raw_debug(levelText=nil)
     eye = :'braket r_dbg'
 
-    $DEBUG_POTRUBI_KLASS_SYNTAX_BRAKET &&
+    #$DEBUG_POTRUBI_KLASS_SYNTAX_BRAKET &&
       begin
         levelString = case levelText
                       when NilClass then 'BRAKET'
@@ -154,9 +229,9 @@ klassContent = Class.new do
         
         puts "#{levelString} #{braketAddress} ==>"
         
-        defined?(@head) && raw_content_debug(levelString, "head", @head)
+        defined?(@west) && raw_content_debug(levelString, "west", @west)
         defined?(@midl) && raw_content_debug(levelString, "midl", @midl)
-        defined?(@tail) && raw_content_debug(levelString, "tail", @tail)
+        defined?(@east) && raw_content_debug(levelString, "east", @east)
         
         puts "#{levelString} #{braketAddress} <=="
       end
@@ -181,7 +256,7 @@ klassContent = Class.new do
         end
       end
     else
-      surprise_exception(contentData, eye)
+      potrubi_bootstrap_surprise_exception(contentData, eye)
     end
     
     self
@@ -190,6 +265,21 @@ klassContent = Class.new do
 
 end
 
+module Potrubi
+  class Klass
+    module Syntax
+      class Braket
+      end
+    end
+  end
+end
+
+Potrubi::Klass::Syntax::Braket.__send__(:include, instanceMethods)  # Instance Methods
+Potrubi::Klass::Syntax::Braket.extend(klassMethods)  # Class Methods
+
+
+__END__
+
 #Potrubi::Core.assign_class_constant_or_croak(klassContent, __FILE__)
 Potrubi::Core.assign_class_constant_or_croak(klassContent, :Potrubi, :Klass, :Syntax, :Braket)
 

data/lib/potrubi/klass/syntax/builder.rb

@@ -0,0 +1,45 @@
+
+# potrubi contract dsl
+
+# syntax method: builder
+
+# to ease the creation of new methods using text manipulation
+
+require_relative '../../bootstrap'
+
+requireList = %w(super ./mixin/new_snippets)
+requireList.each {|r| require_relative "#{r}"}
+###require "potrubi/klass/syntax/braket"
+
+classMethods = Module.new do
+
+  include Potrubi::Bootstrap
+  include Potrubi::Klass::Syntax::Mixin::NewSnippets
+  include Potrubi::Klass::Syntax::Mixin::NewMethods
+  include Potrubi::Klass::Syntax::Mixin::NewAliases
+  include Potrubi::Klass::Syntax::Mixin::NameGeneration
+end
+
+instanceMethods = Module.new do
+
+  include Potrubi::Klass::Syntax::Mixin::NewSnippets
+  include Potrubi::Klass::Syntax::Mixin::NewMethods
+  include Potrubi::Klass::Syntax::Mixin::NewAliases
+  include Potrubi::Klass::Syntax::Mixin::SynelManagement
+  
+end
+
+module Potrubi
+  class Klass
+    module Syntax
+      class Builder
+      end
+    end
+  end
+end
+
+Potrubi::Klass::Syntax::Builder.__send__(:include, instanceMethods)  # Instance Methods
+Potrubi::Klass::Syntax::Builder.extend(classMethods)  # Class Methods
+
+__END__
+

data/lib/potrubi/klass/syntax/method.rb

@@ -0,0 +1,436 @@
+
+# potrubi contract dsl
+
+# syntax methods
+
+# to ease the creation of new methods using text snippets
+
+#require_relative '../../bootstrap'
+
+requireList = %w(super ./mixin/new_statements ./mixin/name_generation ./mixin/synel_management)
+#requireList = %w(super)
+defined?(requireList) && requireList.each {|r| require_relative "#{r}"}
+
+#__END__
+
+classMethods = Module.new do
+
+  include Potrubi::Bootstrap
+  
+  # let the class be able to call new_method
+  include Potrubi::Klass::Syntax::Mixin::NewMethods
+  
+end
+
+instanceMethods = Module.new do
+
+  include Potrubi::Bootstrap
+  ##include Potrubi::Mixin::Util
+  include Potrubi::Klass::Syntax::Mixin::NewSnippets
+  include Potrubi::Klass::Syntax::Mixin::NewStatements
+  include Potrubi::Klass::Syntax::Mixin::NameGeneration
+  #include Potrubi::Klass::Syntax::Mixin::StatementManagement
+  include Potrubi::Klass::Syntax::Mixin::SynelManagement
+  
+  ###attr_accessor :name, :type, :key, :value, :variant, :spec, :edit,
+  ###:blok, :key_names, :default
+  
+  attr_accessor :name, :eye, :signature, :result
+  
+  def to_s
+    syntax
+  end
+
+  def inspect
+    ###potrubi_bootstrap_logger_fmt(potrubi_bootstrap_logger_instance_telltale('DSLSynMth'),  potrubi_bootstrap_logger_fmt(n: name))
+    @to_inspect ||= potrubi_bootstrap_logger_fmt(potrubi_bootstrap_logger_instance_telltale('DSLSynMth'))
+  end
+
+  # Accessor Methods
+  # ################
+
+  #alias_method :set_name, :'name='
+  #alias_method :set_eye, :'eye='
+  #alias_method :set_signature, :'signature='
+  alias_method :get_signature, :'signature'
+  #alias_method :set_result, :'result='
+  alias_method :get_result, :'result'
+
+  # Iterator Methods
+  # ################
+
+  def iterator_block(iterName, *iterArgs, &iterBlok)
+    eye =  :'PotKlsSynMth::iter_blok'
+    eyeTale = 'ITER BLOK'
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, eyeTale, potrubi_bootstrap_logger_fmt_who_only(iterName: iterName, iterArgs: iterArgs, iterBlok: iterBlok))
+
+    #snipInst = new_snippet(parent: parent, delegate: delegate)
+    snipInst = new_snippet(parent: parent, delegate: self)
+
+    ##iterSource = potrubi_bootstrap_mustbe_symbol_or_croak(iterArgs.shift, eye)
+
+    #$DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ms(eye, eyeTale, 'ITER SNIP', potrubi_bootstrap_logger_fmt_who(iterName: iterName, iterSource: iterSource, snipInst: snipInst))
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ms(eye, eyeTale, 'ITER SNIP', potrubi_bootstrap_logger_fmt_who(iterName: iterName, snipInst: snipInst))
+
+    iterNewStmMethod = "new_statement_iterator_#{iterName}"
+
+    
+    #iterEachStm = __send__(iterNewStmMethod, iterSource, *iterArgs, &iterBlok)
+    iterEachStm = __send__(iterNewStmMethod, iterName, *iterArgs, &iterBlok)
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ms(eye, eyeTale, 'ITER SNIP EACH', potrubi_bootstrap_logger_fmt_who(iterName: iterName, iterEachStm: iterEachStm, snipInst: snipInst))
+
+    #STOPHEREITERX1
+         
+    Kernel.block_given? && snipInst.instance_eval(&iterBlok)
+    
+    snipInst.cons_west_synels(iterEachStm)
+    snipInst.tail_east_synels(new_statement_end) # add end of block    
+
+    #SYOPHEREITERBLOKX1
+
+    puts("##{eye} #{eyeTale} SYN SYN SYN >>>>>>>>>>>>>>>>>>> >\n#{snipInst.syntax}<")
+
+            #SYOPHEREITERBLOKX2
+
+    add_synels_or_croak(snipInst)  # now add to the method
+
+    #SYOPHEREITERBLOKX3
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye,  potrubi_bootstrap_logger_fmt_who(snipInst: snipInst), potrubi_bootstrap_logger_fmt_who_only(iterArgs: iterArgs, iterBlok: iterBlok))
+    self # fluent
+    #SYOPHEREITERBLOKEXIT
+  end
+
+
+
+    
+  # Name Methods
+  # ###########
+
+  def set_name(*nameValues)
+    self.name = name_builder_method(*nameValues)
+    self # fluent
+  end
+
+  # Eye Methods
+  # ###########
+
+  def set_eye(*eyeValues)
+    self.eye = name_builder_eye(*eyeValues)
+    self # fluent
+  end
+  
+  # Result Methods
+  # ##############
+
+  def set_result(resultValue)
+    self.result = resultValue
+    self # fluent
+  end
+
+  def set_result_self
+    set_result('self')
+  end
+
+  # Signature Methods
+  # #################
+
+  def set_signature(*signatures)
+    self.signature = signatures.flatten.compact.join(',')
+    self # fluent
+  end
+
+  def set_signature_values_and_blok(*names)
+    sigKey = name_creator('', *names)
+    set_signature("*#{sigKey}Values", "&#{sigKey}Blok")
+  end
+  alias_method :set_signature_values_and_block, :set_signature_values_and_blok
+
+  def set_signature_generic
+    set_signature('*a', '&b')
+  end
+  
+  def set_signature_args_and_blok(*names)
+    sigKey = name_creator('', *names)
+    set_signature("#{sigKey}Args=nil", "&#{sigKey}Blok")
+  end
+  alias_method :set_signature_args_and_block, :set_signature_args_and_blok
+  
+  # # Snippet Methods
+  # # ###############
+
+  # def new_snippets(*snippets, &snipBlok)
+  #  snippets.map {|s| new_statement(s) }
+  # end
+
+  # def new_snippet(*snips, &snipBlok)
+  #  new_statement(*snips)
+  # end
+  
+  # # New to Add Snippets Mapping
+  # # ###########################
+  
+  # newToAddMap = [:snippet,
+  #                :snippets,
+  #                ]
+
+
+  # newToAddTexts = newToAddMap.map {|s| "def add_#{s}(*a, &b); add_statements_or_croak(new_#{s}(*a, &b)); end;"}
+  # ###newToAddTexts << "def add_snippet(*a, &b); add_statements_or_croak(new_snippet(*a, &b)); end;"
+  # newToAddText = newToAddTexts.flatten.compact.join("\n")
+  # puts("NEW TO ADD SNIPPET MAP >\n#{newToAddText}")
+  # module_eval(newToAddText)  
+  # #STOPHEREADDTONEWSNIPPETMETHODS
+  
+
+
+  # New to Add Statements Mapping
+  # #############################
+  
+  newToAddMap = [
+                 :logger_method_entry,
+                 :logger_method_exit,
+                 :logger_method_call,
+                 :logger_call,
+                 :logger_method_entry,
+                 :assign,
+                 :assign_if_not_set,
+                 :assign_instance_variable,
+                 :assign_instance_variable_if_not_set,
+                 :assign_local_variable,
+                 :method_call,
+                 ###:snippets,
+                 :in_parentheses,
+                 :if_ternary,
+                 :end,
+                 :self,
+                 :rescue,
+                 :rescue_nil,
+                 :surprise_exception,
+                 :missing_exception,
+                 :duplicate_exception,
+                 :predicate_and_exception,
+                 :predicate_and_surprise_exception,
+                 :predicate_and_duplicate_exception,
+                 :predicate_and_missing_exception,
+                 :contracts,
+                ]
+
+
+  newToAddTexts = newToAddMap.map {|s| "def add_statement_#{s}(*a, &b); add_synels_or_croak(new_statement_#{s}(*a, &b)); end;"}
+  newToAddTexts << "def add_statement(*a, &b); add_synels_or_croak(new_statement(*a, &b)); end;"
+  newToAddTexts << "def add_statements(*a, &b); add_synels_or_croak(new_statements(*a, &b)); end;"
+  newToAddText = newToAddTexts.flatten.compact.join("\n")
+  puts("NEW TO ADD STATEMENT MAP >\n#{newToAddText}")
+  module_eval(newToAddText)
+
+  #STOPHEREPOSTNEWTOADDMAP
+  
+  # Syntax Methods
+  # ##############
+  
+  def syntax
+    eye = :'PotKlsSynMth::syn'
+    eyeTaleME = '>>>>>>>>>>>>>>>>>> SYN MTH'
+    eyeTaleMX = '<<<<<<<<<<<<<<<<<< SYN MTH'
+    nameMethod = name
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, eyeTaleME, potrubi_bootstrap_logger_fmt_who_only(nameMethod: nameMethod))
+
+    syntaxMethod = case nameMethod
+                   when NilClass then nil
+                   else
+
+                     braketMethod = new_braket_method
+                     
+                     braketMethod.push(make_syntax_def,
+                                       make_syntax_eye,
+                                       ###statements.map {|s| s.syntax },
+                                       ###statements,
+                                       synels,
+                                       make_syntax_result,
+                                       make_syntax_end
+
+                                       )
+                     
+                     #braketMethod.to_s
+                                          braketMethod.to_s.gsub(/\n+/, "\n")
+                     
+                   end
+    
+    puts("#{eye} SYNTAX METHOD NAME >#{nameMethod}< syntax \n#{syntaxMethod}")
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, eyeTaleMX, potrubi_bootstrap_logger_fmt_who_only(nameMethod: nameMethod, synMth: syntaxMethod))
+
+    #STOPHEREMETHODSYNTAXEXIT
+    
+    syntaxMethod
+  end
+
+  def make_syntax_def
+    #eye = :'PotKlsSynMth::m_syn_def'
+    nameMethod = name
+    syntaxSignature = make_syntax_signature
+    new_statement('def ', nameMethod, syntaxSignature)
+  end
+
+  def make_syntax_signature
+    #eye = :'PotKlsSynMth::m_syn_sig'
+    signatureMethod = signature
+    case signatureMethod
+    when NilClass then nil
+    else
+      new_statement_in_parentheses(signatureMethod)
+    end
+  end
+  
+  def make_syntax_end
+    :end
+  end
+  
+  def make_syntax_eye
+    eyeLocal = eye
+    eyeLocal ? new_statement("eye = :'", eyeLocal, "'") : nil
+  end
+  
+  def make_syntax_result
+    resultLocal = result
+    #resultLocal ? new_statement(resultLocal) : new_statement_self
+    resultLocal ? new_statement(resultLocal) : nil
+  end
+
+  
+
+  
+end
+
+module Potrubi
+  class Klass
+    module Syntax
+      class Method < Potrubi::Klass::Syntax::Super
+      end
+    end
+  end
+end
+
+Potrubi::Klass::Syntax::Method.__send__(:include, instanceMethods)  # Instance Methods
+Potrubi::Klass::Syntax::Method.extend(classMethods)  # Class Methods
+
+__END__
+
+m = Potrubi::DSL::Syntax::Method.new_method
+
+__END__
+
+classMethods = Module.new do
+
+  def new_contract(dslArgs=nil, &dslBlok) # class method
+    eye = :'DSLAcc::KLS new_cxt'
+    #potrubi_bootstrap_mustbe_symbol_or_croak(dslAttr, eye, "dslAttr is what?")
+    newContract = self.new(dslArgs, &dslBlok)
+    #$DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ca(eye, potrubi_bootstrap_logger_fmt_who(newContract: newContract), potrubi_bootstrap_logger_fmt_who(dslAttr: dslAttr, dslArgs: dslArgsNrm, dslBlok: dslBlok))
+    newContract
+    ###STOPHERENEWCONTRACTEXIT
+  end
+end
+
+Potrubi::Mixin::Contract::DSL.extend(classMethods)  # CLass Methods
+
+__END__
+
+ def new_method(*a, &b)
+    self.class.new_method(*a, &b)
+  end
+
+  def new_statement(*a)
+    puts("METHOD NEW STATEMNET")
+    bktStm = new_braket_statement
+    a.empty? || bktStm.push(*a)
+    ##:wouldbeanewstat
+    bktStm
+  end
+  
+
+  def new_method(dslArgs=nil, &dslBlok) # class method
+    eye = :'PotKlsSynMth::n'
+    puts("NEW METHOD")
+    #potrubi_bootstrap_mustbe_symbol_or_croak(dslAttr, eye, "dslAttr is what?")
+    newMethod = new(dslArgs, &dslBlok)
+    #$DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ca(eye, potrubi_bootstrap_logger_fmt_who(newMethod: newMethod), potrubi_bootstrap_logger_fmt_who(dslAttr: dslAttr, dslArgs: dslArgsNrm, dslBlok: dslBlok))
+    newMethod
+    ###STOPHERENEWMETHODEXIT
+  end
+
+    def zzzadd_statement(*statementElements)
+    eye = :'PotKlsSynMth::a_stm'
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, potrubi_bootstrap_logger_fmt_who(statementElements: statementElements))
+
+    newStatement = new_statement(statementElements)
+
+    add_statements_or_croak(newStatement)
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, potrubi_bootstrap_logger_fmt_who_only(newStatement: newStatement, statementElements: statementElements))
+
+    self # allows for "fluent interface"
+    
+  end
+
+    
+  def zzzziterator_block_each(*iterArgs, &iterBlok)
+    eye = :'iter_blok'
+    eyeTale = 'ITER BLOK'
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, eyeTale, potrubi_bootstrap_logger_fmt_who_only(iterArgs: iterArgs, iterBlok: iterBlok))
+
+    #snipInst = new_snippet(parent: parent, delegate: delegate)
+    snipInst = new_snippet(parent: parent)
+
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ms(eye, eyeTale, 'SNIP INST', potrubi_bootstrap_logger_fmt_who(snipInst: snipInst))
+
+    iterMethod = potrubi_bootstrap_mustbe_symbol_or_croak(iterArgs[0], eye)
+    iterSource = potrubi_bootstrap_mustbe_symbol_or_croak(iterArgs[1], eye)
+
+    iterStm = case iterMethod
+              when :each, :map, :each_with_hash, :each_with_array then
+
+                blokArgs = iterArgs[2 ... iterArgs.size].join(',')
+
+                iterMethodArgs = case iterMethod
+                                 when :each_with_hash then '{}'
+                                 when :each_with_array then '[]'
+                                 else
+                                   nil
+                                 end
+                
+
+                new_statement(iterSource,
+                              '.',
+                              iterMethod,
+                              iterMethodArgs && "(#{iterMethodArgs})",
+                              ' do | ',
+                              blokArgs,
+                              ' |',
+                              )
+                
+                
+              else
+                potrubi_bootstrap_surprise_excepton(iterMethod, eye, "iterMethod is what?")
+              end
+    
+    
+    snipInst.cons_west_synels(iterStm)
+    snipInst.tail_east_synels(new_statement_end) # add end of block    
+
+    #SYOPHEREITERBLOKENTR
+
+
+    puts("##{eye} #{eyeTale} SYN >\n#{snipInst.syntax}<")
+    
+    add_synels_or_croak(snipInst)  # now add to the method
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye,  potrubi_bootstrap_logger_fmt_who(snipInst: snipInst), potrubi_bootstrap_logger_fmt_who_only(iterArgs: iterArgs, iterBlok: iterBlok))
+    self # fluent
+       # SYOPHEREITERBLOKEXIT
+  end