mongo_collection 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8d57196d59c0c6e82eda6db662c906704be9f887
+  data.tar.gz: 5a06d4350e25e36549f5670c86d8d0e7915f7ded
+SHA512:
+  metadata.gz: 95c2734d9832225cd8b3de686b72305ebfb9871fa62a2dd5a168091962c2badea0571a90ca953a3ab1ea60ff89849d41e1f4c8513b9faf95e01188712cc5d404
+  data.tar.gz: 27490be6d563224211e94b1242d692949856dc35c2b71b80510f9f72bb726893583fe4ccd70e26e827f8d48bed89f67d8066cfe2656f62b71bc408db783af1d9

data/lib/mongo_collection.rb

@@ -0,0 +1,479 @@
+module MongoCollection 
+    def self.included base
+        base.extend ClassMethods       
+    end
+    class MongoCollectionProxy         
+        def initialize(collection, klass)
+            @class = klass
+            @target = collection        
+        end
+    
+        def method_missing(method, *args, &block)
+            result = @target.send(method, *args, &block)                    
+            if result.is_a?(BSON::Document)
+                return @class.from_bson(result)
+            elsif result.is_a?(Fixnum)
+                return result
+            elsif result.is_a?(Array)
+                return result.map{|bson| @class.from_bson(bson)}                            
+            elsif result.is_a?(TrueClass) || result.is_a?(FalseClass)
+                return result
+            end
+            @target = result 
+            self
+        end
+    
+        def all
+            self.to_a
+        end
+
+        def sort_by(&block)            
+            self.to_a.sort_by(&block)
+        end
+
+        def map(&block)
+            self.to_a.map(&block)
+        end
+        
+        def each_cursor 
+            @target.each 
+        end
+        
+        def each(&block)
+            self.to_a.each(&block)
+        end
+
+        def to_h
+            self.map{|x| x.to_h}
+        end
+        
+        def blank? 
+            self.to_a.blank?
+        end
+       
+    end
+
+    module InstanceMethods 
+        def initialize(args=nil)       
+            self.class.defaults.each do |k, v|                
+                self.send(k.to_s+"=", v)                
+            end
+            if !args.is_a?(Hash)
+                return
+            end
+            args.each do |k,v|                
+                if v == nil 
+                    next
+                end
+                k_sym = k.to_sym
+                k_str = k.to_s 
+                new_val = v 
+
+                if self.class.has_one_assosiations.has_key?(k_sym)                
+                    klass = self.class.has_one_assosiations[k_sym].constantize
+                    if v.is_a?(Hash)
+                        new_val = klass.new(v)
+                    elsif !v.is_a?(klass)
+                        raise "Value should be a hash or #{klass.to_s}"
+                    end
+                end              
+                if self.class.has_many_assosiations.has_key?(k_sym)                    
+                    klass = self.class.has_many_assosiations[k_sym].constantize
+                    if !v.is_a?(Array)
+                        raise "Has many assosiations should be in form of Array"
+                    end
+                    
+                    new_val = v.map do |obj|                    
+                        new_obj = obj
+                        if obj.is_a?(Hash)                        
+                            new_obj = klass.new(obj)                        
+                        elsif !obj.is_a?(klass)
+                            raise "Value should be a hash or #{klass.to_s}"
+                        end                          
+                        new_obj                  
+                    end
+
+                end
+                instance_variable_set "@#{k_str}", new_val if self.class.props.member?(k_sym)
+            end
+        end
+
+        def new?       
+            if self._id.blank?
+                return true
+            end
+            !BSON::ObjectId.legal?(self._id)            
+        end
+
+        def destroy
+            if self.new? 
+                return false 
+            end
+            r = self.class.collection.delete_one(_id: BSON::ObjectId(self._id))
+            if !self.class.after_destroy_block.nil?                
+                self.class.after_destroy_block.call(self)                
+            end
+            r
+        end
+
+        def save
+            
+            if !self.class.before_save_block.nil?                
+                self.class.before_save_block.call(self)                
+            end           
+
+            self.class.has_one_assosiations.each do |k,v|
+                val = self.send(k)            
+                if !val 
+                    next 
+                end
+                if val.new? 
+                    if !val.save 
+                        raise "Unable to save assosiation #{v}"
+                    end           
+                end
+            end
+            
+            self.class.has_many_assosiations.each do |k,v|
+                val = self.send(k)            
+                if !val 
+                    next 
+                end                
+                val.each do |obj|
+                    if obj.new? && !obj.save                    
+                        raise "Unable to save assosiation #{v}"                    
+                    end    
+                end
+            end
+
+            if self.new?               
+                self._id = nil 
+                result = DB[self.class.mongo_collection]
+                .insert_one(self.class.to_bson(self))                
+                if result.ok?
+                    self._id = result.inserted_id.to_s
+                end
+                ok = result.ok?                
+            else                 
+                ok = DB[self.class.mongo_collection]
+                .update_one({_id: BSON::ObjectId(self._id)}, self.class.to_bson(self))
+                .ok? 
+            end
+            if ok && !self.class.after_save_block.nil?                
+                self.class.after_save_block.call(self)                                   
+            end
+            ok
+        end
+
+        def to_h
+            result = {}        
+
+            self.class.props.each do |prop|            
+                value = self.send(prop)
+                if value.nil? 
+                    next
+                end      
+                     
+                if self.class.has_one_assosiations.has_key?(prop)
+                    value = value.to_h            
+                end
+
+                if self.class.has_many_assosiations.has_key?(prop)
+                    value = value.map{|x| x.to_h}
+                end
+                result[prop] = value
+            end
+            return result
+        end
+    end
+    
+    module ClassMethods
+        attr_accessor :mongo_collection
+        attr_accessor :props
+        attr_accessor :simple_props
+        attr_accessor :has_one_assosiations
+        attr_accessor :has_many_assosiations 
+        attr_accessor :before_save_block
+        attr_accessor :after_save_block
+        attr_accessor :after_destroy_block
+        attr_accessor :references_one_assosiations, :references_many_assosiations
+        attr_accessor :referenced_one_assosiations, :referenced_many_assosiations
+        attr_accessor :defaults
+
+        def has_mongo_collection (*args)
+            
+            class_eval <<-EOV
+            include MongoCollection::InstanceMethods
+            EOV
+
+            collection = args[0]
+            properties = args[1..-1]
+
+            @props = [:_id] + properties
+            
+            @simple_props = @props.clone
+            @has_one_assosiations = {}
+            @has_many_assosiations = {}
+            @references_one_assosiations = {}
+            @references_many_assosiations = {}
+            @referenced_one_assosiations = {} 
+            @referenced_many_assosiations = {}            
+            @before_save_block = nil
+            @after_save_block = nil
+            @after_destroy_block = nil
+            @defaults = {}
+            instance_eval { attr_accessor *@props }                                                
+                                                
+            @mongo_collection = collection
+            
+            def find_by_id(id)
+                if id.is_a?(String)
+                    id = BSON::ObjectId(id)
+                end
+
+                bson = DB[mongo_collection].find(_id: id).limit(1).first
+
+                if !bson 
+                    return nil
+                end
+
+                self.from_bson(bson) 
+            end
+
+            def before_save(&block)
+                @before_save_block = block
+            end
+            
+            def after_save(&block)
+                @after_save_block = block
+            end
+            
+            def after_destroy(&block)
+                @after_destroy = block
+            end
+
+            def count(*args)
+                self.collection.count(*args)               
+            end
+            def all 
+                self.collection.find().all
+            end
+
+            def first
+                self.collection.find().first
+            end
+
+            def find_all(limit=nil, sort=nil, direction=1)
+                req = DB[self.mongo_collection].find()
+                if sort
+                    req = req.sort({sort.to_sym => direction})
+                end
+                if limit 
+                    req = req.limit(limit)
+                end
+                req.map{|bson| self.from_bson(bson)}
+            end
+
+            def find_all_by_children_ids(fields={})                
+                query = Hash[fields.map{|k,_| [k.to_s+"._id",_]}]
+                self.collection.find(query).all
+            end
+
+            def find_one_by_children_ids(fields={})                
+                query = Hash[fields.map{|k,_| [k.to_s+"._id",_]}]
+                self.collection.find(query).first
+            end
+
+            def count_all_by_children_ids(fields={})                
+                query = Hash[fields.map{|k,_| [k.to_s+"._id",_]}]
+                self.collection.find(query).count
+            end
+
+            def find_or_create_by_name(name)
+                existing_obj = self.find_by_name(name)
+                if existing_obj
+                  return existing_obj 
+                end            
+                new_obj = self.new(name: name)
+                new_obj.save 
+                new_obj
+            end
+
+            def collection
+                MongoCollectionProxy.new(DB[self.mongo_collection], self)
+            end
+
+            def db(&block)
+                collection = DB[self.mongo_collection]
+                result = block.call(collection)
+                if result.is_a?(Array) || result.is_a?(Mongo::Collection::View)                    
+                    return result.map{|bson| self.from_bson(bson)}                
+                end
+
+                if result.is_a?(Fixnum)
+                    return result
+                end
+                return self.from_bson(result)     
+            end            
+
+            properties.each do |property|
+                method = "find_by_" + property.to_s
+                metaclass.send(:define_method, method) do |query|
+                    bson = DB[self.mongo_collection].find({property.to_sym => query}).limit(1).first 
+                    if bson
+                        return self.from_bson(bson)
+                    end
+                end
+            end
+
+
+        end
+        
+        def has_one(*args)  
+            assosiation, class_name = args
+            @props << assosiation
+            class_name ||= assosiation.to_s.camelize
+            self.has_one_assosiations[assosiation.to_sym] = class_name            
+            instance_eval { attr_accessor assosiation}                                                                             
+        end
+
+        def has_many(*args) 
+            assosiation, class_name = args
+            @props << assosiation
+            class_name ||= assosiation.to_s.sub(/s$/, "").camelize            
+            self.has_many_assosiations[assosiation.to_sym] = class_name
+            instance_eval { attr_accessor assosiation}
+        end
+
+        # def references_one(*args)
+        #     assosiation, class_name = args 
+        #     if assosiation.blank? || class_name.blank?
+        #         raise "references_one: should have both assosiation and class_name"
+        #     end
+        #     self.references_one_assosiations[assosiation.to_sym] = class_name            
+        #     assosiation_id = assosiation.to_s + "_id"
+        #     @props << assosiation_id.to_sym   
+            
+        #     child_id_accessor = assosiation.to_s + "_" + class_name.downcase + "_id"
+
+        #     instance_eval do 
+        #         attr_accessor assosiation_id.to_sym
+
+        #         define_method(assosiation) do
+        #             id = self.send(assosiation_id)
+        #             if id.nil? 
+        #                 return nil 
+        #             end
+
+        #             result = instance_variable_get("@" + assosiation.to_s)
+        #             if result 
+        #                 return result
+        #             end                 
+        #             result = class_name.constantize.find_by_id(id)
+        #             instance_variable_set("@" + assosiation.to_s, result)
+        #             return result
+        #         end
+
+        #         define_method((assosiation.to_s+"=").to_sym) do |ref_obj|                    
+        #             klass = class_name.constantize
+        #             current_id = self.send(assosiation_id)
+        #             if ref_obj.nil?
+        #                 if current_id
+        #                     child = klass.find_by_id(current_id)
+        #                     if child
+        #                         child.send(child_id_accessor + "=", nil)
+        #                         child.save
+        #                     end                            
+        #                 end 
+        #                 instance_variable_set('@' + assosiation_id, nil)                       
+        #                 return
+        #             end
+        #             if ref_obj.kind_of?(klass) == false
+        #                 raise "Referenced object shoud be kind_of #{klass}"
+        #             end
+        #             if ref_obj.new? 
+        #                 raise "Unable to reference not_saved object"
+        #             end
+        #             if current_id
+
+        #             else 
+        #                 instance_variable_set("@" + assosiation.to_s, ref_obj)                        
+        #             end
+        #             if ref_obj._id == current_id 
+        #                 return                        
+        #             else 
+                        
+        #             end
+
+                    
+        #             instance_variable_set("@" + assosiation.to_s, ref_obj)
+        #         end
+        #     end
+        # end
+        
+        # def referenced_one(*args)
+        #     class_name, reference_assoisation = args 
+        #     if reference_assoisation.blank? || class_name.blank?
+        #         raise "referenced_one: should have both reference_assoisation and class_name"
+        #     end
+        #     self.referenced_one_assosiations[reference_assoisation.to_sym] = class_name
+            
+            
+        #     parent_accessor = reference_assoisation.to_s + '_' + class_name.downcase            
+        #     parent_id = parent_accessor+ "_id"
+        #     @props << parent_id.to_sym
+
+        #     instance_eval do 
+        #         attr_accessor parent_id.to_sym
+        #         define_method(parent_accessor.to_sym) do
+        #             id = self.send(parent_id.to_sym)
+        #             if id.nil? 
+        #                 return nil
+        #             end
+        #             result = instance_variable_get("@" + parent_accessor.to_s)
+        #             if result 
+        #                 return result
+        #             end                 
+        #             result = class_name.constantize.find_by_id(id)
+        #             instance_variable_set("@" + parent_accessor.to_s, result)
+        #             result
+        #         end                
+        #         define_method((parent_accessor + '=').to_sym) do |parent_obj|
+        #             if parent_obj.new? || self.new? 
+        #                 raise "Unable to reference not saved objects" 
+        #             end
+        #             current_reference_id = self.send(parent_id)
+        #             if current_reference_id
+        #                 self.send()
+        #             end
+        #         end
+        #         define_method("unref_"+parent_accessor) do
+        #             if self.new? 
+        #                 raise "Unable to unref new object"
+        #             end
+        #             if self.send(parent_id) 
+        #                 self.send(parent_id+"=", nil)
+        #                 self.save
+        #             end
+        #         end
+        #     end            
+
+        # end
+
+        def from_bson(bson)
+            bson["_id"] = bson["_id"].to_s            
+            return self.new(bson.to_h)              
+        end
+        
+        def to_bson(item)        
+            bson = item.to_h
+            if !bson[:_id].blank?
+                bson[:_id] = BSON::ObjectId(item._id)  
+            end        
+            bson
+        end
+        def has_defaults(d)
+            @defaults = d
+        end
+    end
+end

metadata

@@ -0,0 +1,44 @@
+--- !ruby/object:Gem::Specification
+name: mongo_collection
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Pavel Malay
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-12-01 00:00:00.000000000 Z
+dependencies: []
+description: A simple ORM for mongodb
+email: flagmansupport@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mongo_collection.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.6.13
+signing_key: 
+specification_version: 4
+summary: Mongo Collection
+test_files: []