rearmed 1.3.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8cd8b9873096a342bb640e7bab688970350bf050
-  data.tar.gz: 84ac122091acba8d89b1c4f1b99bf2e9ff3896e2
+SHA256:
+  metadata.gz: 5e9c5aa5c6b89f77aeae8704f39ad697f5fa90fcf2defb344b01e1a74374fe53
+  data.tar.gz: 50ab78b692722a964136b0e7ddfc6a2f4d0cf27f574fdc097e760d64ade52622
 SHA512:
-  metadata.gz: 704335a6f2403d194b54bfbca86c6660d49f3c6a5eab6eb2031d813032e9c7d62ea7b03f35d11dd6a11adf251a6b15c706e39046e2fb298f093d2904e313ddd7
-  data.tar.gz: d8d2552250bacd242eac8e83d492d6cde941a0177d4cbbc8888fececb7ffe568b7f336fa553bcc18746214dc02836744f3542aa34c998ba4694f8ea820e170fd
+  metadata.gz: 5faf458204002b2096d67c5eb0bdf79852cfe86a014ade04b6546a43516e45b441c1cd6dbc45738d4a196507c988841c9af2eca57bcdd6f08b67f401d44ce0a1
+  data.tar.gz: 3e825f05d3ff172f366845faa5eb44347c4f9b8110834cb915bb2bbd766db266618930f27446b3a2a803ca5b8e1b16ec728adc702911da85137eb935c5e267c1

data/CHANGELOG.md

@@ -1,6 +1,15 @@
 CHANGELOG
 ---------
 
+- **2.0.0 - July 11, 2018**
+  - Rename all generic `Rearmed` methods to their respective object type subclass and add type checking. Three examples:
+    - `Rearmed.casecmp?(str1, str2)` changed to `Rearmed::String.casecmp?(str1, str2)`
+    - `Rearmed.hash_join(h)` changed to `Rearmed::Hash.join?(h)`
+    - `Rearmed.dig` is the only exception will remained at the global `Rearmed` namespace. This method is shared by both Array and Hash and also is used internally throughout the library.
+  - Change method of applying patches from `require 'rearmed/apply_patches'` to `Rearmed#apply_patches!`. Once `apply_patches!` has been called, then `enabled_patches` cannot be changed. If it is, it will raise a `PatchesAlreadyAppliedError`
+  - Overhaul `Rearmed#enabled_patches=` method with type checking
+  - Allow setting `:all` for `Rearmed#enabled_patches=`
+  - Add `Integer#length`, `Object#bool?`, `Object#true?`, `Object#false?`, `String#match?`. These methods were all borrowed from [`finishing_moves`](https://github.com/forgecrafted/finishing_moves), Thanks!
 - **1.3.1 - Sept 2, 2017**
   - Add `Enumerable#select_map`
   - Add `String#casecmp?` for Ruby 2.3.x and below

data/README.md

@@ -1,6 +1,9 @@
-# Rearmed Ruby <a href='https://travis-ci.org/westonganger/rearmed-rb' target='_blank'><img src='https://api.travis-ci.org/westonganger/rearmed-rb.svg?branch=master' border='0' alt='Build Status' /></a> 
+# Rearmed Ruby
 
-<a href='https://ko-fi.com/A5071NK' target='_blank'><img height='32' style='border:0px;height:32px;' src='https://az743702.vo.msecnd.net/cdn/kofi1.png?v=a' border='0' alt='Buy Me a Coffee' /></a> 
+<a href="https://badge.fury.io/rb/rearmed" target="_blank"><img height="21" style='border:0px;height:21px;' border='0' src="https://badge.fury.io/rb/rearmed.svg" alt="Gem Version"></a>
+<a href='https://travis-ci.org/westonganger/rearmed-rb' target='_blank'><img height='21' style='border:0px;height:21px;' src='https://api.travis-ci.org/westonganger/rearmed-rb.svg?branch=master' border='0' alt='Build Status' /></a>
+<a href='https://rubygems.org/gems/rearmed' target='_blank'><img height='21' style='border:0px;height:21px;' src='https://ruby-gem-downloads-badge.herokuapp.com/rearmed?label=rubygems&type=total&total_label=downloads&color=brightgreen' border='0' alt='RubyGems Downloads' /></a>
+<a href='https://ko-fi.com/A5071NK' target='_blank'><img height='22' style='border:0px;height:22px;' src='https://az743702.vo.msecnd.net/cdn/kofi1.png?v=a' border='0' alt='Buy Me a Coffee' /></a> 
 
 A collection of helpful methods and monkey patches for Arrays, Hash, Enumerables, Strings, Objects & Dates in Ruby. [Rearmed is a collection of plugins](https://github.com/westonganger?utf8=%E2%9C%93&tab=repositories&q=rearmed) which are driven by making life easier & coding more natural.
 
@@ -18,15 +21,15 @@ gem 'rearmed'
 
 # Usage
 
-## Setup Enabled Monkey Patches (all are optional)
+## Setup Monkey Patches (all are opt-in)
 
 ```ruby
 # config/initializers/rearmed.rb
 
 Rearmed.enabled_patches = {
   array: {
-    dig: false,
     delete_first: false,
+    dig: false,
     not_empty: false
   },
   date: {
@@ -44,14 +47,21 @@ Rearmed.enabled_patches = {
     only: false,
     to_struct: false
   },
+  integer: {
+    length: false
+  },
   object: {
+    bool?: false,
+    false?: false,
     in: false,
-    not_nil: false
+    not_nil: false,
+    true?: false
   },
   string: {
     begins_with: false,
-    casecmp?: false
+    casecmp?: false,
     ends_with: false,
+    match?: false,
     starts_with: false,
     to_bool: false,
     valid_float: false,
@@ -59,10 +69,34 @@ Rearmed.enabled_patches = {
   }
 }
 
+Rearmed.apply_patches!
+```
+
+Some other argument formats the `enabled_patches` option accepts are:
 
-require 'rearmed/apply_patches'
+```ruby
+### Enable everything
+Rearmed.enabled_patches = :all
+
+### Disable everything
+Rearmed.enabled_patches = nil
+
+### Hash values can be boolean/nil values also
+Rearmed.enabled_patches = {
+  array: true, 
+  date: {
+    now: true
+  },
+  enumerable: true, 
+  hash: false, 
+  integer: false, 
+  object: nil, 
+  string: nil
+}
 ```
 
+By design, once `Rearmed.apply_patches!` is called then `Rearmed.enabled_patches` is no longer editable and `Rearmed.apply_patches!` cannot be called again. If you try to do so, it will raise a `PatchesAlreadyAppliedError`. There is no-built in way of changing the patches, if you need to do so (which you shouldn't) that is up to you to figure out.
+
 ## Array Methods
 ```ruby
 array = [1,2,1,4,1]
@@ -133,6 +167,10 @@ my_var.not_nil?
 # Only monkey patched if not using ActiveSupport / Rails as this method is already defined there
 my_var.in?([1,2,3])
 my_var.in?(1,2,3) # or with splat arguments
+
+my_var.bool? # if is true or false boolean value
+my_var.true? # if is true boolean value
+my_var.false? # if is false boolean value
 ```
 
 ## String
@@ -143,9 +181,14 @@ my_var.in?(1,2,3) # or with splat arguments
 '123.123'.valid_float? 
 # or without monkey patch: Rearmed.valid_float?('123.123')
 
+'123.123'.valid_number? 
+# or without monkey patch: Rearmed.valid_number?('123.123')
+
 'true'.to_bool 
 # or without monkey patch: Rearmed.to_bool('true')
 
+'foo'.match?(/fo/) #=> true, this method returns a convenient boolean value instead of matchdata
+
 # alias of start_with? and end_with? to have more sensible method names
 'foo'.starts_with?('fo') # => true
 'foo'.begins_with?('fo') # => true
@@ -158,19 +201,19 @@ my_var.in?(1,2,3) # or with splat arguments
 ```
 
 # Contributing / Todo
-If you want to request a method please raise an issue and we can discuss the implementation. 
-
-If you want to contribute here are a couple of things you could do:
+If your looking to contribute here is a list of outstanding items:
 
 - Get the `natural_sort` method to accept a block
 
+To request or add a method, please raise an issue and we can discuss the implementation. 
+
 
 # Credits
 Created by Weston Ganger - [@westonganger](https://github.com/westonganger)
 
 For any consulting or contract work please contact me via my company website: [Solid Foundation Web Development](https://solidfoundationwebdev.com)
 
-## Similar Libraries Created By Me
+## Other Libraries in the Rearmed family of Plugins
 - [Rearmed Rails](https://github.com/westonganger/rearmed_rails)
 - [Rearmed-JS](https://github.com/westonganger/rearmed-js)
 - [Rearmed-CSS](https://github.com/westonganger/rearmed-css)

data/Rakefile

@@ -3,28 +3,19 @@ require 'bundler/gem_tasks'
 
 task :test do 
   require 'rake/testtask'
+
   Rake::TestTask.new do |t|
     t.libs << 'test'
-    t.test_files = FileList['test/**/tc_*.rb']
+    t.test_files = FileList['test/**/*_test.rb']
     t.verbose = true
   end
 end
 
 task :console do
   require 'rearmed'
-  Rearmed.enabled_patches = {
-    array: true,
-    hash: true,
-    object: true,
-    string: true,
-    date: true,
-    enumerable: true,
-    rails_3: true,
-    rails_4: true,
-    rails: true,
-    minitest: true
-  }
-  require 'rearmed/apply_patches'
+
+  Rearmed.enabled_patches = :all
+  Rearmed.apply_patches!
 
   require 'irb'
   binding.irb

data/lib/rearmed.rb

@@ -5,14 +5,63 @@ require 'rearmed/exceptions'
 
 module Rearmed
 
-  @enabled_patches = eval(File.read(File.join(File.dirname(__FILE__), 'rearmed/default_enabled_patches.hash')))
+  DEFAULT_PATCHES = {
+    array: {}, 
+    date: {}, 
+    enumerable: {}, 
+    hash: {}, 
+    integer: {}, 
+    object: {}, 
+    string: {}, 
+  }.freeze
+  private_constant :DEFAULT_PATCHES
+  
+  @enabled_patches = Marshal.load(Marshal.dump(DEFAULT_PATCHES)) 
+  @applied = false
 
   def self.enabled_patches=(val)
-    @enabled_patches = val
+    if @applied
+      raise ::Rearmed::Exceptions::PatchesAlreadyAppliedError.new
+    else
+      if [nil, {}].include?(val)
+        @enabled_patches = Marshal.load(Marshal.dump(DEFAULT_PATCHES)) 
+      elsif val == :all
+        @enabled_patches = val
+      elsif val.is_a?(::Hash)
+        @enabled_patches = {}
+
+        DEFAULT_PATCHES.keys.each do |k|
+          methods = val[k] || val[k.to_sym]
+          if methods
+            if methods.is_a?(::Hash) || methods == true
+              @enabled_patches[k] = methods
+            else
+              raise TypeError.new('Invalid value within the hash passed to Rearmed.enabled_patches=')
+            end
+          else
+            @enabled_patches[k] = {}
+          end
+        end
+      else
+        raise TypeError.new('Invalid value passed to Rearmed.enabled_patches=')
+      end
+    end
   end
 
   def self.enabled_patches
     @enabled_patches
   end
 
+  def self.apply_patches!
+    if @applied 
+      raise ::Rearmed::Exceptions::PatchesAlreadyAppliedError.new
+    else
+      Dir[File.join(__dir__, 'rearmed/monkey_patches/*.rb')].each do |filename| 
+        require filename
+      end
+
+      @applied = true 
+    end
+  end
+
 end

data/lib/rearmed/exceptions.rb

@@ -2,22 +2,28 @@ module Rearmed
   module Exceptions
 
     class BlockFoundError < StandardError
-      def initialize(klass=nil)
+      def initialize
         super("Rearmed doesn't yet support a block on this method.")
       end
     end
 
     class NoArgOrBlockGivenError < StandardError
-      def initialize(klass=nil)
+      def initialize
         super("Must pass an argument or a block.")
       end
     end
 
     class BothArgAndBlockError < StandardError
-      def initialize(klass=nil)
+      def initialize
         super("Arguments and blocks must be used seperately.")
       end
     end
 
+    class PatchesAlreadyAppliedError < StandardError
+      def initialize
+        super("Cannot change or apply patches again after `Rearmed#apply_patches!` has been called.")
+      end
+    end
+
   end
 end

data/lib/rearmed/methods.rb

@@ -1,129 +1,181 @@
 module Rearmed
 
-  def self.casecmp?(str1, str2)
-    if str1.is_a?(String) && str2.is_a?(String)
-      str1.casecmp(str2) == 0
-    end
-  end
-
   def self.dig(collection, *values)
-    current_val = nil
-    current_collection = collection
-    values.each_with_index do |val,i|
-      if i+1 == values.length
-        if (current_collection.is_a?(Array) && val.is_a?(Integer)) || (current_collection.is_a?(Hash) && ['String','Symbol'].include?(val.class.name))
-          current_val = current_collection[val]
-        else
-          current_val = nil
-        end
-      elsif current_collection.is_a?(Array)
-        if val.is_a?(Integer)
-          current_collection = current_collection[val]
-          next
+    if collection.is_a?(::Hash) || collection.is_a?(::Array)
+      current_val = nil
+      current_collection = collection
+      values.each_with_index do |val,i|
+        if i+1 == values.length
+          if (current_collection.is_a?(::Array) && val.is_a?(::Integer)) || (current_collection.is_a?(::Hash) && [::String, ::Symbol].include?(val.class))
+            current_val = current_collection[val]
+          else
+            current_val = nil
+          end
+        elsif current_collection.is_a?(::Array)
+          if val.is_a?(::Integer)
+            current_collection = current_collection[val]
+            next
+          else
+            current_val = nil
+            break
+          end
+        elsif current_collection.is_a?(::Hash)
+          if [::String, ::Symbol].include?(val.class)
+            current_collection = current_collection[val]
+            next
+          else
+            current_val = nil
+            break
+          end
         else
           current_val = nil
-          break
-        end
-      elsif current_collection.is_a?(Hash)
-        if ['Symbol','String'].include?(val.class.name)
-          current_collection = current_collection[val]
-          next
-        else
-          current_val = nil
-          break
+          break 
         end
+      end
+
+      return current_val
+    else
+      raise TypeError.new("Invalid object passed to #{__method__}, must be a Hash or Array")
+    end
+  end
+
+  module Hash
+    def self.compact(hash)
+      if hash.is_a?(::Hash)
+        hash.reject{|_, value| value.nil?}
       else
-        current_val = nil
-        break 
+        raise TypeError.new("Invalid object passed to #{__method__}, must be a Hash")
       end
     end
 
-    return current_val
-  end
+    def self.join(hash, delimiter=', ', &block)
+      if hash.is_a?(::Hash)
+        unless block_given?
+          block = ->(k,v){ "#{k}: #{v}" }
+        end
 
-  def self.hash_compact(hash)
-    hash.reject{|_, value| value.nil?}
-  end
+        str = ""
 
-  def self.hash_join(hash, delimiter=', ', &block)
-    unless block_given?
-      block = ->(k,v){ "#{k}: #{v}" }
-    end
+        hash.each_with_index do |(k,v), i| 
+          val = block.call(k,v)
+          unless val.is_a?(::String)
+            val = val.to_s
+          end
+          str << val
 
-    str = ""
+          if i+1 < hash.length
+            str << delimiter
+          end
+        end
 
-    hash.each_with_index do |(k,v), i| 
-      val = block.call(k,v)
-      unless val.is_a?(String)
-        val = val.to_s
+        return str
+      else
+        raise TypeError.new("Invalid object passed to #{__method__}, must be a Hash")
       end
-      str << val
+    end
 
-      if i+1 < hash.length
-        str << delimiter
+    def self.only(hash, *keys)
+      if hash.is_a?(::Hash)
+        keys.map!{|key| hash.convert_key(key)} if hash.respond_to?(:convert_key, true)
+        keys.each_with_object(hash.class.new){|k, new_hash| new_hash[k] = hash[k] if hash.has_key?(k)}
+      else
+        raise TypeError.new("Invalid object passed to #{__method__}, must be a Hash")
       end
     end
 
-    return str
-  end
-
-  def self.hash_only(hash, *keys)
-    keys.map!{|key| hash.convert_key(key)} if hash.respond_to?(:convert_key, true)
-    keys.each_with_object(hash.class.new){|k, new_hash| new_hash[k] = hash[k] if hash.has_key?(k)}
+    def self.to_struct(hash)
+      if hash.is_a?(::Hash)
+        Struct.new(*hash.keys).new(*hash.values)
+      else
+        raise TypeError.new("Invalid object passed to #{__method__}, must be a Hash")
+      end
+    end
   end
 
-  def self.hash_to_struct(hash)
-    Struct.new(*hash.keys).new(*hash.values)
-  end
+  module Enumerable
+    def self.natural_sort_by(collection)
+      if collection.is_a?(::Enumerable) 
+        collection.sort_by{|x| self._naturalize_str(yield(x))}
+      else
+        raise TypeError.new("Invalid object passed to #{__method__}, must be an Enumerable")
+      end
+    end
 
-  def self.natural_sort_by(collection)
-    collection.sort_by{|x| self.naturalize_str(yield(x))}
-  end
+    def self.natural_sort(collection, options={})
+      if !collection.is_a?(::Enumerable)
+        raise TypeError.new("Invalid object passed to #{__method__}, must be an Enumerable")
+      elsif block_given?
+        Rearmed::Exceptions::BlockFoundError
+      else
+        collection.sort do |a,b| 
+          if options[:reverse] == true
+            self._naturalize_str(b.to_s) <=> self._naturalize_str(a.to_s)
+          else
+            self._naturalize_str(a.to_s) <=> self._naturalize_str(b.to_s)
+          end
+        end
+      end
+    end
 
-  def self.natural_sort(collection, options={})
-    if block_given?
-      Rearmed::Exceptions::BlockFoundError
-    else
-      collection.sort do |a,b| 
-        if options[:reverse] == true
-          self.naturalize_str(b.to_s) <=> self.naturalize_str(a.to_s)
+    def self.select_map(collection)
+      if collection.is_a?(::Enumerable)
+        if block_given?
+          collection.select{|x| yield(x) }.map{|x| yield(x) }
         else
-          self.naturalize_str(a.to_s) <=> self.naturalize_str(b.to_s)
+          collection.select.map
         end
+      else
+        raise TypeError.new("Invalid object passed to #{__method__}, must be an Enumerable")
       end
     end
-  end
 
-  def self.select_map(collection)
-    if block_given?
-      collection.select{|x| yield(x) }.map{|x| yield(x) }
-    else
-      collection.select.map
+    private
+    
+    def self._naturalize_str(str)
+      str.to_s.split(/(\d+)/).map{|a| a =~ /\d+/ ? a.to_i : a}
     end
   end
 
-  def self.to_bool(str)
-    if str =~ /^(true|1|t|T)$/
-      true
-    elsif str =~ /^(false|0|f|F)$/
-      false
-    else
-      nil
+  module String
+    def self.to_bool(str)
+      if str.is_a?(::String)
+        if str =~ /^(true|1|t|T)$/
+          true
+        elsif str =~ /^(false|0|f|F)$/
+          false
+        else
+          nil
+        end
+      else
+        raise TypeError.new("Invalid object passed to #{__method__}, must be a String")
+      end
     end
-  end
 
-  def self.valid_integer?(str)
-    str =~ /^\d*$/ ? true : false
-  end
+    def self.valid_integer?(str)
+      if str.is_a?(::String)
+        str =~ /^\d*$/ ? true : false
+      else
+        raise TypeError.new("Invalid object passed to #{__method__}")
+      end
+    end
 
-  def self.valid_float?(str)
-    str =~ /(^(\d+)(\.)?(\d+)?$)|(^(\d+)?(\.)(\d+)$)/ ? true : false
-  end
+    def self.valid_float?(str)
+      if str.is_a?(::String)
+        str =~ /(^(\d+)(\.)?(\d+)?$)|(^(\d+)?(\.)(\d+)$)/ ? true : false
+      else
+        raise TypeError.new("Invalid object passed to #{__method__}, must be a String")
+      end
+    end
 
-  private
-  
-  def self.naturalize_str(str)
-    str.to_s.split(/(\d+)/).map{|a| a =~ /\d+/ ? a.to_i : a}
+    def self.casecmp?(str1, str2)
+      if str1.is_a?(::String)
+        if str2.is_a?(::String)
+          return str1.casecmp(str2) == 0
+        end
+      else
+        raise TypeError.new("Invalid object passed to #{__method__}, must be a String")
+      end
+    end
   end
 
 end