guacamole 0.0.1 → 0.1.0

data/lib/rails/generators/guacamole_generator.rb

@@ -0,0 +1,28 @@
+# -*- encoding : utf-8 -*-
+
+require 'rails/generators/named_base'
+require 'rails/generators/active_model'
+
+module Guacamole
+  module Generators
+    class Base < ::Rails::Generators::NamedBase
+      def self.source_root
+        @_guacamole_source_root ||=
+          File.expand_path("../#{base_name}/#{generator_name}/templates", __FILE__)
+      end
+    end
+  end
+end
+
+module Rails
+  module Generators
+    class GeneratedAttribute
+      def type_class
+        return 'Time' if type == :datetime
+        return 'String' if type == :text
+        return 'Boolean' if type == :boolean
+        type.to_s.camelcase
+      end
+    end
+  end
+end

data/lib/rails/generators/rails/collection/collection_generator.rb

@@ -0,0 +1,13 @@
+# -*- encoding : utf-8 -*-
+
+require 'rails/generators/guacamole/collection/collection_generator.rb'
+
+module Rails
+  module Generators
+    class CollectionGenerator < Guacamole::Generators::CollectionGenerator
+      def self.source_root
+        File.expand_path("../../guacamole/#{generator_name}/templates", File.dirname(__FILE__))
+      end
+    end
+  end
+end

data/lib/rails/generators/rspec/collection/collection_generator.rb

@@ -0,0 +1,13 @@
+# -*- encoding : utf-8 -*-
+
+require 'rails/generators/guacamole_generator'
+
+module Rspec
+  module Generators
+    class CollectionGenerator < ::Guacamole::Generators::Base
+      def create_collection_spec
+        template 'collection_spec.rb.tt', File.join('spec/collections', class_path, "#{file_name}_collection_spec.rb")
+      end
+    end
+  end
+end

data/lib/rails/generators/rspec/collection/templates/collection_spec.rb.tt

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+<% module_namespacing do -%>
+describe <%= class_name %>Collection do
+  pending "add some examples to (or delete) #{__FILE__}"
+end
+<% end -%>

data/spec/acceptance/association_spec.rb

@@ -0,0 +1,40 @@
+# -*- encoding : utf-8 -*-
+require 'guacamole'
+require 'acceptance/spec_helper'
+
+require 'fabricators/book'
+require 'fabricators/author'
+
+class AuthorsCollection
+  include Guacamole::Collection
+
+  map do
+    referenced_by :books
+  end
+end
+
+class BooksCollection
+  include Guacamole::Collection
+
+  map do
+    references :author
+  end
+end
+
+describe 'Associations' do
+  let(:author) { Fabricate(:author_with_three_books) }
+
+  it 'should load referenced models from the database' do
+    the_author        = AuthorsCollection.by_key author.key
+    books_from_author = BooksCollection.by_example(author_id: author.key).to_a
+
+    expect(books_from_author).to eq the_author.books.to_a
+  end
+
+  it 'should load the referenced model from the database' do
+    the_author           = AuthorsCollection.by_key author.key
+    a_book_by_the_author = BooksCollection.by_example(author_id: author.key).to_a.first
+
+    expect(a_book_by_the_author.author).to eq the_author
+  end
+end

data/spec/acceptance/basic_spec.rb

@@ -75,7 +75,7 @@ describe 'CollectionBasics' do
       expect(found_model).to eq some_article
     end
 
-    it 'should save models to the database' do
+    it 'should create models in the database' do
       new_article = Fabricate.build(:article)
       subject.save new_article
 
@@ -84,7 +84,7 @@ describe 'CollectionBasics' do
 
     it 'should update models in the database' do
       some_article.title = 'Has been updated'
-      subject.replace some_article
+      subject.save some_article
 
       updated_article = subject.by_key(some_article.key)
 
@@ -107,6 +107,23 @@ describe 'CollectionBasics' do
       expect(found_article.comments.first).to be_a Comment
       expect(found_article.comments).to eq article_with_comments.comments
     end
+
+    context 'prevent aliasing effects' do
+      it 'should hold only one object of the same document when getting one document' do
+        this_article = subject.by_key some_article.key
+        that_article = subject.by_key some_article.key
+
+        expect(this_article.object_id).to eq that_article.object_id
+      end
+
+      it 'should only hold one object of the same document when using `by_example`' do
+        Fabricate.times(3, :article)
+
+        subject.all.each do |article|
+          expect(article.object_id).to eq subject.by_key(article.key).object_id
+        end
+      end
+    end
   end
 
 end

