more_ruby 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5b1771efb7dc83fea53e24b2d7b5a2f67fa7d1e2cdca9dec76ef81ad09817c30
+  data.tar.gz: 46a7e965a7449f3f6e0258f355e414cc2f537ad8f2c2284f06a63fddf515e26b
+SHA512:
+  metadata.gz: 6a8b12b7cf3c75568bfbce46433e6b07e315524ffb34d2b37bdf2f3cae73c0919e2f075f9425a88cd55638caa76e85928c04dcb02a42f1503a173dafaba15012
+  data.tar.gz: 3ad555c95b8f5c8512a6b24522dea8b434539584ecb237c66e56ad9154f26863a168fc16b55df38275cace7ac8e248ca9648e7587c776599ed6f0b0c2cc6aea8

data/LICENCE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Richard Morrisby
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+A very simple gem that adds some methods to some Ruby standard classes, e.g. <array>.include_any?, <array>.delete_random, etc.
+
+Simply require the gem ( require "more_ruby" ) and the additional methods will be available.
+
+# New instance methods #
+
+## Array
+:all_instance_of?, :all_kind_of?, :av, :delete_random, :include_any?, :insert_flat, :mean, :modulo_fetch, :peach, :random, :random_index, :random_insert, :random_move, :stringify_all_values_deep, :sum, :wrap_fetch
+
+## Fixnum
+:digit_count, :format_with_thousands_delimiter, :num_to_letter, :signif
+
+## Float
+:format_with_thousands_delimiter, :signif
+
+## Hash
+:all_keys, :all_values, :delete_random, :peach, :random_key, :random_pair, :random_value, :remove_empty_fields, :sort_deep, :stringify_all_values_deep, :strip_hash_of_keys, :to_a_deep, :to_xml
+
+## Integer
+:digit_count, :format_with_thousands_delimiter, :signif
+
+## NilClass
+:empty?
+
+## Numeric
+:format_with_thousands_delimiter
+
+## String
+:append, :camelcase, :camelcase_to_snakecase, :capitalize_all, :capitalize_first_letter_only, :escape, :escape_whitespace, :extract_values_from_xml_string, :formatted_number, :index_of_last_capital, :invert_case, :is_hex?, :is_integer?, :join, :pascalcase, :prefix_lines, :random_case, :snakecase, :snakecase_and_downcase, :to_bool, :unindent
+
+## Time
+:is_after?, :is_before?, :is_within?, :remove_subseconds
+
+# New singleton methods #
+
+## FalseClass
+:maybe?, :random
+
+## File
+:basename_no_ext
+
+## TrueClass
+:maybe?, :random

data/lib/more_ruby.rb

@@ -0,0 +1,15 @@
+
+require_relative 'more_ruby/array.rb'
+require_relative 'more_ruby/enumerable.rb'
+require_relative 'more_ruby/falseclass.rb'
+require_relative 'more_ruby/file.rb'
+require_relative 'more_ruby/fixnum.rb'
+require_relative 'more_ruby/float.rb'
+require_relative 'more_ruby/hash.rb'
+require_relative 'more_ruby/integer.rb'
+require_relative 'more_ruby/nilclass.rb'
+require_relative 'more_ruby/numeric.rb'
+require_relative 'more_ruby/string.rb'
+require_relative 'more_ruby/time.rb'
+require_relative 'more_ruby/trueclass.rb'
+

data/lib/more_ruby/array.rb

@@ -0,0 +1,119 @@
+
+class Array
+    # Does the array contain any of the supplied items?
+    def include_any?(*items)
+        items.each do |i|
+         return true if self.include? i
+        end
+        false
+    end    
+
+    # Return a random item from the array (by index)
+    def random
+        self[rand(size)]
+    end
+    
+    # Deletes at a random index from the array, and returns the deleted item
+    def delete_random
+        index = rand(size)
+        item = self[index]
+        delete_at(index)
+        item
+    end
+
+    def random_index
+        rand(size)
+    end
+
+    # Insert the supplied element to a random position within the array
+    def random_insert(element)
+        insert(rand(size), element)
+    end
+
+    # Move a random element to a random position in the array
+    def random_move(times = 1)
+        times.times do
+            element = delete_random
+            random_insert(element)
+        end
+    end
+
+    # Returns the mean / average of the Numeric array. Returns a float. All entries must be Numeric.
+    def mean
+        each {|item| raise TypeError, "Cannot determine the mean of an array that contains non-Numeric objects." unless item.kind_of?(Numeric)}
+        inject{ |sum, item| sum + item }.to_f / size
+    end
+    alias :av :mean
+
+    # Returns the summation of the contents of the array
+    # Ignores nils; raises if the array contains a non-Numeric non-nil
+    def sum
+        raise TypeError, "Array contained non-numeric non-nil elements; cannot sum contents." unless compact.all_kind_of? Numeric
+        compact.inject(0) do |sum, item| 
+            sum += item 
+        end
+    end
+
+    # Will insert each member of the supplied array into self, such that self does not contain a new sub-array
+    # Insertion behaviour is more like += than << , e.g. [1, 2, 3].insert_flat(0, [4, 5]) => [4, 5, 1, 2, 3]
+    # Does not flatten self, so any preexisting subarrays are preserved
+    def insert_flat(index, o)
+        case o
+        when Array
+            # A -ve insertion index inserts items AFTER the item at that index, which causes problems when inserting multiple times
+            # Use o.each when -ve ; o.reverse_each when +ve or zero
+            if index < 0
+                o.each do |item|
+                    insert(index, item)
+                end
+            else
+                o.reverse_each do |item|
+                    insert(index, item)
+                end
+            end
+        else
+            insert(index, o)
+        end
+    end
+
+    # A simple method to fetch the item at the index. If index > size, then it 'wraps' around and looks again
+    # E.g. [0, 1, 2].wrap_fetch(4) returns 1 
+    # Operation is effectively fetch(index % size)
+    def wrap_fetch(index)
+        return nil if empty?
+        fetch(index % size)
+    end
+    alias :modulo_fetch :wrap_fetch
+
+    # Returns true if all elements of self are kind_of?(klass)
+    def all_kind_of?(klass)
+        all? {|item| item.kind_of?(klass)}
+    end
+
+    # Returns true if all elements of self are instance_of?(klass)
+    def all_instance_of?(klass)
+        all? {|item| item.instance_of?(klass)}
+    end
+
+    # A prettier way of printing an array
+    # Want to p each row, but have each p appear on a new line in STDOUT
+    def peach
+        self.each { |z| p z }
+    end
+
+    # Method to convert all values to strings, for all layers within the array
+    def stringify_all_values_deep
+        for i in 0 ... size do
+            v = self[i]
+            case v
+            when Array, Hash
+                v = v.stringify_all_values_deep
+            else
+                v = v.to_s
+            end
+            self[i] = v
+        end
+        self
+    end
+
+end

