potrubi 0.0.3 → 0.0.4

data/lib/potrubi/klass/syntax/mixin/name_generation.rb

@@ -0,0 +1,85 @@
+
+# potrubi contract dsl
+
+# syntax methods: method
+
+# to ease the creation of new methods using text manipulation
+
+#require_relative '../../bootstrap'
+
+#requireList = %w(base )
+#requireList.each {|r| require_relative "#{r}"}
+###require "potrubi/klass/syntax/braket"
+
+
+instanceMethods = Module.new do
+
+  #include Potrubi::Klass::Syntax::Mixin::Base
+
+   # Naming Methods
+  # ##############
+
+  def name_builder_instance_variable(*names)
+    name_creator('', '@', name_creator('_', *names))
+  end
+  
+  def name_builder_method_getter(*names)
+    name_builder_method(*names)
+  end
+  
+  def name_builder_method_setter(*names)
+    name_creator('', name_builder_method(*names), '=')
+  end
+
+  def name_builder_method_or_croak(*names)
+    name_creator('_', name_builder_method(*names), :or, :croak)
+  end
+  
+  def name_builder_method(*names)
+    name_creator('_', *names)
+  end
+
+  def name_creator(sepChar, *names, &joinBlok)
+    r = names.flatten.compact
+    case
+    when Kernel.block_given? then r.map {|a| joinBlok.call(a) }.flatten.compact.join
+    else
+      #p = r.map {|a| [a, sepChar]}.flatten
+      #p.pop # last sepchar
+      #p.join('')
+      r.join(sepChar)
+    end
+  end
+
+  def name_builder_eye_getter(*eyes)
+    name_builder_eye(:g, *eyes)
+  end
+
+  def name_builder_eye_setter(*eyes)
+    name_builder_eye(:s, *eyes)
+  end
+  
+  def name_builder_eye(*eyes)
+    name_builder_method(*eyes).to_sym
+  end
+  
+end
+
+
+
+module Potrubi
+  class Klass
+    module Syntax
+      module Mixin
+        module NameGeneration
+        end
+      end
+    end
+  end
+end
+
+Potrubi::Klass::Syntax::Mixin::NameGeneration.__send__(:include, instanceMethods)  # Instance Methods
+
+
+__END__
+

data/lib/potrubi/klass/syntax/mixin/new_aliases.rb

@@ -0,0 +1,76 @@
+
+# potrubi contract dsl
+
+# syntax methods: method
+
+# to ease the creation of new methods using text manipulation
+
+#require_relative '../../bootstrap'
+
+instanceMethods = Module.new do
+
+  #include Potrubi::Klass::Syntax::Mixin::Base
+
+  def alias_klass
+    @alias_klass ||= Potrubi::Klass::Syntax::Alias
+  end
+  
+  # New Alias Methods
+  # #################
+
+  def new_alias(dslArgs=nil, &dslBlok) # class alias
+    eye = :'PotKlsSynMixAli::n_alias'
+    #puts("NEW ALIAS")
+    newAlias = alias_klass.new(dslArgs, &dslBlok)
+    #$DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ca(eye, potrubi_bootstrap_logger_fmt_who(newAlias: newAlias), potrubi_bootstrap_logger_fmt_who_only(newAlias: newAlias, dslArgs: dslArgsNrm, dslBlok: dslBlok))
+    newAlias
+    ###STOPHERENEWALIASEXIT
+  end
+
+  
+  def new_aliases(aliasDefs)
+    eye = :n_aliases
+
+    potrubi_bootstrap_mustbe_hash_or_croak(aliasDefs)
+
+    newAlias = new_alias do
+
+      aliasDefs.each do | srcMth, tgtMth |
+
+        add_statement_method_alias(srcMth, tgtMth)
+
+      end
+
+    end
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ca(eye, potrubi_bootstrap_logger_fmt_who(newAlias: newAlias, aliasDefs: aliasDefs))
+    #STOPHERENEWMETHODRESCUE
+
+    newAlias
+    
+  end
+ 
+  
+end
+
+
+
+module Potrubi
+  class Klass
+    module Syntax
+      module Mixin
+        module NewAliases
+        end
+      end
+    end
+  end
+end
+
+Potrubi::Klass::Syntax::Mixin::NewAliases.__send__(:include, instanceMethods)  # Instance Methods
+
+
+requireList = %w(../alias)
+defined?(requireList) && requireList.each {|r| require_relative "#{r}"}
+
+__END__
+

