opal-pouchdb 0.1.1

data/opal/pouchdb/event_emitter.rb

@@ -0,0 +1,27 @@
+module PouchDB
+  class EventEmitter
+    include Conversion
+
+    def initialize(stream)
+      @native    = stream
+    end
+
+    def on(event, &blk)
+      %x{
+        #{@native}.on(event, function(change) {
+          #{blk.call(OBJECT_CONVERSION.call(`change`))}
+        })
+      }
+
+      self
+    end
+
+    def then
+      as_opal_promise(`#{@native}`)
+    end
+
+    def cancel
+      `#{@native}.cancel()`
+    end
+  end
+end

data/opal/pouchdb/replication.rb

@@ -0,0 +1,17 @@
+module PouchDB
+  class Replication
+    include Conversion
+
+    def initialize(native)
+      @native = native
+    end
+
+    def to(db, options = {})
+      EventEmitter.new(`#{@native}.replicate.to(#{database_as_string(db)}, #{options.to_n})`)
+    end
+
+    def from(db, options = {})
+      EventEmitter.new(`#{@native}.replicate.from(#{database_as_string(db)}, #{options.to_n})`)
+    end
+  end
+end

data/opal/pouchdb/row.rb

@@ -0,0 +1,15 @@
+module PouchDB
+  class Row
+    include Native
+
+    def initialize(native_row)
+      super native_row
+    end
+
+    native_reader :id, :key, :value
+
+    def document
+      Hash.new(`#{@native}.doc`)
+    end
+  end
+end

data/spec/database_events_spec.rb

@@ -0,0 +1,81 @@
+require "spec_helper"
+
+describe "PouchDB::Database#changes" do
+  describe "changes" do
+    async "calls a block when a 'change' event is emitted" do
+      with_new_database do |db|
+        db.post(name: "I Change Things")
+        db.post(name: "I Change Things Too")
+
+        stream = db.changes
+        count  = 0
+        stream.on "change" do count += 1 end
+
+        delayed(1.2) do |p|
+          p.resolve(count == 2)
+        end.then do |c|
+          async do
+            expect(c).to be(true)
+          end
+        end
+      end
+    end
+  end
+
+  describe "cancellation" do
+    async "calls a block when the 'complete' event is emitted" do
+      with_new_database do |db|
+        stream    = db.changes
+        cancelled = false
+        stream.on "complete" do cancelled = true end
+
+        delayed(1) do |p|
+          p.resolve(cancelled)
+        end.then do |c|
+          async do
+            expect(c).to be(true)
+          end
+        end
+      end
+    end
+  end
+
+  describe "single-shot" do
+    # TODO: Make this pass. I think I'm missing some important
+    # point of the "Single-shot" mode.
+    pending "calls a block with all the changes" do
+      with_new_database do |db|
+        db.post(classification: "Important Stuff")
+        db.post(classification: "REALLY Important Stuff")
+
+        db.changes(limit: 1, since: 0).then do |cs|
+          async do
+            expect(cs).to eq(1)
+          end
+        end
+      end
+    end
+  end
+
+  async "passes options along" do
+    with_new_database do |db|
+      db.post(name: "Ishmael")
+      db.post(name: "Fishmael")
+
+      changes = []
+      db.changes(include_docs: true).on "change" do |c|
+        changes << c
+      end
+
+      delayed(1.2) do |p|
+        p.resolve(changes)
+      end.then do |c|
+        async do
+          expect(c.size).to eq(2)
+          expect(c.first["doc"]["name"]).to eq("Ishmael")
+          expect(c.last["doc"]["name"]).to eq("Fishmael")
+        end
+      end
+    end
+  end
+end

data/spec/database_spec.rb

