potrubi 0.0.3 → 0.0.4

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

@@ -0,0 +1,91 @@
+
+# potrubi contract dsl
+
+# syntax methods
+
+# to ease the creation of new statements using text snippets
+
+#require_relative '../../bootstrap'
+
+requireList = %w(super)
+requireList.each {|r| require_relative "#{r}"}
+###require "potrubi/klass/syntax/braket"
+
+instanceMethods = Module.new do
+
+  ###include Potrubi::Bootstrap
+  
+  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('DSLSynStm'))
+  end
+  
+  def elements
+    @elements ||= []
+  end
+  
+  def add_elements_or_croak(*newElements)
+    eye = :'PotKlsSynStm::a_eles'
+
+    #newElementsNrm = newElements.flatten.compact.map {|s| mustbe_braket_element_or_croak(s) }
+    newElementsNrm = newElements.flatten.compact
+
+    elements.concat(newElementsNrm)
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ca(eye, potrubi_bootstrap_logger_fmt_who(newEles: newElementsNrm))
+
+    self
+  end
+  alias_method :add_elements, :add_elements_or_croak
+  
+  def syntax
+    eye = :'PotKlsSynStm::syn'
+
+    braketStatement = new_braket_statement.push(elements)
+    
+    syntaxStatement = braketStatement.to_s
+    
+    ###puts("#{eye} STM SYN #{syntaxStatement}")
+    
+    #$DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ca(eye, potrubi_bootstrap_logger_fmt_who_only(self: self, size: elements.size, synStm: syntaxStatement))
+
+    syntaxStatement
+
+  end
+
+
+  
+end
+
+module Potrubi
+  class Klass
+    module Syntax
+      class Statement < Super
+      end
+    end
+  end
+end
+
+Potrubi::Klass::Syntax::Statement.__send__(:include, instanceMethods)  # Instance Methods
+
+__END__
+
+
+classMethods = Module.new do
+
+  include Potrubi::Bootstrap
+  
+end
+
+Potrubi::Klass::Syntax::Statement.extend(classMethods)  # Class Methods
+
+__END__
+
+m = Potrubi::DSL::Syntax::Method.new_method
+
+__END__
+

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

@@ -0,0 +1,88 @@
+
+# potrubi contract dsl
+
+# syntax method
+
+# to ease the creation of new methods using text manipulation
+
+#require_relative '../../bootstrap'
+
+requireList = %w(./mixin/new_brakets ../../mixin/initialize)
+requireList.each {|r| require_relative "#{r}"}
+###require "potrubi/klass/syntax/braket"
+
+
+
+instanceMethods = Module.new do
+
+  include Potrubi::Bootstrap
+  include Potrubi::Mixin::Initialize
+  ###include Potrubi::Klass::Syntax::Mixin::Base
+  include Potrubi::Klass::Syntax::Mixin::NewBrakets
+  
+  ##include Potrubi::Mixin::Util
+
+  ###attr_accessor :name, :eye, :signature, :result
+  
+  def to_s
+    @to_s ||= potrubi_bootstrap_logger_fmt(potrubi_bootstrap_logger_instance_telltale('DSLSynSpr'),  potrubi_bootstrap_logger_fmt(n: name))
+  end
+
+  def mustbe_statement_or_croak(statementValue)
+    statementValue.is_a?(statement_klass) ? statementValue : potrubi_bootstrap_surprise_exception(statementValue, :mustbe_stm, "statementValue not a statement")
+  end
+
+  def mustbe_method_or_croak(methodValue)
+    methodValue.is_a?(method_klass) ? methodValue : potrubi_bootstrap_surprise_exception(methodValue, :mustbe_stm, "methodValue not a statetment")
+  end
+
+
+
+  
+end
+
+module Potrubi
+  class Klass
+    module Syntax
+      class Super
+      end
+    end
+  end
+end
+
+Potrubi::Klass::Syntax::Super.__send__(:include, instanceMethods)  # Instance Methods
+
+__END__
+
+
+classMethods = Module.new do
+
+  include Potrubi::Bootstrap
+
+end
+
+Potrubi::Klass::Syntax::Super.extend(classMethods)  # Class Methods
+
+__END__
+
+m = Potrubi::DSL::Syntax::Super.new
+
+__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/mixin/bootstrap_common.rb

@@ -6,6 +6,7 @@
 
 defined?($DEBUG_POTRUBI_BOOTSTRAP) || ($DEBUG_POTRUBI_BOOTSTRAP = nil)
 
+#$DEBUG_POTRUBI_BOOTSTRAP = true
 #$DEBUG = true # TESTING
 
 require_relative('logger')
@@ -14,33 +15,32 @@ module Potrubi
   module Mixin
     module BootstrapCommon
 
-#=begin
       bootstrapLoggerMethods = {
         logger: :logger_message,
+        logger_instance_telltale: :logger_instance_telltale,
         logger_me: :logger_me,
         logger_mx: :logger_mx,
         logger_ms: :logger_ms,
         logger_ca: :logger_ca,
-        logger_fmt_class: :logger_fmt0,
+        logger_beg: :logger_beg,
+        logger_fin: :logger_fin,
+        logger_fmt: :logger_fmt,
+        logger_fmt_kls: :logger_fmt00,
+        logger_fmt_kls_size: :logger_fmt0000,
         logger_fmt_who: :logger_fmt0,
-        logger_fmt_who_only: :logger_fmt00,
+        logger_fmt_who_only: :logger_fmt000,
       }
 
       bootstrapLoggerText = bootstrapLoggerMethods.map do | bootMethod, loggerMethod |
-         text = <<-"ENDOFHERE"
+        text = <<-"ENDOFHERE"
           def potrubi_bootstrap_#{bootMethod}(*a, &b)
-            #puts("BOOTLOGR POTRUBI DEBUG >#{$DEBUG_POTRUBI_BOOTSTRAP.class}< >#{$DEBUG_POTRUBI_BOOTSTRAP}<")
-            #puts("BOOTLOGR DEBUG >#{$DEBUG.class}< >#{$DEBUG}<")
             $DEBUG_POTRUBI_BOOTSTRAP && #{loggerMethod}(*a, &b)
           end;
           ENDOFHERE
           text
       end.compact.flatten.join("\n")
 
-      ###puts("bootstrapLoggerText >\n#{bootstrapLoggerText}")
-        
       self.module_eval(bootstrapLoggerText)
-#=end
       
       def potrubi_bootstrap_raise_exception(exception, value, *tellTales)
         #tellTale = potrubi_bootstrap_logger_format_telltales(*tellTales)
@@ -49,7 +49,7 @@ module Potrubi
       end
 
       def potrubi_bootstrap_surprise_exception(value, *tellTales)
-        potrubi_bootstrap_raise_exception(ArgumentError, value, "value was a surpise", *tellTales)
+        potrubi_bootstrap_raise_exception(ArgumentError, value, "value was a surprise", *tellTales)
       end
       
       def potrubi_bootstrap_unsupported_exception(value, *tellTales)
@@ -59,6 +59,10 @@ module Potrubi
       def potrubi_bootstrap_missing_exception(value, *tellTales)
         potrubi_bootstrap_raise_exception(ArgumentError, value, "value missing", *tellTales)
       end
+
+      def potrubi_bootstrap_duplicate_exception(value, *tellTales)
+        potrubi_bootstrap_raise_exception(ArgumentError, value, "duplicate value", *tellTales)
+      end
       
       def potrubi_bootstrap_mustbe_hash_or_croak(testValue, *tellTales)
         testValue.is_a?(Hash) ? testValue : potrubi_bootstrap_raise_exception(ArgumentError, testValue, "value not hash", tellTales)
@@ -84,12 +88,24 @@ module Potrubi
         testValue.is_a?(String) ? testValue : potrubi_bootstrap_raise_exception(ArgumentError, testValue, "value not string", tellTales)
       end
 
+      def potrubi_bootstrap_mustbe_symbol_or_croak(testValue, *tellTales)
+        testValue.is_a?(Symbol) ? testValue : potrubi_bootstrap_raise_exception(ArgumentError, testValue, "value not symbol", tellTales)
+      end
+      
+      def potrubi_bootstrap_mustbe_fixnum_or_croak(testValue, *tellTales)
+        testValue.is_a?(Fixnum) ? testValue : potrubi_bootstrap_raise_exception(ArgumentError, testValue, "value not fixnum", tellTales)
+      end
+      
+      def potrubi_bootstrap_mustbe_float_or_croak(testValue, *tellTales)
+        testValue.is_a?(Float) ? testValue : potrubi_bootstrap_raise_exception(ArgumentError, testValue, "value not float", tellTales)
+      end
+      
       def potrubi_bootstrap_mustbe_file_or_croak(testValue, *tellTales)
