fauna 1.3.4 → 2.0.0

data/lib/fauna/set.rb

@@ -1,240 +0,0 @@
-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
-      if @function == 'match'
-        # Escape strings for match values
-        @params = @params[0..1] + @params[2..-1].collect do |p|
-          p.is_a?(String) ? p.inspect : p
-        end
-      end
-
-      @param_strings ||= @params.collect do |p|
-        if p.respond_to? :expr
-          p.expr
-        elsif p.respond_to? :ref
-          p.ref
-        else
-          p.to_s
-        end
-      end
-    end
-
-    def expr
-      @expr ||= "#{@function}(#{param_strings.join(',')})"
-    end
-
-    def ref
-      "queries?q=#{expr}"
-    end
-
-    def page(pagination = {})
-      SetPage.find('queries', { 'q' => expr }, pagination)
-    end
-
-    def events(pagination = {})
-      EventsPage.find('queries', { '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('queries', { 'q' => "each(events(#{query}),#{subqueries})" }, pagination)
-    end
-  end
-
-  class CustomSet < Set
-    def add(resource, time = nil)
-      self.class.add(self, resource, time)
-    end
-
-    def remove(resource, time = nil)
-      self.class.remove(self, resource, time)
-    end
-
-    def self.add(set, resource, time = nil)
-      set = set.ref if set.respond_to? :ref
-      resource = resource.ref if resource.respond_to? :ref
-      if time
-        Fauna::Client.put("#{set}/#{resource}/events/#{Fauna.usecs_from_time(time)}/create")
-      else
-        Fauna::Client.put("#{set}/#{resource}")
-      end
-    end
-
-    def self.remove(set, resource, time = nil)
-      set = set.ref if set.respond_to? :ref
-      resource = resource.ref if resource.respond_to? :ref
-      if time
-        Fauna::Client.put("#{set}/#{resource}/events/#{Fauna.usecs_from_time(time)}/delete")
-      else
-        Fauna::Client.delete("#{set}/#{resource}")
-      end
-    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 fauna_count
-      struct['count']
-    end
-
-    def length
-      refs.length
-    end
-
-    def size
-      refs.size
-    end
-  end
-
-  class EventsPage < Fauna::Resource
-    include Enumerable
-
-    def events
-      @events ||= struct['events'].collect { |e| Event.new(e) }
-    end
-
-    def each(&block)
-      events.each(&block)
-    end
-
-    def empty?
-      events.empty?
-    end
-
-    def fauna_count
-      struct['count']
-    end
-
-    def length
-      events.length
-    end
-
-    def size
-      events.size
-    end
-  end
-
-  class Event
-    def initialize(attrs)
-      @attrs = attrs
-    end
-
-    def ref
-      "#{resource}/events/#{@attrs['ts']}/#{action}"
-    end
-
-    def event_ref
-      if set == resource
-        "#{resource}/events/#{@attrs['ts']}/#{action}"
-      else
-        "#{set}/#{resource}/events/#{@attrs['ts']}/#{action}"
-      end
-    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
-
-    def save
-      Fauna::Client.put(event_ref) if editable?
-    end
-
-    def delete
-      Fauna::Client.delete(event_ref) if editable?
-    end
-
-    def editable?
-      %w(create delete).include? action
-    end
-  end
-end

data/lib/tasks/fauna.rake

@@ -1,71 +0,0 @@
-
-task :environment
-
-namespace :fauna do
-  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 |inner_ref, inner_value|
-              File.open("#{inner_ref.split('/').last}.json", 'w') { |f| f.write(inner_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'].collect 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,65 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class ClassTest < MiniTest::Unit::TestCase
-  def setup
-    super
-    @model = Fauna::Resource.new('classes/pigs')
-  end
-
-  def test_new
-    settings = Fauna::Resource.new('settings', :ref => 'settings/12345678', :email => 'test@test.com')
-    user = Fauna::Resource.new('users', :ref => 'users/87654321')
-    assert user.data.object_id != settings.data.object_id
-  end
-
-  def test_create
-    pig = Fauna::Resource.create 'classes/pigs', :data => { :visited => true }
-    assert_equal true, pig.data['visited']
-    assert pig.persisted?
-    assert pig.ref
-    refute pig.deleted?
-    refute_nil pig.deleted?
-  end
-
-  def test_all
-    pig = Fauna::Resource.create 'classes/pigs'
-    assert Fauna::Set.new('classes/pigs/instances').page.include?(pig.ref)
-  end
-
-  def test_save
-    pig = Fauna::Resource.new 'classes/pigs'
-    pig.save
-    assert pig.persisted?
-  end
-
-  def test_update
-    pig = Fauna::Resource.new 'classes/pigs', :data => { :visited => false }
-    pig.save
-    pig.data['visited'] = true
-    pig.save
-
-    assert pig.data['visited']
-    assert_equal pig.events.length, 2
-  end
-
-  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_delete
-    pig = Fauna::Resource.create 'classes/pigs'
-    pig.delete
-    assert pig.deleted?
-  end
-
-  def test_ts
-    pig = Fauna::Resource.create 'classes/pigs'
-    assert_instance_of(Time, pig.ts)
-
-    pig = Fauna::Resource.new 'classes/pigs'
-    assert_nil pig.ts
-  end
-end

data/test/client_test.rb

@@ -1,63 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class ClientTest < MiniTest::Unit::TestCase
-  def setup
-    super
-    @attributes = { 'name' => 'Princess Eilonwy', 'email' => email, 'password' => password }
-  end
-
-  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'])
-    end
-  end
-
-  def test_client_context
-    Fauna::Client.context(@client_connection) do
-      Fauna::Resource.create('users', @attributes)
-
-      Fauna::Client.context(@client_connection) do
-        assert_raises(Fauna::Connection::PermissionDenied) do
-          Fauna::Resource.create('classes/posts', @attributes)
-        end
-      end
-    end
-  end
-
-  def test_token_context
-    Fauna::Client.context(@server_connection) do
-      Fauna::Client.post('users', @attributes)
-    end
-
-    Fauna::Client.context(@client_connection) do
-      @token = Fauna::Client.post('tokens', @attributes)
-    end
-
-    Fauna::Client.context(Fauna::Connection.new(:secret => @token['secret'], :domain => @server_connection.domain, :scheme => @server_connection.scheme, :port => @server_connection.port)) do
-      user = Fauna::Client.get(@token['user'])
-      Fauna::Client.delete(user['ref'])
-    end
-  end
-
-  def test_caching_1
-    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)
-
-      Fauna::Client.context(@server_connection) do
-        Fauna::Client.get(user['ref'])
-        @server_connection.expects(:get).never
-        Fauna::Client.get(user['ref'])
-      end
-    end
-  end
-end

data/test/connection_test.rb

@@ -1,66 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class ConnectionTest < MiniTest::Unit::TestCase
-  def setup
-    super
-    @attributes = { 'name' => 'Arawn', 'email' => email, 'password' => password }
-  end
-
-  def test_get
-    @server_connection.get('users/instances')
-  end
-
-  def test_get_with_invalid_key
-    connection = Fauna::Connection.new(:secret => 'bad_key', :domain => @server_connection.domain, :scheme => @server_connection.scheme, :port => @server_connection.port)
-    assert_raises(Fauna::Connection::Unauthorized) do
-      connection.get('users/instances')
-    end
-  end
-
-  def test_post
-    @client_connection.post('users', @attributes)['resource']
-  end
-
-  def test_put
-    user = @server_connection.post('users', @attributes)['resource']
-    user = @server_connection.put(user['ref'], :data => { :pockets => 2 })['resource']
-
-    assert_equal 2, user['data']['pockets']
-
-    user = @server_connection.put(user['ref'], :data => { :apples => 3 })['resource']
-
-    assert_nil user['data']['pockets']
-    assert_equal 3, user['data']['apples']
-  end
-
-  def test_patch
-    user = @server_connection.post('users', @attributes)['resource']
-    user = @server_connection.patch(user['ref'], :data => { :pockets => 2 })['resource']
-    user = @server_connection.patch(user['ref'], :data => { :apples => 3 })['resource']
-
-    assert_equal 2, user['data']['pockets']
-    assert_equal 3, user['data']['apples']
-  end
-
-  def test_delete
-    user = @server_connection.post('users', @attributes)['resource']
-    @server_connection.delete(user['ref'])
-    assert_raises(Fauna::Connection::NotFound) do
-      @server_connection.get(user['ref'])
-    end
-  end
-
-  # def test_retry
-  #   class << RestClient::Request
-  #     alias __execute__ execute
-  #   end
-
-  #   class << RestClient::Request
-  #     def execute(*args, &block)
-  #       alias execute __execute__
-  #       raise RestClient::ServerBrokeConnection
-  #     end
-  #   end
-  #   @server_connection.get('users/instances')
-  # end
-end