rearmed 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d1c1c9a931a133791cfbdacdbfd5ccb01f50234d
-  data.tar.gz: 6daedcedcc902bfed66cad975fbcf99f34724163
+  metadata.gz: 1a547fa7cd7259d77eee0a4707cd1cf9589e9aa2
+  data.tar.gz: a0be2f3e5e61f6c6ffb8da8213bfd9dd7b767b6d
 SHA512:
-  metadata.gz: 00253c513c5b1e4ba17485a1c7e72a2c5070e3e80121d8a612f5c8ebe10f06d04bff262bd117856a9fcffa0f1254e9fc9de5b50074bc61b126333e8a9be42624
-  data.tar.gz: c52b3d027600904d10d8ba89b3d9cb587ab6688c2b0c19a72fdb8b3d4766d177fc0d26d061283240ff86c277a515011bbb8c45c14a1409534492fb18d8aee341
+  metadata.gz: f4fff0c4782edd10fee028e471469fa73ab5f8a0b8c0fa6a91f6debe23a9451e2afe7e45fe09c34ef9c6ad3b38686d5cb5f9fee199108706c6f86766279f429b
+  data.tar.gz: a6ba345629c2076c05c8fd219eddc4c4fe63772ebd683d81f967328759e1a88c1f862b636a27330f34df8dd0c5086901f74d0956ec68a7ce15cb8d98c9697183

data/CHANGELOG.md

@@ -1,6 +1,12 @@
 CHANGELOG
 ---------
 
+- **1.3.0 - Feb 28, 2017**
+  - Remove Rails and Minitest methods. Those methods moved to https://github.com/westonganger/rearmed_rails
+  - Change methods names of Rearmed namespaced hash methods to convey better meaning
+- **1.2.2 - Feb 19, 2017**
+  - Add `field_is_array`, `options_for_select_include_blank`, `options_from_collect_for_select_include_blank`
+  - Namespace rails patches to active_record and other
 - **1.2.1 - Jan 24, 2017**
   - Add Hash `join`, `to_struct`
   - Fix `find_duplicates`

data/README.md

@@ -1,11 +1,13 @@
 # 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 collection of helpful methods and monkey patches for Objects, Strings, Enumerables, Arrays, Hash, Dates, Minitest & Rails (optional)
+A collection of helpful methods and monkey patches for Objects, Strings, Enumerables, Arrays, Hash, Dates
+
+I have recently extracted the Rails and Minitest monkey patches to another gem https://github.com/westonganger/rearmed_rails because the Rails methods are getting quite extensive.
 
 The difference between this library and others is that all monkey patching is performed in an opt-in way because you shouldnt be using methods you dont know about anyways. 
 
-For applicable methods I have placed the implementation inside the Rearmed module so if you don't like monkey patching or are working on the project with a team then you can use these methods instead. You can see how to use this implementation below the relevant methods here in the readme.
+When possible I have placed the method implementations inside the Rearmed module so if you don't like monkey patching or are working on the project with a team then you can use these methods instead. You can then skip the config and see how to use each implementation below the relevant methods documentation.
 
 ```ruby
 # Gemfile
@@ -13,7 +15,9 @@ For applicable methods I have placed the implementation inside the Rearmed modul
 gem 'rearmed'
 ```
 
-Run `rails g rearmed:setup` to create a settings files in `config/initializers/rearmed.rb` where you can opt-in to the monkey patches available in the library. Set these values to true if you want to enable the applicable monkey patch. If your not using Rails then just copy config this into your file and start from there.
+# Usage
+
+## Setup Enabled Monkey Patches (all are optional)
 
 ```ruby
 # config/initializers/rearmed.rb
@@ -49,30 +53,6 @@ Rearmed.enabled_patches = {
     to_bool: false,
     valid_float: false,
     valid_integer: false
-  },
-  minitest: {
-    assert_changed: false,
-    assert_not_changed: false
-  },
-  rails: {
-    find_duplicates: false,
-    find_in_relation_batches: false,
-    find_or_create: false,
-    find_relation_each: false,
-    newest: false,
-    pluck_to_hash: false,
-    pluck_to_struct: false,
-    reset_auto_increment: false,
-    reset_table: false
-  },
-  rails_4: {
-    link_to_confirm: false,
-    or: false
-  },
-  rails_3: {
-    all: false,
-    pluck: false,
-    update_columns: false
   }
 }
 
@@ -80,7 +60,7 @@ Rearmed.enabled_patches = {
 require 'rearmed/apply_patches'
 ```
 
-### Array Methods
+## Array Methods
 ```ruby
 array = [1,2,1,4,1]
 array.delete_first(1) # => 1
@@ -98,7 +78,7 @@ items.dig(0, :foo, 1) # => 'bar'
 # or without monkey patch: Rearmed.dig(items, 0, :foo, 1)
 ```
 
