Fix rubocop errors

Author: Ricard Forniol

Gemfile

@@ -3,8 +3,8 @@ source "http://rubygems.org"
 gemspec
 
 group :test do
-  gem 'rspec'
   gem "codeclimate-test-reporter", require: nil
-  gem 'database_cleaner'
-  gem 'mongoid-rspec'
+  gem "database_cleaner"
+  gem "mongoid-rspec"
+  gem "rspec"
 end

lib/mongoid/token.rb

@@ -24,9 +24,10 @@ def resolvers
       end
 
       private
+
       def add_token_field_and_index(options)
-        self.field options.field_name, :type => String, :default => default_value(options)
-        self.index({ options.field_name => 1 }, { :unique => true, :sparse => true })
+        field options.field_name, type: String, default: default_value(options)
+        index({ options.field_name => 1 }, unique: true, sparse: true)
       end
 
       def add_token_collision_resolver(options)
@@ -55,24 +56,26 @@ def set_token_callbacks(options)
       end
 
       def override_to_param(options)
-        self.send(:define_method, :to_param) do
-          self.send(options.field_name) || super()
+        send(:define_method, :to_param) do
+          send(options.field_name) || super()
         end
       end
 
       def default_value(options)
-        options.generate_on_init && Mongoid::Token::Generator.generate(options.pattern) || nil
+        options.generate_on_init &&
+          Mongoid::Token::Generator.generate(options.pattern) || nil
       end
     end
 
     protected
+
     def create_token(field_name, pattern)
-      self.send :"#{field_name.to_s}=", self.generate_token(pattern)
+      send :"#{field_name}=", generate_token(pattern)
     end
 
     def create_token_if_nil(field_name, pattern)
       if self[field_name.to_sym].blank?
-        self.create_token field_name, pattern
+        create_token field_name, pattern
       end
     end
 

lib/mongoid/token/collision_retries_exceeded.rb

@@ -7,7 +7,8 @@ def initialize(resource = "unknown resource", attempts = "unspecified")
       end
 
       def to_s
-        "Failed to generate unique token for #{@resource} after #{@attempts} attempts."
+        "Failed to generate unique token for #{@resource} after #{@attempts} "\
+        "attempts."
       end
     end
   end

lib/mongoid/token/collisions.rb

@@ -10,6 +10,7 @@ def resolve_token_collisions
             duplicate_token_error?(e, self, r.field_name)
           end.first
           raise e unless resolver
+
           retries ||= resolver.retry_count
           if (retries -= 1) >= 0
             resolver.create_new_token_for(self)
@@ -21,12 +22,16 @@ def resolve_token_collisions
       end
 
       def raise_collision_retries_exceeded_error(field_name, retry_count)
-        Rails.logger.warn "[Mongoid::Token] Warning: Maximum token generation retries (#{retry_count}) exceeded on `#{field_name}'." if defined?(Rails)
+        if defined?(Rails)
+          Rails.logger.warn "[Mongoid::Token] Warning: Maximum token "\
+                            "generation retries (#{retry_count}) exceeded on "\
+                            "`#{field_name}'."
+        end
         raise Mongoid::Token::CollisionRetriesExceeded.new(self, retry_count)
       end
 
       def duplicate_token_error?(err, document, field_name)
-        [11000, 11001].include?(err.code) &&
+        [11_000, 11_001].include?(err.code) &&
           err.message =~ /dup key/ &&
           err.message =~ /"#{document.send(field_name)}"/ &&
           true

lib/mongoid/token/finders.rb

@@ -6,7 +6,7 @@ def self.define_custom_token_finder_for(klass, field_name = :token)
           if token.is_a?(Array)
             self.in field_name.to_sym => token
           else
-            self.find_by field_name.to_sym => token
+            find_by field_name.to_sym => token
           end
         end
       end

lib/mongoid/token/generator.rb

@@ -7,73 +7,73 @@
 # %w - upper and lower alpha character
 # %p - URL-safe punctuation
 #
-# Any pattern can be followed by a number, representing how many of that type to generate
+# Any pattern can be followed by a number, representing how many of that type
+# to generate
 
 module Mongoid
   module Token
     module Generator
       REPLACE_PATTERN = /%((?<character>[cCdDhHpsw]{1})(?<length>\d+(,\d+)?)?)/
+      TYPES = {
+        c: ->(length) { down_character(length) },
+        C: ->(length) { up_character(length) },
+        d: ->(length) { digits(length) },
+        D: ->(length) { integer(length) },
+        h: ->(length) { digits(length, 16) },
+        H: ->(length) { integer(length, 16) },
+        s: ->(length) { alphanumeric(length) },
+        w: ->(length) { alpha(length) },
+        p: ->(_length) { "-" }
+      }.freeze
 
       def self.generate(pattern)
-        pattern.gsub REPLACE_PATTERN do |match|
-          match_data = $~
-          type = match_data[:character]
-          length = [match_data[:length].to_i, 1].max
+        pattern.gsub REPLACE_PATTERN do
+          match = $~
+          type = match[:character]
+          length = [match[:length].to_i, 1].max
 
