mongocore 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 15559a6ab53895176145f773faaff205c501289e
-  data.tar.gz: 29b028ec25e1035047404b83fcaa3a342162c640
+  metadata.gz: 930f0c5ba53f15b7014cb473803554975acf1679
+  data.tar.gz: 6d84ab1c806b72b558641f89cbb3608d7ee34c79
 SHA512:
-  metadata.gz: 8ae672dfcca254ff415fc76d25485af917cbd1dff5e750e1d688aa2160b92db56ef9e323358b6a291aaae0a4231c002ec6fd0c723c8be07e0deff9f10a86ca6f
-  data.tar.gz: bc320ce559c4372cd884f192c28aa98f0351d5a789adc1348c5bbf993cc02b0799af35876712362b4567b4a904b393459bed0c0b67eaf2e8609df000626edf24
+  metadata.gz: 750dcd341fee0a1266951f93705d6aeb02a03f5b0ef44af2c439ccc5d2db0d284da1d241a325393982662b88a436b61cecf768850547d252e0842dfd1fc6b42c
+  data.tar.gz: 9a98403d956ae87fec94e8833a6bdd6acd9d0ed9ea2c4979629b84ce0f69ff72b6542b04da5b87cd6dfb657f239cdccea37c371d9574647959714080d65a902e

data/.gitignore