-### Enumerable Methods (Array, Hash, etc.)
+## Enumerable Methods (Array, Hash, etc.)
 ```ruby
 items = ['1.1', '1.11', '1.2']
 items.natural_sort 
@@ -110,42 +90,45 @@ items.natural_sort_by{|x| x[:version]}
 # or without monkey patch: Rearmed.natural_sort_by(items){|x| x[:version]}
 ```
 
-### Date
+## Date
 ```ruby
 Date.now
 ```
 
-### Hash Methods
+## Hash Methods
 ```ruby
-my_hash.compact
-my_hash.compact!
-
 hash.join{|k,v| "#{k}: #{v}\n"}
 
 hash = {foo: 'foo', bar: 'bar', other: 'other'}
 hash.only(:foo, :bar) # => {foo: 'foo'}
-# or without monkey patch: Rearmed.only(hash, :foo, :bar)
+# or without monkey patch: Rearmed.hash_only(hash, :foo, :bar)
 
 hash.only!(:foo, :bar)
 
 hash.to_struct
+# or without monkey patch: Rearmed.hash_to_struct(hash)
 
 # Only available on array and hash in Ruby 2.2.x or below
 items = [{foo: ['foo','bar']}, {test: 'thing'}]
 items.dig(0, :foo, 1) # => 'bar'
 # or without monkey patch: Rearmed.dig(items, 0, :foo, 1)
+
+# Only available on array and hash in Ruby 2.3.x or below
+hash.compact
+# or without monkey patch: Rearmed.hash_compact(hash)
+hash.compact!
 ```
 
-### Object
+## Object
 ```ruby
 my_var.not_nil?
 
-# Only for non-Rails environments, as Rails already has this method
+# In ActiveSupport / Rails this is not patched as this method is already defined there
 my_var.in?([1,2,3])
 my_var.in?(1,2,3) # or with splat arguments
 ```
 
-### String
+## String
 ```ruby
 '123'.valid_integer?
 # or without monkey patch: Rearmed.valid_integer?('123')
@@ -162,87 +145,11 @@ my_var.in?(1,2,3) # or with splat arguments
 'bar'.ends_with?('ar') # => true
 ```
 
-### Minitest Methods
-```ruby
-assert_changed 'user.name' do
-  user.name = "Bob"
-end
-
-assert_not_changed -> { user.name } do
-  user.update(user_params)
-end
-
-assert_not_changed lambda{ user.name } do
-  user.update(user_params)
-end
-```
-
-### Rails
-
-##### Additional ActiveRecord Methods
-Note: All methods which involve deletion are compatible with Paranoia & ActsAsParanoid
-
-```ruby
-Post.pluck_to_hash(:name, :category, :id)
-Post.pluck_to_struct(:name, :category, :id)
-
-Post.find_or_create(name: 'foo', content: 'bar') # use this instead of the super confusing first_or_create method
-Post.find_or_create!(name: 'foo', content: 'bar')
-
-Post.find_duplicates # return active record relation of all records that have duplicates. By default it skips the primary_key, created_at, updated_at, & deleted_at columns
-Post.find_duplicates(:name) # find duplicates based on the name attribute
-Post.find_duplicates(:name, :category) # find duplicates based on the name & category attribute
-Post.find_duplicates(self.column_names.reject{|x| ['id','created_at','updated_at','deleted_at'].include?(x)})
-
-# It also can delete duplicates. Valid values for keep are :first & :last. Valid values for delete_method are :destroy & :delete. soft_delete is only used if you are using acts_as_paranoid on your model.
-Post.find_duplicates(:name, :category, delete: true)
-Post.find_duplicates(:name, :category, delete: {keep: :first, delete_method: :destroy, soft_delete: true}) # these are the default settings for delete: true
-
-Post.newest # get the newest post, by default ordered by :created_at
-Post.newest(:updated_at) # different sort order
-Post.newest(:published_at, :created_at) # multiple columns to sort on
-
-Post.reset_table # delete all records from table and reset autoincrement column (id), works with mysql/mariadb/postgresql/sqlite
-# or with options
-Post.reset_table(delete_method: :destroy) # to ensure all callbacks are fired
-
-Post.reset_auto_increment # reset mysql/mariadb/postgresql/sqlite auto-increment column, if contains records then defaults to starting from next available number
-# or with options
-Post.reset_auto_increment(value: 1, column: :id) # column option is only relevant for postgresql
-
-Post.find_in_relation_batches # this returns a relation instead of an array
-Post.find_relation_each # this returns a relation instead of an array
-```
-
-##### Rails 4.x Backports
-```ruby
-# returns to rails 3 behaviour of allowing confirm attribute as well as data-confirm
-= link_to 'Delete', post_path(post), method: :delete, confirm: "Are you sure you want to delete this post?" 
-
-# This version of `or` behaves way nicer than the one implemented in Rails 5, it allows you to do what you need. 
-# However this patch does not work in Rails 5+
-Post.where(name: 'foo').or.where(content: 'bar')
-Post.where(name: 'foo').or.my_custom_scope
-Post.where(name: 'foo').or(Post.where(content: 'bar'))
-Post.where(name: 'foo).or(content: 'bar')
-```
-
-##### Rails 3.x Backports
-```ruby
-Post.all # Now returns AR relation
-Post.first.update_columns(a: 'foo', b: 'bar')
-Post.pluck(:name, :id) # adds multi column pluck support ex. => [['first', 1], ['second', 2], ['third', 3]]
-
-my_hash.compact # See Hash methods above
-my_hash.compact!
-```
-
 # 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:
 
