pacecar 1.5.2 → 1.5.3

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

@@ -0,0 +1,191 @@
+(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;
+    });
+  });
+
+  Ajax.Responders.register({
+    onCreate: function(request) {
+      var csrf_meta_tag = $$('meta[name=csrf-token]')[0];
+
+      if (csrf_meta_tag) {
+        var header = 'X-CSRF-Token',
+            token = csrf_meta_tag.readAttribute('content');
+
+        if (!request.options.requestHeaders) {
+          request.options.requestHeaders = {};
+        }
+        request.options.requestHeaders[header] = token;
+      }
+    }
+  });
+})();

data/spec/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/spec/duration_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe 'Duration' do
+
+  before do
+    @same_user = Factory :user, :created_at => 15.days.ago.midnight, :updated_at => 15.days.ago.midnight
+    @updated_user = Factory :user, :created_at => 15.days.ago.midnight, :updated_at => 1.days.ago.midnight
+  end
+
+  it "should set the correct expected values for a with_duration_of datetime column method" do
+    User.with_duration_of(14, :created_at, :updated_at).should == [@updated_user]
+  end
+
+  it "should set the correct expected values for a with_duration_over datetime column method" do
+    User.with_duration_over(10, :created_at, :updated_at).should == [@updated_user]
+  end
+
+  it "should set the correct expected values for a with_duration_under datetime column method" do
+    User.with_duration_under(10, :created_at, :updated_at).should == [@same_user]
+  end
+
+end

data/spec/factories.rb

@@ -0,0 +1,26 @@
+FactoryGirl.define do
+
+  sequence :age do |n|
+    n.to_i
+  end
+
+  sequence :rating do |n|
+    n.to_f
+  end
+
+  factory :comment do
+    association :user
+  end
+
+  factory :mammal do
+  end
+
+  factory :post do
+  end
+
+  factory :user do
+    age     { Factory.next :age }
+    rating  { Factory.next :rating }
+  end
+
+end

data/spec/helpers_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe 'Helpers' do
+
+  describe "A class without a db table" do
+    it "should return an empty array when asked about #safe_columns" do
+      Article.send(:safe_columns).should == []
+    end
+
+    it "should survive an include of Pacecar" do
+      lambda { Article.send :include, Pacecar }.should_not raise_error
+    end
+  end
+
+  describe "A class with a db table" do
+    it "should  should return columns for #safe_column_names" do
+      Comment.safe_column_names.should == ['id', 'user_id', 'description', 'rating', 'created_at', 'updated_at']
+    end
+  end
+
+  describe "A class with many column types" do
+    it "should return boolean columns for #boolean_column_names" do
+      User.boolean_column_names.should == ['admin']
+    end
+
+    it "should return non boolean columns for #non_boolean_column_names" do
+      User.non_boolean_column_names.should == ['id', 'approved_at', 'rejected_at', 'last_posted_on', 'first_name', 'last_name', 'description', 'age', 'rating', 'balance', 'created_at', 'updated_at']
+    end
+
+    it "should  return datetime columns for #datetime_column_names" do
+      User.datetime_column_names.should == ['approved_at', 'rejected_at', 'last_posted_on', 'created_at', 'updated_at']
+    end
+
+    it "should  return text and string columns for #text_and_string_column_names" do
+      User.text_and_string_column_names.should == ['first_name', 'last_name', 'description']
+    end
+
+    it "should  return numeric columns for #numeric_column_names" do
+      User.numeric_column_names.should == ['id', 'age', 'rating', 'balance']
+    end
+  end
+
+  describe "A class with a state column should" do
+    it "should return all non state text and string columns for #non_state_text_and_string_column_names" do
+      Post.non_state_text_and_string_columns.should == ['title', 'body']
+    end
+  end
+
+end

data/spec/integration/navigation_spec.rb

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

