mongodbmodel 0.0.1

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake_ext'
+
+project(
+  name: "mongodbmodel",
+  # version: '0.1.0',
+  gem: true,
+  summary: "Object Model for MongoDB",
+
+  author: "Alexey Petrushin",
+  homepage: "http://github.com/alexeypetrushin/mongodb_model"
+)

data/lib/mongo/model.rb

@@ -0,0 +1,50 @@
+require 'mongodb_model/gems'
+
+require 'validatable'
+require 'file_model'
+require 'i18n'
+require 'ruby_ext'
+require 'mongo/object'
+
+module Mongo::Model; end
+
+%w(
+  support/types
+
+  db
+  assignment
+  callbacks
+  validation
+  validation/uniqueness_validator
+  crud
+  query
+  query_mixin
+  scope
+  attribute_convertors
+  file_model
+  misc
+  model
+).each{|f| require "mongo/model/#{f}"}
+
+module Mongo
+  module Model
+    inherit \
+      Db,
+      Assignment,
+      Callbacks,
+      Validation,
+      Crud,
+      QueryMixin,
+      Scope,
+      AttributeConvertors,
+      Mongo::Model::FileModel,
+      Misc
+  end
+end
+
+Mongo.defaults.merge! \
+  symbolize:                    true,
+  convert_underscore_to_dollar: true,
+  batch_size:                   50,
+  multi:                        true,
+  safe:                         true

data/lib/mongo/model/assignment.rb

@@ -0,0 +1,65 @@
+module Mongo::Model::Assignment
+  class Dsl < BasicObject
+    def initialize
+      @attributes = {}
+    end
+
+    def self.const_missing name
+      # BasicObject doesn't have access to any constants like String, Symbol, ...
+      ::Object.const_get name
+    end
+
+    def to_h; attributes end
+
+    protected
+      attr_reader :attributes
+
+      def method_missing attribute_name, *args
+        attribute_name.must_be.a Symbol
+
+        args.size.must_be.in 1..2
+        if args.first.is_a? Class
+          type, mass_assignment = args
+          mass_assignment ||= false
+          type.must.respond_to :cast
+        else
+          type, mass_assignment = nil, args.first
+        end
+
+        attributes[attribute_name] = [type, mass_assignment]
+      end
+  end
+
+  def set attributes, options = {}
+    if rules = self.class._assign
+      force = options[:force]
+      attributes.each do |n, v|
+        n = n.to_sym
+        if rule = rules[n]
+          type, mass_assignment = rule
+          if mass_assignment or force
+            v = type.cast(v) if type
+            send "#{n}=", v
+          end
+        end
+      end
+    else
+      attributes.each{|n, v| send "#{n}=", v}
+    end
+    self
+  end
+
+  def set! attributes, options = {}
+    set attributes, options.merge(force: true)
+  end
+
+  module ClassMethods
+    inheritable_accessor :_assign, nil
+
+    def assign &block
+      dsl = ::Mongo::Model::Assignment::Dsl.new
+      dsl.instance_eval &block
+      self._assign = (_assign || {}).merge dsl.to_h
+    end
+  end
+end

data/lib/mongo/model/attribute_convertors.rb

@@ -0,0 +1,54 @@
+require 'json'
+require 'yaml'
+
+module Mongo::Model::AttributeConvertors
+  CONVERTORS = {
+    line: {
+      from_string: -> s {(s || "").split(',').collect{|s| s.strip}},
+      to_string:   -> v {v.join(', ')}
+    },
+    column: {
+      from_string: -> s {(s || "").split("\n").collect{|s| s.strip}},
+      to_string:   -> v {v.join("\n")}
+    },
+    yaml: {
+      from_string: -> s {YAML.load s rescue {}},
+      to_string:   -> v {v.to_yaml.strip}
+    },
+    json: {
+      from_string: -> s {JSON.parse s rescue {}},
+      to_string:   -> v {v.to_json.strip}
+    }
+  }
+
+  module ClassMethods
+    def available_as_string name, converter_name
+      converter = CONVERTORS[converter_name]
+      raise "unknown converter name :#{converter_name} for :#{name} field!" unless converter
+
+      from_string, to_string = converter[:from_string], converter[:to_string]
+      name_as_string = "#{name}_as_string".to_sym
+      define_method name_as_string do
+        _cache[name_as_string] ||= to_string.call(send(name))
+      end
+
+      define_method "#{name_as_string}=" do |value|
+        _cache.delete name_as_string
+        self.send "#{name}=", from_string.call(value)
+      end
+    end
+
+    def available_as_yaml name
+      raise "delimiter not specified for :#{name} field!" unless delimiter
+      method = "#{name}_as_string"
+      define_method method do
+        self.send(name).join(delimiter)
+      end
+      define_method "#{method}=" do |value|
+        value = (value || "").split(delimiter.strip).collect{|s| s.strip}
+        self.send "#{name}=", value
+      end
+    end
+  end
+
+end