-        File.file?(testValue) ? testValue : potrubi_bootstrap_raise_exception(ArgumentError, testValue, "value not file", tellTales)
+        File.file?(testValue.to_s) ? testValue : potrubi_bootstrap_raise_exception(ArgumentError, testValue, "value not file", tellTales)
       end
       
       def potrubi_bootstrap_mustbe_directory_or_croak(testValue, *tellTales)
-        File.directory?(testValue) ? testValue : potrubi_bootstrap_raise_exception(ArgumentError, testValue, "value not directory", tellTales)
+        File.directory?(testValue.to_s) ? testValue : potrubi_bootstrap_raise_exception(ArgumentError, testValue, "value not directory", tellTales)
       end
       
       def potrubi_bootstrap_mustbe_key_or_croak(testValue, keyName, *tellTales)
@@ -103,6 +119,10 @@ module Potrubi
       def potrubi_bootstrap_mustbe_not_empty_or_croak(testValue, *tellTales)
         (testValue.respond_to?(:empty?) && (! testValue.empty?)) ? testValue : potrubi_bootstrap_raise_exception(ArgumentError, testValue, "testValue >#{testValue}< failed not empty", tellTales)
       end
+
+      def potrubi_bootstrap_mustbe_empty_or_croak(testValue, *tellTales)
+        (testValue.respond_to?(:empty?) && testValue.empty?) ? testValue : potrubi_bootstrap_raise_exception(ArgumentError, testValue, "testValue >#{testValue}< failed empty", tellTales)
+      end
       
       def bootstrap_find_module_constant(*a)
         bootstrap_find_module_constant_or_croak(*a) rescue nil
@@ -124,3 +144,9 @@ module Potrubi
     end
   end
 end
+
+__END__
+
+Potrubi::Mixin::BootstrapCommon.instance_methods.each {|m| puts("Potrubi::Mixin::BootstrapCommon Inst Mth >#{m}<")}
+
+__END__

data/lib/potrubi/mixin/configuration.rb

@@ -16,7 +16,6 @@ mixinContent = Module.new do
   include Potrubi::Mixin::Persistence
   
   # so common
-  
   def set_attributes_or_croak(attrArgsNom, &attrBlok)
     eye = :'s_attrs'
     mustbe_hash_or_croak(attrArgsNom, eye)
@@ -38,7 +37,6 @@ mixinContent = Module.new do
     self
   end
 
-
   # If has key value is external source e.g. yaml
   # read it and set_attributes with it
   # Else raise exception unless blok is given
@@ -65,7 +63,6 @@ mixinContent = Module.new do
   end
   alias_method :set_attributes_from_configuration_files_or_croak, :set_attributes_from_configuration_sources_or_croak
   
-
   def set_attributes_using_specification_or_croak(attrSpec, attrData,  &attrBlok)
     eye = :'s_attrs_using_spec'
 
@@ -73,6 +70,9 @@ mixinContent = Module.new do
 
     mustbe_hash_or_croak(attrSpec, eye, "attrSpec failed contract")
     mustbe_hash_or_croak(attrData, eye, "attrData failed contract")
+
+    attrSpec.each {|k,v| puts("#{eye} ATTR SPEC k >#{k}< v >#{v.class}< >#{v}<") }
+        attrData.each {|k,v| puts("\n\n\n#{eye} ATTR DATA k >#{k}< v >#{v.class}< >#{v}<") }
     
     attrData.each do | attrName, attrValue |
 
@@ -99,6 +99,34 @@ mixinContent = Module.new do
     self
     
   end
+
+  def resolve_ruby_exe_path_or_croak(rubyArgs)
+    eye = :rsv_ruby_exe_path
+    
+    mustbe_hash_or_croak(rubyArgs, eye)
+
+    rubyVersion = rubyArgs[:ruby] || :ruby # default is MRI
+
+    rubyPath = case rubyVersion
+               when String then rubyVersion
+               when Symbol
+                 case rubyVersion
+                 when :ruby then '/usr/bin/ruby'
+                 when :jruby then '/usr/bin/jruby'
+                 else
+                   surprise_exception(rubyVersion, eye, "rubyVersion is what?")
+                 end
+               else
+                 surprise_exception(rubyVersion, eye, "rubyVersion is what?")
+               end
+    
+    mustbe_file_or_croak(rubyPath, eye, "ruby path does not exist")
+
+    $DEBUG && logger_ca(eye, logger_fmt_kls(rubyPath: rubyPath, rubyVersion: rubyVersion))
+
+    rubyPath
+    
+  end
   
 end
 