-- Add Tests for Rails methods
 - Get the `natural_sort` method to accept a block
 
 

data/lib/rearmed/apply_patches.rb

@@ -3,8 +3,4 @@ require 'rearmed/monkey_patches/string'
 require 'rearmed/monkey_patches/array'
 require 'rearmed/monkey_patches/hash'
 require 'rearmed/monkey_patches/enumerable'
-require 'rearmed/monkey_patches/rails'
-require 'rearmed/monkey_patches/rails_3'
-require 'rearmed/monkey_patches/rails_4'
 require 'rearmed/monkey_patches/date'
-require 'rearmed/monkey_patches/minitest'

data/lib/rearmed/default_enabled_patches.hash

@@ -35,15 +35,22 @@
     assert_not_changed: false
   },
   rails: {
-    find_duplicates: false,
-    find_in_relation_batches: false,
-    find_or_create: false,
-    find_relation_each: false,
-    newest: false,
-    pluck_to_hash: false,
-    pluck_to_struct: false,
-    reset_auto_increment: false,
-    reset_table: false
+    active_record: {
+      find_duplicates: false,
+      find_in_relation_batches: false,
+      find_or_create: false,
+      find_relation_each: false,
+      newest: false,
+      pluck_to_hash: false,
+      pluck_to_struct: false,
+      reset_auto_increment: false,
+      reset_table: false
+    },
+    other: {
+      field_is_array: false,
+      options_for_select_include_blank: false,
+      options_from_collection_for_select_include_blank: false
+    }
   },
   rails_4: {
     link_to_confirm: false,

data/lib/rearmed/methods.rb

@@ -35,7 +35,7 @@ module Rearmed
     return current_val
   end
 
-  def self.join(hash, delimiter=', ', &block)
+  def self.hash_join(hash, delimiter=', ', &block)
     unless block_given?
       block = -> (k,v) {
         "#{k}: #{v}"
@@ -76,8 +76,12 @@ module Rearmed
       end
     end
   end
+  
+  def self.hash_compact(hash)
+    hash.reject{|_, value| value.nil?}
+  end
 
-  def self.only(hash, *keys)
+  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)}
   end
@@ -100,6 +104,10 @@ module Rearmed
     str =~ /(^(\d+)(\.)?(\d+)?$)|(^(\d+)?(\.)(\d+)$)/ ? true : false
   end
 
+  def self.hash_to_struct(hash)
+    Struct.new(*hash.keys).new(*hash.values)
+  end
+
   private
   
   def self.naturalize_str(str)

data/lib/rearmed/monkey_patches/array.rb

@@ -21,7 +21,7 @@ Array.module_eval do
     end
   end
 
-  if RUBY_VERSION.to_f < 2.3 && array_enabled || Rearmed.dig(Rearmed.enabled_patches, :array, :dig)
+  if ![].respond_to?(:dig) && (array_enabled || Rearmed.dig(Rearmed.enabled_patches, :array, :dig))
     def dig(*args)
       Rearmed.dig(self, *args)
     end

data/lib/rearmed/monkey_patches/hash.rb

@@ -1,10 +1,9 @@
 hash_enabled = Rearmed.enabled_patches[:hash] == true
 
 Hash.class_eval do
-  allowed = defined?(ActiveSupport) ? (ActiveSupport::VERSION::MAJOR > 3) : true
-  if allowed && (hash_enabled || Rearmed.dig(Rearmed.enabled_patches, :hash, :compact))
+  if !{}.respond_to?(:compact) && (hash_enabled || Rearmed.dig(Rearmed.enabled_patches, :hash, :compact))
     def compact
-      self.select{|_, value| !value.nil?}
+      Rearmed.hash_compact(self)
     end
 
     def compact!
@@ -12,7 +11,7 @@ Hash.class_eval do
     end
   end
 
-  if RUBY_VERSION.to_f < 2.3 && hash_enabled || Rearmed.dig(Rearmed.enabled_patches, :hash, :dig)
+  if !{}.respond_to?(:dig) && (hash_enabled || Rearmed.dig(Rearmed.enabled_patches, :hash, :dig))
     def dig(*args)
       Rearmed.dig(self, *args)
     end
@@ -21,16 +20,16 @@ Hash.class_eval do
   if hash_enabled || Rearmed.dig(Rearmed.enabled_patches, :hash, :join)
     def join(delimiter=', ', &block)
       if block_given?
-        Rearmed.join(self, delimiter, &block)
+        Rearmed.hash_join(self, delimiter, &block)
       else
