potrubi 0.0.3 → 0.0.4

data/lib/potrubi/mixin/logger.rb

@@ -1,7 +1,5 @@
 
-# Common Mixins
-
-# logger methods 
+# potrubi mixin logger
 
 require "logger"
 
@@ -36,7 +34,6 @@ module Potrubi
         
       end
       
-      #=begin
       def logger_enabled?(logrLevel=nil)
         case logrLevel
         when Fixnum
@@ -45,34 +42,25 @@ module Potrubi
           nil
         end
       end
-      #=end
       
-      #=begin
       def logger_fmt(*logrArgs)
         logrArgs.flatten.compact.join(' ')
       end
       alias_method :logger_format_telltales, :logger_fmt
       alias_method :potrubi_bootstrap_logger_format_telltales, :logger_fmt
-      #=end
       
-      #=begin
       def logger_message(logEye, *logArgs, &msgBlok)
         $DEBUG && logger.debug(logEye) { logger_format_telltales(*logArgs) }
       end
-      #=end
-
-      #=begin
+      
       def logger_message_beg(logEye, *logArgs, &msgBlok)
         logger_message(logEye, :BEG, *logArgs, &msgBlok)
       end
-      #=end
-      #=begin
+
       def logger_message_fin(logEye, *logArgs, &msgBlok)
         logger_message(logEye, :FIN, *logArgs, &msgBlok)
       end
-      #=end
       
-      #=begin
       def logger_method_entry(logEye, *a)
         logger_message(logEye, '==>', *a)
       end
@@ -87,7 +75,6 @@ module Potrubi
       alias_method :logger_me, :logger_method_entry
       alias_method :logger_mx, :logger_method_exit
       alias_method :logger_ca, :logger_method_call
-      #=end
       
       alias_method :logger_ms, :logger_message
       alias_method :logger_en?, :logger_enabled?
@@ -95,47 +82,41 @@ module Potrubi
       alias_method :logger_beg, :logger_message_beg
       alias_method :logger_fin, :logger_message_fin
       
-      #=begin
       def logger_fmt0(logrArgs)
         logrArgs.is_a?(Hash) || raise(ArgumentError,"logrArgs >#{logrArgs}< not hash",caller)
-        logrArgs.inject([]) {|s, (k,v)| s << "#{k} >#{v.class}< >#{v}<"}
+        logrArgs.inject([]) {|s, (k,v)| s << "#{k} >#{v.class}< >#{v.inspect}<"}
       end
-      #=end
-      #=begin
+
       def logger_fmt00(logrArgs)
         logrArgs.is_a?(Hash) || raise(ArgumentError,"logrArgs >#{logrArgs}< not hash",caller)
         logrArgs.inject([]) {|s, (k,v)| s << "#{k} >#{v.class}<"}
       end
-      #=end
-      #=begin
+
+      def logger_fmt000(logrArgs)
+        logrArgs.is_a?(Hash) || raise(ArgumentError,"logrArgs >#{logrArgs}< not hash",caller)
+        logrArgs.inject([]) {|s, (k,v)| s << "#{k} >#{v.inspect}<"}
+      end
+
+      def logger_fmt0000(logrArgs)
+        logrArgs.is_a?(Hash) || raise(ArgumentError,"logrArgs >#{logrArgs}< not hash",caller)
+        logrArgs.inject([]) {|s, (k,v)| s << "#{k} >#{v.class}< >#{v.size rescue :nosize}<"}
+      end
+
       def logger_fmt1(logrArgs)
         logrArgs.is_a?(Hash) || raise(ArgumentError,"logrArgs >#{logrArgs}< not hash",caller)
-        logrArgs.inject([]) {|s, (k,v)| s << "#{k} >#{v.whoami?}< >#{v}<"}
+        logrArgs.inject([]) {|s, (k,v)| s << "#{k} >#{v.whoami?}< >#{v.inspect}<"}
       end
