fauna 0.0.0 → 0.1

data/lib/fauna/client.rb

@@ -0,0 +1,100 @@
+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)
+        @cache[ref] = res['resource'] if ref =~ %r{^users/self}
+        @cache[res['resource']['ref']] = res['resource']
+        @cache.merge!(res['references'])
+      end
+    end
+
+    def self.context(connection)
+      push_context(connection)
+      yield
+    ensure
+      pop_context
+    end
+
+    def self.push_context(connection)
+      stack.push(CachingContext.new(connection))
+    end
+
+    def self.pop_context
+      stack.pop
+    end
+
+    def self.get(ref, query = nil)
+      this.get(ref, query)
+    end
+
+    def self.post(ref, data = nil)
+      this.post(ref, data)
+    end
+
+    def self.put(ref, data = nil)
+      this.put(ref, data)
+    end
+
+    def self.delete(ref, data = nil)
+      this.delete(ref, data)
+    end
+
+    def self.this
+      stack.last or raise NoContextError, "You must be within a Fauna::Client.context block to perform operations."
+    end
+
+    class << self
+      private
+
+      def stack
+        Thread.current[:fauna_context_stack] ||= []
+      end
+    end
+  end
+end

data/lib/fauna/connection.rb

@@ -0,0 +1,129 @@
+module Fauna
+  class Connection
+    API_VERSION = 0
+
+    class Error < RuntimeError
+      attr_reader :param_errors
+
+      def initialize(message, param_errors = {})
+        @param_errors = param_errors
+        super(message)
+      end
+    end
+
+    class NotFound < Error; end
+    class BadRequest < Error; end
+    class Unauthorized < Error; end
+    class NotAllowed < Error; end
+    class NetworkError < Error; end
+
+    HANDLER = Proc.new do |res, _, _|
+      case res.code
+      when 200..299
+        res
+      when 400
+        json = JSON.parse(res)
+        raise BadRequest.new(json['error'], json['param_errors'])
+      when 401
+        raise Unauthorized, JSON.parse(res)['error']
+      when 404
+        raise NotFound, JSON.parse(res)['error']
+      when 405
+        raise NotAllowed, JSON.parse(res)['error']
+      else
+        raise NetworkError, res
+      end
+    end
+
+    def initialize(params={})
+      @logger = params[:logger] || nil
+
+      if ENV["FAUNA_DEBUG"]
+        @logger = Logger.new(STDERR)
+        @debug = true
+      end
+
+      # 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])}"
+      else
+        raise ArgumentError, "Credentials not defined."
+      end
+    end
+
+    def get(ref, query = nil)
+      JSON.parse(execute(:get, ref, nil, query))
+    end
+
+    def post(ref, data = nil)
+      JSON.parse(execute(:post, ref, data))
+    end
+
+    def put(ref, data = nil)
+      JSON.parse(execute(:put, ref, data))
+    end
+
+    def patch(ref, data = nil)
+      JSON.parse(execute(:patch, ref, data))
+    end
+
+    def delete(ref, data = nil)
+      execute(:delete, ref, data)
+      nil
+    end
+
+    private
+
+    def log(indent)
+      Array(yield).map do |string|
+        string.split("\n")
+      end.flatten.each do |line|
+        @logger.debug(" " * indent + line)
+      end
+    end
+
+    def execute(action, ref, data = nil, query = nil)
+      args = { :method => action, :url => url(ref), :headers => {} }
+
+      if query
+        args[:headers].merge! :params => query
+      end
+
+      if data
+        args[:headers].merge! :content_type => :json
+        args.merge! :payload => data.to_json
+      end
+
+      if @logger
+        log(2) { "Fauna #{action.to_s.upcase}(\"#{ref}\")" }
+        log(4) { "Request query: #{JSON.pretty_generate(query)}" } if query
+        log(4) { "Request JSON: #{JSON.pretty_generate(data)}" } if @debug && data
+
+        t0, r0 = Process.times, Time.now
+
+        RestClient::Request.execute(args) do |res, _, _|
+          t1, r1 = Process.times, Time.now
+          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" }
+
+          HANDLER.call(res)
+        end
+      else
+        RestClient::Request.execute(args, &HANDLER)
+      end
+    end
+
+    def url(ref)
+      "https://#{@credentials}@rest.fauna.org/v#{API_VERSION}/#{ref}"
+    end
+  end
+end

data/lib/fauna/ddl.rb