data/lib/more_ruby/enumerable.rb

@@ -0,0 +1,11 @@
+
+module Enumerable
+    def group_by
+        result = {}
+        self.each do |value|
+            key = yield(value)
+            (result[key] ||= []) << value
+        end
+        result
+    end
+end

data/lib/more_ruby/falseclass.rb

@@ -0,0 +1,11 @@
+class FalseClass
+
+    # Yields true 50% of the time, otherwise yields false
+    def self.random
+        rand(2) % 2 == 0
+    end
+
+    def self.maybe?
+        random
+    end
+end

data/lib/more_ruby/file.rb

@@ -0,0 +1,7 @@
+
+class File
+    # Returns the file's basename without its extension 
+    def self.basename_no_ext f
+        File.basename(f, File.extname(f))
+    end
+end

data/lib/more_ruby/fixnum.rb

@@ -0,0 +1,10 @@
+
+class Fixnum
+
+    # Converts the number (1 <= x <= 26) to a letter
+    # 1 => A, 9 => I, 0 has no corresponding letter
+    def num_to_letter
+        raise "Do not call num_to_letter with a number that is not between 1 and 26" unless self >= 1 && self <= 26
+        (self.to_i + 64).chr
+    end
+end

data/lib/more_ruby/float.rb

@@ -0,0 +1,53 @@
+
+
+class Float
+
+    # Two cases : self.abs >= 1, and self.abs < 1
+    # If >= 1, we can use .round(), adjusting for the number of digits before the decimal point
+    # If < 1, .round() will not ignore leading zeroes, so we have to use another means
+    # There is another complication in that 0.00000766.to_s returns 7.66e-06 , not 0.00000766 as we would prefer here
+    def signif(num_digits)
+        raise TypeError, "Must call #{__method__} with an Integer" unless num_digits.kind_of?(Integer)
+        raise ArgumentError, "Must call #{__method__} with a positive Integer" if num_digits < 0 # 0 is a special case, but allowed
+        # Special cases
+        return 0.0 if num_digits == 0
+        return self if self == 0.0
+
+        negative = self < 0 # remember its sign for later
+
+        # Need to check to see if the numebr is small enough that to_s will put it into scientific notation
+        if self.to_s =~ /^(\d)\.(\d*)e-(\d+)$/
+            places = 1 + $2.size + $3.to_i             
+            s = "%.#{places}f" % self # should print out 7.66e-06 as 0.00000766
+        else
+            s = self.to_s
+        end
+        parts = s.split(".")
+        whole = parts[0].to_i.abs
+
+        # significant figures ignore leading zeroes, so we can only return early here if self.abs > 1
+        # 123.456.signif(4) should return 123.4; 123.456.signif(3) should return 123
+        if whole != 0 # equivalent to self.abs > 1
+            if num_digits <= whole.digit_count
+                return whole.signif(num_digits).to_f 
+            else
+                return self.round(num_digits - whole.digit_count)
+            end
+        end
+
+        fraction_as_s = parts[1] # keep as string for now
+        return whole.signif(num_digits).to_f unless fraction_as_s # should not be possible, but check it anyway
+        return whole.signif(num_digits).to_f if fraction_as_s == "0"
+
+        relevant_fraction_digits = num_digits
+        fraction = "0.#{fraction_as_s}".to_f
+        fraction_as_s =~ /^([0]*)[1-9]/
+        leading_zeroes_count = $1.size
+        rounded_fraction = fraction.round(relevant_fraction_digits + leading_zeroes_count)
+        if negative
+            return -(rounded_fraction)
+        else
+            return rounded_fraction
+        end
+    end
+end

data/lib/more_ruby/hash.rb

