mongodb 0.0.1 → 0.0.2

data/lib/mongodb/model.rb

@@ -0,0 +1,26 @@
+require 'mongodb/object'
+require 'ruby_ext'
+require 'i18n'
+
+module Mongo::Model; end
+
+%w(
+  support/types
+
+  db
+  assignment
+  callbacks
+  validation
+  crud
+  query
+  scope
+  attribute_convertors
+  misc
+  model
+).each{|f| require "mongodb/model/#{f}"}
+
+module Mongo
+  module Model
+    inherit Db, Assignment, Callbacks, Validation, Crud, Query, Scope, AttributeConvertors, Misc
+  end
+end

data/lib/mongodb/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/mongodb/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/mongodb/model/callbacks.rb

@@ -0,0 +1,36 @@
+module Mongo::Model::Callbacks
+  inherit RubyExt::Callbacks
+
+  def _run_callbacks type, method_name
+    if type == :before
+      run_before_callbacks method_name, method: method_name
+    elsif type == :after
+      run_after_callbacks method_name, method: method_name
+    else
+      raise "invalid callback type (#{type})!"
+    end
+  end
+
+  module ClassMethods
+    [:validate, :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/mongodb/model/crud.rb

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

data/lib/mongodb/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/mongodb/model/misc.rb

@@ -0,0 +1,33 @@
+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
+
+
+  module ClassMethods
+    def timestamps!
+      attr_accessor :created_at, :updated_at
+      before_save :update_timestamps
+    end
+  end
+end

data/lib/mongodb/model/model.rb

@@ -0,0 +1,11 @@
+module Mongo::Model
+  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/mongodb/model/query.rb

@@ -0,0 +1,36 @@
+module Mongo::Model::Query
+  module ClassMethods
+    include Mongo::DynamicFinders
+
+    def count selector = {}, opts = {}
+      collection.count selector, opts
+    end
+
+    def first selector = {}, opts = {}
+      collection.first selector, opts
+    end
+
+    def each selector = {}, opts = {}, &block
+      collection.each selector, opts, &block
+    end
+
+    def all selector = {}, opts = {}, &block
+      if block
+        each selector, opts, &block
+      else
+        list = []
+        each(selector, opts){|doc| list << doc}
+        list
+      end
+    end
+
+    def first! selector = {}, opts = {}
+      first(selector, opts) || raise(Mongo::NotFound, "document with selector #{selector} not found!")
+    end
+
+    def exists? selector = {}, opts = {}
+      count(selector, opts) > 0
+    end
+    alias :exist? :exists?
+  end
+end

data/lib/mongodb/model/scope.rb

@@ -0,0 +1,99 @@
+module Mongo::Model::Scope
+  class ScopeProxy < BasicObject
+    def initialize model, scope
+      @model, @scope = model, scope
+    end
+
+    def class
+      ::Mongo::Model::Scope::ScopeProxy
+    end
+
+    def reverse_merge! scope
+      @scope = scope.merge @scope
+    end
+
+    def inspect
+      "#<ScopeProxy:{#{scope.inspect}}>"
+    end
+    alias_method :to_s, :inspect
+
+    protected
+      attr_reader :model, :scope
+
+      def method_missing method, *args, &block
+        model.with_scope scope do
+          result = model.send method, *args, &block
+          result.reverse_merge! scope if result.class == ::Mongo::Model::Scope::ScopeProxy
+          result
+        end
+      end
+  end
+
+  module ClassMethods
+    def current_scope
+      scope, exclusive = Thread.current[:mongo_model_scope]
+      if exclusive
+        scope
+      elsif scope
+        default_scope.merge scope
+      else
+        default_scope
+      end
+    end
+
+    def with_exclusive_scope options = {}, &block
+      with_scope options, true, &block
+    end
+
+    def with_scope options = {}, exclusive = false, &block
+      previous_options, previous_exclusive = Thread.current[:mongo_model_scope]
+      raise "exclusive scope already applied!" if previous_exclusive
+
+      begin
+        options = previous_options.merge options if previous_options and !exclusive
+        Thread.current[:mongo_model_scope] = [options, exclusive]
+        return block.call
+      ensure
+        Thread.current[:mongo_model_scope] = [previous_options, false]
+      end
+    end
+
+    inheritable_accessor :_default_scope, -> {{}}
+    def default_scope *args, &block
+      if block
+        self._default_scope = block
+      elsif !args.empty?
+        args.size.must == 1
+        args.first.must_be.a Hash
+        scope = args.first
+        self._default_scope = -> {args.first}
+      else
+        _default_scope.call
+      end
+    end
+
+    def scope name, options = nil, &block
+      model = self
+      metaclass.define_method name do
+        scope = (block && block.call) || options
+        ScopeProxy.new model, scope
+      end
+    end
+
+
+    #
+    # finders
+    #
+    def count selector = {}, opts = {}
+      super current_scope.merge(selector), opts
+    end
+
+    def first selector = {}, opts = {}
+      super current_scope.merge(selector), opts
+    end
+
+    def each selector = {}, opts = {}, &block
+      super current_scope.merge(selector), opts, &block
+    end
+  end
+end