mongoblazer 0.0.1 → 0.0.2

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.DS_Store

data/Rakefile

@@ -1 +1,5 @@
 require "bundler/gem_tasks"
+
+task :default do
+  exit system('bundle exec rspec spec --color --debug')
+end

data/lib/mongoblazer.rb

@@ -1,5 +1,11 @@
+require "rails"
+require "mongoid"
+require "active_record"
 require "mongoblazer/version"
+require "mongoblazer/active_record/carrierwave"
+require "mongoblazer/active_record"
+require "mongoblazer/document"
+require "mongoblazer/railtie"
 
 module Mongoblazer
-  # Your code goes here...
 end

data/lib/mongoblazer/active_record.rb

@@ -0,0 +1,431 @@
+module Mongoblazer
+  ##
+  # Mongoblazer's ActiveRecord extension.
+  #
+  module ActiveRecord
+    extend ActiveSupport::Concern
+    include Carrierwave
+
+    included do
+      def mongoblazed
+        @mongoblazed ||= begin
+          self.class.recreate_mongoblazer_class!
+          self.class.mongoblazer_class.where(id: self.mongoblazer_id).last
+        end
+      end
+
+      def mongoblazed_add_attribute(name, data={})
+        self.class.recreate_mongoblazer_class!
+        instance = self.class.mongoblazer_class.where(id: self.mongoblazer_id).last
+        instance[name] = data
+        instance.save!
+        @mongoblazed = instance
+      end
+
+      ##
+      # Add a relation that is not in the includes options
+      #
+      # Example:
+      # post.mongoblazed.add_include(:comments, post.comments.map(&:attributes))
+      #
+      # Returns the mongoblazed instance with the new include.
+      def mongoblazed_add_include(name, data={})
+        self.class.recreate_mongoblazer_class!
+        relations = {name => data}
+        mongoblaze_relations(mongoblazed, relations)
+        mongoblazed.save!
+        mongoblazed
+      end
+
+      def mongoblaze!(caller=self.class)
+        if @mongoblazer_already_blazing
+          @mongoblazer_already_blazing = false
+          return true
+        end
+
+        self.class.recreate_mongoblazer_class!
+
+        data = mongoblazer_attributes
+        relations = {}
+
+        self.class.mongoblazer_options[:embeds_one].each do |em, class_name|
+          if related = data.delete(em)
+            klass = class_name ? class_name.constantize : "#{em.to_s.camelize}".constantize
+            if klass != caller
+              related_id = related['id'] || data["#{em}_id"]
+              if klass.mongoblazable? && related_id
+                klass.recreate_mongoblazer_class!
+                relations[em] = klass.find(related_id).mongoblazer_attributes(self.class)
+              else
+                data[em] = related.attributes
+              end
+            end
+          end
+        end
+
+        self.class.mongoblazer_options[:embeds_many].each do |em, class_name|
+          if related = data.delete(em)
+            klass = class_name ? class_name.constantize : "#{em.to_s.singularize.camelize}".constantize
+            if klass != caller
+              if klass.mongoblazable?
+                klass.recreate_mongoblazer_class!
+                relations[em] = related.map do |r|
+                  related_id = r['id'] || data["#{em.to_s.singularize}_id"]
+                  if related_id
+                    klass.find(related_id).mongoblazer_attributes(self.class)
+                  else
+                    r.attributes
+                  end
+                end
+              else
+                data[em] = related.map(&:attributes)
+              end
+            end
+          end
+        end
+
+        self.class.recreate_mongoblazer_class!
+
+        blazed_record = if self.mongoblazer_id.present?
+          self.class.mongoblazer_class
+            .where(id: self.mongoblazer_id).first
+          else
+            nil
+          end
+
+        if blazed_record.present?
+          blazed_record.save!(data)
+        else
+          blazed_record = self.class.mongoblazer_class.create(data)
+          @mongoblazer_already_blazing = true
+          update_attribute :mongoblazer_id, blazed_record.id.to_s
+        end
+
+        mongoblaze_relations(blazed_record, relations)
+
+        blazed_record.save!
+
+        blazed_record
+      end
+
+      def mongoblaze_relations(blazed_record, relations)
+        if relations.present?
+          self.class.recreate_mongoblazer_class!
+
+          relations.each do |name, related|
+            next if self.class.mongoblazer_options[:uploaders].include? name
+
+            if related.is_a? Array
+              blazed_record.send(name).destroy_all
+
+              related.each do |r|
+                blazed_record.send(name).build(r)
+              end
+
+            else
+              blazed_record.send("build_#{name}", related)
+            end
+          end
+        end
+      end
+
+      def mongoblazer_attributes(caller=self.class)
+        if self.class.mongoblazable?
+          self.class.recreate_mongoblazer_class!
+
+          includes = self.class.mongoblazer_options[:includes]
+
+          instance = self.class.includes(includes).find(id)
+          data = if includes
+            instance.serializable_hash(:include => includes)
+          else
+            instance.attributes
+          end
+
+          if additional = self.class.mongoblazer_options[:additional_attributes]
+            additional.each do |attribute|
+              next if self.class.mongoblazer_options[:uploaders].include? attribute
+
+              data[attribute] = instance.send(attribute)
+            end
+          end
+
+          if uploaders = self.class.mongoblazer_options[:uploaders]
+            uploaders.each do |uploader|
+              data.delete(uploader)
+              data.delete(uploader.to_s)
+              if instance.send(uploader).present?
+                versions = {}
+                instance.send(uploader).versions.each do |v,u|
+                  versions[v] = u.to_s
+                end
+                versions.merge({default: instance.send(uploader).to_s})
+              end
+            end
+          end
+
+          data[:ar_id] = data.delete('id')
+
+          data.delete(caller.name.underscore.to_sym)
+          data.delete(caller.name.pluralize.underscore.to_sym)
+
+          self.class.recreate_mongoblazer_class!
+
+          data
+        else
+          throw "#{self.class.name} is not Mongoblazable!"
+        end
+      end
+
+      private
+
+        # Add associations specified via the <tt>:include</tt> option.
+        #
+        # Expects a block that takes as arguments:
+        #   +association+ - name of the association
+        #   +records+     - the association record(s) to be serialized
+        #   +opts+        - options for the association records
+        def serializable_add_includes(options = {}) #:nodoc:
+          return unless include = options[:include]
+
+          unless include.is_a?(Hash)
+            include = Hash[Array.wrap(include).map { |n| n.is_a?(Hash) ? n.to_a.first : [n, {}] }]
+          end
+
+          include.each do |association, opts|
+            # TODO: This is broken in Rails 3.2.13 it seems, hence this fix.
+            opts = {:include => opts} if opts.is_a? Array
+
+            if records = send(association)
+              yield association, records, opts
+            end
+          end
+        end
+    end
+
+    module ClassMethods
+      def find_blazed(id)
+        ar_instance = select("#{self.table_name}.mongoblazer_id").find(id)
+
+        recreate_mongoblazer_class!
+
+        mongoblazer_class.find(ar_instance.mongoblazer_id)
+      end
+
+      ##
+      # Is this model Mongoblazable?
+      #
+      def mongoblazable?
+        mongoblazer_options.present?
+      end
+
+      def belongs_to(name, options={})
+        mongoblazer_init embeds_one: {name => options[:class_name]}
+        super
+      end
+
+      def has_one(name, options={})
+        mongoblazer_init embeds_one: {name => options[:class_name]}
+        super
+      end
+
+      def has_many(name, options={})
+        mongoblazer_init embeds_many: {name => options[:class_name]}
+        super
+      end
+
+      def has_and_belongs_to_many(name, options={})
+        mongoblazer_init embeds_many: {name => options[:class_name]}
+        super
+      end
+
+      ##
+      # Defines relation includes to be merged
+      # in the mongodb document.
+      #
+      # Syntax same as eager loading syntax in AR:
+      #    http://guides.rubyonrails.org/active_record_querying.html#eager-loading-associations
+      #
+      def mongoblazer_includes(options={})
+        mongoblazer_init includes: options
+      end
+
+      ##
+      # Defines default scope to find the matching mongodb
+      # document.
+      #
+      # Syntax same as where() in AR
+      #
+      def mongoblazer_default_scope(options={})
+        mongoblazer_init default_scope: options
+      end
+
+      ##
+      # Defines indexes on the blazer model.
+      #
+      def mongoblazer_index_fields(options={})
+        mongoblazer_init indexes: options
+      end
+
+      ##
+      # Defines additional attributes (e.g. not in db) to be merged
+      # in the mongodb document.
+      #
+      def mongoblazer_additional_attributes(options={})
+        mongoblazer_init additional_attributes: options
+      end
+
+      ##
+      # Initialize Mongoblazer wit some options:
+      #   includes: relations to include
+      #   default_scope: the default scope for the blazed model
+      #   indexes: fields to index in the blazed model
+      #   embeds_one: model to embed one of
+      #   embeds_many: model to embed many of
+      #
+      def mongoblazer_init(options)
+        unless @mongoblazer_options
+          @mongoblazer_options = {}
+
+          @mongoblazer_options[:indexes] =
+            ::ActiveRecord::Base.connection.indexes(self.table_name).map do |ind|
+            {ind => 1}
+          end
+
+          @mongoblazer_options[:uploaders] = []
+
+          @mongoblazer_options[:embeds_one]  = {}
+          @mongoblazer_options[:embeds_many] = {}
+        end
+
+        if one = options.delete(:embeds_one)
+          @mongoblazer_options[:embeds_one][one.keys.first] = one.values.first
+        end
+
+        if many = options.delete(:embeds_many)
+          @mongoblazer_options[:embeds_many][many.keys.first] = many.values.first
+        end
+
+        if uploader = options.delete(:uploaders)
+          @mongoblazer_options[:uploaders] << uploader
+        end
+
+        @mongoblazer_options.merge! options
+
+        create_mongoblazer_class!
+      end
+
+      def mongoblazer_options
+        if defined?(@mongoblazer_options)
+          @mongoblazer_options
+        elsif superclass.respond_to?(:mongoblazer_options)
+          superclass.mongoblazer_options || { }
+        else
+          { }
+        end
+      end
+
+      def mongoblazer_class
+        mongoblazer_class_name.constantize
+      end
+
+      def mongoblazer_class_name
+        "#{self.name}Blazer"
+      end
+
+      def recreate_mongoblazer_class!(called_from_parent=false)
+        create_mongoblazer_class!
+
+        unless called_from_parent
+          begin
+            configuration[:embeds_one].each do |rel|
+              "#{rel.to_s.camelize}".constantize.recreate_mongoblazer_class!(true)
+            end
+          rescue NameError
+          end
+          begin
+            configuration[:embeds_many].each do |rel|
+              "#{rel.to_s.singularize.camelize}".constantize.recreate_mongoblazer_class!(true)
+            end
+          rescue NameError
+          end
+        end
+      end
+
+      private # ----------------------------------------------------------------
+
+      def create_mongoblazer_class!
+        configuration = mongoblazer_options
+
+        relations  = configure_mongoblazer_relations! configuration[:embeds_one], :embeds_one
+        relations += configure_mongoblazer_relations! configuration[:embeds_many], :embeds_many
+
+        uploaders = configure_mongoblazer_uploaders!
+
+        klass = begin
+          mongoblazer_class
+        rescue NameError
+          collection = mongoblazer_class_name.pluralize.underscore
+
+          klass = Class.new do
+            include ::Mongoblazer::Document
+
+            # Use one collection to avoid class initialization trouble
+            # when guessing the collection to use.
+            store_in collection: collection
+
+            index ar_id: 1
+            index _type: 1
+
+            default_scope configuration[:default_scope] if configuration[:default_scope].present?
+
+            configuration[:indexes].each { |ind| index ind }
+          end
+
+          Object.const_set mongoblazer_class_name, klass
+
+          klass
+        end
+
+        klass.module_eval relations.join("\n")
+        klass.module_eval uploaders.join("\n")
+      end
+
+      def configure_mongoblazer_relations!(relations, embed_type=:embeds_one)
+        relations.map do |em, klass_name|
+          class_name = if klass_name
+            "#{klass_name}Blazer"
+          elsif embed_type == :embeds_one
+            "#{em.to_s.camelize}Blazer"
+          else
+            "#{em.to_s.singularize.camelize}Blazer"
+          end
+
+          if const_defined?(class_name)
+            <<-CODE
+              #{embed_type} :#{em}, class_name: '#{class_name}', inverse_of: '#{mongoblazer_class_name}'
+              accepts_nested_attributes_for :#{em}
+            CODE
+          else
+            <<-CODE
+              def #{em}=(data)
+                write_attribute(:#{em}, data)
+              end
+
+              def #{em}
+                data = attributes['#{em}']
+                if data.is_a? Array
+                  data.map{|d| OpenStruct.new(d)}
+                elsif data.is_a? Hash
+                  OpenStruct.new(data)
+                else
+                  data
+                end
+              end
+            CODE
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoblazer/active_record/carrierwave.rb

@@ -0,0 +1,47 @@
+# module CarrierWave
+#   class Uploader::Base
+#     def __bson_dump__(io, key)
+#       data = versions.merge({default: self.to_s})
+
+#       io << Types::OBJECT_ID
+#       io << key
+#       io << NULL_BYTE
+#       io << data
+#     end
+#   end
+# end
+
+module Mongoblazer
+  module ActiveRecord
+    module Carrierwave
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def mount_uploader(name, klass, options={})
+          mongoblazer_init uploaders: name
+          super
+        end
+
+        private
+
+        def configure_mongoblazer_uploaders!
+          mongoblazer_options[:uploaders].map do |uploader|
+            <<-CODE
+              def #{uploader}
+                @#{uploader} ||= begin
+                  klass = Class.new OpenStruct do
+                    def to_s
+                      default
+                    end
+                  end
+
+                  klass.new(attributes['#{uploader}'])
+                end
+              end
+            CODE
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoblazer/document.rb

@@ -0,0 +1,34 @@
+module Mongoblazer
+  module Document
+    extend ActiveSupport::Concern
+    include Mongoid::Document
+
+    included do
+      field :ar_id, type: String
+
+      index ar_id: 1
+
+      def is_mongoblazed?
+        true
+      end
+
+      def ar_object
+        @ar_object ||= self.class.name.sub(/Blazer$/, '').constantize.find(ar_id)
+      end
+
+      def method_missing(method_sym, *arguments, &block)
+        begin
+          super
+        rescue NoMethodError
+          Rails.logger.debug "MONGOBLAZER DEBUG: #{self.class.name} access to unblazed method:
+            #{method_sym} with args:
+            #{arguments.inspect}
+            for record with id: #{id}"
+          if ar_object.respond_to? method_sym
+            ar_object.send method_sym
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoblazer/railtie.rb

@@ -0,0 +1,27 @@
+module Mongoblazer
+  if defined? Rails::Railtie
+    require 'rails'
+
+    class Railtie < Rails::Railtie
+      initializer 'mongoblazer.insert_into_active_record' do
+        ActiveSupport.on_load :active_record do
+          Mongoblazer::Railtie.insert
+        end
+      end
+
+      # rake_tasks do
+      #   load "tasks/mongoblazer.rake"
+      # end
+    end
+  end
+
+  class Railtie
+    def self.insert
+      if defined?(::ActiveRecord)
+        ::ActiveRecord::Base.class_eval do
+          include Mongoblazer::ActiveRecord
+        end
+      end
+    end
+  end
+end

data/lib/mongoblazer/version.rb

@@ -1,3 +1,3 @@
 module Mongoblazer
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/mongoblazer.gemspec

@@ -20,6 +20,10 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "database_cleaner"
+  spec.add_development_dependency "debugger"
+  spec.add_development_dependency "sqlite3"
 
   spec.add_runtime_dependency "rails"
   spec.add_runtime_dependency "mongoid"

data/spec/mongoblazer/active_record_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe Mongoblazer::ActiveRecord do
+
+  describe ".mongoblazable" do
+    context "not enabled" do
+      subject { NotEnabled }
+      it { should_not be_mongoblazable }
+    end
+
+    context "enabled" do
+      subject { Enabled }
+      it { should be_mongoblazable }
+    end
+
+    context "enabled in parent" do
+      subject { EnabledInParent }
+      it { should be_mongoblazable }
+    end
+
+    context "options" do
+      subject { EnabledInParent.mongoblazer_options }
+      it { should eq({:indexes=>[], :uploaders=>[], :embeds_one=>{}, :embeds_many=>{:posts=>nil}, :includes=>{:posts=>[{:comments=>:user}, :tags]}, :additional_attributes=>[:additional]}) }
+    end
+  end
+
+  describe ".create_mongoblazer_class!" do
+    subject { Enabled }
+
+    it "should have defined the EnabledBlazer class" do
+      defined?(EnabledBlazer).should eq "constant"
+    end
+  end
+
+  describe ".mongoblaze!" do
+    let(:post) { Post.create(title: "Foo", body: "Bar baz burp", status: 'published')}
+    let(:enabled) { Enabled.create(name: "Enabled", posts: [post]) }
+
+    context "after_create" do
+      before { Enabled.any_instance.should_receive :mongoblaze! }
+
+      it { enabled }
+    end
+
+    context "with relations" do
+      subject { enabled.mongoblazed }
+
+      it "should contain a post" do
+        subject.posts.size.should be 1
+      end
+
+      context "related data" do
+        subject {  enabled.mongoblazed.posts.first }
+
+        its(:title)   { should eq "Foo" }
+        its(:body)    { should eq "Bar baz burp" }
+        its(:status)  { should eq "published" }
+      end
+
+      context "with additional_attributes" do
+        its(:additional) { should eq "additional attribute to include" }
+      end
+
+      context "with attributes not in blazed fallback" do
+        its(:not_in_blazed) { should eq "this is not in the blazed instance" }
+      end
+    end
+
+    context "with enabled relations" do
+      let(:enabled) { WithEnabledRelation.create(name: "FooBar", related_enableds: [related_enabled]) }
+      let(:related_enabled) { RelatedEnabled.create(name: "Related To FooBar") }
+      subject { enabled.mongoblazed }
+
+      its(:name) { should eq "FooBar" }
+
+      it "should have embedded related_enableds" do
+        subject.related_enableds.size.should be 1
+      end
+
+      context "options" do
+        subject { WithEnabledRelation.mongoblazer_options }
+        it { should eq({:indexes=>[], :uploaders=>[], :embeds_one=>{}, :embeds_many=>{:related_enableds=>nil}, :includes=>:related_enableds}) }
+      end
+
+      context "relations" do
+        subject {  enabled.mongoblazed.related_enableds.first }
+
+        its(:name) { should eq "Related To FooBar" }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+ENV["RACK_ENV"]  ||= 'test'
+ENV['RAILS_ENV'] ||= 'test'
+
+require 'bundler'
+Bundler.require
+
+Dir[File.expand_path("../../lib/**/*.rb", __FILE__)].each {|f| require f}
+Dir[File.expand_path("../support/**/*.rb", __FILE__)].each {|f| require f}
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.tty = true
+  config.formatter = :progress
+end

data/spec/support/ar.rb

@@ -0,0 +1,121 @@
+::ActiveRecord::Base.class_eval do
+  include Mongoblazer::ActiveRecord
+end
+
+ActiveRecord::Base.establish_connection(
+  :adapter => 'sqlite3',
+  :database => ':memory:'
+)
+
+ActiveRecord::Schema.define(:version => 0) do
+  create_table "not_enableds" do |t|
+    t.string "name"
+  end
+
+  create_table "enableds" do |t|
+    t.string "name"
+    t.string "mongoblazer_id"
+  end
+
+  create_table "with_enabled_relations" do |t|
+    t.string "name"
+    t.string "mongoblazer_id"
+  end
+
+  create_table "related_enableds" do |t|
+    t.string "name"
+    t.integer "with_enabled_relation_id"
+  end
+
+  create_table "posts" do |t|
+    t.integer "enabled_id"
+    t.integer "user_id"
+    t.string "title"
+    t.text "body"
+    t.string "status"
+  end
+
+  add_index "posts", "status", name: "index_posts_on_status"
+
+  create_table "comments" do |t|
+    t.integer "post_id"
+    t.integer "user_id"
+    t.string "text"
+  end
+
+  create_table "users" do |t|
+    t.string "name"
+  end
+
+  create_table "tags" do |t|
+    t.string "name"
+  end
+
+  create_table "posts_tags", id: false do |t|
+    t.integer "post_id"
+    t.integer "tag_id"
+  end
+end
+
+class NotEnabled < ActiveRecord::Base
+end
+
+class Enabled < ActiveRecord::Base
+  has_many :posts
+
+  mongoblazer_includes posts: [{comments: :user}, :tags]
+  mongoblazer_additional_attributes [:additional]
+
+  after_save :mongoblaze!
+
+  def additional
+    "additional attribute to include"
+  end
+
+  def not_in_blazed
+    "this is not in the blazed instance"
+  end
+end
+
+class EnabledInParent < Enabled
+end
+
+class WithEnabledRelation < ActiveRecord::Base
+  has_many :related_enableds
+
+  mongoblazer_includes :related_enableds
+
+  after_save :mongoblaze!
+end
+
+class RelatedEnabled < ActiveRecord::Base
+  belongs_to :with_enabled_relation
+
+  mongoblazer_includes :with_enabled_relation
+end
+
+class DefaultScoped < Enabled
+  default_scope where(foo: "bar")
+end
+
+class Post < ActiveRecord::Base
+  belongs_to              :user
+  has_many                :comments
+  has_and_belongs_to_many :tags
+
+  default_scope where(status: 'published')
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :post
+  belongs_to :user
+end
+
+class User < ActiveRecord::Base
+  has_many :posts
+  has_many :comments
+end
+
+class Tag < ActiveRecord::Base
+  has_and_belongs_to_many :posts
+end

data/spec/support/database_cleaner.rb

@@ -0,0 +1,20 @@
+require 'database_cleaner'
+
+RSpec.configure do |config|
+
+  config.before :suite do
+    DatabaseCleaner.orm =      :mongoid
+    DatabaseCleaner.strategy = :truncation
+    DatabaseCleaner.clean_with :truncation
+  end
+
+  config.before :each do
+    DatabaseCleaner.clean
+    DatabaseCleaner.start
+  end
+
+  config.after :each do
+    DatabaseCleaner.clean
+  end
+
+end

data/spec/support/mongoid.rb

@@ -0,0 +1 @@
+Mongoid.load!(File.expand_path("../mongoid.yml", __FILE__))

data/spec/support/mongoid.yml

@@ -0,0 +1,6 @@
+test:
+  sessions:
+    default:
+      hosts:
+        - <%= ENV['WERCKER'] ? "#{ENV['WERCKER_MONGODB_HOST']}:#{ENV['WERCKER_MONGODB_PORT']}" : "localhost:27017" %>
+      database: mongoblazer_test

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongoblazer
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-05 00:00:00.000000000 Z
+date: 2013-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -43,6 +43,70 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -89,8 +153,18 @@ files:
 - README.md
 - Rakefile
 - lib/mongoblazer.rb
+- lib/mongoblazer/active_record.rb
+- lib/mongoblazer/active_record/carrierwave.rb
+- lib/mongoblazer/document.rb
+- lib/mongoblazer/railtie.rb
 - lib/mongoblazer/version.rb
 - mongoblazer.gemspec
+- spec/mongoblazer/active_record_spec.rb
+- spec/spec_helper.rb
+- spec/support/ar.rb
+- spec/support/database_cleaner.rb
+- spec/support/mongoid.rb
+- spec/support/mongoid.yml
 homepage: http://springest.github.com/mongoblazer
 licenses:
 - MIT
@@ -116,4 +190,10 @@ rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: MongoBlazer to flatten ActiveRecord Models into Mongodb Documents
-test_files: []
+test_files:
+- spec/mongoblazer/active_record_spec.rb
+- spec/spec_helper.rb
+- spec/support/ar.rb
+- spec/support/database_cleaner.rb
+- spec/support/mongoid.rb
+- spec/support/mongoid.yml