data/spec/acceptance/spec_helper.rb

@@ -4,6 +4,7 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 require 'fabrication'
+require 'faker'
 require 'logging'
 require 'ashikawa-core'
 
@@ -13,8 +14,11 @@ rescue LoadError
   puts "Debugger is not available. Maybe you're Travis."
 end
 
-class Fabrication::Generator::Guacamole < Fabrication::Generator::Base
+# This is required to remove the deprecation warning introduced in this commit:
+# https://github.com/svenfuchs/i18n/commit/3b6e56e06fd70f6e4507996b017238505e66608c.
+I18n.config.enforce_available_locales = false
 
+class Fabrication::Generator::Guacamole < Fabrication::Generator::Base
   def self.supports?(klass)
     defined?(Guacamole) && klass.ancestors.include?(Guacamole::Model)
   end
@@ -27,7 +31,6 @@ class Fabrication::Generator::Guacamole < Fabrication::Generator::Base
   def validate_instance
     _instance.valid?
   end
-
 end
 
 Fabrication::Schematic::Definition::GENERATORS.unshift Fabrication::Generator::Guacamole

data/spec/fabricators/author.rb

@@ -0,0 +1,11 @@
+# -*- encoding: utf-8 -*-
+
+class Author
+  extend ActiveSupport::Autoload
+  include Guacamole::Model
+
+  autoload :Book, 'fabricators/book'
+
+  attribute :name, String
+  attribute :books, Array[Book], coerce: false
+end

data/spec/fabricators/author_fabricator.rb

@@ -0,0 +1,7 @@
+# -*- encoding: utf-8 -*-
+
+Fabricator(:author_with_three_books, from: :author) do
+  name 'Star Swirl the Bearded'
+
+  books(count: 3)
+end

data/spec/fabricators/book.rb

@@ -0,0 +1,11 @@
+# -*- encoding: utf-8 -*-
+
+class Book
+  include Guacamole::Model
+  include Guacamole::Model
+
+  autoload :Author, 'fabricators/author'
+
+  attribute :title, String
+  attribute :author, Author
+end

data/spec/fabricators/book_fabricator.rb

@@ -0,0 +1,5 @@
+# -*- encoding: utf-8 -*-
+
+Fabricator(:book) do
+  title { Faker::Lorem.words.join(' ') }
+end

data/spec/unit/collection_spec.rb

@@ -115,9 +115,174 @@ describe Guacamole::Collection do
 
   describe 'save' do
 
