streamit 0.0.0 → 0.0.1

data/test/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/test/dummy/public/stylesheets/scaffold.css

@@ -0,0 +1,56 @@
+body { background-color: #fff; color: #333; }
+
+body, p, ol, ul, td {
+  font-family: verdana, arial, helvetica, sans-serif;
+  font-size:   13px;
+  line-height: 18px;
+}
+
+pre {
+  background-color: #eee;
+  padding: 10px;
+  font-size: 11px;
+}
+
+a { color: #000; }
+a:visited { color: #666; }
+a:hover { color: #fff; background-color:#000; }
+
+div.field, div.actions {
+  margin-bottom: 10px;
+}
+
+#notice {
+  color: green;
+}
+
+.field_with_errors {
+  padding: 2px;
+  background-color: red;
+  display: table;
+}
+
+#error_explanation {
+  width: 450px;
+  border: 2px solid red;
+  padding: 7px;
+  padding-bottom: 0;
+  margin-bottom: 20px;
+  background-color: #f0f0f0;
+}
+
+#error_explanation h2 {
+  text-align: left;
+  font-weight: bold;
+  padding: 5px 5px 5px 15px;
+  font-size: 12px;
+  margin: -7px;
+  margin-bottom: 0px;
+  background-color: #c00;
+  color: #fff;
+}
+
+#error_explanation ul li {
+  font-size: 12px;
+  list-style: square;
+}

data/test/dummy/script/rails

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# 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/test/integration/navigation_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+class NavigationTest < ActiveSupport::IntegrationCase
+  
+  def register_new_user
+    visit "/users/new"
+    fill_in "Name", :with => "davis"
+    click_button "Create User"
+  end
+  
+  should "fetch recent streams" do
+    register_new_user
+    register_new_user
+    visit "/streamit/fetch"
+    assert page.has_selector?("li.stream", :count => 2), "Expected 2 streams, Got:\n#{page.body.inspect}"
+  end
+  
+  should "fetch streams in last ? seconds" do
+    Timecop.freeze(Time.now - 30.seconds) do
+      register_new_user
+    end
+    register_new_user
+    register_new_user
+    visit "/streamit/fetch?ago=30"
+    assert page.has_selector?("li.stream", :count => 2), "Expected 2 streams, Got:\n#{page.body.inspect}"
+  end
+  
+  should "fetch streams from after an id" do
+    register_new_user
+    register_new_user
+    register_new_user
+    visit "/streamit/fetch?after=#{Stream.last.id}"
+    assert page.has_selector?("li.stream", :count => 2), "Expected 2 streams, Got:\n#{page.body.inspect}"
+  end
+
+end

data/test/store_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+class StoreTest < ActiveSupport::TestCase
+  setup do
+    @user = TestUser.create(:name => 'davis')
+  end
+  
+  def default_args
+    { :stream_type => 'streamit.example', 
+      :actor       => @user, 
+      :receiver    => @user, 
+      :subject     => @user,
+      :started_at  => Time.now }
+  end
+
+  def store!(args=default_args)
+    stream = Stream.new(args)
+  end
+  
+  should "set the type" do
+    assert_equal "streamit.example", store!.stream_type
+  end
+
+  should "set started at" do
+    assert_kind_of Time, store!.started_at
+  end
+  
+  should "translate type to meaningful words" do
+    I18n.backend.store_translations :en,
+      :streamit => { :example => "just an example" }
+  
+    assert_equal "just an example", store!.stream_type_in_words
+    I18n.reload!
+  end
+  
+end

data/test/streamit_test.rb

@@ -0,0 +1,118 @@
+require 'test_helper'
+
+class StreamitTest < ActiveSupport::TestCase
+  def stream_store
+    Streamit.store
+  end
+  
+  context "when user watches an item" do
+    setup do
+      TestWatching.class_eval do
+        stream :create, :actor => :watcher, :subject => :watched_item
+      end
+      @watch = TestWatching.new(:watcher => TestUser.create!, :watched_item => TestItem.create!)
+    end
+    
+    should "create a stream if watching is created successfully" do
+      @watch.save
+      stream = stream_store.last
+      assert_not_nil stream
+      assert_equal "streamit.testwatchings.create",  stream.stream_type
+      assert_equal @watch.watcher,      stream.actor      
+      assert_equal @watch.watched_item, stream.subject
+      assert_nil stream.receiver
+    end
+    
+    should "not create a stream if failed to create a watching" do
+      TestWatching.class_eval do
+        before_create { return false }
+      end
+      assert_no_difference("stream_store.count") { @watch.save }
+    end
+  end
+  
+  context "when create or update a user" do
+    setup do
+      @user = TestUser.new
+      @user.singleton_class.class_eval do
+        def self.name; "TestUser"; end
+      end
+    end
+    
+    should "create a stream" do
+      @user.singleton_class.class_eval do
+        stream :create
+      end
+      @user.save
+      stream = stream_store.last
+      assert_not_nil stream
+      assert_equal "streamit.testusers.create", stream.stream_type
+      assert_equal @user, stream.actor
+      assert_nil stream.subject
+      assert_nil stream.receiver
+    end
+
+    context "when user updates her attributes" do
+      setup do
+        @user.save
+      end
+
+      should "create a stream the attribute specified has changed" do
+        @user.singleton_class.class_eval do
+          stream :update, :attributes => :image_url
+        end
+        @user.image_url = "image"
+        @user.save
+        stream = stream_store.last
+        assert_not_nil stream
+        assert_equal "streamit.testusers.update.image_url", stream.stream_type
+        assert_equal @user, stream.actor
+        assert_nil stream.subject
+        assert_nil stream.receiver
+      end
+
+      should "create a stream if any attributes have changed" do
+        @user.singleton_class.class_eval do
+          stream :update
+        end
+        @user.name = "davis"
+        @user.save
+        stream = stream_store.last
+        assert_not_nil stream
+        assert_equal "streamit.testusers.update.default", stream.stream_type
+        assert_equal @user, stream.actor
+        assert_nil stream.subject
+        assert_nil stream.receiver
+      end
+
+      should "create a stream if any attributes specified have changed" do
+        @user.singleton_class.class_eval do
+          stream :update, :attributes => [:name, :image_url]
+        end
+        @user.name = "davis"
+        @user.save
+        stream = stream_store.last
+        assert_not_nil stream
+        assert_equal "streamit.testusers.update.default", stream.stream_type
+        assert_equal @user, stream.actor
+        assert_nil stream.subject
+        assert_nil stream.receiver
+      end
+
+      should "not create a stream if no attributes has changed" do
+        assert_no_difference("stream_store.count") { @user.save }
+      end
+
+      should "not create a stream if no attributes specified has changed" do
+        @user.singleton_class.class_eval do
+          stream :update, :attributes => :name
+        end
+        @user.image_url = "image"
+        @user.save
+        assert_equal 0, stream_store.count
+      end
+    end
+  end
+
+end
+

data/test/support/fixtures.rb

@@ -0,0 +1,14 @@
+class TestUser < ActiveRecord::Base
+  self.table_name = "users"
+end
+
+class TestItem < ActiveRecord::Base
+  self.table_name = "items"
+end
+
+class TestWatching < ActiveRecord::Base
+  self.table_name = "watchings"
+  
+  belongs_to :watcher,      :class_name => "TestUser", :foreign_key => "user_id"
+  belongs_to :watched_item, :class_name => "TestItem", :foreign_key => "item_id"
+end