social_stream 0.0.4 → 0.0.5

data/spec/dummy/public/javascripts/rails.js

@@ -0,0 +1,175 @@
+(function() {
+  // Technique from Juriy Zaytsev
+  // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
+  function isEventSupported(eventName) {
+    var el = document.createElement('div');
+    eventName = 'on' + eventName;
+    var isSupported = (eventName in el);
+    if (!isSupported) {
+      el.setAttribute(eventName, 'return;');
+      isSupported = typeof el[eventName] == 'function';
+    }
+    el = null;
+    return isSupported;
+  }
+
+  function isForm(element) {
+    return Object.isElement(element) && element.nodeName.toUpperCase() == 'FORM'
+  }
+
+  function isInput(element) {
+    if (Object.isElement(element)) {
+      var name = element.nodeName.toUpperCase()
+      return name == 'INPUT' || name == 'SELECT' || name == 'TEXTAREA'
+    }
+    else return false
+  }
+
+  var submitBubbles = isEventSupported('submit'),
+      changeBubbles = isEventSupported('change')
+
+  if (!submitBubbles || !changeBubbles) {
+    // augment the Event.Handler class to observe custom events when needed
+    Event.Handler.prototype.initialize = Event.Handler.prototype.initialize.wrap(
+      function(init, element, eventName, selector, callback) {
+        init(element, eventName, selector, callback)
+        // is the handler being attached to an element that doesn't support this event?
+        if ( (!submitBubbles && this.eventName == 'submit' && !isForm(this.element)) ||
+             (!changeBubbles && this.eventName == 'change' && !isInput(this.element)) ) {
+          // "submit" => "emulated:submit"
+          this.eventName = 'emulated:' + this.eventName
+        }
+      }
+    )
+  }
+
+  if (!submitBubbles) {
+    // discover forms on the page by observing focus events which always bubble
+    document.on('focusin', 'form', function(focusEvent, form) {
+      // special handler for the real "submit" event (one-time operation)
+      if (!form.retrieve('emulated:submit')) {
+        form.on('submit', function(submitEvent) {
+          var emulated = form.fire('emulated:submit', submitEvent, true)
+          // if custom event received preventDefault, cancel the real one too
+          if (emulated.returnValue === false) submitEvent.preventDefault()
+        })
+        form.store('emulated:submit', true)
+      }
+    })
+  }
+
+  if (!changeBubbles) {
+    // discover form inputs on the page
+    document.on('focusin', 'input, select, texarea', function(focusEvent, input) {
+      // special handler for real "change" events
+      if (!input.retrieve('emulated:change')) {
+        input.on('change', function(changeEvent) {
+          input.fire('emulated:change', changeEvent, true)
+        })
+        input.store('emulated:change', true)
+      }
+    })
+  }
+
+  function handleRemote(element) {
+    var method, url, params;
+
+    var event = element.fire("ajax:before");
+    if (event.stopped) return false;
+
+    if (element.tagName.toLowerCase() === 'form') {
+      method = element.readAttribute('method') || 'post';
+      url    = element.readAttribute('action');
+      params = element.serialize();
+    } else {
+      method = element.readAttribute('data-method') || 'get';
+      url    = element.readAttribute('href');
+      params = {};
+    }
+
+    new Ajax.Request(url, {
+      method: method,
+      parameters: params,
+      evalScripts: true,
+
+      onComplete:    function(request) { element.fire("ajax:complete", request); },
+      onSuccess:     function(request) { element.fire("ajax:success",  request); },
+      onFailure:     function(request) { element.fire("ajax:failure",  request); }
+    });
+
+    element.fire("ajax:after");
+  }
+
+  function handleMethod(element) {
+    var method = element.readAttribute('data-method'),
+        url = element.readAttribute('href'),
+        csrf_param = $$('meta[name=csrf-param]')[0],
+        csrf_token = $$('meta[name=csrf-token]')[0];
+
+    var form = new Element('form', { method: "POST", action: url, style: "display: none;" });
+    element.parentNode.insert(form);
+
+    if (method !== 'post') {
+      var field = new Element('input', { type: 'hidden', name: '_method', value: method });
+      form.insert(field);
+    }
+
+    if (csrf_param) {
+      var param = csrf_param.readAttribute('content'),
+          token = csrf_token.readAttribute('content'),
+          field = new Element('input', { type: 'hidden', name: param, value: token });
+      form.insert(field);
+    }
+
+    form.submit();
+  }
+
+
+  document.on("click", "*[data-confirm]", function(event, element) {
+    var message = element.readAttribute('data-confirm');
+    if (!confirm(message)) event.stop();
+  });
+
+  document.on("click", "a[data-remote]", function(event, element) {
+    if (event.stopped) return;
+    handleRemote(element);
+    event.stop();
+  });
+
+  document.on("click", "a[data-method]", function(event, element) {
+    if (event.stopped) return;
+    handleMethod(element);
+    event.stop();
+  });
+
+  document.on("submit", function(event) {
+    var element = event.findElement(),
+        message = element.readAttribute('data-confirm');
+    if (message && !confirm(message)) {
+      event.stop();
+      return false;
+    }
+
+    var inputs = element.select("input[type=submit][data-disable-with]");
+    inputs.each(function(input) {
+      input.disabled = true;
+      input.writeAttribute('data-original-value', input.value);
+      input.value = input.readAttribute('data-disable-with');
+    });
+
+    var element = event.findElement("form[data-remote]");
+    if (element) {
+      handleRemote(element);
+      event.stop();
+    }
+  });
+
+  document.on("ajax:after", "form", function(event, element) {
+    var inputs = element.select("input[type=submit][disabled=true][data-disable-with]");
+    inputs.each(function(input) {
+      input.value = input.readAttribute('data-original-value');
+      input.removeAttribute('data-original-value');
+      input.disabled = false;
+    });
+  });
+})();

