fauna 0.2.6 → 1.1.0

data/lib/fauna/cache.rb

@@ -0,0 +1,58 @@
+module Fauna
+  class NoContextError < StandardError
+  end
+
+  class Cache
+    attr_reader :connection
+
+    def initialize(connection)
+      raise ArgumentError, "Connection cannot be nil" unless connection
+      @cache = {}
+      @connection = connection
+    end
+
+    def get(ref, query = {}, pagination = {})
+      res = @cache[ref]
+      res = @cache[res] if res.is_a? String # non-canonical refs point to their canonical refs.
+
+      if res.nil?
+        response = @connection.get(ref, query.merge(pagination))
+        update_cache(ref, response)
+        res = response['resource']
+      end
+
+      res
+    end
+
+    def post(ref, data)
+      res = @connection.post(ref, data)
+      update_cache(ref, res)
+      res['resource']
+    end
+
+    def put(ref, data)
+      res = @connection.put(ref, data)
+      if res['resource']
+        update_cache(ref, res)
+        res['resource']
+      end
+    end
+
+    def delete(ref, data)
+      @connection.delete(ref, data)
+      @cache.delete(ref)
+      nil
+    end
+
+    private
+
+    def update_cache(ref, res)
+      # FIXME Implement set range caching
+      if (res['resource']['class'] != "resources" && res['resource']['class'] != "events")
+        @cache[ref] = res['resource']['ref'] # store the non-canonical ref as a pointer to the real one.
+        @cache[res['resource']['ref']] = res['resource']
+      end
+      @cache.merge!(res['references'] || {})
+    end
+  end
+end

data/lib/fauna/client.rb

@@ -1,62 +1,5 @@
 module Fauna
   class Client
-
-    class NoContextError < StandardError
-    end
-
-    class CachingContext
-      attr_reader :connection
-
-      def initialize(connection)
-        raise ArgumentError, "Connection cannot be nil" unless connection
-        @cache = {}
-        @connection = connection
-      end
-
-      def get(ref, query = nil)
-        if @cache[ref]
-          Resource.alloc(@cache[ref])
-        else
-          res = @connection.get(ref, query)
-          cohere(ref, res)
-          Resource.alloc(res['resource'])
-        end
-      end
-
-      def post(ref, data)
-        res = @connection.post(ref, filter(data))
-        cohere(ref, res)
-        Resource.alloc(res['resource'])
-      end
-
-      def put(ref, data)
-        res = @connection.put(ref, filter(data))
-        cohere(ref, res)
-        Resource.alloc(res['resource'])
-      end
-
-      def delete(ref, data)
-        @connection.delete(ref, data)
-        @cache.delete(ref)
-        nil
-      end
-
-      private
-
-      def filter(data)
-        data.select {|_, v| v }
-      end
-
-      def cohere(ref, res)
-        # FIXME Implement set range caching
-        if (res['resource']['class'] != "sets")
-          @cache[ref] = res['resource'] if ref =~ %r{^users/self}
-          @cache[res['resource']['ref']] = res['resource']
-          @cache.merge!(res['references'] || {})
-        end
-      end
-    end
-
     def self.context(connection)
       push_context(connection)
       yield
@@ -65,30 +8,34 @@ module Fauna
     end
 
     def self.push_context(connection)
-      stack.push(CachingContext.new(connection))
+      stack.push(Fauna::Cache.new(connection))
     end
 
     def self.pop_context
       stack.pop
     end
 
-    def self.get(ref, query = nil)
-      this.get(ref, query)
+    def self.reset_context
+      stack = []
+    end
+
+    def self.get(ref, query = {}, pagination = {})
+      connection.get(ref, query, pagination)
     end
 
-    def self.post(ref, data = nil)
-      this.post(ref, data)
+    def self.post(ref, data = {})
+      connection.post(ref, data)
     end
 
-    def self.put(ref, data = nil)
-      this.put(ref, data)
+    def self.put(ref, data = {})
+      connection.put(ref, data)
     end
 
-    def self.delete(ref, data = nil)
-      this.delete(ref, data)
+    def self.delete(ref, data = {})
+      connection.delete(ref, data)
     end
 
-    def self.this
+    def self.connection
       stack.last or raise NoContextError, "You must be within a Fauna::Client.context block to perform operations."
     end
 

data/lib/fauna/connection.rb

@@ -33,9 +33,12 @@ module Fauna
       end
     end
 
+    attr_reader :domain, :scheme
+
     def initialize(params={})
       @logger = params[:logger] || nil
-      @api_version = params[:version] || "v1/"
+      @domain = params[:domain] || "rest1.fauna.org"
+      @scheme = params[:scheme] || "https"
 
       if ENV["FAUNA_DEBUG"]
         @logger = Logger.new(STDERR)
@@ -44,38 +47,32 @@ module Fauna
 
       # Check credentials from least to most privileged, in case
       # multiple were provided
-      @credentials = if params[:token]
-        CGI.escape(@key = params[:token])
-      elsif params[:client_key]
-        CGI.escape(params[:client_key])
-      elsif params[:publisher_key]
-        CGI.escape(params[:publisher_key])
-      elsif params[:email] and params[:password]
-        "#{CGI.escape(params[:email])}:#{CGI.escape(params[:password])}"
+      @credentials = if params[:secret]
+        CGI.escape(params[:secret])
       else
         raise TypeError
       end
     rescue TypeError
-      raise ArgumentError, "Credentials must be in the form of a hash containing either :publisher_key, :client_key, or :token, or both :email and :password."
+      raise ArgumentError, "Invalid secret."
     end
 
-    def get(ref, query = nil)
+    def get(ref, query = {})
       parse(execute(:get, ref, nil, query))
     end
 
-    def post(ref, data = nil)
+    def post(ref, data = {})
       parse(execute(:post, ref, data))
     end
 
-    def put(ref, data = nil)
+    def put(ref, data = {})
       parse(execute(:put, ref, data))
     end
 
-    def patch(ref, data = nil)
+    def patch(ref, data = {})
       parse(execute(:patch, ref, data))
     end
 
-    def delete(ref, data = nil)
+    def delete(ref, data = {})
       execute(:delete, ref, data)
       nil
     end
@@ -83,12 +80,8 @@ module Fauna
     private
 
     def parse(response)
-      obj = if response.empty?
-        {}
-      else
-        JSON.parse(response)
-      end
-      obj.merge!("headers" => response.headers.stringify_keys)
+      obj = response.empty? ? {} : JSON.parse(response)
+      obj.merge! "headers" => Fauna.stringify_keys(response.headers)
       obj
     end
 
@@ -101,7 +94,7 @@ module Fauna
     end
 
     def query_string_for_logging(query)
-      if query
+      if query && !query.empty?
         "?" + query.map do |k,v|
           "#{k}=#{v}"
         end.join("&")
@@ -111,17 +104,18 @@ module Fauna
     def execute(action, ref, data = nil, query = nil)
       args = { :method => action, :url => url(ref), :headers => {} }
 
-      if query
+      if query && !query.empty?
         args[:headers].merge! :params => query
       end
 
-      if data
+      if data && !data.empty?
         args[:headers].merge! :content_type => :json
         args.merge! :payload => data.to_json
       end
 
       if @logger
-        log(2) { "Fauna #{action.to_s.upcase}(\"#{ref}#{query_string_for_logging(query)}\")" }
+        log(2) { "Fauna #{action.to_s.upcase} /#{ref}#{query_string_for_logging(query)}" }
+        log(4) { "Credentials: #{@credentials}" } if @debug
         log(4) { "Request JSON: #{JSON.pretty_generate(data)}" } if @debug && data
 
         t0, r0 = Process.times, Time.now
@@ -131,7 +125,7 @@ module Fauna
           real = r1.to_f - r0.to_f
           cpu = (t1.utime - t0.utime) + (t1.stime - t0.stime) + (t1.cutime - t0.cutime) + (t1.cstime - t0.cstime)
           log(4) { ["Response headers: #{JSON.pretty_generate(res.headers)}", "Response JSON: #{res}"] } if @debug
