mongocore 0.1.0 → 0.1.1

data/lib/mongocore/document.rb

@@ -0,0 +1,301 @@
+module Mongocore
+  module Document
+    extend ActiveSupport::Concern
+
+    # # # # # # # # #
+    # The Document module holds data and methods for your models:
+    #
+    # class Model
+    #   include Mongocore::Document
+    # end
+    #
+    # Then after that create a model with m = Model.new
+    #
+    # The Model class, accessible from Model or m.class, holds the data
+    # for your models like the schema and the keys.
+    #
+    # The model instance, m, lets you do operations on a single model
+    # like m.save, m.update, m.delete
+    #
+
+    included do
+
+      # Accessors, everything is writable if you need something dynamic.
+      class << self
+        attr_accessor :schema, :access, :filters
+      end
+
+      # Schema
+      @schema = Mongocore::Schema.new(self)
+
+      # Access
+      @access = Mongocore::Access.new(@schema)
+
+      # Filters
+      @filters = Mongocore::Filters.new(self)
+
+      # # # # # # # # # # #
+      # Instance variables
+      # @errors is used for validates
+      # @changes keeps track of object changes
+      # @saved indicates whether this is saved or not
+      #
+
+      attr_accessor :errors, :changes, :saved
+
+
+      # # # # # # # # # # #
+      # The class initializer, called when you write Model.new
+      # Pass in attributes you want to set: Model.new(:duration => 60)
+      # Defaults are filled in automatically.
+      #
+
+      def initialize(a = {})
+        a = a.deep_symbolize_keys
+
+        # The _id has the BSON object, create new unless it exists
+        a[:_id] ? @saved = true : a[:_id] = BSON::ObjectId.new
+
+        # The errors hash
+        @errors = Hash.new{|h, k| h[k] = []}
+
+        # Defaults
+        self.class.schema.defaults.each{|k, v| write(k, v)}
+
+        # Set the attributes
+        a.each{|k, v| write(k, v)}
+
+        # The changes hash
+        @changes = Hash.new{|h, k| h[k] = []}
+      end
+
+      # # # # # # # # # # # #
+      # Model methods are called with m = Model.new, m.method_name
+      # # # # # # # # # # # # # # # # # #
+      #
+      # Database methods
+      #
+
+      # Save attributes to db
+      def save(o = {})
+        # Send :validate => true to validate
+        return nil unless valid? if o[:validate]
+
+        # Create a new query
+        filter(:save){mq(self.class, {:_id => @_id}).update(attributes)}
+      end
+
+      # Update document in db
+      def update(a = {})
+        a.each{|k, v| write(k, v)}; filter(:update){single.update(a)}
+      end
+
+      # Delete a document in db
+      def delete
+        filter(:delete, false){single.delete}
+      end
+
+      # Run filters before and after accessing the db
+      def filter(cmd, saved = true, &block)
+        run(:before, cmd); yield.tap{@saved = saved; run(:after, cmd)}
+      end
+
+      # Reload the document from db and update attributes
+      def reload
+        single.first.tap{|m| attributes = m.attributes}
+      end
+
+      # Set the timestamps if enabled
+      def timestamps
+        t = Time.now.utc; @updated_at = t; @created_at = t if unsaved?
+      end
+
+
+      # # # # # # # # # # # # # # # #
+      # Attribute methods
+      #
+
+      # Collect the attributes, pass tags like defined in your model yml
+      def attributes(*tags)
+        a = {}; self.class.schema.attributes(tags.map(&:to_s)).each{|k| a[k] = read!(k)}; a
+      end
+
+      # Set the attributes
+      def attributes=(a)
+        a.each{|k, v| write!(k, v)}
+      end
+
+      # Changed?
+      def changed?
+        changes.any?
+      end
+
+      # JSON format, pass tags as symbols: to_json(:badge, :gun)
+      def to_json(*args)
+        attributes(*args).to_json
+      end
+
+      # # # # # # # # # # # # # # # #
+      # Validation methods
+      #
+
+      # Valid?
+      def valid?
+        self.class.filters.valid?(self)
+      end
+
+      # Available filters are :save, :update, :delete
+      def run(filter, key = nil)
+        self.class.filters.run(self, filter, key)
+      end
+
+
+      # # # # # # # # # # # # # # # #
+      # Convenience methods
+      #
+
+      # Saved? Persisted?
+      def saved?; !!@saved; end
+
+      # Unsaved? New record?
+      def unsaved?; !@saved; end
+
+      # Short cut for setting up a Mongocore::Query object
+      def mq(m, q = {}, o = {}, s = {})
+        Mongocore::Query.new(m, q, o, {:source => self}.merge(s))
+      end
+
+      # Short cut for simple query with cache buster
+      def single(s = {:cache => false})
+        mq(self.class, {:_id => @_id}, {}, s)
+      end
+
+
+      # # # # # # # # # # # # # # # #
+      # Read and write instance variables
+      #
+
+      # Get attribute if access
+      def read(key)
+        self.class.access.read?(key) ? read!(key) : nil
+      end
+
+      # Get attribute
+      def read!(key)
+        instance_variable_get("@#{key}")
+      end
+
+      # Set attribute if access
+      def write(key, val)
+        return nil unless self.class.access.write?(key)
+
+        # Convert to type as in schema yml
+        v = self.class.schema.convert(key, val)
+
+        # Record change for dirty attributes
+        read!(key).tap{|r| @changes[key] = r if v != r} if @changes
+
+        # Write attribute
+        write!(key, v)
+      end
+
+      # Set attribute
+      def write!(key, v)
+        instance_variable_set("@#{key}", v)
+      end
+
+      # Dynamically read or write attributes
+      def method_missing(name, *args, &block)
+        # Extract name and write mode
+        name =~ /([^=]+)(=)?/
+
+        # Write or read
+        if self.class.schema.keys.has_key?(key = $1.to_sym)
+          return write(key, args.first) if $2
+          return read(key)
+        end
+
+        # Attributes changed?
+        return changes.has_key?($1.to_sym) if key =~ /(.+)_changed\?/
+
+        # Attributes was
+        return changes[$1.to_sym] if key =~ /(.+)_was/
+
+        # Pass if nothing found
+        super
+      end
+
+    end
+
+
+    # # # # # # # # # # # # # # #
+    # Class methods are mostly database lookups and filters
+    #
+
+    class_methods do
+
+      # Find, takes an id or a hash
+      def find(*args)
+        mq(self, *args)
+      end
+
+      # Count
+      def count(*args)
+        find(*args).count
+      end
+
+      # First
+      def first(*args)
+        find(*args).first
+      end
+
+      # Last
+      def last
+        sort(:_id => -1).limit(1).first
+      end
+
+      # All
+      def all(*args)
+        find(*args).all
+      end
+
+      # Sort
+      def sort(o = {})
+        find({}, {}, :sort => o)
+      end
+
+      # Limit
+      def limit(n = 1)
+        find({}, {}, :limit => n)
+      end
+
+      # # # # # # # # #
+      # After, before and validation filters
+      # Pass a method name as symbol or a block
+      #
+      # Possible events for after and before are :save, :update, :delete
+      #
+
+      # After
+      def after(*args, &block)
+        filters.after[args[0]] << (args[1] || block)
+      end
+
+      # Before
+      def before(*args, &block)
+        filters.before[args[0]] << (args[1] || block)
+      end
+
+      # Validate
+      def validate(*args, &block)
+        filters.validate << (args[0] || block)
+      end
+
+      # Short cut for setting up a Mongocore::Query object
+      def mq(*args)
+        Mongocore::Query.new(*args)
+      end
+
+    end
+  end
+end

