rearmed 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 968b1b6d9e143a067cf3bbf08421b30aec7bfa6e
-  data.tar.gz: 1177068969514cbbbc788e813816945358c5216c
+  metadata.gz: f2c29c181ff21a0d8d827e5ddc041a24ffdf27e2
+  data.tar.gz: 720e02b98600437a7721e8da557a9cf8a93af7b0
 SHA512:
-  metadata.gz: 574d3c484daae7a490282e4a8019c00ecbf82b61782d74d32134f793736b3604ac05c9e6064c3ef3ecde1f43461df6efcf34ccebf33fdd405ba13cc91e9371bd
-  data.tar.gz: ed8bf5a25c7ebd663277831dcd8e4a4e32a1622d7fbdf8c13861a9fface22dc97d818d7790f31bf85be3012bd9dc3695b5b12a017aafe428ae12f0c8467d456e
+  metadata.gz: ce9ee1703ccb3d7cbd44d672e1622760026135fb32fc4e66b59009981cca2d40e31d0b19bfe1623cf1d7b3456934eee62618e2d5c018786e42a5ecd653ce1851
+  data.tar.gz: 4115b29b94fb22028294cdce9996f93ed7428aba08c3f487db6a4ff9c07f24775731d5c4890052ce3aeba824290cca7302ff9e06741ff0bab9c238dd453e7ad2

data/CHANGELOG.md

@@ -1,6 +1,23 @@
 CHANGELOG
 ---------
 
+- **1.1.0 - July 8, 2016**
+  - Add ActiveRecord `find_or_create`, `reset_table`, `reset_auto_increment`, `depupe`
+  - Add `starts_with?`, `begins_with?`, `ends_with?` aliases
+  - Major improvements to opt-in system
+  - Allow Hash compact work without ActiveSupport
+  - Only allow `in?` patch without ActiveSupport
+  - Move some methods to Rearmed for use outside of monkey patching
+  - Add test's for everything except for the Rails methods (Would love a PR for the Rails tests)
+- **1.0.3 - June 20, 2016**
+  - Useless version update
+  - I Thought the `delete_first` method still wasn't fixed but my app was incorrect instead
+- **1.0.2 - June 20, 2016**
+  - Fix array `delete_first` method
+- **1.0.1 - June 17, 2016**
+  - Add `pluck_to_hash`
+  - Add `pluck_to_struct`
+  - Reorganize rails patches to have generic rails patches
 - **1.0.0 - June 8, 2016**
   - Ready for public use
   - Major improvements to opt-in system

data/README.md