+    before do
+      allow(mapper).to receive(:model_to_document).with(model).and_return(document)
+      allow(mapper).to receive(:referenced_by_models).and_return([])
+      allow(mapper).to receive(:referenced_models).and_return([])
+    end
+
+    let(:key)       { double('Key') }
+    let(:rev)       { double('Rev') }
+    let(:document)  { double('Document', key: key, revision: rev).as_null_object }
+    let(:model)     { double('Model').as_null_object }
+    let(:response)  { double('Hash') }
+
+    context 'a valid model' do
+
+      before do
+        allow(model).to receive(:valid?).and_return(true)
+      end
+
+      context 'which is not persisted' do
+
+        before do
+          allow(connection).to receive(:create_document).with(document).and_return(document)
+          allow(model).to receive(:persisted?).and_return(false)
+        end
+
+        it 'should return the model after calling save' do
+          expect(subject.save(model)).to eq model
+        end
+
+        it 'should set timestamps before creating the document' do
+          now = double('Time.now')
+
+          allow(Time).to receive(:now).once.and_return(now)
+
+          expect(model).to receive(:created_at=).with(now).ordered
+          expect(model).to receive(:updated_at=).with(now).ordered
+
+          allow(connection).to receive(:create_document).with(document).and_return(document).ordered
+
+          subject.save model
+        end
+
+        it 'should add key to model' do
+          expect(model).to receive(:key=).with(key)
+
+          subject.save model
+        end
+
+        it 'should add rev to model' do
+          expect(model).to receive(:rev=).with(rev)
+
+          subject.save model
+        end
+      end
+
+      context 'which is persisted' do
+
+        before do
+          allow(model).to receive(:persisted?).and_return(true)
+          allow(connection).to receive(:replace).and_return(response)
+          allow(response).to receive(:[]).with('_rev').and_return(rev)
+        end
+
+        let(:model)    { double('Model', key: key).as_null_object }
+
+        it 'should set the updated_at timestamp before replacing the document' do
+          now = double('Time.now')
+
+          allow(Time).to receive(:now).once.and_return(now)
+          expect(model).to receive(:updated_at=).with(now)
+
+          subject.save model
+        end
+
+        it 'should replace the document by key via the connection' do
+          expect(connection).to receive(:replace).with(key, document)
+
+          subject.save model
+        end
+
+        it 'should update the revision after replacing the document' do
+          allow(connection).to receive(:replace).and_return(response).ordered
+          expect(model).to receive(:rev=).with(rev).ordered
+
+          subject.save model
+        end
+
+        it 'should return the model' do
+          expect(subject.save(model)).to eq model
+        end
+
+        it 'should not update created_at' do
+          expect(model).not_to receive(:created_at=)
+
+          subject.save model
+        end
+
+      end
+    end
+
+    context 'an invalid model' do
+
+      before do
+        expect(model).to receive(:valid?).and_return(false)
+      end
+
+      context 'which is not persisted' do
+
+        before do
+          allow(model).to receive(:persisted?).and_return(false)
+        end
+
+        it 'should not be used to create the document' do
+          expect(connection).not_to receive(:create_document)
+
+          subject.save model
+        end
+
+        it 'should not be changed' do
+          expect(model).not_to receive(:created_at=)
+          expect(model).not_to receive(:updated_at=)
+          expect(model).not_to receive(:key=)
+          expect(model).not_to receive(:rev=)
+
+          subject.save model
+        end
+
+        it 'should return false' do
+          expect(subject.save(model)).to be false
+        end
+      end
+
+      context 'which is persisted' do
+
+        before do
+          allow(model).to receive(:persisted?).and_return(true)
+          allow(response).to receive(:[]).with('_rev').and_return(rev)
+        end
+
+        let(:model)    { double('Model', key: key).as_null_object }
+
+        it 'should not be used to replace the document' do
+          expect(connection).not_to receive(:replace)
+
+          subject.save model
+        end
+
+        it 'should not be changed' do
+          expect(model).not_to receive(:rev=)
+          expect(model).not_to receive(:updated_at=)
+
+          subject.save model
+        end
+
+        it 'should return false' do
+          expect(subject.save(model)).to be false
+        end
+      end
+    end
+  end
+
+  describe 'create' do
+
     before do
       allow(connection).to receive(:create_document).with(document).and_return(document)
       allow(mapper).to receive(:model_to_document).with(model).and_return(document)
+      allow(mapper).to receive(:referenced_by_models).and_return([])
+      allow(mapper).to receive(:referenced_models).and_return([])
     end
 
     let(:key)       { double('Key') }
@@ -134,11 +299,11 @@ describe Guacamole::Collection do
         expect(connection).to receive(:create_document).with(document).and_return(document)
         expect(mapper).to receive(:model_to_document).with(model).and_return(document)
 
-        subject.save model
+        subject.create model
       end
 
-      it 'should return the model after calling save' do
-        expect(subject.save(model)).to eq model
+      it 'should return the model after calling create' do
+        expect(subject.create(model)).to eq model
       end
 
       it 'should set timestamps before creating the document' do
@@ -151,19 +316,101 @@ describe Guacamole::Collection do
 
         allow(connection).to receive(:create_document).with(document).and_return(document).ordered
 
-        subject.save model
+        subject.create model
       end
 
       it 'should add key to model' do
         expect(model).to receive(:key=).with(key)
 
-        subject.save model
+        subject.create model
       end
 
       it 'should add rev to model' do
         expect(model).to receive(:rev=).with(rev)
 
