mongoid-ids 0.1.1

data/lib/mongoid/ids.rb

@@ -0,0 +1,83 @@
+require 'mongoid/ids/exceptions'
+require 'mongoid/ids/options'
+require 'mongoid/ids/generator'
+require 'mongoid/ids/finders'
+require 'mongoid/ids/collision_resolver'
+
+module Mongoid
+  module Ids
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # def initialize_copy(source)
+      #   super(source)
+      #   self.token = nil
+      # end
+
+      def token(*args)
+        options = Mongoid::Ids::Options.new(args.extract_options!)
+        options.field_name = args.join
+
+        add_token_collision_resolver(options)
+
+        if options.field_name == :_id
+          self.field :_id, default: -> { generate_token(options.pattern) }
+        else
+          set_token_callbacks(options)
+          add_token_field_and_index(options)
+
+          define_custom_finders(options) if options.skip_finders? == false
+          override_to_param(options) if options.override_to_param?
+        end
+      end
+
+      private
+      def add_token_field_and_index(options)
+        self.field(options.field_name, :type => String, :default => nil)
+        self.index({ options.field_name => 1 }, { :unique => true, :sparse => true })
+      end
+
+      def add_token_collision_resolver(options)
+        resolver = Mongoid::Ids::CollisionResolver.new(self, options.field_name, options.retry_count)
+        resolver.create_new_token = Proc.new do |document|
+          document.send(:create_token, options.field_name, options.pattern)
+        end
+      end
+
+      def define_custom_finders(options)
+        Finders.define_custom_token_finder_for(self, options.field_name)
+      end
+
+      def set_token_callbacks(options)
+        set_callback(:create, :before) do |document|
+          document.create_token_if_nil options.field_name, options.pattern
+        end
+
+        set_callback(:save, :before) do |document|
+          document.create_token_if_nil options.field_name, options.pattern
+        end
+      end
+
+      def override_to_param(options)
+        self.send(:define_method, :to_param) do
+          self.send(options.field_name) || super()
+        end
+      end
+    end
+
+    protected
+    def create_token(field_name, pattern)
+      self.send :"#{field_name.to_s}=", self.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
+      end
+    end
+
+    def generate_token(pattern)
+      Mongoid::Ids::Generator.generate pattern
+    end
+  end
+end