@@ -0,0 +1,2 @@
+.bundle
+Gemfile.lock

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+**Version 0.1.0** - *2017-01-05*
+
+- Automatic saving of created_at and updated_at keys if they exist
+- All before and after filters working
+- Tagged keys working
+- Can do m.reload instead of m = m.reload

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'rerun'
+  gem 'rb-fsevent'
+  gem 'terminal-notifier'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Fugroup
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,367 @@
+# Mongocore Ruby Database Driver
+A new MongoDB ORM implementation on top of the [MongoDB Ruby driver.](https://docs.mongodb.com/ruby-driver/master/quick-start/) Very fast and light weight.
+
+The perfect companion for Sinatra or other Rack-based web frameworks.
+
+### Features
+With Mongocore you can do:
+
+* Insert, update and delete
+* Finding, sorting, limit, defaults
+* Scopes, associations, validations
+* Read and write access control for each key
+* Request cache, counter cache, track changes
+* Automatic timestamps, tagged keys
+
+The schema is specified with a YAML file which supports default values, data types, and security levels for each key.
+
+Please read [the source code](https://github.com/fugroup/mongocore/tree/master/lib/mongocore) to see how it works, it's fully commented and very small, only 7 files, and 354 lines of fully test driven code.
+
+| Library                                | Files | Comment | Lines of code |
+| -------------------------------------- | ----- | ------- | ------------- |
+| [Mongoid](http://mongoid.com)          | 256   | 14371   | 10590         |
+| [MongoMapper](http://mongomapper.com)  | 91    | 200     | 4070          |
+| [Mongocore](http://mongocore.com)      | 7     | 224     | 354           |
+
+<br>
+If you are looking for something even lighter, we also [have Minimongo,](https://github.com/fugroup/minimongo) the world's tiniest MongoDB library.
+
+The tests are written [using Futest,](https://github.com/fugroup/futest) try it out if you haven't, it makes testing so much fun.
+
+### Installation
+```
+gem install mongocore
+```
+or add to your Gemfile.
+
+Then in your model:
+```ruby
+class Model
+  include Mongocore::Document
+end
+```
+
+### Settings
+Mongocore has a few built in settings you can easily toggle:
+```ruby
+# Schema path is $app_root/config/db/schema/:model.yml
+# The yml files should have singular names
+Mongocore.schema = File.join(Dir.pwd, 'config', 'db', 'schema')
+
+# The cache stores documents in memory to avoid db round trips
+Mongocore.cache = true
+
+# The access enables the read / write access levels for the keys
+Mongocore.access = true
+
+# Enable timestamps, auto-save created_at and updated_at keys
+Mongocore.timestamps = true
+
+# Enable debug to see caching information and help
+Mongocore.debug = false
+```
+
+### Usage
+
+```ruby
+# Create a new document
+m = Model.new
+m.duration = 59
+m.save
+
+# Create another document
+p = Parent.new(:house => 'Nice')
+p.save
+
+# Reload the model attributes from the database
+p.reload
+
+# Add the parent to the model
+m.parent = p
+m.save
+
+# Finding
+query = Model.find
+
+# Query doesn't get executed until you call all, count, last or first
+m = query.all
+a = query.featured.all
+c = query.count
+l = query.last
+f = query.first
+
+# All
+m = Model.find.all
+
+# All of these can be used:
+# https://docs.mongodb.com/manual/reference/operator/query-comparison
+m = Model.find(:house => {:$ne => nil, :$eq => 'Nice'}).last
+
+# Sorting, use -1 for descending, 1 for ascending
+m = Model.find({:duration => {:$gt => 40}}, {}, :sort => {:duration => -1}).all
+m = p.models.find(:duration => 10).sort(:duration => -1).first
+
+# Limit, pass as third option to find or chain, up to you
+p = Parent.find.sort(:duration => 1).limit(5).all
+p = Parent.limit(1).last
+m = p.models.find({}, {}, :sort => {:goal => 1}, :limit => 1).first
+m = Model.sort(:goal => 1, :duration => -1).limit(10).all
+
+# First
+m = Model.find(:_id => object_id).first
+m = Model.find(object_id).first
+m = Model.find(string).first
+m = Model.find(:duration => 60, :goal => {:$gt => 0}).first
+
+# Last
+m = Model.last
+m = p.models.last
+
+# Count
+c = Model.count
+c = p.models.featured.count
+
+# Tagged keys for attributes and to_json
+m = Model.first
+m.attributes             # => All attributes
+m.attributes(:badge)     # => Attributes with the badge tag only
+m.to_json                # => All attributes as json
+m.to_json(:badge, :test) # => Pass multiple tags if needed
+
+# Track changes
+m.duration = 33
+m.changed?
+m.duration_changed?
+m.duration_was
+m.changes
+m.saved?
+m.unsaved?
+
+# Validate
+m.valid?
+m.errors.any?
+m.errors
+
+# Update
+m.update(:duration => 60)
+
+# Delete
+m.delete
+
+# Many associations
+q = p.models.all
+m = p.models.first
+m = p.models.last
+
+# Scopes
+q = p.models.featured.all
+q = p.models.featured.nested.all
+m = Model.featured.first
+
+# In your model
+class Model
+  include Mongocore::Document
+
+  # Validations will be run if you pass model.save(:validate => true)
+  # You can run them manually by calling model.valid?
+  # You can have multiple validate blocks if you want to
+  validate do
+    # The errors hash can be used to collect error messages.
+    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
+
+  # Before and after, filters: :save, :update, :delete
+  # You can have multiple blocks for each filter if needed
+  before :save, :setup
+
+  def setup
+    puts "Before save"
+  end
+
+  after :delete do
+    puts "After delete"
+  end
+end
+
+# Use pure Ruby driver, returns BSON::Document objects
+Mongocore.db[:models].find.to_a
+Mongocore.db[:models].find({:_id => m._id}).first
+
+# Indexing
+Mongocore.db[:models].indexes.create_one({:key => 1})
+Mongocore.db[:models].indexes.create_one({:key => 1}, :unique => true)
+```
+
+### Schema
+For keys, defaults, description, counters, associations, scopes and accessors, use a schema file written in [YAML.](http://yaml.org)
+
+#### Parent example schema
+```yml
+
+# The meta is information about your model
+meta:
+  name: parent
+  type: document
+
+keys:
+
+  # Use the _id everywhere. The id can be used for whatever you want.
+  # @desc: Describes the key, can be used for documentation.
+  # @type: object_id, string, integer, float, boolean, time, hash, array
+  # @default: the default value for the key when you call .new
+  # @read: access level for read: all, user, dev, admin, super, app
+  # @write: access level for write. Returns nil if no access, as on read
+
+  # Object ID, usually added for each model
+  _id:
+    desc: Unique id
+    type: object_id
+    read: all
+    write: app
+
+  # String key
+  world:
+    desc: Parent world
+    type: string
+    read: all
+    write: user
+
+  # If the key ends with _count, it will be used automatically when
+  # you call .count on the model as an automatic caching mechanism
+  models_count:
+    desc: Models count
+    type: integer
+    default: 0
+    read: all
+    write: app
+
+  # This field will be returned when you write models.featured.count
+  # Remember to create an after filter to keep it updated
+  models_featured_count:
+    desc: Models featured count
+    type: integer
+    default: 0
+    read: all
+    write: app
+
+# Many relationships lets you do:
+# Model.parents.all or model.parents.featured.all with scopes
+many:
+  models:
+    dependent: destroy
+```
+
+
+#### Model example schema
+
+```yml
+meta:
+  name: model
+  type: document
+
+keys:
+  # Object ID
+  _id:
+    desc: Unique id
+    type: object_id
+    read: all
+    write: app
+
+  # Integer key with default
+  duration:
+    desc: Model duration in days
+    type: integer
+    default: 60
+    read: dev
+    write: user
+    # Add tags for keys for use with attributes and to_json
+    tags:
+    - badge
+
+  # Time key
+  expires_at:
+    desc: Model expiry date
+    type: time
+    read: all
+    write: dev
+    # Multiple tags possible: to_json(:badge, :campaigns)
+    tags:
+    - badge
+    - campaigns
+
+  # Hash key
+  location_data:
+    desc: Model location data
+    type: hash
+    read: all
+    write: user
+
+  # Counter key
+  votes_count:
+    desc: Votes count
+    type: integer
+    default: 0
+    read: all
+    write: dev
+    tags:
+    - badge
+
+  # If the key ends with _id, it is treated as a foreign key,
+  # and you can access it from the referencing model and set it too.
+  # Example: model.parent, model.parent = parent
+  parent_id:
+    desc: Parent id
+    type: object_id
+    read: all
+    write: dev
+
+# Generate accessors (attr_accessor) for each key
+accessor:
+- submittable
+- update_expires_at
+- skip_before_save
+
+# Define scopes that lets you do Models.featured.count
+# Each scope has a name, and a set of triggers
+scopes:
+
+  # This will create a .featured scope, and add :duration => 60 to the query.
+  featured:
+    duration: 60
+
+  nested:
+    goal: 10
+
+  # Any mongodb driver query is possible
+  finished:
+    duration: 60
+    goal:
+      $gt: 10
+
+  active:
+    params:
+      - duration
+    duration:
+      $ne: duration
+
+  # You can also pass parameters into the scope, as a lambda.
+  ending:
+    params:
+     - user
+    $or:
+      - user_id: user.id
+      - listener: user.id
+      - listener: user.link
+    deletors:
+      $ne: user.id
+```
+
+### Contribute
+Contributions and feedback are welcome! MIT Licensed.
+
+Issues will be fixed, this library is actively maintained by [Fugroup Ltd.](http://www.fugroup.net) We are the creators of [CrowdfundHQ.](https://crowdfundhq.com)
+
+Thanks!
+
+`@authors: Vidar`

data/config/boot.rb

@@ -0,0 +1,23 @@
+require 'bundler/setup'
+Bundler.require(:default, :development, :test)
+
+MODE = ENV['RACK_ENV'] || 'test'
+
+require './lib/mongocore.rb'
+
+# Add settings here
+Mongocore.schema = File.join(Dir.pwd, 'config', 'db', 'schema')
+
+require './models/parent.rb'
+require './models/model.rb'
+
+# Logging verbosity
+Mongo::Logger.logger.level = ::Logger::DEBUG
+Mongo::Logger.logger.level = ::Logger::FATAL
+
+# To make the driver log to a logfile instead:
+# Mongo::Logger.logger       = ::Logger.new('mongo.log')
+# Mongo::Logger.logger.level = ::Logger::INFO
+
+# Connect to DB
+Mongocore.db = Mongo::Client.new(['127.0.0.1:27017'], :database => "mongocore_#{MODE}")

data/config/db/schema/model.yml

@@ -0,0 +1,103 @@
+---
+meta:
+  name: model
+  type: document
+keys:
+  _id:
+    desc: Unique id
+    type: object_id
+    read: all
+    write: app
+  link:
+    desc: Model link
+    read: all
+    write: dev
+    tags:
+    - badge
+  goal:
+    desc: Model goal
+    type: float
+    read: all
+    write: user
+    tags:
+    - badge
+  duration:
+    desc: Model duration in days
+    type: integer
+    default: 60
+    read: dev
+    write: user
+    tags:
+    - badge
+  expires_at:
+    desc: Model expiry date
+    type: time
+    read: all
+    write: dev
+    tags:
+    - badge
+  location_data:
+    desc: Model location data
+    type: hash
+    read: all
+    write: user
+  reminders_sent:
+    desc: Reminders sent?
+    type: boolean
+    default: false
+    read: user
+    write: dev
+  votes_count:
+    desc: Votes count
+    type: integer
+    default: 0
+    read: all
+    write: dev
+    tags:
+    - badge
+  parent_id:
+    desc: Parent id
+    type: object_id
+    read: all
+    write: dev
+  created_at:
+    desc: Created at
+    type: time
+    read: all
+    write: dev
+  updated_at:
+    desc: Updated at
+    type: time
+    read: all
+    write: dev
+
+accessor:
+- submittable
+- update_expires_at
+- skip_before_save
+- owner
+- validate_campaign_fields
+- update_link
+scopes:
+  featured:
+    duration: 60
+  nested:
+    goal: 10
+  finished:
+    duration: 60
+    goal:
+      $gt: 10
+  active:
+    params:
+      - duration
+    duration:
+      $ne: duration
+  ending:
+    params:
+     - user
+    $or:
+      - user_id: user.id
+      - listener: user.id
+      - listener: user.link
+    deletors:
+      $ne: user.id

data/config/db/schema/parent.yml

@@ -0,0 +1,41 @@
+---
+meta:
+  name: parent
+  type: document
+keys:
+  _id:
+    desc: Unique id
+    type: object_id
+    read: all
+    write: app
+  house:
+    desc: Parent house
+    type: string
+    read: all
+    write: user
+  models_count:
+    desc: Models count
+    type: integer
+    default: 0
+    read: all
+    write: app
+  models_featured_count:
+    desc: Models featured count
+    type: integer
+    default: 0
+    read: all
+    write: app
+  models_featured_nested_count:
+    desc: Models nested featured count
+    type: integer
+    default: 0
+    read: all
+    write: app
+  link:
+    desc: Link
+    read: all
+    write: dev
+
+many:
+  models:
+    dependent: destroy

data/lib/mongocore/access.rb

@@ -0,0 +1,63 @@
+module Mongocore
+  class Access
+
+    # # # # # # # #
+    # The Access class is responsible for checking if an attribute
+    # can be read or written. It uses 6 access levels and the
+    # read and write attributes in the schema yml file for the model.
+    #
+    # If your current access level is above the key level, then you
+    # can read or write, if not you get nil. This is very useful for APIs
+    # where f.ex. you want to show the email to logged in users, but not to all.
+    #
+
+    # Access levels (6)
+    AL = [:all, :user, :dev, :admin, :super, :app]
+
+    # Holds the keys from the model schema
+    attr_accessor :keys
+
+    # The access control class
+    def initialize(schema)
+      @keys = schema.keys
+    end
+
+    # Set the current access level
+    def set(level = nil)
+      set?(level) ? RequestStore.store[:access] = level : get
+    end
+
+    # Get the current access level
+    def get
+      RequestStore.store[:access]
+    end
+
+    # Reset the access level
+    def reset
+      RequestStore.store[:access] = nil
+    end
+
+    # Key readable?
+    def read?(key)
+      ok?(keys[key][:read]) rescue false
+    end
+
+    # Key writable?
+    def write?(key)
+      ok?(keys[key][:write]) rescue false
+    end
+
+    private
+
+    # Set?
+    def set?(level)
+      AL.index(level) > AL.index(get || :all)
+    end
+
+    # Ok?
+    def ok?(level)
+      !Mongocore.access || AL.index(level.to_sym) <= AL.index(get || :app)
+    end
+
+  end
+end

data/lib/mongocore/cache.rb

@@ -0,0 +1,41 @@
+module Mongocore
+
+  # # # # # # # #
+  # The Cache class keeps track of cache entries.
+  #
+  # Every query is cached, used the state as the cache key. This is a
+  # very aggressive strategy, where arrays won't get updated on update or delete.
+  #
+
+  class Cache
+
+    # Accessors
+    attr_accessor :query, :cache, :key, :type
+
+    # Init
+    def initialize(q)
+      @query = q
+      @cache = (RequestStore[:cache] ||= {})
+      @key = Digest::MD5.hexdigest(@query.key)
+    end
+
+    # Get the cache key
+    def get(t)
+      @cache[t = key + t.to_s].tap{|d| stat(d, t) if Mongocore.debug}
+    end
+
+    # Set the cache key
+    def set(t, v = nil)
+      t = key + t.to_s; v ? cache[t] = v : cache.delete(t)
+    end
+
+    private
+
+    # Stats for debug and cache
+    def stat(d, t)
+      puts('Cache ' + (d ? 'Hit!' : 'Miss') + ': ' + t)
+      RequestStore[d ? :h : :m] = (RequestStore[d ? :h : :m] || 0) + 1
+    end
+
+  end
+end