@@ -0,0 +1,331 @@
+require "spec_helper"
+require "securerandom"
+
+describe PouchDB::Database do
+  let(:docs) {
+    [
+      { name: "Banana", color: "yellow" },
+      { name: "Apple", color: "red" },
+      { name: "Green Apple", color: "green" }
+    ]
+  }
+
+  let(:docs_with_ids) {
+    docs.map { |d|
+      d.merge(_id: d[:name].downcase.gsub(/\s+/, "-"))
+    }
+  }
+
+  let(:sorted_ids) {
+    docs_with_ids.map { |d| d[:_id] }.sort
+  }
+
+  describe "#initialize" do
+    it "requires a name" do
+      expect { PouchDB::Database.new }.to raise_error(KeyError)
+    end
+  end
+
+  describe "#destroy" do
+    let(:database_name) { "throaway_test_database" }
+
+    async "calls the returned Promise's success handler" do
+      with_new_database do |db|
+        db.destroy.then do |response|
+          run_async do
+            expect(response["ok"]).to be(true)
+          end
+        end
+      end
+    end
+  end
+
+  describe "#put" do
+    async "creating a new Document calls the returned Promise's success handler" do
+      with_new_database do |db|
+        promise = db.put(docs_with_ids.first)
+
+        promise.then do |response|
+          run_async do
+            expect(response).not_to be_nil
+            expect(response["rev"]).not_to be_nil
+            expect(response["id"]).to eq("banana")
+          end
+        end
+      end
+    end
+
+    async "updating an existing Document calls the returned Promise's success handler" do
+      with_new_database do |db|
+        db.put(docs_with_ids.first).then do |created|
+          update = { name: "Bananananas" }
+
+          db.put(update, doc_id: created["id"], doc_rev: created["rev"]).then do |updated|
+            run_async do
+              expect(updated["rev"]).not_to eq(created["rev"])
+            end
+          end
+        end
+      end
+    end
+
+    async "calls the returned Promise's error handler" do
+      with_new_database(false) do |db|
+        db.put(docs.first).fail do |error|
+          run_async do
+            expect(error.message).to match(/_id is required/)
+          end
+        end
+      end
+    end
+  end
+
+  describe "#post" do
+    async "posting new Document generates an id" do
+      with_new_database do |db|
+        promise = db.post(docs.first)
+
+        promise.then do |response|
+          run_async do
+            expect(response["rev"]).not_to be_nil
+            expect(response["id"]).not_to be_nil
+          end
+        end
+      end
+    end
+  end
+
+  describe "#bulk_docs" do
+    async "generates ids if Documents don't have them" do
+      with_new_database do |db|
+        db.bulk_docs(docs).then do |response|
+          run_async do
+            expect(response.size).to eq(3)
+            expect(response.all? { |r| r["ok"] }).to be(true)
+            expect(response.map { |r| r["id"] }.none?(&:empty?)).to be(true)
+          end
+        end
+      end
+    end
+
+    async "keeps passed-in ids if Documents have them" do
+      with_new_database do |db|
+        db.bulk_docs(docs_with_ids).then do |response|
+          run_async do
+            expect(response.map { |r| r["id"] }.sort).to eq(sorted_ids)
+          end
+        end
+      end
+    end
+
+    async "updates sets of Documents" do
+      with_new_database do |db|
+        by_id = Hash[docs_with_ids.map { |d| [d[:_id], d] }]
+
+        db.bulk_docs(docs_with_ids).then do |created|
+          new_versions = created.map { |r|
+            d = by_id[r["id"]]
+            d.merge(_id: r["id"], _rev: r["rev"], name: d[:name].reverse)
+          }
+
+          created_by_id = Hash[created.map { |c| [c[:id], c] }]
+
+          db.bulk_docs(new_versions).then do |updated|
+            run_async do
+              updated.each do |ud|
+                cd = created_by_id[ud["id"]]
+                expect(ud["rev"]).not_to eq(cd["rev"])
+              end
+            end
+          end
+        end
+      end
+    end
+
+    async "mixes errors with successes (non-transactional)" do
+      with_new_database do |db|
+        db.put(docs_with_ids.first).then do
+          db.bulk_docs(docs_with_ids)
+        end.then do |response|
+          run_async do
+            errors = response.select { |r| r.is_a?(Exception) }
+            ok     = response - errors
+
+            expect(ok.size).to eq(2)
+            expect(errors.size).to eq(1)
+            expect(errors.first.message).to match(/conflict/)
+          end
+        end
+      end
+    end
+  end
+
+  describe "#get" do
+    async "calls the returned Promise's success handler with a Document" do
+      with_new_database do |db|
+        db.put(_id: "magic_object", contents: "It's Magic").then do
+          db.get("magic_object")
+        end.then do |doc|
+          run_async do
+            expect(doc["_id"]).to eq("magic_object")
+            expect(doc["contents"]).to eq("It's Magic")
+          end
+        end
+      end
+    end
+
+    async "correctly serializes/deserializes nested Hashes" do
+      with_new_database do |db|
+        promise = db.put(_id: "nasty_nested",
+                         contents: { foo: { bar: { baz: 1 } } })
+
+        promise.then do
+          db.get("nasty_nested")
+        end.then do |document|
+          run_async do
+            expect(document["contents"]["foo"]["bar"]["baz"]).to eq(1)
+          end
+        end
+      end
+    end
+  end
+
+  describe "#all_docs" do
+    async "fetches every Document by default" do
+      with_new_database do |db|
+        db.bulk_docs(docs_with_ids).then do
+          db.all_docs
+        end.then do |rows|
+          run_async do
+            expect(rows.size).to eq(sorted_ids.size)
+            expect(rows.map(&:id).sort).to eq(sorted_ids)
+            expect(rows.first.document).to eq({})
+          end
+        end
+      end
+    end
+
+    # dodecaphonic: This is non-exhaustive. I just want to check if
+    # passing options actually goes through.
+    describe "passing options along" do
+      async "allows for full Documents to come with a Row" do
+        with_new_database do |db|
+          db.bulk_docs(docs_with_ids).then do
+            db.all_docs(include_docs: true)
+          end.then do |rows|
+            run_async do
+              expect(rows.first.document["name"]).not_to be_empty
+            end
+          end
+        end
+      end
+
+      async "can limit the number of Rows to return" do
+        with_new_database do |db|
+          db.bulk_docs(docs_with_ids).then do
+            db.all_docs(key: "banana").then do |rows|
+              run_async do
+                expect(rows.size).to eq(1)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "#remove" do
+    let(:doc) { docs_with_ids.first }
+
+    describe "with a Document containing an _id and _rev" do
+      async "works correctly" do
+        with_new_database do |db|
+          db.put(doc).then do |created|
+            run_async do
+              to_remove = { _id: created["id"], _rev: created["rev"] }
+              db.remove(doc: to_remove)
+            end
+          end
+        end.then do |removed|
+          run_async do
+            expect(removed["ok"]).to be(true)
+          end
+        end
+      end
+
+      async "fails if _id is missing" do
+        with_new_database(false) do |db|
+          db.put(doc).then do |created|
+            run_async do
+              to_remove = { _rev: created["rev"] }
+              db.remove(doc: to_remove)
+            end
+          end
+        end.fail do |error|
+          run_async do
+            expect(error.message).to match(/missing/)
+          end
+        end
+      end
+
+      async "fails if _rev is missing" do
+        with_new_database(false) do |db|
+          db.put(doc).then do |created|
+            run_async do
+              to_remove = { _id: created["id"] }
+              db.remove(doc: to_remove)
+            end
+          end
+        end.fail do |error|
+          run_async do
+            expect(error.message).to match(/missing/)
+          end
+        end
+      end
+    end
+
+    describe "passing its _id and _rev explicitly" do
+      async "works correctly" do
+        with_new_database do |db|
+          db.put(doc).then do |created|
+            run_async do
+              db.remove(doc_id: created["id"], doc_rev: created["rev"])
+            end
+          end
+        end.then do |removed|
+          run_async do
+            expect(removed.ok).to be(true)
+          end
+        end
+      end
+
+      async "fails if _id is missing" do
+        with_new_database(false) do |db|
+          db.put(doc).then do |created|
+            run_async do
+              db.remove(doc_rev: created["rev"])
+            end
+          end
+        end.fail do |error|
+          run_async do
+            expect(error.message).to match(/missing/)
+          end
+        end
+      end
+
+      async "fails if _rev is missing" do
+        with_new_database(false) do |db|
+          db.put(doc).then do |created|
+            run_async do
+              db.remove(doc_id: created["id"])
+            end
+          end
+        end.fail do |error|
+          run_async do
+            expect(error.message).to match(/missing/)
+          end
+        end
+      end
+    end
+  end
+end