minidoc 1.0.0.rc1 → 1.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ca8f2d071dcb6f2ef8e43e9d995e36ef0b1d4c6e
-  data.tar.gz: 0b0a1037fa259ab0602d2e21401a368495739803
+  metadata.gz: ac23e96443960c47789feec77de1e521febb6813
+  data.tar.gz: 946ccd3f12984a8f148225336f12cf9320a15b57
 SHA512:
-  metadata.gz: d5029b2a00f9427603fe3b3e50270959b1333c0312bd8b50fcd5b8b1d1d9144724a1d893e2bc77f6497435047def4f3fe3f9ce4deaeecc8f14639590f9f66ba4
-  data.tar.gz: c398c3570ac71d56aef8a27309ab3c8a4321e172ee829403e8050a64542944288f96a750a1fc24e826f3ecfe5a592df4661c3a528b1bc42f725c5de88b6b7dac
+  metadata.gz: ef711ba9125436d4bc9d5c599169f35aaebb67aca99a87de0e76eada3badaa81cdc0ad1bd420310ac0ceacb94d00e7874777fbc00f2d412642888156b6908692
+  data.tar.gz: 8aa19f3f9798c80dbba905dfb50d8cb7adde092067325f952bf64e81b295dcf25c3024ca74379d5c52d4e831fed09c0ed840e382cb3d196b29555bd67a7972f7

data/.codeclimate.yml

@@ -13,4 +13,4 @@ ratings:
   paths:
   - "**.rb"
 exclude_paths:
-- test/
+- spec/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/CHANGELOG.md

@@ -8,6 +8,20 @@
 
 ### Changes
 
+## v1.0.0.rc2 (2016-10-26)
+
+### New features
+
+* Allow omitting selectors to finder methods. ([@maxjacobson][])
+
+### Bug fixes
+
+* Minidoc#reload will raise Minidoc::DocumentNotFoundError when the document no longer exists, rather than a nil error. ([@maxjacobson][])
+
+### Changes
+
+* Make Minidoc.wrap and Minidoc.from_db private. ([@maxjacobson][])
+
 ## v1.0.0.rc1 (2016-09-29)
 
 ### New features

data/Gemfile

@@ -1,9 +1,8 @@
 source "https://rubygems.org"
 
-gem "minitest"
-gem "mocha"
+gem "codeclimate-test-reporter", "1.0.0.pre.rc2"
 gem "rake"
+gem "rspec"
 gem "simplecov"
-gem "codeclimate-test-reporter", "1.0.0.pre.rc2"
 
 gemspec

data/README.md

@@ -144,7 +144,7 @@ When making a pull request, please update the [changelog](CHANGELOG.md).
 
 * Update the changelog to mark the unreleased changes as part of the new release.
 * Update the version.rb with the new version number
-* Commit and push to master
+* Commit and push to master (may need to make a Pull Request because master is protected)
 * `rake release` which will
   * tag the latest commit based on version.rb
   * push to github

data/Rakefile

@@ -1,11 +1,6 @@
 require "bundler/gem_tasks"
-require "rake/testtask"
+require "rspec/core/rake_task"
 
-Rake::TestTask.new do |t|
-  t.libs.push "lib"
-  t.ruby_opts = %w[-W0]
-  t.test_files = FileList["test/*_test.rb"]
-  t.verbose = true
-end
+RSpec::Core::RakeTask.new(:spec)
 
-task :default => :test
+task :default => :spec

data/lib/minidoc/finders.rb

@@ -33,19 +33,21 @@ module Minidoc::Finders
       end
     end
 
-    def find_one(selector, options = {})
+    def find_one(selector = {}, options = {})
       wrap(collection.find_one(selector, options))
     end
 
-    def find_one!(query, options = {})
-      find_one(query, options) or raise DocumentNotFoundError
+    def find_one!(selector = {}, options = {})
+      find_one(selector, options) or raise DocumentNotFoundError
     end
 
-    def find_one_or_initialize(attributes, options = {})
+    def find_one_or_initialize(attributes = {}, options = {})
       raise ArgumentError unless attributes.is_a?(Hash)
       find_one(attributes, options) || new(attributes)
     end
 
+    private
+
     def from_db(attrs)
       doc = new(attrs)
       doc.instance_variable_set("@new_record", false)

data/lib/minidoc/version.rb

@@ -1,3 +1,3 @@
 class Minidoc
-  VERSION = "1.0.0.rc1"
+  VERSION = "1.0.0.rc2".freeze
 end

data/lib/minidoc.rb

@@ -157,7 +157,7 @@ class Minidoc
   end
 
   def reload
-    new_object = self.class.find(self.id)
+    new_object = self.class.find(self.id) or raise DocumentNotFoundError
 
     self.class.attribute_set.each do |attr|
       self[attr.name] = new_object[attr.name]