data/spec/limit_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe 'Limit' do
+
+  before do
+    50.times { Factory :user }
+  end
+
+  it "should set the correct expected values for a by_ column method" do
+    User.count.should == 50
+    User.limited.all.size.should == 10
+  end
+
+  it "should set the correct expected values for a by_ column method when sent args" do
+    User.count.should == 50
+    User.limited(20).all.size.should == 20
+  end
+
+  it "should set the correct expected values for a by_ column method when per_page defined" do
+    User.expects(:per_page).returns 30
+    User.count.should == 50
+    User.limited.all.size.should == 30
+  end
+
+end

data/spec/numeric_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe 'Numeric' do
+
+  before do
+    @young = Factory :user, :age => 11, :rating => 10.0
+    @legal = Factory :user, :age => 21, :rating => 7.5
+    @older = Factory :user, :age => 31, :rating => 5.0
+  end
+
+  it "should set the correct expected values for a _greater_than column method for an integer column" do
+    User.age_greater_than(21).should == [@older]
+  end
+
+  it "should set the correct expected values for a _greater_than_or_equal_to column method for an integer column" do
+    User.age_greater_than_or_equal_to(21).should == [@legal, @older]
+  end
+
+  it "should set the correct expected values for a _less_than column method for an integer column" do
+    User.age_less_than(21).should == [@young]
+  end
+
+  it "should set the correct expected values for a _less_than_or_equal_to column method for an integer column" do
+    User.age_less_than_or_equal_to(21).should == [@young, @legal]
+  end
+
+  it "should set the correct expected values for a _greater_than column method for a float column" do
+    User.rating_greater_than(7.5).should == [@young]
+  end
+
+  it "should set the correct expected values for a _greater_than_or_equal_to column method for a float column" do
+    User.rating_greater_than_or_equal_to(7.5).should == [@young, @legal]
+  end
+
+  it "should set the correct expected values for a _less_than column method for a float column" do
+    User.rating_less_than(7.5).should == [@older]
+  end
+
+  it "should set the correct expected values for a _less_than_or_equal_to column method for a float column" do
+    User.rating_less_than_or_equal_to(7.5).should == [@legal, @older]
+  end
+
+end

data/spec/order_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe 'Order' do
+
+  before do
+    @first = Factory :user, :first_name => 'Abe'
+    @last  = Factory :user, :first_name => 'Zed'
+  end
+
+  it "should set the correct expected values for a by_ column method with no args" do
+    User.by_first_name.should == [@first, @last]
+  end
+
+  it "should set the correct expected values for a by_ column method with asc args" do
+    User.by_first_name(:asc).should == [@first, @last]
+  end
+
+  it "should set the correct expected values for a by_ column method with desc args" do
+    User.by_first_name(:desc).should == [@last, @first]
+  end
+
+end

data/spec/pacecar_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Pacecar do
+  it "should be valid" do
+    Pacecar.should be_a(Module)
+  end
+end

data/spec/polymorph_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe 'Polymorph' do
+
+  before do
+    @owned_by_user = Factory :post, :owner_type => 'User'
+    @owned_by_mammal = Factory :post, :owner_type => 'Mammal'
+  end
+
+  it "should set the correct expected values on a _for column method with Class" do
+    Post.for_owner_type(User).should == [@owned_by_user]
+  end
+
+  it "should set the correct expected values on a _for column method with String" do
+    Post.for_owner_type('User').should == [@owned_by_user]
+  end
+
+end

data/spec/presence_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe 'Presence' do
+
+  before do
+    @not_null = Factory :user, :first_name => 'Fake'
+    @null = Factory :user, :first_name => nil
+  end
+
+  it "should set the correct expected values for a _present column method" do
+    User.first_name_present.should == [@not_null]
+  end
+
+  it "should set the correct expected values for a _missing column method" do
+    User.first_name_missing.should == [@null]
+  end
+
+  it "should not setup methods for boolean columns" do
+    lambda { User.admin_missing }.should raise_error(NoMethodError)
+    lambda { User.admin_present }.should raise_error(NoMethodError)
+  end
+
+end