-          log(4) { "Response (#{res.code}): API processing #{res.headers[:x_time_total]}ms, network latency #{((real - cpu)*1000).to_i}ms, local processing #{(cpu*1000).to_i}ms" }
+          log(4) { "Response (#{res.code}): API processing #{res.headers[:x_http_request_processing_time]}ms, network latency #{((real - cpu)*1000).to_i}ms, local processing #{(cpu*1000).to_i}ms" }
 
           HANDLER.call(res)
         end
@@ -141,7 +135,7 @@ module Fauna
     end
 
     def url(ref)
-      "https://#{@credentials}@rest.fauna.org/#{@api_version}#{ref}"
+      "#{@scheme}://#{@credentials}@#{@domain}/#{ref}"
     end
   end
 end

data/lib/fauna/provided_classes.rb

@@ -0,0 +1,39 @@
+module Fauna
+  class NamedResource < Fauna::Resource
+    def name; struct['name'] end
+
+    def ref; super || "#{fauna_class}/#{name}" end
+
+    private
+
+    def post
+      raise Invalid, "Cannot POST to named resource."
+    end
+  end
+
+  class Database < Fauna::NamedResource
+    def self.new(*args); super('databases', *args) end
+  end
+
+  class Class < Fauna::NamedResource
+    def self.new(*args); super('classes', *args) end
+  end
+
+  class Key < Fauna::Resource
+    def self.new(*args); super('keys', *args) end
+
+    def database
+      struct['database'] || ref.split('/keys').first
+    end
+
+    private
+
+    def post
+      Fauna::Client.post("#{database}/keys", struct)
+    end
+  end
+
+  class Token < Fauna::Resource
+    def self.new(*args); super('tokens', *args) end
+  end
+end

data/lib/fauna/rails.rb

@@ -9,9 +9,10 @@ if defined?(Rails)
 
     @silent = false
 
-    CONFIG_FILE = "#{Rails.root}/config/fauna.yml"
+    CONFIG_FILE = "#{Rails.root}/fauna.yml"
     LOCAL_CONFIG_FILE = "#{ENV["HOME"]}/.fauna.yml"
     APP_NAME = Rails.application.class.name.split("::").first.underscore
+    FIXTURES_DIR = "#{Rails.root}/test/fixtures/fauna"
 
     def self.auth!
       if File.exist? CONFIG_FILE
@@ -22,8 +23,8 @@ if defined?(Rails)
         end
 
         if !@silent
-          if credentials["publisher_key"]
-            STDERR.puts ">> Using Fauna publisher key #{credentials["publisher_key"].inspect} for #{APP_NAME.inspect}."
+          if credentials["server_key"]
+            STDERR.puts ">> Using Fauna server key #{credentials["server_key"].inspect} for #{APP_NAME.inspect}."
           else
             STDERR.puts ">> Using Fauna account #{credentials["email"].inspect} for #{APP_NAME.inspect}."
           end
@@ -31,18 +32,18 @@ if defined?(Rails)
           STDERR.puts ">> You can change this in config/fauna.yml or ~/.fauna.yml."
         end
 
-        if credentials["publisher_key"]
-          publisher_key = credentials["publisher_key"]
+        if credentials["server_key"]
+          server_key = credentials["server_key"]
         else
           self.root_connection = Connection.new(
             :email => credentials["email"],
             :password => credentials["password"],
           :logger => Rails.logger)
 
-          publisher_key = root_connection.post("keys/publisher")["resource"]["key"]
+          server_key = root_connection.post("keys", "role" => "server")["resource"]["key"]
         end
 
-        self.connection = Connection.new(publisher_key: publisher_key, logger: Rails.logger)
+        self.connection = Connection.new(server_key: server_key, logger: Rails.logger)
       else
         if !@silent
           STDERR.puts ">> Fauna account not configured. You can add one in config/fauna.yml."