data/lib/potrubi/klass/syntax/mixin/new_brakets.rb

@@ -0,0 +1,89 @@
+
+# potrubi contract dsl
+
+# syntax methods for brakets
+
+# to ease the creation of new methods using text manipulation
+
+#require_relative '../../bootstrap'
+
+#requireList = %w(base)
+#requireList.each {|r| require_relative "#{r}"}
+###require "potrubi/klass/syntax/braket"
+
+instanceMethods = Module.new do
+
+  #include Potrubi::Klass::Syntax::Mixin::Base
+
+  def braket_klass
+    @braket_klass ||= Potrubi::Klass::Syntax::Braket
+  end
+  alias_method :braket_method_klass, :braket_klass
+  alias_method :braket_statement_klass, :braket_klass
+  alias_method :braket_snippet_klass, :braket_klass
+  
+  # Braket Methods
+  # ##############
+  
+  def mustbe_braket_method_or_croak(braketMethod)
+    braketMethod.is_a?(braket_method_klass) ? braketMethod : potrubi_bootstrap_surprise_exception(braketMethod, :mustbe_bkt_mth, "braketMethod not a braket method")
+  end
+  
+  def new_braket_method
+    braket_method_klass.new_method
+  end
+
+  # Statement Braket Methods
+  # ########################
+
+  def new_braket_statement
+    #puts("NEW BRAKET STATEMENT ")
+    #stateKls = braket_statement_klass
+    #puts("NEW BRAKET STATEMENT kls >#{stateKls.class}< >#{stateKls}<")
+    braket_statement_klass.new_statement
+  end
+  
+  def mustbe_braket_statement_or_croak(braketStatement)
+    braketStatement.is_a?(braket_statement_klass) ? braketStatement : potrubi_bootstrap_surprise_exception(braketStatement, :mustbe_bkt_stm, "braketStatement not a braket statetment")
+  end
+
+  # Snippet Braket Methods
+  # ########################
+
+  def new_braket_snippet
+    #puts("NEW BRAKET SNIPPET ")
+    #stateKls = braket_snippet_klass
+    #puts("NEW BRAKET SNIPPET kls >#{stateKls.class}< >#{stateKls}<")
+    braket_snippet_klass.new_snippet
+  end
+  
+  def mustbe_braket_snippet_or_croak(braketSnippet)
+    braketSnippet.is_a?(braket_snippet_klass) ? braketSnippet : potrubi_bootstrap_surprise_exception(braketSnippet, :mustbe_bkt_stm, "braketSnippet not a braket snippet")
+  end
+  
+end
+
+module Potrubi
+  class Klass
+    module Syntax
+      module Mixin
+        module NewBrakets
+        end
+      end
+    end
+  end
+end
+
+Potrubi::Klass::Syntax::Mixin::NewBrakets.__send__(:include, instanceMethods)  # Instance Methods
+
+
+__END__
+
+Potrubi::Klass::Syntax::Super.extend(classMethods)  # Class Methods
+
+__END__
+
+m = Potrubi::DSL::Syntax::Super.new
+
+__END__
+

data/lib/potrubi/klass/syntax/mixin/new_methods.rb