data/lib/mongo/model/callbacks.rb

@@ -0,0 +1,26 @@
+module Mongo::Model::Callbacks
+  inherit RubyExt::Callbacks
+
+  module ClassMethods
+    [:validate, :create, :update, :save, :destroy].each do |method_name|
+      define_method "before_#{method_name}" do |*args, &block|
+        opt = args.extract_options!
+        if block
+          set_callback method_name, :before, opt, &block
+        else
+          opt[:terminator] = false unless opt.include? :terminator
+          args.each{|executor| set_callback method_name, :before, executor, opt}
+        end
+      end
+
+      define_method "after_#{method_name}" do |*args, &block|
+        opt = args.extract_options!
+        if block
+          set_callback method_name, :after, opt, &block
+        else
+          args.each{|executor| set_callback method_name, :after, executor, opt}
+        end
+      end
+    end
+  end
+end

data/lib/mongo/model/crud.rb

@@ -0,0 +1,57 @@
+module Mongo::Model::Crud
+  def save options = {}
+    with_collection options do |collection, options|
+      collection.save self, options
+    end
+  end
+
+  def save! *args
+    save(*args) || raise(Mongo::Error, "can't save #{self.inspect}!")
+  end
+
+  def destroy options = {}
+    with_collection options do |collection, options|
+      collection.destroy self, options
+    end
+  end
+
+  def destroy! *args
+    destroy(*args) || raise(Mongo::Error, "can't destroy #{self.inspect}!")
+  end
+
+  module ClassMethods
+    def build attributes = {}, options = {}
+      self.new.set attributes, options
+    end
+
+    def create attributes = {}, options = {}
+      o = build attributes, options
+      o.save
+      o
+    end
+
+    def create! attributes = {}, options = {}
+      o = create attributes
+      raise(Mongo::Error, "can't create #{attributes.inspect}!") if o.new_record?
+      o
+    end
+
+    def destroy_all selector = {}, options = {}
+      success = true
+      collection = options[:collection] || self.collection
+      each(selector){|o| success = false unless o.destroy}
+      success
+    end
+
+    def destroy_all! selector = {}, options = {}
+      destroy_all(selector, options) || raise(Mongo::Error, "can't destroy #{selector.inspect}!")
+    end
+  end
+
+  protected
+    def with_collection options, &block
+      options = options.clone
+      collection = options.delete(:collection) || self.class.collection
+      block.call collection, options
+    end
+end

data/lib/mongo/model/db.rb

@@ -0,0 +1,53 @@
+module Mongo::Model::Db
+  module ClassMethods
+    inheritable_accessor :_db, nil
+    def db= v
+      self._db = if v.is_a? ::Proc
+        v
+      elsif v.is_a? ::Symbol
+        -> {::Mongo::Model.connection.db v.to_s}
+      else
+        -> {v}
+      end
+    end
+
+    def db *args, &block
+      if block
+        self.db = block
+      elsif !args.empty?
+        args.size.must == 1
+        self.db = args.first
+      else
+        (_db && _db.call) || ::Mongo::Model.db
+      end
+    end
+
+    inheritable_accessor :_collection, nil
+    def collection= v
+      self._collection = if v.is_a? ::Proc
+        v
+      elsif v.is_a? ::Symbol
+        -> {db.collection v}
+      else
+        -> {v}
+      end
+    end
+
+    def collection *args, &block
+      if block
+        self.collection = block
+      elsif !args.empty?
+        args.size.must == 1
+        self.collection = args.first
+      else
+        (_collection && _collection.call) || db.collection(default_collection_name)
+      end
+    end
+
+    def default_collection_name
+      first_ancestor_class = ancestors.find{|a| a.is_a? Class} ||
+        raise("can't evaluate default collection name for #{self}!")
+      first_ancestor_class.alias.pluralize.underscore.to_sym
+    end
+  end
+end

