toughguy 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fd8b128c7302c3b25ec0274ce6fea18599e8acd2
+  data.tar.gz: bb2a8e05fee133b6dd322c5fd9cdc3140857a7ed
+SHA512:
+  metadata.gz: a578bbc736a87c373b440fd32750d03791e5fcad33b69f6331602d3a4cb1ac9c31473bea8f2d22dfdf7812a71dd4a29b7a280a531e52c138684ef4d9f8a6bf2d
+  data.tar.gz: cb5f2f74d06f4c4a157cee9aba307b2f6516855611f4541e0e95a1836bb210486bc73e4e7504cb9f0977497900781deb3d91cf391be2206d34e42347a08b77d8

data/.gitignore

@@ -0,0 +1,34 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+gemspec
+
+gem "mongo", "1.11.1"
+gem "bson_ext", "1.11.1"
+gem "plucky", "0.6.6"
+gem "assistance", "0.1.5"
+gem "rake"
+
+group(:test) do
+  gem 'rspec'
+end

data/Gemfile.lock

@@ -0,0 +1,46 @@
+PATH
+  remote: .
+  specs:
+    toughguy (0.1.0)
+      assistance (= 0.1.5)
+      bson_ext (= 1.11.1)
+      mongo (= 1.11.1)
+      plucky (= 0.6.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    assistance (0.1.5)
+    bson (1.11.1)
+    bson_ext (1.11.1)
+      bson (~> 1.11.1)
+    diff-lcs (1.2.5)
+    mongo (1.11.1)
+      bson (= 1.11.1)
+    plucky (0.6.6)
+      mongo (~> 1.5)
+    rake (10.4.2)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  assistance (= 0.1.5)
+  bson_ext (= 1.11.1)
+  mongo (= 1.11.1)
+  plucky (= 0.6.6)
+  rake
+  rspec
+  toughguy!

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Sharon Rosner
+
+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/Rakefile

@@ -0,0 +1,4 @@
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :default => :spec

data/lib/toughguy.rb

@@ -0,0 +1,12 @@
+require 'mongo'
+require 'plucky'
+require 'assistance'
+
+require 'toughguy/ext'
+require 'toughguy/model'
+require 'toughguy/query'
+require 'toughguy/singleton_model'
+require 'toughguy/mapped_query'
+require 'toughguy/mapped_model'
+
+

data/lib/toughguy/ext.rb

@@ -0,0 +1,75 @@
+class Plucky::Normalizers::CriteriaHashValue
+  # add support for specifying ranges
+  def call(parent_key, key, value)
+    case value
+      when Array, Set
+        if object_id?(parent_key)
+          value = value.map { |v| to_object_id(v) }
+        end
+
+        if nesting_operator?(key)
+          value.map  { |v| criteria_hash_class.new(v, options).to_hash }
+        elsif parent_key == key && !modifier?(key) && !value.empty?
+          # we're not nested and not the value for a symbol operator
+          {:$in => value.to_a}
+        else
+          # we are a value for a symbol operator or nested hash
+          value.to_a
+        end
+      when Time
+        value.utc
+      when String
+        if object_id?(key)
+          return to_object_id(value)
+        end
+        value
+      when Range
+        v1 = value.begin; v2 = value.end
+        if (parent_key == :_id) && v1.is_a?(Time) && v2.is_a?(Time)
+          v1 = BSON::ObjectId.from_time(v1)
+          v2 = BSON::ObjectId.from_time(v2)
+        end
+        {'$gte' => v1, (value.exclude_end? ? '$lt' : '$lte') => v2}
+      when Hash
+        value.each { |k, v| value[k] = call(key, k, v) }
+        value
+      when Regexp
+        Regexp.new(value)
+      else
+        value
+    end
+  end
+end
+
+class Symbol
+  # return descending order hash
+  def desc
+    [self, -1]
+  end
+end
+
+class Mongo::DB
+  def stats
+    command({dbstats: 1}).symbolize_keys_with_underscore
+  end
+end
+
+# Required for regexp to work in plucky 0.3.2. I don't really see the point in
+# this. See: plucky-0.3.2/lib/plucky/criteria_hash.rb:16
+class Regexp
+  def duplicable?
+    false
+  end
+end
+
+# Hash extensions
+class Hash
+  def symbolize_keys
+    inject({}) {|m, kv| v = kv[1]; m[kv[0].to_sym] = v.is_a?(Hash) ? v.symbolize_keys : v; m}
+  end
+  
+  def symbolize_keys_with_underscore
+    inject({}) {|m, kv| v = kv[1]; m[kv[0].underscore.to_sym] = v.is_a?(Hash) ? v.symbolize_keys : v; m}
+  end
+end
+

data/lib/toughguy/mapped_model.rb

@@ -0,0 +1,119 @@
+require 'toughguy/mapped_query'
+
+module ToughGuy
+  class MappedModel < Model
+    def delete
+      model.delete(_id: id)
+      model.remove_map_ref(self)
+    end
+  
+    def set(hash)
+      collection.update({_id: id}, '$set' => hash)
+      @values.merge!(hash)
+    end
+  
+    def exists?
+      model.q.filter(_id: id).count == 1
+    end
+  
+    class << self
+      def map_key
+        @map_key
+      end
+    
+      def set_map_key(k)
+        @map = {}
+        @map_key = k
+      end
+    
+      def inherited(m)
+        super
+        # the map key is inherited, the map itself is not.
+        m.set_map_key(@map_key)
+      end
+    
+      def map
+        @map
+      end
+    
+      def instances
+        @map.values
+      end
+    
+      def enumerate
+        @map.each
+      end
+    
+      def load_map(opts = {})
+        query({}).sort(@map_key).each {}
+      end
+    
+      def load_map_async(&block)
+        @async_start = Time.now
+        EM.next_tick {load_next_map_chunk(1, &block)}
+      end
+    
+      def load_next_map_chunk(page, &block)
+        query.paginate(page: page, per_page: 100).each {}.tap do |q|
+          if page < q.total_pages
+            EM.timeout(0.1) {load_next_map_chunk(page + 1, &block)}
+          else
+            block.call if block
+          end
+        end
+      end
+    
+      def all(load=false)
+        load_map if load
+        @map.values
+      end
+    
+      def reset_map
+        @map = {}
+      end
+    
+      def remove_map_ref(o)
+        @map.delete(o[@map_key])
+      end
+    
+      def set_map_ref(o)
+        if @map[o[@map_key]]
+          raise "Map reference already set for #{self}[#{o[@map_key].inspect}]"
+        end
+        @map[o[@map_key]] = o
+      end
+    
+      def [](k)
+        @map[k] || first(@map_key => k)
+      end
+    
+      alias_method :find, :[]
+
+      def delete_all
+        super
+        reset_map
+      end
+
+      def destroy_all
+        instances.each {|o| o.destroy}
+        reset_map
+      end
+
+      def load(values)
+        new(values).tap {|o| o.after_load; set_map_ref(o)}
+      end
+
+      def create(values = {})
+        super.tap {|o| set_map_ref(o)}
+      end
+
+      def query(opts = {})
+        MappedQuery.new(self).where(opts)
+      end
+    
+      alias_method :q, :query
+      alias_method :where, :query
+      alias_method :filter, :query
+    end
+  end
+end

data/lib/toughguy/mapped_query.rb

@@ -0,0 +1,40 @@
+module ToughGuy
+  class MappedQuery < Query
+    def initialize(klass, opts = {})
+      super(klass, opts)
+      @map = klass.map
+      @map_key = klass.map_key
+      @map_key_s = @map_key.to_s
+    end
+  
+    def all(opts={})
+      a = []
+      each {|o| a << o}
+      a
+    end
+  
+    alias_method :to_a, :all
+
+    def each(opts={}, &block)
+      find_each(opts).each do |d|
+        if o = @map[d[@map_key_s]]
+          block.call(o)
+        else
+          block.call(@klass.load(d))
+        end
+      end
+      self
+    end
+  
+    def find_one(opts={})
+      if (d = orig_find_one(opts))
+        @map[d[@map_key_s]] || @klass.load(d)
+      else
+        nil
+      end
+    end
+  
+    # override method aliasing in Plucky::Query
+    alias_method :first,  :find_one
+  end
+end

data/lib/toughguy/model.rb

@@ -0,0 +1,339 @@
+module ToughGuy
+  class Model
+    attr_accessor :values, :collection
+
+    def initialize(values = {}, collection = nil)
+      @values = values.symbolize_keys
+      @collection = collection
+    end
+
+    def after_load
+    end
+
+    def method_missing(m, *args)
+      if m.to_s =~ /^(.+)=$/
+        @values[$1.to_sym] = args[0]
+      else
+        @values[m]
+      end
+    end
+
+    def collection
+      @collection ||= model.collection
+    end
+
+    def database
+      @database ||= collection.db
+    end
+
+    alias_method :db, :database
+
+    def model
+      self.class
+    end
+
+    def [](k)
+      @values[k]
+    end
+
+    def []=(k, v)
+      @values[k] = v
+    end
+
+    def id
+      @values[:_id]
+    end
+
+    def new?
+      !@values[:_id]
+    end
+
+    def before_create
+    end
+
+    def after_create
+    end
+
+    def save
+      if new?
+        before_create
+        values[:_id] = collection.insert(values)
+        after_create
+      else
+        collection.update({_id: id}, values.exclude(:_id))
+      end
+    end
+
+    def update(hash)
+      collection.update({_id: id}, hash)
+    end
+
+    def set(hash)
+      update('$set' => hash)
+      @values.merge!(hash.symbolize_keys)
+    end
+
+    def refresh
+      @values = collection.find(_id: id).first.symbolize_keys
+      self
+    end
+
+    def delete
+      model.delete(_id: id)
+    end
+
+    def before_destroy
+    end
+
+    def after_destroy
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    def destroy
+      before_destroy
+      @destroyed = true
+      delete
+      after_destroy
+    end
+
+    def to_s
+      "#<#{model.name}:#{id || 'unsaved'}>"
+    end
+
+    def inspect
+      v = values.exclude(:_id).map {|k, v| "#{k}: #{v.inspect}"}.join(', ')
+      "#<#{model.name}:#{id || 'unsaved'} #{v}>"
+    end
+
+    def ==(obj)
+      (obj.class == model) && (obj.values == @values)
+    end
+
+    def exists?
+      model.find(id) != nil
+    end
+
+    class << self
+      def add_index(spec, opts={})
+        @indexes ||= []
+        @indexes << [spec, opts]
+      end
+  
+      def ensure_index(spec, opts={})
+        add_index(spec, opts)
+        collection.create_index(spec, opts)
+      end
+  
+      def recreate_indexes
+        if @indexes
+          @indexes.each {|idx| ensure_index(*idx)}
+        end
+      end
+  
+      def load(values)
+        new(values).tap {|o| o.after_load}
+      end
+
+      def create(values = {})
+        o = new(values)
+        o.save
+        o
+      end
+
+      def [](opts)
+        unless opts.is_a?(Hash)
+          opts = {_id: opts}
+        end
+        first(opts)
+      end
+  
+      alias_method :find, :[]
+
+      def query(opts = {})
+        ToughGuy::Query.new(self).where(opts)
+      end
+  
+      alias_method :q, :query
+      alias_method :where, :query
+      alias_method :filter, :query
+  
+      def sort(*args)
+        query.sort(*args)
+      end
+  
+      def limit(l, skip = 0)
+        query.limit(l).skip(0)
+      end
+  
+      def paginate(opts)
+        query.paginate(opts)
+      end
+
+      def count(opts = {})
+        query(opts).count
+      end
+
+      def all(opts = {})
+        query(opts).to_a
+      end
+  
+      def each(*args, &block)
+        query.each(*args, &block)
+      end
+  
+      def map(key = nil, &block)
+        query.map(key, &block)
+      end
+  
+      def sort(*args)
+        query.sort(*args)
+      end
+
+      def first(opts = {})
+        query(opts).first
+      end
+  
+      def map_keys(hash)
+        hash.each do |key, short_key|
+          define_method(key) {@values[short_key]}
+          define_method(:"#{key}=") {|v| @values[short_key] = v}
+        end
+      end
+
+      def collection
+        @collection ||= database[collection_name]
+      end
+  
+      def set_collection(c)
+        @collection = c
+      end
+  
+      def to_table_name
+        parts = name.downcase.split('::')
+        parts.push(parts.pop.pluralize)
+        parts.join('.')
+      end
+  
+      def collection_name
+        @collection_name ||= to_table_name
+      end
+
+      def set_collection_name(n)
+        @collection_name = n
+      end
+  
+      def delete_all
+        collection.remove
+      end
+  
+      def delete(selector)
+        q(selector).remove
+      end
+  
+      def destroy_all
+        q.each {|d| d.destroy}
+      end
+
+      def drop
+        collection.drop
+      end
+  
+      def update(*args)
+        collection.update(*args)
+      end
+  
+      def stats
+        collection.stats
+      end
+
+      @database = nil
+
+      def database
+        @database
+      end
+
+      alias_method :db, :database
+  
+      @@db_map = {}
+  
+      def database=(db)
+        if db.is_a?(String)
+          db = (@@db_map[db] = connection[db])
+        end
+        @database = db
+        # update also for mapped model
+        if self == ToughGuy::Model
+          ToughGuy::MappedModel.database = db
+          ToughGuy::SingletonModel.database = db
+        end
+      end
+  
+      def db_key(db)
+        db.is_a?(String) ? db : db.name
+      end
+  
+      def db_class_name(db_key)
+        name = (db_key =~ /_(.+)/) && $1.gsub(/[^a-z0-9]/, '').capitalize
+        "P_#{name}"
+      end
+  
+      def subclass_with_db(db, db_key)
+        c = Class.new(self).tap do |klass|
+          klass.database = db
+          klass.set_collection_name(collection_name)
+          if @indexes
+            @indexes.each {|idx| klass.ensure_index(*idx)}
+          end
+        end
+        
+        # create proper class name
+        class_name = db_class_name(db_key)
+        if class_name
+          # remove class const before defining it in order to prevent warning
+          send(:remove_const, class_name) if const_defined?(class_name, false)
+          const_set(class_name, c)
+        end
+    
+        c
+      end
+  
+      def with_db(db)
+        key = db_key(db)
+        return self if key == db_key(self.db)
+        @subclass_map ||= {}
+        @subclass_map[key] ||= subclass_with_db(db, key)
+      end
+
+      def remove_class_with_db(db)
+        @subclass_map ||= {}
+        key = db_key(db)
+        class_name = db_class_name(key)
+        c = @subclass_map.delete(key)
+        if class_name
+          send(:remove_const, class_name) if const_defined?(class_name, false)
+        end
+      end
+  
+      def inherited(subclass)
+        subclass.database = database
+      end
+  
+      def mapped_db_classes
+        (@subclass_map || {}).values.unshift(self)
+      end
+
+      @@connection = nil
+
+      def connection
+        @@connection
+      end
+
+      def connection=(c)
+        @@connection = c
+      end
+    end
+  end
+end

data/lib/toughguy/query.rb

@@ -0,0 +1,196 @@
+module ToughGuy
+  class Query < Plucky::Query
+    attr_accessor :klass
+  
+    def initialize(klass, opts = {})
+      super(klass.collection, opts)
+      @klass = klass
+    end
+  
+    # Allow self-changing methods: where!, sort! etc.
+    def method_missing(m, *args)
+      if m.to_s =~ /^(.+)!$/
+        send($1.to_sym, *args).tap {|q| @criteria, @options = q.criteria, q.options}
+        self
+      else
+        super(m, *args)
+      end
+    end
+  
+    def explain(opts={})
+      find_each(opts).explain
+    end
+  
+    alias_method :filter, :where
+
+    alias_method :orig_all, :all
+  
+    def all(opts={})
+      if @klass
+        orig_all(opts).map {|d| @klass.load(d)}
+      else
+        orig_all(opts)
+      end
+    end
+  
+    alias_method :to_a, :all
+
+    def each(opts={}, &block)
+      if @klass
+        find_each(opts).each {|d| block[@klass.load(d)]}
+      else
+        find_each(opts).each(&block)
+      end
+      self
+    end
+  
+    alias_method :orig_find_one, :find_one
+  
+    def find_one(opts={})
+      (doc = orig_find_one(opts)) ? (@klass ? @klass.load(doc) : doc) : nil
+    end
+
+    # override method aliasing in Plucky::Query
+    alias_method :first,  :find_one
+  
+    # Extend map to accept key argument, allowing stuff like:
+    #   map(:path) # equivalent to map {|d| d[:path]}
+    def map(key = nil, &block)
+      m = []
+      key ? each {|d| m << d[key]} : each {|d| m << block[d]}
+      m
+    end
+  
+    # Return an array of object ids.
+    def map_id
+      map(:_id)
+    end
+  
+    def group(key, initial, reduce, finalize = nil)
+      key = [key] unless key.is_a?(Array)
+      collection.group(key.map {|k| k.to_s}, criteria.to_hash,
+        initial, reduce, finalize)
+    end
+  
+    def group_and_count(key)
+      group(key, {'sum' => 0}, "function(doc, prev) { prev.sum += 1}")
+    end
+  
+    def group_and_avg(group, key)
+      group(group, {'count' => 0, 'sum' => 0},
+        "function(doc, out) {out.count++; out.sum += doc.#{key}}",
+        "function(out){ if (out.count > 0) out.avg = out.sum / out.count }"
+      ).map {|g| g.symbolize_keys}.sort_by {|g| -g[:avg]}
+    end
+  
+    def min(key)
+      d = sort(key).first
+      d ? d[key] : nil
+    end
+  
+    def max(key)
+      d = sort(key.desc).first
+      d ? d[key] : nil
+    end
+  
+    def avg(key)
+      values = raw.select(key).map(key.to_s)
+      values.inject(0) {|m, i| m += i} / values.size.to_f
+    end
+  
+    def insert_rate(opts={})
+      opts[:limit] ||= 100
+      opts[:key] ||= :_id
+      docs = raw.limit(opts[:limit]).sort(:_id.desc).select(opts[:key]).all
+      if docs.empty?
+        nil
+      else
+        t1, t2 = docs.first[opts[:key].to_s], docs.last[opts[:key].to_s]
+        if opts[:key] == :_id
+          t1, t2 = t1.generation_time, t2.generation_time
+        end
+        docs.size.to_f / (t1 - t2)
+      end
+    end
+  
+    alias_method :orig_sort, :sort
+  
+    # Extend the sort API to allow stuff like:
+    #   sort(:kind, :stamp)
+    #   sort(:kind, :stamp.desc) # see Symbol#desc below
+    def sort(*args)
+      if args.all? {|a| a.is_a?(Symbol) || a.is_a?(Array)}
+        orig_sort(args.map {|a| a.is_a?(Symbol) ? [a, 1] : a})
+      else
+        orig_sort(*args)
+      end
+    end
+  
+    # Add select method to select the fields to return
+    def select(fields)
+      if (fields == []) || (fields.nil?)
+        fields = [:_id]
+      end
+      clone.tap {|q| q.options[:fields] = fields}
+    end
+  
+    # Returns a query that does not converted docs to model instances
+    def raw
+      @klass ? clone.tap {|q| q.klass = nil} : self
+    end
+  
+    def update_values(doc, opts={})
+      collection.update(criteria.to_hash, doc, opts)
+    end
+
+    def paginate(opts)
+      per_page = opts[:per_page] || 50
+      page = opts[:page] || 1
+    
+      paginated = limit(per_page).skip((page - 1) * per_page)
+      paginated.set_pagination_info(page, per_page, count)
+      paginated
+    end
+
+    # Sets the pagination info
+    def set_pagination_info(page_no, page_size, record_count)
+      @current_page = page_no
+      @per_page = page_size
+      @total_count = record_count
+      @total_pages = (record_count / page_size.to_f).ceil
+    
+      extend PaginationMethods
+
+      self
+    end
+
+    module PaginationMethods
+      attr_accessor :per_page, :total_pages, :current_page, :total_count
+
+      # Returns the previous page number or nil if the current page is the first
+      def prev_page
+        @current_page > 1 ? (@current_page - 1) : nil
+      end
+
+      # Returns the next page number or nil if the current page is the last page
+      def next_page
+        @current_page < @total_pages ? (@current_page + 1) : nil
+      end
+  
+      # Returns the page range
+      def page_range
+        1..@total_pages
+      end
+  
+      # Returns the record range for the current page
+      def current_page_record_range
+        return (0..0) if @current_page > @total_pages
+    
+        a = 1 + (@current_page - 1) * @per_page
+        b = a + @per_page - 1
+        b = @total_count if b > @total_count
+        a..b
+      end
+    end
+  end
+end

data/lib/toughguy/singleton_model.rb

@@ -0,0 +1,31 @@
+module ToughGuy
+  class SingletonModel < Model
+    def self.instance
+      @instance ||= (first || create)
+    end
+
+    def self.resident_instance
+      @instance
+    end
+
+    def self.all_resident_instances
+      list = @subclass_map ?
+        @subclass_map.values.map {|c| c.resident_instance}.compact : []
+      @instance ? (list << resident_instance) : list
+    end
+
+    def self.reset
+      @instance = nil
+    end
+
+    def self.delete_all
+      super
+      reset
+    end
+
+    def delete
+      super
+      model.reset
+    end
+  end
+end

data/lib/toughguy/version.rb

@@ -0,0 +1,4 @@
+# encoding: UTF-8
+module ToughGuy
+  Version = '0.1.0'
+end

data/spec/helper.rb

@@ -0,0 +1,33 @@
+$:.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'rubygems'
+require 'bundler'
+
+Bundler.require(:default, :test)
+
+require 'toughguy'
+
+port = ENV.fetch "BOXEN_MONGODB_PORT", 27017
+connection = Mongo::MongoClient.new('127.0.0.1', port.to_i)
+ToughGuy::Model.connection = connection
+ToughGuy::Model.database = DB = connection.db('test')
+
+RSpec.configure do |config|
+  config.filter_run :focused => true
+  config.alias_example_to :fit, :focused => true
+  config.alias_example_to :xit, :pending => true
+  config.run_all_when_everything_filtered = true
+
+  config.before(:suite) do
+    DB.collections.reject { |collection|
+      collection.name =~ /system\./
+    }.map(&:drop_indexes)
+  end
+
+  config.before(:each) do
+    DB.collections.reject { |collection|
+      collection.name =~ /system\./
+    }.map(&:remove)
+  end
+end
+

data/spec/toughguy_spec.rb

@@ -0,0 +1,193 @@
+require 'helper'
+
+class Mau < ToughGuy::Model
+  ensure_index([['blah', Mongo::ASCENDING]])
+end
+
+describe "Model#update" do
+  before do
+    Mau.drop
+  end
+  
+  it "should replace the old values with the given values" do
+    m = Mau.create(a: 1, b: 2)
+    id = m.id
+    m.update(c: 3, d: 4)
+    m.refresh
+    m.values.should == {c: 3, d: 4, _id: id}
+  end
+end
+
+describe "Model#set" do
+  before do
+    Mau.drop
+  end
+  
+  it "should merge the given values" do
+    m = Mau.create(a: 1, b: 2)
+    id = m.id
+    m.set(c: 3, d: 4)
+    m.refresh
+    m.values.should == {a: 1, b: 2, c: 3, d: 4, _id: id}
+  end
+
+  it "should replace nested hashes" do
+    m = Mau.create(a: 1, b: {c: 3})
+    id = m.id
+    m.set(b: {d: 4})
+    m.refresh
+    m.values.should == {a: 1, b: {d: 4}, _id: id}
+  end
+end
+
+describe "Model#collection" do
+  it "should default to Model.collection" do
+    m1 = Mau.new(a: 1)
+    m2 = Mau.new(b: 2)
+    m1.collection.should == m2.collection
+    m1.collection.should == Mau.collection
+  end
+  
+  it "should be configurable per instance" do
+    c1 = DB['maus']
+    c2 = DB['maus']
+    c1.should_not == c2
+    m1 = Mau.new({a: 1}, c1)
+    m2 = Mau.new({b: 2}, c2)
+    m1.collection.should_not == m2.collection
+    m1.collection.should == c1
+    m2.collection.should == c2
+  end
+end
+
+describe "Model.with_db" do
+  before do
+    @db2 = ToughGuy::Model.connection['dbxxx']
+    @mau2 = Mau.with_db(@db2)
+  end
+  
+  it "should create a descendant class" do
+    @mau2.class.should == Class
+    @mau2.superclass.should == Mau
+  end
+  
+  it "should change the associated database to the specifed one" do
+    Mau.database.name.should == 'test'
+    Mau.database.should_not == @db2
+    @mau2.database.name.should == 'dbxxx'
+  end
+end
+
+class Single < ToughGuy::SingletonModel
+  set_collection_name :single
+  
+  def self.reset
+    @instance = nil
+    collection.drop
+  end
+end
+
+describe "A singleton model" do
+  before do
+    Single.reset
+  end
+  
+  it "should provide a single instance from the first doc in the collection" do
+    Single.collection.insert(a: 1, b: 2)
+    s1 = Single.instance
+    s1.a.should == 1
+    s1.b.should == 2
+    s2 = Single.instance
+    s2.object_id.should == s1.object_id
+  end
+  
+  it "should create an instance automatically if the collection is empty" do
+    s1 = Single.instance
+    Single.collection.count.should == 1
+    s2 = Single.instance
+    Single.collection.count.should == 1
+    s2.object_id.should == s1.object_id
+  end
+  
+  it "should always update the same record for the instance" do
+    s1 = Single.instance
+    s1.set(a: 1)
+    Single.collection.count.should == 1
+    s1.set(b: 2)
+    Single.collection.count.should == 1
+    s2 = Single.instance
+    s2.object_id.should == s1.object_id
+    s2.a.should == 1
+    s2.b.should == 2
+  end
+  
+  it "should provide all resident instances" do
+    s1 = Single.with_db('s1')
+    s2 = Single.with_db('s2')
+    s1.instance
+    
+    Single.all_resident_instances.should == [s1.instance]
+    s2.instance
+    Single.all_resident_instances.size.should == 2
+    Single.all_resident_instances.should include(s1.instance)
+    Single.all_resident_instances.should include(s2.instance)
+    
+    Single.instance
+    Single.all_resident_instances.size.should == 3
+    Single.all_resident_instances.should include(s1.instance)
+    Single.all_resident_instances.should include(s2.instance)
+    Single.all_resident_instances.should include(Single.instance)
+  end
+end
+
+class Separate < ToughGuy::Model
+  set_collection_name :separate
+end
+
+describe "Model.with_db" do
+  before do
+    @c = ToughGuy::Model.connection
+  end
+  
+  it "should provide a subclass of the model associated with a separate db" do
+    s1 = Separate.with_db('s1')
+    s2 = Separate.with_db('s2')
+    s1.superclass.should == Separate
+    s2.superclass.should == Separate
+    s1.db.name.should == 's1'
+    s2.db.name.should == 's2'
+    s1.drop
+    d1 = s1.create(a: 1)
+    s2.drop
+    d2 = s2.create(b: 2)
+    s1.count.should == 1
+    s2.count.should == 1
+    
+    @c['s1']['separate'].count.should == 1
+    @c['s2']['separate'].count.should == 1
+    
+    @c['s1']['separate'].find.to_a.first["a"].should == 1
+    @c['s2']['separate'].find.to_a.first["b"].should == 2
+    
+    d2.destroy
+    
+    s1.count.should == 1
+    s2.count.should == 0
+    @c['s1']['separate'].count.should == 1
+    @c['s2']['separate'].count.should == 0
+    
+    d1.destroy
+    s1.count.should == 0
+    @c['s1']['separate'].count.should == 0
+  end
+  
+  it "should cache subclasses for subsequent calls" do
+    s1 = Separate.with_db('s1')
+    s2 = Separate.with_db('s2')
+    s3 = Separate.with_db('s1')
+    s4 = Separate.with_db('s2')
+    
+    s1.object_id.should ==  s3.object_id
+    s2.object_id.should ==  s4.object_id
+  end
+end

data/toughguy.gemspec

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+require File.expand_path('../lib/toughguy/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name         = 'toughguy'
+  s.homepage     = 'http://github.com/ciconia/toughguy'
+  s.summary      = 'Simple MongoDB ORM'
+  s.require_path = 'lib'
+  s.authors      = ['Sharon Rosner']
+  s.email        = ['ciconia@gmail.com']
+  s.version      = ToughGuy::Version
+  s.platform     = Gem::Platform::RUBY
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'mongo', '1.11.1'
+  s.add_dependency 'bson_ext', '1.11.1'
+  s.add_dependency 'plucky', '0.6.6'
+  s.add_dependency 'assistance', '0.1.5'
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: toughguy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sharon Rosner
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.11.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.11.1
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.11.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.11.1
+- !ruby/object:Gem::Dependency
+  name: plucky
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.6
+- !ruby/object:Gem::Dependency
+  name: assistance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+description: 
+email:
+- ciconia@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/toughguy.rb
+- lib/toughguy/ext.rb
+- lib/toughguy/mapped_model.rb
+- lib/toughguy/mapped_query.rb
+- lib/toughguy/model.rb
+- lib/toughguy/query.rb
+- lib/toughguy/singleton_model.rb
+- lib/toughguy/version.rb
+- spec/helper.rb
+- spec/toughguy_spec.rb
+- toughguy.gemspec
+homepage: http://github.com/ciconia/toughguy
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.2
+signing_key: 
+specification_version: 4
+summary: Simple MongoDB ORM
+test_files:
+- spec/helper.rb
+- spec/toughguy_spec.rb