fauna 1.3.4 → 2.0.0

data/lib/fauna/connection.rb

@@ -1,152 +0,0 @@
-module Fauna
-  class Connection # rubocop:disable Metrics/ClassLength
-    class Error < RuntimeError
-      attr_reader :error, :reason, :parameters
-
-      def initialize(error, reason = nil, parameters = {})
-        if error.is_a?(Hash)
-          json = error
-          @error = json['error']
-          @reason = json['reason']
-          @parameters = json['parameters'] || {}
-        else
-          @error = error
-          @reason = reason
-          @parameters = parameters
-        end
-
-        super(@reason || @error)
-      end
-    end
-
-    class NotFound < Error; end
-    class BadRequest < Error; end
-    class Unauthorized < Error; end
-    class PermissionDenied < Error; end
-    class MethodNotAllowed < Error; end
-    class NetworkError < Error; end
-
-    attr_reader :domain, :scheme, :port, :credentials, :timeout, :connection_timeout, :adapter, :logger
-
-    def initialize(params = {}) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
-      @logger = params[:logger] || nil
-      @domain = params[:domain] || 'rest1.fauna.org'
-      @scheme = params[:scheme] || 'https'
-      @port = params[:port] || (@scheme == 'https' ? 443 : 80)
-      @timeout = params[:timeout] || 60
-      @connection_timeout = params[:connection_timeout] || 60
-      @adapter = params[:adapter] || Faraday.default_adapter
-      @credentials = params[:secret].to_s.split(':')
-
-      if ENV['FAUNA_DEBUG']
-        @logger = Logger.new(STDERR)
-        @logger.formatter = proc { |_, _, _, msg| "#{msg}\n" }
-      end
-
-      @conn = Faraday.new(
-        :url => "#{@scheme}://#{@domain}:#{@port}/",
-        :headers => { 'Accept-Encoding' => 'gzip', 'Content-Type' => 'application/json;charset=utf-8' },
-        :request => { :timeout => @timeout, :open_timeout => @connection_timeout },
-      ) do |conn|
-        conn.adapter(@adapter)
-        conn.basic_auth(@credentials[0].to_s, @credentials[1].to_s)
-      end
-    end
-
-    def get(ref, query = {})
-      parse(*execute(:get, ref, nil, query))
-    end
-
-    def post(ref, data = {})
-      parse(*execute(:post, ref, data))
-    end
-
-    def put(ref, data = {})
-      parse(*execute(:put, ref, data))
-    end
-
-    def patch(ref, data = {})
-      parse(*execute(:patch, ref, data))
-    end
-
-    def delete(ref, data = {})
-      execute(:delete, ref, data)
-      nil
-    end
-
-  private
-
-    def parse(headers, body)
-      obj = body.empty? ? {} : JSON.parse(body)
-      obj.merge!('headers' => headers)
-      obj
-    end
-
-    def log(indent)
-      lines = Array(yield).collect { |string| string.split("\n") }
-      lines.flatten.each { |line| @logger.debug(' ' * indent + line) }
-    end
-
-    def query_string_for_logging(query)
-      return unless query && !query.empty?
-
-      '?' + query.collect do |k, v|
-        "#{k}=#{v}"
-      end.join('&')
-    end
-
-    def inflate(response)
-      if %w(gzip deflate).include?(response.headers['Content-Encoding'])
-        Zlib::GzipReader.new(StringIO.new(response.body.to_s), :external_encoding => Encoding::UTF_8).read
-      else
-        response.body.to_s
-      end
-    end
-
-    def execute(action, ref, data = nil, query = nil) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
-      if @logger
-        log(0) { "Fauna #{action.to_s.upcase} /#{ref}#{query_string_for_logging(query)}" }
-        log(2) { "Credentials: #{@credentials}" }
-        log(2) { "Request JSON: #{JSON.pretty_generate(data)}" } if data
-
-        t0, r0 = Process.times, Time.now
-        response = execute_without_logging(action, ref, data, query)
-        t1, r1 = Process.times, Time.now
-        body = inflate(response)
-
-        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(2) { ["Response headers: #{JSON.pretty_generate(response.headers)}", "Response JSON: #{body}"] }
-        log(2) { "Response (#{response.status}): API processing #{response.headers['X-HTTP-Request-Processing-Time']}ms, network latency #{((real - cpu) * 1000).to_i}ms, local processing #{(cpu * 1000).to_i}ms" }
-      else
-        response = execute_without_logging(action, ref, data, query)
-        body = inflate(response)
-      end
-
-      case response.status
-      when 200..299
-        [response.headers, body]
-      when 400
-        fail BadRequest.new(JSON.parse(body))
-      when 401
-        fail Unauthorized.new(JSON.parse(body))
-      when 403
-        fail PermissionDenied.new(JSON.parse(body))
-      when 404
-        fail NotFound.new(JSON.parse(body))
-      when 405
-        fail MethodNotAllowed.new(JSON.parse(body))
-      else
-        fail NetworkError, body
-      end
-    end
-
-    def execute_without_logging(action, ref, data, query)
-      @conn.send(action) do |req|
-        req.params = query if query.is_a?(Hash)
-        req.body = data.to_json if data.is_a?(Hash)
-        req.url(ref || '')
-      end
-    end
-  end
-end

