potrubi 0.0.1 → 0.0.2

data/lib/potrubi/mixin/logger.rb

@@ -0,0 +1,178 @@
+
+# Common Mixins
+
+# logger methods 
+
+require "logger"
+
+module Potrubi
+  module Mixin
+    module Logger
+
+      def logger
+        Logger.logger
+      end
+
+      def self.logger(logrArgs=nil)
+        @logger ||= new_logger(logrArgs)
+      end
+      
+      def self.logger(logrArgs=nil)
+        
+        logrArgs && (logrArgs.is_a?(Hash) || raise(ArgumentError,"logrArgs >#{logrArgs}< not hash",caller))
+        ###log = Log4r.new(STDOUT)
+
+        logrArgsDef = {device: STDOUT, level: ::Logger::DEBUG, datetime_format: "%H:%M:%S"}
+        
+        logrArgsUse = logrArgs ? logrArgsDef.merge(logrArgs) : logrArgsDef
+
+        logr = ::Logger.new(logrArgsUse[:device])
+
+        logrArgsUse.delete(:device)
+
+        logrArgsUse.each {|k,v| logr.__send__("#{k}=", v) }
+        
+        logr
+        
+      end
+      
+      #=begin
+      def logger_enabled?(logrLevel=nil)
+        case logrLevel
+        when Fixnum
+          (@logger_level ||= nil) && @logger_level.is_a?(Fixnum) && (logrLevel <= @logger_level) && logrLevel
+        else
+          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
+
+      def logger_method_exit(logEye, *a)
+        logger_message(logEye, '<==', *a)
+      end
+
+      def logger_method_call(logEye, *a)
+        logger_message(logEye, '<=>', *a)
+      end        
+      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?
+
+      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}<"}
+      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_fmt1(logrArgs)
+        logrArgs.is_a?(Hash) || raise(ArgumentError,"logrArgs >#{logrArgs}< not hash",caller)
+        logrArgs.inject([]) {|s, (k,v)| s << "#{k} >#{v.whoami?}< >#{v}<"}
+      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
+      def logger_debug(*a, &b)
+        logger_generic(:debug, *a, &b)
+      end
+      def logger_warn(*a, &b)
+        logger_generic(:warn, *a, &b)
+      end
+      def logger_error(*a, &b)
+        logger_generic(:error, *a, &b)
+      end
+      def logger_fatal(*a, &b)
+        logger_generic(:fatal, *a, &b)
+      end
+      def logger_unknown(*a, &b)
+        logger_generic(:unknown, *a, &b)
+      end
+
+      def logger_generic(logType, logEye, *logArgs, &logBlok)
+        $DEBUG && begin
+                    logTypeCheck = [logType] - [:warn, :debug, :info, :error, :fatal, :unknown]
+
+                    logTypeCheck.empty? || raise_exception(ArgumentError, "log type >#{logType}< unknown")
+
+                    #logger.__send__(logType, *logArgs, &logBlok)
+                    logger.__send__(logType, *logEye) { logger_fmt(*logArgs) }
+                  end
+        
+
+      end
+    end
+  end
+end
+
+
+__END__
+
+IGR::Mixin::Logger.instance_methods.each {|m| puts("Lgr Inst Mth >#{m}<")}
+

data/lib/potrubi/mixin/pathandnames.rb