data/spec/dummy/script/rails

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby1.8
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require File.expand_path('../../config/boot',  __FILE__)
+require 'rails/commands'

data/spec/factories/activity.rb

@@ -0,0 +1,10 @@
+Factory.define :activity do |a|
+  a.association :tie
+  a.activity_verb { ActivityVerb["post"] }
+end
+
+Factory.define :like_activity, :parent => :activity do |a|
+  a.association :parent, :factory => :activity
+  a.activity_verb { ActivityVerb["like"] }
+  a.tie { |tie| tie.association(:tie, :receiver => tie.parent.tie.receiver) }
+end

data/spec/factories/actor.rb

@@ -0,0 +1,4 @@
+Factory.define :actor do |s|
+  s.sequence(:name) { |n| "Actor #{ n }" }
+  s.subject_type "Subject"
+end

data/spec/factories/group.rb

@@ -0,0 +1,3 @@
+Factory.define :group do |g|
+  g.sequence(:name) { |n| "Group #{ n }" }
+end

data/spec/factories/post.rb

@@ -0,0 +1,3 @@
+Factory.define :post do |p|
+  p._activity_tie_id { |q| q.association(:tie) }
+end

data/spec/factories/tie.rb

@@ -0,0 +1,38 @@
+Factory.define :tie do |t|
+  t.sender { |s| Factory(:user).actor }
+  t.receiver { |r| Factory(:user).actor }
+  t.relation { |r| Relation.mode('User', 'User').strongest }
+end
+
+# UserToUser ties
+
+Factory.define :friend_tie, :parent => :tie do |t|
+  t.relation { |r| Relation.mode('User', 'User').find_by_name('friend') }
+end
+
+Factory.define :fof_tie, :parent => :tie do |t|
+  t.relation { |r| Relation.mode('User', 'User').find_by_name('friend_of_friend') }
+end
+
+Factory.define :public_tie, :parent => :tie do |t|
+  t.relation { |r| Relation.mode('User', 'User').find_by_name('public') }
+end
+
+# UserToGroup ties
+Factory.define :u2g_tie, :parent => :tie do |t|
+  t.receiver { |r| Factory(:group).actor }
+  t.relation { |r| Relation.mode('User', 'Group').strongest }
+end
+
+Factory.define :admin_tie, :parent => :u2g_tie do |t|
+  t.relation { |r| Relation.mode('User', 'Group').find_by_name('admin') }
+end
+
+Factory.define :user_tie, :parent => :u2g_tie do |t|
+  t.relation { |r| Relation.mode('User', 'Group').find_by_name('user') }
+end
+
+Factory.define :follower_tie, :parent => :u2g_tie do |t|
+  t.relation { |r| Relation.mode('User', 'Group').find_by_name('follower') }
+end
+

