motiro 0.6.8 → 0.6.9

data/vendor/mediacloth-trunk/test/linkhandler.rb

@@ -0,0 +1,39 @@
+require 'mediacloth/mediawikilinkhandler'
+
+require 'test/unit'
+require 'testhelper'
+
+class LinkHandler_Test < Test::Unit::TestCase
+
+  def test_resolves_single_links
+    handler = create_handler
+    assert_equal '<a href="http://example.com/wiki/MyPage">this is my page</a>',
+                 handler.link_for('MyPage', 'this is my page')
+  end
+
+  def test_forgets_previous_links
+    handler = create_handler
+    handler.link_for('MyPage', 'this is my page')
+    assert_equal '<a href="http://example.com/wiki/YourPage">this page is yours</a>',
+                 handler.link_for('YourPage', 'this page is yours')
+  end
+
+  def test_provides_suitable_elem_method_for_subclasses
+    handler = create_handler
+    def handler.link_for(page, text)
+      elem.span(:class => 'empty') {|x| x << text }
+    end
+    assert_equal '<span class="empty">Here is my page</span>',
+                 handler.link_for('MyPage', 'Here is my page')
+  end
+
+private
+
+  def create_handler
+    handler = MediaWikiLinkHandler.new
+    def handler.url_for(page); "http://example.com/wiki/#{page}"; end
+    handler
+  end
+
+end
+

data/vendor/mediacloth-trunk/test/parser.rb

@@ -0,0 +1,22 @@
+require 'mediacloth/mediawikilexer'
+require 'mediacloth/mediawikiparser'
+
+require 'test/unit'
+require 'testhelper'
+require 'debugwalker'
+
+class Parser_Test < Test::Unit::TestCase
+
+    include TestHelper
+
+    def test_input
+        test_files("result") { |input,result|
+            parser = MediaWikiParser.new
+            parser.lexer = MediaWikiLexer.new
+            ast = parser.parse(input)
+            walker = DebugWalker.new
+            walker.parse(ast)
+        }
+    end
+
+end

data/vendor/mediacloth-trunk/test/testhelper.rb

@@ -0,0 +1,27 @@
+module TestHelper
+
+    #Helper method for file-based comparison tests.
+    #
+    #Looks in "data/" directory for files named "inputXXX",
+    #substitutes "input" with baseName and loads the contents
+    #of "inputXXX" file into the "input" variable and the
+    #contents of "baseNameXXX" into the "result" variable.
+    #
+    #Then it calls the block with input and result as parameters.
+    def test_files(baseName, &action)
+        Dir.glob(File.dirname(__FILE__) + "/data/input*").each do |filename|
+            resultname = filename.gsub(/input(.*)/, "#{baseName}\\1")
+            #exclude backup files
+            if not resultname.include?("~")
+                input_file = File.new(filename, "r")
+                input = input_file.read
+                if File.exists?(resultname)
+                    result_file = File.new(resultname, "r")
+                    result = result_file.read
+
+                    yield(input, result, resultname)
+                end
+            end
+        end
+    end
+end

data/vendor/mediacloth.rb

@@ -0,0 +1,3 @@
+$:.push File.expand_path(File.dirname(__FILE__) + '/mediacloth-trunk/lib/')
+
+require 'mediacloth-trunk/lib/mediacloth'

data/vendor/motiro-installer.rb

@@ -1,5 +1,5 @@
 #  Motiro - A project tracking tool
-#  Copyright (C) 2006-2007  Thiago Arrais
+#  Copyright (C) 2006-2008  Thiago Arrais
 #  
 #  This program is free software; you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by

data/vendor/plugins/cache_test-0.2/CHANGELOG

@@ -0,0 +1,14 @@
+*0.2* (October 17th, 2006)
+
+* overrides default page caching method to record page cached and
+  expired and use that information instead of going to the filesystem
+  to see if cached file exists or not.
+
+* add unit testing
+
+* add method for action and fragment caching
+
+*0.1* (October 5th, 2006)
+
+* first plugin release
+

data/vendor/plugins/cache_test-0.2/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006 Damien Merenne
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/plugins/cache_test-0.2/README