@@ -0,0 +1,226 @@
+
+# potrubi paths and names methods
+
+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
+
+    logrArgs = potrubi_bootstrap_logger_fmt_who(:spec => transformSpec, :data => transformData)
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, logrArgs)
+
+    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)
+      when Symbol then __send__(transformCode, s)
+      when Array then
+        case
+        when transformCode.last.is_a?(Proc) then
+          transformArgs = transformCode[0, transformCode.size - 1]
+          $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_ms(eye,"PROC ON METHOD", potrubi_bootstrap_logger_fmt_who(:transformArgs => transformArgs))
+          s.__send__(*transformArgs, &(transformCode.last))
+        else
+          s.__send__(*transformCode)
+        end
+      else
+        potrubi_bootstrap_surprise_exception(transformCode, eye, "transformCode is what?")
+      end
+    end
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, potrubi_bootstrap_logger_fmt_who(:result => transformResult), logrArgs)
+
+    transformResult
+    
+  end
+  #=end
+
+
+  # Core Methods
+  # ############
+
+  #=begin
+  def normalise_pathandname_names_syntax_or_croak(*names, &block)
+    eye = :nrm_pan_ns_syn
+    
+    nameNorm = names.flatten.compact.join('::').gsub('\\','::').gsub('/','::').gsub(':::', '::').sub(/(\.\w*)?\Z/,'')
+    
+    potrubi_bootstrap_logger_ca(eye, potrubi_bootstrap_logger_fmt_who(:name => nameNorm, :names => names))
+
+    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)
+
+    r = case i
+        when NilClass then [a] # not found: all are "before"
+        when Fixnum then
+          [a[0, i], a[i+1, a.size - i - 1], a[i], i] # before, after, match value and index
+        else
+          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))
+    
+    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' }
+    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))
+    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
+    
+    potrubi_bootstrap_logger_ca(eye, potrubi_bootstrap_logger_fmt_who(:pathNorm => pathNorm, :paths => paths))
+    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
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, potrubi_bootstrap_logger_fmt_who(:names => names))
+
+    nameHier = transform_pathandname_or_croak([:normalise_pathandname_names_syntax_or_croak,
+                                               [:split, '::'],
+                                               :normalise_pathandname_hier_from_lib,
+                                               :normalise_pathandname_names_elements,
+                                               Kernel.block_given? ? [:map, block] : nil,
+                                              ], *names)
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, potrubi_bootstrap_logger_fmt_who(:hier => nameHier, :names => names))
+    
+    potrubi_bootstrap_mustbe_array_or_croak(nameHier, eye)
+    
+  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
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, "paths >#{paths}<")
+
+    pathHier = transform_pathandname_or_croak([:normalise_pathandname_paths_or_croak,
+                                               [:split, '/'],
+                                               Kernel.block_given? ? [:map, block] : nil,
+                                              ], *paths)
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, "pathhier >#{pathHier.whoami?}< >#{pathHier}< paths >#{paths}<")
+    
+    potrubi_bootstrap_mustbe_array_or_croak(pathHier, eye)
+    
+  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('::')
+    potrubi_bootstrap_logger_ca(eye, potrubi_bootstrap_logger_fmt_who(:name => nameNorm, :names => names))
+    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
+    
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_me(eye, potrubi_bootstrap_logger_fmt_who(:names => names))
+    
+    nameHier = normalise_pathandname_names_to_hier_or_croak(*names)
+    
+    libHierNom = nameHier.reverse.drop_while {|v| (v.downcase != 'Lib') }.reverse
+    
+    libHierNom.shift  # the lib
+
+    libHierMap = Kernel.block_given? ? libHierNom.map {|m| block.call(m)} : libHierNom     
+
+    $DEBUG_POTRUBI_BOOTSTRAP && potrubi_bootstrap_logger_mx(eye, potrubi_bootstrap_logger_fmt_who(:libHierMap => libHierMap, :libHierNom => libHierNom, :name_hier => nameHier, :names => names))
+    
+    potrubi_bootstrap_mustbe_array_or_croak(libHier)
+
+  end
+  #=end
+  
+end
+
+module Potrubi
+  module Mixin
+    module PathAndNames
+    end
+  end
+end
+
+Potrubi::Mixin::PathAndNames.__send__(:include, mixinContent)  # Instance Methods
+
+
+__END__
+

data/lib/potrubi/mixin/persistence.rb

@@ -0,0 +1,192 @@
+
+# potrubi mixin persistence
+
+# various file, etc methods
+
+require_relative '../core'
+
+requireList = %w(util filesys)
+requireList.each {|r| require_relative "#{r}"}
+
+require 'yaml'
+
+mixinContent = Module.new do
+
+  include Potrubi::Mixin::Filesys
+  
+  def write_yaml_file_or_croak(yamlPath, yamlData)
+    eye = :w_yaml
+    File.directory?(yamlPath) || create_path_directory_or_croak(yamlPath)
+    File.open(yamlPath, 'w') {|yamlHndl|  YAML.dump(yamlData, yamlHndl) }
+    self
+  end
+
+  def read_yaml_file_or_croak(yamlPath, &yamlBlok)
+    eye = :r_yaml
+    
+    yamlData = case
+               when (p = is_value_yaml_path?(yamlPath)) then YAML.load(File.read(p))
+               else
+                 missing_exception(yamlPath, eye, 'yamlPath not found / not a file')
+               end
+    
+    r = Kernel.block_given? ? yamlBlok.call(yamlData) : yamlData
+    
+    $DEBUG && logger_ca(eye, logger_fmt_kls(:yamlPath => yamlPath), logger_fmt_kls_only(:yamlData => r))
+    
+    r
+  end
+
+  # 'reading' a ruby configuration sources mean instance_eval-ing the
+  # code and returning the final value
+  
+  def read_ruby_configuration_source_or_croak(rubyPath, &rubyBlok)
+    eye = :r_ruby
+    
+    rubyText = case
+               when (p = is_value_ruby_configuration_source?(rubyPath)) then File.open(p).readlines.join("\n")
+               else
+                 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
+    
+    $DEBUG && logger_ca(eye, logger_fmt_kls(:rubyPath => rubyPath), logger_fmt_kls(:rubyData => r))
+
+    r
+  end
+  
+  # generalises configuration sources
+
+  # Read configuration sources
+  # Take hard line and raise exception if not a source
+  # Unless blok is given and retruns reuslt of block
+  
+  def read_configuration_sources_or_croak(srceArgs, &srceBlok)
+    eye = :r_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 |
+      ##is_value_configuration_source?(srceValue) ? read_configuration_source_or_croak(srceValue) : (Kernel.block_given? ? srceBlok.call(srceName, srceValue) : potrubi_bootstrap_surprise_exception(srceValue, eye, "srceName >#{srceName}< srceValue not a configuration source"))
+      read_configuration_source_or_croak(srceValue, &srceBlok)
+    end
+    
+    $DEBUG && logger_mx(eye, logger_fmt_kls(srceData: srceData))
+    
+    mustbe_hash_or_croak(srceData, eye, "srceData not hash")
+    
+  end
+  alias_method :read_configuration_files_or_croak, :read_configuration_sources_or_croak
+
+  # Tolerate non-sources
+  
+  def read_maybe_configuration_sources_or_croak(srceArgs)
+    read_configuration_sources_or_croak(srceArgs) {|v| v}
+  end
+  
+  # Read the actual source
+  
+  def read_configuration_source_or_croak(srceSpec, &srceBlok)
+    eye = :'r_cfg_src'
+
+    $DEBUG && logger_me(eye, logger_fmt_kls(srceSpec: srceSpec), logger_fmt_kls(srceBlok: srceBlok))
+
+    srceType = is_value_configuration_source?(srceSpec)
+
+    srceData = case srceType
+               when Symbol
+                 case srceType
+                 when :HASH then srceSpec # nothing to do
+                 when :YAML then read_yaml_file_or_croak(srceSpec)
+                 when :RUBY then read_ruby_configuration_source_or_croak(srceSpec)
+                 else
+                   surprise_exception(srceType, eye, "srceType not a known symbol")
+                 end
+               else
+                 Kernel.block_given? ? srceBlok.call(srceSpec) : potrubi_bootstrap_surprise_exception(srceSpec, eye, "srceSpec not a configuration source")
+               end
+
+    $DEBUG && logger_mx(eye, logger_fmt_kls_only(srceType: srceType),  logger_fmt_kls(srceBlok: srceBlok), logger_fmt_kls_only(srceData: srceData))    
+
+    srceData
+  end
+
+  def read_maybe_configuration_sources_list_or_croak(*srceArgs)
+    read_configuration_sources_list_or_croak(*srceArgs) {|v| v}
+  end
+  
+  def read_configuration_sources_list_or_croak(*srceArgs, &srceBlok)
+    eye = 'r_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 { | srceArg | read_configuration_source_or_croak(srceArg, &srceBlok)}
+
+    $DEBUG && logger_mx(eye, logger_fmt_kls(srceData: srceData, srceBlok: srceBlok))
+
+    mustbe_array_or_croak(srceData, eye, "srceData not array")
+
+  end
+  
+  def is_value_configuration_source?(srceArgs)
+    eye = :'is_val_cfg_src?'
+    srceType = case
+               when srceArgs.is_a?(Hash) then :HASH 
+               when (r = is_value_yaml_path?(srceArgs)) then :YAML
+               when (r = is_value_ruby_configuration_source?(srceArgs)) then :RUBY
+               else
+                 nil
+               end
+    $DEBUG && logger_ca(eye, logger_fmt_kls(srceType: srceType), logger_fmt_kls(srceArgs: srceArgs), )
+    srceType
+  end
+  
+  # specific source type tests  (TODO: xml?)
+  
+  def is_value_yaml_path?(yamlPathNom, &yamlBlok)
+    eye = :is_yaml_path?
+
+    yamlPathNrm = case
+                    #when is_value_file?(yamlPathNom) then yamlPathNom
+                  when is_value_file?(yamlPathNom) && ((File.extname(yamlPathNom) == '.yaml') || (File.extname(yamlPathNom) == '.yml')) then yamlPathNom
+                  when is_value_file?(r = "#{yamlPathNom}.yml") then r
+                  when is_value_file?(r = "#{yamlPathNom}.yaml") then r
+                  else
+                    nil
+                  end
+
+    r = Kernel.block_given? ? yamlBlok.call(yamlPathNrm) : yamlPathNrm
+    
+    $DEBUG && logger_ca(eye, logger_fmt_kls(yamlPath: yamlPathNrm, yamlPathNom: r))
+    
+    r
+  end
+
+  def is_value_ruby_configuration_source?(rubyPathNom, &rubyBlok)
+    eye = :is_ruby_path?
+
+    rubyPathNrm = case
+                  when (is_value_file?(rubyPathNom) && (File.extname(rubyPathNom) == '.rb'))  then rubyPathNom
+                  else
+                    nil
+                  end
+
+    r = Kernel.block_given? ? rubyBlok.call(rubyPathNrm) : rubyPathNrm
+    
+    $DEBUG && logger_ca(eye, logger_fmt_kls(rubyPath: rubyPathNrm, rubyPathNom: r))
+    
+    r
+  end
+end
+
+mixinConstant = Potrubi::Core.assign_mixin_constant_or_croak(mixinContent, :Potrubi, :Mixin, :Persistence)
+
+__END__
+