mongo_taggable 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3758c89d443f91ef1f35c5590a2468be9a6a38e2
+  data.tar.gz: cf8bddb5855929fa982415b23f3421ef4b73f3a9
+SHA512:
+  metadata.gz: 1ba706ac8dd684f7a4cd447999b42279afe44cc59a4130b47a6fbeef325589232e3e38a3c20a598578e628a181784b807661d5a7ced85edc41cab231c6f5ddba
+  data.tar.gz: 62ad8b7e3460f9ee6051182f624b431ae489055fc4d9175c7a1f5e28cf30d59d0535fdff3ad1b13d5b4c7cf01a4024e21d46fbf11e74f180987cf93fb3be6862

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format=documentation
+

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 dkulhari
+
+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,70 @@
+# MongoTaggable
+  Extensions for gem https://github.com/mepatterson/acts_as_mongo_taggable with rails 4 and ruby 2.1.1
+
+## Requirements
+  MongoDB
+  MongoMapper gem
+  Expects you to have a User model that includes MongoMapper::Document
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mongo_taggable'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mongo_taggable
+
+## Usage
+
+class User
+  include MongoMapper::Document
+end
+
+class Widget
+  include MongoMapper::Document
+  include MongoTaggable
+end
+To rate it:
+
+widget.tag(word_or_words, user)
+word_or_words can be a string, a string of comma-delimited words, or an array
+user is the User who is tagging this widget
+Basic search:
+
+Widget.find_with_tag('vampires')
+... will return the first Widget object that has been tagged with that phrase
+
+Widget.find_all_with_tag('vampires')
+... will return an array of Widget objects, all of which have been tagged with that phrase
+
+Widget.most_tagged_with('vampires')
+... will return the Widget object that has been tagged the most times with that phrase
+
+Making tag clouds:
+
+Widget.all_tags_with_counts
+... will return a nice array of arrays, a la [["rails", 8],["ruby", 12], ["php", 6], ["java", 2]] Use this to make yourself a tag cloud for now. (maybe I'll implement a tag cloud view helper someday.)
+
+Statistics on Tags:
+
+Tag.top_25
+... returns the top 25 most used tags across all taggable object classes in the system
+
+Tag.top_25("Widget")
+... returns the top 25 most used tags for Widget objects
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/mongo_taggable/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,2 @@
+require "bundler/gem_tasks"
+

data/lib/app/models/model_tag.rb

@@ -0,0 +1,84 @@
+class ModelTag
+  include MongoMapper::EmbeddedDocument
+  
+  key :word,            String, :required => true
+  key :tagging_count,   Integer
+  key :user_ids,        Array
+  
+  def users
+    UserProxy.new(self)
+  end
+  
+  belongs_to :tag
+  
+  before_save :set_tagging_count
+  
+  def save_or_destroy
+    user_ids.empty? ? destroy : save
+  end
+  
+private
+  def set_tagging_count
+    self.tagging_count = user_ids.count
+  end
+  
+  class UserProxy
+    attr_accessor :model_tag
+    
+    def initialize(model_tag)
+      @model_tag = model_tag
+    end
+    
+    def to_a
+      fetch_all.to_a
+    end
+    
+    def count
+      model_tag.user_ids.size
+    end
+    
+    def all(opts = {})
+      fetch_all
+    end
+    
+    def each(&block)
+      fetch_all.each {|user| yield user}
+    end
+    
+    def find(id)
+      return nil unless model_tag.user_ids.include?(id)
+      User.find(id)
+    end
+    
+    def first(opts = {})
+      return @first ||= User.find(model_tag.user_ids.first) if opts.empty?
+      User.first(opts.merge(:_id.in => model_tag.user_ids))
+    end
+    
+    def last(opts = {})
+      return @last ||= User.find(model_tag.user_ids.last) if opts.empty?
+      User.last(opts.merge(:_id.in => model_tag.user_ids))
+    end
+    
+    alias :size :count
+    
+    def << (user)
+      model_tag.user_ids << user.id
+      model_tag.send(:set_tagging_count)
+    end
+    
+    def delete(user)
+      model_tag.user_ids.delete user.id
+      model_tag.send(:set_tagging_count)
+    end
+    
+    def inspect
+      all.inspect
+    end
+    
+  private
+    def fetch_all
+      @fetch ||= User.find(model_tag.user_ids)
+    end
+  end
+end

data/lib/app/models/tag.rb

@@ -0,0 +1,107 @@
+class Tag
+  include MongoMapper::Document
+  key :word,            String,   :required => true, :index => true
+  key :taggings_count,   Integer, :index => true
+
+  many :taggings do
+    def << (tagging)
+      super << tagging
+      tagging._parent_document.send(:increment_counts, tagging)
+    end
+
+    def delete(tagging)
+      target.delete tagging
+      tagging._parent_document.send(:decrement_counts, tagging)
+    end
+  end
+
+  ensure_index 'taggings.user_id'
+  ensure_index 'taggings.taggable_type'
+  ensure_index 'taggings.taggable_id'
+
+  before_save :set_tagging_counts
+
+  def self.register_taggable_type(type)
+    key taggings_count_key_for(type), Integer, :index => true
+  end
+
+  # == Various Class Methods
+
+  # takes a string and produces an array of words from the db that are 'like' this one
+  # great for those oh-so-fancy autocomplete/suggestion text fields
+  def self.like(string, klass = nil)
+    opts = {:word => /^#{string}/}
+    opts['taggings.taggable_type'] = klass.to_s if klass
+    all(opts)
+  end
+
+  def self.all_for_class(klass, opts = {})
+    all(opts.merge('taggings.taggable_type' => klass.to_s))
+  end
+
+  def self.most_tagged(klass = nil, opts = {})
+    order = klass ?  "#{taggings_count_key_for(klass)} desc" : 'taggings_count desc'
+    lo = opts.merge(:order => order)
+    lo['taggings.taggable_type'] = klass.to_s if klass
+    all(lo)
+  end
+
+  def self.top_25(klass = nil)
+    most_tagged(klass, :limit => 25)
+  end
+
+  def count_for(klass = nil)
+    klass ? send(taggings_count_key_for(klass)) : taggings_count
+  end
+
+  #Called when removing taggings.  If no taggings left, destroy, otherwise save
+  def save_or_destroy
+    taggings.empty? ? destroy : save
+  end
+
+private
+  def set_tagging_counts
+    self.taggings_count = self.taggings.size
+
+    count_hash = self.taggings.inject({}) do |hash, tagging|
+      key = taggings_count_key_for(tagging.taggable_type)
+      hash[key] ||= 0
+      hash[key] += 1
+      hash
+    end
+    count_hash.each{|key, count| self.send("#{key}=", count)}
+  end
+
+  def increment_counts(tagging)
+    safe_increment_count(:taggings_count)
+    safe_increment_count(taggings_count_key_for(tagging.taggable_type))
+  end
+
+  def decrement_counts(tagging)
+    safe_decrement_count(:taggings_count)
+    safe_decrement_count(taggings_count_key_for(tagging.taggable_type))
+  end
+
+  def taggings_count_key_for(type)
+    Tag.taggings_count_key_for(type)
+  end
+
+  def safe_increment_count(key)
+    val = self.send(key) || 0
+    self.send("#{key}=", val + 1)
+  end
+
+  def safe_decrement_count(key)
+    self.send("#{key}=", self.send("#{key}") - 1) if self.send("#{key}")
+  end
+
+  def self.taggings_count_key_for(type)
+    type = type.constantize if type.is_a? String
+    #check for inheritance, get most superclass with include
+    while type.superclass && type.superclass.include?(MongoTaggable)
+      type = type.superclass
+    end
+    type = type.name
+    :"#{type.underscore}_taggings_count"
+  end
+end

data/lib/app/models/tagging.rb

@@ -0,0 +1,6 @@
+class Tagging
+  include MongoMapper::EmbeddedDocument
+  
+  belongs_to :user #, :required => true, :index => true
+  belongs_to :taggable, :polymorphic => true
+end

data/lib/mongo_taggable.rb

@@ -0,0 +1,210 @@
+require "mongo_taggable/version"
+
+module MongoTaggable
+  module ClassMethods
+    def all_tags_with_counts
+      Tag.most_tagged(self).map{|tag| [tag.word, tag.count_for(self)]}
+    end
+
+    # returns the _first_ widget with this tag, a la ActiveRecord find()
+    # note: case-insensitive unless you specify otherwise with :case_sensitive=>true
+    def first_with_tag(phrase, opts={})
+      lo = opts.clone
+      case_sensitive = lo.delete :case_sensitive
+      phrase = phrase.downcase unless case_sensitive
+      first(lo.merge(:tag_words => phrase))
+    end
+
+
+    def all_with_tag(phrase, opts={})
+      lo = opts.clone
+      case_sensitive = lo.delete :case_sensitive
+      phrase = phrase.downcase unless case_sensitive
+      all(lo.merge(:tag_words => phrase))
+    end
+
+    def most_tagged_with(phrase, opts={})
+      lo = opts.clone
+      case_sensitive = lo.delete :case_sensitive
+      phrase = phrase.downcase unless case_sensitive
+
+      #Doesn't work :(
+      #first(lo.merge('model_tags.word' => phrase, :order => 'model_tags.tagging_count desc'))
+
+      all_with_tag(phrase, lo).sort do |a, b|
+        b.model_tag(phrase, opts).tagging_count <=> a.model_tag(phrase, opts).tagging_count
+      end.first
+    end
+
+    def top_25_tags
+      Tag.top_25(self)
+    end
+  end
+
+  module InstanceMethods
+
+    def delete_all_tags
+      Tag.find(tag_ids).each do |tag|
+        model_taggings = tag.taggings.select{|tagging| tagging.taggable_type == self.class.name && tagging.taggable_id == self.id}
+        model_taggings.each{|tagging| tag.taggings.delete tagging}
+        tag.save_or_destroy
+      end
+      update_attributes({ :model_tags => [], :tag_words => [] })
+    end
+
+    def _tags
+      Tag.find(:all, tag_ids)
+    end
+
+    # returns array of tags and counts:
+    #   [["matt", 3], ["bob", 2], ["bill", 1], ["joe", 1], ["frank", 1]]
+    def tags_with_counts
+      counts = model_tags.map{|tag| [tag.word, tag.tagging_count]}
+      counts.sort{|a, b| b[1] <=> a[1]}
+    end
+
+    # returns an array of ids and user_ids
+    def tags_with_user_ids
+      model_tags.inject([]) do |arr, tag|
+        tag.user_ids.each{|user_id| arr << [tag.id, user_id]}
+        arr
+      end
+    end
+
+    def tag_words_by_user(user)
+      tags_by_user(user).map(&:word)
+    end
+
+    def tags_by_user(user)
+      model_tags.select{|tag| tag.user_ids.include? user.id}
+    end
+
+    # returns only the tag words, sorted by frequency; optionally can be limited
+    def tags(limit=nil)
+      array = tags_with_counts
+      limit ||= array.size
+      array[0,limit].map{|t| t[0]}
+    end
+
+    def model_tag(phrase, opts = {})
+      phrase = phrase.downcase unless opts[:case_sensitive]
+      model_tags.detect{|tag| tag.word == phrase}
+    end
+
+    def tag_ids
+      model_tags.map(&:tag_id)
+    end
+  end
+
+  def delete_tags_by_user(user)
+    return false unless user
+    return 0 if model_tags.blank?
+    user_tags = tags_by_user(user)
+
+    Tag.find(user_tags.map(&:tag_id)).each do |tag|
+      user_taggings = tag.taggings.select{|tagging| tagging.user_id == user.id && tagging.taggable_type == self.class.name && tagging.taggable_id == self.id}
+      user_taggings.each{|tagging| tag.taggings.delete tagging}
+      tag.save_or_destroy
+    end
+
+    user_tags.each do |tag|
+      tag.users.delete user
+      destroy_if_empty(tag)
+    end
+    save
+    reload
+  end
+
+  def arr_of_words(words)
+    raise "Passed an invalid data type to tag()" unless words.is_a?(String) || words.is_a?(Array)
+    if words.is_a?(String)
+      words.squish.split(',').map{|w| w.squish}
+    else
+      words.map{|w| w.squish}
+    end
+  end
+
+  # returns my current tag word list; raises exception if user tries to multi-tag with same word
+  def tag!(word_or_words, user)
+    arr_of_words(word_or_words).each do |word|
+      raise StandardError if tag_words_by_user(user).include?(word)
+
+      #First add Tag/Tagging
+      t = Tag.first(:word => word) || Tag.create!(:word => word)
+      t.taggings << Tagging.new(:user => user, :taggable => self)
+      t.save!
+
+      #Now add ModelTag/User/tag_word
+      model_tag = model_tags.detect{|tag| tag.word == word}
+      unless model_tag
+        model_tag = ModelTag.new(:word => word, :tag => t)
+        self.model_tags << model_tag
+        self.tag_words << word
+      end
+      model_tag.users << user
+    end
+    save!
+    tags
+  end
+
+  # tags, but silently ignores if user tries to multi-tag with same word
+  # NOTE: automatically downcases each word unless you manually specify :case_sensitive=>true
+  def tag(word_or_words, user, opts={})
+    arr_of_words(word_or_words).each do |word|
+      word = word.downcase unless opts[:case_sensitive] == true
+      unless tag_words_by_user(user).include?(word)
+        #First add Tag/Tagging
+        t = Tag.first(:word => word) || Tag.create!(:word => word)
+        t.taggings << Tagging.new(:user => user, :taggable => self)
+        t.save
+
+        #Now add ModelTag/User/tag_word
+        model_tag = model_tags.detect{|tag| tag.word == word}
+        unless model_tag
+          model_tag = ModelTag.new(:word => word, :tag => t)
+          self.model_tags << model_tag
+          self.tag_words << word
+        end
+        model_tag.users << user
+      end
+    end
+    save
+    tags
+  end
+
+  # returns the Rating object found if user has rated this project, else returns nil
+  def tagged_by_user?(user)
+    !(model_tags.detect{|tag| tag.user_ids.include?(user.id)}.nil?)
+  end
+
+  def self.included(receiver)
+    receiver.class_eval do
+      key :tag_words, Array, :index => true
+      many :model_tags
+
+      ensure_index 'model_tags.word'
+      ensure_index 'model_tags.tagging_count'
+    end
+    receiver.extend         ClassMethods
+    receiver.send :include, InstanceMethods
+
+    Tag.register_taggable_type receiver
+  end
+
+  private
+  def destroy_if_empty(tag)
+    if tag.user_ids.empty?
+      tag_words.delete(tag.word)
+      model_tags.delete tag
+    end
+  end
+
+end
+
+%w{ models observers }.each do |dir|
+  path = File.join(File.dirname(__FILE__), 'app', dir)
+  $LOAD_PATH << path
+  ActiveSupport::Dependencies.autoload_paths << path
+end
+
+

data/lib/mongo_taggable/version.rb

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

data/mongo_taggable.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mongo_taggable/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mongo_taggable"
+  spec.version       = MongoTaggable::VERSION
+  spec.authors       = ["deepak Shinde"]
+  spec.email         = ["deepak2726@coriolis.co.in"]
+  spec.summary       = %q{A ruby gem for acts_as_taggable to mongo}
+  spec.description   = %q{A ruby gem for acts_as_taggable to mongo}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 2.99"
+  spec.add_development_dependency "mongo_mapper", "~> 0.13.0"
+  spec.add_development_dependency "faker", "~> 1.1.2"
+  spec.add_development_dependency "pry-byebug"
+end

data/spec/mongo_taggable_spec.rb

@@ -0,0 +1,77 @@
+# require 'spec_helper.rb'
+
+describe "it mongo acts as taggable" do
+
+  it "widget tagged with the same word multiple times should not have dupes in tag_words" do
+
+  end
+
+  it "ensure we can actually tag two different object types without collisions" do
+
+  end
+
+  it "search and find all widgets containing a specified tag" do
+
+  end
+
+  it "find first widget that matches specified tag" do
+
+  end
+
+  it "all_with_tag and first_with_tag are case-insensitive" do
+
+  end
+
+  it "case-sensitive mode" do
+  end
+
+  it "we get an empty array if we ask for all tags with counts and there are none" do
+
+  end
+
+  it "we can build an array of tags and counts across an entire tagged object space" do
+
+  end
+
+  it "most_tagged_with returns the proper widget" do
+
+  end
+
+  it "tag is created when project tagged" do
+
+  end
+
+  it "tagged_by_user? returns true when this object tagged by user" do
+
+  end
+
+  it "tagged_by_user? returns false when this object not tagged but some other object is" do
+
+  end
+
+  it "tag object can be retrieved after project tagged" do
+
+  end
+
+  it "widget returns correct array with multiple tags with varying counts" do
+  end
+
+  it "tags_with_counts returns the right tags and counts" do
+  end
+
+  it "same user cannot multi-tag with same word using tag!()" do
+  end
+
+  it "delete only tags by certain users" do
+  end
+
+  it "silently ignore multi-tag by single user with same word using tag()" do
+
+  end
+
+  it "widget with multiple tags can be cleared" do
+  end
+
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'rspec'
+require 'faker'
+require 'mongo_taggable'

data/spec/test_helper.rb

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'active_support'
+require 'active_support/test_case'
+require 'test/unit'
+
+ENV['RAILS_ROOT'] ||= File.dirname(__FILE__) + '/../../../..'
+env_rb = File.expand_path(File.join(ENV['RAILS_ROOT'], 'config/environment.rb'))
+
+if File.exists? env_rb
+  require env_rb
+else
+  require 'mongo_mapper'
+  require File.dirname(__FILE__) + '/../lib/acts_as_mongo_taggable'
+  config = {'test' => {'database' => 'aamt-test'}}
+  MongoMapper.setup(config, 'test')
+end
+
+class ActiveSupport::TestCase
+  # Drop all columns after each test case.
+  def teardown
+    MongoMapper.database.collections.each do |coll|
+      coll.drop  
+    end
+  end
+ 
+  # Make sure that each test case has a teardown
+  # method to clear the db after each test.
+  def inherited(base)
+    base.define_method teardown do 
+      super
+    end
+  end
+end
+
+# kinda weird, but we have to do this so we can ignore the app's User class and use our own for testing
+Object.send(:remove_const, :User) if Object.const_defined?(:User)
+
+class User
+  include MongoMapper::Document
+  key :name, String
+  has_many :widgets
+  has_many :dongles
+end
+
+class Widget
+  include MongoMapper::Document  
+  include ActsAsMongoTaggable 
+
+  belongs_to :user
+  
+  key :user_id, ObjectId
+  key :name, String
+end
+
+class Dongle
+  include MongoMapper::Document  
+  include ActsAsMongoTaggable 
+
+  belongs_to :user
+  
+  key :user_id, ObjectId
+  key :name, String
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: mongo_taggable
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- deepak Shinde
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.99'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.99'
+- !ruby/object:Gem::Dependency
+  name: mongo_mapper
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.0
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A ruby gem for acts_as_taggable to mongo
+email:
+- deepak2726@coriolis.co.in
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/app/models/model_tag.rb
+- lib/app/models/tag.rb
+- lib/app/models/tagging.rb
+- lib/mongo_taggable.rb
+- lib/mongo_taggable/version.rb
+- mongo_taggable.gemspec
+- spec/mongo_taggable_spec.rb
+- spec/spec_helper.rb
+- spec/test_helper.rb
+homepage: ''
+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.2.2
+signing_key: 
+specification_version: 4
+summary: A ruby gem for acts_as_taggable to mongo
+test_files:
+- spec/mongo_taggable_spec.rb
+- spec/spec_helper.rb
+- spec/test_helper.rb
+has_rdoc: