fauna 0.0.0 → 0.1

data/lib/fauna/model/follow.rb

@@ -0,0 +1,43 @@
+
+module Fauna
+  class Follow < Fauna::Model
+    def self.find_by_follower_and_resource(follower, resource)
+      find(new(:follower => follower, :resource => resource).ref)
+    end
+
+    def initialize(attrs = {})
+      super({})
+      attrs.stringify_keys!
+      follower_ref = attrs['follower_ref']
+      follower_ref = attrs['follower'].ref if attrs['follower']
+      resource_ref = attrs['resource_ref']
+      resource_ref = attrs['resource'].ref if attrs['resource']
+      ref = "#{follower_ref}/follows/#{resource_ref}"
+
+      raise ArgumentError, "Follower ref is nil." if follower_ref.nil?
+      raise ArgumentError, "Resource ref is nil." if resource_ref.nil?
+
+      @struct = { 'ref' => ref, 'follower' => follower_ref, 'resource' => resource_ref }
+    end
+
+    def follower_ref
+      struct['follower']
+    end
+
+    def follower
+      Fauna::Resource.find(follower_ref)
+    end
+
+    def resource_ref
+      struct['resource']
+    end
+
+    def resource
+      Fauna::Resource.find(resource_ref)
+    end
+
+    def update(*args)
+      raise Fauna::Invalid, "Follows have nothing to update."
+    end
+  end
+end

data/lib/fauna/model/publisher.rb

@@ -0,0 +1,8 @@
+
+module Fauna
+  class Publisher < Fauna::Model
+    def self.find
+      super("publisher")
+    end
+  end
+end

data/lib/fauna/model/timeline.rb

@@ -0,0 +1,92 @@
+
+module Fauna
+  class TimelineEvent
+
+    attr_reader :ts, :timeline_ref, :resource_ref, :action
+
+    def initialize(attrs)
+      # TODO v1
+      # @ts = attrs['ts']
+      # @timeline_ref = attrs['timeline']
+      # @resource_ref = attrs['resource']
+      # @action = attrs['action']
+      @ts, @action, @resource_ref = *attrs
+    end
+
+    def resource
+      Fauna::Resource.find(resource_ref)
+    end
+
+    def timeline
+      Timeline.new(timeline_ref)
+    end
+  end
+
+  class TimelinePage < Fauna::Resource
+    def events
+      @events ||= struct['events'].map { |e| TimelineEvent.new(e) }
+    end
+
+    def any?
+      struct['events'].any?
+    end
+
+    def resources
+      # TODO duplicates can exist in the local timeline. remove w/ v1
+      seen = {}
+      events.inject([]) do |a, ev|
+        if (ev.action == 'create' && !seen[ev.resource_ref])
+          seen[ev.resource_ref] = true
+          a << ev.resource
+        end
+
+        a
+      end
+    end
+  end
+
+  class Timeline
+    attr_reader :ref
+
+    def initialize(ref)
+      @ref = ref
+    end
+
+    def page(query = nil)
+      TimelinePage.find(ref, query)
+    end
+
+    def events(query = nil)
+      page(query).events
+    end
+
+    def resources(query = nil)
+      page(query).resources
+    end
+
+    def add(resource)
+      self.class.add(ref, resource)
+    end
+
+    def remove(resource)
+      self.class.remove(ref, resource)
+    end
+
+    def self.add(ref, resource)
+      resource = resource.ref if resource.respond_to?(:ref)
+      Fauna::Client.post(ref, 'resource' => resource)
+    end
+
+    def self.remove(ref, resource)
+      resource = resource.ref if resource.respond_to?(:ref)
+      Fauna::Client.delete(ref, 'resource' => resource)
+    end
+  end
+
+  class TimelineSettings < Fauna::Resource
+    def initialize(name, attrs = {})
+      super(attrs)
+      struct['ref'] = "timelines/#{name}"
+    end
+  end
+end

data/lib/fauna/model/user.rb

@@ -0,0 +1,44 @@
+
+module Fauna
+  class User < Fauna::Model
+
+    validates :name, :presence => true
+
+    class Settings < Fauna::Model; end
+
+    def self.self
+      find("users/self")
+    end
+
+    def self.find_by_email(email)
+      find_by("users", :email => email)
+    end
+
+    def self.find_by_external_id(external_id)
+      find_by("users", :external_id => external_id)
+    end
+
+    def self.find_by_name(name)
+      find_by("users", :name => name)
+    end
+
+    def email; struct['email']; end
+
+    def password; struct['password']; end
+
+    # FIXME https://github.com/fauna/issues/issues/16
+    def name
+      struct['name']
+    end
+
+    def settings
+      Fauna::User::Settings.find("#{ref}/settings")
+    end
+
+    private
+
+    def post
+      Fauna::Client.post("users", struct)
+    end
+  end
+end

data/lib/fauna/rails.rb