@@ -0,0 +1,202 @@
+
+class Hash
+
+    def random_value
+        self.values.random
+    end
+
+    def random_key
+        self.keys.random
+    end
+
+    # Returns a hash of the key and value
+    def random_pair
+        key = random_key
+        {key => self[key]}
+    end
+
+    def delete_random
+        delete(self.random_key)
+    end
+
+    # Gathers all keys in the hash in a flat array, even if it's multi-level    
+    # E.g. from {:a => :b, :c => {:d => :e}}, returns [:a, :c, :d]
+    def all_keys
+        list = []
+        self.each_pair do |k, v|
+            case k
+            when Hash
+                list += k.all_keys
+            when Array
+                if k[0].class == Hash # if the array contains hashes
+                    k.each do |array_item|
+                        list += array_item.all_keys
+                    end
+                else
+                    list << k
+                end
+            else
+                list << k
+            end # end case k
+
+            case v
+            when Hash
+                list += v.all_keys
+            when Array
+                if v[0].class == Hash # if the array contains hashes
+                    v.each do |array_item|
+                        list += array_item.all_keys
+                    end
+                else
+                    # do nothing
+                end
+            else
+                # do nothing
+            end # end case v
+        end
+        list
+    end
+    
+    # Gathers all values in the hash in a flat array, even if it's multi-level    
+    # E.g. from {:a => :b, :c => {:d => :e}}, returns [:b, :e]
+    def all_values
+        list = []
+        self.each_pair do |k, v|
+            case k
+            when Hash
+                list += k.all_values
+            when Array
+                if k[0].class == Hash # if the array contains hashes
+                    k.each do |array_item|
+                        list += array_item.all_values
+                    end
+                else
+                    # do nothing
+                end
+            else
+                # do nothing
+            end # end case k
+
+            case v
+            when Hash
+                list += v.all_values
+            when Array
+                if v[0].class == Hash # if the array contains hashes
+                    v.each do |array_item|
+                        list += array_item.all_values
+                    end
+                else
+                    list << v
+                end
+            else
+                list << v
+            end # end case v
+        end
+        list
+    end
+
+    # Method to convert all values to strings, for all layers within the hash
+    def stringify_all_values_deep
+        self.each_pair do |k, v|
+            case v
+            when Array, Hash
+                v = v.stringify_all_values_deep
+            else
+                self[k] = v.to_s
+            end
+        end
+        self
+    end
+    
+    # A prettier way of printing a hash
+    # Want to p each pair, but have each p appear on a new line in STDOUT
+    def peach
+        self.each_pair { |k, v| puts "#{k.inspect} => #{v.inspect}" }
+    end
+
+    # Recursively deletes keys from the hash if the value of that field is nil or empty
+    def remove_empty_fields
+        self.each_pair do |k, v|
+            if self[k].class == Hash
+                self[k] = self[k].remove_empty_fields
+            else
+                self.delete(k) if v.to_s == ""
+            end
+        end
+        self
+    end
+
+    # Method to strip from the hash (and all sub-hashes) all keys matching the entries in the supplied array
+    # Entries in the array can be strings or other literals, or regexes
+    # Directly deletes from self; returns the modified self
+    def strip_hash_of_keys(array_of_keys_to_strip)
+        self.keys.each do |k|
+            strip = false
+            array_of_keys_to_strip.each do |i|
+                if i.class == Regexp
+                    strip = true if k =~ i
+                else
+                    strip = true if k == i
+                end
+            end
+
+            if strip
+                self.delete(k)
+            else
+                if self[k].class == Hash
+                    self[k] = self[k].strip_hash_of_keys(array_of_keys_to_strip)
+                elsif self[k].class == Array
+                    self[k].each do |h|
+                        h = h.strip_hash_of_keys(array_of_keys_to_strip) if h.class == Hash
+                    end
+                end
+            end
+        end
+        self
+    end
+
+    # Method to fully convert the hash into an array, including all sub-hashes
+    # to_a only converts the base level
+    def to_a_deep
+        self.keys.each do |k|
+            if self[k].class == Hash
+                self[k] = self[k].to_a_deep
+            end
+        end
+        self.to_a
+    end
+
+    # Sorts the hash by its keys. This way, if two versions of the hash (mhich are identical but their k-v pairs are in different order)
+    # are both sorted then converted to string (to_s) they will be identical.
+    # Assumes that all of the keys in the hash are symbol/string/numeric and are not Hash, Array, etc.
+    # Assumes that each key in the hash is unique
+    # Sorts deep, not shallow
+    # Returns a new hash; does not modify self
+    def sort_deep
+        new = {}
+        keys = self.keys.sort
+        keys.each do |main_key|
+            self.each_pair do |k, v|
+                next unless k == main_key
+                if v.class == Hash
+                    new[k] = v.sort_deep
+                else
+                    new[k] = v
+                end
+            end
+        end
+        new
+    end
+
+    def to_xml
+        map do |k, v|
+            if v.class == Hash
+                text = v.to_xml
+            else
+                text = v
+            end
+            "<%s>%s</%s>" % [k, text, k]
+        end.join
+    end
+    
+end

data/lib/more_ruby/integer.rb

@@ -0,0 +1,20 @@
+require 'bigdecimal'
+
+class Integer
+
+    # Returns the number of digits in the number
+    def digit_count
+        self.to_s.size
+    end
+
+    # Code taken from https://www.ruby-forum.com/topic/187036 ; all credit for mechanism goes to Harry Kakueki
+    # Method is same as Float#signif below; dangerous to add to common parent Numeric?
+    def signif(num_digits)
+        raise TypeError, "Must call #{__method__} with an Integer" unless num_digits.kind_of?(Integer)
+        raise ArgumentError, "Must call #{__method__} with a positive Integer" if num_digits < 0 # 0 is a special case, but allowed
+        return 0.0 if num_digits == 0
+        return self if self.digit_count <= num_digits
+        m = (num_digits - 1) - Math.log10(self.abs).floor
+        BigDecimal.new(((self * 10 ** m).round * 10 ** (-1 * m)).to_s).to_s('F').gsub(/\.0*$/,"").to_i
+    end
+end

data/lib/more_ruby/nilclass.rb

@@ -0,0 +1,10 @@
+
+class NilClass
+
+    # A simple routing method in case your empty array is actually nil
+    # If you're calling empty?, you care if there is data in there, not if the object is actually an array
+    # nil is obviously empty, so return true instead of NoMethodError
+    def empty?
+        true
+    end
+end

data/lib/more_ruby/numeric.rb

