stores_in_mongo 0.3.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 64ec51cf6d63a3e3a5e66c1acb4d4ed90b8c3b07
-  data.tar.gz: c5cdbdde558ef53ccef4763b65f6f9845d0c53fe
+  metadata.gz: 05ff0ec8463f5f848e7e736bb3e50d71de2c4ae7
+  data.tar.gz: 327f6d173bbda76ebd7e4a614ab58279d9f1422f
 SHA512:
-  metadata.gz: f950dea3950ca559fd9146f8ef32c5cafec65ea1f6cec22d6c1deafb5ee316f9a5b4e849e8732b431464d2f336f76399386f5696d9bb9d6ddc227dedd48c93a1
-  data.tar.gz: 763d446a09154d1bf09bb1a886817698224d0f2716e14d2d57780ead34941a268d077d08e45ab350e104a1ad8c69db2156f8e20b56a50a7140ddd4dcb8e036b6
+  metadata.gz: 3af0be54c3fdee52d4820b781fb7a82c54fabd6c280138c939af99826390b1fcee5a0ce3d469b8bf867f489418be32a69fa6b72cd9b7a556397c261ef9877c9c
+  data.tar.gz: 3765c8da5b23fbf0c2c8219992aa6296fa87c5dd3e507584695afd980492baf6aabdf7b27b6e2becda7021a2c2460d380f8f2f8ac7319a2c082980cbd7ea786c

data/lib/stores_in_mongo.rb

@@ -1,5 +1,8 @@
 require "stores_in_mongo/base.rb"
 require "stores_in_mongo/builder.rb"
 require "stores_in_mongo/document_methods.rb"
+require "stores_in_mongo/interpreter.rb"
 
-ActiveRecord::Base.extend(StoresInMongo::Base)
+class StoresInMongo::RuntimeError < RuntimeError; end
+
+ActiveRecord::Base.include(StoresInMongo::Base)

data/lib/stores_in_mongo/base.rb

@@ -1,7 +1,36 @@
 module StoresInMongo
   module Base
-    def stores_in_mongo(field, data_type = Hash)
-      ::StoresInMongo::Builder.new(self, field, data_type).build
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def stores_in_mongo(field_name = nil, data_type = nil,
+          as: nil,
+          class_name: nil,
+          foreign_key: nil,
+          &blk)
+        raise ArgumentError, "Provide either inline field_name or block syntax, you cannot provide both to stores_in_mongo" if field_name.present? && blk.present?
+        raise ArgumentError, "Cannot use :class_name or :foreign_key with polymorphic :as option" if as.present? && (class_name.present? || foreign_key.present?)
+        if as.present?
+          foreign_key = as.to_s.foreign_key
+          class_name = foreign_key.sub(/id$/, "type")
+        end
+        class_attribute :stores_in_mongo_options
+        self.stores_in_mongo_options = {
+          polymorphic: as.present?,
+          foreign_key: foreign_key,
+          class_name: class_name,
+          use_sessions: false
+        }
+        builder = ::StoresInMongo::Builder.new(self)
+        if field_name.present?
+          builder.build do
+            field(field_name, data_type)
+          end
+        else
+          builder.build(&blk)
+        end
+      end
     end
+
   end
 end

data/lib/stores_in_mongo/builder.rb

@@ -1,44 +1,64 @@
 module StoresInMongo
   class Builder
 
-    def initialize(model, field, data_type)
+    def initialize(model)
       @model = model
-      @field = field.to_s
-      @data_type = data_type
+      @class_given = @model.stores_in_mongo_options[:class_name].present?
     end
 
-    def build
-      @model.class_attribute :mongo_data_field
-      @model.mongo_data_field = @field
-
-      document_methods = build_document_methods_module
-      @model.instance_exec(document_methods, @data_type) do |document_methods, data_type|
-        const_set("MongoDocumentMethods", document_methods)
-        include self::MongoDocumentMethods
+    def build(&blk)
+      if !@class_given
+        klass = build_mongo_class
+        @model.stores_in_mongo_options[:class_name] = klass.name
+      end
+      @model.stores_in_mongo_options[:foreign_key] ||= @model.stores_in_mongo_options[:class_name].foreign_key
+      @model.include(get_document_methods_module)
+      Interpreter.new(self).instance_exec(&blk)
+    end
 