@@ -0,0 +1,124 @@
+= Cache Test Plugin
+
+This plugin adds assertions in test cases to check the caching 
+logic of your application.
+
+
+== 1. Installation
+
+Unpack into the vendor/plugin and that should be it.
+
+== 2. Usage
+
+=== Testing page caching
+
+First create an integration test. Then, to test caching of the
+"/pages/about" and "/pages/contact" pages, add a method like this:
+
+  def test_caching
+    assert_cache_pages("/pages/about", "/pages/contact")
+  end
+
+The assert_cache_pages method will
+
+- first make sure that the urls are not cached,
+- execute a get on each request,
+- assert that the corresponding cache files have been created.
+
+You can also give a block to the assert_cache_pages method. Instead
+of executing a get on each url, it will yield the urls. For example:
+
+  def test_caching
+    assert_cache_pages("/pages/about", "/pages/contact") do |url_about, url_contact|
+      post url_about
+      post url_contact
+    end
+  end
+
+=== Testing expiration of pages
+
+You will also certainly want (and that's really the most interesting
+part) to check if your cached pages expires when the user is doing
+some action. For that, here is the assert_expire method:
+
+  def test_expiring
+    assert_expire_pages("/news/list", "/news/show/1") do |*urls|
+      post "/news/delete/1"
+    end
+  end
+
+Here the assert_expire_pages method will 
+
+- check that the urls are cached,
+- execute the post request,
+- and assert that the urls are no more cached.
+
+This is great for testing your cache sweepers logic.
+
+=== Testing action caching
+
+To test caching of the "bar" action of the foo "controller"
+in an integration test, do
+
+  assert_cache_actions(:controller => "foo", :action => "bar") do
+    get "/foo/bar"
+  end
+
+The assert_cache_actions method will
+- first make sure that the actions are not cached,
+- yield the given block
+- assert that the corresponding action fragment have been stored.
+
+=== Testing expiration of actions
+
+To check that some actions are expired, use the assert_expire_actions method:
+
+  assert_expire_actions(:controller => "foo", :action => "bar") do |*urls|
+    post "/foo/expire_cache"
+  end
+
+Here the assert_expire_actions method will 
+
+- check that the actions fragments are cached,
+- execute the post request,
+- and assert that the fragments are no more cached.
+
+In functional test, there can be only one controller, so you are
+not required to give the :controller option and if they are no
+parameters to the action, you can simply call 
+
+  assert_cache_actions(:foo, :bar) do
+    get :bar
+    get :foo
+  end
+
+== Testing fragments caching
+
+To check that your fragments are cached when doing some action,
+do
+
+  assert_cache_fragments(:controller => "foo", :action => "bar", :action_suffix => "baz") do
+    get "/foo/bar"
+  end
+
+== Testing expiration of fragments
+
+To check that your fragments are expired when doing some action,
+do
+
+  assert_expire_fragments(:controller => "foo", :action => "bar", :action_suffix => "baz") do
+    get "/foo/expire"
+  end
+
+In functional test, your not required to give the :controller option.
+
+== 3. License
+
+This plugin is licensed under the MIT license. Complete license text
+is included in the MIT-LICENSE[link:files/MIT-LICENSE.html] file.
+
+== 4. Author
+
+This plugin was created by Damien Merenne <dam@cosinux.org> and is
+located at http://blog.cosinux.org/pages/page-cache-test.
+

data/vendor/plugins/cache_test-0.2/init.rb

@@ -0,0 +1,8 @@
+if RAILS_ENV == "test"
+  require 'page_cache_test'
+  require 'fragment_cache_test'
+  
+  Cosinux::PageCacheTest.configure
+  Cosinux::FragmentCacheTest.configure
+end
+

data/vendor/plugins/cache_test-0.2/lib/fragment_cache_test.rb

