potrubi 0.0.3 → 0.0.4

data/lib/potrubi/mixin/util.rb

@@ -3,51 +3,97 @@
 
 # various useful methods
 
-require_relative '../core'
+# Notes *ONLY* need bootstrap
 
-#requireList = %w(bootstrap)
-#requireList.each {|r| require_relative "#{r}"}
+require_relative '../bootstrap'
 
 mixinContent = Module.new do
+
+  def potrubi_util_merge_arrays_or_croak(*arrays)
+    r = arrays.compact.inject({}) {|s, a| s.concat(potrubi_bootstrap_mustbe_array_or_croak(a)) }
+    r.empty? ? nil : r
+  end
+  alias_method :potrubi_util_merge_arrays, :potrubi_util_merge_arrays_or_croak
+  alias_method :potrubi_util_reduce_arrays, :potrubi_util_merge_arrays_or_croak
   
-  #=begin
-  def potrubi_util_merge_hashes_or_croak(*hashes)
-    r = hashes.flatten.compact.inject({}) {|s, h| s.merge(potrubi_bootstrap_mustbe_hash_or_croak(h))}
+  def potrubi_util_merge_hashes_or_croak(*hashes, &mergeBlok)
+    r = hashes.flatten.compact.inject({}) {|s, h| s.merge(potrubi_bootstrap_mustbe_hash_or_croak(h), &mergeBlok)}
     r.empty? ? nil : r
   end
   alias_method :potrubi_util_merge_hashes, :potrubi_util_merge_hashes_or_croak
-  #=end
+  alias_method :potrubi_util_reduce_hashes_or_croak, :potrubi_util_merge_hashes_or_croak
+  alias_method :potrubi_util_reduce_hashes, :potrubi_util_merge_hashes_or_croak
 
+  def potrubi_util_merge_hashes_concatenate_array_values_or_croak(*hashes)
+    potrubi_util_merge_hashes_or_croak(*hashes) do | k, oldV, newV |
+      case
+      when oldV.is_a?(Array) && newV.is_a?(Array) then [].concat(oldV).concat(newV)
+      else
+        newV
+      end
+    end
+  end
+  
   #  Apply a proc to the hash values and return a new hash with new values
   
-  #=begin
   def potrubi_util_apply_proc_to_hash_or_croak(srceHash, &srceBlok)
-    mustbe_proc_or_croak(srceBlok)
-    mustbe_hash_or_croak(srceHash).each_with_object({}) {|(k,v),h| h[k] = srceBlok.call(k, v) }
+    potrubi_bootstrap_mustbe_proc_or_croak(srceBlok)
+    potrubi_bootstrap_mustbe_hash_or_croak(srceHash).each_with_object({}) {|(k,v),h| h[k] = srceBlok.call(k, v) }
   end
   alias_method :potrubi_util_map_hash_value, :potrubi_util_apply_proc_to_hash_or_croak
   alias_method :potrubi_util_map_hash_v, :potrubi_util_apply_proc_to_hash_or_croak
-  #=end
-  #=begin
+
   def potrubi_util_map_hash_key_and_value_or_croak(srceHash, &srceBlok)
-    mustbe_proc_or_croak(srceBlok)
-    mustbe_hash_or_croak(srceHash).each_with_object({}) {|(k,v),h| r = mustbe_array_or_croak(srceBlok.call(k, v)); h[r[0]] = r[1] }
+    potrubi_bootstrap_mustbe_proc_or_croak(srceBlok)
+    potrubi_bootstrap_mustbe_hash_or_croak(srceHash).each_with_object({}) {|(k,v),h| r = potrubi_bootstrap_mustbe_array_or_croak(srceBlok.call(k, v)); h[r[0]] = r[1] }
   end
   alias_method :potrubi_util_map_hash_kv, :potrubi_util_map_hash_key_and_value_or_croak
-  #=end
 