-        before_save :save_document
-        before_destroy :destroy_document
+    def build_mongo_class
+      klass = @model.const_set("MongoDocument", Class.new)
+      klass.include Mongoid::Document
+      klass.include Mongoid::Timestamps
+      return klass
+    end
 
-        mongo_klass = const_set("MongoDocument", Class.new)
-        mongo_klass.include Mongoid::Document
-        mongo_klass.include Mongoid::Timestamps
-        mongo_klass.field self.mongo_data_field.to_sym, :type => data_type, default: data_type.try(:new)
+    def get_document_methods_module
+      @model.const_set("MongoDocumentMethods", Module.new)
+      @model::MongoDocumentMethods.include(StoresInMongo::DocumentMethods)
+      @model::MongoDocumentMethods.extend ActiveSupport::Concern
+      @model::MongoDocumentMethods.included do
+        before_save :save_mongo_document
+        after_save :clear_mongo_owner_dirty
+        before_destroy :destroy_mongo_document
       end
+      return @model::MongoDocumentMethods
     end
 
-    def build_document_methods_module
-      mod = Module.new
-      mod.include(StoresInMongo::DocumentMethods)
-      mod.instance_exec(@model) do |model|
-        define_method(model.mongo_data_field) do |reload = false|
-          document(reload)[model.mongo_data_field]
+    def add_field(field_name, data_type)
+      @model.stores_in_mongo_options[:class_name].constantize.field field_name, :type => data_type, default: data_type.try(:new) if !@class_given
+
+      @model::MongoDocumentMethods.instance_exec(field_name) do |field_name|
+        # getter
+        define_method(field_name) do
+          mongo_document.public_send(field_name)
         end
 
-        define_method(model.mongo_data_field + "=") do |data|
-          document[model.mongo_data_field] = data
+        # setter
+        define_method("#{field_name}=") do |data|
+          mongo_document.public_send("#{field_name}=", data)
+        end
+
+      end
+    end
+
+    def define_session(&blk)
+      @model.stores_in_mongo_options[:use_sessions] = true
+      @model::MongoDocumentMethods.instance_exec(blk) do |blk|
+        define_method("mongo_session") do
+          instance_exec(&blk)
         end
       end
-      return mod
     end
 
   end

data/lib/stores_in_mongo/document_methods.rb

@@ -1,45 +1,108 @@
 module StoresInMongo
   module DocumentMethods
+    def mongo_class_name
+      if self.stores_in_mongo_options[:polymorphic]
+        self.public_send(mongo_class_column) or raise RuntimeError, "No mongo type specified in #{mongo_class_column} for #{self}! Initialize your model with a value or use a column default."
+      else
+        self.stores_in_mongo_options[:class_name]
+      end
+    end
+
+    def mongo_class
+      if self.stores_in_mongo_options[:use_sessions]
+        mongo_class_name.constantize.with(session: mongo_session)
+      else
+        mongo_class_name.constantize
+      end
+    end
+
+    def mongo_key
+      self.public_send(mongo_key_column)
+    end
+
+    def mongo_class_column
+      self.stores_in_mongo_options[:polymorphic] && self.stores_in_mongo_options[:class_name]
+    end
+
+    def mongo_key_column
+      stores_in_mongo_options[:foreign_key]
+    end
+
     def reload(*args)
+      clear_mongo_cache
       super
-      find_or_initialize_document if document_loaded?
-      return self
     end
 
-    def dup
+    def deep_dup(*args)
       copy = super
-      copy.document = document.dup if document_loaded?
+      copy.mongo_document = mongo_document.deep_dup
       return copy
     end
 
+    def changed?
+      @mongo_dirty || super
+    end
+
+    protected
+
+    def mongo_document=(mongo_document)
+      # We can't easily determine in-place data modification, so always mark as dirty if data has been loaded
+      # TODO: only mark as dirty if data has actually changed. Clear dirty on a fresh load.
+      mark_mongo_owner_as_dirty
+      @mongo_document = mongo_document
+      set_mongo_document_id
+      return mongo_document
+    end
+
     private
 