-      #=end
-      #=begin
+
       def logger_fmt2(logrArgs)
         logrArgs.is_a?(Hash) || raise(ArgumentError,"logrArgs >#{logrArgs}< not hash",caller)
         logrArgs.inject([]) {|s, (k,v)| s << "#{k} >#{v.whoami?}<"}
       end
-      #=end
 
       alias_method :logger_fmt_kls, :logger_fmt0
       alias_method :logger_fmt_kls_only, :logger_fmt00
       alias_method :logger_fmt_who, :logger_fmt1
       alias_method :logger_fmt_who_only, :logger_fmt2
 
-=begin
-      alias_method :potrubi_bootstrap_logger, :logger_message
-      alias_method :potrubi_bootstrap_logger_me, :logger_me
-      alias_method :potrubi_bootstrap_logger_mx, :logger_mx
-      alias_method :potrubi_bootstrap_logger_ms, :logger_ms
-      alias_method :potrubi_bootstrap_logger_ca, :logger_ca
-      alias_method :potrubi_bootstrap_logger_fmt_class, :logger_fmt0
-      alias_method :potrubi_bootstrap_logger_fmt_who, :logger_fmt0
-      alias_method :potrubi_bootstrap_logger_fmt_who_only, :logger_fmt00
-=end
-      
       def logger_info(*a, &b)
         logger_generic(:info, *a, &b)
       end
@@ -161,18 +142,24 @@ module Potrubi
 
                     logTypeCheck.empty? || raise_exception(ArgumentError, "log type >#{logType}< unknown")
 
-                    #logger.__send__(logType, *logArgs, &logBlok)
                     logger.__send__(logType, *logEye) { logger_fmt(*logArgs) }
                   end
         
 
       end
+
+      def logger_instance_telltale(tellTale=nil)
+        case tellTale
+        when NilClass then
+          @logger_instance_telltale ||= "I(%x)" % (object_id.abs*2)
+        else
+          @logger_instance_telltale = "#{tellTale}(%x)" % (object_id.abs*2)
+        end
+      end
+  
     end
   end
 end
 
 
 __END__
-
-IGR::Mixin::Logger.instance_methods.each {|m| puts("Lgr Inst Mth >#{m}<")}
-

data/lib/potrubi/mixin/pathandnames.rb

@@ -3,15 +3,11 @@
 
 require_relative '../bootstrap'
 
-#requireList = %w(bootstrap)
-#requireList.each {|r| require_relative "#{r}"}
-
 mixinContent = Module.new do
 
   # Fundamental Methods
   # ###################
   
-  #=begin
   def transform_pathandname_or_croak(transformSpec, *transformData)
     eye = :tfm_pan
 
@@ -21,15 +17,12 @@ mixinContent = Module.new do
 
     transformDefs = case transformSpec
                     when Proc, Symbol, Array then [*transformSpec].compact
-                      #when Array then transformSpec
-                      ###mustbe_hashs_or_croak(transformSpec)
                     else
                       potrubi_bootstrap_surprise_exception(transformSpec, eye, "transformSpec is what?")
                     end
 
 
     transformResult = transformDefs.inject(transformData) do |s, transformCode|
-      ###transformCode = transformDef[:transform]
       $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ms(eye,"INJ BEG", potrubi_bootstrap_logger_fmt_who(:transformCode => transformCode, :s => s))
       case transformCode
       when Proc then transformCode.call(s)
@@ -53,13 +46,10 @@ mixinContent = Module.new do
     transformResult
     
   end
-  #=end
-
 
   # Core Methods
   # ############
 
-  #=begin
   def normalise_pathandname_names_syntax_or_croak(*names, &block)
     eye = :nrm_pan_ns_syn
     
@@ -70,20 +60,16 @@ mixinContent = Module.new do
     nameNorm
     
   end
-  #=end
   
-  #=begin
   def normalise_pathandname_hier_drop_while(*names, &block)
     r = names.flatten.compact.drop_while(&block)
     potrubi_bootstrap_logger_ca(:nrm_pan_drop_while, potrubi_bootstrap_logger_fmt_who(:r => r, :names => names))
     r
   end
