toolrack 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a6d6ade6a80e5efb3499f23135144ee8c0f58b53aa98b453981e74cb279237c
-  data.tar.gz: f665002e707b8c53aa855bedefa8c50a18fa9b4a3162cc987cdd0d000f33bd37
+  metadata.gz: 6e976dbea0f65aaafda38f95d4ae09824a98b3286f92b36b56e8caa2bd1bc342
+  data.tar.gz: 985e060c28df014cdfdf507a78f5601f24918b10e405bd0879e1f6d00355cb3e
 SHA512:
-  metadata.gz: eab1c799dc27d82fb55006baba5943bada9f9234d4e78266f8564638b86286129f5fd3938d42be729a62044411bcb686fc75bc59d127e106a6245d9fb85e11a8
-  data.tar.gz: bf908f5e105b9e096b779de8c1e63d66057e8034c9a7eb996c6a01c1aca7e1e941f5cad68d6dedf329d26b49a6ec45fb121e33d2d452342c511ddc96f35b06bc
+  metadata.gz: 196a38ae3b58129c33713d02579ee2301888a7bec935fd5882c6ad775bdc090fcd80e563f6c072a1913c45127d5ec642fa1cfac99238ad9e44a4d29e59786fc9
+  data.tar.gz: c4d1173f3824c72652096e94834f829cf36740885df519cbf0e4f30393ea19e7dee2895221e31a7ba26a2a6e1de10d27fb5042f147c636b0d9dc4f58ce39e8f0

data/README.md

@@ -1,6 +1,6 @@
 # Toolrack
 
-Toolrack just the collection of utilities that helps in my code clarity
+Toolrack just the collection of utilities that helps in my code clarity and assistance since those utils too small to be a gem on its own.
 
 ## Installation
 
@@ -40,10 +40,21 @@ class EditController
   # enable instance method to access those uitilities
   include ToolRack::ConditionUtils
   include ToolRack::ExceptionUtils