@@ -0,0 +1,145 @@
+module Fauna
+  class DDL
+
+    def initialize
+      @ddls = []
+    end
+
+    def configure!
+      @ddls.each { |ddl| ddl.configure! }
+    end
+
+    def load!
+      @ddls.each { |ddl| ddl.load! }
+    end
+
+    # resources
+
+    def with(__class__, args = {}, &block)
+      res = ResourceDDL.new(__class__, args)
+      res.instance_eval(&block) if block_given?
+      @ddls << res
+      nil
+    end
+
+    class ResourceDDL
+      def initialize(__class__, args = {})
+        @timelines = []
+        @class = __class__
+        @class_name = args[:class_name] || fauna_class_name(@class)
+        @class.fauna_class_name = @class_name
+
+        unless @class <= max_super(@class_name)
+          raise ArgmentError "#{@class} must be a subclass of #{max_super(@class_name)}."
+        end
+
+        @meta = Fauna::ClassSettings.alloc('ref' => @class_name) if @class_name =~ %r{^classes/[^/]+$}
+      end
+
+      def configure!
+        Fauna.add_class(@class_name, @class) if @class
+      end
+
+      def load!
+        @meta.save! if @meta
+        @timelines.each { |t| t.load! }
+      end
+
+      def timeline(*name)
+        args = name.last.is_a?(Hash) ? name.pop : {}
+        @class.send :timeline, *name
+
+        name.each { |n| @timelines << TimelineDDL.new(@class_name, n, args) }
+      end
+
+      def field(*name)
+        @class.send :field, *name
+      end
+
+      def reference(*name)
+        @class.send :reference, *name
+      end
+
+      private
+
+      def max_super(name)
+        case name
+        when "users" then Fauna::User
+        when "publisher" then Fauna::Publisher
+        when %r{^classes/[^/]+$} then Fauna::Class
+        else Fauna::Resource
+        end
+      end
+
+      def fauna_class_name(__class__)
+        if __class__ < Fauna::User
+          "users"
+        elsif __class__ < Fauna::Publisher
+          "publisher"
+        elsif  __class__ < Fauna::Class
+          "classes/#{__class__.name.tableize}"
+        else
+          raise ArgumentError, "Must specify a :class_name for non-default resource class #{__class__.name}"
+        end
+      end
+    end
+
+    # timelines
+
+    def timeline(*name)
+      args = name.last.is_a?(Hash) ? name.pop : {}
+      name.each { |n| @ddls << TimelineDDL.new(nil, n, args) }
+    end
+
+    class TimelineDDL
+      def initialize(parent_class, name, args)
+        @meta = TimelineSettings.new(name, args)
+      end
+
+      def configure!
+      end
+
+      def load!
+        @meta.save!
+      end
+    end
+
+    # commands
+
+    # def command(name)
+    #   cmd = CommandDDL.new(name)
+
+    #   yield cmd
+    #   @ddls << cmd
+
+    #   nil
+    # end
+
+    # class CommandDDL
+    #   attr_accessor :comment
+
+    #   def initialize(name)
+    #     @actions = []
+    #   end
+
+    #   def configure!
+    #   end
+
+    #   def load!
+    #   end
+
+    #   def get(path, args = {})
+    #     args.update method: 'GET', path: path
+    #     args.stringify_keys!
+
+    #     @actions << args
+    #   end
+    # end
+  end
+
+  # c.command "name" do |cmd|
+  #   cmd.comment = "foo bar"
+
+  #   cmd.get "users/self", :actor => "blah", :body => {}
+  # end
+end

data/lib/fauna/model.rb

@@ -0,0 +1,61 @@
+module Fauna
+  class Model < Resource
+    def self.inherited(base)
+      base.send :extend, ActiveModel::Naming
+      base.send :include, ActiveModel::Validations
+      base.send :include, ActiveModel::Conversion
+
+      # Callbacks support
+      base.send :extend, ActiveModel::Callbacks
+      base.send :include, ActiveModel::Validations::Callbacks
+      base.send :define_model_callbacks, :save, :create, :update, :destroy
+
+      # Serialization
+      base.send :include, ActiveModel::Serialization
+    end
+
+    # TODO: use proper class here
+    def self.find_by_id(id)
+      ref =
+        if self <= Fauna::User
+          "users/#{id}"
+        elsif self <= Fauna::User::Settings
+          "users/#{id}/settings"
+        else
+          "instances/#{id}"
+        end
+
+      Fauna::Resource.find(ref)
+    end
+
+    def id
+      ref.split("/").last
+    end
+
+    def save
+      if valid?
+        run_callbacks(:save) do
+          if new_record?
+            run_callbacks(:create) { super }
+          else
+            run_callbacks(:update) { super }
+          end
+        end
+      else
+        false
+      end
+    end
+
+    def delete
+      run_callbacks(:destroy) { super }
+    end
+
+    def valid?
+      run_callbacks(:validate) { super }
+    end
+
+    def to_model
+      self
+    end
+  end
+end

data/lib/fauna/model/class.rb

@@ -0,0 +1,49 @@
+module Fauna
+  class ClassSettings < Fauna::Resource; end
+
+  class Class < Fauna::Model
+    class << self
+      def inherited(base)
+        fc = name.split("::").last.underscore
+        Fauna.add_class(fc, base) unless Fauna.exists_class_for_name?(fc)
+      end
+
+      def ref
+        fauna_class_name
+      end
+
+      def data
+        Fauna::Resource.find(fauna_class_name).data
+      end
+
+      def update_data!(hash = {})
+        meta = Fauna::Resource.find(fauna_class_name)
+        block_given? ? yield(meta.data) : meta.data = hash
+        meta.save!
+      end
+
+      def update_data(hash = {})
+        meta = Fauna::Resource.find(fauna_class_name)
+        block_given? ? yield(meta.data) : meta.data = hash
+        meta.save
+      end
+
+      def __class_name__
+        @__class_name__ ||= begin
+          raise MissingMigration, "Class #{name} has not been added to Fauna.schema." if !fauna_class_name
+          fauna_class_name[8..-1]
+        end
+      end
+
+      def find_by_external_id(external_id)
+        find_by("instances", :external_id => external_id, :class => __class_name__).first
+      end
+    end
+
+    private
+
+    def post
+      Fauna::Client.post("instances", struct.merge("class" => self.class.__class_name__))
+    end
+  end
+end