-  #=end
   
-  #=begin
   def normalise_pathandname_hier_split_at(*names, &splitBlok)
     a = names.flatten
-    i = a.find_index(&splitBlok)
+    i = splitBlok.call(a)
 
     r = case i
         when NilClass then [a] # not found: all are "before"
@@ -93,40 +79,33 @@ mixinContent = Module.new do
           potrubi_bootstrap_surprise_exception(i, eye, "a >#{a}< i is what?")
         end
     
-    potrubi_bootstrap_logger_ca(:nrm_pan_h_split_at, potrubi_bootstrap_logger_fmt_who(:r => r, :names => names))
+    potrubi_bootstrap_logger_ca(:nrm_pan_h_split_at, potrubi_bootstrap_logger_fmt_who(:r => r, :a => a))
     
     r
   end
-  #=end
 
-  #=begin
   def normalise_pathandname_hier_from_lib(*names) # from as in after
-    r =  normalise_pathandname_hier_split_at(*names) {|v| v.downcase == 'lib' }
+    r =  normalise_pathandname_hier_split_at(*names) {|a| a.rindex {|v| v.downcase == 'lib' }}
     q = case
         when r.size == 1 then r.first # no match; use all
         else
           r[1] # the after
         end
-    potrubi_bootstrap_logger_ca(:nrm_pan_h_from_lib, potrubi_bootstrap_logger_fmt_who(:q => q, :r => r, :names => names))
+    potrubi_bootstrap_logger_ca(:nrm_pan_h_from_lib, potrubi_bootstrap_logger_fmt_who(:q => q, :r => r, :a => names))
     q
   end
-  #=end
   
-  #=begin
   def normalise_pathandname_names_elements(*names)
     versionSuffixRegexp = Regexp.new('(.+)_v\d+.*\Z')
     r = names.flatten.compact.map {|n| m = n.to_s; (mD = m.to_s.match(versionSuffixRegexp)) ? mD[1] : m}.map {|n| p = n.split('_'); p.map {|q| q[0] = q.chr.upcase; q}.join }
     potrubi_bootstrap_logger_ca(:nrm_pan_ns_eles, potrubi_bootstrap_logger_fmt_who(:r => r, :names => names))
     r
   end
-  #=end
 
-  #=begin
   def normalise_pathandname_paths_or_croak(*paths, &block)
     eye = :nrm_pan_ps
     pathNorm = begin
                  pathNomn = paths.flatten.compact.join('/').gsub('\\', '/').gsub('::', '/').gsub('//', '/')
-                 #pathFull = (pathNomn =~ /\A\./) ? ::File.expand_path(pathNomn) : pathNomn
                  File.expand_path(pathNomn)
                end
     
@@ -134,9 +113,7 @@ mixinContent = Module.new do
     pathNorm
   end
   alias_method :normalise_pathandname_path_or_croak, :normalise_pathandname_paths_or_croak
-  #=end
   
-  #=begin
   def normalise_pathandname_names_to_hier_or_croak(*names, &block)
     eye = :nrm_pan_ns_2_h
     
@@ -155,9 +132,7 @@ mixinContent = Module.new do
     
   end
   alias_method :normalise_pathandname_name_to_hier_or_croak, :normalise_pathandname_names_to_hier_or_croak
-  #=end
 
-  #=begin
   def normalise_pathandname_paths_to_hier_or_croak(*paths, &block)
     eye = :nrm_pan_ps_2_h
     
@@ -174,12 +149,10 @@ mixinContent = Module.new do
     
   end
   alias_method :normalise_pathandname_path_to_hier_or_croak, :normalise_pathandname_paths_to_hier_or_croak
-  #=end
 
   # Derivative Methods
   # ##################
   
-  #=begin
   def normalise_pathandname_names_or_croak(*names, &block)
     eye = :nrm_pan_ns
     nameNorm = normalise_pathandname_names_to_hier_or_croak(*names, &block).join('::')