@@ -74,7 +75,6 @@ if defined?(Rails)
     def self.install_reload_callback!
       if defined? ActionDispatch::Reloader
         ActionDispatch::Reloader.to_prepare do
-          Fauna.configure_schema!
           Fauna.install_around_filter!
         end
       end
@@ -89,10 +89,30 @@ if defined?(Rails)
         end
       end
     end
+
+    def self.install_test_helper!
+      if defined? ActiveSupport::TestCase
+        ActiveSupport::TestCase.setup do
+          Fauna::Client.push_context(Fauna.connection)
+        end
+
+        ActiveSupport::TestCase.teardown do
+          Fauna::Client.pop_context
+        end
+      end
+    end
+
+    def self.install_console_helper!
+      Rails.application.class.console do
+        Fauna::Client.push_context(Fauna.connection)
+      end
+    end
   end
 
   Fauna.auth!
   Fauna.install_around_filter!
   Fauna.install_reload_callback!
   Fauna.install_inflections!
+  Fauna.install_test_helper!
+  Fauna.install_console_helper!
 end

data/lib/fauna/resource.rb

@@ -1,123 +1,66 @@
 module Fauna
   class Resource
-
-    def self.fields; @fields ||= [] end
-    def self.event_sets; @event_sets ||= [] end
-    def self.references; @references ||= [] end
-
-    # config DSL
-
-    class << self
-      attr_accessor :fauna_class
-
-      def fauna_class
-        @fauna_class or raise MissingMigration, "Class #{name} has not been added to Fauna.schema."
+    def self.resource_subclass(fauna_class)
+      case fauna_class
+      when 'databases' then Fauna::Database
+      when 'classes' then Fauna::Class
+      when 'keys' then Fauna::Key
+      when 'resources' then Fauna::SetPage
+      when 'events' then Fauna::EventsPage
+      else Fauna::Resource
       end
-
-      private
-
-      def field(*names)
-        names.each do |name|
-          name = name.to_s
-          fields << name
-          fields.uniq!
-
-          define_method(name) { data[name] }
-          define_method("#{name}=") { |value| data[name] = value }
-        end
-      end
-
-      def event_set(*names)
-        args = names.last.is_a?(Hash) ? names.pop : {}
-
-        names.each do |name|
-          set_name = args[:internal] ? name.to_s : "sets/#{name}"
-          event_sets << set_name
-          event_sets.uniq!
-
-          define_method(name.to_s) { Fauna::CustomEventSet.new("#{ref}/#{set_name}") }
-        end
-      end
-
-      def reference(*names)
-        names.each do |name|
-          name = name.to_s
-          references << name
-          references.uniq!
-
-          define_method("#{name}_ref") { references[name] }
-          define_method("#{name}_ref=") { |ref| (ref.nil? || ref.empty?) ? references.delete(name) : references[name] = ref }
-
-          define_method(name) { Fauna::Resource.find_by_ref(references[name]) if references[name] }
-          define_method("#{name}=") { |obj| obj.nil? ? references.delete(name) : references[name] = obj.ref }
-        end
-      end
-
-      # secondary index helper
-
-      def find_by(ref, query)
-        # TODO elimate direct manipulation of the connection
-        response = Fauna::Client.this.connection.get(ref, query)
-        response['resources'].map { |attributes| alloc(attributes) }
-      rescue Fauna::Connection::NotFound
-        []
-      end
-    end
-
-    def self.find_by_ref(ref, query = nil)
-      res = Fauna::Client.get(ref, query)
-      Fauna.class_for_name(res.fauna_class).alloc(res.to_hash)
     end
 
-    def self.create(*args)
-      new(*args).tap { |obj| obj.save }
-    end
-
-    def self.create!(*args)
-      new(*args).tap { |obj| obj.save! }
+    def self.hydrate(struct)
+      obj = resource_subclass(struct['class']).allocate
+      obj.instance_variable_set '@struct', struct
+      obj
     end
 
