bullet 7.0.7 → 7.1.0

data/Rakefile

@@ -1,51 +0,0 @@
-$LOAD_PATH.unshift File.expand_path('lib', __dir__)
-require 'bundler'
-Bundler.setup
-
-require 'rake'
-require 'rspec'
-require 'rspec/core/rake_task'
-
-require 'bullet/version'
-
-task :build do
-  system 'gem build bullet.gemspec'
-end
-
-task install: :build do
-  system "sudo gem install bullet-#{Bullet::VERSION}.gem"
-end
-
-task release: :build do
-  puts "Tagging #{Bullet::VERSION}..."
-  system "git tag -a #{Bullet::VERSION} -m 'Tagging #{Bullet::VERSION}'"
-  puts 'Pushing to Github...'
-  system 'git push --tags'
-  puts 'Pushing to rubygems.org...'
-  system "gem push bullet-#{Bullet::VERSION}.gem"
-end
-
-RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = 'spec/**/*_spec.rb'
-end
-
-RSpec::Core::RakeTask.new('spec:progress') do |spec|
-  spec.rspec_opts = %w[--format progress]
-  spec.pattern = 'spec/**/*_spec.rb'
-end
-
-begin
-  require 'rdoc/task'
-
-  desc 'Generate documentation for the plugin.'
-  Rake::RDocTask.new do |rdoc|
-    rdoc.rdoc_dir = 'rdoc'
-    rdoc.title = "bullet #{Bullet::VERSION}"
-    rdoc.rdoc_files.include('README*')
-    rdoc.rdoc_files.include('lib/**/*.rb')
-  end
-rescue LoadError
-  puts 'RDocTask is not supported for this platform'
-end
-
-task default: :spec

data/bullet.gemspec

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
-
-require 'bullet/version'
-
-Gem::Specification.new do |s|
-  s.name        = 'bullet'
-  s.version     = Bullet::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ['Richard Huang']
-  s.email       = ['flyerhzm@gmail.com']
-  s.homepage    = 'https://github.com/flyerhzm/bullet'
-  s.summary     = 'help to kill N+1 queries and unused eager loading.'
-  s.description = 'help to kill N+1 queries and unused eager loading.'
-  s.metadata    = {
-    'changelog_uri' => 'https://github.com/flyerhzm/bullet/blob/master/CHANGELOG.md',
-    'source_code_uri' => 'https://github.com/flyerhzm/bullet'
-  }
-
-  s.license = 'MIT'
-
-  s.required_ruby_version = '>= 2.3'
-  s.required_rubygems_version = '>= 1.3.6'
-
-  s.add_runtime_dependency 'activesupport', '>= 3.0.0'
-  s.add_runtime_dependency 'uniform_notifier', '~> 1.11'
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.require_paths = ['lib']
-end