data/lib/fauna/named_resource.rb

@@ -1,17 +0,0 @@
-module Fauna
-  class NamedResource < Fauna::Resource
-    def name
-      struct['name']
-    end
-
-    def ref
-      super || "#{fauna_class}/#{name}"
-    end
-
-  private
-
-    def post
-      fail Invalid, 'Cannot POST to named resource.'
-    end
-  end
-end

data/lib/fauna/rails.rb

@@ -1,120 +0,0 @@
-require 'fauna'
-
-# Various and sundry Rails integration points
-
-if defined?(Rails)
-  module Fauna
-    mattr_accessor :root_connection
-    mattr_accessor :connection
-
-    @silent = false
-
-    CONFIG_FILE = "#{Rails.root}/config/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"
-
-    # rubocop:disable Metrics/BlockNesting
-    def self.auth! # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
-      if File.exist? CONFIG_FILE
-        credentials = YAML.load_file(CONFIG_FILE)[Rails.env] || {}
-
-        if File.exist? LOCAL_CONFIG_FILE
-          credentials.merge!((YAML.load_file(LOCAL_CONFIG_FILE)[APP_NAME] || {})[Rails.env] || {})
-        end
-
-        unless @silent
-          if credentials['secret']
-            STDERR.puts ">> Using Fauna server key #{credentials['secret'].inspect} for #{APP_NAME.inspect}."
-          else
-            STDERR.puts ">> Using Fauna account #{credentials['email'].inspect} for #{APP_NAME.inspect}."
-          end
-
-          STDERR.puts '>> You can change this in config/fauna.yml or ~/.fauna.yml.'
-        end
-
-        if credentials['secret']
-          secret = credentials['secret']
-        else
-          self.root_connection = Connection.new(
-            :email => credentials['email'],
-            :password => credentials['password'],
-            :logger => Rails.logger)
-
-          secret = root_connection.post('keys', 'role' => 'server')['resource']['key']
-        end
-
-        self.connection = Connection.new(:secret => secret, :logger => Rails.logger)
-      else
-        unless @silent
-          STDERR.puts '>> Fauna account not configured. You can add one in config/fauna.yml.'
-        end
-      end
-
-      @silent = true
-      nil
-    end
-    # rubocop:enable Metrics/BlockNesting
-
-    # Around filter to set up a default context
-
-    # ActionDispatch's Auto reloader blows away some of Fauna's schema
-    # configuration that does not live within the Model classes
-    # themselves. Add a callback to Reloader to reload the schema config
-    # before each request.
-    def self.install_around_filter!
-      if Fauna.connection && defined?(ActionController::Base)
-        ApplicationController.class_eval do
-          around_filter :default_fauna_context
-
-          def default_fauna_context
-            Fauna::Client.context(Fauna.connection) { yield }
-          end
-        end
-      end
-    end
-
-    def self.install_reload_callback!
-      if defined? ActionDispatch::Reloader
-        ActionDispatch::Reloader.to_prepare do
-          Fauna.install_around_filter!
-        end
-      end
-    end
-
-    def self.install_inflections!
-      # ActiveSupport::Inflector's 'humanize' method handles the _id
-      # suffix for association fields, but not _ref.
-      if defined? ActiveSupport::Inflector
-        ActiveSupport::Inflector.inflections do |inflect|
-          inflect.human(/_ref$/i, '')
-        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,175 +0,0 @@
-module Fauna
-  class Resource # rubocop:disable Metrics/ClassLength
-    def self.resource_subclass(fauna_class)
-      case fauna_class
-      when 'databases' then Fauna::NamedResource
-      when 'classes' then Fauna::NamedResource
-      when 'indexes' then Fauna::NamedResource
-      when 'resources' then Fauna::SetPage
-      when 'events' then Fauna::EventsPage
-      else Fauna::Resource
-      end
-    end
-
-    def self.hydrate(struct)
-      obj = resource_subclass(struct['class']).allocate
-      obj.instance_variable_set('@struct', struct)
-      obj
-    end
-
-    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.struct = attrs
-      obj
-    end
-
-    def self.create(*args)
-      new(*args).tap(&:save)
-    end
-
-    def self.find(ref, query = {}, pagination = {})
-      hydrate(Fauna::Client.get(ref, query, pagination))
-    end
-
-    attr_reader :struct
-    alias_method :to_hash, :struct
-
-    def ts
-      struct['ts'] ? Fauna.time_from_usecs(struct['ts']) : nil
-    end
-
-    def ts=(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 constraints
-      struct['constraints'] ||= {}
-    end
-
-    def data
-      struct['data'] ||= {}
-    end
-
-    def references
-      struct['references'] ||= {}
-    end
-
-    def permissions
-      struct['permissions'] ||= {}
-    end
-
-    def events(pagination = {})
-      EventsPage.find("#{ref}/events", {}, pagination)
-    end
-
-    def new_event(action, time)
-      return unless persisted?
-
-      Fauna::Event.new(
-        'resource' => ref,
-        'set' => ref,
-        'action' => action,
-        'ts' => Fauna.usecs_from_time(time),
-      )
-    end
-
-    def set(name)
-      CustomSet.new("#{ref}/sets/#{CGI.escape(name)}")
-    end
-
-    def eql?(other)
-      fauna_class == other.fauna_class && ref == other.ref && !ref.nil?
-    end
-    alias_method :==, :eql?
-
-    # dynamic field access
-
-    def respond_to?(method, *args)
-      !!getter_method(method) || !!setter_method(method) || super
-    end
-
-    def method_missing(method, *args)
-      if (field = getter_method(method))
-        struct[field]
-      elsif (field = setter_method(method))
-        struct[field] = args.first
-      else
-        super
-      end
-    end
-
-    # object lifecycle
-
-    def new_record?
-      ref.nil?
-    end
-
-    def deleted?
-      !!deleted
-    end
-
-    def persisted?
-      !(new_record? || deleted?)
-    end
-
-    def save
-      new_record? ? post : put
-    end
-
-    def delete
-      Fauna::Client.delete(ref) if persisted?
-      struct['deleted'] = true
-      struct.freeze
-      nil
-    end
-
-    def put
-      @struct = Fauna::Client.put(ref, struct).to_hash
-    end
-
-    def patch
-      @struct = Fauna::Client.patch(ref, struct).to_hash
-    end
-
-    def post
-      @struct = Fauna::Client.post(fauna_class, struct).to_hash
-    end
-
-    # TODO: make this configurable, and possible to invert to a white list
-    UNASSIGNABLE_ATTRIBUTES = %w(ts deleted fauna_class).inject({}) { |h, attr| h.update attr => true }
-
-    def struct=(attributes)
-      default_attributes.merge(attributes).each do |name, val|
-        send "#{name}=", val unless UNASSIGNABLE_ATTRIBUTES[name.to_s]
-      end
-    end
-
-  private
-
-    def default_attributes
-      { 'data' => {}, 'references' => {}, 'constraints' => {} }
-    end
-
-    def getter_method(method)
-      field = method.to_s
-      struct.include?(field) ? field : nil
-    end
-
-    def setter_method(method)
-      (/(.*)=$/ =~ method.to_s) ? Regexp.last_match[1] : nil
-    end
-  end
-end