-        Rearmed.join(self, delimiter)
+        Rearmed.hash_join(self, delimiter)
       end
     end
   end
 
   if hash_enabled || Rearmed.dig(Rearmed.enabled_patches, :hash, :only)
     def only(*keys)
-      Rearmed.only(self, *keys)
+      Rearmed.hash_only(self, *keys)
     end
 
     def only!(*keys)
@@ -44,7 +43,7 @@ Hash.class_eval do
 
   if hash_enabled || Rearmed.dig(Rearmed.enabled_patches, :hash, :to_struct)
     def to_struct
-      Struct.new(*keys).new(*values)
+      Rearmed.hash_to_struct(self)
     end
   end
 end

data/lib/rearmed/monkey_patches/object.rb

@@ -7,7 +7,7 @@ Object.class_eval do
     end
   end
 
-  if !defined?(ActiveSupport) && (object_enabled || Rearmed.dig(Rearmed.enabled_patches, :object, :in))
+  if !Object.new.respond_to?(:in?) && (object_enabled || Rearmed.dig(Rearmed.enabled_patches, :object, :in))
     def in?(array, *more)
       if !more.empty?
         array = [array, *more]

data/lib/rearmed/version.rb

@@ -1,3 +1,3 @@
 module Rearmed
-  VERSION = "1.2.1"
+  VERSION = "1.3.0"
 end

data/test/tc_rearmed.rb

@@ -58,10 +58,9 @@ class TestRearmed < MiniTest::Test
     eql(str.to_bool, false)
 
     str = 'not true'
-    eql(str.to_bool, nil)
+    assert_nil(str.to_bool)
 
 
-    # Test Rearmed methods (just cause really)
     str = 'true'
     eql(Rearmed.to_bool(str), true)
 
@@ -99,10 +98,10 @@ class TestRearmed < MiniTest::Test
     array = [{foo: ['foo','bar']}, {test: 'thing'}]
 
     eql(array.dig(0, :foo, 1), 'bar')
-    eql(array.dig(0, :foo, 2), nil)
+    assert_nil(array.dig(0, :foo, 2))
 
     eql(Rearmed.dig(array, 1, :test), 'thing')
-    eql(Rearmed.dig(array, 1, :bar), nil)
+    assert_nil(Rearmed.dig(array, 1, :bar))
 
     hash = {a: {foo: ['bar']}, b: {c: 'c'}}
     
@@ -135,10 +134,11 @@ class TestRearmed < MiniTest::Test
     eql(hash, {foo: 'foo', bar: 'bar'})
 
     hash = {foo: 'foo', bar: 'bar', other: 'other'}
-    eql(Rearmed.only(hash, :foo, :bar), {foo: 'foo', bar: 'bar'})
+    eql(Rearmed.hash_only(hash, :foo, :bar), {foo: 'foo', bar: 'bar'})
 
     hash = {foo: nil, bar: nil, other: 'other'}
     eql(hash.compact, {other: 'other'})
+    eql(Rearmed.hash_compact(hash), {other: 'other'})
 
     hash = {foo: nil, bar: nil, other: 'other'}
     hash.compact!
@@ -149,16 +149,21 @@ class TestRearmed < MiniTest::Test
     eql(hash.join('___'), "foo: bar___bar: foo")
     eql(hash.join{|k,v| v}, "bar, foo")
     eql(hash.join('___'){|k,v| v}, "bar___foo")
-    eql(Rearmed.join(hash), "foo: bar, bar: foo")
-    eql(Rearmed.join(hash, '___'), "foo: bar___bar: foo")
-    eql(Rearmed.join(hash){|k,v| v}, "bar, foo")
-    eql(Rearmed.join(hash, '___'){|k,v| v}, "bar___foo")
+    eql(Rearmed.hash_join(hash), "foo: bar, bar: foo")
+    eql(Rearmed.hash_join(hash, '___'), "foo: bar___bar: foo")
+    eql(Rearmed.hash_join(hash){|k,v| v}, "bar, foo")
+    eql(Rearmed.hash_join(hash, '___'){|k,v| v}, "bar___foo")
 
     hash = {foo: :bar, bar: 'foo'}
     struct = hash.to_struct
     assert(struct.is_a?(Struct))
     eql(struct.foo, :bar)
     eql(struct.bar, 'foo')
+
+    struct = Rearmed.hash_to_struct(hash)
+    assert(struct.is_a?(Struct))
+    eql(struct.foo, :bar)
+    eql(struct.bar, 'foo')
   end
 
   def test_object
@@ -190,79 +195,4 @@ class TestRearmed < MiniTest::Test
     eql(str.in?('a real string'), false)
   end
 
