potrubi 0.0.1 → 0.0.2

data/README.md

@@ -0,0 +1,9 @@
+# potrubi #
+
+*Plumbing for Ruby*
+
+A collection of mixins for common Ruby programming needs
+
+Regreatably the only documenation at this stage is the auto-generated gem pages.
+
+*potrubi* is the Czech word for plumbing

data/lib/potrubi.rb

@@ -0,0 +1,9 @@
+
+# Potrubi
+
+gemName = 'potrubi'
+
+requireList = %w(bootstrap)
+requireList.each {|r| require_relative "#{gemName}/#{r}"}
+
+__END__

data/lib/potrubi/bootstrap.rb

@@ -0,0 +1,27 @@
+
+# Potrubi Bootstrap Mixin
+
+requireList = %w(logger bootstrap_common)
+requireList.each {|r| require_relative "mixin/#{r}"}
+
+mixinContent = Module.new do
+
+  # Include the mixins becuase of class method usage
+  
+  includeList = [Potrubi::Mixin::Logger,
+                 Potrubi::Mixin::BootstrapCommon,
+                ]
+  includeList.each {|n| include n}
+
+end
+
+module Potrubi
+  module Bootstrap
+  end
+end
+
+Potrubi::Bootstrap.__send__(:include, mixinContent)  # Instance Methods
+Potrubi::Bootstrap.extend(mixinContent)              # Class Methods
+
+__END__
+

data/lib/potrubi/core.rb

@@ -0,0 +1,33 @@
+
+# Core Mixin
+
+require_relative 'bootstrap'
+
+requireList = %w(dynamic text-snippets exception contract konstant pathandnames)
+requireList.each {|r| require_relative "mixin/#{r}"}
+
+mixinContent = Module.new do
+
+  # Include the mixins becuase of class method usage
+  
+  includeList = [Potrubi::Bootstrap,
+                 Potrubi::Mixin::Dynamic,
+                 Potrubi::Mixin::Exception,
+                 Potrubi::Mixin::Contract,
+                 Potrubi::Mixin::Konstant,
+                 Potrubi::Mixin::PathAndNames,
+                ]
+  includeList.each {|n| include n}
+
+end
+
+module Potrubi
+  module Core
+  end
+end
+
+Potrubi::Core.__send__(:include, mixinContent)  # Instance Methods
+Potrubi::Core.extend(mixinContent)              # Module Methods
+
+__END__
+

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

