mongoid_token_r 4.0.0

data/lib/mongoid/token/collision_resolver.rb

@@ -0,0 +1,37 @@
+require 'mongoid/token/collisions'
+
+module Mongoid
+  module Token
+    class CollisionResolver
+      attr_accessor :create_new_token
+      attr_reader :klass
+      attr_reader :field_name
+      attr_reader :retry_count
+
+      def initialize(klass, field_name, retry_count)
+        @create_new_token = Proc.new {|doc|}
+        @klass = klass
+        @field_name = field_name
+        @retry_count = retry_count
+        klass.send(:include, Mongoid::Token::Collisions)
+        alias_method_with_collision_resolution(:insert)
+        alias_method_with_collision_resolution(:upsert)
+      end
+
+      def create_new_token_for(document)
+        @create_new_token.call(document)
+      end
+
+      private
+      def alias_method_with_collision_resolution(method)
+        handler = self
+        klass.send(:define_method, :"#{method.to_s}_with_#{handler.field_name}_safety") do |method_options = {}|
+          self.resolve_token_collisions handler do
+            with(:safe => true).send(:"#{method.to_s}_without_#{handler.field_name}_safety", method_options)
+          end
+        end
+        klass.alias_method_chain method.to_sym, :"#{handler.field_name}_safety"
+      end
+    end
+  end
+end

data/lib/mongoid/token/collisions.rb

@@ -0,0 +1,33 @@
+module Mongoid
+  module Token
+    module Collisions
+      def resolve_token_collisions(resolver)
+        retries = resolver.retry_count
+        begin
+          yield
+        rescue Mongo::Error::OperationFailure => e
+          if is_duplicate_token_error?(e, self, resolver.field_name)
+            if (retries -= 1) >= 0
+              resolver.create_new_token_for(self)
+              retry
+            end
+            raise_collision_retries_exceeded_error resolver.field_name, resolver.retry_count
+          else
+            raise e
+          end
+        end
+      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)
+        raise Mongoid::Token::CollisionRetriesExceeded.new(self, retry_count)
+      end
+
+      def is_duplicate_token_error?(err, document, field_name)
+        err.message =~ /(11000|11001)/ &&
+          err.message =~ /dup key/ &&
+          err.message =~ /"#{document.send(field_name)}"/
+      end
+    end
+  end
+end

data/lib/mongoid/token/exceptions.rb

@@ -0,0 +1,16 @@
+module Mongoid
+  module Token
+    class Error < StandardError; end
+
+    class CollisionRetriesExceeded < Error
+      def initialize(resource = "unknown resource", attempts = "unspecified")
+        @resource = resource
+        @attempts = attempts
+      end
+
+      def to_s
+        "Failed to generate unique token for #{@resource} after #{@attempts} attempts."
+      end
+    end
+  end
+end

data/lib/mongoid/token/finders.rb

@@ -0,0 +1,15 @@
+module Mongoid
+  module Token
+    module Finders
+      def self.define_custom_token_finder_for(klass, field_name = :token)
+        klass.define_singleton_method(:"find_by_#{field_name}") do |token|
+          if token.is_a?(Array)
+            self.in field_name.to_sym => token
+          else
+            self.find_by field_name.to_sym => token
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/token/generator.rb

