fauna 0.2.6 → 1.1.0

data/lib/fauna/event_set.rb

@@ -1,197 +0,0 @@
-
-module Fauna
-  class SetRef
-    def initialize(attrs)
-      @attrs = attrs
-    end
-
-    def ts
-      Resource.time_from_usecs(@attrs['ts'])
-    end
-
-    def resource_ref
-      @attrs['resource']
-    end
-
-    def resource
-      Fauna::Resource.find_by_ref(resource_ref)
-    end
-  end
-
-  class Event < SetRef
-    def set_ref
-      @attrs['set']
-    end
-
-    def action
-      @attrs['action']
-    end
-
-    def set
-      EventSet.new(set_ref)
-    end
-  end
-
-  class EventsPage < Fauna::Resource
-    include Enumerable
-
-    def self.find(ref, query = nil)
-      if query
-        query = query.merge(:before => usecs_from_time(query[:before])) if query[:before]
-        query = query.merge(:after => usecs_from_time(query[:after])) if query[:after]
-      end
-
-      alloc(Fauna::Client.get(ref, query).to_hash)
-    end
-
-    def before
-      struct['before'] ? Resource.time_from_usecs(struct['before']) : nil
-    end
-
-    def after
-      struct['after'] ? Resource.time_from_usecs(struct['after']) : nil
-    end
-
-    def events
-      @events ||= struct['events'].map { |e| Event.new(e) }
-    end
-
-    def each(&block)
-      events.each(&block)
-    end
-
-    def empty?
-      events.empty?
-    end
-  end
-
-  class RefsPage < Fauna::Resource
-    include Enumerable
-
-    def self.find(ref, query = nil)
-      alloc(Fauna::Client.get(ref, query).to_hash)
-    end
-
-    def refs
-      @refs ||= struct['events'].map { |e| SetRef.new(e) }
-    end
-
-    def resources
-      refs.map(&:resource)
-    end
-
-    def empty?
-      events.empty?
-    end
-  end
-
-  class EventSet
-    attr_reader :ref
-
-    def initialize(ref)
-      @ref = ref
-    end
-
-    def page(query = nil)
-      EventsPage.find(ref, query)
-    end
-
-    def creates(query = nil)
-      RefsPage.find("#{ref}/creates", query)
-    end
-
-    def updates(query = nil)
-      RefsPage.find("#{ref}/updates", query)
-    end
-
-    def events(query = nil)
-      page(query).events
-    end
-
-    def resources(query = nil)
-      creates(query).resources
-    end
-
-    def self.join(*args)
-      EventSetQuery.new('join', *args)
-    end
-
-    def self.union(*args)
-      EventSetQuery.new('union', *args)
-    end
-
-    def self.intersection(*args)
-      EventSetQuery.new('intersection', *args)
-    end
-
-    def self.difference(*args)
-      EventSetQuery.new('difference', *args)
-    end
-
-    def self.query(&block)
-      module_eval(&block)
-    end
-  end
-
-  class CustomEventSet < EventSet
-    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 EventSetQuery < EventSet
-    def initialize(function, *params)
-      @function = function
-      @params = params
-    end
-
-    def query
-      @query ||=
-      begin
-        pstrs = @params.map do |p|
-          p.respond_to?(:query) ? p.query : "'#{p.respond_to?(:ref) ? p.ref : p}'"
-        end
-
-        "#{@function}(#{pstrs.join(',')})"
-      end
-    end
-
-    def ref
-      "query?query=#{query}"
-    end
-
-    def page(query = nil)
-      EventsPage.find("query", (query || {}).merge(:query => self.query))
-    end
-
-    def creates(query = nil)
-      RefsPage.find("query/creates", (query || {}).merge(:query => self.query))
-    end
-
-    def updates(query = nil)
-      RefsPage.find("query/updates", (query || {}).merge(:query => self.query))
-    end
-
-  end
-
-  class EventSetConfig < Fauna::Resource
-    def initialize(parent_class, name, attrs = {})
-      super(attrs)
-      struct['ref'] = "#{parent_class}/sets/#{name}/config"
-    end
-  end
-end

data/lib/fauna/model.rb

@@ -1,73 +0,0 @@
-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
-
-    def self.all
-      Fauna::EventSet.new(fauna_class)
-    end
-
-    def self.find_by_ref(ref)
-      Fauna::Resource.find_by_ref(URI.escape(ref))
-    end
-
-    def self.find_by_unique_id(unique_id)
-      find_by_ref("#{fauna_class}/unique_id/#{unique_id}")
-    end
-
-    def self.find(id)
-      find_by_ref("#{fauna_class}/#{id}")
-    end
-
-    class << self
-        alias find_by_id find
-    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
-
-    private
-
-    def post
-      Fauna::Client.post(self.class.fauna_class, struct)
-    end
-  end
-end

data/lib/fauna/model/class.rb