data/lib/potrubi/mixin/contract.rb

@@ -4,12 +4,6 @@
 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
@@ -21,11 +15,11 @@ mixinContent = Module.new do
   
   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,
+    :float	=> nil,
     :range	=> nil,
     :proc	=> nil,
     :class	=> nil,
@@ -34,28 +28,28 @@ mixinContent = Module.new do
     :enumerator   => nil,
     :regexp       => nil,
     :struct       => nil,
+    :exception  => 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,
+    :directory    => [{:name => :'is_value_directory?', :spec => ->(d) {(d.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
+
+    :is_a => [{:name => :'is_value_is_a?', :spec => ->(p,q) {p.is_a?(q) ? p : nil}}, mustbeLimited1TwoArgSpec].flatten,
   }
 
   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]]})
@@ -63,10 +57,8 @@ mixinContent = Module.new do
       {:edit => edits, :spec => v}
     end
   end
-  
 
   # Compare Contracts
-  
   compareMethods = {
     :eq => '==',
     :equal => '==',
@@ -87,7 +79,6 @@ mixinContent = Module.new do
   }
 
   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
 

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

@@ -0,0 +1,307 @@
+
+# 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(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,  MUSTBE_NAME: k, MUSTBE_SPEC: k, MUSTBE_KEY_NAME: k}
+  end
+
+  def standard_mustbe_edit(k, v)
+    {MUSTBE_NAME: k, MUSTBE_SPEC: k, MUSTBE_KEY_NAME: k}
+  end
+
+  def keyname_mustbe_edit(k, v, n)
+    {MUSTBE_NAME: k, MUSTBE_SPEC: k, MUSTBE_KEY_NAME: n}
+  end
+  
+  # convenience methods
+  
+  def merge_edits(*edits)
+    Potrubi::Mixin::Dynamic.dynamic_merge_edits(*edits)
+  end
+
+  def merge_specs(*specs)
+    specs.flatten.compact
+  end
+
+  def merge_spec_and_edit(spec, edit)
+    {edit: edit, spec: spec}
+  end
+
+
+  def standard_syntax_value_test(v, t='testValue')
+    eye = :'standard_syntax_value_test'
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, 'PRE', 'VALUE', 'TEST', potrubi_bootstrap_logger_fmt_who(v: v, t: t))
+    r = case v
+        when Symbol then  "is_value_#{v}?(#{t})"
+        when Class, String then "#{t}.is_a?(#{v})"
+        when NilClass then "#{t}"
+        when Proc then value.call
+        else
+          potrubi_bootstrap_surprise_exception(v, eye, "v >#{v}< spec not expected")
+        end
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, 'POST', 'VALUE', 'TEST', potrubi_bootstrap_logger_fmt_who(v: v, r: r))
+
+    r
+
+  end
+  
+  
+  # This method is peculiar 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'
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, potrubi_bootstrap_logger_fmt_who(k: k, v: v, edit: edit))
+    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 Symbol then  merge_spec_and_edit(spec, merge_edits(edit, {IS_VALUE_TEST: "is_value_#{v}?(testValue)"}))
+        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 v.merge(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_mx(eye, potrubi_bootstrap_logger_fmt_who(k: k, v: v, edit: edit), potrubi_bootstrap_logger_fmt_who(spec: spec), potrubi_bootstrap_logger_fmt_who(RRRRRRRRRRRRRRRRRRRRRRRRRr: r))
+    r
+  end
+
+  def standard_accessor_recipe_block(s) # returns a lambda
+    ->(k, v) do
+      edit = standard_accessor_edit(k, v)
+      spec = s
+      r = standard_case_statement(k, v, s, edit, spec)
+      r
+    end
+  end
+
+  def standard_derived_edits_assign(s, srcKey, tgtKey, tgtText)
+    eye = :'standard_derived_edits_assign'
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, potrubi_bootstrap_logger_fmt_who(srcKey: srcKey, tgtKey: tgtKey, tgtText: tgtText, s: s))
+    # does the target key already exist?
+    potrubi_bootstrap_mustbe_hash_or_croak(s)
+    r = if s.has_key?(tgtKey) then
+          # yes; nothing to do
+          s
+        else
+          # no; does the source key exist?. if use use to set target key
+          if s.has_key?(srcKey) then
+            s[tgtKey] = standard_syntax_value_test(s[srcKey], tgtText)
+            s
+          else
+            s
+          end
+        end
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, potrubi_bootstrap_logger_fmt_who(srcKey: srcKey, tgtKey: tgtKey, r: r))
+    potrubi_bootstrap_mustbe_hash_or_croak(r, eye, 'POST', 'EDITS', 'ASSIGN')
+    #r
+  end
+
+  def standard_derived_edits(edits={})
+    eye = :'standard_derived_edits'
+
+    derivedMap =
+      {
+      IS_COLLECTION_VALUE_TEST: {key: :VALUE_TYPE, target: 'v'},
+      IS_COLLECTION_KEY_TEST: {key: :KEY_TYPE, target: 'k'},
+    }
+
+    editsDerived =
+      if edits then
+        potrubi_bootstrap_mustbe_hash_or_croak(edits)
+        derivedMap.reduce(edits) do | s, (tgtKey, srcSpec) |
+        srcKey = srcSpec[:key]
+        tgtText = srcSpec[:target]
+        standard_derived_edits_assign(s, srcKey, tgtKey, tgtText)
+      end
+      else
+        nil
+      end
+    
+    editsDerived && potrubi_bootstrap_mustbe_hash_or_croak(editsDerived)
+
+  end
+
+  def standard_mustbe_recipe_block(s) # returns a lambda
+    ->(k, v) {
+
+      spec = s
+      
+      r = case v
+          when Hash then
+
+            o = v[:other] || {}
+
+            # any key name?
+            key_name = o[:key_name]
+            
+            eKeyName = keyname_mustbe_edit(k, v, key_name || k)
+
+            eDerived = standard_derived_edits(v[:edit])
+
+            e = merge_edits(eKeyName, eDerived)
+            
+            # any type?
+            t = o[:type]
+            
+            r = standard_case_statement(k, t || v, s, e, spec)
+
+            
+          else
+            e = keyname_mustbe_edit(k, v, k)
+            ###spec = {spec: s}
+            
+            r = standard_case_statement(k, v, s, e, spec)
+          end
+      
+      r
+    }
+  end
+  
+  def resolve_recipe_texts(*recipeTexts)
+    recipeTexts.flatten
+  end
+  
+
+  def recipe_accessors(attrTarget, attrDefs, *attrTexts, &attrBlok)
+    eye = :'rcp_accessors'
+
+    $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_accessor_with_contract : attrTexts) # default is contract accessor
+
+    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
+
+  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
+
+
+
+  def recipe_variant_accessor(attrTarget, attrDefs, *attrTexts, &attrBlok)
+    eye = :'rcp_var_acc'
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, potrubi_bootstrap_logger_fmt_who(attrTarget: attrTarget, attrDefs: attrDefs, attrTexts: attrTexts))
+
+    textDefs = resolve_recipe_texts(attrTexts)
+
+    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
+
+  end
+  
+
+
+  def recipe_variant_mustbe(attrTarget, attrDefs, *attrTexts, &attrBlok)
+    eye = :'rcp_var_mustbe'
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, potrubi_bootstrap_logger_fmt_who(attrTarget: attrTarget, attrDefs: attrDefs, attrTexts: attrTexts))
+
+    textDefs = resolve_recipe_texts(attrTexts.compact.empty? ? :package_mustbe : attrTexts) # default is contract accessor
+
+    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 Contract
+      module Recipes
+      end
+    end
+  end
+end
+
+Potrubi::Mixin::Contract::Recipes.extend(mixinContent) # Make mixin methods
+
+__END__
+
+# quick tests
+
+$LOAD_PATH.unshift('../../../.') # ensure get code not gem
+
+$LOAD_PATH.each {|p| puts("LOAD PATH >#{p}<")}
+#STOPHERELOADPATH
+require '../../core'
+require "potrubi/klass/syntax/braket"
+
+$DEBUG = true
+$DEBUG_POTRUBI_BOOTSTRAP = true
+
+testClass2 = Class.new do
+
+  Potrubi::Mixin::Contract::Recipes.recipe_dsl(self) do
+
+    #accessor :x1, default: 10
+    #accessor :x2, default: 'default-for-x2'
+    #accessor :x3, default: :x3_def_is_a_symbol
+
+    #    accessor :riemann_host, :string
+    accessor :riemann_port, type: :fixnum, default: 5555
+    #accessor :riemann_interval, type: :fixnum, default: 10
+    
+    
+  end
+  
+
+end
+
+__END__
+