-  def test_minitest
-    str = 'first'
-    assert_changed "str" do
-      str = 'second'
-    end
-
-    str = 'first'
-    assert_changed ->{ str } do
-      str = 'second'
-    end
-
-    name = 'first'
-    assert_changed lambda{ name } do
-      name = 'second'
-    end
-
-    name = 'first'
-    assert_not_changed 'name' do
-      name = 'first'
-    end
-
-    name = 'first'
-    assert_not_changed ->{ name } do
-      name = 'first'
-    end
-
-    name = 'first'
-    assert_not_changed lambda{ name } do
-      name = 'first'
-    end
-  end
-
-  def test_general_rails
-    # THE MOST IMPORTANT TESTS HERE WOULD BE dedupe, reset_auto_increment, reset_table
-    
-    #Post.pluck_to_hash(:name, :category, :id)
-    #Post.pluck_to_struct(:name, :category, :id)
-
-    #Post.find_or_create(name: 'foo', content: 'bar') # use this instead of the super confusing first_or_create method
-    #Post.find_or_create!(name: 'foo', content: 'bar')
-
-    #Post.find_duplicates # return active record relation of all records that have duplicates
-    #Post.find_duplicates(:name) # find duplicates based on the name attribute
-    #Post.find_duplicates([:name, :category]) # find duplicates based on the name & category attribute
-    #Post.find_duplicates(name: 'A Specific Name')
-
-    #Post.reset_table # delete all records from table and reset autoincrement column (id), works with mysql/mariadb/postgresql/sqlite
-    ## or with options
-    #Post.reset_table(delete_method: :destroy) # to ensure all callbacks are fired
-
-    #Post.reset_auto_increment # reset mysql/mariadb/postgresql/sqlite auto-increment column, if contains records then defaults to starting from next available number
-    ## or with options
-    #Post.reset_auto_increment(value: 1, column: :id) # column option is only relevant for postgresql
-
-    #Post.find_in_relation_batches # this returns a relation instead of an array
-    #Post.find_relation_each # this returns a relation instead of an array
-  end
-
-  def test_rails_3
-    #my_hash.compact
-    #my_hash.compact!
-    #Post.all # Now returns AR relation
-    #Post.first.update_columns(a: 'foo', b: 'bar')
-    #Post.pluck(:name, :id) # adds multi column pluck support ex. => [['first', 1], ['second', 2], ['third', 3]]
-  end
-
-  def test_rails_4
-    #Post.where(name: 'foo').or.where(content: 'bar')
-    #Post.where(name: 'foo').or.my_custom_scope
-    #Post.where(name: 'foo').or(Post.where(content: 'bar'))
-    #Post.where(name: 'foo).or(content: 'bar')
-
-    #= link_to 'Delete', post_path(post), method: :delete, confirm: "Are you sure you want to delete this post?" 
-    # returns to rails 3 behaviour of allowing confirm attribute as well as data-confirm
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rearmed
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Weston Ganger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-24 00:00:00.000000000 Z
+date: 2017-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -63,7 +63,6 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- lib/generators/rearmed/setup_generator.rb
 - lib/rearmed.rb
 - lib/rearmed/apply_patches.rb
 - lib/rearmed/default_enabled_patches.hash
@@ -73,11 +72,7 @@ files:
 - lib/rearmed/monkey_patches/date.rb
 - lib/rearmed/monkey_patches/enumerable.rb
 - lib/rearmed/monkey_patches/hash.rb
-- lib/rearmed/monkey_patches/minitest.rb
 - lib/rearmed/monkey_patches/object.rb
-- lib/rearmed/monkey_patches/rails.rb
-- lib/rearmed/monkey_patches/rails_3.rb
-- lib/rearmed/monkey_patches/rails_4.rb
 - lib/rearmed/monkey_patches/string.rb
 - lib/rearmed/version.rb
 - test/tc_rearmed.rb

data/lib/generators/rearmed/setup_generator.rb

@@ -1,15 +0,0 @@
-require 'rails/generators'
-
-module Rearmed
-  class SetupGenerator < Rails::Generators::Base
-
-    def setup
-      create_file "config/initializers/rearmed.rb", <<eos
-Rearmed.enabled_patches = #{File.read(File.join(File.dirname(__FILE__), '../../rearmed/default_enabled_patches.hash'))}
-
-require 'rearmed/apply_patches'
-eos
-    end
-
-  end
-end

data/lib/rearmed/monkey_patches/minitest.rb

@@ -1,35 +0,0 @@
-if defined?(Minitest::Assertions)
-
-  enabled = Rearmed.enabled_patches[:minitest] == true
-
-  Minitest::Assertions.module_eval do
-
-    if enabled || Rearmed.dig(Rearmed.enabled_patches, :minitest, :assert_changed)
-      def assert_changed(expression, &block)
-        if expression.respond_to?(:call)
-          e = expression
-        else
-          e = lambda{ block.binding.eval(expression) }
-        end
-        old = e.call
-        block.call
-        refute_equal old, e.call
-      end
-    end
-
-    if enabled || Rearmed.dig(Rearmed.enabled_patches, :minitest, :assert_not_changed)
-      def assert_not_changed(expression, &block)
-        if expression.respond_to?(:call)
-          e = expression
-        else
-          e = lambda{ block.binding.eval(expression) }
-        end
-        old = e.call
-        block.call
-        assert_equal old, e.call
-      end
-    end
-
-  end
-
-end

data/lib/rearmed/monkey_patches/rails.rb