data/lib/mongocore/filters.rb

@@ -0,0 +1,45 @@
+module Mongocore
+  class Filters
+
+    # # # # # # # #
+    # The Filters class is responsible for the before, after and validate filters.
+    #
+
+    # Accessors
+    attr_accessor :klass, :before, :after, :validate
+
+    # Init
+    def initialize(klass)
+      # Save model class
+      @klass = klass
+
+      # The before filters
+      @before = Hash.new{|h, k| h[k] = []}
+
+      # Add timestamp filters if enabled
+      [:save, :update].each{|f| @before[f] << :timestamps} if Mongocore.timestamps
+
+      # The after filters
+      @after = Hash.new{|h, k| h[k] = []}
+
+      # The validators
+      @validate = []
+    end
+
+    # Valid?
+    def valid?(m)
+      @validate.each{|k| call(k, m)}; m.errors.empty?
+    end
+
+    # Available filters are :save, :update, :delete
+    def run(m, f, key = nil)
+      send(f)[key].each{|k| call(k, m)}
+    end
+
+    # Execute a proc or a method
+    def call(k, m)
+      k.is_a?(Proc) ? m.instance_eval(&k) : m.send(k)
+    end
+
+  end
+end

data/lib/mongocore/query.rb

@@ -0,0 +1,125 @@
+module Mongocore
+  class Query
+
+    # # # # # # # #
+    # The Query class keeps the cursor and handles the connection with the
+    # underlying MongoDB database. A new query is created every time you call
+    # find, sort, limit, count, update, scopes and associations.
+    #
+    # Every query can be chained, but only one find is ever done to the database,
+    # it's only the parameters that change.
+    #
+
+    attr_accessor :model, :collection, :colname, :query, :options, :store, :cache
+
+    # These options will be deleted before doing the find
+    def initialize(m, q = {}, o = {}, s = {})
+      # Support find passing a ID
+      q = {:_id => oid(q)} unless q.is_a?(Hash)
+
+      # Storing model class. The instance can be found in store[:source]
+      @model = m
+
+      # The model name is singular, the collection name is plural
+      @colname = "#{m.to_s.downcase}s".to_sym
+
+      # Storing the Mongo::Collection object
+      @collection = Mongocore.db[@colname]
+
+      # Storing query and options. Sort and limit is stored in options
+      s[:sort] ||= {}; s[:limit] ||= 0; s[:chain] ||= []; s[:source] ||= nil
+      @query, @options, @store = q, o, s
+
+      # Set up cache
+      @cache = Mongocore::Cache.new(self)
+    end
+
+    # Find. Returns a Mongocore::Query
+    def find(q = {}, o = {}, s = {})
+      Mongocore::Query.new(@model, @query.merge(q), @options.merge(o), @store.merge(s))
+    end
+
+    # Cursor
+    def cursor
+      @collection.find(@query, @options).sort(@store[:sort]).limit(@store[:limit])
+    end
+
+    # Update
+    def update(a)
+      # We do $set on non nil, $unset on nil
+      u = {
+        :$set => a.select{|k, v| !v.nil?}, :$unset => a.select{|k, v| v.nil?}
+      }.delete_if{|k, v| v.empty?}
+
+      # Update the collection
+      @collection.update_one(@query, u, :upsert => true)
+    end
+
+    # Delete
+    def delete
+      @collection.delete_one(@query)
+    end
+
+    # Count. Returns the number of documents as an integer
+    def count
+      counter || fetch(:count)
+    end
+
+    # Check if there's a corresponding counter for this count
+    def counter(s = @store[:source], c = @store[:chain])
+      s.send(%{#{@colname}#{c.present? ? "_#{c.join('_')}" : ''}_count}) rescue nil
+    end
+
+    # Return first document
+    def first(doc = nil)
+      (doc ||= fetch(:first)) ? @model.new(doc.to_hash) : nil
+    end
+
+    # Return last document
+    def last
+      sort(:_id => -1).limit(1).first
+    end
+
+    # Return all documents
+    def all
+      fetch(:to_a).map{|d| first(d)}
+    end
+
+    # Fetch docs, pass type :first, :to_a or :count
+    def fetch(t)
+      cache.get(t) if Mongocore.cache
+
+      # Fetch from mongodb and add to cache
+      cursor.send(t).tap{|r| cache.set(t, r) if Mongocore.cache}
+    end
+
+    # Sort
+    def sort(o = {})
+      find(@query, options, @store.tap{store[:sort].merge!(o)})
+    end
+
+    # Limit
+    def limit(n = 1)
+      find(@query, @options, @store.tap{store[:limit] = n})
+    end
+
+    # Cache key
+    def key
+      @key ||= "#{@model}#{@query.sort}#{@options.sort}#{@store.values}"
+    end
+
+    # String id to BSON::ObjectId, or create a new by passing nothing or nil
+    def oid(id = nil)
+      return id if id.is_a?(BSON::ObjectId)
+      return BSON::ObjectId.new if !id
+      BSON::ObjectId.from_string(id) rescue id
+    end
+
+    # Call and return the scope if it exists
+    def method_missing(name, *arguments, &block)
+      return @model.send(name, @query, @options, @store.tap{@store[:chain] << name}) if @model.schema.scopes.has_key?(name)
+      super
+    end
+
+  end
+end

data/lib/mongocore/schema.rb

@@ -0,0 +1,117 @@
+module Mongocore
+  class Schema
+
+    # # # # # # # #
+    # The Schema class is responsible for the schema handling.
+    #
+
+    # Accessors
+    attr_accessor :klass, :path, :schema, :meta, :accessors, :keys, :many, :scopes, :defaults
+
+    # Init
+    def initialize(klass)
+      # Store the document
+      @klass = klass
+
+      # Schema path
+      @path = File.join(Mongocore.schema, "#{@klass.to_s.downcase}.yml")
+
+      # Load schema
+      @schema = YAML.load(File.read(@path)).deep_symbolize_keys
+
+      # Meta
+      @meta = @schema[:meta] || {}
+
+      # Keys
+      @keys = @schema[:keys] || {}
+
+      # Accessors
+      (@accessors = @schema[:accessor] || []).each{|a| @klass.send(:attr_accessor, a)}
+
+      # Many
+      (@many = @schema[:many] || {}).each{|k, v| many(k, v)}
+
+      # Scopes
+      (@scopes = @schema[:scopes] || {}).each{|k, v| scope(k, v)}
+
+      # Defaults and foreign keys
+      @defaults = {}; @keys.each{|k, v| foreign(k, v); @defaults[k] = v[:default]}
+    end
+
+    # Get attributes that has these tags
+    def attributes(tags)
+      (tags[0] ? @keys.select{|k, v| v[:tags] & tags} : @keys).keys
+    end
+
+    # Convert type if val and schema type is set
+    def convert(key, val)
+      return nil if val.nil?
+      type = @keys[key][:type].to_sym rescue nil
+      return val if type.nil?
+
+      # Convert to the same type as in the schema
+      return val.to_i if type == :integer
+      return val.to_f if type == :float
+      return !!val    if type == :boolean
+      if type == :object_id and !val.is_a?(BSON::ObjectId)
+        return BSON::ObjectId.from_string(val) rescue nil
+      end
+      val
+    end
+
+    # # # # # # # # #
+    # Templates for foreign key, many-associations and scopes.
+    #
+
+    # Foreign keys
+    def foreign(key, data)
+      return if key !~ /(.+)_id/
+      t = %Q{
+        def #{$1}
+          @#{$1} ||= mq(#{$1.capitalize}, :_id => @#{key}).first
+        end
+
+        def #{$1}=(m)
+          @#{key} = m._id
+          @#{$1} = m
+        end
+      }
+      @klass.class_eval t
+    end
+
+    # Many
+    def many(key, data)
+      t = %Q{
+        def #{key}
+          mq(#{key[0..-2].capitalize}, {:#{@klass.to_s.downcase}_id => @_id}, {}, :source => self)
+        end
+      }
+      @klass.class_eval t
+    end
+
+    # Set up scope and insert it
+    def scope(key, data)
+      # Extract the parameters
+      pm = data.delete(:params) || []
+
+      # Replace data if we are using parameters
+      d = %{#{data}}
+      pm.each do |a|
+        d.scan(%r{(=>"(#{a})(\.[a-z0-9]+)?")}).each do |n|
+          d.gsub!(n[0], %{=>#{n[1]}#{n[2]}})
+        end
+      end
+
+      # Define the scope method so we can call it
+      j = pm.any? ? %{#{pm.join(', ')},} : ''
+      t = %Q{
+        def #{key}(#{j} q = {}, o = {}, s = {})
+          mq(self, q.merge(#{d}), o, {:scope => [:#{key}]}.merge(s))
+        end
+      }
+      @klass.instance_eval t
+    end
+
+
+  end
+end

data/lib/mongocore.rb

@@ -1,7 +1,12 @@
 require 'active_support'
 require 'active_support/core_ext'
+require 'yaml'
+require 'json'
+require 'mongo'
+require 'request_store'
 
 module Mongocore
+  VERSION = '0.1.1'
 
   # # # # # #
   # Mongocore Ruby Database Driver.

data/models/model.rb

@@ -0,0 +1,44 @@
+class Model
+  include Mongocore::Document
+
+  # Just define a validate method and call it when needed
+  # Use the errors hash to add your errors to it
+  validate do
+    errors[:duration] << 'duration must be greater than 0' if duration and duration < 1
+    errors[:goal] << 'you need a higher goal' if goal and goal < 5
+  end
+
+  attr_accessor :list
+
+  before :save do
+    (@list ||= []) << 'before_save'
+  end
+
+  before :update do
+    (@list ||= []) << 'before_update'
+  end
+
+  before :delete do
+    (@list ||= []) << 'before_delete'
+  end
+
+  after :save do
+    (@list ||= []) << 'after_save'
+  end
+
+  after :update do
+    (@list ||= []) << 'after_update'
+  end
+
+  after :delete do
+    (@list ||= []) << 'after_delete'
+  end
+
+  # Save, update, delete
+  # before :delete, :hello
+  # after(:delete){ puts "Hello" }
+
+  # def hello
+  #   puts "HELLO"
+  # end
+end

data/models/parent.rb

@@ -0,0 +1,30 @@
+class Parent
+  include Mongocore::Document
+
+  attr_accessor :list
+
+  before :save do
+    (@list ||= []) << 'before_save'
+  end
+
+  before :update do
+    (@list ||= []) << 'before_update'
+  end
+
+  before :delete do
+    (@list ||= []) << 'before_delete'
+  end
+
+  after :save do
+    (@list ||= []) << 'after_save'
+  end
+
+  after :update do
+    (@list ||= []) << 'after_update'
+  end
+
+  after :delete do
+    (@list ||= []) << 'after_delete'
+  end
+
+end

data/mongocore.gemspec

@@ -0,0 +1,22 @@
+Gem::Specification.new do |s|
+  s.name        = 'mongocore'
+  s.version     = '0.1.1'
+  s.date        = '2017-01-05'
+  s.summary     = "MongoDB ORM implementation on top of the Ruby MongoDB driver"
+  s.description = "Does validations, associations, scopes, filters, counter cache, request cache, and nested queries. Using a YAML schema file, which supports default values, data types, and security levels for each key."
+  s.authors     = ["Fugroup Limited"]
+  s.email       = 'mail@fugroup.net'
+
+  s.add_runtime_dependency 'mongo', '~> 2.2'
+  s.add_runtime_dependency 'request_store', '>= 0'
+  s.add_runtime_dependency 'activesupport', '>= 0'
+  s.add_development_dependency 'futest', '>= 0'
+
+  s.homepage    = 'https://github.com/fugroup/mongocore'
+  s.license     = 'MIT'
+
+  s.require_paths = ['lib']
+  s.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+end