@@ -0,0 +1,18 @@
+
+class Numeric
+
+    # Returns a more print-friendly version of the number
+    # e.g. 1234567.8901 => 1,234,567.8901
+    # Returns a string
+    # Copied from http://stackoverflow.com/questions/6458990/how-to-format-a-number-1000-as-1-000
+    # Credit goes to user "loosecannon"
+    def format_with_thousands_delimiter(delimiter = ",")
+        parts = to_s.split(".")
+        if parts.size == 2        
+            parts[0].reverse.gsub(/...(?=.)/, '\&' + delimiter).reverse + "." + parts[1]
+        else
+            to_s.reverse.gsub(/...(?=.)/, '\&' + delimiter).reverse
+        end
+    end
+
+end

data/lib/more_ruby/string.rb

@@ -0,0 +1,172 @@
+
+class String
+
+    # .capitalize will upcase the first letter and lowercase everything else; this method does only the upcase part
+    def capitalize_first_letter_only
+        return self if empty?
+        return self[0].upcase + self[1 .. -1] # self[1 .. -1] will return "" if self is only one character long
+    end
+
+    # Returns new string, does not modify in place
+    def escape
+        Regexp.escape(self)
+    end
+
+    # Returns a new string with each character's case randomised
+    def random_case
+        new = ""
+        self.each_char do |x|
+            new << ((rand(2) % 2 == 0) ? x.upcase : x.downcase)
+        end
+        new
+    end
+
+    def capitalize_all
+        downcase.scan(/[a-z0-9]+/).map { |z| z.capitalize }.join(' ')
+    end
+
+    def invert_case
+        s = ""
+        self.chars do |c|
+            if c =~ /[A-Z]/
+                s << c.downcase
+            elsif c =~ /[a-z]/
+                s << c.upcase
+            else
+                s << c
+            end            
+        end
+        raise "invert_case failed!" unless s.size == self.size
+        s
+    end
+
+    # Prefixes each line with the supplied string
+    def prefix_lines(prefix)
+        gsub(/^/) { prefix }
+    end
+
+    # Remove leading whitespace from each line in the string, using the indentation of the first line as the guide
+    def unindent
+        leading_whitespace = self[/\A\s*/]
+        self.gsub(/^#{leading_whitespace}/, '')
+    end
+
+    # Returns the index of the last capital in the string (if one exists)
+    def index_of_last_capital
+        pos = 0
+        reverse_index = self.reverse.index /[A-Z]/
+        return nil if reverse_index == nil
+        self.size - reverse_index - 1
+    end
+
+    def snakecase
+        gsub(/[^a-zA-Z0-9]+/, '_')
+    end
+
+    def snakecase_and_downcase
+        downcase.snakecase
+    end
+
+    # Like camelcase but with the first letter also capitalised
+    # Pascalcase is C#'s case convention
+    def pascalcase
+        downcase.scan(/[a-z0-9]+/).map { |x| x.capitalize }.join
+    end
+
+    def camelcase
+        s = self.pascalcase
+        s[0].downcase + s[1 .. -1]
+    end
+
+    # Converts aStringInCamelCase to a_string_in_camel_case
+    def camelcase_to_snakecase
+        a = []
+
+        self =~ /(^[a-z]+)/
+        a << $1 if $1
+
+        m = self.scan /([A-Z]+[a-z0-9]*)/
+        m.flatten!
+        m.each do |fragment|
+            fragment =~ /([A-Z]+[a-z0-9]*)/
+            caps = $1
+            lower = $2
+            if caps.size > 1
+                s = "_#{caps.downcase}"
+                a << s
+                caps = "" # set to empty string so that the below caps.downcase still works
+            end
+            s = "_#{caps.downcase}#{lower}"
+            a << s unless s == "_"
+        end
+        a.join
+    end
+
+    def append(s)
+        self << s
+    end
+
+    def join(s = "")
+        append(s)
+    end
+
+    def to_bool
+        return true if self.downcase == "true"
+        return false if self.downcase == "false"
+        raise "String #{self} was neither 'true' nor 'false'. Cannot convert to boolean in this custom method."
+    end
+
+    # Does the string look like an integer?
+    # !! will convrt nil to false, and anythig else (e.g. 0) to true
+    def is_integer?
+        !!(self =~ /^[0-9]+$/)
+    end
+
+    # Does the string look like hex?
+    # !! will convrt nil to false, and anythig else (e.g. 0) to true
+    def is_hex?
+        !!(self =~ /^[0-9a-fA-F]+$/)
+    end
+
+    def formatted_number(separator = ",", count_limit = 3)
+        copy = self.dup
+        s = ""
+        count = 0
+        while copy.size > 0
+            if count == count_limit
+                s << separator
+                count = 0
+            else
+                count += 1
+                s << copy[-1]
+                copy.chop!
+            end
+        end
+        s.reverse
+    end
+
+    # Take the XML-string and remove from it anything that looks like an XML tag
+    def extract_values_from_xml_string
+        values = []
+        a = self.split("<").collect { |z| z.chomp } # need to remove whitespace where possible
+        # Now remove from the array any items that end in a > - these items look like fragments of tags
+        a.delete_if { |z| z =~ />$/ }
+
+        # a might now contain nils, "" and items like "foo>bar"
+        a.delete_if { |z| z == "" }
+        a.compact!
+        a.each { |z| values << z.split(">")[1] }
+
+        values
+    end
+
+    # Within the string, whitespace chars (\n, \r, \t) are replaced by their text equivalents, e.g. \n => \\n
+    # Does not modify self
+    def escape_whitespace
+        copy = self.dup
+        copy.gsub!("\n", "\\n")
+        copy.gsub!("\r", "\\r")
+        copy.gsub!("\t", "\\t")
+        copy
+    end
+end

data/lib/more_ruby/time.rb

@@ -0,0 +1,31 @@
+
+class Time
+
+    # Returns a new Time object with all subseconds set to zero
+    def remove_subseconds
+        ms = self.subsec
+        self.clone - ms
+    end
+
+    # Method to compare self against other_time, returning true if self is equal to or earlier/before other_time
+    # This comparison is made with some leeway, so that if self is actually after other_time, but by less than
+    # the leeway amount (in seconds), the method will return true
+    def is_before?(other_time, leeway = 5)
+        other_time += leeway
+        self <= other_time
+    end
+
+    # Method to compare self against other_time, returning true if self is equal to or later/after other_time
+    # This comparison is made with some leeway, so that if self is actually before other_time, but by less than
+    # the leeway amount (in seconds), the method will return true
+    def is_after?(other_time, leeway = 5)
+        other_time -= leeway
+        self >= other_time
+    end
+
+    # Method to compare self against other_time, returning true if it is close enough to self in either direction
+    # Leeway is in seconds
+    def is_within?(other_time, leeway = 5)
+        is_before?(other_time, leeway) && is_after?(other_time, leeway)
+    end
+end

data/lib/more_ruby/trueclass.rb

@@ -0,0 +1,12 @@
+
+class TrueClass
+
+    # Yields true 50% of the time, otherwise yields false
+    def self.random
+        rand(2) % 2 == 0
+    end
+
+    def self.maybe?
+        random
+    end
+end

data/test/test_array.rb

@@ -0,0 +1,193 @@
+require "test/unit"
+require_relative "../lib/more_ruby"
+
+class TestArray < Test::Unit::TestCase
+
+    def test_random
+        a = (1 .. 20).to_a
+        randoms = []
+        count = 20
+        count.times do
+            randoms << a.random
+        end
+        
+        assert_equal(count, randoms.size)
+        
+        randoms.compact!
+        assert_equal(count, randoms.size, ".random returned nils")
+        
+        randoms.uniq!
+        assert_empty(randoms - a, ".random returned values not in the original array")
+        
+        # Extremely unlikely to happen, but rand may roll in order for every call in this test
+        assert_not_equal(a, randoms, ".random did not return values in a random order")
+    end
+    
+    def test_delete_random_size
+        orig_size = 20
+        a = (1 .. orig_size).to_a
+        count = 10
+        count.times do |i|
+            deleted = a.delete_random
+
+            assert_not_equal(orig_size, a.size, ".delete_random is not deleting from self")
+            
+            assert_equal(orig_size - (i + 1), a.size, ".delete_random is deleting too many from self")
+            
+            # TODO would be nice to test randomness, but that's pretty difficult    
+        end
+    end
+    
+    def test_delete_random_return
+        b = [3, 3, 3]
+        deleted = b.delete_random
+        
+        assert_not_empty(b, ".delete_random is deleting by object, not by index")
+        assert_not_equal(b.uniq, b, ".delete_random is deleting by object, not by index")
+        assert_equal(deleted, b.random, ".delete_random is not returning the deleted item")
+        assert_not_nil(deleted, ".delete_random is not returning the deleted item")
+        
+    end
+    
+    def test_mean
+        a = (1 .. 6).to_a # mean is 3.5
+        expected = 3.5
+        mean = a.mean
+        assert_kind_of(Float, mean, ".mean did not return a Float")
+        assert_equal(mean, expected, ".mean is not returning the correct mean")
+    end
+    
+    def test_av
+        a = (1 .. 6).to_a # mean is 3.5
+        expected = 3.5
+        mean = a.av
+        assert_kind_of(Float, mean, ".av did not return a Float")
+        assert_equal(mean, expected, ".av is not returning the correct mean")
+    end
+
+    def test_mean_mixed_numerics
+        a = [1, 2.0, -6789, 432.123456, 0, 0x04B, 01000, 0b1000]
+        expected = -719.859568
+        mean = a.mean
+        assert_kind_of(Float, mean, ".mean did not return a Float")
+        assert_equal(mean, expected, ".mean is not returning the correct mean")
+    end
+
+    def test_non_numeric_mean
+        assert_exception_message_correct_non_numeric_mean ["a", "b", "c"]
+        assert_exception_message_correct_non_numeric_mean ["1", "2", "c"]
+        assert_exception_message_correct_non_numeric_mean [1, 2, "c", 4]
+        assert_exception_message_correct_non_numeric_mean [1, 2, "3", 4]
+        assert_exception_message_correct_non_numeric_mean [1, nil, 3, 4]
+        assert_exception_message_correct_non_numeric_mean [1, false, true, 4]
+    end
+
+    def assert_exception_message_correct_non_numeric_mean(array) 
+        exception = assert_raise(TypeError) {array.mean}
+        assert_equal("Cannot determine the mean of an array that contains non-Numeric objects.", exception.message) 
+    end
+
+    def test_sum
+        a = (1 .. 6).to_a
+        expected = 21
+        sum = a.sum
+        assert_kind_of(Integer, sum, ".sum did not return a Integer")
+        assert_equal(sum, expected, ".sum is not returning the correct sum")
+    end
+
+    def test_sum_floats
+        a = (1 .. 6).to_a
+        a << 4.32
+        expected = 25.32
+        sum = a.sum
+        assert_kind_of(Float, sum, ".sum did not return a Float")
+        assert_equal(sum, expected, ".sum is not returning the correct sum")
+    end
+
+    def test_sum_non_numeric
+        a = (1 .. 6).to_a
+        a << "4.32"
+        exception = assert_raise(TypeError) {a.sum}
+        assert_equal("Array contained non-numeric non-nil elements; cannot sum contents.", exception.message) 
+    end
+
+    def test_sum_with_nil
+        a = (1 .. 6).to_a
+        a << nil
+        a << 4.32
+        a << -26
+        expected = -0.68
+        sum = a.sum.signif(8) # need to work around floating-point precision issues
+        assert_kind_of(Float, sum, ".sum did not return a Float")
+        assert_equal(sum, expected, ".sum is not returning the correct sum")
+    end
+
+    def test_insert_flat
+        a = [1, 2, 3]
+        b = [4, 5]
+        expected = [4, 5, 1, 2, 3]
+        a.insert_flat(0, b)
+        assert_equal(expected, a, ".insert_flat failed")
+    end
+
+    def test_insert_flat_preserving_subarrays
+        a = [1, [2.1, 2.2], 3]
+        b = [4, 5]
+        expected = [1, [2.1, 2.2], 4, 5, 3]
+        a.insert_flat(-2, b)
+        assert_equal(expected.size, a.size, ".insert_flat failed to preserve preexisting subarray")
+        assert_equal(expected, a, ".insert_flat failed")
+    end
+
+    def test_all_kind_of
+        a = ["A string", :smybol, false, 1]
+        assert_false(a.all_kind_of?(String), ".all_kind_of? returned true when there were distinctly different types in the array")
+        assert(a.all_kind_of?(Object), ".all_kind_of? returned true when there were distinctly different types in the array")
+
+        b = (1 .. 4).to_a
+        assert(b.all_kind_of?(Numeric), ".all_kind_of? returned false when the array's contents were all subclasses of the questioned class")
+        assert(b.all_kind_of?(Integer), ".all_kind_of? returned false when the array's contents were all subclasses of the questioned class")
+        assert(b.all_kind_of?(Fixnum), ".all_kind_of? returned false when the array's contents were all instances of the questioned class")
+
+        b.insert(2, 2.0)
+        assert(b.all_kind_of?(Numeric), ".all_kind_of? returned false when the array's contents were all subclasses of the questioned class")
+        assert_false(b.all_kind_of?(Integer), ".all_kind_of? returned true when there were distinctly different types in the array")
+        assert_false(b.all_kind_of?(Fixnum), ".all_kind_of? returned true when there were distinctly different types in the array")
+    end
+
+
+    def test_all_instance_of
+        a = ["A string", :smybol, false, 1]
+        assert_false(a.all_instance_of?(String), ".all_instance_of? returned true when there were distinctly different types in the array")
+        assert_false(a.all_instance_of?(Object), ".all_instance_of? returned true when there were distinctly different types in the array")
+
+        b = (1 .. 4).to_a
+        assert_false(b.all_instance_of?(Numeric), ".all_instance_of? returned true when the array's contents were all subclasses of the questioned class")
+        assert_false(b.all_instance_of?(Integer), ".all_instance_of? returned true when the array's contents were all subclasses of the questioned class")
+        assert(b.all_instance_of?(Fixnum), ".all_instance_of? returned false when the array's contents were all instances of the questioned class")
+
+        b.insert(2, 2.0)
+        assert_false(b.all_instance_of?(Numeric), ".all_instance_of? returned true when the array's contents were all subclasses of the questioned class")        
+    end
+
+    def test_wrap_fetch
+        a = [:a, :b, :c, :d]
+        assert_equal(:a, a.wrap_fetch(0), "wrap_fetch failed")
+        assert_equal(:d, a.wrap_fetch(3), "wrap_fetch failed")
+        assert_equal(:d, a.wrap_fetch(-1), "wrap_fetch failed")
+        assert_equal(:a, a.wrap_fetch(-4), "wrap_fetch failed")
+        assert_equal(:a, a.wrap_fetch(4), "wrap_fetch failed")
+        assert_equal(:b, a.wrap_fetch(5), "wrap_fetch failed")
+        assert_equal(:c, a.wrap_fetch(494), "wrap_fetch failed")
+        assert_equal(:c, a.wrap_fetch(-494), "wrap_fetch failed")        
+
+        b = []
+        assert_nil(b.wrap_fetch(0), "wrap_fetch failed")
+    end
+
+    def test_modulo_fetch
+        a = [:a, :b, :c, :d]
+        assert_equal(:b, a.modulo_fetch(5), "modulo_fetch failed")
+    end
+
+end

data/test/test_integer.rb

@@ -0,0 +1,51 @@
+require "test/unit"
+require_relative "../lib/more_ruby"
+
+class TestArray < Test::Unit::TestCase
+
+	def test_signif_digits
+		a = []
+		a << {:raw => 2326759, :digits => 2, :pro => 2300000}
+		a << {:raw => 2326759, :digits => 3, :pro => 2330000}
+		a << {:raw => 2326759, :digits => 4, :pro => 2327000}
+		a << {:raw => 2326759, :digits => 5, :pro => 2326800}
+		a << {:raw => 2326759, :digits => 6, :pro => 2326760}
+		a << {:raw => 2326759, :digits => 7, :pro => 2326759}
+		a << {:raw => 2326759, :digits => 8, :pro => 2326759}
+		a << {:raw => 23, :digits => 3, :pro => 23}
+		a << {:raw => 23, :digits => 2, :pro => 23}
+		a << {:raw => 23, :digits => 1, :pro => 20}    	
+		a << {:raw => 23, :digits => 0, :pro => 0}
+		a << {:raw => 10.546, :digits => 0, :pro => 0}
+		a << {:raw => 10.546, :digits => 1, :pro => 10.0}
+		a << {:raw => 10.546, :digits => 2, :pro => 10.0}
+		a << {:raw => 10.546, :digits => 3, :pro => 10.5}
+		a << {:raw => 10.546, :digits => 4, :pro => 10.55}
+		a << {:raw => 10.546, :digits => 5, :pro => 10.546}
+		a << {:raw => 10.546, :digits => 6, :pro => 10.546}
+		a << {:raw => 0.766, :digits => 2, :pro => 0.77}
+		a << {:raw => 0.00000766, :digits => 4, :pro => 0.00000766}
+		a << {:raw => 0.00000766, :digits => 3, :pro => 0.00000766}
+		a << {:raw => 0.00000766, :digits => 2, :pro => 0.0000077}
+		a << {:raw => 0.00000766, :digits => 1, :pro => 0.000008}
+		a << {:raw => 0.00000766, :digits => 0, :pro => 0}
+		a << {:raw => 0.0, :digits => 4, :pro => 0.0}
+		a << {:raw => 0.0, :digits => 1, :pro => 0.0}
+		a << {:raw => 0.0, :digits => 0, :pro => 0.0}
+		a << {:raw => 1.00000766, :digits => 8, :pro => 1.0000077}
+		a << {:raw => 1.00000766, :digits => 3, :pro => 1.0}
+		a << {:raw => 1.00000766, :digits => 2, :pro => 1.0}
+		a << {:raw => 1.00000766, :digits => 1, :pro => 1}
+		a << {:raw => 1.00000766, :digits => 0, :pro => 0}
+		a << {:raw => -23, :digits => 3, :pro => -23}
+		a << {:raw => -0.0, :digits => 1, :pro => -0.0}
+		a << {:raw => -2326759, :digits => 5, :pro => -2326800}
+		a << {:raw => -1.00000766, :digits => 8, :pro => -1.0000077}
+
+		a.each do |x|
+			processed = x[:raw].signif(x[:digits])
+			assert_equal(x[:pro], processed, ".signif did not produce the expected result; for digit-count of #{x[:digits]} with #{x[:raw]}, expected #{x[:pro]} but received #{processed}")
+		end
+	end
+
+end

data/test/test_numeric.rb

@@ -0,0 +1,27 @@
+require "test/unit"
+require "test/unit"
+require_relative "../lib/more_ruby"
+
+class TestArray < Test::Unit::TestCase
+
+	def test_format_with_thousands_delimiter
+		a = []
+		a << {:raw => 234, :expected => "234"}
+		a << {:raw => 2326759, :expected => "2,326,759"}
+		a << {:raw => 2326759, :expected => "2.326.759", :delimiter => "."}
+		a << {:raw => 2326759, :expected => "2.-.326.-.759", :delimiter => ".-."}
+		a << {:raw => 2326759.123456, :expected => "2,326,759.123456"}
+		a << {:raw => -2326759.123456, :expected => "-2,326,759.123456"}
+		a << {:raw => 0.23456, :expected => "0.23456"}
+
+		a.each do |x|
+			if x[:delimiter]
+				processed = x[:raw].format_with_thousands_delimiter(x[:delimiter])
+			else
+				processed = x[:raw].format_with_thousands_delimiter
+			end
+			assert_equal(x[:expected], processed, ".format_with_thousands_delimiter did not produce the expected result; delimiter? #{x[:delimiter] != nil ? x[:delimiter] : "<none>"} with #{x[:raw]}, expected #{x[:expected]} but received #{processed}")
+		end
+	end
+
+end

data/test/test_string.rb

@@ -0,0 +1,102 @@
+require "test/unit"
+require_relative "../lib/more_ruby"
+
+class TestString < Test::Unit::TestCase
+
+	def test_capitalize_first_letter_only
+		input = "someThingELSE"
+		expected = "SomeThingELSE"
+		actual = input.capitalize_first_letter_only
+        assert_equal(expected, actual, ".capitalize_first_letter_only is not behaving correctly")
+	end
+
+	def test_capitalize_first_letter_only_single_letter
+		input = "s"
+		expected = "S"
+		actual = input.capitalize_first_letter_only
+        assert_equal(expected, actual, ".capitalize_first_letter_only is not behaving correctly")
+	end
+
+	def test_capitalize_first_letter_only_empty_string
+		input = ""
+		expected = ""
+		actual = input.capitalize_first_letter_only
+        assert_equal(expected, actual, ".capitalize_first_letter_only is not behaving correctly")
+	end
+
+	def test_escape_into_regex
+		s = "some s\\tring"
+		s2 = s.clone
+		e = s.escape
+
+		re = Regexp.new(e)
+
+		assert_equal(s, s2, ".escape modified the original string")
+		assert_not_equal(e, s, ".escape didn't escape parts of the string")
+
+		assert_equal(re =~ s, 0, ".escape didn't yield an escaped string that could be used to make a Regexp object")
+		assert_nil(re =~ e, ".escape yielded an escaped string that matched its Regexp object")
+	end
+
+	def test_snakecase
+		a = []
+		a << {:raw => "thiNGS", :expected => "thiNGS"}
+		a << {:raw => "thiNGS-with_stuff", :expected => "thiNGS_with_stuff"}
+		a << {:raw => "thi--_-ngs", :expected => "thi_ngs"}
+		a << {:raw => "th2i<>n!!!gs", :expected => "th2i_n_gs"}
+
+		a.each do |x|
+			actual = x[:raw].snakecase
+			assert_equal(actual, x[:expected], ".snakecase didn't work properly")
+		end
+
+	end
+
+	def test_snakecase_and_downcase
+		a = []
+		a << {:raw => "thiNGS", :expected => "things"}
+		a << {:raw => "thiNGS-with_stuff", :expected => "things_with_stuff"}
+		a << {:raw => "thi--_-ngs", :expected => "thi_ngs"}
+		a << {:raw => "th2i<>n!!!gs", :expected => "th2i_n_gs"}
+
+		a.each do |x|
+			actual = x[:raw].snakecase_and_downcase
+			assert_equal(actual, x[:expected], "snakecase_and_downcase didn't work properly")
+		end
+
+	end
+
+	def test_pascalcase
+		a = []
+		a << {:raw => "thiNGS", :expected => "Things"}
+		a << {:raw => "thiNGS-with_stuff", :expected => "ThingsWithStuff"}
+		a << {:raw => "thi--_-ngs", :expected => "ThiNgs"}
+		a << {:raw => "th2i<>n!!!gs", :expected => "Th2iNGs"}
+		a << {:raw => "a_and_b", :expected => "AAndB"}
+		a << {:raw => "A_AND_B", :expected => "AAndB"}
+		a << {:raw => "AAndB", :expected => "Aandb"}
+
+		a.each do |x|
+			actual = x[:raw].pascalcase
+			assert_equal(x[:expected], actual, ".pascalcase didn't work properly")
+		end
+
+	end
+
+	def test_camelcase
+		a = []
+		a << {:raw => "thiNGS", :expected => "things"}
+		a << {:raw => "thiNGS-with_stuff", :expected => "thingsWithStuff"}
+		a << {:raw => "thi--_-ngs", :expected => "thiNgs"}
+		a << {:raw => "th2i<>n!!!gs", :expected => "th2iNGs"}
+		a << {:raw => "a_and_b", :expected => "aAndB"}
+		a << {:raw => "A_AND_B", :expected => "aAndB"}
+		a << {:raw => "AAndB", :expected => "aandb"}
+
+		a.each do |x|
+			actual = x[:raw].camelcase
+			assert_equal( x[:expected], actual, ".camelcase didn't work properly")
+		end
+
+	end
+end

data/test/test_time.rb

@@ -0,0 +1,16 @@
+require "test/unit"
+require_relative "../lib/more_ruby"
+
+class TestArray < Test::Unit::TestCase
+
+	def test_remove_subseconds
+		t = Time.now
+		t2 = t.remove_subseconds
+
+		assert_not_equal(t, t2, "remove_subseconds didn't work")
+		assert_equal(t2.subsec.to_s, "0", "remove_subseconds didn't work")
+		assert_equal(t2.usec.to_s, "0", "remove_subseconds didn't work")
+
+	end
+
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: more_ruby
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Richard Morrisby
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-05-04 00:00:00.000000000 Z
+dependencies: []
+description: "  A very simple gem that adds some methods to some Ruby standard classes,
+  e.g. <array>.include_any?, <array>.delete_random, etc.\n\n  Simply require the gem
+  ( require \"more_ruby\" ) and the additional methods will be available.\n  \n  #
+  New instance methods #\n\n  ## Array\n  :all_instance_of?, :all_kind_of?, :av, :delete_random,
+  :include_any?, :insert_flat, :mean, :modulo_fetch, :peach, :random, :random_index,
+  :random_insert, :random_move, :stringify_all_values_deep, :sum, :wrap_fetch\n  \n
+  \ ## Fixnum\n  :digit_count, :format_with_thousands_delimiter, :num_to_letter, :signif\n
+  \ \n  ## Float\n  :format_with_thousands_delimiter, :signif\n  \n  ## Hash\n  :all_keys,
+  :all_values, :delete_random, :peach, :random_key, :random_pair, :random_value, :remove_empty_fields,
+  :sort_deep, :stringify_all_values_deep, :strip_hash_of_keys, :to_a_deep, :to_xml\n
+  \ \n  ## Integer\n  :digit_count, :format_with_thousands_delimiter, :signif\n  \n
+  \ ## NilClass\n  :empty?\n  \n  ## Numeric\n  :format_with_thousands_delimiter\n
+  \ \n  ## String\n  :append, :camelcase, :camelcase_to_snakecase, :capitalize_all,
+  :capitalize_first_letter_only, :escape, :escape_whitespace, :extract_values_from_xml_string,
+  :formatted_number, :index_of_last_capital, :invert_case, :is_hex?, :is_integer?,
+  :join, :pascalcase, :prefix_lines, :random_case, :snakecase, :snakecase_and_downcase,
+  :to_bool, :unindent\n  \n  ## Time\n  :is_after?, :is_before?, :is_within?, :remove_subseconds\n
+  \ \n  # New singleton methods #\n  \n  ## FalseClass\n  :maybe?, :random\n  \n  ##
+  File\n  :basename_no_ext\n  \n  ## TrueClass\n  :maybe?, :random\n\n"
+email: rmorrisby@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENCE.txt
+- README.md
+- lib/more_ruby.rb
+- lib/more_ruby/array.rb
+- lib/more_ruby/enumerable.rb
+- lib/more_ruby/falseclass.rb
+- lib/more_ruby/file.rb
+- lib/more_ruby/fixnum.rb
+- lib/more_ruby/float.rb
+- lib/more_ruby/hash.rb
+- lib/more_ruby/integer.rb
+- lib/more_ruby/nilclass.rb
+- lib/more_ruby/numeric.rb
+- lib/more_ruby/string.rb
+- lib/more_ruby/time.rb
+- lib/more_ruby/trueclass.rb
+- test/test_array.rb
+- test/test_integer.rb
+- test/test_numeric.rb
+- test/test_string.rb
+- test/test_time.rb
+homepage: https://rubygems.org/gems/more_ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Adds some extra methods to some Ruby standard classes
+test_files:
+- test/test_array.rb
+- test/test_integer.rb
+- test/test_numeric.rb
+- test/test_string.rb
+- test/test_time.rb