@@ -1,268 +0,0 @@
-enabled = Rearmed.enabled_patches[:rails] == true
-
-if defined?(ActiveRecord)
-
-  ActiveRecord::Base.class_eval do
-    if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails, :newest)
-      def self.newest(*columns)
-        if columns.empty? || !columns.to_s.include?('created_at')
-          columns << 'created_at'
-        end
-
-        the_order = {}
-        columns.each do |x|
-          the_order[x.to_s] = :desc
-        end
-        self.order(the_order).limit(1).first
-      end
-    end
-
-    if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails, :reset_table)
-      def self.reset_table(opts={})
-        if opts[:delete_method] && opts[:delete_method].to_sym == :destroy
-          if self.try(:paranoid?)
-            self.unscoped.each do |x|
-              if x.respond_to?(:really_destroy!)
-                x.really_destroy!
-              else
-                x.destroy!
-              end
-            end
-          else
-            self.unscoped.destroy_all
-          end
-        end
-
-        case self.connection.adapter_name.downcase.to_sym
-        when :mysql2
-          if !opts[:delete_method] || opts[:delete_method].to_sym != :destroy
-            if defined?(ActsAsParanoid) && self.try(:paranoid?)
-              self.unscoped.delete_all!
-            else
-              self.unscoped.delete_all
-            end
-          end
-          self.connection.execute("ALTER TABLE #{self.table_name} AUTO_INCREMENT = 1")
-        when :postgresql
-          self.connection.execute("TRUNCATE TABLE #{self.table_name} RESTART IDENTITY")
-        when :sqlite3
-          self.connection.execute("DELETE FROM #{self.table_name}")
-          self.connection.execute("DELETE FROM sqlite_sequence WHERE NAME='#{self.table_name}'")
-        end
-      end
-    end
-
-    if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails, :reset_auto_increment)
-      def self.reset_auto_increment(opts={})
-        case self.connection.adapter_name.downcase.to_sym
-        when :mysql2
-          opts[:value] = 1 if opts[:value].blank?
-          self.connection.execute("ALTER TABLE #{self.table_name} AUTO_INCREMENT = #{opts[:value]}")
-        when :postgresql
-          opts[:value] = 1 if opts[:value].blank?
-          self.connection.execute("ALTER SEQUENCE #{self.table_name}_#{opts[:column].to_s || self.primary_key}_seq RESTART WITH #{opts[:value]}")
-        when :sqlite3
-          opts[:value] = 0 if opts[:value].blank?
-          self.connection.execute("UPDATE SQLITE_SEQUENCE SET SEQ=#{opts[:value]} WHERE NAME='#{self.table_name}'")
-        end
-      end
-    end
-
-    if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails, :find_duplicates)
-      def self.find_duplicates(*args)
-        options = {}
-
-        unless args.empty?
-          if args.last.is_a?(Hash)
-            options = args.pop
-          end
-
-          unless args.empty?
-            if args.count == 1 && args.first.is_a?(Array)
-              args = args.first
-            end
-
-            options[:columns] = args
-          end
-        end
-        
-        options[:columns] ||= self.column_names.reject{|x| [self.primary_key, :created_at, :updated_at, :deleted_at].include?(x)}
-
-        duplicates = self.select("#{options[:columns].join(', ')}, COUNT(*)").group(options[:columns]).having("COUNT(*) > 1")
-
-        if options[:delete]
-          if options[:delete] == true
-            options[:delete] = {keep: :first, delete_method: :destroy, soft_delete: true}
-          else
-            options[:delete][:delete_method] ||= :destroy
-            options[:delete][:keep] ||= :first
-            if options[:delete][:soft_delete] != false
-              options[:delete][:soft_delete] = true
-            end
-          end
-
-          if options[:delete][:keep] == :last
-            duplicates.reverse!
-          end
-
-          used  = []
-          duplicates.reject! do |x| 
-            attrs = x.attributes.slice(*options[:columns].collect(&:to_s))
-
-            if used.include?(attrs)
-              return false
-            else
-              used.push attrs
-              return true
-            end
-          end
-          used = nil
-
-          if options[:delete][:delete_method].to_sym == :delete
-            duplicates = self.where(id: duplicates.collect(&:id))
-
-            if x.respond_to?(:delete_all!)
-              duplicates.delete_all!
-            else
-              duplicates.delete_all
-            end
-          else
-            duplicates.each do |x|
-              if !options[:delete][:soft_delete] && x.respond_to?(:really_destroy!)
-                x.really_destroy!
-              else
-                x.destroy!
-              end
-            end
-          end
-          return nil
-        else
-          return duplicates
-        end
-      end
-    end
-
-    if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails, :find_or_create)
-      def self.find_or_create(attrs={}, save_opts={})
-        unless self.where(attrs).limit(1).first
-          x = self.class.new(attrs)
-          x.save(save_opts)
-          return t
-        end
-      end
-
-      def self.find_or_create!(attrs={}, save_opts={})
-        unless self.where(attrs).limit(1).first
-          x = self.class.new(attrs)
-          x.save!(save_opts)
-          return t
-        end
-      end
-    end
-
-    if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails, :pluck_to_hash)
-      def self.pluck_to_hash(*keys)
-        hash_type = keys[-1].is_a?(Hash) ? keys.pop.fetch(:hash_type, HashWithIndifferentAccess) : HashWithIndifferentAccess
-        block_given = block_given?
-        keys, formatted_keys = format_keys(keys)
-        keys_one = keys.size == 1
-
-        pluck(*keys).map do |row|
-          value = hash_type[formatted_keys.zip(keys_one ? [row] : row)]
-          block_given ? yield(value) : value
-        end
-      end
-    end
-
-    if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails, :pluck_to_struct)
-      def self.pluck_to_struct(*keys)
-        struct_type = keys[-1].is_a?(Hash) ? keys.pop.fetch(:struct_type, Struct) : Struct
-        block_given = block_given?
-        keys, formatted_keys = format_keys(keys)
-        keys_one = keys.size == 1
-
-        struct = struct_type.new(*formatted_keys)
-        pluck(*keys).map do |row|
-          value = keys_one ? struct.new(*[row]) : struct.new(*row)
-          block_given ? yield(value) : value
-        end
-      end
-    end
-
-    private
-
-    if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails, :pluck_to_hash) || Rearmed.dig(Rearmed.enabled_patches, :rails, :pluck_to_struct)
-      def self.format_keys(keys)
-        if keys.blank?
-          [column_names, column_names]
-        else
-          [
-            keys,
-            keys.map do |k|
-              case k
-              when String
-                k.split(/\bas\b/i)[-1].strip.to_sym
-              when Symbol
-                k
-              end
-            end
-          ]
-        end
-      end
-    end
-  end
-
-  ActiveRecord::Batches.module_eval do
-    if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails, :find_in_relation_batches)
-      def find_in_relation_batches(options = {})
-        options.assert_valid_keys(:start, :batch_size)
-
-        relation = self
-        start = options[:start]
-        batch_size = options[:batch_size] || 1000
-
-        unless block_given?
-          return to_enum(:find_in_relation_batches, options) do
-            total = start ? where(table[primary_key].gteq(start)).size : size
-            (total - 1).div(batch_size) + 1
-          end
-        end
-
-        if logger && (arel.orders.present? || arel.taken.present?)
-          logger.warn("Scoped order and limit are ignored, it's forced to be batch order and batch size")
-        end
-
-        relation = relation.reorder(batch_order).limit(batch_size)
-        #records = start ? relation.where(table[primary_key].gteq(start)).to_a : relation.to_a
-        records = start ? relation.where(table[primary_key].gteq(start)) : relation
-
-        while records.any?
-          records_size = records.size
-          primary_key_offset = records.last.id
-          raise ActiveRecordError, "Primary key not included in the custom select clause" unless primary_key_offset
-
-          yield records
-
-          break if records_size < batch_size
-
-          records = relation.where(table[primary_key].gt(primary_key_offset))#.to_a
-        end
-      end
-    end
-
-    if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails, :find_relation_each)
-      def find_relation_each(options = {})
-        if block_given?
-          find_in_relation_batches(options) do |records|
-            records.each { |record| yield record }
-          end
-        else
-          enum_for :find_relation_each, options do
-            options[:start] ? where(table[primary_key].gteq(options[:start])).size : size
-          end
-        end
-      end
-    end
-  end
-
-end