-          case type
-          when 'c'
-            down_character(length)
-          when 'C'
-            up_character(length)
-          when 'd'
-            digits(length)
-          when 'D'
-            integer(length)
-          when 'h'
-            digits(length, 16)
-          when 'H'
-            integer(length, 16)
-          when 's'
-            alphanumeric(length)
-          when 'w'
-            alpha(length)
-          when 'p'
-            "-"
-          end
+          TYPES[type.to_sym].call(length)
         end
       end
 
-      private
       def self.rand_string_from_chars(chars, length = 1)
-        Array.new(length).map{ chars.sample }.join
+        Array.new(length).map { chars.sample }.join
       end
 
       def self.down_character(length = 1)
-        self.rand_string_from_chars ('a'..'z').to_a, length
+        rand_string_from_chars ("a".."z").to_a, length
       end
 
       def self.up_character(length = 1)
-        self.rand_string_from_chars ('A'..'Z').to_a, length
+        rand_string_from_chars ("A".."Z").to_a, length
       end
 
       def self.integer(length = 1, base = 10)
-        (rand(base**length - base**(length-1)) + base**(length-1)).to_s(base)
+        (rand(base**length - base**(length - 1)) + base**(length - 1)).
+          to_s(base)
       end
 
       def self.digits(length = 1, base = 10)
         rand(base**length).to_s(base).rjust(length, "0")
       end
 
       def self.alpha(length = 1)
-        self.rand_string_from_chars (('A'..'Z').to_a + ('a'..'z').to_a), length
+        rand_string_from_chars (("A".."Z").to_a + ("a".."z").to_a), length
       end
 
       def self.alphanumeric(length = 1)
-        (1..length).collect { (i = Kernel.rand(62); i += ((i < 10) ? 48 : ((i < 36) ? 55 : 61 ))).chr }.join
+        (1..length).map do
+          i = Kernel.rand(62)
+          if i < 10
+            i + 48
+          else
+            i + (i < 36 ? 55 : 61)
+          end.chr
+        end.join
       end
 
       def self.punctuation(length = 1)
-        self.rand_string_from_chars ['.','-','_','=','+','$'], length
+        rand_string_from_chars %w[. - _ = + $], length
       end
     end
   end

lib/mongoid/token/options.rb

@@ -1,6 +1,18 @@
 module Mongoid
   module Token
     class Options
+      PATTERNS = {
+        alphanumeric: ->(length) { "%s#{length}" },
+        alpha: ->(length) { "%w#{length}" },
+        alpha_upper: ->(length) { "%C#{length}" },
+        alpha_lower: ->(length) { "%c#{length}" },
+        numeric: ->(length) { "%d1,#{length}" },
+        fixed_numeric: ->(length) { "%d#{length}" },
+        fixed_numeric_no_leading_zeros: ->(length) { "%D#{length}" },
+        fixed_hex_numeric: ->(length) { "%h#{length}" },
+        fixed_hex_numeric_no_leading_zeros: ->(length) { "%H#{length}" }
+      }.freeze
+
       def initialize(options = {})
         @options = merge_defaults validate_options(options)
       end
@@ -34,32 +46,17 @@ def generate_on_init
       end
 
       def pattern
-        @options[:pattern] ||= case @options[:contains].to_sym
-        when :alphanumeric
-          "%s#{@options[:length]}"
-        when :alpha
-          "%w#{@options[:length]}"
-        when :alpha_upper
-          "%C#{@options[:length]}"
-        when :alpha_lower
-          "%c#{@options[:length]}"
-        when :numeric
-          "%d1,#{@options[:length]}"
-        when :fixed_numeric
-          "%d#{@options[:length]}"
-        when :fixed_numeric_no_leading_zeros
-          "%D#{@options[:length]}"
-        when :fixed_hex_numeric
-          "%h#{@options[:length]}"
-        when :fixed_hex_numeric_no_leading_zeros
-          "%H#{@options[:length]}"
-        end
+        @options[:pattern] ||=
+          PATTERNS[@options[:contains]].call(@options[:length])
       end
 
       private
+
       def validate_options(options)
-        if options.has_key?(:retry)
-          STDERR.puts "Mongoid::Token Deprecation Warning: option `retry` has been renamed to `retry_count`. `:retry` will be removed in v2.1"
+        if options.key?(:retry)
+          warn "Mongoid::Token Deprecation Warning: option `retry` has "\
+               "been renamed to `retry_count`. `:retry` will be "\
+               "removed in v2.1"
           options[:retry_count] = options[:retry]
         end
         options

spec/mongoid/token/collisions_spec.rb

@@ -107,7 +107,7 @@
         allow(document).to receive("token").and_return("tokenvalue123")
         allow(err).to(receive("message").and_return(message))
       end
-      let(:err) { double('Mongo::Error::OperationFailure', code: 11000) }
+      let(:err) { double('Mongo::Error::OperationFailure', code: 11_000) }
       subject { document.duplicate_token_error?(err, document, :token) }
 
       context "mongodb version 2.6, 3.0" do

spec/mongoid/token_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require File.join(File.dirname(__FILE__), %w[.. spec_helper])
 
 describe Mongoid::Token do

spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "simplecov"
 require "codeclimate-test-reporter"
 SimpleCov.start