@@ -187,9 +160,7 @@ mixinContent = Module.new do
     nameNorm
   end
   alias_method :normalise_pathandname_name_or_croak, :normalise_pathandname_names_or_croak
-  #=end
   
-  #=begin
   def find_pathandname_names_hier_from_lib_or_croak(*names, &block)
     eye = :f_pan_ns_hier_fr_lib
     
@@ -208,7 +179,6 @@ mixinContent = Module.new do
     potrubi_bootstrap_mustbe_array_or_croak(libHier)
 
   end
-  #=end
   
 end
 

data/lib/potrubi/mixin/persistence.rb

@@ -13,11 +13,44 @@ require 'yaml'
 mixinContent = Module.new do
 
   include Potrubi::Mixin::Filesys
+
+  def write_ruby_script_or_croak(rubyArgs)
+    eye = :w_ruby
+    mustbe_hash_or_croak(rubyArgs, eye)
+
+    mustbe_subset_or_croak(rubyArgs.keys, [:ruby, :path, :permissions, :text], eye, "unexpected keys")
+
+    scriptPath = mustbe_string_key_or_croak(rubyArgs, :path, eye)
+    scriptPermissions = mustbe_fixnum_key_or_nil_or_croak(rubyArgs, :permissions, eye)
+    
+    rubyTextNom = mustbe_not_nil_or_croak(rubyArgs[:text], eye)
+
+    # may not want the header line
+    
+    rubyPath =  rubyArgs.has_key?(:ruby) ? resolve_ruby_exe_path_or_croak(rubyArgs) : nil
+    
+    rubyTextNrm = [rubyPath && "#!#{rubyPath}\n", rubyTextNom].flatten.compact.join
+
+    File.open(scriptPath, 'w', scriptPermissions) {|f| f.puts(rubyTextNrm) }
+
+    self
+    
+  end
   
-  def write_yaml_file_or_croak(yamlPath, yamlData)
+    
+  def write_yaml_file_or_croak(yamlPath, yamlData, yamlOpts=nil)
     eye = :w_yaml
+    
+    yamlPermissions = nil
+    yamlOpts && begin
+                  mustbe_hash_or_croak(yamlOpts, eye)
+                  mustbe_subset_or_croak(yamlOpts.keys, [:permissions], eye)
+                  yamlPermissions = yamlOpts[:permissions]
+                end
+
+    yamlPermissions = yamlOpts[:permissions]
     File.directory?(yamlPath) || create_path_directory_or_croak(yamlPath)
-    File.open(yamlPath, 'w') {|yamlHndl|  YAML.dump(yamlData, yamlHndl) }
+    File.open(yamlPath, 'w', yamlPermissions) {|yamlHndl|  YAML.dump(yamlData, yamlHndl) }
     self
   end
 
@@ -49,8 +82,6 @@ mixinContent = Module.new do
                  missing_exception(rubyPath, eye, 'rubyPath not found / not a file')
                end
 
-    ###puts("RUBY TETX >#{rubyText.class}< >#{rubyText}<")
-
     rubyData = instance_eval(rubyText)
     
     r = Kernel.block_given? ? rubyBlok.call(rubyData) : rubyData
@@ -61,10 +92,49 @@ mixinContent = Module.new do
   end
   
   # generalises configuration sources
+  # #################################
+  
+  # Recirsives resolves the config sources
+  # Takes hash:  source name and value pairs
+  # If value is a config source, and returns a hash, recursivesly resolves any config source values in it
+  # If value is a array, maps any configur sources
+  
+  def read_recursive_configuration_sources_or_croak(srceArgs, &srceBlok)
+    eye = :r_rcv_cfg_srces
+
+    $DEBUG && logger_me(eye, logger_fmt_kls(srceArgs: srceArgs), logger_fmt_kls(srceBlok: srceBlok))
+
+    srceData = potrubi_util_map_hash_v(srceArgs) do | srceName, srceValue |
+
+      r = read_configuration_source_or_croak(srceValue, &srceBlok)
+
+      case r
+      when Hash then read_recursive_configuration_sources_or_croak(r, &srceBlok)
+      when Array then read_recursive_configuration_sources_list_or_croak(*r, &srceBlok)
+      else
+        r
+      end
+      
+      ###r.is_a?(Hash) ? read_recursive_configuration_sources_or_croak(r, &srceBlok) : r
+      
+    end
+    
+    $DEBUG && logger_mx(eye, logger_fmt_kls(srceData: srceData))
+    
+    mustbe_hash_or_croak(srceData, eye, "srceData not hash")
+    
+  end
+
+  # Tolerate non-sources
 
+  def read_recursive_maybe_configuration_sources_or_croak(srceArgs)
+    read_recursive_configuration_sources_or_croak(srceArgs) {|v| v}
+  end
+  
   # Read configuration sources
-  # Take hard line and raise exception if not a source
-  # Unless blok is given and retruns reuslt of block
+  # Takes hash: source name and value pairs
+  # Take hard line and raise exception if value not a source
+  # Unless block is given and returns result of block
   
   def read_configuration_sources_or_croak(srceArgs, &srceBlok)
     eye = :r_cfg_srces
@@ -116,6 +186,8 @@ mixinContent = Module.new do
     srceData
   end
 
+  # same semantics as for hash sources
+  
   def read_maybe_configuration_sources_list_or_croak(*srceArgs)
     read_configuration_sources_list_or_croak(*srceArgs) {|v| v}
   end
@@ -134,6 +206,40 @@ mixinContent = Module.new do
     mustbe_array_or_croak(srceData, eye, "srceData not array")
 
   end
+
+  def read_recursive_configuration_sources_list_or_croak(*srceArgs, &srceBlok)
+    eye = 'r_rcv_cfg_srcs_lst'
+
+    # srceBlok is used on hash merges for duplicate keys
+    
+    $DEBUG && logger_me(eye, logger_fmt_kls(srceArgs: srceArgs, srceBlok: srceBlok))
+
+    srceData = srceArgs.map do | srceArg |
+
+      r = read_configuration_source_or_croak(srceArg, &srceBlok)
+
+      case r
+      when Hash then read_recursive_configuration_sources_or_croak(r, &srceBlok)
+      when Array then read_recursive_configuration_sources_list_or_croak(*r, &srceBlok)
+      else
+        r
+      end
+
+    end
+
+    $DEBUG && logger_mx(eye, logger_fmt_kls(srceData: srceData, srceBlok: srceBlok))
+
+    mustbe_array_or_croak(srceData, eye, "srceData not array")
+
+  end
+
+  def read_recursive_maybe_configuration_sources_list_or_croak(*srceArgs)
+    read_recursive_configuration_sources_list_or_croak(*srceArgs) {|v| v}
+  end
+
+    
+  # is_value predicates
+  # ##################
   
   def is_value_configuration_source?(srceArgs)
     eye = :'is_val_cfg_src?'
@@ -178,15 +284,14 @@ mixinContent = Module.new do
                     nil
                   end
 
-    r = Kernel.block_given? ? rubyBlok.call(rubyPathNrm) : rubyPathNrm
+    rubyPathMap = Kernel.block_given? ? rubyBlok.call(rubyPathNrm) : rubyPathNrm
     
-    $DEBUG && logger_ca(eye, logger_fmt_kls(rubyPath: rubyPathNrm, rubyPathNom: r))
+    $DEBUG && logger_ca(eye, logger_fmt_kls(rubyPathMap: rubyPathMap, rubyPathNrm: rubyPathNrm, rubyPathNom: rubyPathNom))
     
-    r
+    rubyPathMap
   end
 end
 
 mixinConstant = Potrubi::Core.assign_mixin_constant_or_croak(mixinContent, :Potrubi, :Mixin, :Persistence)
 
 __END__
-