data/lib/rearmed/monkey_patches/rails_3.rb

@@ -1,57 +0,0 @@
-enabled = Rearmed.enabled_patches[:rails_3] == true
-
-if defined?(ActiveRecord) && ActiveRecord::VERSION::MAJOR < 4
-
-  if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails_3, :all)
-    ActiveRecord::FinderMethods.module_eval do
-      def all(*args)
-        args.any? ? apply_finder_options(args.first) : self
-      end
-    end
-  end
-
-  if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails_3, :update_columns)
-    ActiveRecord::Persistence::ClassMethods.module_eval do
-      def update_columns(attributes)
-        raise ActiveRecordError, "cannot update a new record" if new_record?
-        raise ActiveRecordError, "cannot update a destroyed record" if destroyed?
-
-        attributes.each_key do |key|
-          raise ActiveRecordError, "#{key.to_s} is marked as readonly" if self.class.readonly_attributes.include?(key.to_s)
-        end
-
-        updated_count = self.class.unscoped.where(self.class.primary_key => id).update_all(attributes)
-
-        attributes.each do |k, v|
-          raw_write_attribute(k, v)
-        end
-
-        updated_count == 1
-      end
-    end
-  end
-
-  if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails_3, :pluck)
-    ActiveRecord::Relation.class_eval do
-      def pluck(*args)
-        args.map! do |column_name|
-          if column_name.is_a?(Symbol) && column_names.include?(column_name.to_s)
-            "#{connection.quote_table_name(table_name)}.#{connection.quote_column_name(column_name)}"
-          else
-            column_name.to_s
-          end
-        end
-
-        relation = clone
-        relation.select_values = args
-        klass.connection.select_all(relation.arel).map! do |attributes|
-          initialized_attributes = klass.initialize_attributes(attributes)
-          attributes.map do |key, attr|
-            klass.type_cast_attribute(key, initialized_attributes)
-          end
-        end
-      end
-    end
-  end
-
-end