@@ -0,0 +1,197 @@
+
+# potrubi klass
+
+# syntax braket
+
+defined?($DEBUG_POTRUBI_KLASS_SYNTAX_BRAKET) ||
+  begin
+    $DEBUG_POTRUBI_KLASS_SYNTAX_BRAKET ||= nil
+  end
+
+require "potrubi/core"
+require 'potrubi/mixin/dynamic-recipes'
+
+klassContent = Class.new do
+
+  include Potrubi::Core
+  ###include Potrubi::Mixin::DynamicRecipes
+  
+  # Class Methods
+  # #############
+  
+  def self.new_method
+    new(:pos_text => "\n")
+  end
+
+  def self.new_stanza
+    new(:pos_text => "\n")
+  end
+  
+  def self.new_statement
+    #self.new(nil, nil)
+    new
+  end
+  
+  attr_accessor :pre_text, :pos_text
+
+  def initialize(initArgs=nil)
+    initArgs && mustbe_hash_or_croak(initArgs, :'braket i').each {|k,v| self.__send__("#{k}=", v)}
+  end
+  
+  def to_s
+    eye = :'bkt to_s'
+    preText = pre_text 
+    posText = pos_text
+
+    fullText = [ 
+                defined?(@head) && head_text(preText, posText), 
+                defined?(@midl) && midl_text(preText, posText), 
+                defined?(@tail) && tail_text(preText, posText), 
+               ].flatten.compact.join
+
+    $DEBUG_POTRUBI_KLASS_SYNTAX_BRAKET && logger_ca(eye, "self >#{self.object_id}< fulText >#{fullText.class}< >\n#{fullText}\n< ")
+    
+    fullText
+    
+  end
+
+  
+  def to_s_with_edits(editList=nil)
+    eye = :to_s_w_edt
+    fulText = to_s
+    edtText = case editList
+              when NilClass then fulText
+              when Hash, Array then  Potrubi::Core.dynamic_apply_edits(editList, fullText)
+              else
+                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<")
+    edtText
+  end
+  
+
+
+  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}<")
+      METHOD_NAMEText
+    end'
+
+
+  baseMethodText =
+    'def push_METHOD_NAME(*args)
+       (@METHOD_NAME ||= []).push(*ARGS_SPEC)
+       self
+     end
+     alias_method :tail_METHOD_NAME, :push_METHOD_NAME
+     def unshift_METHOD_NAME(*args)
+       (@METHOD_NAME ||= []).unshift(*ARGS_SPEC)
+       self
+     end
+     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}<")
+       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}<")
+       r
+     end'
+
+  defTextList = [textMethodText, baseMethodText]
+  ###puts("TEXT TEST TEXT >#{defTextList}<")
+
+  braketMethods = {
+    :tail => defTextList,
+    :head => defTextList,
+    :midl => defTextList,
+  }
+
+  Potrubi::Core.dynamic_define_methods(self, braketMethods) do |k, v|
+    edits = {
+     ARGS_SPEC: 'args.flatten(1)',
+     METHOD_NAME: k,
+    }
+    case v
+    when Hash then v.merge({edit: [edits, v[:edit]]})
+    else
+      {edit: edits, spec: v || defTextList}
+    end
+  end
+
+  aliasMethods = {
+    :push     => :push_midl,
+    :pop      => :pop_midl,
+    :shift    => :shift_midl,
+    :unshift  => :unshift_midl,
+    :cons     => :cons_midl,
+    :tail     => :tail_midl,
+  }
+
+  #Potrubi::Core.dynamic_define_methods_aliases(self, aliasMethods)
+  Potrubi::Mixin::DynamicRecipes.recipe_aliases(self, aliasMethods)
+
+
+# Diagnostics
+# ###########
+
+  def raw_debug(levelText=nil)
+    eye = :'braket r_dbg'
+
+    $DEBUG_POTRUBI_KLASS_SYNTAX_BRAKET &&
+      begin
+        levelString = case levelText
+                      when NilClass then 'BRAKET'
+                      when String, Symbol then "#{levelText}"
+                      else
+                        unsupported_exception(levelText, eye)
+                      end
+
+        braketAddress = "%x" % (object_id.abs*2)
+        
+        puts "#{levelString} #{braketAddress} ==>"
+        
+        defined?(@head) && raw_content_debug(levelString, "head", @head)
+        defined?(@midl) && raw_content_debug(levelString, "midl", @midl)
+        defined?(@tail) && raw_content_debug(levelString, "tail", @tail)
+        
+        puts "#{levelString} #{braketAddress} <=="
+      end
+    
+    self
+  end
+
+  def raw_content_debug(levelString, contentName, contentData)
+    eye = :'braket r_cnt_dbg'
+    
+    braketAddress = "%x" % (object_id.abs*2)
+    
+    case contentData
+    when NilClass then puts "#{levelString} #{braketAddress} #{contentName.to_s.upcase} IS EMPTY"
+    when Array then
+      selfClass = self.class
+      contentData.each_with_index do | cV, cN |
+        case
+        when cV.is_a?(selfClass) then cV.raw_debug("#{levelString} #{braketAddress}")
+        else
+          puts "#{levelString} #{braketAddress} #{contentName.to_s.upcase} cN #{"%2d" % cN} cV >#{cV.class}< >#{cV}<"
+        end
+      end
+    else
+      surprise_exception(contentData, eye)
+    end
+    
+    self
+    
+  end
+
+end
+
+Potrubi::Core.assign_class_constant_or_croak(klassContent, __FILE__)
+
+__END__
+
+

data/lib/potrubi/mixin/bootstrap_common.rb