@@ -0,0 +1,158 @@
+
+# potrubi contract dsl
+
+# syntax methods: method
+
+# to ease the creation of new methods using text manipulation
+
+#require_relative '../../bootstrap'
+
+
+
+#__END__
+
+instanceMethods = Module.new do
+
+  #include Potrubi::Klass::Syntax::Mixin::Base
+  include Potrubi::Klass::Syntax::Mixin::NewSnippets
+
+  # New Method Methods
+  # ##################
+
+
+  def method_klass
+    @method_klass ||= Potrubi::Klass::Syntax::Method
+  end
+  
+  def new_method(dslArgs=nil, &dslBlok)
+    eye = :'PotKlsSynMixNewMths::n_mth'
+    puts("NEW METHOD USING SNIPPETS X1")
+    #potrubi_bootstrap_mustbe_symbol_or_croak(dslAttr, eye, "dslAttr is what?")
+
+    newMethod = method_klass.new(dslArgs)
+        puts("NEW METHOD USING SNIPPETS X2")
+    #newSnippet = snippet_klass.new(parent: newMethod.parent, delegate: newMethod, &dslBlok)
+    # use same synels collection
+    newSnippet = snippet_klass.new(synels: newMethod.synels, parent: newMethod.parent, delegate: newMethod, &dslBlok)
+
+        puts("NEW METHOD USING SNIPPETS X3")
+    #STOPHERENEWMETHODPOSTNEWSNIPOET
+    #newMethod.statements = newSnippet.statements
+    #newMethod.add_statements_or_croak(newSnippet.statements)
+
+    snipSyns = newSnippet.synels
+    #STOPHEREPREX3A
+    puts("NEW METHOD USING SNIPPETS X3a SYNELS >#{snipSyns.class}< >\n#{snipSyns.to_s}<")
+    #STOPHEREPOISTX3Q
+    
+    #newMethod.add_synels_or_croak(newSnippet.synels)
+    #newMethod.synels = newSnippet.synels
+    
+    puts("NEW METHOD USING SNIPPETS X4")
+    #$DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ca(eye, potrubi_bootstrap_logger_fmt_who(newMethod: newMethod), potrubi_bootstrap_logger_fmt_who_only(dslAttr: dslAttr, dslArgs: dslArgsNrm, dslBlok: dslBlok))
+    newMethod
+    #STOPHERENEWMETHODEXIT
+  end
+
+  def keepkeepkeep_new_method(dslArgs=nil, &dslBlok)
+    eye = :'PotKlsSynSpr::n_mth'
+    #puts("NEW METHOD")
+    #potrubi_bootstrap_mustbe_symbol_or_croak(dslAttr, eye, "dslAttr is what?")
+    newMethod = method_klass.new(dslArgs, &dslBlok)
+    #$DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ca(eye, potrubi_bootstrap_logger_fmt_who(newMethod: newMethod), potrubi_bootstrap_logger_fmt_who_only(dslAttr: dslAttr, dslArgs: dslArgsNrm, dslBlok: dslBlok))
+    newMethod
+    ###STOPHERENEWMETHODEXIT
+  end
+
+
+  
+  def new_method_rescue(*methodNames)
+    eye = :n_mth_rsc
+
+    newMethod = new_method do
+
+      methodNameRescue = name_builder_method(*methodNames)
+      methodNameCroak  = name_builder_method_or_croak(methodNameRescue)
+      
+      set_name(methodNameRescue)
+      set_signature_generic
+      add_statement(
+                    new_statement_method_call(methodNameCroak, get_signature),
+                    ' ',
+                    new_statement_rescue_nil,
+                    #' rescue nil'
+                    )
+    end
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ca(eye, potrubi_bootstrap_logger_fmt_who(newMethod: newMethod, name: methodNames))
+    #STOPHERENEWMETHODRESCUE
+
+    newMethod
+  end
+
+
+  def new_method_caller_callee(callArgs, &callBlok)
+    eye = :n_mth_caller_callee
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, potrubi_bootstrap_logger_fmt_who_only(callArgs: callArgs, callBlok: callBlok))
+
+    potrubi_bootstrap_mustbe_hash_or_croak(callArgs, eye)
+
+    newMethod = new_method do
+      
+      nameCallee =  name_builder_method(callArgs[:callee])
+      nameCaller =  name_builder_method(callArgs[:caller])
+      
+      potrubi_bootstrap_mustbe_string_or_croak(nameCaller, eye)
+      potrubi_bootstrap_mustbe_string_or_croak(nameCallee, eye)
+
+      signCaller =  callArgs[:caller_sig]
+      argsCalleeNom =  callArgs[:callee_args]
+
+      argsCallee = case
+                   when Kernel.block_given? then callBlok.call(signCaller)
+                   when (! argsCalleeNom.nil?) then argsCalleeNom
+                   else
+                     potrubi_bootstrap_surprise_exception(nameCaller, eye, "no args for caller")
+                   end
+      
+      
+
+      set_name(nameCaller)
+      set_signature(signCaller)
+      add_statement_method_call(nameCallee,
+                                *argsCallee,
+                                )
+
+    end
+
+    #$DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, potrubi_bootstrap_logger_fmt_who(newMethod: newMethod), potrubi_bootstrap_logger_fmt_who_only(nameCaller: nameCaller, nameCallee: nameCallee, signCaller: signCaller, argsCallee: argsCallee))
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, potrubi_bootstrap_logger_fmt_who(newMethod: newMethod), potrubi_bootstrap_logger_fmt_who_only(callArgs: callArgs, callBlok: callBlok))
+    #STOPHERENEWMETHODCALLMULTFROMSINGLE
+
+    newMethod
+  end
+  
+  
+end
+
+
+
+module Potrubi
+  class Klass
+    module Syntax
+      module Mixin
+        module NewMethods
+        end
+      end
+    end
+  end
+end
+
+Potrubi::Klass::Syntax::Mixin::NewMethods.__send__(:include, instanceMethods)  # Instance Methods
+
+requireList = %w(../method)
+defined?(requireList) && requireList.each {|r| require_relative "#{r}"}
+###require "potrubi/klass/syntax/braket"
+
+__END__
+