@@ -1,32 +0,0 @@
-module Fauna
-  class ClassConfig < 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 config_ref
-        "#{fauna_class}/config"
-      end
-
-      def data
-        Fauna::Resource.find_by_ref(config_ref).data
-      end
-
-      def update_data!(hash = {})
-        meta = Fauna::Resource.find_by_ref(config_ref)
-        block_given? ? yield(meta.data) : meta.data = hash
-        meta.save!
-      end
-
-      def update_data(hash = {})
-        meta = Fauna::Resource.find_by_ref(config_ref)
-        block_given? ? yield(meta.data) : meta.data = hash
-        meta.save
-      end
-    end
-  end
-end

data/lib/fauna/model/user.rb

@@ -1,23 +0,0 @@
-
-module Fauna
-  class User < Fauna::Model
-
-    class Config < Fauna::Resource; end
-
-    def self.self
-      find_by_ref("users/self")
-    end
-
-    def self.find_by_email(email)
-      find_by_ref("users/email/#{email}")
-    end
-
-    def config
-      Fauna::User::Config.find_by_ref("#{ref}/config")
-    end
-
-    # set on user create
-    def email; struct['email']; end
-    def password; struct['password']; end
-  end
-end

data/lib/fauna/publisher.rb

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

data/test/association_test.rb

@@ -1,23 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-class AssociationTest < MiniTest::Unit::TestCase
-
-  def setup
-    super
-
-    @pig = Pig.create!(:name => "Henwen")
-    @vision = Vision.create!(:pronouncement => "It was a dark and stormy night...", :pig => @pig)
-    @pig.visions.add @vision
-  end
-
-  def test_event_set
-    assert_equal @pig.visions.page.events.first.resource, @vision
-    assert @pig.visions.page.events.first.resource.pronouncement
-  end
-
-  def test_reference
-    assert_equal @vision.pig, @pig
-    assert_equal @vision.pig_ref, @pig.ref
-    assert @vision.pig.visions
-  end
-end

data/test/event_set_test.rb

@@ -1,92 +0,0 @@
-require File.expand_path('../test_helper', __FILE__)
-
-# TODO use association_test classes
-
-class EventSetTest < ActiveModel::TestCase
-  # include ActiveModel::Lint::Tests
-
-  def setup
-    super
-    @model = MessageBoard.create!
-  end
-
-  def test_page
-    page = @model.posts.page
-    assert_equal "#{@model.ref}/sets/posts", page.ref
-    assert_equal 0, page.events.size
-  end
-
-  def test_pagination
-    @model.posts.add(Post.create(:body => "Flewdyr Flam, called also Flewdyr Wledig."))
-    @model.posts.add(Post.create(:body => "Recorded in the Triads as one of the three sovereigns."))
-    @model.posts.add(Post.create(:body => "They preferred remaining as knights in the court of Arthur."))
-    @model.posts.add(Post.create(:body => "Even so, they had dominions of their own."))
-    @model.posts.add(Post.create(:body => "He is mentioned in the Mabinogi of Cilhwch and Olwen."))
-
-    page1 = @model.posts.page(:size => 2)
-    assert_equal 2, page1.events.size
-    page2 = @model.posts.page(:size => 2, :before => page1.before)
-    assert_equal 2, page2.events.size
-    page3 = @model.posts.page(:size => 2, :before => page2.before)
-    assert_equal 1, page3.events.size
-
-    page4 = @model.posts.page(:size => 2, :after => page3.events.last.ts)
-    assert_equal 2, page4.events.size
-    page5 = @model.posts.page(:size => 2, :after => page4.after)
-    assert_equal 2, page5.events.size
-    page6 = @model.posts.page(:size => 2, :after => page5.after)
-    assert_equal 1, page6.events.size
-  end
-
-  def test_any
-    @model.posts.add(Post.create(:body => "Hello"))
-    assert @model.posts.page.any?
-    assert @model.posts.page.events.any?
-  end
-
-  def test_event_set_add
-    @model.posts.add(Post.create(:body => "Goodbye"))
-    page = @model.posts.page
-    assert_equal 1, page.events.size
-    assert_equal "Goodbye", page.events[0].resource.body
-  end
-
-  def test_event_set_remove
-    @model.posts.add(Post.create(:body => "Hello"))
-    page = @model.posts.page
-    assert_equal 1, page.events.size
-    @model.posts.remove(page.events[0].resource)
-  end
-
-  def test_event_set_resources
-    post = Post.create(:body => "Hello")
-    @model.posts.add(post)
-    assert_equal [post], @model.posts.resources
-    assert_equal [post], @model.posts.creates.resources
-    assert_equal [post], @model.posts.updates.resources
-  end
-
-  def test_event_set_query
-    posts = (1..3).map do |i|
-      Post.create(:body => "p#{i}").tap do |p|
-        @model.posts.add(p)
-      end
-    end
-
-    comments = posts.map do |p|
-      (1..3).map do |i|
-        Comment.create(:body => "#{p.body}_c#{i}").tap do |c|
-          p.comments.add(c)
-        end
-      end
-    end
-
-    q = Fauna::EventSet.join(@model.posts, 'sets/comments')
-
-    assert_equal 9, q.resources.size
-
-    comments.flatten.each do |c|
-      assert q.resources.include?(c)
-    end
-  end
-end