rearmed 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 270b7582528a427dfcd54ea2cbe616af8bc67717
-  data.tar.gz: e97b0352883c108aa366ec3078bf188349e1b907
+  metadata.gz: d1c1c9a931a133791cfbdacdbfd5ccb01f50234d
+  data.tar.gz: 6daedcedcc902bfed66cad975fbcf99f34724163
 SHA512:
-  metadata.gz: f4785d8f2332220c02dbe2d904ef328ff4554b98f6711c5e095a071beb52c6000ae540228c53f732beb9987e435c7d8c5820fb317d959fa4815b2f6e8247cf00
-  data.tar.gz: 9f77a7b3b1e35f8027b00d676076e7e90ce33b88e34efdaa82b927c57b1caaa5e69bb8aa108b8b29c9f220911c45879d29f0dfa6d6df29d6d151cca0efec22dc
+  metadata.gz: 00253c513c5b1e4ba17485a1c7e72a2c5070e3e80121d8a612f5c8ebe10f06d04bff262bd117856a9fcffa0f1254e9fc9de5b50074bc61b126333e8a9be42624
+  data.tar.gz: c52b3d027600904d10d8ba89b3d9cb587ab6688c2b0c19a72fdb8b3d4766d177fc0d26d061283240ff86c277a515011bbb8c45c14a1409534492fb18d8aee341

data/CHANGELOG.md

@@ -1,7 +1,10 @@
 CHANGELOG
 ---------
 
-- 
+- **1.2.1 - Jan 24, 2017**
+  - Add Hash `join`, `to_struct`
+  - Fix `find_duplicates`
+  - Some minor refractoring
 - **1.2.0 - September 3, 2016**
   - Add Minitest patches `assert_changed` & `assert_not_changed`
   - Remove `dedupe` in favor of new `find_duplicates`

data/README.md

@@ -1,7 +1,7 @@
 # Rearmed Ruby
 <a href='https://ko-fi.com/A5071NK' target='_blank'><img height='32' style='border:0px;height:32px;' src='https://az743702.vo.msecnd.net/cdn/kofi1.png?v=a' border='0' alt='Buy Me a Coffee' /></a> 
 
-A collection of helpful methods and monkey patches for Objects, Strings, Enumerables, Arrays, Hash, Dates, Minitest & Rails
+A collection of helpful methods and monkey patches for Objects, Strings, Enumerables, Arrays, Hash, Dates, Minitest & Rails (optional)
 
 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. 
 