@@ -0,0 +1,125 @@
+
+# bootstrap common methods
+
+# This turns on or off logging from boostrap / core methods
+# Normally off (nil/false)
+
+defined?($DEBUG_POTRUBI_BOOTSTRAP) || ($DEBUG_POTRUBI_BOOTSTRAP = nil)
+
+#$DEBUG = true # TESTING
+
+require_relative('logger')
+
+module Potrubi
+  module Mixin
+    module BootstrapCommon
+
+#=begin
+      bootstrapLoggerMethods = {
+        logger: :logger_message,
+        logger_me: :logger_me,
+        logger_mx: :logger_mx,
+        logger_ms: :logger_ms,
+        logger_ca: :logger_ca,
+        logger_fmt_class: :logger_fmt0,
+        logger_fmt_who: :logger_fmt0,
+        logger_fmt_who_only: :logger_fmt00,
+      }
+
+      bootstrapLoggerText = bootstrapLoggerMethods.map do | bootMethod, loggerMethod |
+         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
+      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)
+        tellTale = tellTales.flatten.compact.join(' ')
+        raise(exception,"Potrubi Bootstrap Exception value >#{value.class}< >#{value}< #{tellTale}",caller)
+      end
+
+      def potrubi_bootstrap_surprise_exception(value, *tellTales)
+        potrubi_bootstrap_raise_exception(ArgumentError, value, "value was a surpise", *tellTales)
+      end
+      
+      def potrubi_bootstrap_unsupported_exception(value, *tellTales)
+        potrubi_bootstrap_raise_exception(ArgumentError, value, "value not supported", *tellTales)
+      end
+
+      def potrubi_bootstrap_missing_exception(value, *tellTales)
+        potrubi_bootstrap_raise_exception(ArgumentError, value, "value missing", *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)
+      end
+      
+      def potrubi_bootstrap_mustbe_array_or_croak(testValue, *tellTales)
+        testValue.is_a?(Array) ? testValue : potrubi_bootstrap_raise_exception(ArgumentError, testValue, "value not array", tellTales)
+      end
+
+      def potrubi_bootstrap_mustbe_module_or_croak(testValue, *tellTales)
+        testValue.is_a?(Module) ? testValue : potrubi_bootstrap_raise_exception(ArgumentError, testValue, "value not module", tellTales)
+      end
+
+      def potrubi_bootstrap_mustbe_class_or_croak(testValue, *tellTales)
+        testValue.is_a?(Class) ? testValue : potrubi_bootstrap_raise_exception(ArgumentError, testValue, "value not class", tellTales)
+      end
+
+      def potrubi_bootstrap_mustbe_proc_or_croak(testValue, *tellTales)
+        testValue.is_a?(Proc) ? testValue : potrubi_bootstrap_raise_exception(ArgumentError, testValue, "value not proc", tellTales)
+      end
+      
+      def potrubi_bootstrap_mustbe_string_or_croak(testValue, *tellTales)
+        testValue.is_a?(String) ? testValue : potrubi_bootstrap_raise_exception(ArgumentError, testValue, "value not string", 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)
+      end
+      
+      def potrubi_bootstrap_mustbe_directory_or_croak(testValue, *tellTales)
+        File.directory?(testValue) ? testValue : potrubi_bootstrap_raise_exception(ArgumentError, testValue, "value not directory", tellTales)
+      end
+      
+      def potrubi_bootstrap_mustbe_key_or_croak(testValue, keyName, *tellTales)
+        (testValue.respond_to?(:has_key?) && testValue.has_key?(keyName)) ? testValue[keyName] : potrubi_bootstrap_raise_exception(ArgumentError, keyName, "testValue >#{testValue}< keyName not found", tellTales)
+      end
+
+      def potrubi_bootstrap_mustbe_not_nil_or_croak(testValue, *tellTales)
+        testValue || potrubi_bootstrap_raise_exception(ArgumentError, testValue, "testValue >#{testValue}< failed not nil ", tellTales)
+      end
+
+      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 bootstrap_find_module_constant(*a)
+        bootstrap_find_module_constant_or_croak(*a) rescue nil
+      end
+      
+      def bootstrap_find_module_constant_or_croak(*modNames)
+        #potrubi_bootstrap_mustbe_module_or_croak(modNames.flatten.compact.inject(Object) {|s,m| (s && s.const_defined?(m, false)) ? s.const_get(m) : nil})
+        potrubi_bootstrap_mustbe_module_or_croak(modNames.flatten.compact.join('::').split('::').inject(Object) {|s,m| (s && s.const_defined?(m, false)) ? s.const_get(m) : nil}) 
+      end
+      
+      def bootstrap_find_class_constant(*a)
+        bootstrap_find_class_constant_or_croak(*a) rescue nil
+      end
+      
+      def bootstrap_find_class_constant_or_croak(*a)
+        potrubi_bootstrap_mustbe_class_or_croak(bootstrap_find_module_constant_or_croak(*a))
+      end
+      
+    end
+  end
+end

data/lib/potrubi/mixin/configuration.rb

