mongoid_token_r 4.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f6d694b67ef23128e4d6dc9d2eb5f9392e1a9843
+  data.tar.gz: 17ed3109121d5e9d64228409a87452ffe7d4c717
+SHA512:
+  metadata.gz: 01575418d36384691b95b59325bdebc7a4e1fe2491d94c145cc04e9b6007d833ddbe5da50af294737d18da232e63301e3ca17d2515188c4e177d09726336fda7
+  data.tar.gz: e642f422be0838e003b05d212e23f26bd00a627787eeaef95d8cf25f9ddf322859111ec5b20202b581d252a9ed9e7a3322e2b1f6a2d89c5a27476b0221b21f8d

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.DS_Store

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,18 @@
+language: ruby
+
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.1.1
+
+gemfile:
+  - Gemfile
+
+services:
+  - mongodb
+
+env:
+  - CODECLIMATE_REPO_TOKEN=b216164ab66da464aa02fe5b862811ba0526c8dc7ea291ebe53056be4b6b5e1f
+
+script: "bundle exec rspec"

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+gemspec
+
+group :test do
+  gem 'rspec', '2.14.1'
+  gem "codeclimate-test-reporter", require: nil
+  gem 'database_cleaner'
+  gem 'mongoid-rspec', '1.5.1'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Nicholas Bruning
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,242 @@
+# Mongoid::Token - Short snappy tokens for Mongoid documents
+
+[![Build Status](https://secure.travis-ci.org/thetron/mongoid_token.png)](http://travis-ci.org/thetron/mongoid_token)
+[![Code Climate](https://codeclimate.com/github/thetron/mongoid_token.png)](https://codeclimate.com/github/thetron/mongoid_token)
+
+This library is a quick and simple way to generate unique, random tokens
+for your mongoid documents, in the cases where you can't, or don't want
+to use slugs, or the default MongoDB ObjectIDs.
+
+Mongoid::Token can help turn this:
+
+    http://bestappever.com/video/4dcfbb3c6a4f1d4c4a000012
+
+Into something more like this:
+
+    http://bestappever.com/video/8tmQ9p
+
+
+## Getting started
+
+In your gemfile, add:
+
+```ruby
+# For mongoid < 5
+gem 'mongoid_token', '~> 3.0.0'
+
+# For mongoid >= 5
+gem 'mongoid_token', '~> 4.0.0'
+```
+
+Then update your bundle
+
+    $ bundle install
+
+In your Mongoid documents, just add `include Mongoid::Token` and the
+`token` method will take care of all the setup, like so:
+
+```ruby
+class Person
+  include Mongoid::Document
+  include Mongoid::Token
+
+  field :name
+
+  token
+end
+
+```
+
+And that's it! There's lots of configuration options too - which are all
+listed [below](#configuration). By default, the `token` method will
+create tokens 4 characters long, containing random alphanumeric characters.
+
+__Note:__ Mongoid::Token leverages Mongoid's 'safe mode' by
+automatically creating a unique index on your documents using the token
+field. In order to take advantage of this feature (and ensure that your
+documents always have unique tokens) remember to create your indexes.
+
+## Using without Rails
+
+If you're using Mongoid without Rails, remember to:
+
+    require 'mongoid_token'
+
+in your app
+
+## Finders
+
+By default, the gem will add a convenience `find_by_[token name]` method, to
+make it a tiny bit simpler to query by your tokens. If you'd rather it didn't,
+you can disable these with the
+[`skip_finders` configuration option](#skip-finders-skip_finders).
+
+The methods accept either a single token, or an array of tokens:
+
+```ruby
+Video.find_by_token("x3v98") # If your token was named 'token'
+Account.find_by_account_number(["ACC-123456", "ACC-567890"]) # If your token was named 'account_number'
+```
+
+## Configuration
+
+### Tokens
+
+As of `Mongoid::Token` 2.0.0, you can now choose between two different
+systems for managing how your tokens look.
+
+For simple setup, you can use
+combination of the [`length`](#length-length) and [`contains`](#contains-contains), which modify the length and
+types of characters to use.
+
+For when you need to generate more complex tokens, you can use the
+[`pattern`](#patterns-pattern) option, which allows for very low-level control of the precise
+structure of your tokens, as well as allowing for static strings, like
+prefixes, infixes or suffixes.
+
+#### Length (`:length`)
+
+This one is easy, it's just an integer.
+
+__Example:__
+
+```ruby
+token :length => 6 # Tokens are now of length 6
+token :length => 12 # Whow, whow, whow. Slow down egghead.
+```
+
+You get the idea.
+
+The only caveat here is that if used in combination with the
+`:contains => :numeric` option, tokens may vary in length _up to_ the
+specified length.
+
+#### Contains (`:contains`)
+
+Contains has 7 different options:
+
+* `:alphanumeric` - contains uppercase & lowercase characters, as well
+as numbers
+* `:alpha` - contains only uppercase & lowercase characters
+* `:alpha_upper` - contains only uppercase letters
+* `:alpha_lower` - contains only lowercase letters
+* `:numeric` - integer, length may be shorter than `:length`
+* `:fixed_numeric` - integer, but will always be of length `:length`
+* `:fixed_numeric_no_leading_zeros` - same as `:fixed_numeric`, but will
+never start with zeros
+* `:fixed_hex_numeric` - hex integer, but will always be of length `:length`
+* `:fixed_hex_numeric_no_leading_zeros` - same as `:fixed_hex_numeric`, but will
+never start with zeros
+
+__Examples:__
+```ruby
+token :contains => :alpha_upper, :length => 8
+token :contains => :fixed_numeric
+```
+
+#### Patterns (`:pattern`)
+
+New in 2.0.0, patterns allow you fine-grained control over how your
+tokens look. It's great for generating random data that has a
+requirements to also have some basic structure. If you use the
+`:pattern` option, it will override both the `:length` and `:contains`
+options.
+
+This was designed to operate in a similar way to something like `strftime`,
+if the syntax offends you - please open an issue, I'd love to get some
+feedback here and better refine how these are generated.
+
+Any characters in the string are treated as static, except those that are
+proceeded by a `%`. Those special characters represent a single, randomly
+generated character, and are as follows:
+
+* `%s` - any uppercase, lowercase, or numeric character
+* `%w` - any uppercase, or lowercase character
+* `%c` - any lowercase character
+* `%C` - any uppercase character
+* `%d` - any digit
+* `%D` - any non-zero digit
+
+__Example:__
+
+```ruby
+token :pattern => "PRE-%C%C-%d%d%d%d" # Generates something like: 'PRE-ND-3485'
+```
+
+You can also add a repetition modifier, which can help improve readability on
+more complex patterns. You simply add any integer after the letter.
+
+__Examples:__
+
+```ruby
+token :pattern => "APP-%d6" # Generates something like; "APP-638924"
+```
+
+### Field Name (`:field_name`)
+
+This allows you to change the field name used by `Mongoid::Token`
+(default is `:token`). This is particularly handy when you're wanting to
+use multiple tokens one a single document.
+
+__Examples:__
+```ruby
+token :length => 6
+token :field_name => :sharing_token, :length => 12
+token :field_name => :yet_another
+```
+
+
+### Skip Finders (`:skip_finders`)
+
+This will prevent the gem from creating the extra `find_by_*` methods.
+
+__Example:__
+```ruby
+token :skip_finders => true
+```
+
+
+### Override to_param (`:override_to_param`)
+
+By default, `Mongoid::Token` will override to_param, to make it an easy
+drop-in replacement for the default ObjectIDs. If needed, you can turn
+this behaviour off:
+
+__Example:__
+```ruby
+token :override_to_param => false
+```
+
+
+### Retry Count (`:retry_count`)
+
+In the event of a token collision, this gem will attempt to try three
+more times before raising a `Mongoid::Token::CollisionRetriesExceeded`
+error. If you're wanting it to try harder, or less hard, then this
+option is for you.
+
+__Examples:__
+```ruby
+token :retry_count => 9
+token :retry_count => 0
+```
+
+# Notes
+
+If you find a problem, please [submit an issue](http://github.com/thetron/mongoid_token/issues) (and a failing test, if
+you can). Pull requests and feature requests are always welcome and
+greatly appreciated.
+
+Thanks to everyone that has contributed to this gem over the past year.
+Many, many thanks - you guys rawk.
+
+
+## Contributors:
+
+Thanks to everyone who has provided support for this gem over the years.
+In particular: [olliem](https://github.com/olliem),
+[msolli](https://github.com/msolli),
+[siong1987](https://github.com/siong1987),
+[stephan778](https://github.com/stephan778),
+[eagleas](https://github.com/eagleas), and
+[jamesotron](https://github.com/jamesotron).

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/benchmarks/benchmark.rb

@@ -0,0 +1,49 @@
+$: << File.expand_path("../../lib", __FILE__)
+
+require 'database_cleaner'
+require 'mongoid'
+require 'mongoid_token'
+require 'benchmark'
+
+Mongoid.configure do |config|
+  config.connect_to("mongoid_token_benchmark")
+end
+
+DatabaseCleaner.strategy = :truncation
+
+# start benchmarks
+
+TOKEN_LENGTH = 8
+
+class Link
+  include Mongoid::Document
+  include Mongoid::Token
+  field :url
+  token :length => TOKEN_LENGTH, :contains => :alphanumeric
+end
+
+class NoTokenLink
+  include Mongoid::Document
+  field :url
+end
+
+def create_link(token = true)
+  if token
+    Link.create(:url => "http://involved.com.au")
+  else
+    NoTokenLink.create(:url => "http://involved.com.au")
+  end
+end
+
+Link.destroy_all
+Link.create_indexes
+num_records = [1, 50, 100, 1000, 2000, 3000, 4000]
+puts "-- Alphanumeric token of length #{TOKEN_LENGTH} (#{62**TOKEN_LENGTH} possible tokens)"
+Benchmark.bm do |b|
+  num_records.each do |qty|
+    b.report("#{qty.to_s.rjust(5, " ")} records    "){ qty.times{ create_link(false) } }
+    b.report("#{qty.to_s.rjust(5, " ")} records tok"){ qty.times{ create_link } }
+    Link.destroy_all
+  end
+end
+

data/lib/mongoid/token.rb

@@ -0,0 +1,81 @@
+require 'mongoid/token/exceptions'
+require 'mongoid/token/options'
+require 'mongoid/token/generator'
+require 'mongoid/token/finders'
+require 'mongoid/token/collision_resolver'
+
+module Mongoid
+  module Token
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def initialize_copy(source)
+        super(source)
+        self.token = nil
+      end
+
+      def token(*args)
+        options = Mongoid::Token::Options.new(args.extract_options!)
+
+        add_token_field_and_index(options)
+        add_token_collision_resolver(options)
+        set_token_callbacks(options)
+
+        define_custom_finders(options) if options.skip_finders? == false
+        override_to_param(options) if options.override_to_param?
+      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 })
+      end
+
+      def add_token_collision_resolver(options)
+        resolver = Mongoid::Token::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
+
+      def default_value(options)
+        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)
+    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::Token::Generator.generate pattern
+    end
+  end
+end