mongokit 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b0207a9bfb1363e04a263ee0a60c68fecd226a25
+  data.tar.gz: 382598e973bd393aeb8cf2d0224bd529e42d29d1
+SHA512:
+  metadata.gz: f6f794510f044bbadbb70d37634f56c4abe9afa6ffe6f28677bbc8b5d4374f2136ec52c2366b7bd94482879421667c38fe5001edc07675eac73602eb5bc0824a
+  data.tar.gz: 93ae9fdc1f3851d39b8b40e9a2eba81bb048c9b547f176502b87f8afbac837d9d23dae861b823b281214fb7292edbd16a982071583104afb79da3eb099fe28ef

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.swp
+/spec/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.1.5

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mongokit.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Jiren[jirenpatel@gmail.com]
+
+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,39 @@
+# Mongokit
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/mongokit`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mongokit', github: 'jiren/mongokit'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mongokit # NOTE: It will not work because gem is not published
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/mongokit/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mongokit"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/mongokit.rb

@@ -0,0 +1,39 @@
+require 'mongoid'
+
+module Mongokit
+
+  MODULE_NAMES = %w(
+    AutoIncrement
+    SecureToken
+    Address
+    CsvTransformer
+    ModelHelpers
+  ).inject({}) do |result, module_name|
+    result[module_name.underscore.to_sym] = module_name
+    result
+  end
+
+  MODULE_NAMES.each do |module_name, const_name|
+    autoload const_name, "mongokit/#{module_name}"
+  end
+
+  autoload :Options, 'mongokit/utils/options'
+
+  MongokitError = Class.new(StandardError)
+
+  def self.modules
+    MODULE_NAMES.values
+  end
+
+  def self.config(options = {})
+    options[:load] = Array(options[:load])
+
+    options[:load].each do |module_name|
+      require "mongokit/#{module_name}"
+    end
+  end
+end
+
+require 'mongokit/version'
+require 'mongokit/extensions/mongoid_document'
+require 'mongokit/find_in_batch'

data/lib/mongokit/address.rb

@@ -0,0 +1,91 @@
+module Mongokit
+  module Address
+    extend ActiveSupport::Concern
+
+    #
+    # == Example
+    #   class User
+    #     include Mongoid::Document
+    #
+    #     mongokit :address
+    #     has_address
+    #
+    #     # OR
+    #     # has_address(except: [:latitude, :longitude])
+    #     # has_address(replace: {address_1: :street_1, address_2: :street_2})
+    #   end
+    #
+    #   user = User.create({
+    #     address_1:   'Studio 103',
+    #     address_2:   'The Business Centre',
+    #     street:      '61 Wellfield Road',
+    #     city:        'Roath',
+    #     state:       'Cardiff',
+    #     postal_code: 'CF24 3DG',
+    #     country:     'England'
+    #   })
+    #
+    #   user.full_address # Studio 103, The Business Centre, 61 Wellfield Road, Roath, Cardiff, CF24 3DG, England
+    #
+    module ClassMethods
+      include Options::Store
+
+      ADDRESS_FIELDS = {
+        address_1:   String,
+        address_2:   String,
+        street:      String,
+        city:        String,
+        state:       String,
+        postal_code: String,
+        country:     String,
+        latitude:    Float,
+        longitude:   Float
+      }.freeze
+
+      def has_address(options = {})
+        fields = ADDRESS_FIELDS.dup
+
+        if options[:add]
+          if options[:add].is_a?(Array)
+            options[:add] = options[:add].inject({}){|r, f| r[f] = String; r}
+          else
+            fields.merge!(options[:add])
+          end
+        end
+
+        fields = Options.process(fields, options)
+
+        fields.each do |name, type|
+          field name, type: type
+        end
+
+        mk_options.tap do |o|
+          o.put(:address_fields, fields.keys)
+          o.put(:full_address_fields, fields.reject{|f, _| f == :latitude || f == :longitude }.keys)
+        end
+      end
+
+      def address_fields
+        mk_options.get(:address_fields)
+      end
+
+      def full_address(obj, options = nil)
+        fields = mk_options.get(:full_address_fields)
+
+        if options
+          if options[:only]
+            fields = options[:only]
+          elsif options[:except]
+            fields = fields - options[:except]
+          end
+        end
+
+        fields.map{|f| obj[f]}.compact.join(', ')
+      end
+    end
+
+    def full_address(options = nil)
+      self.class.full_address(self, options)
+    end
+  end
+end

data/lib/mongokit/auto_increment.rb

@@ -0,0 +1,66 @@
+require 'mongokit/auto_increment/counter'
+require 'mongokit/auto_increment/formater'
+require 'mongokit/models/auto_increment_counter'
+
+module Mongokit
+  module AutoIncrement
+    extend ActiveSupport::Concern
+
+    included do
+      unless included_modules.include?(Mongoid::Timestamps)
+        include Mongoid::Timestamps
+      end
+    end
+
+    module ClassMethods
+      #
+      # == Example
+      #   class Order
+      #     include Mongoid::Document
+      #     mongokit :auto_increment
+      #
+      #     auto_increment :order_count,
+      #     auto_increment :order_no, pattern: "%Y%m#####"  # Default numner symbol is #
+      #   end
+      #
+      #   order = Order.create
+      #   order.order_count  # 1
+      #   order.order_no     # 20150500001
+      #
+      def auto_increment(attribute, _options = {})
+        options = {
+          number_symbol: '#',
+          start:  0,
+          step: 1
+        }
+
+        options.merge!(_options)
+        options[:attribute] = attribute
+        options[:model] = self
+        options[:type] ||= Integer
+
+        if options[:pattern]
+          options[:time_format] = Mongokit::Counter.to_time_format(options[:pattern])
+          options[:type] = String
+        end
+
+        field(attribute, type: options[:type])
+
+        # create new record in counter collection
+        Models::AutoIncrementCounter.find_or_create_with_seed(options)
+
+        after_create do |doc|
+          doc.set(attribute => Mongokit::Counter.next(options))
+        end
+
+        define_method("reserve_#{attribute}!") do
+          set(attribute => Mongokit::Counter.next(options))
+        end
+
+        define_method("current_#{attribute}_counter") do
+          Models::AutoIncrementCounter.current_counter(options)
+        end
+      end
+    end
+  end
+end

data/lib/mongokit/auto_increment/counter.rb

@@ -0,0 +1,35 @@
+module Mongokit
+  module Counter
+    module_function
+
+    def next(options)
+      record = Models::AutoIncrementCounter.where({
+        counter_model_name: options[:model].collection_name,
+        counter_field: options[:attribute]
+      }).find_and_modify({ '$inc' => { counter: options[:step] }}, new: true)
+
+      return record.counter if options[:pattern].nil?
+
+      if outdated?(record, options[:time_format])
+        record.set(counter: options[:start] + options[:step])
+      end
+
+      Formater.new.format(record.counter, options)
+    end
+
+    def outdated?(record, time_format)
+      Time.now.strftime(time_format).to_i > record.updated_at.strftime(time_format).to_i
+    end
+
+    def to_time_format(pattern)
+      event = String.new
+
+      event += '%Y' if pattern.include? '%y' or pattern.include? '%Y'
+      event += '%m' if pattern.include? '%m'
+      event += '%H' if pattern.include? '%H'
+      event += '%M' if pattern.include? '%M'
+      event += '%d' if pattern.include? '%d'
+      event
+    end
+  end
+end

data/lib/mongokit/auto_increment/formater.rb

@@ -0,0 +1,72 @@
+module Mongokit
+  class Formater
+
+    def format(number, options)
+      @options = options
+
+      build(number)
+    end
+
+    private
+
+    # gets the next number.
+    # it prepends the prefix + counter + sufix
+    # ex:
+    #   "%Y####BANK"
+    #   %Y => prefix (year)
+    #   #### => counter (starts with 0001)
+    #   BANK => sufix
+    #
+    # if we are in 2011, the first model to be saved will get "20110001BANK"
+    # the next model to be saved will get "20110002BANK", "20110003BANK"...
+    #
+    #   number => is the counter
+    #
+    #   next_custom_number(1)
+    #   => "20110001BANK"
+    def build(number)
+      prefix(@options[:pattern]).to_s +
+      counter(@options[:pattern], number).to_s +
+      sufix(@options[:pattern]).to_s
+    end
+
+    def prefix(pattern)
+      prefx = extract_prefix(pattern)
+      expand_times(prefx.to_s)
+    end
+
+    def counter(pattern, n)
+      format_counter(digits_size(pattern), n)
+    end
+
+    def sufix(pattern)
+      sufx = extract_sufix(pattern)
+      expand_times(sufx.to_s)
+    end
+
+    def format_counter(zeros, value)
+      "%0#{zeros}d" % value
+    end
+
+    def extract_prefix(pattern)
+      # Company#### => Company
+      symbol = @options[:number_symbol]
+      (pattern =~ /^(\s|\d)*[^#{symbol}]+/ and $&)
+    end
+
+    def extract_sufix(pattern)
+      # ###Company => Company
+      symbol = @options[:number_symbol]
+      (pattern =~ /[^#{symbol}]+$/ and $&)
+    end
+
+    def expand_times(pattern)
+      Time.now.strftime(pattern)
+    end
+
+    def digits_size(pattern)
+      symbol = @options[:number_symbol]
+      (pattern =~ /[#{symbol}]+/ and $&).length
+    end
+  end
+end

data/lib/mongokit/csv_transformer.rb

@@ -0,0 +1,97 @@
+require 'mongokit/csv_transformer/csv_io'
+
+module Mongokit
+  module CsvTransformer
+    extend ActiveSupport::Concern
+
+    #
+    # == Example
+    #   class Address
+    #     include Mongoid::Document
+    #
+    #     mongokit :csv_transformer
+    #
+    #     field :name
+    #     field :region
+    #     field :district
+    #     field :state
+    #     field :zip_code, type: Integer
+    #
+    #     csv_import_mapping :address, [:name, :zip_code], headers: true do |row, attrs|
+    #       attrs[:zip_code] = attrs[:zip_code].to_i
+    #     end
+    #
+    #     csv_export_mapping :address, [:zip_code, :name, :region] do |row, record|
+    #       row[:zip_code] = "IN-#{row[:zip_code]}"
+    #     end
+    #   end
+    #
+    #   Address.from_address_csv('address.csv') # Import
+    #   Address.to_address_csv('address.csv')   # Export
+    #
+    module ClassMethods
+      CsvTransformerError = Class.new(StandardError)
+
+      def csv_import_mapping(name, fields, options = {},  &block)
+        if respond_to?("from_#{name}_csv")
+          raise CsvTransformerError, "#{name} import mapper is already defined."
+        end
+
+        self.class.instance_eval do
+          define_method "from_#{name}_csv" do |file|
+            options[:columns] = fields
+            csv_import(file, options, &block)
+          end
+        end
+      end
+
+      def csv_export_mapping(name, fields, options = {},  &block)
+        if respond_to?("to_#{name}_csv")
+          raise CsvTransformerError, "#{name} export mapper is already defined."
+        end
+
+        self.class.instance_eval do
+          define_method "to_#{name}_csv" do |file, criteria = nil|
+            options[:columns] = fields
+            criteria = self.all if criteria.nil?
+            csv_export(file, criteria, options, &block)
+          end
+        end
+      end
+
+      def _csv_columns_(options = nil)
+        columns = fields.collect do |f, o|
+          if o.class == Mongoid::Fields::Standard && o.type != BSON::ObjectId
+            o.name
+          end
+        end
+
+        columns.compact!
+        options ? Options.process(options[:columns] || columns, options) : columns
+      end
+
+      def csv_export(file, criteria, options = {}, &block)
+        columns = _csv_columns_(options)
+        io = CsvIO.new(:write, file, columns, options)
+
+        criteria.in_batches do |records|
+          records.each do |record|
+            row = io.to_row(record, block)
+            io << row if row
+          end
+        end
+
+        io.close
+      end
+
+      def csv_import(file, options = {}, &block)
+        io = CsvIO.new(:read, file, options[:columns] || _csv_columns_, options)
+
+        io.each do |row|
+          attrs = io.to_attrs(row, block)
+          create(attrs) if attrs
+        end
+      end
+    end
+  end
+end

data/lib/mongokit/csv_transformer/csv_io.rb

@@ -0,0 +1,67 @@
+require 'forwardable'
+require 'csv'
+
+module Mongokit
+  class CsvIO
+    attr_reader :csv, :column_mapping, :columns, :options
+
+    extend Forwardable
+    def_delegators :@csv, :<<, :readline, :close, :each
+
+    def initialize(operation, file, columns, options = {})
+      @options = options
+      @column_mapping = build_column_mapping(columns)
+      @columns = @column_mapping.keys.map(&:to_sym)
+
+      if operation == :write
+        @csv = CSV.open(file, 'wb')
+        write_headers
+      else
+        @csv = CSV.open(file)
+        @csv.readline if options[:headers]
+      end
+    end
+
+    def build_column_mapping(columns)
+      if columns.is_a?(Array)
+        columns.zip((0..columns.length).to_a).to_h.reject{|k| k.nil? }
+      else
+        columns.sort_by{|_, pos| pos }.to_h
+      end
+    end
+
+    def write_headers
+      return if options[:headers].nil?
+
+      if options[:headers] === true
+        csv << column_mapping.map { |f, _|  f.to_s.titleize }
+      else
+        csv << options[:headers]
+      end
+    end
+
+    def to_attrs(row, block)
+      attrs = column_mapping.inject({}) do |r, (f, pos)|
+        r[f] = row[pos]
+        r
+      end
+
+      if block
+        return false if block.call(row, attrs) == false
+      end
+
+      attrs
+    end
+
+    def to_row(record, block)
+      row = CSV::Row.new(columns, columns.map {|f| record[f] })
+
+      if block
+        return false if block.call(row, record) == false
+      end
+
+      row
+    end
+
+  end
+end

data/lib/mongokit/extensions/mongoid_document.rb

@@ -0,0 +1,19 @@
+module Mongokit
+  module MongoidDocument
+    def mongokit(*modules)
+      modules = modules.map(&:to_sym).uniq
+
+      modules.each do |module_name|
+        const_name = Mongokit::MODULE_NAMES[module_name]
+
+        if const_name
+          self.send :include, Mongokit.const_get(const_name)
+        else
+          raise MongokitError, "#{module_name} not existing in mongokit"
+        end
+      end
+    end
+  end
+end
+
+Mongoid::Document::ClassMethods.send :include, Mongokit::MongoidDocument

data/lib/mongokit/find_in_batch.rb

@@ -0,0 +1,43 @@
+module Mongokit
+  #
+  # == Example
+  #   Order.in_batches do |orders|
+  #     orders.each do |order|
+  #       puts order.items
+  #     end
+  #   end
+  #
+  #   Order.in_batches(batch_size: 100, start: 50) do |orders|
+  #     ...
+  #   end
+  #
+  #   Order.where(:created_at.gt => Time.now.yesterday).in_batches do |orders|
+  #     ...
+  #   end
+  #
+  module FindInBatch
+    def in_batches(options = {})
+      criteria = self
+      start = options[:start]
+      batch_size = options[:batch_size] || 1000
+
+      criteria = criteria.limit(batch_size)
+      records = start ? criteria.offset(start).to_a : criteria.to_a
+      current_offset = start.to_i
+
+      while records.any?
+        records_size = records.size
+        current_offset += records_size
+
+        yield records
+
+        break if records_size < batch_size
+
+        records = criteria.offset(current_offset).to_a
+      end
+    end
+  end
+end
+
+Mongoid::Document::ClassMethods.send :include, Mongokit::FindInBatch
+Mongoid::Criteria.send :include, Mongokit::FindInBatch

data/lib/mongokit/model_helpers.rb

@@ -0,0 +1,75 @@
+module Mongokit
+  module ModelHelpers
+    extend ActiveSupport::Concern
+
+    #
+    # == Example
+    #
+    #   class Game
+    #     include Mongoid::Document
+    #
+    #     mongokit :model_helpers
+    #
+    #     field :format, type: String
+    #     field :category, type: Integer
+    #
+    #     multi_fields :city, { venue: 'Mumbai' }, :country  # Default string type
+    #     multi_fields :start_time, :end_time, DateTime
+    #
+    #     field_with_validation(:team_type, inclusion: { in: %w(t20 odi test) })
+    #
+    #     boolean_methods(:format, %w(t20 odi test), { postfix: 'match' } )
+    #   end
+    #
+    #   game = Game.new(format: 't20')
+    #   game.t20_match?  # true
+    #   game.odi_match?  # false
+    #
+    module ClassMethods
+      def boolean_methods(field_name, values, options = {})
+        values = values.zip(values).to_h if values.is_a?(Array)
+
+        values.each do |f, v|
+          method_name = [
+            options[:prefix],
+            f,
+            options[:postfix],
+          ].compact.join('_')
+
+          define_method "#{method_name}?" do
+            v == self[field_name]
+          end
+        end
+      end
+
+      def multi_fields(*args)
+        type = args.pop
+        fields = args
+
+        unless type.is_a?(Class)
+          fields << type
+          type = String
+        end
+
+        fields.each do |f|
+          if f.is_a?(Hash)
+            f, default_value = f.flatten
+          end
+
+          field f, type: type, default: default_value
+        end
+      end
+
+      def field_with_validation(field_name, options = {})
+        field field_name, {
+          type: options.delete(:type) || String,
+          default: options.delete(:default)
+        }
+
+        if options.any?
+          validates field_name, options
+        end
+      end
+    end
+  end
+end

data/lib/mongokit/models/auto_increment_counter.rb

@@ -0,0 +1,40 @@
+module Mongokit
+  module Models
+    class AutoIncrementCounter
+      include Mongoid::Document
+      include Mongoid::Timestamps
+
+      store_in(collection: 'auto_increment_counters')
+
+      field :counter_model_name, type: String
+      field :counter_field, type: String
+      field :counter, type: Integer, default: 0
+
+      index({ counter_model_name: 1, counter_field: 1 }, { unique: true })
+
+      def self.find_or_create_with_seed(options)
+        record = find_or_initialize_by({
+          counter_model_name: options[:model].collection_name,
+          counter_field: options[:attribute]
+        })
+
+        if record.new_record?
+          record.counter = options[:start] > 0 ? options[:start] - 1 : options[:start]
+        end
+
+        record.save
+      end
+
+      def self.current_counter(options)
+        record = Models::AutoIncrementCounter.find_by({
+          counter_model_name: options[:model].collection_name,
+          counter_field: options[:attribute]
+        })
+
+        return nil if record.nil?
+        return record.counter if options[:pattern].nil?
+        return Formater.new.format(record.counter, options)
+      end
+    end
+  end
+end

data/lib/mongokit/secure_token.rb

@@ -0,0 +1,65 @@
+require 'securerandom'
+
+module Mongokit
+  module SecureToken
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # == Example
+      #
+      #   class User
+      #     include Mongoid::Document
+      #
+      #     mongokit :secure_token
+      #
+      #     has_secure_token :auth_token
+      #     # has_secure_token :auth_token, token_length: 20
+      #
+      #     # multiple tokens
+      #     # has_secure_token :public_key
+      #     # has_secure_token :private_key, token_length: 20
+      #   end
+      #
+      #   user = User.new
+      #   user.save
+      #   user.auth_token # => "77TMHrHJFvFDwodq8w7Ev2m7"
+      #   user.regenerate_auth_token! # => true
+      #
+      def has_secure_token(attribute, options = {})
+        field(attribute, type: String)
+        index({ attribute => 1 }, { unique: true })
+
+        @_st_options_ ||= {}
+        @_st_options_[attribute] =  (options || {}).tap do |o|
+          o[:random_string] = (('0'..'9').to_a  + ('A'..'Z').to_a + ('a'..'z').to_a - ['0', 'O', 'I', 'l']).sample(4).join
+          o[:token_length] ||= 16
+        end
+
+        before_create do |doc|
+          doc[attribute] = doc.class.generate_unique_secure_token(attribute)
+        end
+
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def regenerate_#{attribute}!
+            update_attributes(#{attribute}: self.class.generate_unique_secure_token(:#{attribute}))
+          end
+        RUBY
+
+        self.class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def find_by_#{attribute}(token)
+            where(#{attribute}: token).first
+          end
+        RUBY
+      end
+
+      def generate_unique_secure_token(attribute)
+        options = @_st_options_[attribute]
+
+        loop do
+          token = SecureRandom.base64(options[:token_length]).tr('0+/=', options[:random_string])
+          break token unless where(attribute => token).exists?
+        end
+      end
+    end
+  end
+end

data/lib/mongokit/utils/options.rb

@@ -0,0 +1,62 @@
+module Mongokit
+  class Options
+
+    CRITERIAS = [:only, :except, :add, :replace]
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def all
+      @options
+    end
+
+    def put(name, values)
+      @options[name] = values
+    end
+
+    def get(name, field = nil)
+      field ? @options[name][field] : @options[name]
+    end
+
+    class << self
+      def only(fields, options)
+        fields = fields.select{ |f, _| options[:only].include?(f) } if options[:only]
+        fields
+      end
+
+      def except(fields, options)
+        fields = fields.reject{ |f, _| options[:except].include?(f) } if options[:except]
+        fields
+      end
+
+      def add(fields, options)
+        return unless options[:add]
+
+        fields.is_a?(Hash) ? fields.merge(options[:add]) : fields.concat(options[:add])
+      end
+
+      def replace(fields, options)
+        options[:replace].each { |old_f, new_f| fields[new_f] = fields.delete(old_f) } if options[:replace]
+        fields
+      end
+
+      def process(fields, options, criterias = nil)
+        criterias = options.keys unless criterias
+
+        criterias.each do |c|
+          fields = send(c, fields, options) if CRITERIAS.include?(c)
+        end
+
+        fields
+      end
+    end
+
+    # Used for common options store.
+    module Store
+      def mk_options
+        @mk_options ||= Options.new
+      end
+    end
+  end
+end

data/lib/mongokit/version.rb

@@ -0,0 +1,3 @@
+module Mongokit
+  VERSION = "0.0.1"
+end

data/lib/mongokit/yaml_store.rb

@@ -0,0 +1,48 @@
+require 'yaml'
+require 'pathname'
+
+module YamlStore
+  module_function
+
+  @@store = {}
+
+  def store
+    @@store
+  end
+
+  def load(*files)
+    files.each do |f|
+      yaml = Pathname.new(f)
+
+      unless yaml.exist?
+        raise "File not found #{f}"
+      end
+
+      key = yaml.basename.to_s.gsub(yaml.extname, '')
+      @@store[key.to_sym] = read_yaml(yaml)
+
+      self.class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{key}
+          store[:#{key}]
+        end
+      RUBY
+    end
+  end
+
+  def get(name, key = nil)
+    values = @@store[name]
+
+    return nil unless values
+    return key ? values[key] : values
+  end
+
+  def read_yaml(file)
+    yml = YAML.load_file(file)
+
+    if defined?(Rails)
+      yml = yml[Rails.evn] || yml[Rails.evn.to_sym]
+    end
+
+    yml
+  end
+end

data/mongokit.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mongokit/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mongokit"
+  spec.version       = Mongokit::VERSION
+  spec.authors       = ["Jiren"]
+  spec.email         = ["jirenpatel@gmail.com"]
+
+  spec.summary       = %q{Helpers for mongoid i.e auto increment fields, search index}
+  spec.description   = %q{Helpers for mongoid i.e auto increment fields, search index}
+  spec.homepage      = "http://github.com/jiren/mongokit"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|examples)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "database_cleaner", "~> 1.2.0"
+
+  spec.add_dependency("mongoid", "~> 4.0.0")
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: mongokit
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jiren
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-06-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+description: Helpers for mongoid i.e auto increment fields, search index
+email:
+- jirenpatel@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/mongokit.rb
+- lib/mongokit/address.rb
+- lib/mongokit/auto_increment.rb
+- lib/mongokit/auto_increment/counter.rb
+- lib/mongokit/auto_increment/formater.rb
+- lib/mongokit/csv_transformer.rb
+- lib/mongokit/csv_transformer/csv_io.rb
+- lib/mongokit/extensions/mongoid_document.rb
+- lib/mongokit/find_in_batch.rb
+- lib/mongokit/model_helpers.rb
+- lib/mongokit/models/auto_increment_counter.rb
+- lib/mongokit/secure_token.rb
+- lib/mongokit/utils/options.rb
+- lib/mongokit/version.rb
+- lib/mongokit/yaml_store.rb
+- mongokit.gemspec
+homepage: http://github.com/jiren/mongokit
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Helpers for mongoid i.e auto increment fields, search index
+test_files: []
+has_rdoc: