fauna 0.2.6 → 1.1.0

data/lib/fauna/set.rb

@@ -0,0 +1,184 @@
+module Fauna
+  class Set
+
+    attr_reader :ref
+
+    def initialize(ref)
+      @ref = ref
+    end
+
+    def page(pagination = {})
+      SetPage.find(ref, {}, pagination)
+    end
+
+    def events(pagination = {})
+      EventsPage.find("#{ref}/events", {}, pagination)
+    end
+
+    # query DSL
+
+    def self.query(&block)
+      module_eval(&block)
+    end
+
+    def self.union(*args)
+      QuerySet.new('union', *args)
+    end
+
+    def self.intersection(*args)
+      QuerySet.new('intersection', *args)
+    end
+
+    def self.difference(*args)
+      QuerySet.new('difference', *args)
+    end
+
+    def self.merge(*args)
+      QuerySet.new('merge', *args)
+    end
+
+    def self.join(*args)
+      QuerySet.new('join', *args)
+    end
+
+    def self.match(*args)
+      QuerySet.new('match', *args)
+    end
+
+    # although each is handled via the query DSL, it might make more
+    # sense to add it as a modifier on Set instances, similar to events.
+
+    def self.each(*args)
+      EachSet.new(*args)
+    end
+  end
+
+  class QuerySet < Set
+    def initialize(function, *params)
+      @function = function
+      @params = params
+    end
+
+    def param_strings
+      @param_strings ||= @params.map do |p|
+        if p.respond_to? :expr
+          p.expr
+        elsif p.respond_to? :ref
+          p.ref
+        else
+          p
+        end
+      end
+    end
+
+    def expr
+      @expr ||= "#{@function}(#{param_strings.join ','})"
+    end
+
+    def ref
+      "query?q=#{expr}"
+    end
+
+    def page(pagination = {})
+      SetPage.find('query', { 'q' => expr }, pagination)
+    end
+
+    def events(pagination = {})
+      EventsPage.find("query", { 'q' => "events(#{expr})" }, pagination)
+    end
+  end
+
+  class EachSet < QuerySet
+    def initialize(*params)
+      super('each', *params)
+    end
+
+    def events(pagination = {})
+      query = param_strings.first
+      subqueries = param_strings.drop(1).join ','
+      EventsPage.find("query", { 'q' => "each(events(#{query}),#{subqueries})" }, pagination)
+    end
+  end
+
+  class CustomSet < Set
+    def add(resource)
+      self.class.add(self, resource)
+    end
+
+    def remove(resource)
+      self.class.remove(self, resource)
+    end
+
+    def self.add(set, resource)
+      set = set.ref if set.respond_to? :ref
+      resource = resource.ref if resource.respond_to? :ref
+      Fauna::Client.put("#{set}/#{resource}")
+    end
+
+    def self.remove(set, resource)
+      set = set.ref if set.respond_to? :ref
+      resource = resource.ref if resource.respond_to? :ref
+      Fauna::Client.delete("#{set}/#{resource}")
+    end
+  end
+
+  class SetPage < Fauna::Resource
+    include Enumerable
+
+    def refs
+      @refs ||= struct['resources']
+    end
+
+    def each(&block)
+      refs.each(&block)
+    end
+
+    def empty?
+      refs.empty?
+    end
+
+    def length; refs.length end
+    def size; refs.size end
+  end
+
+  class EventsPage < Fauna::Resource
+    include Enumerable
+
+    def events
+      @events ||= struct['events'].map { |e| Event.new(e) }
+    end
+
+    def each(&block)
+      events.each(&block)
+    end
+
+    def empty?
+      events.empty?
+    end
+
+    def length; events.length end
+    def size; events.size end
+  end
+
+  class Event
+    def initialize(attrs)
+      @attrs = attrs
+    end
+
+    def ts
+      Fauna.time_from_usecs(@attrs['ts'])
+    end
+
+    def resource
+      @attrs['resource']
+    end
+
+    def set
+      @attrs['set']
+    end
+
+    def action
+      @attrs['action']
+    end
+  end
+end

data/lib/fauna/util.rb

@@ -0,0 +1,19 @@
+module Fauna
+  def self.stringify_keys!(hash)
+    hash.keys.each do |k|
+      hash[k.to_s] = hash.delete k
+    end
+  end
+
+  def self.stringify_keys(hash)
+    stringify_keys!(hash.dup)
+  end
+
+  def self.time_from_usecs(microseconds)
+    Time.at(microseconds/1_000_000, microseconds % 1_000_000)
+  end
+
+  def self.usecs_from_time(time)
+    time.to_i * 1000000 + time.usec
+  end
+end

data/lib/tasks/fauna.rake

@@ -2,10 +2,70 @@
 task :environment
 
 namespace :fauna do
-  desc "Migrate your fauna database to the latest version"
+  desc "Migrate your Fauna database to the latest version of your schema"
   task :migrate => :environment do
+    puts "Migrating #{Rails.env} Fauna database schema"
     Fauna::Client.context(Fauna.connection) do
       Fauna.migrate_schema!
     end
   end
+
+  desc "Completely reset your Fauna database"
+  task :reset => :environment do
+    if Rails.env.production?
+      puts "Won't reset #{Rails.env} Fauna database"
+    else
+      Fauna::Client.context(Fauna.root_connection) do
+        puts "Resetting #{Rails.env} Fauna database"
+        Fauna::Client.delete("everything")
+      end
+      Fauna.auth!
+    end
+  end
+
+  desc "Dump the contents of your Fauna database to 'test/fixtures/fauna'"
+  task :dump => :environment do
+    puts "Dumping #{Rails.env} Fauna database contents to #{Fauna::FIXTURES_DIR}"
+    Fauna::Client.context(Fauna.connection) do
+      FileUtils.mkdir_p(Fauna::FIXTURES_DIR)
+
+      class_configs = Fauna.connection.get("/classes")["references"] || {}
+      class_configs["users"] = nil
+
+      Dir.chdir(Fauna::FIXTURES_DIR) do
+        class_configs.each do |ref, value|
+          class_name = ref[0..-8]
+          FileUtils.mkdir_p(class_name)
+
+          Dir.chdir(class_name) do
+            # FIXME shouldn't round trip JSON
+            File.open("config.json", "w") { |f| f.write(value.to_json)} if value
+            (Fauna.connection.get(class_name)["references"] || {}).each do |ref, value|
+              File.open("#{ref.split("/").last}.json", "w") { |f| f.write(value.to_json) }
+            end
+          end
+        end
+      end
+    end
+  end
+
+  desc "Load the contents of your Fauna database"
+  task :load => :environment do
+    puts "Loading #{Rails.env} Fauna database contents from #{Fauna::FIXTURES_DIR}"
+    Fauna::Client.context(Fauna.connection) do
+      Dir.chdir(Fauna::FIXTURES_DIR) do
+        Dir["**/*.json"].map do |filename|
+          value = JSON.parse(File.open(filename) { |f| f.read })
+          begin
+            Fauna.connection.put(value["ref"], value)
+          rescue Fauna::Connection::NotFound
+            Fauna.connection.post(value["ref"].split("/")[0..-2].join("/"), value)
+          end
+        end
+      end
+    end
+  end
+
 end
+
+task :test => ["fauna:reset", "fauna:migrate", "fauna:load"]

data/test/class_test.rb

@@ -1,111 +1,82 @@
 require File.expand_path('../test_helper', __FILE__)
 
-class ClassTest < ActiveModel::TestCase
-  include ActiveModel::Lint::Tests
+class InstanceTest < MiniTest::Unit::TestCase
 
   def setup
     super
-    @model = Pig.new
-  end
-
-  def test_class_name
-    assert_equal 'classes/pigs', Pig.fauna_class
-    assert_equal 'classes/pigs/config', Pig.config_ref
-  end
-
-  def test_class_save
-    Pig.update_data! do |data|
-      data["class_visited"] = true
-    end
-    assert Pig.data["class_visited"]
+    @model = Fauna::Resource.new('classes/pigs')
   end
 
   def test_create
-    pig = Pig.create(:visited => false)
-    assert_equal false, pig.visited
+    pig = Fauna::Resource.create 'classes/pigs', :data => { :visited => true }
+    assert_equal true, pig.data['visited']
     assert pig.persisted?
     assert pig.ref
   end
 
   def test_all
-    pig = Pig.create
-    assert Pig.all.resources.include?(pig)
+    pig = Fauna::Resource.create 'classes/pigs'
+    assert Fauna::Set.new('classes/pigs/instances').page.include?(pig.ref)
   end
 
   def test_save
-    pig = Pig.new
+    pig = Fauna::Resource.new 'classes/pigs'
     pig.save
     assert pig.persisted?
   end
 
   def test_update
-    pig = Pig.new(:visited => false)
+    pig = Fauna::Resource.new 'classes/pigs', :data => { :visited => false }
     pig.save
-    pig.update(:visited => true)
-    assert pig.visited
-  end
-
-  def test_changes
-    pig = Pig.new(:visited => true)
+    pig.data['visited'] = true
     pig.save
-    pig.update(:visited => false)
-    assert_equal pig.changes.page.events.length, 2
-  end
 
-  def test_find_by_ref
-    pig = Pig.create
-    pig1 = Pig.find_by_ref(pig.ref)
-    assert_equal pig.ref, pig1.ref
-    assert pig1.persisted?
+    assert pig.data['visited']
+    assert_equal pig.events.length, 2
   end
 
-  def test_find_by_unique_id
-    pig = Pig.create(:unique_id => "the pig")
-    pig1 = Pig.find_by_unique_id("the pig")
+  def test_find
+    pig = Fauna::Resource.create 'classes/pigs'
+    pig1 = Fauna::Resource.find(pig.ref)
     assert_equal pig.ref, pig1.ref
     assert pig1.persisted?
   end
 
-  def test_find
-    pig = Pig.create
-
-    pig1 = Pig.find(pig.id)
+  def test_find_by_constraint
+    pig = Fauna::Resource.create 'classes/pigs', :constraints => { :name => "the pig" }
+    pig1 = Fauna::Resource.find('classes/pigs/constraints/name/the%20pig')
     assert_equal pig.ref, pig1.ref
     assert pig1.persisted?
-
-    pig2 = Pig.find_by_id(pig.id)
-    assert_equal pig.ref, pig2.ref
-    assert pig2.persisted?
   end
 
-  def test_destroy
-    pig = Pig.create
-    pig.destroy
-    assert pig.destroyed?
+  def test_delete
+    pig = Fauna::Resource.create 'classes/pigs'
+    pig.delete
+    assert pig.deleted?
   end
 
   def test_ts
-    pig = Pig.create
+    pig = Fauna::Resource.create 'classes/pigs'
     assert_instance_of(Time, pig.ts)
 
-    pig = Pig.new
+    pig = Fauna::Resource.new 'classes/pigs'
     assert_nil pig.ts
   end
 
   def test_ts_assignment
     time = Time.at(0)
-    pig = Pig.create
+    pig = Fauna::Resource.create 'classes/pigs'
     pig.ts = time
 
-    Fauna::Client.context(@publisher_connection) do
-      pig2 = Pig.find(pig.id)
-      assert_not_equal time, pig2.ts
+    Fauna::Client.context(@server_connection) do
+      pig2 = Fauna::Resource.find(pig.ref)
+      assert(time != pig2.ts)
     end
 
     pig.save
 
-    Fauna::Client.context(@publisher_connection) do
-      pig3 = Pig.find(pig.id)
+    Fauna::Client.context(@server_connection) do
+      pig3 = Fauna::Resource.find(pig.ref)
       # Waiting on server support for timestamp overrides
       # assert_equal time, pig3.ts
     end

data/test/client_test.rb

@@ -6,17 +6,17 @@ class ClientTest < MiniTest::Unit::TestCase
     @attributes = { "name" => "Princess Eilonwy", "email" => email, "password" => password }
   end
 
-  def test_publisher_context
-    Fauna::Client.context(@publisher_connection) do
+  def test_database_context
+    Fauna::Client.context(@server_connection) do
       user = Fauna::Client.post("users", @attributes)
-      user = Fauna::Client.get(user.ref)
-      Fauna::Client.delete(user.ref)
+      user = Fauna::Client.get(user['ref'])
+      Fauna::Client.delete(user['ref'])
     end
   end
 
   def test_client_context
     Fauna::Client.context(@client_connection) do
-      user = Fauna::Client.post("users", @attributes)
+      user = Fauna::Resource.create("users", @attributes)
       Fauna::Client.context(@client_connection) do
         assert_raises(Fauna::Connection::Unauthorized) do
           Fauna::Client.get(user.ref)
@@ -26,7 +26,7 @@ class ClientTest < MiniTest::Unit::TestCase
   end
 
   def test_token_context
-    Fauna::Client.context(@publisher_connection) do
+    Fauna::Client.context(@server_connection) do
       Fauna::Client.post("users", @attributes)
     end
 
@@ -34,28 +34,28 @@ class ClientTest < MiniTest::Unit::TestCase
       @token = Fauna::Client.post("tokens", @attributes)
     end
 
-    Fauna::Client.context(Fauna::Connection.new(:token => @token.token)) do
-      user = Fauna::Client.get(@token.user)
-      Fauna::Client.delete(user.ref)
+    Fauna::Client.context(Fauna::Connection.new(:secret => @token['secret'], :domain => @server_connection.domain, :scheme => @server_connection.scheme)) do
+      user = Fauna::Client.get(@token['user'])
+      Fauna::Client.delete(user['ref'])
     end
   end
 
   def test_caching_1
-    Fauna::Client.context(@publisher_connection) do
-      @user = Fauna::Client.post("users", @attributes)
-      @publisher_connection.expects(:get).never
-      Fauna::Client.get(@user.ref)
+    Fauna::Client.context(@server_connection) do
+      user = Fauna::Client.post("users", @attributes)
+      @server_connection.expects(:get).never
+      Fauna::Client.get(user['ref'])
     end
   end
 
   def test_caching_2
     Fauna::Client.context(@client_connection) do
-      @user = Fauna::Client.post("users", @attributes)
+      user = Fauna::Client.post("users", @attributes)
 
-      Fauna::Client.context(@publisher_connection) do
-        Fauna::Client.get(@user.ref)
-        @publisher_connection.expects(:get).never
-        Fauna::Client.get(@user.ref)
+      Fauna::Client.context(@server_connection) do
+        Fauna::Client.get(user['ref'])
+        @server_connection.expects(:get).never
+        Fauna::Client.get(user['ref'])
       end
     end
   end