rearmed_rails 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a4ee0fb7927533d24c1c51d5b336ec748a2594f9
+  data.tar.gz: 137ddb07d7184f254f68948a2d897a4bebe20a69
+SHA512:
+  metadata.gz: 9bbfa3d1aff55e2295264ac940174b29b1bc00f1508a43fa8fb0158d8fd91437e1857b17d66b508b2ee763581debd7952a8af9dfc398c94755270e42d4204765
+  data.tar.gz: a1985d414a13d6bdfec7379480fd4346b345c9e1793fad0a729f58e860a8f47a98b695f60cf766412a52f906da1872cf523cdfeda2eb6be145065192bd006ef4

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+CHANGELOG
+---------
+
+- **1.0.0 - Feb 28, 2017**
+  - Gem Initial Release
+  - Gem was extracted from the `rearmed` gem. https://github.com/westonganger/rearmed-rb

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2017 Weston Ganger
+
+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,146 @@
+# Rearmed Rails
+<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 Rails
+
+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. 
+
+```ruby
+# Gemfile
+
+gem 'rearmed_rails'
+```
+
+Run `rails g rearmed_rails:setup` to create a settings files in `config/initializers/rearmed_rails.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.
+
+```ruby
+# config/initializers/rearmed.rb
+
+RearmedRails.enabled_patches = {
+  rails: {
+    active_record: {
+      find_duplicates: false,
+      find_in_relation_batches: false,
+      find_or_create: false,
+      find_relation_each: false,
+      newest: false,
+      or: false,
+      pluck_to_hash: false,
+      pluck_to_struct: false,
+      reset_auto_increment: false,
+      reset_table: false
+    },
+    helpers: {
+      field_is_array: false,
+      link_to_confirm: false,
+      options_for_select_include_blank: false,
+      options_from_collection_for_select_include_blank: false
+    },
+    v3: {
+      all: false,
+      pluck: false,
+      update_columns: false
+    }
+  },
+  minitest: {
+    assert_changed: false,
+    assert_not_changed: false
+  }
+}
+
+
+require 'rearmed_rails/apply_patches'
+```
+
+
+## Rails
+
+### ActiveRecord
+
+```ruby
+# This version of `or` behaves way nicer than the stupid one that was implemented in Rails 5
+# it allows you to do what you need when you want to. This patch is for Rails 4, 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')
+
+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
+```
+
+Note: All methods which involve deletion are compatible with Paranoia & ActsAsParanoid
+
+### Helpers
+
+```ruby
+# field_is_array: works with field type tag, form_for, simple form, etc
+= text_field_tag :name, is_array: true #=> <input type='text' name='name[]' />
+
+# options_for_select_include_blank
+options_for_select(@users.map{|x| [x.name, x.id]}, include_blank: true, selected: params[:user_id])
+
+# options_from_collection_for_select_include_blank
+options_from_collection_for_select(@users, 'id', 'name', include_blank: true, selected: params[:user_id])
+
+# 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?" 
+```
+
+### 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]]
+```
+
+### 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
+```
+
+# Contributing
+If you want to request a new method please raise an issue and we will discuss the idea. 
+
+
+# Credits
+Created by Weston Ganger - @westonganger
+
+<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> 

data/Rakefile

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + '/lib/rearmed_rails/version.rb')
+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.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'
+
+  require 'irb'
+  binding.irb
+end
+
+task default: :test

data/lib/generators/rearmed_rails/setup_generator.rb

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

data/lib/rearmed_rails/apply_patches.rb

@@ -0,0 +1,6 @@
+require 'rearmed_rails/monkey_patches/rails/active_record/base'
+require 'rearmed_rails/monkey_patches/rails/active_record/batches'
+require 'rearmed_rails/monkey_patches/rails/active_record/query_methods'
+require 'rearmed_rails/monkey_patches/rails/helpers'
+require 'rearmed_rails/monkey_patches/rails/v3'
+require 'rearmed_rails/monkey_patches/minitest'

data/lib/rearmed_rails/default_enabled_patches.hash

@@ -0,0 +1,31 @@
+{
+  rails: {
+    active_record: {
+      find_duplicates: false,
+      find_in_relation_batches: false,
+      find_or_create: false,
+      find_relation_each: false,
+      newest: false,
+      or: false,
+      pluck_to_hash: false,
+      pluck_to_struct: false,
+      reset_auto_increment: false,
+      reset_table: false
+    },
+    helpers: {
+      field_is_array: false,
+      link_to_confirm: false,
+      options_for_select_include_blank: false,
+      options_from_collection_for_select_include_blank: false
+    },
+    v3: {
+      all: false,
+      pluck: false,
+      update_columns: false
+    },
+    minitest: {
+      assert_changed: false,
+      assert_not_changed: false
+    }
+  }
+}

data/lib/rearmed_rails/monkey_patches/minitest.rb

@@ -0,0 +1,35 @@
+if defined?(Minitest::Assertions)
+
+  enabled = RearmedRails.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_rails/monkey_patches/rails/active_record/base.rb

@@ -0,0 +1,216 @@
+enabled = RearmedRails.enabled_patches[:rails] == true
+enabled ||= RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record) == true
+
+if defined?(ActiveRecord)
+
+  ActiveRecord::Base.class_eval do
+    if enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record, :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 || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record, :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 || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record, :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 || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record, :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 || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record, :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 || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record, :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 || enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record, :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 || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record, :pluck_to_hash) || RearmedRails.dig(RearmedRails.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
+
+end

data/lib/rearmed_rails/monkey_patches/rails/active_record/batches.rb

@@ -0,0 +1,60 @@
+enabled = RearmedRails.enabled_patches[:rails] == true
+enabled ||= RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record) == true
+
+if defined?(ActiveRecord::Batches)
+
+  ActiveRecord::Batches.module_eval do
+    if enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record, :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 || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record, :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_rails/monkey_patches/rails/active_record/query_methods.rb

@@ -0,0 +1,101 @@
+enabled = RearmedRails.enabled_patches[:rails] == true
+enabled ||= RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record) == true
+
+if defined?(ActiveRecord)
+
+  if enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record, :or)
+
+    if Rails::VERSION::MAJOR > 4
+
+      module RearmedRails
+        class OrChain
+          def initialize(scope)
+            @scope = scope
+          end
+
+          def method_missing(method, *args, &block)
+            other = @scope.klass.unscoped do
+              @scope.klass.send(method, *args, &block)
+            end
+            return @scope.smart_or(other)
+          end
+        end
+      end
+
+      ActiveRecord::QueryMethods.class_eval do
+        def or(opts=nil, *rest)
+          if opts.nil?
+            return RearmedRails::OrChain.new(self)
+          else
+            other = opts.is_a?(ActiveRecord::Relation) ? opts : klass.unscoped.where(opts, rest)
+
+            self.where_clause = self.where_clause.or(other.where_clause)
+            self.having_clause = self.having_clause.or(other.having_clause)
+
+            return self
+          end
+        end
+      end
+
+    else # rails 4
+
+      module ActiveRecord
+        module Querying
+          delegate :or, to: :all
+        end
+
+        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
+
+          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
+
+          private # 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
+
+end

data/lib/rearmed_rails/monkey_patches/rails/helpers.rb

@@ -0,0 +1,116 @@
+enabled = RearmedRails.enabled_patches[:rails] == true
+enabled ||= RearmedRails.dig(RearmedRails.enabled_patches, :rails, :helpers) == true
+
+if defined?(ActionView::Helpers)
+
+  if enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :helpers, :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 enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :helpers, :field_is_array)
+    module ActionView 
+      module Helpers
+        module Tags
+          class Base
+            private
+
+            original_method = instance_method(:add_default_name_and_id)
+            define_method :add_default_name_and_id  do |options|
+              original_method.bind(self).(options)
+
+              if options['is_array'] && options['name']
+                options['name'] = "#{options['name']}[]"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  module RearmedRails
+    module RailsHelpers
+    end
+  end
+
+  RearmedRails::RailsHelpers.module_eval do
+
+    if enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :helpers, :options_for_select_include_blank)
+      def options_for_select(container, selected = nil)
+        return container if String === container
+
+        if selected.is_a?(Hash)
+          include_blank = selected[:include_blank] || selected['include_blank']
+        end
+
+        selected, disabled = extract_selected_and_disabled(selected).map do |r|
+          Array(r).map(&:to_s)
+        end
+
+        options = []
+
+        if include_blank
+          include_blank = '' if include_blank == true
+          options.push(content_tag_string(:option, include_blank, {value: ''}))
+        end
+
+        container.each do |element|
+          html_attributes = option_html_attributes(element)
+          text, value = option_text_and_value(element).map(&:to_s)
+
+          html_attributes[:selected] ||= option_value_selected?(value, selected)
+          html_attributes[:disabled] ||= disabled && option_value_selected?(value, disabled)
+          html_attributes[:value] = value
+
+          options.push content_tag_string(:option, text, html_attributes)
+        end
+
+        options.join("\n").html_safe
+      end
+    end
+
+    if enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :helpers, :options_from_collection_for_select_include_blank)
+      def options_from_collection_for_select(collection, value_method, text_method, selected = nil)
+        options = collection.map do |element|
+          [value_for_collection(element, text_method), value_for_collection(element, value_method), option_html_attributes(element)]
+        end
+
+        if selected.is_a?(Hash)
+          include_blank = selected[:include_blank] || selected['include_blank']
+        end
+
+        selected, disabled = extract_selected_and_disabled(selected)
+
+        select_deselect = {
+          selected: extract_values_from_collection(collection, value_method, selected),
+          disabled: extract_values_from_collection(collection, value_method, disabled),
+          include_blank: include_blank
+        }
+
+        options_for_select(options, select_deselect)
+      end
+    end
+  end
+
+  ActiveSupport.on_load :action_view do
+    ActionView::Base.send(:include, RearmedRails::RailsHelpers)
+  end
+end

data/lib/rearmed_rails/monkey_patches/rails/v3.rb

@@ -0,0 +1,58 @@
+enabled = RearmedRails.enabled_patches[:rails] == true
+enabled ||= RearmedRails.dig(RearmedRails.enabled_patches, :rails, :v3) == true
+
+if defined?(ActiveRecord) && ActiveRecord::VERSION::MAJOR < 4
+
+  if enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :v3, :all)
+    ActiveRecord::FinderMethods.module_eval do
+      def all(*args)
+        args.any? ? apply_finder_options(args.first) : self
+      end
+    end
+  end
+
+  if enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :v3, :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
+
+  if enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :v3, :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
+
+end

data/lib/rearmed_rails/version.rb

@@ -0,0 +1,3 @@
+module RearmedRails
+  VERSION = "1.0.0"
+end

data/lib/rearmed_rails.rb

@@ -0,0 +1,52 @@
+require 'rearmed_rails/version'
+
+module RearmedRails
+
+  @enabled_patches = eval(File.read(File.join(File.dirname(__FILE__), 'rearmed_rails/default_enabled_patches.hash')))
+
+  def self.enabled_patches=(val)
+    @enabled_patches = val
+  end
+
+  def self.enabled_patches
+    @enabled_patches
+  end
+
+  private
+
+  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
+        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
+        end
+      else
+        current_val = nil
+        break 
+      end
+    end
+
+    return current_val
+  end
+
+end

data/test/tc_rearmed.rb

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby -w
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'yaml'
+require 'minitest'
+
+require 'rearmed_rails'
+
+require 'minitest/autorun'
+
+class TestRearmedRails < MiniTest::Test
+  def setup
+    Minitest::Assertions.module_eval do
+      alias_method :eql, :assert_equal
+    end
+
+    RearmedRails.enabled_patches = {
+      rails: true,
+      minitest: true
+    }
+    require 'rearmed_rails/apply_patches'
+  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

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: rearmed_rails
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Weston Ganger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-02-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A collection of helpful methods and monkey patches for Rails
+email: westonganger@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- lib/generators/rearmed_rails/setup_generator.rb
+- lib/rearmed_rails.rb
+- lib/rearmed_rails/apply_patches.rb
+- lib/rearmed_rails/default_enabled_patches.hash
+- lib/rearmed_rails/monkey_patches/minitest.rb
+- lib/rearmed_rails/monkey_patches/rails/active_record/base.rb
+- lib/rearmed_rails/monkey_patches/rails/active_record/batches.rb
+- lib/rearmed_rails/monkey_patches/rails/active_record/query_methods.rb
+- lib/rearmed_rails/monkey_patches/rails/helpers.rb
+- lib/rearmed_rails/monkey_patches/rails/v3.rb
+- lib/rearmed_rails/version.rb
+- test/tc_rearmed.rb
+homepage: https://github.com/westonganger/rearmed_rails
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: A collection of helpful methods and monkey patches for Rails
+test_files:
+- test/tc_rearmed.rb