@@ -13,99 +13,89 @@ For applicable methods I have placed the implementation inside the Rearmed modul
 gem 'rearmed'
 ```
 
-Run `rails g rearmed:setup` to create a settings files in `config/initializers/rearmed.rb` where you can opt-in to the monkey patches available in the library. Set these values to true if you want to enable the applicable monkey patch.
+Run `rails g rearmed:setup` to create a settings files in `config/initializers/rearmed.rb` where you can opt-in to the monkey patches available in the library. Set these values to true if you want to enable the applicable monkey patch. If your not using Rails then just copy config this into your file and start from there.
 
 ```ruby
 # config/initializers/rearmed.rb
 
 Rearmed.enabled_patches = {
-  rails_4: {
-    or: false,
-    link_to_confirm: false
-  },
-  rails_3: {
-    pluck: false,
-    update_columns: false,
-    all: false
-  },
-  rails: {
-    pluck_to_hash: false,
-    pluck_to_struct: false,
-    find_or_create: false,
-    find_duplicates: false,
-    newest: false,
-    reset_table: false,
-    reset_auto_increment: false,
-    find_relation_each: false,
-    find_in_relation_batches: false,
-  },
-  string: {
-    valid_integer: false,
-    valid_float: false,
-    to_bool: false,
-    starts_with: false,
-    begins_with: false,
-    ends_with: false
-  },
-  hash: {
-    only: false,
-    dig: false,
-    compact: false
-  },
   array: {
     dig: false,
     delete_first: false,
     not_empty: false
   },
+  date: {
+    now: false
+  },
   enumerable: {
     natural_sort: false,
     natural_sort_by: false
   },
+  hash: {
+    compact: false,
+    dig: false,
+    join: false,
+    only: false,
+    to_struct: false
+  },
   object: {
     in: false,
     not_nil: false
   },
-  date: {
-    now: false
+  string: {
+    begins_with: false,
+    ends_with: false,
+    starts_with: false,
+    to_bool: false,
+    valid_float: false,
+    valid_integer: false
   },
   minitest: {
     assert_changed: false,
     assert_not_changed: false
+  },
+  rails: {
+    find_duplicates: false,
+    find_in_relation_batches: false,
+    find_or_create: false,
+    find_relation_each: false,
+    newest: false,
+    pluck_to_hash: false,
+    pluck_to_struct: false,
+    reset_auto_increment: false,
+    reset_table: false
+  },
+  rails_4: {
+    link_to_confirm: false,
+    or: false
+  },
+  rails_3: {
+    all: false,
+    pluck: false,
+    update_columns: false
   }
 }
 
-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
+require 'rearmed/apply_patches'
 ```
 
-### String
+### Array Methods
 ```ruby
-'123'.valid_integer?
-# or without monkey patch: Rearmed.valid_integer?('123')
-
-'123.123'.valid_float? 
-# or without monkey patch: Rearmed.valid_float?('123.123')
-
-'true'.to_bool 
-# or without monkey patch: Rearmed.to_bool('true')
+array = [1,2,1,4,1]
+array.delete_first(1) # => 1
+puts array #=> [2,1,4,1]
+array.delete_first{|x| 1 == x} # => 1
+puts array # => [2,4,1]
+array.delete_first # => 2
+puts array # => [4,1]
 
-# 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
-```
+array.not_empty? # => true
 
-### Date
-```ruby
-Date.now
+# Only available on array and hash in Ruby 2.2.x or below
+items = [{foo: ['foo','bar']}, {test: 'thing'}]
+items.dig(0, :foo, 1) # => 'bar'
+# or without monkey patch: Rearmed.dig(items, 0, :foo, 1)
 ```
 
 ### Enumerable Methods (Array, Hash, etc.)
@@ -118,6 +108,27 @@ items.natural_sort(reverse: true) # because natural_sort does not accept a block
 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]}
+```
+
+### Date
+```ruby
+Date.now
+```
+
+### Hash Methods
+```ruby
+my_hash.compact
+my_hash.compact!
+
+hash.join{|k,v| "#{k}: #{v}\n"}
+
+hash = {foo: 'foo', bar: 'bar', other: 'other'}
+hash.only(:foo, :bar) # => {foo: 'foo'}
+# or without monkey patch: Rearmed.only(hash, :foo, :bar)
+
+hash.only!(:foo, :bar)
+
+hash.to_struct
 
 # Only available on array and hash in Ruby 2.2.x or below
 items = [{foo: ['foo','bar']}, {test: 'thing'}]
@@ -125,29 +136,45 @@ items.dig(0, :foo, 1) # => 'bar'
 # or without monkey patch: Rearmed.dig(items, 0, :foo, 1)
 ```
 
-### Array Methods
+### Object
 ```ruby
-array = [1,2,1,4,1]
-array.delete_first(1) # => 1
-puts array #=> [2,1,4,1]
-array.delete_first{|x| 1 == x} # => 1
-puts array # => [2,4,1]
-array.delete_first # => 2
-puts array # => [4,1]
+my_var.not_nil?
 
-array.not_empty? # => true
+# 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
 ```
 
-### Hash Methods
+### String
 ```ruby
-hash = {foo: 'foo', bar: 'bar', other: 'other'}
-hash.only(:foo, :bar) # => {foo: 'foo'}
-# or without monkey patch: Rearmed.only(hash, :foo, :bar)
+'123'.valid_integer?
+# or without monkey patch: Rearmed.valid_integer?('123')
 
-hash.only!(:foo, :bar)
+'123.123'.valid_float? 
+# or without monkey patch: Rearmed.valid_float?('123.123')
 
-my_hash.compact
-my_hash.compact!
+'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
+```
+
+### Minitest Methods
+```ruby
+assert_changed 'user.name' do
+  user.name = "Bob"
+end
+
+assert_not_changed -> { user.name } do
+  user.update(user_params)
+end
+
+assert_not_changed lambda{ user.name } do
+  user.update(user_params)
+end
 ```
 
 ### Rails
@@ -189,13 +216,15 @@ Post.find_relation_each # this returns a relation instead of an array
 
 ##### Rails 4.x Backports
 ```ruby
+# returns to rails 3 behaviour of allowing confirm attribute as well as data-confirm
+= link_to 'Delete', post_path(post), method: :delete, confirm: "Are you sure you want to delete this post?" 
+
+# This version of `or` behaves way nicer than the one implemented in Rails 5, it allows you to do what you need. 
+# However this patch does not work in Rails 5+
 Post.where(name: 'foo').or.where(content: 'bar')
 Post.where(name: 'foo').or.my_custom_scope
 Post.where(name: 'foo').or(Post.where(content: 'bar'))
 Post.where(name: 'foo).or(content: 'bar')
-
-= 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
@@ -208,21 +237,6 @@ my_hash.compact # See Hash methods above
 my_hash.compact!
 ```
 
-### Minitest Method
-```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 / Todo
 If you want to request a method please raise an issue and we can discuss the implementation. 
 
@@ -230,7 +244,6 @@ 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
-- Get the `assert_changed` and `assert_not_changed` method to accept a String with the variable name similar to Rails ``
 
 
 # Credits

data/Rakefile

@@ -10,4 +10,24 @@ task :test do
   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/setup_generator.rb

@@ -5,61 +5,7 @@ module Rearmed
 
     def setup
       create_file "config/initializers/rearmed.rb", <<eos
-Rearmed.enabled_patches = {
-  rails_4: {
-    or: false,
-    link_to_confirm: false
-  },
-  rails_3: {
-    pluck: false,
-    update_columns: false,
-    all: false
-  },
-  rails: {
-    pluck_to_hash: false,
-    pluck_to_struct: false,
-    find_or_create: false,
-    find_duplicates: false,
-    newest: false,
-    reset_table: false,
-    reset_auto_increment: false,
-    find_relation_each: false,
-    find_in_relation_batches: false,
-  },
-  string: {
-    valid_integer: false,
-    valid_float: false,
-    to_bool: false,
-    starts_with: false,
-    begins_with: false,
-    ends_with: false,
-  },
-  hash: {
-    only: false,
-    dig: false,
-    compact: false,
-  },
-  array: {
-    dig: false,
-    delete_first: false,
-    not_empty: false
-  },
-  enumerable: {
-    natural_sort: false,
-    natural_sort_by: false
-  },
-  object: {
-    in: false,
-    not_nil: false
-  },
-  date: {
-    now: false
-  },
-  minitest: {
-    assert_changed: false,
-    assert_not_changed: false
-  }
-}
+Rearmed.enabled_patches = #{File.read(File.join(File.dirname(__FILE__), '../../rearmed/default_enabled_patches.hash'))}
 
 require 'rearmed/apply_patches'
 eos

data/lib/rearmed.rb

@@ -1,59 +1,11 @@
+require 'rearmed/version'
+
+require 'rearmed/methods'
+require 'rearmed/exceptions'
+
 module Rearmed
 
-  @enabled_patches = {
-    rails_4: {
-      or: false,
-      link_to_confirm: false
-    },
-    rails_3: {
-      pluck: false,
-      update_columns: false,
-      all: false
-    },
-    rails: {
-      pluck_to_hash: false,
-      pluck_to_struct: false,
-      find_or_create: false,
-      find_duplicates: false,
-      reset_table: false,
-      reset_auto_increment: false,
-      find_relation_each: false,
-      find_in_relation_batches: false,
-    },
-    string: {
-      valid_integer: false,
-      valid_float: false,
-      to_bool: false,
-      starts_with: false,
-      begins_with: false,
-      ends_with: false
-    },
-    hash: {
-      only: false,
-      dig: false,
-      compact: false
-    },
-    array: {
-      dig: false,
-      delete_first: false,
-      not_empty: false
-    },
-    enumerable: {
-      natural_sort: false,
-      natural_sort_by: false
-    },
-    object: {
-      in: false,
-      not_nil: false
-    },
-    date: {
-      now: false
-    },
-    minitest: {
-      assert_changed: false,
-      assert_not_changed: false
-    }
-  }
+  @enabled_patches = eval(File.read(File.join(File.dirname(__FILE__), 'rearmed/default_enabled_patches.hash')))
 
   def self.enabled_patches=(val)
     @enabled_patches = val
@@ -63,105 +15,4 @@ module Rearmed
     @enabled_patches
   end
 
-  def self.valid_integer?(str)
-    str =~ /^\d*$/ ? true : false
-  end
-
-  def self.valid_float?(str)
-    str =~ /(^(\d+)(\.)?(\d+)?$)|(^(\d+)?(\.)(\d+)$)/ ? true : false
-  end
-
-  def self.to_bool(str)
-    if str =~ /^true$/
-      true
-    elsif str =~ /^false$/
-      false
-    else
-      #raise(ArgumentError.new "incorrect element #{str}")
-      nil
-    end
-  end
-
-  def self.natural_sort_by(array)
-    array.sort_by{|x| self.naturalize_str(yield(x))}
-  end
-
-  def self.natural_sort(array, options={})
-    if block_given?
-      BlockFoundError
-    else
-      array.sort do |a,b| 
-        if options[:reverse] == true
-          self.naturalize_str(b.to_s) <=> self.naturalize_str(a.to_s)
-        else
-          self.naturalize_str(a.to_s) <=> self.naturalize_str(b.to_s)
-        end
-      end
-    end
-  end
-
-  def self.only(hash, *keys)
-    keys.map!{|key| hash.convert_key(key)} if hash.respond_to?(:convert_key, true)
-    keys.each_with_object(hash.class.new){|k, new_hash| new_hash[k] = hash[k] if hash.has_key?(k)}
-  end
-
-  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
-
-  class BlockFoundError < StandardError
-    def initialize(klass=nil)
-      super("Rearmed doesn't yet support a block on this method.")
-    end
-  end
-
-  class NoArgOrBlockGivenError < StandardError
-    def initialize(klass=nil)
-      super("Must pass an argument or a block.")
-    end
-  end
-
-  class BothArgAndBlockError < StandardError
-    def initialize(klass=nil)
-      super("Arguments and blocks must be used seperately.")
-    end
-  end
-
-  private
-  
-  def self.naturalize_str(str)
-    str.to_s.split(/(\d+)/).map{|a| a =~ /\d+/ ? a.to_i : a}
-  end
-
 end

data/lib/rearmed/default_enabled_patches.hash

@@ -0,0 +1,57 @@
+{
+  array: {
+    dig: false,
+    delete_first: false,
+    not_empty: false
+  },
+  date: {
+    now: false
+  },
+  enumerable: {
+    natural_sort: false,
+    natural_sort_by: false
+  },
+  hash: {
+    compact: false,
+    dig: false,
+    join: false,
+    only: false,
+    to_struct: false
+  },
+  object: {
+    in: false,
+    not_nil: false
+  },
+  string: {
+    begins_with: false,
+    ends_with: false,
+    starts_with: false,
+    to_bool: false,
+    valid_float: false,
+    valid_integer: false
+  },
+  minitest: {
+    assert_changed: false,
+    assert_not_changed: false
+  },
+  rails: {
+    find_duplicates: false,
+    find_in_relation_batches: false,
+    find_or_create: false,
+    find_relation_each: false,
+    newest: false,
+    pluck_to_hash: false,
+    pluck_to_struct: false,
+    reset_auto_increment: false,
+    reset_table: false
+  },
+  rails_4: {
+    link_to_confirm: false,
+    or: false
+  },
+  rails_3: {
+    all: false,
+    pluck: false,
+    update_columns: false
+  }
+}

data/lib/rearmed/exceptions.rb

@@ -0,0 +1,23 @@
+module Rearmed
+  module Exceptions
+
+    class BlockFoundError < StandardError
+      def initialize(klass=nil)
+        super("Rearmed doesn't yet support a block on this method.")
+      end
+    end
+
+    class NoArgOrBlockGivenError < StandardError
+      def initialize(klass=nil)
+        super("Must pass an argument or a block.")
+      end
+    end
+
+    class BothArgAndBlockError < StandardError
+      def initialize(klass=nil)
+        super("Arguments and blocks must be used seperately.")
+      end
+    end
+
+  end
+end

data/lib/rearmed/methods.rb

@@ -0,0 +1,109 @@
+module Rearmed
+
+  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
+
+  def self.join(hash, delimiter=', ', &block)
+    unless block_given?
+      block = -> (k,v) {
+        "#{k}: #{v}"
+      }
+    end
+
+    str = ""
+
+    hash.each_with_index do |(k,v), i| 
+      val = block.call(k,v)
+      unless val.is_a?(String)
+        val = val.to_s
+      end
+      str << val
+
+      if i+1 < hash.length
+        str << delimiter
+      end
+    end
+
+    return str
+  end
+
+  def self.natural_sort_by(array)
+    array.sort_by{|x| self.naturalize_str(yield(x))}
+  end
+
+  def self.natural_sort(array, options={})
+    if block_given?
+      Rearmed::Exceptions::BlockFoundError
+    else
+      array.sort do |a,b| 
+        if options[:reverse] == true
+          self.naturalize_str(b.to_s) <=> self.naturalize_str(a.to_s)
+        else
+          self.naturalize_str(a.to_s) <=> self.naturalize_str(b.to_s)
+        end
+      end
+    end
+  end
+
+  def self.only(hash, *keys)
+    keys.map!{|key| hash.convert_key(key)} if hash.respond_to?(:convert_key, true)
+    keys.each_with_object(hash.class.new){|k, new_hash| new_hash[k] = hash[k] if hash.has_key?(k)}
+  end
+
+  def self.to_bool(str)
+    if str =~ /^(true|1|t|T)$/
+      true
+    elsif str =~ /^(false|0|f|F)$/
+      false
+    else
+      nil
+    end
+  end
+
+  def self.valid_integer?(str)
+    str =~ /^\d*$/ ? true : false
+  end
+
+  def self.valid_float?(str)
+    str =~ /(^(\d+)(\.)?(\d+)?$)|(^(\d+)?(\.)(\d+)$)/ ? true : false
+  end
+
+  private
+  
+  def self.naturalize_str(str)
+    str.to_s.split(/(\d+)/).map{|a| a =~ /\d+/ ? a.to_i : a}
+  end
+
+end

data/lib/rearmed/monkey_patches/array.rb

@@ -10,7 +10,7 @@ Array.module_eval do
   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
+        raise Rearmed::Exceptions::BothArgAndBlockError
       elsif block_given?
         self.delete_at(self.index{|x| yield(x)} || self.length)
       elsif item || !no_arg_passed

data/lib/rearmed/monkey_patches/hash.rb

@@ -12,6 +12,22 @@ Hash.class_eval do
     end
   end
 
+  if RUBY_VERSION.to_f < 2.3 && hash_enabled || Rearmed.dig(Rearmed.enabled_patches, :hash, :dig)
+    def dig(*args)
+      Rearmed.dig(self, *args)
+    end
+  end
+
+  if hash_enabled || Rearmed.dig(Rearmed.enabled_patches, :hash, :join)
+    def join(delimiter=', ', &block)
+      if block_given?
+        Rearmed.join(self, delimiter, &block)
+      else
+        Rearmed.join(self, delimiter)
+      end
+    end
+  end
+
   if hash_enabled || Rearmed.dig(Rearmed.enabled_patches, :hash, :only)
     def only(*keys)
       Rearmed.only(self, *keys)
@@ -26,9 +42,9 @@ Hash.class_eval do
     end
   end
 
-  if RUBY_VERSION.to_f < 2.3 && hash_enabled || Rearmed.dig(Rearmed.enabled_patches, :hash, :dig)
-    def dig(*args)
-      Rearmed.dig(self, *args)
+  if hash_enabled || Rearmed.dig(Rearmed.enabled_patches, :hash, :to_struct)
+    def to_struct
+      Struct.new(*keys).new(*values)
     end
   end
 end

data/lib/rearmed/monkey_patches/rails.rb

@@ -87,8 +87,8 @@ if defined?(ActiveRecord)
         end
         
         options[:columns] ||= self.column_names.reject{|x| [self.primary_key, :created_at, :updated_at, :deleted_at].include?(x)}
-        
-        ids = self.select("MIN(#{self.primary_key}) as #{self.primary_key}").group(options[:columns]).pluck(self.primary_key)
+
+        duplicates = self.select("#{options[:columns].join(', ')}, COUNT(*)").group(options[:columns]).having("COUNT(*) > 1")
 
         if options[:delete]
           if options[:delete] == true
@@ -101,9 +101,26 @@ if defined?(ActiveRecord)
             end
           end
 
-          duplicates = self.where.not(self.primary_key => ids)
+          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
@@ -120,7 +137,7 @@ if defined?(ActiveRecord)
           end
           return nil
         else
-          return self.where.not(self.primary_key => ids)
+          return duplicates
         end
       end
     end
@@ -222,7 +239,7 @@ if defined?(ActiveRecord)
         while records.any?
           records_size = records.size
           primary_key_offset = records.last.id
-          raise "Primary key not included in the custom select clause" unless primary_key_offset
+          raise ActiveRecordError, "Primary key not included in the custom select clause" unless primary_key_offset
 
           yield records
 

data/lib/rearmed/monkey_patches/rails_4.rb

@@ -51,7 +51,7 @@ if defined?(ActiveRecord)
         while records.any?
           records_size = records.size
           primary_key_offset = records.last.id
-          raise "Primary key not included in the custom select clause" unless primary_key_offset
+          raise ActiveRecordError, "Primary key not included in the custom select clause" unless primary_key_offset
 
           yield records
 

data/lib/rearmed/version.rb

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

data/test/tc_rearmed.rb

@@ -137,13 +137,28 @@ class TestRearmed < MiniTest::Test
     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'})
+
+    hash = {foo: :bar, bar: :foo}
+    eql(hash.join, "foo: bar, bar: foo")
+    eql(hash.join('___'), "foo: bar___bar: foo")
+    eql(hash.join{|k,v| v}, "bar, foo")
+    eql(hash.join('___'){|k,v| v}, "bar___foo")
+    eql(Rearmed.join(hash), "foo: bar, bar: foo")
+    eql(Rearmed.join(hash, '___'), "foo: bar___bar: foo")
+    eql(Rearmed.join(hash){|k,v| v}, "bar, foo")
+    eql(Rearmed.join(hash, '___'){|k,v| v}, "bar___foo")
+
+    hash = {foo: :bar, bar: 'foo'}
+    struct = hash.to_struct
+    assert(struct.is_a?(Struct))
+    eql(struct.foo, :bar)
+    eql(struct.bar, 'foo')
   end
 
   def test_object

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rearmed
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Weston Ganger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-03 00:00:00.000000000 Z
+date: 2017-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -66,6 +66,9 @@ files:
 - lib/generators/rearmed/setup_generator.rb
 - lib/rearmed.rb
 - lib/rearmed/apply_patches.rb
+- lib/rearmed/default_enabled_patches.hash
+- lib/rearmed/exceptions.rb
+- lib/rearmed/methods.rb
 - lib/rearmed/monkey_patches/array.rb
 - lib/rearmed/monkey_patches/date.rb
 - lib/rearmed/monkey_patches/enumerable.rb
@@ -97,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: A collection of helpful methods and monkey patches for Objects, Strings,