rearmed_rails 1.0.5 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5d2e1474fe0711ea54cf256d3954b9254c4e8e01
-  data.tar.gz: 26d6c3cb7c20f65d5568019d4be2c4335af2dabe
+SHA256:
+  metadata.gz: 66bf5b7b6b2a6f6cfb1697c7a05edfc21dbb27d3f3bf38ffce810fc5f2ea2b21
+  data.tar.gz: 5f96d7b7582e51ec05b74da7f85bc18f1eebb5f07a73a09e2375dc4fec928570
 SHA512:
-  metadata.gz: 461717a406c59c914ad5f66fa2955efb0678aaf8926a315d733a41f134f40dfaab46433f3a923beec00dc947b626ccd2aa1def8bdfb1f841033af074f6105547
-  data.tar.gz: aa3ce67201167bf2ba223043118fb992db82300c277c021ca14c87d76b3f90daa6aaed0ef19d5200aa63afe935a1581afb06df69efb24a3c4851968806ef829b
+  metadata.gz: 5153c73e99edd5ee9f010babbd24eed05640a6ba538fb3991083ec9130c6979c447763fd39cf289e9bdefedb1ae6a908aaada86f0beedecb15dc108d57fb513f
+  data.tar.gz: deca81c0c5c8f2c5226ab2f9d2d82abaebd8eea3d3cfac87fd8c85c54e6dee572db8f5b89073bb0e7e7877d805dea890cedb2e799b758647ba760778f6a28215

data/CHANGELOG.md

@@ -1,6 +1,15 @@
 CHANGELOG
 ---------
 
+- **2.0.0 - July 11, 2018**
+  - Change method of applying patches from `require 'rearmed_rails/apply_patches'` to `RearmedRails#apply_patches!`
+  - Once `apply_patches!` has been called, then `enabled_patches` cannot be changed. If it is, it will raise a `PatchesAlreadyAppliedError`
+  - Allow setting `:all` for `Rearmed#enabled_patches=`
+  - Add type checking to `Rearmed#enabled_patches=`
+  - Remove support for Rails 3
+  - Remove and Extract minitest methods to new gem `minitest-changed-assertions`
+  - Remove `ActiveRecord#or` method as it does not always return correct results. Instead use this gem https://github.com/khiav223577/rails_or
+  - Remove `ActiveRecord#find_in_relation_batches` and `ActiveRecord#find_relation_each` methods. The reason I implemented these methods was to improve some performance issues I was having. After used this and then later trying some other techniques I can confirm this is a poor technique to improve performance. Therefore I am removing these methods.
 - **1.0.5 - August 3, 2017**
   - Fix `options_for_select_include_blank` & `options_for_select_include_blank` for Rails 5.1+ and improved them to patch in safer way
 - **1.0.4 - July 19, 2017**

data/README.md

@@ -1,9 +1,14 @@
 # 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 href="https://badge.fury.io/rb/rearmed_rails" target="_blank"><img height="21" style='border:0px;height:21px;' border='0' src="https://badge.fury.io/rb/rearmed_rails.svg" alt="Gem Version"></a>
+<a href='https://travis-ci.org/westonganger/rearmed_rails' target='_blank'><img height='21' style='border:0px;height:21px;' src='https://api.travis-ci.org/westonganger/rearmed_rails.svg?branch=master' border='0' alt='Build Status' /></a>
+<a href='https://rubygems.org/gems/rearmed_rails' 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 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. 
+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 that you dont know about.
 
 ```ruby
 # Gemfile
@@ -17,73 +22,59 @@ Run `rails g rearmed_rails:setup` to create a settings files in `config/initiali
 # 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
-    }
+    find_duplicates: false,
+    find_or_create: false,
+    newest: false,
+    pluck_to_hash: false,
+    pluck_to_struct: false,
+    reset_auto_increment: false,
+    reset_table: false
   },
-  minitest: {
-    assert_changed: false,
-    assert_not_changed: false
+  helpers: {
+    field_is_array: false,
+    link_to_confirm: false,
+    options_for_select_include_blank: false,
+    options_from_collection_for_select_include_blank: false
   }
 }
 
+RearmedRails.apply_patches!
+```
+
+Some other argument formats the `enabled_patches` option accepts are:
+
+```ruby
+### Enable everything
+Rearmed.enabled_patches = :all
+
+### Disable everything
+Rearmed.enabled_patches = nil
 
-require 'rearmed_rails/apply_patches'
+### Hash values can be boolean/nil values also
+Rearmed.enabled_patches = {
+  active_record: true,
+  helpers: false,
+}
 ```
 
+By design, once `apply_patches!` is called then `RearmedRails.enabled_patches` is no longer editable and `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.
+
 
 ## 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.pluck_to_hash(:name, :category, :id)
+Post.pluck_to_struct(:name, :category, :id)
+
 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
@@ -92,11 +83,17 @@ Post.reset_auto_increment # reset mysql/mariadb/postgresql/sqlite auto-increment
 # 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
-```
+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)})
 
-Note: All methods which involve deletion are compatible with Paranoia & ActsAsParanoid
+# It also can delete duplicates. 
+# Valid values for keep are :first & :last.
+# Valid values for delete_method are :destroy & :delete. The soft-delete option 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
+```
 
 ### Helpers
 
@@ -110,42 +107,20 @@ options_for_select(@users.map{|x| [x.name, x.id]}, include_blank: true, selected
 # 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
+# returns Rails v3 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](https://github.com/westonganger)
+Created by [Weston Ganger](https://westonganger.com) - [@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 Ruby](https://github.com/westonganger/rearmed-rb)
 - [Rearmed JS](https://github.com/westonganger/rearmed_rails)
 - [Rearmed CSS](https://github.com/westonganger/rearmed_css)

data/Rakefile

@@ -5,20 +5,19 @@ 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_rails'
+  require 'active_record'
+  require 'action_view'
 
-  RearmedRails.enabled_patches = {
-    rails: true,
-    minitest: true
-  }
+  require 'rearmed_rails'
 
-  require 'rearmed_rails/apply_patches'
+  RearmedRails.enabled_patches = :all
+  RearmedRails.apply_patches!
 
   require 'irb'
   binding.irb

data/lib/generators/rearmed_rails/setup_generator.rb

@@ -7,7 +7,7 @@ module RearmedRails
       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'
+RearmedRails.apply_patches!'
 eos
     end
 

data/lib/rearmed_rails.rb

@@ -2,19 +2,58 @@ require 'rearmed_rails/version'
 
 module RearmedRails
 
-  @enabled_patches = eval(File.read(File.join(File.dirname(__FILE__), 'rearmed_rails/default_enabled_patches.hash')))
+  DEFAULT_PATCHES = eval(File.read(File.join(File.dirname(__FILE__), 'rearmed_rails/default_enabled_patches.hash'))).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 ::RearmedRails::Exceptions::PatchesAlreadyAppliedError.new
+    else
+      if val.nil?
+        @enabled_patches = Marshal.load(Marshal.dump(DEFAULT_PATCHES)) 
+      elsif val == :all
+        @enabled_patches = val
+      elsif val.is_a?(Hash)
+        @enabled_patches = Marshal.load(Marshal.dump(DEFAULT_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
+          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 ::RearmedRails::Exceptions::PatchesAlreadyAppliedError.new
+    else
+      Dir[File.join(__dir__, 'rearmed_rails/monkey_patches/**/*.rb')].each do |filename| 
+        require filename
+      end
+
+      @applied = true 
+    end
+  end
+
   private
 
-  def self.dig(collection, *values)
+  def self._dig(collection, *values)
     current_val = nil
     current_collection = collection
     values.each_with_index do |val,i|

data/lib/rearmed_rails/default_enabled_patches.hash

@@ -1,31 +1,17 @@
 {
-  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
-    }
+  active_record: {
+    find_duplicates: false,
+    find_or_create: false,
+    newest: 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
   }
 }

data/lib/rearmed_rails/exceptions.rb

@@ -0,0 +1,11 @@
+module RearmedRails
+  module Exceptions
+
+    class PatchesAlreadyAppliedError < StandardError
+      def initialize
+        super("Cannot change or apply patches again after `RearmedRails#apply_patches!` has been called.")
+      end
+    end
+
+  end
+end

data/lib/rearmed_rails/monkey_patches/{rails/active_record/base.rb → active_record.rb}

@@ -1,10 +1,9 @@
-enabled = RearmedRails.enabled_patches[:rails] == true
-enabled ||= RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record) == true
+enabled = RearmedRails.enabled_patches == :all || RearmedRails._dig(RearmedRails.enabled_patches, :active_record) == true
 
 if defined?(ActiveRecord)
 
   ActiveRecord::Base.class_eval do
-    if enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record, :newest)
+    if enabled || RearmedRails._dig(RearmedRails.enabled_patches, :active_record, :newest)
       def self.newest(*columns)
         if columns.empty? || !columns.to_s.include?('created_at')
           columns << 'created_at'
@@ -18,7 +17,7 @@ if defined?(ActiveRecord)
       end
     end
 
-    if enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record, :reset_table)
+    if enabled || RearmedRails._dig(RearmedRails.enabled_patches, :active_record, :reset_table)
       def self.reset_table(opts={})
         if opts[:delete_method] && opts[:delete_method].to_sym == :destroy
           if self.try(:paranoid?)
@@ -53,7 +52,7 @@ if defined?(ActiveRecord)
       end
     end
 
-    if enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record, :reset_auto_increment)
+    if enabled || RearmedRails._dig(RearmedRails.enabled_patches, :active_record, :reset_auto_increment)
       def self.reset_auto_increment(opts={})
         case self.connection.adapter_name.downcase.to_sym
         when :mysql2
@@ -69,7 +68,7 @@ if defined?(ActiveRecord)
       end
     end
 
-    if enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record, :find_duplicates)
+    if enabled || RearmedRails._dig(RearmedRails.enabled_patches, :active_record, :find_duplicates)
       def self.find_duplicates(*args)
         options = {}
 