@@ -0,0 +1,81 @@
+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
+
+    def self.auth!
+      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
+
+        if !@silent
+          STDERR.puts ">> Using Fauna account #{credentials["email"].inspect} for #{APP_NAME.inspect}."
+          STDERR.puts ">> You can change this in config/fauna.yml or ~/.fauna.yml."
+        end
+
+        self.root_connection = Connection.new(
+          :email => credentials["email"],
+          :password => credentials["password"],
+        :logger => Rails.logger)
+
+        publisher_key = root_connection.post("keys/publisher")["resource"]["key"]
+        self.connection = Connection.new(publisher_key: publisher_key, logger: Rails.logger)
+      else
+        if !@silent
+          STDERR.puts ">> Fauna account not configured. You can add one in config/fauna.yml."
+        end
+      end
+
+      @silent = true
+      nil
+    end
+  end
+
+  Fauna.auth!
+
+  # Around filter to set up a default context
+
+  if Fauna.connection && defined?(ActionController::Base)
+    ApplicationController
+
+    class ApplicationController
+      around_filter :default_fauna_context
+
+      def default_fauna_context
+        Fauna::Client.context(Fauna.connection) { yield }
+      end
+    end
+  end
+
+  # 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.
+
+  if defined? ActionDispatch::Reloader
+    ActionDispatch::Reloader.to_prepare do
+      Fauna.configure_schema!
+    end
+  end
+
+  # 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

data/lib/fauna/resource.rb

@@ -0,0 +1,239 @@
+module Fauna
+  class Resource
+
+    def self.fields; @fields ||= [] end
+    def self.timelines; @timelines ||= [] end
+    def self.references; @references ||= [] end
+
+    # config DSL
+
+    class << self
+      attr_accessor :fauna_class_name
+
+      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 timeline(*names)
+        args = names.last.is_a?(Hash) ? names.pop : {}
+
+        names.each do |name|
+          timeline_name = args[:internal] ? name.to_s : "timelines/#{name}"
+          timelines << timeline_name
+          timelines.uniq!
+
+          define_method(name.to_s) { Fauna::Timeline.new("#{ref}/#{timeline_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(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(ref, query = nil)
+      res = Fauna::Client.get(ref, query)
+      Fauna.class_for_name(res.fauna_class_name).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! }
+    end
+
+    def self.alloc(struct)
+      obj = allocate
+      obj.instance_variable_set('@struct', struct)
+      obj
+    end
+
+    attr_reader :struct
+
+    alias :to_hash :struct
+
+    def initialize(attrs = {})
+      @struct = { 'ref' => nil, 'ts' => nil, 'deleted' => false }
+      assign(attrs)
+    end
+
+    def ref; struct['ref'] end
+    def ts; struct['ts'] end
+    def deleted; struct['deleted'] end
+    def external_id; struct['external_id'] end
+    def data; struct['data'] ||= {} end
+    def references; struct['references'] ||= {} end
+    def changes; Timeline.new("#{ref}/changes") end
+    def user_follows; Timeline.new("#{ref}/follows/users") end
+    def user_followers; Timeline.new("#{ref}/followers/users") end
+    def instance_follows; Timeline.new("#{ref}/follows/instances") end
+    def instance_followers; Timeline.new("#{ref}/followers/instances") end
+    def local; Timeline.new("#{ref}/local") end
+
+    def eql?(other)
+      self.class.equal?(other.class) && self.ref == other.ref && self.ref != nil
+    end
+    alias :== :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
+
+    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
+      Fauna::Client.delete(ref) if persisted?
+      struct['deleted'] = true
+      struct.freeze
+      nil
+    rescue Fauna::Connection::NotAllowed
+      raise Invalid, "This resource can not be destroyed."
+    end
+
+    alias :destroy :delete
+
+    # TODO eliminate/simplify once v1 drops
+
+    def fauna_class_name
+      @_fauna_class_name ||=
+      case ref
+      when %r{^users/[^/]+$}
+        "users"
+      when %r{^instances/[^/]+$}
+        "classes/#{struct['class']}"
+      when %r{^[^/]+/[^/]+/follows/[^/]+/[^/]+$}
+        "follows"
+      when %r{^.+/timelines/[^/]+$}
+        "timelines"
+      when %r{^.+/changes$}
+        "timelines"
+      when %r{^.+/local$}
+        "timelines"
+      when %r{^.+/follows/[^/]+$}
+        "timelines"
+      when %r{^.+/followers/[^/]+$}
+        "timelines"
+      when %r{^timelines/[^/]+$}
+        "timelines/settings"
+      when %r{^classes/[^/]+$}
+        "classes"
+      when %r{^users/[^/]+/settings$}
+        "users/settings"
+      when "publisher/settings"
+        "publisher/settings"
+      when "publisher"
+        "publisher"
+      else
+        nil
+      end
+    end
+
+    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 }
+
+    def assign(attributes)
+      attributes.each do |name, val|
+        send "#{name}=", val unless UNASSIGNABLE_ATTRIBUTES[name.to_s]
+      end
+    end
+
+    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."
+    end
+
+    def getter_method(method)
+      field = method.to_s
+      struct.include?(field) ? field : nil
+    end
+
+    def setter_method(method)
+      (/(.*)=$/ =~ method.to_s) ? $1 : nil
+    end
+  end
+end