@@ -0,0 +1,205 @@
+module Cosinux
+  module FragmentCacheTest #:nodoc:
+    class NoRequestInBlockError < StandardError #:nodoc:
+    end
+
+    class NoControllerDefinedError < StandardError #:nodoc:
+    end
+
+    # This fragment store remembers the fragments that have been 
+    # cached or deleted so that we can use it to check if
+    # caching or expiring of fragment was done or not.
+    class TestStore < ActionController::Caching::Fragments::MemoryStore #:nodoc:
+      attr_reader :written, :deleted, :deleted_matchers
+      
+      def initialize
+        super
+        @written = []
+        @deleted = []
+        @deleted_matchers = []
+      end
+                    
+      def reset
+        @data.clear
+        @written.clear
+        @deleted.clear
+        @deleted_matchers.clear
+      end
+      
+      def write(name, value, options = nil)
+        @written.push(name)
+        super
+      end
+      
+      def delete(name, options = nil)
+        @deleted.push(name)
+        super
+      end
+      
+      def delete_matched(matcher, options = nil)
+        @deleted_matchers.push(matcher)
+      end
+      
+      def written?(name)
+        @written.include?(name)
+      end
+      
+      def deleted?(name)
+        @deleted.include?(name) || @deleted_matchers.detect { |matcher| name =~ matcher }
+      end
+    end
+    
+    def self.configure #:nodoc:
+      ActionController::Base.perform_caching = true
+      ActionController::Base.fragment_cache_store = TestStore.new
+      
+      Test::Unit::TestCase.class_eval do
+        include Assertions
+      end
+    end
+    
+    # This module define method to validate the fragment and action caching logic of
+    # your application in both integration and functional tests.
+    #
+    # == Testing action caching
+    #
+    # To test caching of the "bar" action of the foo "controller"
+    # in an integration test, do
+    #
+    #   assert_cache_actions(:controller => "foo", :action => "bar") do
+    #     get "/foo/bar"
+    #   end
+    #
+    # The assert_cache_actions method will
+    # - first make sure that the actions are not cached,
+    # - yield the given block
+    # - assert that the corresponding action fragment have been stored.
+    #
+    # == Testing expiring of actions
+    #
+    # To check that some actions are expired, use the assert_expire_actions method:
+    # 
+    #   assert_expire_actions(:controller => "foo", :action => "bar") do |*urls|
+    #     post "/foo/expire_cache"
+    #   end
+    # 
+    # Here the assert_expire_actions method will 
+    # 
+    # - check that the actions fragments are cached,
+    # - execute the post request,
+    # - and assert that the fragments are no more cached.
+    #
+    # In functional test, there can be only one controller, so you are
+    # not required to give the :controller option and if they are no
+    # parameters to the action, you can simply call 
+    #
+    #   assert_cache_actions(:foo, :bar) do
+    #     get :bar
+    #     get :foo
+    #   end
+    #
+    # == Testing fragments caching
+    #
+    # To check that your fragments are cached when doing some action,
+    # do
+    #
+    #   assert_cache_fragments(:controller => "foo", :action => "bar", :action_suffix => "baz") do
+    #     get "/foo/bar"
+    #   end
+    #
+    # == Testing expiration of fragments
+    #
+    # To check that your fragments are expired when doing some action,
+    # do
+    #
+    #   assert_expire_fragments(:controller => "foo", :action => "bar", :action_suffix => "baz") do
+    #     get "/foo/expire"
+    #   end
+    #
+    # In functional test, your not required to give the :controller option.
+    module Assertions
+      # asserts that the list of given fragment name are being cached
+      def assert_cache_fragments(*names)
+        # in integration test, we need the know the controller
+        check_options_has_controller(names) if self.is_a?(ActionController::IntegrationTest)
+        
+        fragment_cache_store.reset
+        
+        yield *names
+        
+        # if there is no variable @controller, then we haven't done any request
+        raise NoRequestInBlockError.new("no request was send while executing block.") if @controller.nil?
+        
+        names.each do |name|
+          assert_block("#{name.inspect} is not cached after executing block") do
+            fragment_cache_store.written?(@controller.fragment_cache_key(name))
+          end
+        end
+      end
+
+      # assert that the list of given fragment are being expired
+      def assert_expire_fragments(*names)
+        check_options_has_controller(names) if self.is_a?(ActionController::IntegrationTest)
+        
+        fragment_cache_store.reset
+        
+        yield *names
+
+        raise NoRequestInBlockError.new("no request was send while executing block.") if @controller.nil?
+        
+        names.each do |name|
+          assert_block("#{name.inspect} is cached after executing block") do
+            fragment_cache_store.deleted?(@controller.fragment_cache_key(name))
+          end
+        end
+      end
+
+      # assert that the given actions are being cached
+      def assert_cache_actions(*actions)
+        check_options_has_controller(actions) if self.is_a?(ActionController::IntegrationTest)
+        
+        fragment_cache_store.reset
+        
+        yield *actions
+       
+        raise NoRequestInBlockError.new("no request was send while executing block.") if @controller.nil?
+        
+        actions.each do |action|
+          action = { :action => action } unless action.is_a?(Hash)
+          assert_block("#{action.inspect} is not cached after executing block") do
+            fragment_cache_store.written?(@controller.fragment_cache_key(action))
+          end
+        end
+      end
+
+      # assert that the given actions are being expired
+      def assert_expire_actions(*actions)
+        check_options_has_controller(actions) if self.is_a?(ActionController::IntegrationTest)
+        
+        fragment_cache_store.reset
+        
+        yield *actions
+        
+        raise NoRequestInBlockError.new("no request was send while executing block.") if @controller.nil?
+        
+        actions.each do |action|
+          action = { :action => action } unless action.is_a?(Hash)
+          assert_block("#{action.inspect} is cached after executing block") do
+            fragment_cache_store.deleted?(@controller.fragment_cache_key(action))
+          end
+        end
+      end
+
+      private
+      def fragment_cache_store
+        ActionController::Base.fragment_cache_store
+      end
+      
+      def check_options_has_controller(options)
+        if option = options.detect { |option| option[:controller].nil? }
+          raise NoControllerDefinedError.new("no controller given in option #{option.inspect} in integration test")
+        end
+      end
+    end
+  end
+end

data/vendor/plugins/cache_test-0.2/lib/page_cache_test.rb

@@ -0,0 +1,140 @@
+module Cosinux #:nodoc:
+  module PageCacheTest #:nodoc:
+    
+    def self.configure #:nodoc:
+      ActionController::Base.perform_caching = true
+
+      # overwrite class caching methods
+      ActionController::Base.class_eval do
+        include ClassCachingMethods
+      end
+      
+      # include integration test methods
+      Test::Unit::TestCase.class_eval do
+        include IntegrationTestMethods
+      end
+    end
+
+    module ClassCachingMethods #:nodoc:
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.class_eval do
+          @@test_page_cached = []
+          cattr_accessor :test_page_cached
+          @@test_page_expired = []
+          cattr_accessor :test_page_expired
+        end
+      end
+      
+      module ClassMethods #:nodoc:
+        def cache_page(content, path)
+          logger.info "Cached page: #{page_cache_file(path)}"
+          test_page_cached.push(path)
+        end
+
+        def expire_page(path)
+          logger.info "Expired page: #{page_cache_file(path)}"
+          test_page_expired.push(path)
+        end
+      
+        def cached?(path)
+          test_page_cached.include?(path)
+        end
+
+        def expired?(path)
+          test_page_expired.include?(path)
+        end
+      
+        def reset_cache
+          test_page_cached.clear
+          test_page_expired.clear
+        end
+      end
+
+      def cached?(options = {})
+        self.class.cached?(url_for(options.merge({ :only_path => true, :skip_relative_url_root => true })))
+      end
+
+      def expired?(options = {})
+        self.class.expired?(url_for(options.merge({ :only_path => true, :skip_relative_url_root => true })))
+      end
+    end
+
+    # This module define method to validate the page caching logic of
+    # your application in integration tests.
+    #
+    # == Testing page caching
+    #
+    # To test caching of the "/pages/about" and "/pages/contact"
+    # pages, add a method like this: 
+    #
+    #   def test_caching
+    #     assert_cache_pages("/pages/about", "/pages/contact")
+    #   end
+    #
+    # The assert_cache method will
+    # - first make sure that the urls are not cached,
+    # - execute a get on each request,
+    # - assert that the corresponding cache files have been created.
+    #
+    # You can also give a block to the assert_cache method. Instead
+    # of executing a get on each url, it will yield the urls. For example:
+    #
+    #  def test_caching
+    #    assert_cache_pages("/pages/about", "/pages/contact") do |url_about, url_contact|
+    #      post url_about
+    #      post url_contact
+    #    end
+    #  end
+    #
+    # == Testing expiring of pages
+    #
+    # You will also certainly want to check if your cached pages
+    # expires when the user is doing some action. For that, here is
+    # the assert_expire method:
+    # 
+    #   def test_expiring
+    #     assert_expire_pages("/news/list", "/news/show/1") do |*urls|
+    #       post "/news/delete/1"
+    #     end
+    #   end
+    # 
+    # Here the assert_expire_pages method will 
+    # 
+    # - check that the urls are cached,
+    # - execute the post request,
+    # - and assert that the urls are no more cached.
+    #
+    module IntegrationTestMethods
+      # asserts that the list of given url are being cached
+      def assert_cache_pages(*urls)
+        ActionController::Base.reset_cache
+      
+        if block_given?
+          yield *urls
+        else
+          urls.each { |url| get url }
+        end
+
+        urls.each do |url|
+          assert_block("#{url.inspect} is not cached after executing block") do
+            ActionController::Base.cached?(url)
+          end
+        end
+      end
+
+      # asserts that the list of given url are being expired
+      def assert_expire_pages(*urls)
+        ActionController::Base.reset_cache
+        
+        yield *urls
+
+        urls.each do |url|
+          assert_block("#{url.inspect} is cached after executing block") do
+            ActionController::Base.expired?(url)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/plugins/global_routing/init.rb

@@ -1,5 +1,5 @@
 #  Motiro - A project tracking tool
-#  Copyright (C) 2006-2007  Thiago Arrais
+#  Copyright (C) 2006-2008  Thiago Arrais
 #  
 #  This program is free software; you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by