-  #=begin
+  # find hash keys recursively
+  def potrubi_util_find_hash_keys_or_croak(srceHash, *srceKeys, &srceBlok)
+    potrubi_bootstrap_mustbe_hash_or_croak(srceHash)
+
+    # puts "potrubi_util_find_hash_keys_or_croak srceHash #{srceHash}"
+    # puts "potrubi_util_find_hash_keys_or_croak srceKeys #{srceKeys}"
+    
+    r = srceKeys.flatten.compact.reduce(srceHash) do | s, k |
+      # puts "potrubi_util_find_hash_keys_or_croak k #{k} s #{s}"
+      ###(s.is_a?(Hash) && s.has_key?(k)) ? s[k] : break
+      (s.is_a?(Hash) && s.has_key?(k)) ? s[k] : potrubi_bootstrap_mustbe_key_or_croak(s, k, 'potrubi_util_find_hash_keys_or_croak')
+    end
+    # any blok? - call even if nil (i.e key was found and value was nil)
+    srceBlok ? srceBlok.call(r) : r
+  end
+
+  def potrubi_util_find_hash_keys(srceHash, *srceKeys, &srceBlok)
+    potrubi_util_find_hash_keys_or_croak(srceHash, *srceKeys, &srceBlok) rescue nil
+  end
+  
   def potrubi_util_array_to_hash(aVal, &procBlok)
-    mustbe_array_or_croak(aVal)
+    aVal.is_a?(Array) || aVal.is_a?(Enumerator) || potrubi_bootstrap_mustbe_array_or_croak(aVal)
     case
-    when Kernel.block_given? then aVal.each_with_object({}) {|a, h| r = mustbe_array_or_croak(procBlok.call(a)); h[r[0]] = r[1] }  # k&v from proc
+    when Kernel.block_given? then aVal.each_with_object({}) {|a, h| r = potrubi_bootstrap_mustbe_array_or_croak(procBlok.call(a)); h[r[0]] = r[1] }  # k&v from proc
     else
       aVal.each_with_object({}) {|a, h| h[a] = nil }  # values to nil
     end
   end
-  #=end
+
+  def potrubi_util_setter_or_croak(setTarget, *hashes, &mergeBlok)
+    potrubi_util_merge_hashes_or_croak(*hashes, &mergeBlok).each {|k, v| setTarget.__send__("#{k}=", v) }
+    setTarget
+  end
+  alias_method :potrubi_util_set_attributes_or_croak, :potrubi_util_setter_or_croak
+
+end
+
+module Potrubi
+  module Mixin
+    module Util
+    end
+  end
 end
 
-Potrubi::Core.assign_module_constant_or_croak(mixinContent, :Potrubi, :Mixin, :Util)
+Potrubi::Mixin::Util.__send__(:include, mixinContent)  # Instance Methods
 
 __END__
+

data/lib/potrubi/version.rb

@@ -2,5 +2,5 @@
 # Version for Potrubi
 
 module Potrubi
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/test/potrubi/mixin/bootstrap_common.rb