@@ -0,0 +1,109 @@
+
+# potrubi mixin configuration
+
+# support configuration from YAML and Ruby file
+
+require_relative '../core'
+
+requireList = %w(util persistence)
+requireList.each {|r| require_relative "#{r}"}
+
+###require 'yaml'
+
+mixinContent = Module.new do
+
+  include Potrubi::Mixin::Util
+  include Potrubi::Mixin::Persistence
+  
+  # so common
+  
+  def set_attributes_or_croak(attrArgsNom, &attrBlok)
+    eye = :'s_attrs'
+    mustbe_hash_or_croak(attrArgsNom, eye)
+    attrArgsNrm = Kernel.block_given? ? potrubi_util_apply_proc_to_hash_or_croak(attrArgsNom, &attrBlok) : attrArgsNom
+    attrArgsNrm.each {|k,v| __send__("#{k}=", v) }
+    ###puts("SET ATTRS attrArgs >#{attrArgs}<")
+    self
+  end
+
+  def set_attributes_from_configuration_sources_list_or_croak(*srceArgs, &srceBlok)
+    eye = 's_attr_fr_cfg_srcs_lst'
+
+    $DEBUG && logger_me(eye, logger_fmt_kls(srceArgs: srceArgs, srceBlok: srceBlok))
+
+    srceArgs.each { | srceArg | set_attributes_or_croak(read_configuration_source_or_croak(srceArg, &srceBlok)) }
+      
+    $DEBUG && logger_mx(eye, logger_fmt_kls(srceArgs: srceArgs, srceBlok: srceBlok))
+
+    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
+  
+  def set_attributes_from_configuration_sources_or_croak(srceArgs, &srceBlok)
+    eye = :s_attrs_fr_cfg_srces
+
+    $DEBUG && logger_me(eye, logger_fmt_kls_only(srceArgs: srceArgs), logger_fmt_kls(srceBlok: srceBlok))
+
+    mustbe_hash_or_croak(srceArgs, eye, "srceArgs not hash")
+    
+    srceArgs.each do | srceName, srceValue |
+      case
+      when (p = is_value_configuration_source?(srceValue)) then set_attributes_or_croak(read_configuration_source_or_croak(srceValue))
+      else
+        Kernel.block_given? ? srceBlok.call(srceName, srceValue) : potrubi_bootstrap_surprise_exception(srceValue, eye, "srceName >#{srceName}< srceValue not a configuration source")
+      end
+    end
+
+    $DEBUG && logger_mx(eye, logger_fmt_kls_only(srceArgs: srceArgs), logger_fmt_kls(srceBlok: srceBlok))
+    
+    self
+    
+  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'
+
+    $DEBUG && logger_me(eye, logger_fmt_kls(attrSpec: attrSpec, attrBlok: attrBlok), logger_fmt_kls(attrData: attrData))
+
+    mustbe_hash_or_croak(attrSpec, eye, "attrSpec failed contract")
+    mustbe_hash_or_croak(attrData, eye, "attrData failed contract")
+    
+    attrData.each do | attrName, attrValue |
+
+      #attrProc = mustbe_key_or_nil_or_croak(attrSpec, attrName, eye, "attrName >#{attrName}< not in attrSpec >#{attrSpec}<")
+      attrProc = attrSpec[attrName]
+      
+      $DEBUG && logger_ms(eye, 'WHAT ATTR', logger_fmt_kls(attrName: attrName, attrProc: attrProc), logger_fmt_kls(attrValue: attrValue))
+      
+      case attrProc
+      when NilClass then
+        $DEBUG && logger_ms(eye, 'SEND ATTR', logger_fmt_kls(attrName: attrName, attrProc: attrProc), logger_fmt_kls(attrValue: attrValue))
+        self.__send__("#{attrName}=", attrValue)
+      when Proc then
+        $DEBUG && logger_ms(eye, 'PROC ATTR', logger_fmt_kls(attrName: attrName, attrProc: attrProc), logger_fmt_kls(attrValue: attrValue))
+        instance_exec(attrName, attrValue, &attrProc)        
+      else
+        surprise_exception(attrProc, eye, "attrProc is what?")
+      end
+      
+    end
+
+    $DEBUG && logger_mx(eye, logger_fmt_kls(attrSpec: attrSpec, attrBlok: attrBlok), logger_fmt_kls(attrData: attrData))    
+
+    self
+    
+  end
+  
+end
+
+
+mixinConstant = Potrubi::Core.assign_mixin_constant_or_croak(mixinContent, :Potrubi, :Mixin, :Configuration)
+
+__END__
+