@@ -0,0 +1,80 @@
+# proposed pattern options
+# %c - lowercase character
+# %C - uppercase character
+# %d - digit
+# %D - non-zero digit / no-leading zero digit if longer than 1
+# %s - alphanumeric character
+# %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
+
+module Mongoid
+  module Token
+    module Generator
+      REPLACE_PATTERN = /%((?<character>[cCdDhHpsw]{1})(?<length>\d+(,\d+)?)?)/
+
+      def self.generate(pattern)
+        pattern.gsub REPLACE_PATTERN do |match|
+          match_data = $~
+          type = match_data[:character]
+          length = [match_data[: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
+        end
+      end
+
+      private
+      def self.rand_string_from_chars(chars, length = 1)
+        Array.new(length).map{ chars.sample }.join
+      end
+
+      def self.down_character(length = 1)
+        self.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
+      end
+
+      def self.integer(length = 1, base = 10)
+        (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
+      end
+
+      def self.alphanumeric(length = 1)
+        (1..length).collect { (i = Kernel.rand(62); i += ((i < 10) ? 48 : ((i < 36) ? 55 : 61 ))).chr }.join
+      end
+
+      def self.punctuation(length = 1)
+        self.rand_string_from_chars ['.','-','_','=','+','$'], length
+      end
+    end
+  end
+end

data/lib/mongoid/token/options.rb

@@ -0,0 +1,78 @@
+class Mongoid::Token::Options
+  def initialize(options = {})
+    @options = merge_defaults validate_options(options)
+  end
+
+  def length
+    @options[:length]
+  end
+
+  def retry_count
+    @options[:retry_count]
+  end
+
+  def contains
+    @options[:contains]
+  end
+
+  def field_name
+    !@options[:id] && @options[:field_name] || :_id
+  end
+
+  def skip_finders?
+    @options[:skip_finders]
+  end
+
+  def override_to_param?
+    @options[:override_to_param]
+  end
+
+  def generate_on_init
+    @options[:id] || @options[: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
+  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"
+      options[:retry_count] = options[:retry]
+    end
+    options
+  end
+
+  def merge_defaults(options)
+    {
+      id: false,
+      length: 4,
+      retry_count: 3,
+      contains: :alphanumeric,
+      field_name: :token,
+      skip_finders: false,
+      override_to_param: true,
+      generate_on_init: false
+    }.merge(options)
+  end
+end

data/lib/mongoid_token.rb

@@ -0,0 +1 @@
+require 'mongoid/token'

data/lib/version.rb

@@ -0,0 +1,3 @@
+module MongoidToken
+  VERSION = "4.0.0"
+end

data/mongoid_token.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "version"
+
+Gem::Specification.new do |s|
+  s.name        = "mongoid_token_r"
+  s.version     = MongoidToken::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Nicholas Bruning"]
+  s.email       = ["nicholas@bruning.com.au"]
+  s.homepage    = "http://github.com/thetron/mongoid_token"
+  s.licenses    = ['MIT']
+  s.summary     = %q{A little random, unique token generator for Mongoid documents.}
+  s.description = %q{Mongoid token is a gem for creating random, unique tokens for mongoid documents. Highly configurable and great for making URLs a little more compact.}
+
+  s.rubyforge_project = "mongoid_token"
+  s.add_dependency 'mongoid', '~> 5.0'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/mongoid/token/collisions_spec.rb

@@ -0,0 +1,101 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+
+describe Mongoid::Token::Collisions do
+  let(:document) { Object.new }
+  describe "#resolve_token_collisions" do
+    context "when there is a duplicate token" do
+      let(:resolver) { double("Mongoid::Token::CollisionResolver") }
+
+      before(:each) do
+        resolver.stub(:field_name).and_return(:token)
+        resolver.stub(:create_new_token_for){|doc|}
+        document.class.send(:include, Mongoid::Token::Collisions)
+        document.stub(:is_duplicate_token_error?).and_return(true)
+      end
+
+      context "and there are zero retries" do
+        it "should raise an error after the first try" do
+          resolver.stub(:retry_count).and_return(0)
+          attempts = 0
+          expect{document.resolve_token_collisions(resolver) { attempts += 1; raise Mongo::Error::OperationFailure }}.to raise_error Mongoid::Token::CollisionRetriesExceeded
+          expect(attempts).to eq 1
+        end
+      end
+
+      context "and retries is set to 1" do
+        it "should raise an error after retrying once" do
+          resolver.stub(:retry_count).and_return(1)
+          attempts = 0
+          expect{document.resolve_token_collisions(resolver) { attempts += 1; raise Mongo::Error::OperationFailure }}.to raise_error Mongoid::Token::CollisionRetriesExceeded
+          expect(attempts).to eq 2
+        end
+      end
+
+      context "and retries is greater than 1" do
+        it "should raise an error after retrying" do
+          resolver.stub(:retry_count).and_return(3)
+          attempts = 0
+          expect{document.resolve_token_collisions(resolver) { attempts += 1; raise Mongo::Error::OperationFailure }}.to raise_error Mongoid::Token::CollisionRetriesExceeded
+          expect(attempts).to eq 4
+        end
+      end
+
+      context "and a different index is violated" do
+        it "should bubble the operation failure" do
+          document.stub(:is_duplicate_token_error?).and_return(false)
+          resolver.stub(:retry_count).and_return(3)
+          e = Mongo::Error::OperationFailure.new("nope")
+          expect{document.resolve_token_collisions(resolver) { raise e }}.to raise_error(e)
+        end
+      end
+    end
+  end
+
+  describe "#raise_collision_retries_exceeded_error" do
+    before(:each) do
+      document.class.send(:include, Mongoid::Token::Collisions)
+    end
+
+    it "should warn the rails logger" do
+      message = nil
+
+      stub_const("Rails", Class.new)
+
+      logger = double("logger")
+      logger.stub("warn"){ |msg| message = msg }
+      Rails.stub("logger").and_return(logger)
+
+      begin
+        document.raise_collision_retries_exceeded_error(:token, 3)
+      rescue
+      end
+      expect(message).to_not be_nil
+    end
+
+    it "should raise an error" do
+      expect{ document.raise_collision_retries_exceeded_error(:token, 3) }.to raise_error(Mongoid::Token::CollisionRetriesExceeded)
+    end
+  end
+
+  describe "#is_duplicate_token_error?" do
+    before(:each) do
+      document.class.send(:include, Mongoid::Token::Collisions)
+    end
+    context "when there is a duplicate key error" do
+      it "should return true" do
+        document.stub("token").and_return("tokenvalue123")
+        err = double("Mongo::Error::OperationFailure")
+        err.stub("details").and_return do
+          {
+            "err" => "E11000 duplicate key error index: mongoid_token_test.links.$token_1  dup key: { : \"tokenvalue123\" }",
+            "code" => 11000,
+            "n" => 0,
+            "connectionId" => 130,
+            "ok" => 1.0
+          }
+          document.is_duplicate_token_error?(err, document, :token)
+        end
+      end
+    end
+  end
+end

data/spec/mongoid/token/exceptions_spec.rb

@@ -0,0 +1,4 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+
+describe Mongoid::Token::CollisionRetriesExceeded do
+end

data/spec/mongoid/token/finders_spec.rb

@@ -0,0 +1,30 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+
+describe Mongoid::Token::Finders do
+  after do
+    Object.send(:remove_const, :Document) if Object.constants.include?(:Document)
+    Object.send(:remove_const, :AnotherDocument) if Object.constants.include?(:AnotherDocument)
+  end
+
+  it "define a finder based on a field_name" do
+    klass = Class.new
+    field = :another_token
+    Mongoid::Token::Finders.define_custom_token_finder_for(klass, field)
+    klass.singleton_methods.should include(:"find_by_#{field}")
+  end
+
+  it "retrieve a document using the dynamic finder" do
+    class Document; include Mongoid::Document; field :token; end
+    document = Document.create!(:token => "1234")
+    Mongoid::Token::Finders.define_custom_token_finder_for(Document)
+    Document.find_by_token("1234").should == document
+  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)
+    Document.find_by_token(["1234", "5678"]).should == [document, document2]
+  end
+end

data/spec/mongoid/token/generator_spec.rb

@@ -0,0 +1,57 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+
+describe Mongoid::Token::Generator do
+  describe "#generate" do
+    it "generates lowercase characters" do
+      100.times{ Mongoid::Token::Generator.generate("%c").should =~ /[a-z]/ }
+    end
+
+    it "generates uppercase characters" do
+      100.times{ Mongoid::Token::Generator.generate("%C").should =~ /[A-Z]/ }
+    end
+
+    it "generates digits" do
+      100.times{ Mongoid::Token::Generator.generate("%d").should =~ /[0-9]/ }
+    end
+
+    it "generates non-zero digits" do
+      100.times{ Mongoid::Token::Generator.generate("%D").should =~ /[1-9]/ }
+    end
+
+    it "generates hexdigits" do
+      100.times{ Mongoid::Token::Generator.generate("%h").should =~ /[0-9a-f]/ }
+    end
+
+    it "generates non-zero hexdigits" do
+      100.times{ Mongoid::Token::Generator.generate("%H").should =~ /[1-9a-f]/ }
+    end
+
+    it "generates alphanumeric characters" do
+      100.times{ Mongoid::Token::Generator.generate("%s").should =~ /[A-Za-z0-9]/ }
+    end
+
+    it "generates upper and lowercase characters" do
+      100.times{ Mongoid::Token::Generator.generate("%w").should =~ /[A-Za-z]/ }
+    end
+
+    it "generates URL-safe punctuation" do
+      100.times{ Mongoid::Token::Generator.generate("%p").should =~ /[\.\-\_\=\+\$]/ }
+    end
+
+    it "generates patterns of a fixed length" do
+      100.times{ Mongoid::Token::Generator.generate("%s8").should =~ /[A-Za-z0-9]{8}/ }
+    end
+
+    it "generates patterns of a variable length" do
+      100.times{ Mongoid::Token::Generator.generate("%s1,5").should =~ /[A-Za-z0-9]{1,5}/ }
+    end
+
+    it "generates patterns with static prefixes/suffixes" do
+      100.times { Mongoid::Token::Generator.generate("prefix-%s4-suffix").should =~ /prefix\-[A-Za-z0-9]{4}\-suffix/ }
+    end
+
+    it "generates more complex patterns" do
+      100.times { Mongoid::Token::Generator.generate("pre-%d4-%C3-%d4").should =~ /pre\-[0-9]{4}\-[A-Z]{3}\-[0-9]{4}/ }
+    end
+  end
+end