@@ -0,0 +1,205 @@
+
+# Potrubi Test Bootstrap Common Mixin
+
+require 'minitest/autorun'
+require 'minitest/spec'
+
+require 'potrubi/mixin/logger'
+require 'potrubi/mixin/bootstrap_common'
+
+class TestClass1
+
+  
+  include Potrubi::Mixin::Logger
+  include Potrubi::Mixin::BootstrapCommon
+
+end
+
+describe TestClass1 do
+
+  before do
+    @mixConstant = Potrubi::Mixin::BootstrapCommon
+    @t = TestClass1.new
+    @validClassMethods = [#:logger,
+                          #:new_logger,
+                         ]
+
+    @validLoggerInstanceMethods = [
+                                   :logger,
+                                   :logger_instance_telltale,
+                                   :logger_me,
+                                   :logger_mx,
+                                   :logger_ms,
+                                   :logger_ca,
+                                   :logger_beg,
+                                   :logger_fin,
+                                   :logger_fmt,
+                                   :logger_fmt_kls,
+                                   :logger_fmt_kls_size,
+                                   :logger_fmt_who,
+                                   :logger_fmt_who_only,
+                                   
+                                  ].map {|m| "potrubi_bootstrap_#{m}" }
+
+
+    @validContractInstanceMethods = [:hash,
+                                     :array,
+                                     :fixnum,
+                                     :string,
+                                     :symbol,
+                                     :float,
+                                     :class,
+                                     :module,
+                                     :proc,
+                                     :key,
+                                     :file,
+                                     :directory,
+                                     :not_nil,
+                                     :not_empty,
+                                     :empty
+                                    ].map {|m| "potrubi_bootstrap_mustbe_#{m}_or_croak"}
+
+    @validExceptionInstanceMethods = [:raise,
+                                      :surprise,
+                                      :duplicate,
+                                      :missing,
+                                     ].map {|m| "potrubi_bootstrap_#{m}_exception" }
+
+    @validInstanceMethods = [@validContractInstanceMethods,
+                             @validLoggerInstanceMethods,
+                             @validExceptionInstanceMethods,
+                            ].flatten
+
+    @validContractTests = {
+      hash: {},
+      array: [],
+      string: 'Hi There',
+      symbol: :'A symbol',
+      fixnum: 1,
+      float: 2.3,
+
+      class: Class.new,
+      module: Module.new,
+
+      file: __FILE__,
+      directory: File.dirname(__FILE__),
+      
+      #empty: [],
+      #not_empty: %w(this is not empty),
+      #not_nil: 'definitely is not nil',
+      ###proc: ->(p) {true}, # can't test proc for some reason - confuses Minitest?
+    }
+
+    @invalidContractTests = {
+      hash: {},
+      array: [],
+      string: 'Hi There',
+      symbol: :'A symbol',
+      fixnum: 1,
+      float: 2.3,
+
+      #class: Class.new,
+      module: Module.new,
+
+      #file: __FILE__,
+      #directory: File.dirname(__FILE__),
+      
+ 
+      ###proc: ->(p) {true}, # can't test proc for some reason - confuses Minitest?
+    }
+
+    @validContractSpecialTests = {
+      empty: [],
+      not_empty: %w(this is not empty),
+      not_nil: 'definitely is not nil',
+    }
+  end
+
+  describe 'mixin reponds to only module methods' do
+
+    it 'has valid module methods' do
+      @validClassMethods.each { | methodName | @mixConstant.must_respond_to methodName }
+    end
+
+    it 'mixin doesnt repond to instance methods' do
+      @validInstanceMethods.each { | methodName | @mixConstant.wont_respond_to methodName }
+    end
+
+    
+  end
+
+  describe 'class reponds to instance methods' do
+    
+    it 'has valid instance methods' do
+      @validInstanceMethods.each { | methodName | @t.must_respond_to methodName }
+    end
+
+  end
+
+  describe 'does contracts' do
+
+    it 'valid one value contracts' do
+
+      validContracts = @validContractTests
+
+
+      validContracts.each do | contractName, contractTest |
+        contractMethod = "potrubi_bootstrap_mustbe_#{contractName}_or_croak"
+        puts("VALID contractName >#{contractName}< contractMethod >#{contractMethod}< contractTest >#{contractTest.class}<")
+        @t.__send__(contractMethod, contractTest).must_equal(contractTest)
+      end
+      
+
+    end
+
+    it 'valid one value speical contracts' do
+
+      validContracts = @validContractSpecialTests
+
+      validContracts.each do | contractName, contractTest |
+        contractMethod = "potrubi_bootstrap_mustbe_#{contractName}_or_croak"
+        puts("VALID SPEICAL contractName >#{contractName}< contractMethod >#{contractMethod}< contractTest >#{contractTest.class}<")
+        @t.__send__(contractMethod, contractTest).must_equal(contractTest)
+      end
+      
+
+    end
+    
+    it 'invalid one value contracts' do
+
+      validContracts =  @validContractTests
+      invalidContracts = @invalidContractTests
+
+      ##invalidContracts = invalidContractsNom.select {|k,v| k != contractName}
+
+      invalidContracts.each do | invalidContractName, invalidContractTest |
+
+        validContractsSel = validContracts.select {|k,v| k != invalidContractName}
+        
+        ###validContracts.has_key?(invalidContractName) || next # invliad only a subset
+        
+        validContractsSel.each do | contractName, contractTest |
+          contractMethod = "potrubi_bootstrap_mustbe_#{contractName}_or_croak"
+          
+          puts("INVALID contractName >#{contractName}< contractMethod >#{contractMethod}< invalidContractTest >#{invalidContractTest.class}< invalidContractName >#{invalidContractName}<")
+          ##@t.__send__(contractMethod, contractTest).must_equal(contractTest)
+          proc do
+            @t.__send__(contractMethod, invalidContractTest)
+          end.must_raise ArgumentError
+          
+        end
+        
+        
+      end
+      
+
+    end
+    
+    
+  end
+  
+end
+
+
+__END__
+

data/test/potrubi/mixin/konstant.rb

@@ -0,0 +1,216 @@
+
+# Potrubi Test Konstant Mixin
+
+require 'minitest'
+require 'minitest/autorun'
+require 'minitest/spec'
+
+require 'potrubi/bootstrap'
+require 'potrubi/mixin/konstant'
+
+class TestClass1
+
+  include Potrubi::Bootstrap
+  
+end
+
+describe TestClass1 do
+
+  before do
+    @mixConstant = Potrubi::Mixin::Konstant
+  end
+
+  describe 'makes modules' do
+
+    it 'valid one value contracts' do
+
+      makeModules = {
+        #[:A] => 'A',
+      }
+
+      makeModules.each do | moduleSpec, moduleWantName |
+
+        puts("MAKE MODULE moduleSpec >#{moduleSpec}< moduleWantName >#{moduleWantName}<")
+        
+        moduleConstant = @mixConstant.create_module_constant_or_croak(moduleSpec)
+        
+        puts("MAKE MODULE moduleSpec >#{moduleSpec}< moduleWantName >#{moduleWantName}< moduleConstant >#{moduleConstant.class}< >#{moduleConstant}< ")
+
+        moduleConstant.must_be_instance_of(Module)
+        
+        moduleFindName = moduleConstant.name
+
+        moduleFindName.must_equal(moduleWantName)
+        
+      end
+      
+    end
+    
+  end
+  
+end
+
+
+__END__
+
+
+   it 'valid one value speical contracts' do
+
+      validContracts = @validContractSpecialTests
+
+      validContracts.each do | contractName, contractTest |
+        contractMethod = "potrubi_bootstrap_mustbe_#{contractName}_or_croak"
+        puts("VALID SPEICAL contractName >#{contractName}< contractMethod >#{contractMethod}< contractTest >#{contractTest.class}<")
+        @t.__send__(contractMethod, contractTest).must_equal(contractTest)
+      end
+      
+
+    end
+    
+    it 'invalid one value contracts' do
+
+      validContracts =  @validContractTests
+      invalidContracts = @invalidContractTests
+
+      ##invalidContracts = invalidContractsNom.select {|k,v| k != contractName}
+
+      invalidContracts.each do | invalidContractName, invalidContractTest |
+
+        validContractsSel = validContracts.select {|k,v| k != invalidContractName}
+        
+        ###validContracts.has_key?(invalidContractName) || next # invliad only a subset
+        
+        validContractsSel.each do | contractName, contractTest |
+          contractMethod = "potrubi_bootstrap_mustbe_#{contractName}_or_croak"
+          
+          puts("INVALID contractName >#{contractName}< contractMethod >#{contractMethod}< invalidContractTest >#{invalidContractTest.class}< invalidContractName >#{invalidContractName}<")
+          ##@t.__send__(contractMethod, contractTest).must_equal(contractTest)
+          proc do
+            @t.__send__(contractMethod, invalidContractTest)
+          end.must_raise ArgumentError
+          
+        end
+        
+        
+      end
+      
+
+    end
+    
+
+  describe 'mixin reponds to only module methods' do
+
+    it 'has valid module methods' do
+      @validClassMethods.each { | methodName | @mixConstant.must_respond_to methodName }
+    end
+
+    it 'mixin doesnt repond to instance methods' do
+      @validInstanceMethods.each { | methodName | @mixConstant.wont_respond_to methodName }
+    end
+
+    
+  end
+
+  describe 'class reponds to instance methods' do
+    
+    it 'has valid instance methods' do
+      @validInstanceMethods.each { | methodName | @t.must_respond_to methodName }
+    end
+
+  end
+
+    @mixConstant = Potrubi::Mixin::BootstrapCommon
+    @t = TestClass1.new
+    @validClassMethods = [#:logger,
+                          #:new_logger,
+                         ]
+
+    @validLoggerInstanceMethods = [
+                                   :logger,
+                                   :logger_instance_telltale,
+                                   :logger_me,
+                                   :logger_mx,
+                                   :logger_ms,
+                                   :logger_ca,
+                                   :logger_beg,
+                                   :logger_fin,
+                                   :logger_fmt,
+                                   :logger_fmt_kls,
+                                   :logger_fmt_kls_size,
+                                   :logger_fmt_who,
+                                   :logger_fmt_who_only,
+                                   
+                                  ].map {|m| "potrubi_bootstrap_#{m}" }
+
+
+    @validContractInstanceMethods = [:hash,
+                                     :array,
+                                     :fixnum,
+                                     :string,
+                                     :symbol,
+                                     :float,
+                                     :class,
+                                     :module,
+                                     :proc,
+                                     :key,
+                                     :file,
+                                     :directory,
+                                     :not_nil,
+                                     :not_empty,
+                                     :empty
+                                    ].map {|m| "potrubi_bootstrap_mustbe_#{m}_or_croak"}
+
+    @validExceptionInstanceMethods = [:raise,
+                                      :surprise,
+                                      :duplicate,
+                                      :missing,
+                                     ].map {|m| "potrubi_bootstrap_#{m}_exception" }
+
+    @validInstanceMethods = [@validContractInstanceMethods,
+                             @validLoggerInstanceMethods,
+                             @validExceptionInstanceMethods,
+                            ].flatten
+
+    @validContractTests = {
+      hash: {},
+      array: [],
+      string: 'Hi There',
+      symbol: :'A symbol',
+      fixnum: 1,
+      float: 2.3,
+
+      class: Class.new,
+      module: Module.new,
+
+      file: __FILE__,
+      directory: File.dirname(__FILE__),
+      
+      #empty: [],
+      #not_empty: %w(this is not empty),
+      #not_nil: 'definitely is not nil',
+      ###proc: ->(p) {true}, # can't test proc for some reason - confuses Minitest?
+    }
+
+    @invalidContractTests = {
+      hash: {},
+      array: [],
+      string: 'Hi There',
+      symbol: :'A symbol',
+      fixnum: 1,
+      float: 2.3,
+
+      #class: Class.new,
+      module: Module.new,
+
+      #file: __FILE__,
+      #directory: File.dirname(__FILE__),
+      
+ 
+      ###proc: ->(p) {true}, # can't test proc for some reason - confuses Minitest?
+    }
+
+    @validContractSpecialTests = {
+      empty: [],
+      not_empty: %w(this is not empty),
+      not_nil: 'definitely is not nil',
+    }