@@ -143,7 +142,7 @@ if defined?(ActiveRecord)
       end
     end
 
-    if enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record, :find_or_create)
+    if enabled || RearmedRails._dig(RearmedRails.enabled_patches, :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)
@@ -161,7 +160,7 @@ if defined?(ActiveRecord)
       end
     end
 
-    if enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record, :pluck_to_hash)
+    if enabled || RearmedRails._dig(RearmedRails.enabled_patches, :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?
@@ -175,7 +174,7 @@ if defined?(ActiveRecord)
       end
     end
 
-    if enabled || enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record, :pluck_to_struct)
+    if enabled || enabled || RearmedRails._dig(RearmedRails.enabled_patches, :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?
@@ -192,7 +191,7 @@ if defined?(ActiveRecord)
 
     private
 
-    if enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :active_record, :pluck_to_hash) || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :pluck_to_struct)
+    if enabled || RearmedRails._dig(RearmedRails.enabled_patches, :active_record, :pluck_to_hash) || RearmedRails._dig(RearmedRails.enabled_patches, :pluck_to_struct)
       def self.format_keys(keys)
         if keys.blank?
           [column_names, column_names]

data/lib/rearmed_rails/monkey_patches/{rails/helpers.rb → helpers.rb}

@@ -1,9 +1,8 @@
-enabled = RearmedRails.enabled_patches[:rails] == true
-enabled ||= RearmedRails.dig(RearmedRails.enabled_patches, :rails, :helpers) == true
+enabled = RearmedRails.enabled_patches == :all || RearmedRails._dig(RearmedRails.enabled_patches, :helpers) == true
 
 if defined?(ActionView::Helpers)
 
-  if enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :helpers, :link_to_confirm)
+  if enabled || RearmedRails._dig(RearmedRails.enabled_patches, :helpers, :link_to_confirm)
     ActionView::Helpers::UrlHelper.module_eval do
       def convert_options_to_data_attributes(options, html_options)
         if html_options
@@ -25,7 +24,7 @@ if defined?(ActionView::Helpers)
     end 
   end
 
-  if enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :helpers, :field_is_array)
+  if enabled || RearmedRails._dig(RearmedRails.enabled_patches, :helpers, :field_is_array)
     module ActionView 
       module Helpers
         module Tags
@@ -53,7 +52,7 @@ if defined?(ActionView::Helpers)
 
   RearmedRails::RailsHelpers.module_eval do
 
-    if enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :helpers, :options_for_select_include_blank)
+    if enabled || RearmedRails._dig(RearmedRails.enabled_patches, :helpers, :options_for_select_include_blank)
       def options_for_select(container, selected = nil)
         if selected.is_a?(Hash)
           include_blank = selected[:include_blank] || selected['include_blank']
@@ -77,7 +76,7 @@ if defined?(ActionView::Helpers)
       end
     end
 
-    if enabled || RearmedRails.dig(RearmedRails.enabled_patches, :rails, :helpers, :options_for_select_include_blank)
+    if enabled || RearmedRails._dig(RearmedRails.enabled_patches, :helpers, :options_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)]

data/lib/rearmed_rails/version.rb

@@ -1,3 +1,3 @@
 module RearmedRails