-        subject.save model
+        subject.create model
+      end
+
+      context 'with referenced model' do
+        let(:referenced_model)                { double('ReferencedModel') }
+        let(:referenced_model_name)           { :some_referenced_model }
+        let(:referenced_models)               { [referenced_model_name] }
+        let(:collection_for_referenced_model) { double('Collection') }
+
+        before do
+          allow(referenced_model).to receive(:persisted?).and_return(false)
+          allow(mapper).to receive(:collection_for)
+            .with(referenced_model_name)
+            .and_return(collection_for_referenced_model)
+          allow(mapper).to receive(:referenced_models).and_return(referenced_models)
+          allow(model).to receive(:send).with(referenced_model_name).and_return(referenced_model)
+          allow(collection_for_referenced_model).to receive(:save).with(referenced_model)
+        end
+
+        it 'should save each referenced model' do
+          expect(collection_for_referenced_model).to receive(:save).with(referenced_model)
+
+          subject.create model
+        end
+
+        it 'should save the reference only if it is not already persisted' do
+          allow(referenced_model).to receive(:persisted?).and_return(true)
+          expect(collection_for_referenced_model).not_to receive(:save).with(referenced_model)
+
+          subject.create model
+        end
+
+        it 'should save the reference only if it is present' do
+          allow(model).to receive(:send).with(:some_referenced_model).and_return(nil)
+          expect(collection_for_referenced_model).not_to receive(:save).with(referenced_model)
+
+          subject.create model
+        end
+      end
+
+      context 'with referenced_by model' do
+        let(:referenced_by_model)                { double('ReferencedByModel') }
+        let(:referenced_by_model_name)           { :some_referenced_by_model }
+        let(:referenced_by_models)               { [referenced_by_model_name] }
+        let(:collection_for_referenced_by_model) { double('Collection') }
+
+        before do
+          allow(referenced_by_model).to receive(:persisted?).and_return(false)
+          allow(referenced_by_model).to receive("#{model.class.name.demodulize.underscore}=").with(model)
+          allow(mapper).to receive(:collection_for)
+            .with(referenced_by_model_name)
+            .and_return(collection_for_referenced_by_model)
+          allow(mapper).to receive(:referenced_by_models).and_return(referenced_by_models)
+          allow(model).to receive(:send).with(referenced_by_model_name).and_return([referenced_by_model])
+          allow(collection_for_referenced_by_model).to receive(:save).with(referenced_by_model)
+        end
+
+        it 'should save the references' do
+          expect(collection_for_referenced_by_model).to receive(:save).with(referenced_by_model)
+
+          subject.create model
+        end
+
+        it 'should save the references only if it is not already persisted' do
+          allow(referenced_by_model).to receive(:persisted?).and_return(true)
+          expect(collection_for_referenced_by_model).not_to receive(:save).with(referenced_by_model)
+
+          subject.create model
+        end
+
+        it 'should save the references only if it is present' do
+          allow(model).to receive(:send).with(referenced_by_model_name).and_return([])
+          expect(collection_for_referenced_by_model).not_to receive(:save).with(referenced_by_model)
+
+          subject.create model
+        end
+
+        it 'should ensure the references have the parent model assigned prior saving' do
+          expect(referenced_by_model).to receive("#{model.class.name.demodulize.underscore}=").with(model).ordered
+          expect(collection_for_referenced_by_model).to receive(:save).with(referenced_by_model).ordered
+
+          subject.create model
+        end
       end
     end
 
@@ -174,22 +421,22 @@ describe Guacamole::Collection do
       end
 
       it 'should not be used to create the document' do
-        expect(connection).to receive(:create_document).never
+        expect(connection).not_to receive(:create_document)
 
-        subject.save model
+        subject.create model
       end
 
       it 'should not be changed' do
-        expect(model).to receive(:created_at=).never
-        expect(model).to receive(:updated_at=).never
-        expect(model).to receive(:key=).never
-        expect(model).to receive(:rev=).never
+        expect(model).not_to receive(:created_at=)
+        expect(model).not_to receive(:updated_at=)
+        expect(model).not_to receive(:key=)
+        expect(model).not_to receive(:rev=)
 
-        subject.save model
+        subject.create model
       end
 
       it 'should return false' do
-        expect(subject.save(model)).to be false
+        expect(subject.create(model)).to be false
       end
     end
   end
@@ -274,7 +521,7 @@ describe Guacamole::Collection do
       end
 
       it 'should not update created_at' do
-        expect(model).to receive(:created_at=).never
+        expect(model).not_to receive(:created_at=)
 
         subject.replace model
       end
@@ -286,14 +533,14 @@ describe Guacamole::Collection do
       end
 
       it 'should not be used to replace the document' do
-        expect(connection).to receive(:replace).never
+        expect(connection).not_to receive(:replace)
 
         subject.replace model
       end
 
       it 'should not be changed' do
-        expect(model).to receive(:rev=).never
-        expect(model).to receive(:updated_at=).never
+        expect(model).not_to receive(:rev=)
+        expect(model).not_to receive(:updated_at=)
 
         subject.replace model
       end