data/perf/benchmark.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-$LOAD_PATH << 'lib'
-require 'benchmark'
-require 'rails'
-require 'active_record'
-require 'activerecord-import'
-require 'bullet'
-
-begin
-  require 'perftools'
-rescue LoadError
-  puts "Could not load perftools.rb, profiling won't be possible"
-end
-
-class Post < ActiveRecord::Base
-  belongs_to :user
-  has_many :comments
-end
-
-class Comment < ActiveRecord::Base
-  belongs_to :user
-  belongs_to :post
-end
-
-class User < ActiveRecord::Base
-  has_many :posts
-  has_many :comments
-end
-
-# create database bullet_benchmark;
-ActiveRecord::Base.establish_connection(
-  adapter: 'mysql2',
-  database: 'bullet_benchmark',
-  server: '/tmp/mysql.socket',
-  username: 'root'
-)
-
-ActiveRecord::Base.connection.tables.each { |table| ActiveRecord::Base.connection.drop_table(table) }
-
-ActiveRecord::Schema.define(version: 1) do
-  create_table :posts do |t|
-    t.column :title, :string
-    t.column :body, :string
-    t.column :user_id, :integer
-  end
-
-  create_table :comments do |t|
-    t.column :body, :string
-    t.column :post_id, :integer
-    t.column :user_id, :integer
-  end
-
-  create_table :users do |t|
-    t.column :name, :string
-  end
-end
-
-users_size = 100
-posts_size = 1_000
-comments_size = 10_000
-users = []
-users_size.times { |i| users << User.new(name: "user#{i}") }
-User.import users
-users = User.all
-
-posts = []
-posts_size.times { |i| posts << Post.new(title: "Title #{i}", body: "Body #{i}", user: users[i % 100]) }
-Post.import posts
-posts = Post.all
-
-comments = []
-comments_size.times { |i| comments << Comment.new(body: "Comment #{i}", post: posts[i % 1_000], user: users[i % 100]) }
-Comment.import comments
-
-puts 'Start benchmarking...'
-
-Bullet.enable = true
-
-Benchmark.bm(70) do |bm|
-  bm.report("Querying & Iterating #{posts_size} Posts with #{comments_size} Comments and #{users_size} Users") do
-    10.times do
-      Bullet.start_request
-      Post.select('SQL_NO_CACHE *').includes(:user, comments: :user).each do |p|
-        p.title
-        p.user.name
-        p.comments.each do |c|
-          c.body
-          c.user.name
-        end
-      end
-      Bullet.end_request
-    end
-  end
-end
-
-puts 'End benchmarking...'
-
-# Run benchmark with bundler
-#
-#     bundle exec ruby perf/benchmark.rb
-#
-# bullet 2.3.0 with rails 3.2.2
-#                                                                              user     system      total        real
-# Querying & Iterating 1000 Posts with 10000 Comments and 100 Users       16.460000   0.190000  16.650000 ( 16.968246)
-#
-# bullet 2.3.0 with rails 3.1.4
-#                                                                              user     system      total        real
-# Querying & Iterating 1000 Posts with 10000 Comments and 100 Users       14.600000   0.130000  14.730000 ( 14.937590)
-#
-# bullet 2.3.0 with rails 3.0.12
-#                                                                              user     system      total        real
-# Querying & Iterating 1000 Posts with 10000 Comments and 100 Users       26.120000   0.430000  26.550000 ( 27.179304)
-#
-#
-# bullet 2.2.1 with rails 3.0.12
-#                                                                              user     system      total        real
-# Querying & Iterating 1000 Posts with 10000 Comments and 100 Users       29.970000   0.270000  30.240000 ( 30.452083)

data/rails/init.rb

@@ -1,3 +0,0 @@
-# frozen_string_literal: true
-
-require 'bullet'

data/spec/bullet/detector/association_spec.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Bullet
-  module Detector
-    describe Association do
-      before :all do
-        @post1 = Post.first
-        @post2 = Post.last
-      end
-
-      context '.add_object_association' do
-        it 'should add object, associations pair' do
-          Association.add_object_associations(@post1, :associations)
-          expect(Association.send(:object_associations)).to be_include(@post1.bullet_key, :associations)
-        end
-      end
-
-      context '.add_call_object_associations' do
-        it 'should add call object, associations pair' do
-          Association.add_call_object_associations(@post1, :associations)
-          expect(Association.send(:call_object_associations)).to be_include(@post1.bullet_key, :associations)
-        end
-      end
-    end
-  end
-end

data/spec/bullet/detector/base_spec.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Bullet
-  module Detector
-    describe Base do
-    end
-  end
-end

data/spec/bullet/detector/counter_cache_spec.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Bullet
-  module Detector
-    describe CounterCache do
-      before :all do
-        @post1 = Post.first
-        @post2 = Post.last
-      end
-
-      context '.add_counter_cache' do
-        it 'should create notification if conditions met' do
-          expect(CounterCache).to receive(:conditions_met?).with(@post1, %i[comments]).and_return(true)
-          expect(CounterCache).to receive(:create_notification).with('Post', %i[comments])
-          CounterCache.add_counter_cache(@post1, %i[comments])
-        end
-
-        it 'should not create notification if conditions not met' do
-          expect(CounterCache).to receive(:conditions_met?).with(@post1, %i[comments]).and_return(false)
-          expect(CounterCache).to receive(:create_notification).never
-          CounterCache.add_counter_cache(@post1, %i[comments])
-        end
-      end
-
-      context '.add_possible_objects' do
-        it 'should add possible objects' do
-          CounterCache.add_possible_objects([@post1, @post2])
-          expect(CounterCache.possible_objects).to be_include(@post1.bullet_key)
-          expect(CounterCache.possible_objects).to be_include(@post2.bullet_key)
-        end
-
-        it 'should add impossible object' do
-          CounterCache.add_impossible_object(@post1)
-          expect(CounterCache.impossible_objects).to be_include(@post1.bullet_key)
-        end
-      end
-
-      context '.conditions_met?' do
-        it 'should be true when object is possible, not impossible' do
-          CounterCache.add_possible_objects(@post1)
-          expect(CounterCache.conditions_met?(@post1, :associations)).to eq true
-        end
-
-        it 'should be false when object is not possible' do
-          expect(CounterCache.conditions_met?(@post1, :associations)).to eq false
-        end
-
-        it 'should be false when object is possible, and impossible' do
-          CounterCache.add_possible_objects(@post1)
-          CounterCache.add_impossible_object(@post1)
-          expect(CounterCache.conditions_met?(@post1, :associations)).to eq false
-        end
-      end
-    end
-  end
-end

data/spec/bullet/detector/n_plus_one_query_spec.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Bullet
-  module Detector
-    describe NPlusOneQuery do
-      before(:all) do
-        @post = Post.first
-        @post2 = Post.last
-      end
-
-      context '.call_association' do
-        it 'should add call_object_associations' do
-          expect(NPlusOneQuery).to receive(:add_call_object_associations).with(@post, :associations)
-          NPlusOneQuery.call_association(@post, :associations)
-        end
-      end
-
-      context '.possible?' do
-        it 'should be true if possible_objects contain' do
-          NPlusOneQuery.add_possible_objects(@post)
-          expect(NPlusOneQuery.possible?(@post)).to eq true
-        end
-      end
-
-      context '.impossible?' do
-        it 'should be true if impossible_objects contain' do
-          NPlusOneQuery.add_impossible_object(@post)
-          expect(NPlusOneQuery.impossible?(@post)).to eq true
-        end
-      end
-
-      context '.association?' do
-        it 'should be true if object, associations pair is already existed' do
-          NPlusOneQuery.add_object_associations(@post, :association)
-          expect(NPlusOneQuery.association?(@post, :association)).to eq true
-        end
-
-        it 'should be false if object, association pair is not existed' do
-          NPlusOneQuery.add_object_associations(@post, :association1)
-          expect(NPlusOneQuery.association?(@post, :association2)).to eq false
-        end
-      end
-
-      context '.conditions_met?' do
-        it 'should be true if object is possible, not impossible and object, associations pair is not already existed' do
-          allow(NPlusOneQuery).to receive(:possible?).with(@post).and_return(true)
-          allow(NPlusOneQuery).to receive(:impossible?).with(@post).and_return(false)
-          allow(NPlusOneQuery).to receive(:association?).with(@post, :associations).and_return(false)
-          expect(NPlusOneQuery.conditions_met?(@post, :associations)).to eq true
-        end
-
-        it 'should be false if object is not possible, not impossible and object, associations pair is not already existed' do
-          allow(NPlusOneQuery).to receive(:possible?).with(@post).and_return(false)
-          allow(NPlusOneQuery).to receive(:impossible?).with(@post).and_return(false)
-          allow(NPlusOneQuery).to receive(:association?).with(@post, :associations).and_return(false)
-          expect(NPlusOneQuery.conditions_met?(@post, :associations)).to eq false
-        end
-
-        it 'should be false if object is possible, but impossible and object, associations pair is not already existed' do
-          allow(NPlusOneQuery).to receive(:possible?).with(@post).and_return(true)
-          allow(NPlusOneQuery).to receive(:impossible?).with(@post).and_return(true)
-          allow(NPlusOneQuery).to receive(:association?).with(@post, :associations).and_return(false)
-          expect(NPlusOneQuery.conditions_met?(@post, :associations)).to eq false
-        end
-
-        it 'should be false if object is possible, not impossible and object, associations pair is already existed' do
-          allow(NPlusOneQuery).to receive(:possible?).with(@post).and_return(true)
-          allow(NPlusOneQuery).to receive(:impossible?).with(@post).and_return(false)
-          allow(NPlusOneQuery).to receive(:association?).with(@post, :associations).and_return(true)
-          expect(NPlusOneQuery.conditions_met?(@post, :associations)).to eq false
-        end
-      end
-
-      context '.call_association' do
-        it 'should create notification if conditions met' do
-          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post, :association).and_return(true)
-          expect(NPlusOneQuery).to receive(:caller_in_project).and_return(%w[caller])
-          expect(NPlusOneQuery).to receive(:create_notification).with(%w[caller], 'Post', :association)
-          NPlusOneQuery.call_association(@post, :association)
-        end
-
-        it 'should not create notification if conditions not met' do
-          expect(NPlusOneQuery).to receive(:conditions_met?).with(@post, :association).and_return(false)
-          expect(NPlusOneQuery).not_to receive(:caller_in_project!)
-          expect(NPlusOneQuery).not_to receive(:create_notification).with('Post', :association)
-          NPlusOneQuery.call_association(@post, :association)
-        end
-
-        context 'stacktrace_excludes' do
-          before { Bullet.stacktrace_excludes = [/def/] }
-          after { Bullet.stacktrace_excludes = nil }
-
-          it 'should not create notification when stacktrace contains paths that are in the exclude list' do
-            in_project = OpenStruct.new(absolute_path: File.join(Dir.pwd, 'abc', 'abc.rb'))
-            included_path = OpenStruct.new(absolute_path: '/ghi/ghi.rb')
-            excluded_path = OpenStruct.new(absolute_path: '/def/def.rb')
-
-            expect(NPlusOneQuery).to receive(:caller_locations).and_return([in_project, included_path, excluded_path])
-            expect(NPlusOneQuery).to_not receive(:create_notification)
-            NPlusOneQuery.call_association(@post, :association)
-          end
-
-          # just a sanity spec to make sure the following spec works correctly
-          it "should create notification when stacktrace contains methods that aren't in the exclude list" do
-            method = NPlusOneQuery.method(:excluded_stacktrace_path?).source_location
-            in_project = OpenStruct.new(absolute_path: File.join(Dir.pwd, 'abc', 'abc.rb'))
-            excluded_path = OpenStruct.new(absolute_path: method.first, lineno: method.last)
-
-            expect(NPlusOneQuery).to receive(:caller_locations).at_least(1).and_return([in_project, excluded_path])
-            expect(NPlusOneQuery).to receive(:conditions_met?).and_return(true)
-            expect(NPlusOneQuery).to receive(:create_notification)
-            NPlusOneQuery.call_association(@post, :association)
-          end
-
-          it 'should not create notification when stacktrace contains methods that are in the exclude list' do
-            method = NPlusOneQuery.method(:excluded_stacktrace_path?).source_location
-            Bullet.stacktrace_excludes = [method]
-            in_project = OpenStruct.new(absolute_path: File.join(Dir.pwd, 'abc', 'abc.rb'))
-            excluded_path = OpenStruct.new(absolute_path: method.first, lineno: method.last)
-
-            expect(NPlusOneQuery).to receive(:caller_locations).and_return([in_project, excluded_path])
-            expect(NPlusOneQuery).to_not receive(:create_notification)
-            NPlusOneQuery.call_association(@post, :association)
-          end
-        end
-      end
-
-      context '.add_possible_objects' do
-        it 'should add possible objects' do
-          NPlusOneQuery.add_possible_objects([@post, @post2])
-          expect(NPlusOneQuery.possible_objects).to be_include(@post.bullet_key)
-          expect(NPlusOneQuery.possible_objects).to be_include(@post2.bullet_key)
-        end
-
-        it 'should not raise error if object is nil' do
-          expect { NPlusOneQuery.add_possible_objects(nil) }.not_to raise_error
-        end
-      end
-
-      context '.add_impossible_object' do
-        it 'should add impossible object' do
-          NPlusOneQuery.add_impossible_object(@post)
-          expect(NPlusOneQuery.impossible_objects).to be_include(@post.bullet_key)
-        end
-      end
-    end
-  end
-end

data/spec/bullet/detector/unused_eager_loading_spec.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Bullet
-  module Detector
-    describe UnusedEagerLoading do
-      before(:all) do
-        @post = Post.first
-        @post2 = Post.all[1]
-        @post3 = Post.last
-      end
-
-      context '.call_associations' do
-        it 'should get empty array if eager_loadings' do
-          expect(UnusedEagerLoading.send(:call_associations, @post.bullet_key, Set.new([:association]))).to be_empty
-        end
-
-        it 'should get call associations if object and association are both in eager_loadings and call_object_associations' do
-          UnusedEagerLoading.add_eager_loadings([@post], :association)
-          UnusedEagerLoading.add_call_object_associations(@post, :association)
-          expect(UnusedEagerLoading.send(:call_associations, @post.bullet_key, Set.new([:association]))).to eq(
-            [:association]
-          )
-        end
-
-        it 'should not get call associations if not exist in call_object_associations' do
-          UnusedEagerLoading.add_eager_loadings([@post], :association)
-          expect(UnusedEagerLoading.send(:call_associations, @post.bullet_key, Set.new([:association]))).to be_empty
-        end
-      end
-
-      context '.diff_object_associations' do
-        it 'should return associations not exist in call_association' do
-          expect(UnusedEagerLoading.send(:diff_object_associations, @post.bullet_key, Set.new([:association]))).to eq(
-            [:association]
-          )
-        end
-
-        it 'should return empty if associations exist in call_association' do
-          UnusedEagerLoading.add_eager_loadings([@post], :association)
-          UnusedEagerLoading.add_call_object_associations(@post, :association)
-          expect(
-            UnusedEagerLoading.send(:diff_object_associations, @post.bullet_key, Set.new([:association]))
-          ).to be_empty
-        end
-      end
-
-      context '.check_unused_preload_associations' do
-        let(:paths) { %w[/dir1 /dir1/subdir] }
-        it 'should create notification if object_association_diff is not empty' do
-          UnusedEagerLoading.add_object_associations(@post, :association)
-          allow(UnusedEagerLoading).to receive(:caller_in_project).and_return(paths)
-          expect(UnusedEagerLoading).to receive(:create_notification).with(paths, 'Post', [:association])
-          UnusedEagerLoading.check_unused_preload_associations
-        end
-
-        it 'should not create notification if object_association_diff is empty' do
-          UnusedEagerLoading.add_object_associations(@post, :association)
-          UnusedEagerLoading.add_eager_loadings([@post], :association)
-          UnusedEagerLoading.add_call_object_associations(@post, :association)
-          expect(
-            UnusedEagerLoading.send(:diff_object_associations, @post.bullet_key, Set.new([:association]))
-          ).to be_empty
-          expect(UnusedEagerLoading).not_to receive(:create_notification).with('Post', [:association])
-          UnusedEagerLoading.check_unused_preload_associations
-        end
-
-        it 'should create call stack for notification' do
-          UnusedEagerLoading.add_object_associations(@post, :association)
-          expect(UnusedEagerLoading.send(:call_stacks).registry).not_to be_empty
-        end
-      end
-
-      context '.add_eager_loadings' do
-        it 'should add objects, associations pair when eager_loadings are empty' do
-          UnusedEagerLoading.add_eager_loadings([@post, @post2], :associations)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include(
-            [@post.bullet_key, @post2.bullet_key],
-            :associations
-          )
-        end
-
-        it 'should add objects, associations pair for existing eager_loadings' do
-          UnusedEagerLoading.add_eager_loadings([@post, @post2], :association1)
-          UnusedEagerLoading.add_eager_loadings([@post, @post2], :association2)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include(
-            [@post.bullet_key, @post2.bullet_key],
-            :association1
-          )
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include(
-            [@post.bullet_key, @post2.bullet_key],
-            :association2
-          )
-        end
-
-        it 'should merge objects, associations pair for existing eager_loadings' do
-          UnusedEagerLoading.add_eager_loadings([@post], :association1)
-          UnusedEagerLoading.add_eager_loadings([@post, @post2], :association2)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key], :association1)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key], :association2)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post2.bullet_key], :association2)
-        end
-
-        it 'should vmerge objects recursively, associations pair for existing eager_loadings' do
-          UnusedEagerLoading.add_eager_loadings([@post, @post2], :association1)
-          UnusedEagerLoading.add_eager_loadings([@post, @post3], :association1)
-          UnusedEagerLoading.add_eager_loadings([@post, @post3], :association2)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key], :association1)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key], :association2)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post2.bullet_key], :association1)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post3.bullet_key], :association1)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post3.bullet_key], :association2)
-        end
-
-        it 'should delete objects, associations pair for existing eager_loadings' do
-          UnusedEagerLoading.add_eager_loadings([@post, @post2], :association1)
-          UnusedEagerLoading.add_eager_loadings([@post], :association2)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key], :association1)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post.bullet_key], :association2)
-          expect(UnusedEagerLoading.send(:eager_loadings)).to be_include([@post2.bullet_key], :association1)
-        end
-      end
-    end
-  end
-end

data/spec/bullet/ext/object_spec.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Object do
-  context 'bullet_key' do
-    it 'should return class and id composition' do
-      post = Post.first
-      expect(post.bullet_key).to eq("Post:#{post.id}")
-    end
-
-    if mongoid?
-      it 'should return class with namespace and id composition' do
-        post = Mongoid::Post.first
-        expect(post.bullet_key).to eq("Mongoid::Post:#{post.id}")
-      end
-    end
-  end
-
-  context 'bullet_primary_key_value' do
-    it 'should return id' do
-      post = Post.first
-      expect(post.bullet_primary_key_value).to eq(post.id)
-    end
-
-    it 'should return primary key value' do
-      post = Post.first
-      Post.primary_key = 'name'
-      expect(post.bullet_primary_key_value).to eq(post.name)
-      Post.primary_key = 'id'
-    end
-
-    it 'should return value for multiple primary keys' do
-      post = Post.first
-      allow(Post).to receive(:primary_keys).and_return(%i[category_id writer_id])
-      expect(post.bullet_primary_key_value).to eq("#{post.category_id},#{post.writer_id}")
-    end
-
-    it 'it should return nil for unpersisted records' do
-      post = Post.new(id: 123)
-      expect(post.bullet_primary_key_value).to be_nil
-    end
-  end
-end

data/spec/bullet/ext/string_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe String do
-  context 'bullet_class_name' do
-    it 'should only return class name' do
-      expect('Post:1'.bullet_class_name).to eq('Post')
-    end
-
-    it 'should return class name with namespace' do
-      expect('Mongoid::Post:1234567890'.bullet_class_name).to eq('Mongoid::Post')
-    end
-  end
-end