-    def document_loaded?
-      @document.present?
+    def mark_mongo_owner_as_dirty
+      @mongo_dirty = true
+      return true
     end
 
-    def document(reload = false)
-      return @document if !reload && document_loaded?
-      @document = find_or_initialize_document
+    def clear_mongo_owner_dirty
+      @mongo_dirty = false
+      return true
     end
 
-    def save_document
-      return true if document.nil?
-      document.save
-      self.document_id = document.id
+    def mongo_document_loaded?
+      @mongo_document.present?
     end
 
-    def destroy_document
-      return true if document.nil?
-      document.destroy
-    end      
+    def clear_mongo_cache
+      @mongo_document = nil
+    end
+
+    def set_mongo_document_id
+      assign_attributes(stores_in_mongo_options[:class_name] => mongo_document.class.name) if self.stores_in_mongo_options[:polymorphic]
+      assign_attributes(stores_in_mongo_options[:foreign_key] => mongo_document.id)
+      return mongo_key
+    end
 
-    def find_or_initialize_document
-      @document = fetch_document || self.class::MongoDocument.new
+    def mongo_document(reload = false)
+      return @mongo_document if !reload && mongo_document_loaded?
+      self.mongo_document = fetch_mongo_document || initialize_mongo_document
     end
 
-    def fetch_document
-      self.class::MongoDocument.where(id: self.document_id).first
+    def fetch_mongo_document
+      mongo_class.where(id: mongo_key).first
     end
+
+    def initialize_mongo_document
+      mongo_class.new
+    end
+
+    def save_mongo_document
+      return true if !mongo_document_loaded?
+      mongo_document.save!
+      set_mongo_document_id
+      return true
+    end
+
+    def destroy_mongo_document
+      return true if !mongo_document_loaded?
+      mongo_document.destroy
+    end      
   end
 end

data/lib/stores_in_mongo/interpreter.rb

@@ -0,0 +1,15 @@
+module StoresInMongo
+  class Interpreter < BasicObject
+    def initialize(builder)
+      @builder = builder
+    end
+
+    def field(name, data_type = nil)
+      @builder.add_field(name, data_type)
+    end
+
+    def session(&blk)
+      @builder.define_session(&blk)
+    end
+  end
+end

data/lib/stores_in_mongo/mongo_store.rb

@@ -0,0 +1,14 @@
+module StoresInMongo
+  class MongoStore
+    attr_reader :name, :klass, :foreign_key
+
+    def initialize(klass, foreign_key)
+      @klass = klass
+      @foreign_key = foreign_key      
+    end
+
+    def find_or_initialize_for(owner)
+      owner[@foreign_key].present? && @klass.where(id: owner[@foreign_key]).first || @klass.new
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stores_in_mongo
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Andrew Schwartz
@@ -30,8 +30,10 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 4.0.0
-description: Use stores_in_mongo <field> in an ActiveRecord object, use it as if it
-  were local. Includes ActiveRecord-like caching behavior.
+description: Define new or provide existing Mongoid::Document classes that access
+  a mongo db, use the mongo connection for persistence of specified virtual fields
+  in an ActiveRecord model. Document creation, persistence, and reloading is handled
+  automatically and highly customizeable.
 email: ozydingo@gmail.com
 executables: []
 extensions: []
@@ -41,6 +43,8 @@ files:
 - lib/stores_in_mongo/base.rb
 - lib/stores_in_mongo/builder.rb
 - lib/stores_in_mongo/document_methods.rb
+- lib/stores_in_mongo/interpreter.rb
+- lib/stores_in_mongo/mongo_store.rb
 homepage: https://github.com/ozydingo/stores_in_mongo
 licenses:
 - MIT
@@ -64,5 +68,5 @@ rubyforge_project:
 rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
-summary: Seamlessly access and store mongo document fields from an ActiveRecord object
+summary: Seamlessly interact with mongo storage as fields of an ActiveRecord model
 test_files: []