-  VERSION = "1.0.5"
+  VERSION = "2.0.0"
 end

data/test/{tc_rearmed.rb → rearmed_rails_test.rb}

@@ -5,53 +5,49 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 require 'yaml'
 require 'minitest'
+require 'minitest/autorun'
 
+require 'active_record'
+require 'action_view'
 require 'rearmed_rails'
 
-require 'minitest/autorun'
+RearmedRails.enabled_patches = :all
+RearmedRails.apply_patches!
 
-class TestRearmedRails < MiniTest::Test
+class RearmedRailsTest < MiniTest::Test
   def setup
-    Minitest::Assertions.module_eval do
-      alias_method :eql, :assert_equal
-    end
+  end
 
-    RearmedRails.enabled_patches = {
-      rails: true,
-      minitest: true
-    }
-    require 'rearmed_rails/apply_patches'
+  def teardown
   end
 
-  def test_minitest
-    str = 'first'
-    assert_changed "str" do
-      str = 'second'
-    end
+  def test_enabled_patches
+    RearmedRails.instance_variable_set(:@applied, false)
 
-    str = 'first'
-    assert_changed ->{ str } do
-      str = 'second'
-    end
+    default = RearmedRails.const_get(:DEFAULT_PATCHES)
 
-    name = 'first'
-    assert_changed lambda{ name } do
-      name = 'second'
-    end
+    RearmedRails.enabled_patches = nil
+    assert_equal RearmedRails.enabled_patches, default
 
-    name = 'first'
-    assert_not_changed 'name' do
-      name = 'first'
-    end
+    RearmedRails.enabled_patches = {}
+    assert_equal RearmedRails.enabled_patches, default
 
-    name = 'first'
-    assert_not_changed ->{ name } do
-      name = 'first'
-    end
+    RearmedRails.enabled_patches = :all
+    assert_equal RearmedRails.enabled_patches, :all
+
+    RearmedRails.enabled_patches = {active_record: true, helpers: false, foo: :bar}
+    assert_equal RearmedRails.enabled_patches, default.merge({active_record: true})
 
-    name = 'first'
-    assert_not_changed lambda{ name } do
-      name = 'first'
+    [true, false, [], '', 1, :foo, RearmedRails].each do |x|
+      assert_raises TypeError do
+        RearmedRails.enabled_patches = x
+      end
+
+      if x != true && x != false
+        assert_raises TypeError do
+          RearmedRails.enabled_patches = {active_record: x}
+        end
+      end
     end
   end
 
@@ -74,26 +70,11 @@ class TestRearmedRails < MiniTest::Test
     #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_rails
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 2.0.0
 platform: ruby
 authors:
 - Weston Ganger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-04 00:00:00.000000000 Z
+date: 2018-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: A collection of helpful methods and monkey patches for Rails
-email: westonganger@gmail.com
+email: weston@westonganger.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -64,16 +64,12 @@ files:
 - 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/exceptions.rb
+- lib/rearmed_rails/monkey_patches/active_record.rb
+- lib/rearmed_rails/monkey_patches/helpers.rb
 - lib/rearmed_rails/version.rb
-- test/tc_rearmed.rb
+- test/rearmed_rails_test.rb
 homepage: https://github.com/westonganger/rearmed_rails
 licenses: []
 metadata: {}
@@ -93,9 +89,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: A collection of helpful methods and monkey patches for Rails
 test_files:
-- test/tc_rearmed.rb
+- test/rearmed_rails_test.rb

data/lib/rearmed_rails/apply_patches.rb

@@ -1,6 +0,0 @@
-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/monkey_patches/minitest.rb

@@ -1,35 +0,0 @@
-if defined?(Minitest::Assertions)
-
-  enabled = RearmedRails.enabled_patches[:minitest] == true
-
-  Minitest::Assertions.module_eval do
-
-    if enabled || RearmedRails.dig(RearmedRails.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 || RearmedRails.dig(RearmedRails.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/batches.rb

@@ -1,60 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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
-
-      unless defined?(ActiveRecord::Relation::QueryMethods)
-        module ActiveRecord
-          class Relation
-            module QueryMethods
-            end
-          end
-        end
-      end
-
-      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.or(other)
-          end
-        end
-      end
-
-      ActiveRecord::QueryMethods.module_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 # end of Rails 5+ section, Rails 4 below
-
-      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 of Rails 4 section
-
-  end
-
-end

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

@@ -1,58 +0,0 @@
-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