-    def self.alloc(struct)
-      obj = allocate
-      obj.instance_variable_set('@struct', struct)
+    def self.new(fauna_class, attrs = {})
+      obj = resource_subclass(fauna_class).allocate
+      obj.instance_variable_set '@struct', { 'ref' => nil, 'ts' => nil, 'deleted' => false, 'class' => fauna_class }
+      obj.send(:assign, attrs)
       obj
     end
 
-    def self.time_from_usecs(microseconds)
-      Time.at(microseconds/1_000_000, microseconds % 1_000_000)
+    def self.create(*args)
+      new(*args).tap(&:save)
     end
 
-    def self.usecs_from_time(time)
-      time.to_i * 1000000 + time.usec
+    def self.find(ref, query = {}, pagination = {})
+      hydrate(Fauna::Client.get(ref, query, pagination))
     end
 
     attr_reader :struct
 
     alias :to_hash :struct
 
-    def initialize(attrs = {})
-      @struct = { 'ref' => nil, 'ts' => nil, 'deleted' => false }
-      assign(attrs)
-    end
-
     def ts
-      struct['ts'] ? Resource.time_from_usecs(struct['ts']) : nil
+      struct['ts'] ? Fauna.time_from_usecs(struct['ts']) : nil
     end
 
     def ts=(time)
-      struct['ts'] = Resource.usecs_from_time(time)
+      struct['ts'] = Fauna.usecs_from_time(time)
     end
 
     def ref; struct['ref'] end
     def fauna_class; struct['class'] end
     def deleted; struct['deleted'] end
-    def unique_id; struct['unique_id'] end
+    def constraints; struct['constraints'] ||= {} end
     def data; struct['data'] ||= {} end
     def references; struct['references'] ||= {} end
-    def changes; EventSet.new("#{ref}/changes") end
+
+    def events(pagination = {})
+      EventsPage.find("#{ref}/events", {}, pagination)
+    end
+
+    def set(name)
+      CustomSet.new("#{ref}/sets/#{CGI.escape(name)}")
+    end
 
     def eql?(other)
-      self.class.equal?(other.class) && self.ref == other.ref && self.ref != nil
+      self.fauna_class == other.fauna_class && self.ref == other.ref && self.ref != nil
     end
     alias :== :eql?
 
@@ -143,34 +86,10 @@ module Fauna
 
     def deleted?; deleted end
 
-    alias :destroyed? :deleted?
-
     def persisted?; !(new_record? || deleted?) end
 
-    def errors
-      @errors ||= ActiveModel::Errors.new(self)
-    end
-
     def save
       @struct = (new_record? ? post : put).to_hash
-      true
-    rescue Fauna::Connection::BadRequest => e
-      e.param_errors.each { |field, message| errors[field] = message }
-      false
-    end
-
-    def save!
-      save || (raise Invalid, errors.full_messages)
-    end
-
-    def update(attributes = {})
-      assign(attributes)
-      save
-    end
-
-    def update!(attributes = {})
-      assign(attributes)
-      save!
     end
 
     def delete
@@ -178,16 +97,12 @@ module Fauna
       struct['deleted'] = true
       struct.freeze
       nil
-    rescue Fauna::Connection::NotAllowed
-      raise Invalid, "This resource can not be destroyed."
     end
 
-    alias :destroy :delete
-
     private
 
     # TODO: make this configurable, and possible to invert to a white list
-    UNASSIGNABLE_ATTRIBUTES = %w(ref ts deleted).inject({}) { |h, attr| h.update attr => true }
+    UNASSIGNABLE_ATTRIBUTES = %w(ts deleted fauna_class).inject({}) { |h, attr| h.update attr => true }
 
     def assign(attributes)
       attributes.each do |name, val|
@@ -197,12 +112,10 @@ module Fauna
 
     def put
       Fauna::Client.put(ref, struct)
-    rescue Fauna::Connection::NotAllowed
-      raise Invalid, "This resource type can not be updated."
     end
 
     def post
-      raise Invalid, "This resource type can not be created."
+      Fauna::Client.post(fauna_class, struct)
     end
 
     def getter_method(method)