data/spec/factories/user.rb

@@ -0,0 +1,4 @@
+Factory.define :user do |u|
+  u.sequence(:name) { |n| "User #{ n }" }
+  u.sequence(:email) { |n| "user#{ n }@example.com" }
+end

data/spec/integration/navigation_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe "Navigation" do
+  include Capybara
+  
+  it "should be a valid app" do
+    ::Rails.application.should be_a(Dummy::Application)
+  end
+end

data/spec/models/activity_spec.rb

@@ -0,0 +1,420 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module ActivityTestHelper
+  def create_activity_assigned_to(t)
+    @tie = t
+    @activity = Factory(:activity, :tie => t)
+  end
+
+  def create_ability_accessed_by(tie_type)
+    t = Factory(tie_type, :receiver => @tie.receiver)
+    u = t.sender.subject
+    @ability = Ability.new(u)
+  end
+
+  shared_examples_for "Allows Creating" do
+    it "should allow create" do
+      @ability.should be_able_to(:create, @activity)
+    end
+  end
+  
+  shared_examples_for "Allows Reading" do
+    it "should allow read" do
+      @ability.should be_able_to(:read, @activity)
+    end
+  end
+  
+  shared_examples_for "Allows Updating" do
+    it "should allow update" do
+      @ability.should be_able_to(:update, @activity)
+    end
+  end
+  
+  shared_examples_for "Allows Destroying" do
+    it "should allow destroy" do
+      @ability.should be_able_to(:destroy, @activity)
+    end
+  end
+
+  shared_examples_for "Denies Creating" do
+    it "should deny create" do
+      @ability.should_not be_able_to(:create, @activity)
+    end
+  end
+  
+  shared_examples_for "Denies Reading" do
+    it "should deny read" do
+      @ability.should_not be_able_to(:read, @activity)
+    end
+  end
+  
+  shared_examples_for "Denies Updating" do
+    it "should deny update" do
+      @ability.should_not be_able_to(:update, @activity)
+    end
+  end
+  
+  shared_examples_for "Denies Destroying" do
+    it "should deny destroy" do
+      @ability.should_not be_able_to(:destroy, @activity)
+    end
+  end
+  
+end
+
+describe Activity do
+  include ActivityTestHelper
+
+  describe "with like subactivity" do
+    before do
+      @like_activity = Factory(:like_activity)
+      @activity = @like_activity.parent
+    end
+
+    it "should recognize the user who likes it" do
+      assert @activity.liked_by?(@like_activity.sender)
+    end
+
+    it "should not recognize the user who does not like it" do
+      assert ! @activity.liked_by?(Factory(:user))
+    end
+  end
+
+  describe "belonging to friend tie" do
+    before do
+      create_activity_assigned_to(Factory(:friend_tie))
+    end
+
+    describe "accessed by same friend" do
+      before do
+        u = @tie.sender.subject
+        @ability = Ability.new(u)
+      end
+
+      it_should_behave_like "Allows Creating"
+      it_should_behave_like "Allows Reading"
+      it_should_behave_like "Allows Updating"
+      it_should_behave_like "Allows Destroying"
+    end
+    
+    describe "accessed by different friend" do
+      before do
+        create_ability_accessed_by :friend_tie
+      end
+
+      it_should_behave_like "Denies Creating"
+      it_should_behave_like "Allows Reading"
+      it_should_behave_like "Denies Updating"
+      it_should_behave_like "Denies Destroying"
+    end
+
+    describe "accessed by friend of friend" do
+      before do
+        create_ability_accessed_by :fof_tie
+      end
+
+      it_should_behave_like "Denies Creating"
+      it_should_behave_like "Denies Reading"
+      it_should_behave_like "Denies Updating"
+      it_should_behave_like "Denies Destroying"
+    end
+
+    describe "accessed publicly" do
+      before do
+        create_ability_accessed_by :public_tie
+      end
+
+      it_should_behave_like "Denies Creating"
+      it_should_behave_like "Denies Reading"
+      it_should_behave_like "Denies Updating"
+      it_should_behave_like "Denies Destroying"
+    end
+  end
+  
+  describe "belonging to fof tie from a friend" do
+    before do
+      create_activity_assigned_to(Factory(:friend_tie).related('friend_of_friend'))
+    end
+    
+    describe "accessed by a friend" do
+      before do
+        create_ability_accessed_by :friend_tie
+      end
+
+      it_should_behave_like "Denies Creating"
+      it_should_behave_like "Allows Reading"
+      it_should_behave_like "Denies Updating"
+      it_should_behave_like "Denies Destroying"
+    end
+
+    describe "accessed by same friend" do
+      before do
+        u = @tie.sender.subject
+        @ability = Ability.new(u)
+      end
+
+      it_should_behave_like "Allows Creating"
+      it_should_behave_like "Allows Reading"
+      it_should_behave_like "Allows Updating"
+      it_should_behave_like "Allows Destroying"
+    end
+    
+    describe "accessed by different friend of friend" do
+      before do
+        create_ability_accessed_by :fof_tie
+      end
+
+      it_should_behave_like "Denies Creating"
+      it_should_behave_like "Allows Reading"
+      it_should_behave_like "Denies Updating"
+      it_should_behave_like "Denies Destroying"
+    end
+
+    describe "accessed publicly" do
+      before do
+        create_ability_accessed_by :public_tie
+      end
+
+      it_should_behave_like "Denies Creating"
+      it_should_behave_like "Denies Reading"
+      it_should_behave_like "Denies Updating"
+      it_should_behave_like "Denies Destroying"
+    end
+  end
+
+  describe "belonging to fof tie from a friend of friend" do
+    before do
+      create_activity_assigned_to(Factory(:fof_tie))
+      u = @tie.sender.subject
+      @ability = Ability.new(u)
+    end
+    
+    it_should_behave_like "Denies Creating"
+  end
+
+ 
+  describe "belonging to public tie" do
+    before do
+      create_activity_assigned_to(Factory(:friend_tie).related('public'))
+    end
+    
+    describe "accessed by a friend" do
+      before do
+        create_ability_accessed_by :friend_tie
+      end
+
+      it_should_behave_like "Denies Creating"
+      it_should_behave_like "Allows Reading"
+      it_should_behave_like "Denies Updating"
+      it_should_behave_like "Denies Destroying"
+    end
+
+    describe "accessed by friend of friend" do
+      before do
+        create_ability_accessed_by :fof_tie
+      end
+
+      it_should_behave_like "Denies Creating"
+      it_should_behave_like "Allows Reading"
+      it_should_behave_like "Denies Updating"
+      it_should_behave_like "Denies Destroying"
+    end
+
+    describe "accessed by same public sender" do
+      before do
+        u = @tie.sender.subject
+        @ability = Ability.new(u)
+      end
+
+      it_should_behave_like "Allows Creating"
+      it_should_behave_like "Allows Reading"
+      it_should_behave_like "Allows Updating"
+      it_should_behave_like "Allows Destroying"
+    end
+
+    describe "accessed by different public" do
+      before do
+        create_ability_accessed_by :public_tie
+      end
+
+      it_should_behave_like "Denies Creating"
+      it_should_behave_like "Allows Reading"
+      it_should_behave_like "Denies Updating"
+      it_should_behave_like "Denies Destroying"
+    end
+  end
+
+  describe "belonging to public tie from a public" do
+    before do
+      create_activity_assigned_to(Factory(:public_tie))
+      u = @tie.sender.subject
+      @ability = Ability.new(u)
+    end
+    
+    it_should_behave_like "Denies Creating"
+  end
+
+  describe "belonging to admin tie" do
+    before do
+      create_activity_assigned_to(Factory(:admin_tie))
+    end
+
+    describe "accessed by same admin" do
+      before do
+        u = @tie.sender.subject
+        @ability = Ability.new(u)
+      end
+
+      it_should_behave_like "Allows Creating"
+      it_should_behave_like "Allows Reading"
+      it_should_behave_like "Allows Updating"
+      it_should_behave_like "Allows Destroying"
+    end
+    
+    describe "accessed by different admin" do
+      before do
+        create_ability_accessed_by :admin_tie
+      end
+
+      it_should_behave_like "Denies Creating"
+      it_should_behave_like "Allows Reading"
+      it_should_behave_like "Allows Updating"
+      it_should_behave_like "Allows Destroying"
+    end
+
+    describe "accessed by user" do
+      before do
+        create_ability_accessed_by :user_tie
+      end
+
+      it_should_behave_like "Denies Creating"
+      it_should_behave_like "Denies Reading"
+      it_should_behave_like "Denies Updating"
+      it_should_behave_like "Denies Destroying"
+    end
+
+    describe "accessed by follower" do
+      before do
+        create_ability_accessed_by :follower_tie
+      end
+
+      it_should_behave_like "Denies Creating"
+      it_should_behave_like "Denies Reading"
+      it_should_behave_like "Denies Updating"
+      it_should_behave_like "Denies Destroying"
+    end
+  end
+  
+  describe "belonging to user tie from an admin" do
+    before do
+      create_activity_assigned_to(Factory(:admin_tie).related('user'))
+    end
+    
+    describe "accessed by a admin" do
+      before do
+        create_ability_accessed_by :admin_tie
+      end
+
+      it_should_behave_like "Denies Creating"
+      it_should_behave_like "Allows Reading"
+      it_should_behave_like "Allows Updating"
+      it_should_behave_like "Allows Destroying"
+    end
+
+    describe "accessed by same admin" do
+      before do
+        u = @tie.sender.subject
+        @ability = Ability.new(u)
+      end
+
+      it_should_behave_like "Allows Creating"
+      it_should_behave_like "Allows Reading"
+      it_should_behave_like "Allows Updating"
+      it_should_behave_like "Allows Destroying"
+    end
+    
+    describe "accessed by different user" do
+      before do
+        create_ability_accessed_by :user_tie
+      end
+
+      it_should_behave_like "Denies Creating"
+      it_should_behave_like "Allows Reading"
+      it_should_behave_like "Allows Updating"
+      it_should_behave_like "Allows Destroying"
+    end
+
+    describe "accessed by follower" do
+      before do
+        create_ability_accessed_by :follower_tie
+      end
+
+      it_should_behave_like "Denies Creating"
+      it_should_behave_like "Denies Reading"
+      it_should_behave_like "Denies Updating"
+      it_should_behave_like "Denies Destroying"
+    end
+  end
+
+  describe "belonging to follower tie" do
+    before do
+      create_activity_assigned_to(Factory(:user_tie).related('follower'))
+    end
+    
+    describe "accessed by an admin" do
+      before do
+        create_ability_accessed_by :admin_tie
+      end
+
+      it_should_behave_like "Denies Creating"
+      it_should_behave_like "Allows Reading"
+      it_should_behave_like "Allows Updating"
+      it_should_behave_like "Allows Destroying"
+    end
+
+    describe "accessed by user" do
+      before do
+        create_ability_accessed_by :user_tie
+      end
+
+      it_should_behave_like "Denies Creating"
+      it_should_behave_like "Allows Reading"
+      it_should_behave_like "Allows Updating"
+      it_should_behave_like "Allows Destroying"
+    end
+
+    describe "accessed by same sender" do
+      before do
+        u = @tie.sender.subject
+        @ability = Ability.new(u)
+      end
+
+      it_should_behave_like "Allows Creating"
+      it_should_behave_like "Allows Reading"
+      it_should_behave_like "Allows Updating"
+      it_should_behave_like "Allows Destroying"
+    end
+
+    describe "accessed by different follower" do
+      before do
+        create_ability_accessed_by :follower_tie
+      end
+
+      it_should_behave_like "Denies Creating"
+      it_should_behave_like "Allows Reading"
+      it_should_behave_like "Denies Updating"
+      it_should_behave_like "Denies Destroying"
+    end
+  end
+
+  describe "belonging to follower tie from a follower" do
+    before do
+      create_activity_assigned_to(Factory(:follower_tie))
+      u = @tie.sender.subject
+      @ability = Ability.new(u)
+    end
+    
+    it_should_behave_like "Denies Creating"
+  end
+
+end