data/spec/minidoc/associations_spec.rb

@@ -0,0 +1,88 @@
+require "spec_helper"
+
+describe Minidoc::Associations do
+  class Cat < Minidoc
+    include Minidoc::Associations
+
+    belongs_to :owner, class_name: "User"
+  end
+
+  class Doggie < Minidoc
+    include Minidoc::Associations
+
+    belongs_to :user
+  end
+
+  module Animal
+    class Armadillo < Minidoc
+      include Minidoc::Associations
+
+      belongs_to :predator
+    end
+
+    class Predator < Minidoc
+    end
+  end
+
+  describe "dynamically defined association methods" do
+    it "can load associated documents" do
+      expect(Cat.new.owner).to be_nil
+      user = User.create
+      cat = Cat.new(owner_id: user.id)
+      expect(cat.owner.id).to eq user.id
+      cat.save
+      expect(cat.owner.id).to eq user.id
+    end
+
+    it "caches the association cache rather than go to the database each time" do
+      user = User.create(name: "Bryan")
+      cat = Cat.create(owner_id: user.id)
+      expect(cat.owner.name).to eq "Bryan"
+      user.set(name: "Noah")
+      expect(cat.owner.name).to eq "Bryan"
+      expect(cat.reload.owner.name).to eq "Noah"
+    end
+
+    it "expires the association cache when a new associated document is provided" do
+      user = User.create(name: "Bryan")
+      cat = Cat.create(owner_id: user.id)
+      expect(cat.owner.name).to eq "Bryan"
+      user.set(name: "Noah")
+      expect(cat.owner.name).to eq "Bryan"
+      cat.owner = user
+      expect(cat.owner.name).to eq "Noah"
+    end
+
+    it "expires the association cache when the related foreign-key id field is updated" do
+      user = User.create(name: "Bryan")
+      cat = Cat.create(owner_id: user.id)
+      expect(cat.owner.name).to eq "Bryan"
+      user.set(name: "Noah")
+      expect(cat.owner.name).to eq "Bryan"
+      cat.owner_id = user.id
+      expect(cat.owner.name).to eq "Noah"
+    end
+  end
+
+  context "when the classes are not namespaced" do
+    it "infers the class name of the association" do
+      expect(Doggie.new.user).to be_nil
+      user = User.create
+      sam = Doggie.new(user_id: user.id)
+      expect(sam.user.id).to eq user.id
+      sam.save
+      expect(sam.user.id).to eq user.id
+    end
+  end
+
+  context "when the classes are namespaced" do
+    it "infers the class name of the association" do
+      expect(Animal::Armadillo.new.predator).to be_nil
+      predator = Animal::Predator.create
+      arnie = Animal::Armadillo.new(predator_id: predator.id)
+      expect(arnie.predator.id).to eq predator.id
+      arnie.save
+      expect(arnie.predator.id).to eq predator.id
+    end
+  end
+end

data/spec/minidoc/connection_spec.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+require "spec_helper"
+
+describe "connection" do
+  class Company < Minidoc
+    self.collection_name = "accounts"
+  end
+
+  describe ".collection_name" do
+    it "is inferred based on the class name" do
+      expect(User.collection_name).to eq "users"
+    end
+
+    it "can be overridden" do
+      expect(Company.collection_name).to eq "accounts"
+    end
+  end
+
+  describe ".collection" do
+    it "exposes the underlying Mongo object" do
+      expect(User.collection).to be_a Mongo::Collection
+    end
+
+    it "passes through the collection_name to the underlying Mongo::Collection" do
+      expect(User.collection.name).to eq "users"
+      expect(Company.collection.name).to eq "accounts"
+    end
+  end
+
+  describe ".database" do
+    it "exposes the underlying Mongo object" do
+      expect(User.database).to be_a Mongo::DB
+    end
+
+    it "passes through the database name to the underlying Mongo::DB" do
+      expect(User.database.name).to eq "minidoc_test"
+    end
+  end
+
+  describe "first run experience" do
+    it "fails helpfully if you haven't configured the necessary values" do
+      with_alternative_configuration do
+        Minidoc.connection = nil
+        Minidoc.database_name = nil
+        expect { User.create(name: "Kären") }.to raise_error(Minidoc::MissingConfiguration, "Make sure to set Minidoc.connection")
+      end
+    end
+
+    it "fails helpfully if you've only neglected the database_name" do
+      with_alternative_configuration do
+        Minidoc.database_name = nil
+        expect { User.create(name: "Kären") }.to raise_error(Minidoc::MissingConfiguration, "Make sure to set Minidoc.database_name")
+      end
+    end
+  end
+
+  def with_alternative_configuration
+    original_connection = Minidoc.connection
+    original_database_name = Minidoc.database_name
+    yield
+  ensure
+    Minidoc.connection = original_connection
+    Minidoc.database_name = original_database_name
+  end
+end