@@ -24,7 +24,6 @@ Rearmed.enabled_patches = {
     link_to_confirm: false
   },
   rails_3: {
-    hash_compact: false,
     pluck: false,
     update_columns: false,
     all: false
@@ -32,17 +31,25 @@ Rearmed.enabled_patches = {
   rails: {
     pluck_to_hash: false,
     pluck_to_struct: false,
+    find_or_create: false,
+    reset_table: false,
+    reset_auto_increment: false,
+    dedupe: false,
     find_relation_each: false,
     find_in_relation_batches: false,
   },
   string: {
-    to_bool: false,
     valid_integer: false,
-    valid_float: false
+    valid_float: false,
+    to_bool: false,
+    starts_with: false,
+    begins_with: false,
+    ends_with: false
   },
   hash: {
     only: false,
-    dig: false
+    dig: false,
+    compact: false
   },
   array: {
     dig: false,
@@ -67,6 +74,8 @@ require 'rearmed/apply_patches'
 ### Object
 ```ruby
 my_var.not_nil?
+
+# Only for non-Rails environments, as Rails already has this method
 my_var.in?([1,2,3])
 my_var.in?(1,2,3) # or with splat arguments
 ```
@@ -81,6 +90,11 @@ my_var.in?(1,2,3) # or with splat arguments
 
 'true'.to_bool 
 # or without monkey patch: Rearmed.to_bool('true')
+
+# alias of start_with? and end_with? to have more sensible method names
+'foo'.starts_with?('fo') # => true
+'foo'.begins_with?('fo') # => true
+'bar'.ends_with?('ar') # => true
 ```
 
 ### Date
@@ -92,21 +106,17 @@ Date.now
 ```ruby
 items = ['1.1', '1.11', '1.2']
 items.natural_sort 
-items.natural_sort(reverse: true) # because natural_sort does not accept a block
+items.natural_sort(reverse: true) # because natural_sort does not accept a block, accepting PR's on this
 # or without monkey patch: Rearmed.natural_sort(items) or Rearmed.natural_sort(items, reverse: true)
 
-items = ['1.1', '1.11', '1.2']
-items.natural_sort{|a,b| b <=> a} 
-# or without monkey patch: Rearmed.natural_sort(items){|a,b| b <=> a}
-
 items = [{version: "1.1"}, {version: "1.11"}, {version: "1.2"}]
 items.natural_sort_by{|x| x[:version]} 
 # or without monkey patch: Rearmed.natural_sort_by(items){|x| x[:version]}
 
 # Only available on array and hash in Ruby 2.2.x or below
 items = [{foo: ['foo','bar']}, {test: 'thing'}]
-items.dig(1, :foo, 2) # => 'bar'
-# or without monkey patch: Rearmed.dig(items){|x| x[:version]}
+items.dig(0, :foo, 1) # => 'bar'
+# or without monkey patch: Rearmed.dig(items, 0, :foo, 1)
 ```
 
 ### Array Methods
@@ -127,33 +137,71 @@ hash.only(:foo, :bar) # => {foo: 'foo'}
 # or without monkey patch: Rearmed.only(hash, :foo, :bar)
 
 hash.only!(:foo, :bar)
+
+my_hash.compact
+my_hash.compact!
 ```
 
 ### Rails
 
 ##### Additional ActiveRecord Methods
+Note: All methods which involve deletion are compatible with Paranoia & ActsAsParanoid
+
 ```ruby
-Post.all.pluck_to_hash(:name, :category, :id)
-Post.all.pluck_to_struct(:name, :category, :id)
+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.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.dedupe # remove all duplicate records, defaults to all of the models column_names except timestamps
+# or with options
+Post.dedupe(delete_method: :destroy) # to ensure all callbacks are fired
+Post.dedupe(columns: [:name, :content, :category_id]
+Post.dedupe(skip_timestamps: false) # skip timestamps defaults to true (created_at, updated_at, deleted_at)
+Post.dedupe(keep: :last) # Keep the last duplicate instead of the first duplicate by default
+
 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
+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
+```
+
 ##### Rails 3.x Backports
 ```ruby
-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]]
+
+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
 
-##### Rails 4.x Backports
-```ruby
-Post.where(name: 'foo').or.where(content: 'bar')
-= link_to 'Delete', post_path(post), method: :delete, confirm: "Are you sure you want to delete this post?" #returns rails 3 behaviour of allowing confirm attribute as well as data-confirm
-```
 
 # Credits
 Created by Weston Ganger - @westonganger

data/lib/generators/rearmed/setup_generator.rb

@@ -11,7 +11,6 @@ Rearmed.enabled_patches = {
     link_to_confirm: false
   },
   rails_3: {
-    hash_compact: false,
     pluck: false,
     update_columns: false,
     all: false
@@ -19,17 +18,25 @@ Rearmed.enabled_patches = {
   rails: {
     pluck_to_hash: false,
     pluck_to_struct: false,
+    find_or_create: false,
+    reset_table: false,
+    reset_auto_increment: false,
+    dedupe: false,
     find_relation_each: false,
     find_in_relation_batches: false,
   },
   string: {
-    to_bool: false,
     valid_integer: false,
-    valid_float: false
+    valid_float: false,
+    to_bool: false,
+    starts_with: false,
+    begins_with: false,
+    ends_with: false,
   },
   hash: {
     only: false,
-    dig: false
+    dig: false,
+    compact: false,
   },
   array: {
     dig: false,

data/lib/rearmed/apply_patches.rb

@@ -3,6 +3,7 @@ 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'

data/lib/rearmed/monkey_patches/array.rb

@@ -1,13 +1,13 @@
 array_enabled = Rearmed.enabled_patches[:array] == true
 
 Array.module_eval do
-  if array_enabled || Rearmed.dig(Rearmed.enabled_patches, :array, :not_empty) == true
+  if array_enabled || Rearmed.dig(Rearmed.enabled_patches, :array, :not_empty)
     def not_empty?
       !empty?
     end
   end
 
-  if array_enabled || Rearmed.dig(Rearmed.enabled_patches, :array, :delete_first) == true
+  if array_enabled || Rearmed.dig(Rearmed.enabled_patches, :array, :delete_first)
     def delete_first(item=(no_arg_passed = true; nil))
       if block_given? && !no_arg_passed
         raise BothArgAndBlockError
@@ -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) == true
+  if RUBY_VERSION.to_f < 2.3 && array_enabled || Rearmed.dig(Rearmed.enabled_patches, :array, :dig)
     def dig(*args)
       Rearmed.dig(self, *args)
     end

data/lib/rearmed/monkey_patches/date.rb

@@ -1,7 +1,7 @@
 date_enabled = Rearmed.enabled_patches[:date] == true
 
 Date.class_eval do
-  if date_enabled || Rearmed.dig(Rearmed.enabled_patches, :date, :now) == true
+  if date_enabled || Rearmed.dig(Rearmed.enabled_patches, :date, :now)
     def self.now
       DateTime.now.to_date
     end

data/lib/rearmed/monkey_patches/enumerable.rb

@@ -1,13 +1,13 @@
 enumerable_enabled = Rearmed.enabled_patches[:enumerable] == true
 
 Enumerable.module_eval do 
-  if enumerable_enabled || Rearmed.dig(Rearmed.enabled_patches, :enumerable, :natural_sort_by) == true
+  if enumerable_enabled || Rearmed.dig(Rearmed.enabled_patches, :enumerable, :natural_sort_by)
     def natural_sort_by
       Rearmed.natural_sort_by(self){|x| yield(x)}
     end
   end
     
-  if enumerable_enabled || Rearmed.dig(Rearmed.enabled_patches, :enumerable, :natural_sort) == true
+  if enumerable_enabled || Rearmed.dig(Rearmed.enabled_patches, :enumerable, :natural_sort)
     def natural_sort(options={})
       if block_given?
         Rearmed.natural_sort(self, options){|x| yield(x)}

data/lib/rearmed/monkey_patches/hash.rb

@@ -1,7 +1,18 @@
 hash_enabled = Rearmed.enabled_patches[:hash] == true
 
 Hash.class_eval do
-  if hash_enabled || Rearmed.dig(Rearmed.enabled_patches, :hash, :only) == true
+  allowed = defined?(ActiveSupport) ? (ActiveSupport::VERSION::MAJOR > 3) : true
+  if allowed && (hash_enabled || Rearmed.dig(Rearmed.enabled_patches, :hash, :compact))
+    def compact
+      self.select{|_, value| !value.nil?}
+    end
+
+    def compact!
+      self.reject!{|_, value| value.nil?}
+    end
+  end
+
+  if hash_enabled || Rearmed.dig(Rearmed.enabled_patches, :hash, :only)
     def only(*keys)
       Rearmed.only(self, *keys)
     end
@@ -15,7 +26,7 @@ Hash.class_eval do
     end
   end
 
-  if RUBY_VERSION.to_f < 2.3 && hash_enabled || Rearmed.dig(Rearmed.enabled_patches, :hash, :dig) == true
+  if RUBY_VERSION.to_f < 2.3 && hash_enabled || Rearmed.dig(Rearmed.enabled_patches, :hash, :dig)
     def dig(*args)
       Rearmed.dig(self, *args)
     end

data/lib/rearmed/monkey_patches/object.rb

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

data/lib/rearmed/monkey_patches/rails.rb

@@ -2,8 +2,108 @@ enabled = Rearmed.enabled_patches[:rails] == true
 
 if defined?(ActiveRecord)
 
-  if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails, :pluck_to_hash) == true
-    ActiveRecord::Base.class_eval do
+  ActiveRecord::Base.class_eval do
+    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 || 'id'}_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, :dedupe)
+      def self.dedupe(opts={})
+        if !opts[:columns]
+          opts[:columns] = self.column_names.reject{|x| x == 'id'}
+        end
+        
+        if opts[:skip_timestamps] != false
+          opts[:columns].reject!{|x| ['created_at','updated_at','deleted_at'].include?(x)}
+        end
+
+        self.all.group_by{|model| opts[:columns].map{|x| model[x]}}.values.each do |duplicates|
+          (opts[:keep] && opts[:keep].to_sym == :last) ? duplicates.pop : duplicates.shift
+          if opts[:delete_method] && opts[:delete_method].to_sym == :destroy
+            duplicates.each do |x|
+              if x.respond_to?(:really_destroy!)
+                x.really_destroy!
+              else
+                x.destroy!
+              end
+            end
+          else
+            if defined?(ActsAsParanoid) && self.try(:paranoid?)
+              self.unscoped.where(id: duplicates.collect(&:id)).delete_all!
+            else
+              self.unscoped.where(id: duplicates.collect(&:id)).delete_all
+            end
+          end
+        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?
@@ -15,7 +115,9 @@ if defined?(ActiveRecord)
           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?
@@ -28,9 +130,11 @@ if defined?(ActiveRecord)
           block_given ? yield(value) : value
         end
       end
+    end
 
-      private
+    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]
@@ -52,7 +156,7 @@ if defined?(ActiveRecord)
   end
 
   ActiveRecord::Batches.module_eval do
-    if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails, :find_in_relation_batches) == true
+    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)
 
@@ -89,7 +193,7 @@ if defined?(ActiveRecord)
       end
     end
 
-    if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails, :find_relation_each) == true
+    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|

data/lib/rearmed/monkey_patches/rails_3.rb

@@ -1,22 +1,8 @@
 enabled = Rearmed.enabled_patches[:rails_3] == true
 
-if defined?(ActiveSupport) && ActiveSupport::VERSION::MAJOR < 4
-  if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails_3, :hash_compact) == true
-    Hash.class_eval do
-      def compact
-        self.select{|_, value| !value.nil?}
-      end
-
-      def compact!
-        self.reject!{|_, value| value.nil?}
-      end
-    end
-  end
-end
-
 if defined?(ActiveRecord) && ActiveRecord::VERSION::MAJOR < 4
 
-  if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails_3, :all) == true
+  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
@@ -24,7 +10,7 @@ if defined?(ActiveRecord) && ActiveRecord::VERSION::MAJOR < 4
     end
   end
 
-  if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails_3, :update_columns) == true
+  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?
@@ -45,7 +31,7 @@ if defined?(ActiveRecord) && ActiveRecord::VERSION::MAJOR < 4
     end
   end
 
-  if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails_3, :pluck) == true
+  if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails_3, :pluck)
     ActiveRecord::Relation.class_eval do
       def pluck(*args)
         args.map! do |column_name|

data/lib/rearmed/monkey_patches/rails_4.rb

@@ -1,6 +1,6 @@
 enabled = Rearmed.enabled_patches[:rails_4] == true
 
-if defined?(ActionView) && enabled || Rearmed.dig(Rearmed.enabled_patches, :rails_4, :link_to_confirm) == 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
@@ -25,7 +25,7 @@ end
 if defined?(ActiveRecord)
 
   ActiveRecord::Batches.module_eval do
-    if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails_4, :find_in_relation_batches) == true
+    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)
 
@@ -62,7 +62,7 @@ if defined?(ActiveRecord)
       end
     end
 
-    if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails_4, :find_relation_each) == true
+    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|
@@ -78,7 +78,7 @@ if defined?(ActiveRecord)
   end
 
 
-  if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails_4, :or) == true
+  if enabled || Rearmed.dig(Rearmed.enabled_patches, :rails_4, :or)
     module ActiveRecord
       module Querying
         delegate :or, :to => :all

data/lib/rearmed/monkey_patches/string.rb

@@ -1,22 +1,33 @@
 string_enabled = Rearmed.enabled_patches[:string] == true
 
 String.class_eval do
-  if string_enabled || Rearmed.dig(Rearmed.enabled_patches, :string, :valid_integer) == true
+  if string_enabled || Rearmed.dig(Rearmed.enabled_patches, :string, :valid_integer)
     def valid_integer?
       Rearmed.valid_integer?(self)
     end
   end
 
-  if string_enabled || Rearmed.dig(Rearmed.enabled_patches, :string, :valid_float) == true
+  if string_enabled || Rearmed.dig(Rearmed.enabled_patches, :string, :valid_float)
     def valid_float?
       Rearmed.valid_float?(self)
     end
   end
 
-  if string_enabled || Rearmed.dig(Rearmed.enabled_patches, :string, :to_bool) == true
+  if string_enabled || Rearmed.dig(Rearmed.enabled_patches, :string, :to_bool)
     def to_bool
       Rearmed.to_bool(self)
     end
   end
-end
 
+  if string_enabled || Rearmed.dig(Rearmed.enabled_patches, :string, :starts_with)
+    alias_method :starts_with?, :start_with?
+  end
+
+  if string_enabled || Rearmed.dig(Rearmed.enabled_patches, :string, :begins_with)
+    alias_method :begins_with?, :start_with?
+  end
+
+  if string_enabled || Rearmed.dig(Rearmed.enabled_patches, :string, :ends_with)
+    alias_method :ends_with?, :end_with?
+  end
+end

data/lib/rearmed/version.rb

@@ -1,3 +1,3 @@
 module Rearmed
-  VERSION = "1.0.3"
+  VERSION = "1.1.0"
 end

data/test/tc_rearmed.rb

@@ -1,33 +1,217 @@
 #!/usr/bin/env ruby -w
-require 'yaml'
-require 'minitest'
 
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'rearmed.rb'
+
+require 'yaml'
+require 'minitest'
+
+require 'rearmed'
 
 require 'minitest/autorun'
 
 class TestRearmed < MiniTest::Test
   def setup
-    @array = ["1.1","1.11","1.2","1.22"]
-    @hash_array = [{version: "1.1"}, {version: "1.11"}, {version: "1.2"}, {version: "1.22"}]
-    @hash = {version_b: "1.1", version_a: "1.11", version_c: "1.2", version_d: "1.22"}
+    Minitest::Assertions.module_eval do
+      alias_method :eql, :assert_equal
+    end
+
+    Rearmed.enabled_patches = {
+      array: true,
+      hash: true,
+      object: true,
+      string: true,
+      date: true,
+      enumerable: true,
+      rails_3: true,
+      rails_4: true,
+      rails: true
+    }
+    require 'rearmed/apply_patches'
+  end
+
+  def test_string
+    # Test String Methods
+    str = '32'
+    eql(str.valid_integer?, true)
+
+    str = '32.2'
+    eql(str.valid_integer?, false)
+
+    str = '32a'
+    eql(str.valid_integer?, false)
+
+    str = '132.2'
+    eql(str.valid_float?, true)
+
+    str = '132.2.2'
+    eql(str.valid_float?, false)
+
+    str = '12.1a'
+    eql(str.valid_float?, false)
+
+    str = 'true'
+    eql(str.to_bool, true)
+
+    str = 'false'
+    eql(str.to_bool, false)
+
+    str = 'not true'
+    eql(str.to_bool, nil)
+
+
+    # Test Rearmed methods (just cause really)
+    str = 'true'
+    eql(Rearmed.to_bool(str), true)
+
+    str = '12'
+    eql(Rearmed.valid_integer?(str), true)
+
+    str = '1.2'
+    eql(Rearmed.valid_float?(str), true)
   end
 
-  def test_should_sort_enumerables_correctly
-    assert_equal [*@array], [@array.to_args]
+  def test_date
+    Date.now
+  end
+
+  def test_enumerable
+    items = ['1.1', '1.11', '1.2']
+
+    eql(items.natural_sort, ['1.1','1.2','1.11'])
+
+    eql(items.natural_sort(reverse: true), ['1.11','1.2','1.1'])
+
+    eql(Rearmed.natural_sort(items), ['1.1','1.2','1.11'])
+
+    eql(Rearmed.natural_sort(items, reverse: true), ['1.11','1.2','1.1'])
+
+
+    items = [{version: "1.1"}, {version: "1.11"}, {version: "1.2"}]
     
-    assert_equal "1.2", @array.natural_sort[1]
-    assert_equal "1.22", @array.natural_sort{|a,b| b <=> a}[0]
-    assert_equal "1.2", @array.natural_sort_by{|x| x}[1]
+    eql(items.natural_sort_by{|x| x[:version]}, [{version: "1.1"}, {version: "1.2"}, {version: "1.11"}])
     
-    assert_equal([:version_c, "1.2"], @hash.natural_sort_by{|x| x[1]}[1])
-    assert_equal([:version_c, "1.2"], @hash.natural_sort[1])
-    #assert_equal([:version_d, "1.22"], @hash.natural_sort{|a,b| b[1] <=> a[1]}[0])
+    eql(Rearmed.natural_sort_by(items){|x| x[:version]}, [{version: "1.1"}, {version: "1.2"}, {version: "1.11"}])
+
+
+    # Only available on array and hash in Ruby 2.2.x or below
+    array = [{foo: ['foo','bar']}, {test: 'thing'}]
+
+    eql(array.dig(0, :foo, 1), 'bar')
+    eql(array.dig(0, :foo, 2), nil)
+
+    eql(Rearmed.dig(array, 1, :test), 'thing')
+    eql(Rearmed.dig(array, 1, :bar), nil)
+
+    hash = {a: {foo: ['bar']}, b: {c: 'c'}}
+    
+    eql(hash.dig(:a, :foo, 0), 'bar')
+    eql(Rearmed.dig(hash, :b, :c), 'c')
+  end
+
+  def test_array
+    array = [1,3,2,1,3,4,1]
+    array.delete_first(3)
+    eql(array, [1,2,1,3,4,1])
+
+    array = [1,3,2,1,3,4,1]
+    array.delete_first
+    eql(array, [3,2,1,3,4,1])
+
+    array = [1,3,2,1,3,4,1]
+    array.delete_first{|x| x != 1}
+    eql(array, [1,2,1,3,4,1])
+  end
+
+  def test_hash
+    hash = {foo: 'foo', bar: 'bar', other: 'other'}
+    eql(hash.only(:foo, :bar), {foo: 'foo', bar: 'bar'})
+
+    hash = {foo: 'foo', bar: 'bar', other: 'other'}
+    hash.only!(:foo, :bar)
+    eql(hash, {foo: 'foo', bar: 'bar'})
+
+    hash = {foo: 'foo', bar: 'bar', other: 'other'}
+    eql(Rearmed.only(hash, :foo, :bar), {foo: 'foo', bar: 'bar'})
+
+
+    hash = {foo: nil, bar: nil, other: 'other'}
+    eql(hash.compact, {other: 'other'})
+
+    hash = {foo: nil, bar: nil, other: 'other'}
+    hash.compact!
+    eql(hash, {other: 'other'})
+  end
+
+  def test_object
+    str = 'test'
+    eql(str.not_nil?, true)
+
+    str = nil
+    eql(str.not_nil?, false)
+
+    str = false
+    eql(str.not_nil?, true)
+
+    str = 'test'
+    eql(str.in?(['test','abc']), true)
+
+    str = 'test'
+    eql(str.in?(['abc','def']), false)
+
+    str = 'test'
+    eql(str.in?('test','abc'), true)
+
+    str = 'test'
+    eql(str.in?('abc','def'), false)
+
+    str = 'test'
+    eql(str.in?('a test string'), true)
+
+    str = 'test'
+    eql(str.in?('a real string'), false)
+  end
+
+  def test_general_rails
+    # THE MOST IMPORTANT TESTS HERE WOULD BE dedupe, reset_auto_increment, reset_table
+    
+    #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) # use destroy_all to ensure all callbacks are fired
+
+    #Post.reset_auto_increment # reset mysql/mariadb/postgresql/sqlite auto-increment column
+    # or with options
+    #Post.reset_auto_increment(value: 1, column: :id)
+
+    #Post.dedupe # remove all duplicate records, defaults to the models column_names list
+    # or with options
+    #Post.dedupe(columns: [:name, :content, :category_id])
+    #Post.dedupe(skip_timestamps: true)
+    #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_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')
 
-    #assert_equal({version: "1.2"}, @hash_array.natural_sort[1])
-    #assert_equal({version: "1.22"}, @hash_array.natural_sort{|a,b| b[:version] <=> a[:version]}[0])
-    #assert_equal({version: "1.2"}, @hash_array.natural_sort_by{|x| x[:version]}[1])
+    #= 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.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Weston Ganger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-20 00:00:00.000000000 Z
+date: 2016-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake