liquid_cms 0.2.2.0 → 0.3.0

data/test/rails_app/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/rails_app/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/test_helper.rb

@@ -1,15 +1,14 @@
 ENV["RAILS_ENV"] = "test"
 
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
 $:.unshift File.dirname(__FILE__)
 
 require "rails_app/config/environment"
-require 'test_help'
-
-if ENV['NO_CONTEXT'] == 'true'
-  Cms.setup do |config|
-    config.context_class = nil
-  end
-end
+require 'rails/test_help'
+require 'ostruct'
 
 ActiveRecord::Migration.verbose = false
 ActiveRecord::Base.logger = Logger.new(nil)
@@ -17,33 +16,19 @@ ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":me
 
 ActiveRecord::Migrator.migrate(File.join(File.dirname(__FILE__), "rails_app/db/migrate/"), nil)
 
-require 'rubygems'
-require 'ostruct'
-require 'shoulda'
-require 'factory_girl'
-
 Factory.definition_file_paths << "#{File.dirname(__FILE__)}/factories"
 Factory.find_definitions
 
 module TestConfig
   mattr_reader :paperclip_test_root
-  @@paperclip_test_root = File.join(File.dirname(__FILE__), 'paperclip')
+  @@paperclip_test_root = File.join(File.expand_path(File.dirname(__FILE__)), 'rails_app', 'test', 'fixtures')
 end
 
 require 'test_helpers/login_methods'
-require 'test_helpers/asset_helpers'
-require 'test_helpers/component_helpers'
 
-class ActionController::TestCase
-  include AssetHelpers
-end
 class ActiveSupport::TestCase
-  include AssetHelpers
-  include ComponentHelpers
-end
-
+  include ActionDispatch::TestProcess
 
-class ActiveSupport::TestCase
   self.use_transactional_fixtures = true
   self.use_instantiated_fixtures = false
 end

data/test/unit/asset_test.rb

@@ -1,199 +1,8 @@
-require File.expand_path('../../test_helper', __FILE__)
+require File.dirname(__FILE__) + '/../test_helper'
 
 class Cms::AssetTest < ActiveSupport::TestCase
-  def setup
-    @context = Factory(:company)
-  end
-
-  def teardown
-    cleanup_assets
-  end
-
-  context "asset field" do
-    setup do
-      @asset = Factory(:image_asset, :context => @context)
-      @fname = File.expand_path('../../rails_app/public/images/rails.png', __FILE__)
-    end
-
-    should "have a valid custom file" do
-      %w(original tiny thumb custom).each do |type|
-        assert_nil @asset.asset.to_file(type)
-      end
-
-      @asset.asset = nil
-      @asset.asset = File.open(@fname)
-      @asset.save
-
-      %w(original tiny thumb custom).each do |type|
-        assert_not_nil @asset.asset.to_file(type)
-      end
-    end
-
-    should "create an image with a custom size" do
-      # check normal size first
-      @asset.asset = File.open(@fname)
-      @asset.save
-
-      assert_equal '50x64', Paperclip::Geometry.from_file(@asset.asset.path(:custom)).to_s
-
-      # assign custom dimensions
-      @asset.custom_width = 5
-      @asset.custom_height = 5
-      @asset.save
-
-      # check new dimensions
-      assert_equal '4x5', Paperclip::Geometry.from_file(@asset.asset.path(:custom)).to_s
-    end
-
-    should "correctly create a custom asset while assigning the asset and dims at the same time" do
-      asset_attrs = {:asset => File.open(@fname), :custom_height => '10', :custom_width => '5'}
-      @asset.assign_ordered_attributes asset_attrs
-      @asset.save
-      assert_equal '50x64', Paperclip::Geometry.from_file(@asset.asset.path(:original)).to_s
-      assert_equal '5x6', Paperclip::Geometry.from_file(@asset.asset.path(:custom)).to_s
-    end
-  end
-
-  context "type checks" do
-    setup do
-      @asset = Factory(:image_asset, :context => @context)
-    end
-
-    context "new image" do
-      setup do
-        @asset = Cms::Asset.new
-      end
-
-      should "not be an image" do
-        assert !@asset.image?
-      end
-      should "not be an icon" do
-        assert !@asset.icon?
-      end
-      should "not be editable" do
-        assert !@asset.editable?
-      end
-      should "not be able to read or write" do
-        assert_equal '', @asset.file_content
-        assert_equal false, @asset.send(:write, 'test')
-        assert_equal 'test', @asset.file_content=('test')
-        assert_equal '', @asset.file_content
-      end
-    end
-
-    context "image" do
-      should "be an image" do
-        assert @asset.image?
-      end
-      should "not be an icon" do
-        assert !@asset.icon?
-      end
-      should "not be editable" do
-        assert !@asset.editable?
-      end
-      should "not be able to read or write" do
-        assert_equal '', @asset.file_content
-        assert_equal false, @asset.send(:write, 'test')
-        assert_equal 'test', @asset.file_content=('test')
-        assert_equal '', @asset.file_content
-      end
-    end
-
-    context "icon" do
-      setup do
-        @asset.update_attribute :asset_content_type, 'image/ico'
-      end
-      should "be an image" do
-        assert @asset.image?
-      end
-      should "be an icon" do
-        assert @asset.icon?
-      end
-      should "not be editable" do
-        assert !@asset.editable?
-      end
-      should "not be able to read or write" do
-        assert_equal '', @asset.file_content
-        assert_equal false, @asset.send(:write, 'test')
-        assert_equal 'test', @asset.file_content=('test')
-        assert_equal '', @asset.file_content
-      end
-    end
-
-    context "javascript" do
-      setup do
-        @asset.update_attributes :asset_content_type => 'text/javascript', :asset_file_name => 'test.js'
-        setup_asset @asset.asset.path(:original)
-      end
-
-      should "not be an image" do
-        assert !@asset.image?
-      end
-      should "not be an icon" do
-        assert !@asset.icon?
-      end
-      should "be editable" do
-        assert @asset.editable?
-      end
-      should "be able to read or write" do
-        assert_equal true, @asset.send(:write, "alert('test')")
-        assert_equal "alert('test')", @asset.file_content=("alert('test')")
-        assert_equal "alert('test')\n", @asset.file_content
-      end
-    end
-  end
-
-  context "tags" do
-    setup do
-      @asset = Factory(:image_asset, :context => @context)
-    end
-    
-    should "be untagged" do
-      assert_nil @context.assets.tagged.find_by_id(@asset.id)
-      assert_not_nil @context.assets.untagged.find_by_id(@asset.id)
-    end
-
-    should "be tagged" do
-      @asset.tag_list = "test, this stuff"
-      @asset.save
-
-      assert_not_nil @context.assets.tagged.find_by_id(@asset.id)
-      assert_not_nil @context.assets.tagged_with('test').find_by_id(@asset.id)
-      assert_not_nil @context.assets.tagged_with('this').find_by_id(@asset.id)
-      assert_not_nil @context.assets.tagged_with('stuff').find_by_id(@asset.id)
-      assert_nil @context.assets.tagged_with('notthis').find_by_id(@asset.id)
-      assert_nil @context.assets.untagged.find_by_id(@asset.id)
-    end
-  end
-
-  context "meta data" do
-    setup do
-      @asset = Factory(:image_asset, :context => @context)
-    end
-
-    should "assign meta data" do
-      @asset.meta = {'new_1' => {:name => 'test name 1', :value => 'test value 1'}, 'new_2' => {:name => ' ', :value => 'test value 2'}}
-      assert @asset.meta_data.is_a?(Array)
-      assert_equal 2, @asset.meta_data.length
-    end
-
-    should "validate" do
-      @asset.meta = {'new_1' => {:name => 'test name 1', :value => 'test value 1'}, 'new_2' => {:name => ' ', :value => 'test value 2'}}
-      assert !@asset.valid?
-      assert_equal "is invalid", @asset.errors.on(:meta_data)
-      assert_equal "is an invalid format", @asset.meta[0].errors.on(:name)
-      assert_equal "must be set", @asset.meta[1].errors.on(:name)
-
-      @asset.meta = {'new_1' => {:name => 'test_name', :value => 'test value 1'}, 'new_2' => {:name => 'new_$', :value => 'test value 2'}}
-      assert !@asset.valid?
-      assert_equal "is invalid", @asset.errors.on(:meta_data)
-      assert @asset.meta[0].errors.empty?
-      assert_equal "is an invalid format", @asset.meta[1].errors.on(:name)
-      
-      @asset.meta = {'new_1' => {:name => 'test_name', :value => 'test value 1'}, 'new_2' => {:name => 'new_2', :value => 'test value 2'}}
-      assert @asset.valid?
-      assert @asset.meta[0].errors.empty?
-      assert @asset.meta[1].errors.empty?
-    end
+  # Replace this with your real tests.
+  test "the truth" do
+    assert true
   end
 end

data/test/unit/page_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path('../../test_helper', __FILE__)
+require File.dirname(__FILE__) + '/../test_helper'
 
 class Cms::PageTest < ActiveSupport::TestCase
   def setup
@@ -29,21 +29,21 @@ class Cms::PageTest < ActiveSupport::TestCase
     should "return blank errors" do
       page = @company.pages.create
       assert_equal 2, page.errors.length
-      assert_equal "is invalid", page.errors[:name]
-      assert_equal "can't be blank", page.errors[:content]
+      assert_equal "is invalid", page.errors[:name].first
+      assert_equal "can't be blank", page.errors[:content].first
 
       page = @company.pages.create :published => true
       assert_equal 2, page.errors.length
-      assert_equal "is invalid", page.errors[:name]
-      assert_equal "can't be blank", page.errors[:content]
+      assert_equal "is invalid", page.errors[:name].first
+      assert_equal "can't be blank", page.errors[:content].first
     end
     
     should "not allow duplicates" do
       # same company, duplicate fails
       page = @company.pages.create :name => @company.pages.first.name, :content => 'Test', :slug => @company.pages.first.slug
       assert_equal 2, page.errors.length
-      assert_equal "has already been taken", page.errors[:name]
-      assert_equal "has already been taken", page.errors[:slug]
+      assert_equal "has already been taken", page.errors[:name].first
+      assert_equal "has already been taken", page.errors[:slug].first
 
       # multiple blank slugs can be saved
       page = @company.pages.create :name => 'new_name_1', :content => 'Test'
@@ -61,13 +61,13 @@ class Cms::PageTest < ActiveSupport::TestCase
       should "check valid formats" do
         page = Factory(:page, :context => @company) 
         page.update_attributes :name => 'test_123'
-        assert_nil page.errors.on(:name)
+        assert page.errors[:name].empty?
         page.update_attributes :name => 'test_123-test'
-        assert_nil page.errors.on(:name)
+        assert page.errors[:name].empty?
         page.update_attributes :name => 'test_123-test/test'
-        assert_not_nil page.errors.on(:name)
+        assert !page.errors[:name].empty?
         page.update_attributes :name => 'test_123-test.test'
-        assert_nil page.errors.on(:name)
+        assert page.errors[:name].empty?
       end
     end
 
@@ -114,17 +114,17 @@ class Cms::PageTest < ActiveSupport::TestCase
       should "reject any slugs that match namespaced controllers" do
         page = @company.pages.create @options.merge(:slug => '/cms')
         assert_equal 1, page.errors.length
-        assert_equal "is reserved and can't be used for this page", page.errors[:slug]
+        assert_equal "is reserved and can't be used for this page", page.errors[:slug].first
 
         page = @company.pages.create @options.merge(:slug => '/cms')
         assert_equal 1, page.errors.length
-        assert_equal "is reserved and can't be used for this page", page.errors[:slug]
+        assert_equal "is reserved and can't be used for this page", page.errors[:slug].first
       end
       
       should "reject a reserved name" do
         page = @company.pages.create @options.merge(:slug => '/cms/assets')
         assert_equal 1, page.errors.length
-        assert_equal "is reserved and can't be used for this page", page.errors[:slug]
+        assert_equal "is reserved and can't be used for this page", page.errors[:slug].first
       end
 
       should "confirm reserved paths" do
@@ -183,7 +183,7 @@ class Cms::PageTest < ActiveSupport::TestCase
       page = Factory.build(:page, :context => @company, :slug => '/testpage', :published => true, :root => true, :content => "{{ content_for_layout }}")
       page.save
       %w(slug published root).each do |attr|
-        assert_equal "can't be set for a layout page", page.errors.on(attr)
+        assert_equal "can't be set for a layout page", page.errors[attr].first
       end
     end
   end