data/spec/minidoc/counters_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe Minidoc::Counters do
+  class SimpleCounter < Minidoc
+    include Minidoc::Counters
+
+    counter :counter
+  end
+
+  class AdvancedCounter < Minidoc
+    include Minidoc::Counters
+
+    counter :counter, start: 2, step_size: 3
+  end
+
+  describe "#increment_counter" do
+    it "increments the field" do
+      x = SimpleCounter.create!
+      expect(x.counter).to eq 0
+      expect(x.increment_counter).to eq 1
+      expect(x.increment_counter).to eq 2
+      expect(x.increment_counter).to eq 3
+      expect(x.reload.counter).to eq 3
+    end
+
+    it "can be customized with some options" do
+      x = AdvancedCounter.create!
+      expect(x.counter).to eq 2
+      expect(x.increment_counter).to eq 5
+      expect(x.increment_counter).to eq 8
+      expect(x.increment_counter).to eq 11
+      expect(x.reload.counter).to eq 11
+    end
+
+    it "is thread safe" do
+      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)
+      expect(counters.uniq.length).to eq 15
+    end
+  end
+end

data/spec/minidoc/finders_spec.rb

@@ -0,0 +1,91 @@
+require "spec_helper"
+
+describe Minidoc::Finders do
+  describe ".all" do
+    it "returns all of the documents in the collection" do
+      (User.collection << { name: "Joe" })
+      (User.collection << { name: "Bryan" })
+      users = User.all
+      expect(["Bryan", "Joe"]).to match_array(users.map(&:name))
+    end
+  end
+
+  describe ".count" do
+    it "counts the documents in the collection" do
+      (User.collection << { name: "Joe" })
+      (User.collection << { name: "Bryan" })
+      expect(User.count).to eq 2
+    end
+
+    it "can be scoped by a query" do
+      (User.collection << { name: "Joe" })
+      (User.collection << { name: "Bryan" })
+      expect(User.count(name: "Bryan")).to eq 1
+    end
+  end
+
+  describe ".exists?" do
+    it "tells you if any documents exist that match a query" do
+      (User.collection << { name: "Joe" })
+      expect(User.exists?(name: "Joe")).to be(true)
+      expect(User.exists?(name: "Bryan")).to be(false)
+    end
+  end
+
+  describe ".first" do
+    it "returns a document from the collection" do
+      expect(User.first).to be_nil
+      user = User.create(name: "Bryan")
+      expect(User.first.name).to eq "Bryan"
+      expect(User.first).to eq user
+    end
+  end
+
+  describe ".find" do
+    it "querys the collection using the mongodb query language" do
+      user = User.create(name: "Bryan")
+      expect(User.find({}).to_a).to eq [user]
+      expect(User.find(name: "Noah").to_a).to eq []
+    end
+  end
+
+  describe ".find_one" do
+    it "returns the first document that matches a query" do
+      user = User.create(name: "Bryan")
+      expect(User.find_one({})).to eq user
+      expect(User.find_one).to eq user
+      expect(User.find_one(name: "Noah")).to eq nil
+    end
+  end
+
+  describe ".find_one!" do
+    it "returns the first document that matches a query or raises an error" do
+      expect { User.find_one! }.to raise_error(Minidoc::DocumentNotFoundError)
+      user = User.create(name: "Bryan")
+      expect(User.find_one!(name: "Bryan")).to eq user
+      expect(User.find_one!).to eq user
+      expect { User.find_one!(name: "Noah") }.to raise_error(Minidoc::DocumentNotFoundError)
+    end
+  end
+
+  describe ".find_one_or_initialize" do
+    it "returns the first document that matches a query or makes a non-persisted document from that query" do
+      user = User.create(name: "Bryan", age: 1)
+      expect((user == User.find_one_or_initialize(name: "Bryan"))).to be_truthy
+      expect(User.find_one_or_initialize(name: "Noah").is_a?(User)).to eq true
+      expect(User.find_one_or_initialize(name: "Noah").new_record?).to eq true
+    end
+
+    it "doesn't require attributes" do
+      expect(User.find_one_or_initialize).to be_a User
+      user = User.create(name: "Bryan", age: 1)
+      expect(user).to eq User.find_one_or_initialize
+    end
+
+    it "allows query options" do
+      user = User.create(name: "Noah", age: 1)
+      expect((user == User.find_one_or_initialize({ age: 1 }, sort: { name: -1 }))).to be_truthy
+      expect { User.find_one_or_initialize("foo") }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/minidoc/grid_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe Minidoc::Grid do
+  let(:grid) { Minidoc::Grid.new(Minidoc.database) }
+
+  describe "#put and #get" do
+    it "can store raw string data" do
+      doc_id = grid.put "estamos en espana"
+      expect(doc_id).to be_a BSON::ObjectId
+
+      document = grid.get doc_id.to_s
+
+      expect(document).to be_a Mongo::GridIO
+      expect(document.read).to eq "estamos en espana"
+    end
+  end
+
+  describe "#get_json" do
+    it "parses the JSON into structured ruby objects" do
+      hash = { "foo" => { "bar" => 1 } }
+      doc_id = grid.put(hash.to_json)
+
+      value = grid.get_json(doc_id.to_s)
+
+      expect(value).to eq hash
+    end
+  end
+
+  describe "#delete" do
+    it "removes the 'file' from the database" do
+      doc_id = grid.put "estamos en espana"
+
+      grid.delete doc_id.to_s
+
+      expect { grid.get doc_id }.to raise_error(Mongo::GridFileNotFound)
+    end
+  end
+end

data/spec/minidoc/read_only_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe Minidoc::ReadOnly do
+  class ReadOnlyUser < Minidoc::ReadOnly
+    self.collection_name = "users"
+    attribute :name, String
+  end
+
+  it "is read only, meaning it can't change over time" do
+    expect { ReadOnlyUser.create(name: "Bryan") }.to raise_error(NoMethodError)
+
+    rw_user = User.create(name: "Bryan")
+    user = ReadOnlyUser.first
+    expect(user.name).to eq "Bryan"
+    expect(rw_user.id).to eq user.id
+    expect(user).to eq user.as_value
+
+    expect { user.name = "Noah" }.to raise_error(NoMethodError)
+  end
+
+  it "can become a value object" do
+    user = User.new(name: "Bryan")
+    user.name = "Noah"
+    user = user.as_value
+
+    expect { user.name = "Noah" }.to raise_error(NoMethodError)
+  end
+end

data/spec/minidoc/timestamps_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe Minidoc::Timestamps do
+  class TimestampsUser < Minidoc
+    include Minidoc::Timestamps
+
+    timestamps!
+  end
+
+  describe ".timestamps!" do
+    it "automatically sets created_at and updated_at" do
+      user = TimestampsUser.create!
+      expect(user.created_at).to_not be_nil
+      expect(user.created_at).to eq user.updated_at
+    end
+
+    it "updates the updated_at when the document changes" do
+      user = TimestampsUser.create
+      sleep 0.001
+      user.save
+      expect(user.created_at).to_not eq user.updated_at
+    end
+  end
+end

data/spec/minidoc/validations_spec.rb

@@ -0,0 +1,64 @@
+require "spec_helper"
+
+describe Minidoc::Validations do
+  describe Minidoc::Validations::UniquenessValidator do
+    class UniquenessUser < User
+      validates :name, uniqueness: true
+    end
+
+    class InsensitiveUser < User
+      attribute :insensitive, String
+      validates :insensitive, uniqueness: { case_sensitive: false }
+    end
+
+    class ScopedUser < User
+      attribute :country_id, Integer
+      attribute :tax_id_number, Integer
+      validates :tax_id_number, uniqueness: { scope: :country_id }
+    end
+
+    it "is invalid with existing value" do
+      UniquenessUser.create!(name: "same name")
+      user = UniquenessUser.new(name: "same name")
+      expect(user).to_not be_valid
+      expect(user.errors[:name]).to eq ["has already been taken"]
+    end
+
+    it "is case insensitive by default" do
+      UniquenessUser.create!(name: "different case")
+      user = UniquenessUser.new(name: "DIFFERENT CASE")
+      expect(user).to be_valid
+    end
+
+    it "persists a document that passes validations" do
+      user = UniquenessUser.create!(name: "lonely")
+      expect(user).to be_valid
+    end
+
+    it "can be made case insensitive" do
+      InsensitiveUser.create!(insensitive: "equivalent")
+      user = InsensitiveUser.new(insensitive: "EquivALENT")
+      expect(user).to_not be_valid
+      expect(user.errors["insensitive"]).to eq ["has already been taken"]
+    end
+
+    it "does not allow the same value within a scope" do
+      ScopedUser.create!(country_id: 1, tax_id_number: 1)
+      user = ScopedUser.new(country_id: 1, tax_id_number: 1)
+      expect(user).to_not be_valid
+      expect(user.errors[:tax_id_number]).to eq ["has already been taken"]
+    end
+
+    it "allows a different value within the same scope" do
+      ScopedUser.create!(country_id: 1, tax_id_number: 1)
+      user = ScopedUser.new(country_id: 1, tax_id_number: 2)
+      expect(user).to be_valid
+    end
+
+    it "does allow the same value in a different scope" do
+      ScopedUser.create!(country_id: 1, tax_id_number: 1)
+      user = ScopedUser.new(country_id: 2, tax_id_number: 1)
+      expect(user).to be_valid
+    end
+  end
+end