data/mongoid-ids.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'mongoid/ids/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'mongoid-ids'
+  s.version     = Mongoid::Ids::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Nicholas Bruning', 'Marcos Piccinini']
+  s.homepage    = 'http://github.com/nofxx/mongoid-ids'
+  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-ids'
+  s.add_dependency 'mongoid', '~> 4.0.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/ids/collisions_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe Mongoid::Ids::Collisions do
+  let(:document) { Object.new }
+  describe "#resolve_token_collisions" do
+    context "when there is a duplicate token" do
+      let(:resolver) { double("Mongoid::Ids::CollisionResolver") }
+
+      before(:each) do
+        allow(resolver).to receive(:field_name).and_return(:token)
+        allow(resolver).to receive(:create_new_token_for){|doc|}
+        document.class.send(:include, Mongoid::Ids::Collisions)
+        allow(document).to receive(: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
+          allow(resolver).to receive(:retry_count).and_return(0)
+          attempts = 0
+          expect{document.resolve_token_collisions(resolver) { attempts += 1; raise Moped::Errors::OperationFailure.new("","") }}.to raise_error Mongoid::Ids::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
+          allow(resolver).to receive(:retry_count).and_return(1)
+          attempts = 0
+          expect{document.resolve_token_collisions(resolver) { attempts += 1; raise Moped::Errors::OperationFailure.new("","") }}.to raise_error Mongoid::Ids::CollisionRetriesExceeded
+          expect(attempts).to eq 2
+        end
+      end
+
+      context "and retries is greater than 1" do
+        it "should raise an error after retrying" do
+          allow(resolver).to receive(:retry_count).and_return(3)
+          attempts = 0
+          expect{document.resolve_token_collisions(resolver) { attempts += 1; raise Moped::Errors::OperationFailure.new("","") }}.to raise_error Mongoid::Ids::CollisionRetriesExceeded
+          expect(attempts).to eq 4
+        end
+      end
+
+      context "and a different index is violated" do
+        it "should bubble the operation failure" do
+          allow(document).to receive(:is_duplicate_token_error?).and_return(false)
+          allow(resolver).to receive(:retry_count).and_return(3)
+          e = Moped::Errors::OperationFailure.new("command", {:details => "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::Ids::Collisions)
+    end
+
+    it "should warn the rails logger" do
+      message = nil
+
+      stub_const("Rails", Class.new)
+
+      logger = double("logger")
+      allow(logger).to receive("warn"){ |msg| message = msg }
+      allow(Rails).to receive("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::Ids::CollisionRetriesExceeded)
+    end
+  end
+
+  describe "#is_duplicate_token_error?" do
+    before(:each) do
+      document.class.send(:include, Mongoid::Ids::Collisions)
+    end
+    context "when there is a duplicate key error" do
+      it "should return true" do
+        allow(document).to receive("token").and_return("tokenvalue123")
+        err = double("Moped::Errors::OperationFailure")
+        allow(err).to receive("details") do
+          {
+            "err" => "E11000 duplicate key error index: mongoid_ids_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/ids/exceptions_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Mongoid::Ids::CollisionRetriesExceeded do
+end

data/spec/mongoid/ids/finders_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Mongoid::Ids::Finders do
+  before :each do
+  end
+
+  it 'define a finder based on a field_name' do
+    klass = Class.new
+    field = :another_token
+    Mongoid::Ids::Finders.define_custom_token_finder_for(klass, field)
+    expect(klass.singleton_methods).to include(:"find_by_#{field}")
+  end
+
+  it 'don\'t override the `find` method of the document' do
+    klass = Class.new
+    klass.define_singleton_method(:find) { |*args| :original_find }
+    klass.define_singleton_method(:find_by) { |*args| :token_find }
+
+    Mongoid::Ids::Finders.define_custom_token_finder_for(klass)
+
+    expect(klass.find(BSON::ObjectId.new)).to eq(:original_find)
+    expect(klass.find(BSON::ObjectId.new, BSON::ObjectId.new)).to eq(:original_find)
+    expect(klass.find()).to eq(:original_find)
+    expect(klass.find(BSON::ObjectId.new, 'token')).to eq(:original_find)
+    expect(klass.find('token')).to eq(:original_find)
+  end
+
+  it 'retrieve a document using the dynamic finder' do
+    class Document; include Mongoid::Document; field :token; end
+    document = Document.create!(token: '1234')
+    Mongoid::Ids::Finders.define_custom_token_finder_for(Document)
+    expect(Document.find_by_token('1234')).to eq(document)
+  end
+
+  it 'retrieve a document using the `find` method' do
+    class AnotherDocument; include Mongoid::Document;  end
+    document = AnotherDocument.create! :_id => '1234'
+    Mongoid::Ids::Finders.define_custom_token_finder_for(AnotherDocument)
+    expect(AnotherDocument.find('1234')).to eq(document)
+  end
+end

data/spec/mongoid/ids/generator_spec.rb

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

data/spec/mongoid/ids/options_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Mongoid::Ids::Options do
+  before do
+    @options = Mongoid::Ids::Options.new(
+      length: 9999,
+      retry_count: 8888,
+      contains: :nonsense,
+      field_name: :not_a_token
+    )
+  end
+
+  it 'should have a length' do
+    expect(@options.length).to eq(9999)
+  end
+
+  it 'should default to a length of 4' do
+    expect(Mongoid::Ids::Options.new.length).to eq(4)
+  end
+
+  it 'should have a retry count' do
+    expect(@options.retry_count).to eq(8888)
+  end
+
+  it 'should default to a retry count of 3' do
+    expect(Mongoid::Ids::Options.new.retry_count).to eq(3)
+  end
+
+  it 'should have a list of characters to contain' do
+    expect(@options.contains).to eq(:nonsense)
+  end
+
+  it 'should default to an alphanumeric set of characters to contain' do
+    expect(Mongoid::Ids::Options.new.contains).to eq(:alphanumeric)
+  end
+
+  it 'should default to an alphanumeric set of characters to contain' do
+    expect(Mongoid::Ids::Options.new.contains).to eq(:alphanumeric)
+  end
+
+  it 'should have a field name' do
+    expect(@options.field_name).to eq(:not_a_token)
+  end
+
+  it 'should default to a field name of \'_id\'' do
+    expect(Mongoid::Ids::Options.new.field_name).to eq(:_id)
+  end
+
+  it 'should create a pattern' do
+    expect(Mongoid::Ids::Options.new.pattern).to eq('%s4')
+  end
+
+  describe 'override_to_param' do
+    it 'should be an option' do
+      expect(Mongoid::Ids::Options.new(override_to_param: false)
+              .override_to_param?).to eq false
+    end
+
+    it 'should default to true' do
+      expect(Mongoid::Ids::Options.new.override_to_param?).to eq true
+    end
+  end
+
+  describe 'skip_finder' do
+    it 'should be an option' do
+      expect(Mongoid::Ids::Options.new(skip_finders: true)
+              .skip_finders?).to eq true
+    end
+
+    it 'should default to false' do
+      expect(Mongoid::Ids::Options.new.skip_finders?).to eq false
+    end
+  end
+end