mongodb 0.0.2 → 0.0.3

data/lib/mongodb/model/attribute_convertors.rb

@@ -1,54 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

data/lib/mongodb/model/spec.rb

@@ -1,12 +0,0 @@
-require 'mongodb/driver/spec'
-
-rspec do
-  class << self
-    def with_mongo_model
-      with_mongo
-
-      before{Mongo::Model.db = mongo.db}
-      after{Mongo::Model.db = nil}
-    end
-  end
-end

data/lib/mongodb/model/support/types.rb

@@ -1,110 +0,0 @@
-#
-# Boolean
-#
-module Mongo::Model::BooleanType
-  Mapping = {
-    true    => true,
-    'true'  => true,
-    'TRUE'  => true,
-    'True'  => true,
-    't'     => true,
-    'T'     => true,
-    '1'     => true,
-    1       => true,
-    1.0     => true,
-    false   => false,
-    'false' => false,
-    'FALSE' => false,
-    'False' => false,
-    'f'     => false,
-    'F'     => false,
-    '0'     => false,
-    0       => false,
-    0.0     => false,
-    nil     => nil
-  }
-
-  def cast value
-    if value.is_a? Boolean
-      value
-    else
-      Mapping[value] || false
-    end
-  end
-end
-
-class Boolean; end unless defined?(Boolean)
-
-Boolean.extend Mongo::Model::BooleanType
-
-
-#
-# Date
-#
-require 'date'
-Date.class_eval do
-  def self.cast value
-    if value.nil? || value == ''
-      nil
-    else
-      date = value.is_a?(::Date) || value.is_a?(::Time) ? value : ::Date.parse(value.to_s)
-      date.to_date
-    end
-  rescue
-    nil
-  end
-end
-
-
-#
-# Float
-#
-Float.class_eval do
-  def self.cast value
-    value.nil? ? nil : value.to_f
-  end
-end
-
-
-#
-# Integer
-#
-Integer.class_eval do
-  def self.cast value
-    value_to_i = value.to_i
-    if value_to_i == 0 && value != value_to_i
-      value.to_s =~ /^(0x|0b)?0+/ ? 0 : nil
-    else
-      value_to_i
-    end
-  end
-end
-
-
-#
-# String
-#
-String.class_eval do
-  def self.cast value
-    value.nil? ? nil : value.to_s
-  end
-end
-
-
-#
-# Time
-#
-Time.class_eval do
-  def self.cast value
-    if value.nil? || value == ''
-      nil
-    else
-      # time_class = ::Time.try(:zone).present? ? ::Time.zone : ::Time
-      # time = value.is_a?(::Time) ? value : time_class.parse(value.to_s)
-      # strip milliseconds as Ruby does micro and bson does milli and rounding rounded wrong
-      # at(time.to_i).utc if time
-
-      value.is_a?(::Time) ? value : Date.parse(value.to_s).to_time
-    end
-  end
-end