Fix rubocop errors

Ricard Forniol · Ricard Forniol · commit c7f77b633513 · 2019-12-03T16:27:47.000+01:00
diff --git a/Gemfile b/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
diff --git a/lib/mongoid/token.rb b/lib/mongoid/token.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Token
     extend ActiveSupport::Concern
@@ -24,9 +26,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 +58,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
 
diff --git a/lib/mongoid/token/collision_resolver.rb b/lib/mongoid/token/collision_resolver.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Token
     module SafeOperationsHandler
diff --git a/lib/mongoid/token/collision_retries_exceeded.rb b/lib/mongoid/token/collision_retries_exceeded.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Token
     class CollisionRetriesExceeded < Error
@@ -7,7 +9,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
diff --git a/lib/mongoid/token/collisions.rb b/lib/mongoid/token/collisions.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Token
     module Collisions
@@ -10,6 +12,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 +24,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
diff --git a/lib/mongoid/token/error.rb b/lib/mongoid/token/error.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Token
     class Error < StandardError; end
diff --git a/lib/mongoid/token/finders.rb b/lib/mongoid/token/finders.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mongoid
   module Token
     module Finders
@@ -6,7 +8,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
diff --git a/lib/mongoid/token/generator.rb b/lib/mongoid/token/generator.rb
@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 # proposed pattern options
 # %c - lowercase character
 # %C - uppercase character
@@ -7,73 +8,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
diff --git a/lib/mongoid/token/options.rb b/lib/mongoid/token/options.rb
@@ -1,6 +1,20 @@
+# frozen_string_literal: true
+
 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 +48,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
diff --git a/lib/mongoid_token.rb b/lib/mongoid_token.rb
@@ -1,4 +1,6 @@
-require 'zeitwerk'
-require 'active_support/concern'
+# frozen_string_literal: true
+
+require "zeitwerk"
+require "active_support/concern"
 loader = Zeitwerk::Loader.for_gem
 loader.setup
diff --git a/spec/mongoid/token/collisions_spec.rb b/spec/mongoid/token/collisions_spec.rb
@@ -8,7 +8,7 @@
 
       before(:each) do
         allow(resolver).to receive(:field_name).and_return(:token)
-        allow(resolver).to receive(:create_new_token_for){|doc|}
+        allow(resolver).to receive(:create_new_token_for) { |doc| }
         document.class.send(:include, Mongoid::Token::Collisions)
         allow(document).to receive(:duplicate_token_error?).and_return(true)
         allow(document.class).to receive(:resolvers).and_return([resolver])
@@ -58,8 +58,8 @@
 
       context "and a different index is violated" do
         it "should bubble the operation failure" do
-          allow(document).to(receive(:duplicate_token_error?)
-                             .and_return(false))
+          allow(document).to(receive(:duplicate_token_error?).
+                             and_return(false))
           allow(resolver).to receive(:retry_count).and_return(3)
           e = Mongo::Error::OperationFailure.new("nope")
           expect do
@@ -93,7 +93,7 @@
 
     it "should raise an error" do
       expect { document.raise_collision_retries_exceeded_error(:token, 3) }.to(
-        raise_error(Mongoid::Token::CollisionRetriesExceeded)
+        raise_error(Mongoid::Token::CollisionRetriesExceeded),
       )
     end
   end
@@ -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
diff --git a/spec/mongoid/token/finders_spec.rb b/spec/mongoid/token/finders_spec.rb
@@ -19,19 +19,25 @@
   end
 
   it "retrieve a document using the dynamic finder" do
-    class Document; include Mongoid::Document; field :token; end
+    class Document
+      include Mongoid::Document
+      field :token
+    end
+
     document = Document.create!(token: "1234")
     Mongoid::Token::Finders.define_custom_token_finder_for(Document)
     expect(Document.find_by_token("1234")).to eq(document)
   end
 
-  it 'retrieves multiple documents using the dynamic finder' do
-    class Document; include Mongoid::Document; field :token; end
+  it "retrieves multiple documents using the dynamic finder" do
+    class Document
+      include Mongoid::Document
+      field :token
+    end
+
     document = Document.create!(token: "1234")
     document2 = Document.create!(token: "5678")
     Mongoid::Token::Finders.define_custom_token_finder_for(Document)
-    expect(Document.find_by_token(["1234", "5678"])).to(
-      eq([document, document2])
-    )
+    expect(Document.find_by_token(%w[1234 5678])).to(eq([document, document2]))
   end
 end
diff --git a/spec/mongoid/token/options_spec.rb b/spec/mongoid/token/options_spec.rb
@@ -1,7 +1,6 @@
 require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
 
 describe Mongoid::Token::Options do
-
   let(:options) do
     Mongoid::Token::Options.new(length: 9999,
                                 retry_count: 8888,
diff --git a/spec/mongoid/token_spec.rb b/spec/mongoid/token_spec.rb
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+# frozen_string_literal: true`
	`2`	`+`
`1`	`3`	`module Mongoid`
`2`	`4`	`module Token`
`3`	`5`	`module SafeOperationsHandler`