+  include ToolRack::PasswordUtils
+  include ToolRack::RuntimeUtils
+  include ToolRack::DataConversionUtils
+
+  # there is also shortcut since I write it so often
+  include TR::CondUtils
+  include TR::ExpUtils
+  include TR::PassUtils
+  include TR::RTUtils
+  include TR::DataConvUtils
 end
 ```
 
-Currently it has 3 modules:
+Currently it has 5 modules:
+
 * Condition Utilities
   * is\_empty?(obj) - I found that I've type the condition if not (x.nil? and x.empty?) too frequent that I think this is very best to turn this into a function. The empty test shall take the following test in sequence:
     * First test is x.nil?. If it is return true
@@ -77,6 +88,45 @@ Currently it has 3 modules:
   * raise\_if\_false(obj, message, error) - As the name implied
   * raise\_if\_true(obj, message, error) -  As the name implied
 
-
- 
+* Runtime utils - Tired rewriting this in other project. Detect if the running system is on which operating system / runtime. The function is pretty self descriptive
+  * RuntimeUtils.on\_windows?
+  * RuntimeUtils.on\_mac?
+  * RuntimeUtils.on\_linux?
+  * RuntimeUtils.on\_ruby?
+  * RuntimeUtils.on\_jruby?
+
+* Password utils - Generate random password with designated complexity
+  * generate\_random\_password(length, options = { complexity: \<value\>, enforce\_quality: \<true/false\> })
+    * length - length of the required generated password
+    * options[:complexity]:
+      * 1 - lowercase alphabet
+      * 2 - lower + upper case alphabet [alpha]
+      * 3 - lower + upper + number [alpha numeric]
+      * 4 - lower + upper + number + symbol
+    * options[:enforce\_quality]
+      * true - generated password is guaranteed to contain the required complexity. E.g. if complexity 4 is required, the password MUST contain lower, upper, number and symbol as its output or a new password that comply to the complexity shall be regenerated. This process is repeated until the required complexity is achieved
+      * false - The rules of the complexity is relexed. E.g. if complexity 4 is requested, the output might not have symbol in it.
+  * gen\_rand\_pass(length, options = { }) & gen\_pass(length, options = { })
+    * Alias for method generate\_random\_password
+
+  * all\_lowercase\_alpha?(str)
+  * all\_uppercase\_alpha?(str)
+  * all\_alpha?(str)
+  * all\_number?(str)
+  * all\_symbol?(str)
+  * all\_alpha\_numeric?(str)
+  * all\_alpha\_numeric\_and\_symbol?(str)
+    * All methods above starts with all_\* is to check for strict compliance to the required output. E.g. if all\_alpha?(str) is used, the input str MUST be all alpha to get a true status
+
+  * has\_lowercase\_alpha?(str)
+  * has\_uppercase\_alpha?(str)
+  * has\_alpha?(str)
+  * has\_number?(str)
+  * has\_symbol?(str)
+  * has\_alpha\_numeric?(str)
+  * has\_alpha\_numeric\_or\_symbol?(str)
+    * All methods above start with has_\* is just to check if the given str contains the required specification. E.g string 'abcdE' will still get true status if pass to has\_lowercase\_alpha?(str). But value 1234 or '1234' or '$%^&' pass to has\_lowercase\_alpha?(str) shall return false.
+
+
+Check out the rspec folder for usage
 

data/lib/toolrack/password_utils.rb

@@ -5,18 +5,297 @@ module Antrapol
   module ToolRack
     module PasswordUtils
       include Antrapol::ToolRack::ConditionUtils
+      
+      class PasswordUtilsError < StandardError; end
+
+      # complexity
+      # 1 : lowercase alphabet
+      # 2 : lower + upper alphabet
+      # 3 : lower + upper + number
+      # 4 : lower + upper + number + symbol
+      def generate_random_password(length = 12, opts = { complexity: 4, enforce_quality: true })
+       
 
-      def generate_random_password(length = 12)
         length = 12 if is_empty?(length)
         length = length.to_i
         length = 12 if length <= 0
 
-        antropy = ('!'..'~').to_a
-        antropy.sort_by { SecureRandom.random_number }.join[0...length]
+        logger.debug "Length : #{length}"
+
+        if not_empty?(opts)
+          complexity = opts[:complexity] || 4
+          
+          raise PasswordUtilsError, "Password length too short but complexity too high. Not able generate the password with required complexity." if length <= complexity
+          
+          enforce_quality = opts[:enforce_quality] || true
+        end
+
+        complexity = 4 if is_empty?(complexity)
+        complexity = 4 if complexity > 4
+        complexity = 1 if complexity < 1
+
+        logger.debug "Complexity : #{complexity}"
+
+        enforce_quality = true if is_empty?(enforce_quality) or not is_bool?(enforce_quality)
+
+        res = []
+        antropy = [("a".."z"),("A".."Z"),(0..9),("!".."?")]
+        selection = antropy[0..complexity-1].map { |s| s.to_a }.flatten
+
+        fres = nil
+        loop do
+
+          len = length
+          processed = 0
+          loop do
+            #res += selection.sample(length)
+            res += selection.sort_by { SecureRandom.random_number }
+            break if res.length >= length
+          end
+
+          fres = res[0...length].join
+
+          if enforce_quality
+            case complexity
+            when 1
+              if all_lowercase_alpha?(fres)
+                break
+              else
+                logger.debug "Failed lowercase alpha quality check. #{fres} - Regenerating..."
+                res.clear
+              end
+            when 2
+              st, dst = all_alpha?(fres)
+              if st
+                break
+              else
+                logger.debug "Failed all alpha quality check. #{dst} - Regenerating..."
+                res.clear
+              end
+            when 3
+              st, dst = all_alpha_numeric?(fres)
+              if st
+                break
+              else
+                logger.debug "Failed alpha numeric quality check. #{dst} - Regenerating"
+                res.clear
+              end
+            when 4
+              st, dst = all_alpha_numeric_and_symbol?(fres)
+              if st
+                break
+              else
+                logger.debug "Failed alpha numeric + symbol quality check. #{fres} / #{dst} - Regenerating"
+                res.clear
+              end
+            else
+              logger.debug "Unknown complexity?? #{complexity}"
+              break
+            end
+          else
+            break
+          end
+
+        end
+
+        fres
+
+        #length = 12 if is_empty?(length)
+        #length = length.to_i
+        #length = 12 if length <= 0
+
+        #antropy = ('!'..'~').to_a
+        #antropy.sort_by { SecureRandom.random_number }.join[0...length]
       end
       alias_method :gen_rand_pass, :generate_random_password
       alias_method :gen_pass, :generate_random_password
 
+      def all_lowercase_alpha?(str)
+        return false if is_empty?(str) or not str.is_a?(String)
+
+        s = str.split("")
+        lalpha = ('a'..'z').to_a
+      
+        (s.difference(lalpha).length == 0)
+      end
+
+      def has_lowercase_alpha?(str)
+        return false if is_empty?(str) or not str.is_a?(String)
+
+        s = str.split("")
+        lalpha = ('a'..'z').to_a
+      
+        (s & lalpha).length > 0
+      end
+
+      def all_uppercase_alpha?(str)
+        return false if is_empty?(str) or not str.is_a?(String)
+
+        s = str.split("")
+        ualpha = ('A'..'Z').to_a
+
+        s.difference(ualpha).length == 0
+      end
+
+      def has_uppercase_alpha?(str)
+        return false if is_empty?(str) or not str.is_a?(String)
+
+        s = str.split("")
+        ualpha = ('A'..'Z').to_a
+
+        (s & ualpha).length > 0
+      end
+
+      def all_alpha?(str)
+        return false if is_empty?(str) or not str.is_a?(String)
+
+        s = str.split("")
+        lalpha = ('a'..'z').to_a
+        ualpha = ('A'..'Z').to_a
+        num = ('0'..'9').to_a
+        sym = ('!'..'?').to_a
+        
+        alpha = [lalpha, ualpha].flatten
+
+        t1 = (alpha.difference(s).length == 0)
+        t2 = (alpha.difference(s).length == 0)
+
+        t3 = (s & num).length > 0
+        t4 = (s & sym).length > 0
+        
+        [!(t1 or t2 or t3 or t4), res = { has_lower_alpha: t1, has_upper_alpha: t2, has_num: t3, has_symbol: t4 }]
+      end
+
+      def has_alpha?(str)
+        return false if is_empty?(str) or not str.is_a?(String)
+
+        s = str.split("")
+        lalpha = ('a'..'z').to_a
+        ualpha = ('A'..'Z').to_a
+        alpha = [lalpha, ualpha].flatten
+
+        (alpha & s).length > 0
+      end
+
+      def has_number?(str)
+        return false if is_empty?(str)
+
+        str = str.to_s if not str.is_a?(String)
+
+        s = str.split("")
+        num = ('0'..'9').to_a
+
+        (s & num).length > 0
+        
+      end
+
+      def all_number?(str)
+        return false if is_empty?(str)
+
+        str = str.to_s if not str.is_a?(String)
+
+        s = str.split("")
+        num = ('0'..'9').to_a
+
+        !(s.difference(num).length > 0)
+        
+      end
+
+      def all_symbol?(str)
+        return false if is_empty?(str)
+
+        s = str.split("")
+        sym = ('!'..'?').to_a
+        !(s.difference(sym).length > 0)
+        
+      end
+
+      def has_symbol?(str)
+        return false if is_empty?(str)
+
+        s = str.split("")
+        sym = ('!'..'?').to_a
+       
+        p (s & sym)
+        (s & sym).length > 0
+      end
+
+
+      def all_alpha_numeric?(str)
+        return false if is_empty?(str)
+
+        s = str.split("")
+        lalpha = ('a'..'z').to_a
+        ualpha = ('A'..'Z').to_a
+        num = ('0'..'9').to_a
+        sym = ('!'..'?').to_a
+        sym = sym.difference(num)
+
+        t1 = ((s & lalpha).length > 0)
+        t2 = ((s & ualpha).length > 0)
+        t3 = ((s & num).length > 0)
+
+        t4 = ((s & sym).length > 0)
+
+        [(t1 and t2 and t3 and !t4), res = { has_lower_alpha: t1, has_upper_alpha: t2, has_num: t3, has_symbol: t4 }]
+      end
+
+      def has_alpha_numeric?(str)
+        return false if is_empty?(str)
+        
+        s = str.split("")
+        lalpha = ('a'..'z').to_a
+        ualpha = ('A'..'Z').to_a
+        num = ('0'..'9').to_a
+        alphanum = [lalpha, ualpha, num].flatten
+
+        (s & alphanum).length > 0
+        
+      end
+
+      def all_alpha_numeric_and_symbol?(str)
+        return false if is_empty?(str)
+
+        s = str.split("")
+        lalpha = ('a'..'z').to_a
+        ualpha = ('A'..'Z').to_a
+        num = ('0'..'9').to_a
+        sym = ('!'..'?').to_a
+        sym = sym.difference(num)
+
+        t1 = ((s & lalpha).length > 0)
+        t2 = ((s & ualpha).length > 0)
+        t3 = ((s & num).length > 0)
+        t4 = ((s & sym).length > 0)
+
+        [(t1 and t2 and t3 and t4), res = { has_lower_alpha: t1, has_upper_alpha: t2, has_num: t3, has_symbol: t4 }]
+      end
+
+      def has_alpha_numeric_or_symbol?(str)
+        return false if is_empty?(str)
+        
+        s = str.split("")
+        lalpha = ('a'..'z').to_a
+        ualpha = ('A'..'Z').to_a
+        num = ('0'..'9').to_a
+        sym = ('!'..'?').to_a
+        sym = sym.difference(num)
+
+        t1 = ((s & lalpha).length > 0)
+        t2 = ((s & ualpha).length > 0)
+        t3 = ((s & num).length > 0)
+        t4 = ((s & sym).length > 0)
+        
+        [(t1 or t2 or t3 or t4), res = { has_lower_alpha: t1, has_upper_alpha: t2, has_num: t3, has_symbol: t4 }]
+      end
+
+      private
+      def logger
+        logger = Antrapol::ToolRack::Logger.instance.glogger
+        logger.tag = :pass_utils
+        logger
+      end
+
     end
   end
 end

data/lib/toolrack/version.rb

@@ -1,6 +1,6 @@
 module Antrapol
   module ToolRack
-    VERSION = "0.9.0"
+    VERSION = "0.10.0"
   end
 end
 

data/lib/toolrack.rb

@@ -22,8 +22,20 @@ module Antrapol
 end
 
 ToolRack = Antrapol::ToolRack
-ToolRack::DataConv = Antrapol::ToolRack::DataConversionUtils
+TR = ToolRack
+
+ToolRack::DataConvUtils = Antrapol::ToolRack::DataConversionUtils
+TR::DataConvUtils = ToolRack::DataConvUtils
+
 ToolRack::CondUtils = ToolRack::ConditionUtils
+TR::CondUtils = ToolRack::ConditionUtils
+
 ToolRack::PassUtils = ToolRack::PasswordUtils
+TR::PassUtils = ToolRack::PasswordUtils
+
+ToolRack::ExpUtils = ToolRack::ExceptionUtils
+TR::ExpUtils = ToolRack::ExpUtils
 
+ToolRack::RTUtils = ToolRack::RuntimeUtils
+TR::RTUtils = ToolRack::RTUtils
 

data/toolrack.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.summary       = %q{Collection of simple utilities but I find it increase clarity}
   spec.description   = %q{Just collections of utilities}
   spec.homepage      = "https://github.com/chrisliaw/toolrack"
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
 
   #spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: toolrack
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Chris
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-08 00:00:00.000000000 Z
+date: 2021-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tlogger
@@ -88,7 +88,7 @@ licenses: []
 metadata:
   homepage_uri: https://github.com/chrisliaw/toolrack
   source_code_uri: https://github.com/chrisliaw/toolrack
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -96,7 +96,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -104,7 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.2.22
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Collection of simple utilities but I find it increase clarity
 test_files: []