data/lib/rearmed/monkey_patches/rails_4.rb

@@ -1,143 +0,0 @@
-enabled = Rearmed.enabled_patches[:rails_4] == true
-
-if defined?(ActionView) && enabled || Rearmed.dig(Rearmed.enabled_patches, :rails_4, :link_to_confirm)
-  ActionView::Helpers::UrlHelper.module_eval do
-    def convert_options_to_data_attributes(options, html_options)
-      if html_options
-        html_options = html_options.stringify_keys
-        html_options['data-remote'] = 'true' if link_to_remote_options?(options) || link_to_remote_options?(html_options)
-
-        method  = html_options.delete('method')
-        add_method_to_attributes!(html_options, method) if method
-        
-        ### CUSTOM - behave like Rails 3.2
-        confirm  = html_options.delete('confirm')
-        html_options['data-confirm'] = confirm if confirm
-
-        html_options
-      else
-        link_to_remote_options?(options) ? {'data-remote' => 'true'} : {}
-      end
-    end
-  end 
-end
-
-if defined?(ActiveRecord)
-
-  ActiveRecord::Batches.module_eval do
-    if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails_4, :find_in_relation_batches)
-      def find_in_relation_batches(options = {})
-        options.assert_valid_keys(:start, :batch_size)
-
-        relation = self
-        start = options[:start]
-        batch_size = options[:batch_size] || 1000
-
-        unless block_given?
-          return to_enum(:find_in_relation_batches, options) do
-            total = start ? where(table[primary_key].gteq(start)).size : size
-            (total - 1).div(batch_size) + 1
-          end
-        end
-
-        if logger && (arel.orders.present? || arel.taken.present?)
-          logger.warn("Scoped order and limit are ignored, it's forced to be batch order and batch size")
-        end
-
-        relation = relation.reorder(batch_order).limit(batch_size)
-        #records = start ? relation.where(table[primary_key].gteq(start)).to_a : relation.to_a
-        records = start ? relation.where(table[primary_key].gteq(start)) : relation
-
-        while records.any?
-          records_size = records.size
-          primary_key_offset = records.last.id
-          raise ActiveRecordError, "Primary key not included in the custom select clause" unless primary_key_offset
-
-          yield records
-
-          break if records_size < batch_size
-
-          records = relation.where(table[primary_key].gt(primary_key_offset))#.to_a
-        end
-      end
-    end
-
-    if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails_4, :find_relation_each)
-      def find_relation_each(options = {})
-        if block_given?
-          find_in_relation_batches(options) do |records|
-            records.each { |record| yield record }
-          end
-        else
-          enum_for :find_relation_each, options do
-            options[:start] ? where(table[primary_key].gteq(options[:start])).size : size
-          end
-        end
-      end
-    end
-  end
-
-
-  if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails_4, :or)
-    module ActiveRecord
-      module Querying
-        delegate :or, :to => :all
-      end
-    end
-
-    module ActiveRecord
-      module QueryMethods
-        class OrChain
-          def initialize(scope)
-            @scope = scope
-          end
-
-          def method_missing(method, *args, &block)
-            right_relation = @scope.klass.unscoped do
-              @scope.klass.send(method, *args, &block)
-            end
-            @scope.or(right_relation)
-          end
-        end
-
-        # Post.where("id = 1").or.where("id = 2")
-        # Post.where("id = 1").or.containing_the_letter_a
-        # Post.where("id = 1").or(Post.where("id = 2"))
-        # Post.where("id = 1").or("id = ?", 2)
-        def or(opts = :chain, *rest)
-          if opts == :chain
-            OrChain.new(self)
-          else
-            left = self
-            right = (ActiveRecord::Relation === opts) ? opts : klass.unscoped.where(opts, rest)
-
-            unless left.where_values.empty? || right.where_values.empty?
-              left.where_values = [left.where_ast.or(right.where_ast)]
-              right.where_values = []
-            end
-
-            left = left.merge(right)
-          end
-        end
-
-        # Returns an Arel AST containing only where_values
-        def where_ast
-          arel_wheres = []
-
-          where_values.each do |where|
-            arel_wheres << (String === where ? Arel.sql(where) : where)
-          end
-
-          return Arel::Nodes::Grouping.new(Arel::Nodes::And.new(arel_wheres)) if arel_wheres.length >= 2
-
-          if Arel::Nodes::SqlLiteral === arel_wheres.first
-            Arel::Nodes::Grouping.new(arel_wheres.first)
-          else
-            arel_wheres.first
-          end
-        end
-      end
-    end
-  end
-
-end