minidoc 0.0.1

data/lib/minidoc.rb

@@ -0,0 +1,244 @@
+require "mongo"
+require "virtus"
+require "active_model"
+require "active_support/core_ext"
+
+class Minidoc
+  VERSION = "0.0.1"
+
+  require "minidoc/associations"
+  require "minidoc/connection"
+  require "minidoc/counters"
+  require "minidoc/finders"
+  require "minidoc/grid"
+  require "minidoc/indexes"
+  require "minidoc/read_only"
+  require "minidoc/record_invalid"
+  require "minidoc/duplicate_key"
+  require "minidoc/timestamps"
+  require "minidoc/validations"
+  require "minidoc/value"
+
+  include Connection
+  include Finders
+  include Validations
+  include Virtus.model
+  extend ActiveModel::Naming
+  include ActiveModel::Conversion
+  include ActiveModel::Validations
+
+  attribute :_id, BSON::ObjectId
+  alias_attribute :id, :_id
+
+  def self.delete_all
+    collection.remove({})
+  end
+
+  def self.create(attrs = {})
+    new(attrs).tap(&:save)
+  end
+
+  def self.create!(*args)
+    new(*args).tap(&:save!)
+  end
+
+  def self.delete(id)
+    collection.remove(_id: BSON::ObjectId(id.to_s))
+  end
+
+  def self.set(id, attributes)
+    id = BSON::ObjectId(id.to_s)
+    update_one(id, "$set" => attributes)
+  end
+
+  def self.unset(id, *keys)
+    id = BSON::ObjectId(id.to_s)
+
+    unsets = {}
+    keys.each do |key|
+      unsets[key] = 1
+    end
+
+    update_one(id, "$unset" => unsets)
+  end
+
+  def self.update_one(id, updates)
+    collection.update({ "_id" => id }, updates)
+  end
+
+  def self.atomic_set(query, attributes)
+    result = collection.update(query, "$set" => attributes)
+    result["ok"] == 1 && result["n"] == 1
+  end
+
+  def self.value_class
+    @value_class ||= Class.new(self) do
+      attribute_set.each do |attr|
+        private "#{attr.name}="
+      end
+
+      private :attributes=
+    end
+  end
+
+  # For databases that support it (e.g. TokuMX), perform the block within a
+  # transaction. For information on the +isolation+ argument, see
+  # https://www.percona.com/doc/percona-tokumx/commands.html#beginTransaction
+  def self.transaction(isolation = "mvcc")
+    return yield unless tokumx?
+
+    begin
+      database.command(beginTransaction: 1, isolation: isolation)
+      yield
+    rescue Exception => error
+      database.command(rollbackTransaction: 1) rescue nil
+      raise
+    ensure
+      begin
+        database.command(commitTransaction: 1) unless error
+      rescue Exception
+        database.command(rollbackTransaction: 1)
+        raise
+      end
+    end
+  end
+
+  # Rescue a duplicate key exception in the given block. Returns the result of
+  # the block, or +false+ if the exception was raised.
+  def self.rescue_duplicate_key_errors
+    yield
+  rescue Minidoc::DuplicateKey
+    false
+  rescue Mongo::OperationFailure => ex
+    if Minidoc::DuplicateKey.duplicate_key_exception(ex)
+      false
+    else
+      raise
+    end
+  end
+
+  def self.tokumx?
+    @server_info ||= connection.server_info
+    @server_info.key?("tokumxVersion")
+  end
+
+  def initialize(attrs = {})
+    if attrs["_id"].nil? && attrs[:_id].nil?
+      attrs[:_id] = BSON::ObjectId.new
+    end
+
+    @new_record = true
+    @destroyed = false
+
+    super(attrs)
+  end
+
+  def ==(other)
+    other.is_a?(self.class) && self.id && self.id == other.id
+  end
+
+  def new_record?
+    @new_record
+  end
+
+  def destroyed?
+    @destroyed
+  end
+
+  def persisted?
+    !(new_record? || destroyed?)
+  end
+
+  def delete
+    self.class.delete(id)
+  end
+
+  def destroy
+    delete
+    @destroyed = true
+  end
+
+  def reload
+    new_object = self.class.find(self.id)
+
+    self.class.attribute_set.each do |attr|
+      self[attr.name] = new_object[attr.name]
+    end
+
+    self
+  end
+
+  def save
+    valid? ? create_or_update : false
+  end
+
+  def save!
+    valid? ? create_or_update : raise(RecordInvalid.new(self))
+  end
+
+  def set(attributes)
+    self.class.set(id, attributes)
+
+    attributes.each do |name, value|
+      self[name] = value
+    end
+  end
+
+  def unset(*keys)
+    self.class.unset(id, *keys)
+
+    keys.each do |key|
+      self[key] = nil
+    end
+  end
+
+  def atomic_set(query, attributes)
+    query[:_id] = id
+
+    if self.class.atomic_set(query, attributes)
+      attributes.each do |name, value|
+        self[name] = value
+      end
+
+      true
+    end
+  end
+
+  def as_value
+    self.class.value_class.new(attributes)
+  end
+
+  def to_key
+    [id.to_s]
+  end
+
+  def to_param
+    id.to_s
+  end
+
+private
+
+  def create_or_update
+    new_record? ? create : update
+    @new_record = false
+    true
+  rescue Mongo::OperationFailure => exception
+    if (duplicate_key_exception = Minidoc::DuplicateKey.duplicate_key_exception(exception))
+      raise duplicate_key_exception
+    else
+      raise
+    end
+  end
+
+  def create
+    self.class.collection << attributes
+  end
+
+  def update
+    self.class.collection.update({ _id: id }, attributes)
+  end
+
+  if ActiveSupport.respond_to?(:run_load_hooks)
+    ActiveSupport.run_load_hooks(:mongo)
+  end
+end