data/lib/mongo/model/file_model.rb

@@ -0,0 +1,27 @@
+module Mongo::Model::FileModel
+  inherit ::FileModel::Helper
+
+  def attribute_get name
+    instance_variable_get :"@#{name}"
+  end
+
+  def attribute_set name, value
+    instance_variable_set :"@#{name}", value
+  end
+
+  module ClassMethods
+    def mount_file attr_name, file_model_class
+      super
+
+      before_validate do |model|
+        file_model = model.send(attr_name)
+        file_model.run_validations
+        model.errors[attr_name] = file_model.errors unless file_model.errors.empty?
+      end
+
+      after_save{|model| model.send(attr_name).save}
+
+      after_destroy{|model| model.send(attr_name).destroy}
+    end
+  end
+end

data/lib/mongo/model/misc.rb

@@ -0,0 +1,44 @@
+module Mongo::Model::Misc
+  def update_timestamps
+    now = Time.now.utc
+    self.created_at ||= now
+    self.updated_at = now
+  end
+
+
+  def _cache
+    @_cache ||= {}
+  end
+  # def _clear_cache
+  #   @_cache = {}
+  # end
+
+  def dom_id
+    # new_record? ? "new_#{self.class.name.underscore}" : to_param
+    to_param
+  end
+
+  def to_param
+    (_id || '').to_s
+  end
+
+  delegate :t, to: I18n
+
+  def reload
+    obj = self.class.by_id!(_id || raise("can't reload new document (#{self})!"))
+    instance_variables.each{|n| remove_instance_variable n}
+    obj.instance_variables.each do |n|
+      instance_variable_set n, obj.instance_variable_get(n)
+    end
+    nil
+  end
+
+  module ClassMethods
+    delegate :t, to: I18n
+
+    def timestamps!
+      attr_accessor :created_at, :updated_at
+      before_save :update_timestamps
+    end
+  end
+end

data/lib/mongo/model/model.rb

@@ -0,0 +1,13 @@
+module Mongo::Model
+  include Mongo::Object
+
+  attr_accessor :_id, :_class
+
+  def _id?; !!_id end
+  def new_record?; !_id end
+
+  class << self
+    attr_accessor :db, :connection
+    attr_required :db, :connection
+  end
+end

data/lib/mongo/model/query.rb

@@ -0,0 +1,46 @@
+class Mongo::Model::Query < Object
+  attr_reader :model, :selector, :options
+
+  def initialize model, selector = {}, options = {} *args
+    @model, @selector, @options = model, selector, options
+  end
+
+  def class
+    ::Mongo::Model::Query
+  end
+
+  def merge query
+    raise "can't merge queries with different models!" unless model == query.model
+    self.class.new model, selector.merge(query.selector), options.merge(query.options)
+  end
+
+  def inspect
+    "#<Mongo::Model::Query: #{model} #{@selector.inspect} #{@options.inspect}>"
+  end
+  alias_method :to_s, :inspect
+
+  def == o
+    self.class == o.class and ([model, selector, options] == [o.model, o.selector, o.options])
+  end
+
+  def build attributes = {}, options = {}
+    model.build selector.merge(attributes), options
+  end
+
+  def create attributes = {}, options = {}
+    model.create selector.merge(attributes), options
+  end
+
+  def create! attributes = {}, options = {}
+    model.create! selector.merge(attributes), options
+  end
+
+  protected
+    def method_missing method, *args, &block
+      model.with_scope selector, options do
+        result = model.send method, *args, &block
+        result = self.merge result if result.is_a? self.class
+        result
+      end
+    end
+end