data/lib/potrubi/klass/syntax/mixin/new_snippets.rb

@@ -0,0 +1,74 @@
+
+# potrubi contract dsl
+
+# syntax methods: method
+
+# to ease the creation of new methods using text manipulation
+
+#require_relative '../../bootstrap'
+
+
+
+#__END__
+
+instanceMethods = Module.new do
+
+  #include Potrubi::Klass::Syntax::Mixin::Base
+
+  def snippet_klass
+    @snippet_klass ||= Potrubi::Klass::Syntax::Snippet
+  end
+  
+  # New Snippet Methods
+  # ###################
+
+  def new_snippet(snipArgs=nil, &snipBlok) # class snippet
+    eye = :'PotKlsSynMixSni::n_snippet'
+    #puts("NEW SNIPPET")
+    newSnippet = snippet_klass.new(snipArgs, &snipBlok)
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ca(eye, potrubi_bootstrap_logger_fmt_who(newSnippet: newSnippet), potrubi_bootstrap_logger_fmt_who_only(snipArgs: snipArgs, snipBlok: snipBlok))
+    newSnippet
+    #STOPHERENEWSNIPPETEXIT
+  end
+
+end
+
+module Potrubi
+  class Klass
+    module Syntax
+      module Mixin
+        module NewSnippets
+        end
+      end
+    end
+  end
+end
+
+Potrubi::Klass::Syntax::Mixin::NewSnippets.__send__(:include, instanceMethods)  # Instance Methods
+
+requireList = %w(../snippet)
+defined?(requireList) && requireList.each {|r| require_relative "#{r}"}
+
+__END__
+
+  def new_snippets(snippetDefs)
+    eye = :n_snippetes
+
+    potrubi_bootstrap_mustbe_hash_or_croak(snippetDefs)
+
+    newSnippet = new_snippet do
+
+      snippetDefs.each do | srcMth, tgtMth |
+
+        add_statement_method_snippet(srcMth, tgtMth)
+
+      end
+
+    end
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ca(eye, potrubi_bootstrap_logger_fmt_who(newSnippet: newSnippet, snippetDefs: snippetDefs))
+    #STOPHERENEWMETHODRESCUE
+
+    newSnippet
+    
+  end