data/minidoc.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+Gem::Specification.new do |spec|
+  spec.name          = "minidoc"
+  spec.version       = "0.0.1"
+  spec.authors       = ["Bryan Helmkamp"]
+  spec.email         = ["bryan@brynary.com"]
+  spec.summary       = %q{Lightweight wrapper for MongoDB documents}
+  spec.homepage      = "https://github.com/brynary/minidoc"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", ">= 3.0.0"
+  spec.add_dependency "activemodel", ">= 3.0.0"
+  spec.add_dependency "virtus", "~> 1.0.0"
+  spec.add_dependency "mongo", "~> 1"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "mocha"
+  spec.add_development_dependency "rake"
+end

data/test/activemodel_test.rb

@@ -0,0 +1,28 @@
+require File.expand_path('../helper', __FILE__)
+
+class ActiveModelTest < Minidoc::TestCase
+  def test_model_name
+    assert_equal "User", User.model_name.to_s
+  end
+
+  def test_to_model
+    user = User.new
+    assert_equal user, user.to_model
+  end
+
+  def test_to_key
+    user = User.new
+    user.id = BSON::ObjectId('52955618f9f6a52444000001')
+    assert_equal ["52955618f9f6a52444000001"], user.to_key
+  end
+
+  def test_to_param
+    user = User.new
+    user.id = BSON::ObjectId('52955618f9f6a52444000001')
+    assert_equal "52955618f9f6a52444000001", user.to_param
+  end
+
+  def test_to_path
+    assert_equal "users/user", User.new.to_partial_path
+  end
+end

data/test/belongs_to_test.rb

@@ -0,0 +1,49 @@
+require File.expand_path('../helper', __FILE__)
+
+class BelongsToTest < Minidoc::TestCase
+  class Cat < Minidoc
+    include Minidoc::Associations
+    belongs_to :owner, class_name: "User"
+  end
+
+  class User < ::User
+  end
+
+  def test_loading
+    assert_nil Cat.new.owner
+    user = User.create
+    cat = Cat.new(owner_id: user.id)
+    assert_equal user.id, cat.owner.id
+    cat.save
+    assert_equal user.id, cat.owner.id
+  end
+
+  def test_caching
+    user = User.create(name: "Bryan")
+    cat = Cat.create(owner_id: user.id)
+    assert_equal "Bryan", cat.owner.name
+    user.set(name: "Noah")
+    assert_equal "Bryan", cat.owner.name # doesn't change
+    assert_equal "Noah", cat.reload.owner.name # changes
+  end
+
+  def test_cache_expiry_on_field_update
+    user = User.create(name: "Bryan")
+    cat = Cat.create(owner_id: user.id)
+    assert_equal "Bryan", cat.owner.name
+    user.set(name: "Noah")
+    assert_equal "Bryan", cat.owner.name # doesn't change
+    cat.owner = user
+    assert_equal "Noah", cat.owner.name # changes
+  end
+
+  def test_cache_expiry_on_id_update
+    user = User.create(name: "Bryan")
+    cat = Cat.create(owner_id: user.id)
+    assert_equal "Bryan", cat.owner.name
+    user.set(name: "Noah")
+    assert_equal "Bryan", cat.owner.name # doesn't change
+    cat.owner_id = user.id
+    assert_equal "Noah", cat.owner.name # changes
+  end
+end

data/test/connection_test.rb

@@ -0,0 +1,20 @@
+require File.expand_path('../helper', __FILE__)
+
+class ConnectionTest < Minidoc::TestCase
+  class Company < Minidoc
+    self.collection_name = "accounts"
+  end
+
+  def test_collection_name
+    assert_equal "users", User.collection_name
+    assert_equal "accounts", Company.collection_name
+  end
+
+  def test_collection
+    assert_equal "users", User.collection.name
+  end
+
+  def test_database
+    assert_equal "minidoc_test", User.database.name
+  end
+end

data/test/counters_test.rb

@@ -0,0 +1,48 @@
+require File.expand_path('../helper', __FILE__)
+
+class CountersTest < Minidoc::TestCase
+  class SimpleCounter < Minidoc
+    include Minidoc::Counters
+
+    counter :counter
+  end
+
+  class AdvancedCounter < Minidoc
+    include Minidoc::Counters
+
+    counter :counter, start: 2, step_size: 3
+  end
+
+  def test_incrementing
+    x = SimpleCounter.create!
+
+    assert_equal 0, x.counter
+    assert_equal 1, x.increment_counter
+    assert_equal 2, x.increment_counter
+    assert_equal 3, x.increment_counter
+    assert_equal 3, x.reload.counter
+  end
+
+  def test_options
+    x = AdvancedCounter.create!
+
+    assert_equal 2, x.counter
+    assert_equal 5, x.increment_counter
+    assert_equal 8, x.increment_counter
+    assert_equal 11, x.increment_counter
+    assert_equal 11, x.reload.counter
+  end
+
+  def test_threading
+    x = SimpleCounter.create!
+    counters = []
+
+    [
+      Thread.new { 5.times { counters << x.increment_counter } },
+      Thread.new { 5.times { counters << x.increment_counter } },
+      Thread.new { 5.times { counters << x.increment_counter } },
+    ].map(&:join)
+
+    assert_equal 15, counters.uniq.length
+  end
+end

data/test/duplicate_key_test.rb

@@ -0,0 +1,21 @@
+require File.expand_path('../helper', __FILE__)
+
+class DuplicateKeyTest < Minidoc::TestCase
+  def test_rescue_duplicate_key_errors_result
+    user = User.create!
+    result = Minidoc.rescue_duplicate_key_errors do
+      User.create!(name: "two")
+    end
+
+    assert_equal "two", result.name
+  end
+
+  def test_rescue_duplicate_key_errors_false
+    user = User.create!
+    result = Minidoc.rescue_duplicate_key_errors do
+      User.create!(_id: user.id, name: "two")
+    end
+
+    assert_equal false, result
+  end
+end

data/test/grid_test.rb

@@ -0,0 +1,33 @@
+require File.expand_path('../helper', __FILE__)
+
+class GridTest < Minidoc::TestCase
+
+  def setup
+    super
+    @grid = Minidoc::Grid.new(Minidoc.database)
+  end
+
+  def test_get_with_string
+    doc_id = @grid.put("estamos en espana")
+    as_string = doc_id.to_s
+    document = @grid.get(as_string)
+    assert_equal("estamos en espana", document.read)
+  end
+
+  def test_get_json
+    hash = { "foo" => { "bar" => 1 } }
+    doc_id = @grid.put(hash.to_json)
+    as_string = doc_id.to_s
+    assert_equal(hash, @grid.get_json(as_string))
+  end
+
+  def test_delete
+    doc_id = @grid.put("estamos en espana")
+    as_string = doc_id.to_s
+    @grid.delete(as_string)
+    assert_raises Mongo::GridFileNotFound do
+      @grid.get(doc_id)
+    end
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,22 @@
+require 'minidoc'
+require 'minidoc/test_helpers'
+require 'minitest/autorun'
+require 'mocha/mini_test'
+
+I18n.enforce_available_locales = false
+I18n.load_path << File.expand_path("../locale/en.yml", __FILE__)
+
+class User < Minidoc
+  attribute :name, String
+  attribute :age, Integer
+end
+
+$mongo = Mongo::MongoClient.from_uri(ENV["MONGODB_URI"] || "mongodb://localhost")
+Minidoc.connection = $mongo
+Minidoc.database_name = "minidoc_test"
+
+class Minidoc::TestCase < Minitest::Test
+  def setup
+    Minidoc::TestHelpers.clear_database
+  end
+end

data/test/indexes_test.rb

@@ -0,0 +1,52 @@
+require File.expand_path('../helper', __FILE__)
+
+class IndexesTest < Minidoc::TestCase
+  class Company < Minidoc
+    self.collection_name = "accounts"
+
+    include Minidoc::Indexes
+
+    attribute :name
+    attribute :title
+    attribute :description
+  end
+
+  def test_ensure_index_single
+    Company.ensure_index(:name)
+
+    assert_equal %w( name ), indexed_keys(Company, "name_1")
+  end
+
+  def test_ensure_index_multiple
+    Company.ensure_index([:name, :title])
+
+    assert_equal %w( name title ), indexed_keys(Company, "name_1_title_1")
+  end
+
+  def test_ensure_index_options
+    Company.ensure_index(:name, unique: true)
+
+    assert index_info(Company, "name_1")["unique"]
+  end
+
+  def test_rescue_duplicate_key_errors_not_raising_exception
+    Company.ensure_index(:name, unique: true)
+
+    Company.rescue_duplicate_key_errors do
+      Company.create!(name: "CodeClimate")
+      Company.create!(name: "CodeClimate")
+    end
+  end
+
+  private
+
+  def index_info(klass, name)
+    klass.collection.index_information[name] || {}
+  end
+
+  def indexed_keys(klass, name)
+    key_info = index_info(klass, name)["key"] || {}
+    key_info.keys
+  end
+
+end

data/test/locale/en.yml

@@ -0,0 +1,5 @@
+en:
+  activemodel:
+    errors:
+      messages:
+        taken: "has already been taken"