skylinecms 3.0.8 → 3.1.0

data/vendor/digitpaint/personify/test/parser_test.rb

@@ -0,0 +1,109 @@
+require 'test_helper'
+require File.dirname(__FILE__) + "/../vendor/treetop/lib/treetop"
+Treetop.load "../lib/parser/personify"
+# require File.dirname(__FILE__) + "/../personify"
+
+class ParserTest < Test::Unit::TestCase
+  include ParserTestHelper
+  context "The parser" do
+    setup do
+      @parser = PersonifyLanguageParser.new
+    end
+    context "parsing text" do
+      should "eval text" do
+        assert_equal "text", parse("text").eval()
+        assert_equal "t", parse("t").eval()
+        assert_equal "t\n1\n2", parse("t\n1\n2").eval()       
+      end
+      
+      should "eval UTF8 text" do
+        assert_equal "financiële", parse("financiële").eval()
+      end
+  
+      should "eval empty text" do
+        assert_equal "", parse("").eval()
+      end
+  
+      should "eval '[bla]' as text" do
+        assert_equal "[bla]", parse("[bla]").eval()
+      end
+
+      should "eval '[KE bla' as text" do
+        assert_equal "[KE bla", parse("[KE bla").eval()
+      end
+
+      should "eval nested brackets as text" do
+        assert_equal "[[BLA]]", parse("[[BLA]]").eval
+      end
+
+      should "eval '[BLA]' as text on nil 'bla' " do
+        assert_equal "[BLA]", parse("[BLA]").eval()
+      end
+    end
+    context "parsing expressions" do  
+      should "eval simple expression" do
+        assert_equal "var", parse("[VAR]").eval("var" => "var")
+        assert_equal "a var b", parse("a [VAR] b").eval("var" => "var")
+        assert_equal "var\nvar", parse("[VAR]\n[VAR]").eval("var" => "var")              
+      end
+      
+      should "eval simple expression with empty substitution" do
+        assert_equal "", parse("[VAR]").eval("var" => "")
+      end
+      
+      should "eval expressions careless of whitespace" do
+        assert_equal "k1",parse("[ K1]").eval("k1" => "k1")
+        assert_equal "k1",parse("[ K1 ]").eval("k1" => "k1")
+        assert_equal "k1",parse("[K1 | K2]").eval("k1" => "k1")
+      end   
+     
+      context "with alternatives" do    
+        should "eval alternative expression on first empty" do       
+          assert_equal "k2", parse("[K1|K2]").eval("k2" => "k2")
+          assert_equal "k2", parse("[K1|K2]").eval("k2" => "k2")
+          assert_equal "k3", parse("[K1|K2|K3]").eval("k1" => nil,"k2" => nil, "k3" => "k3")
+        end
+
+        should "eval first expression on first nonempty" do       
+          assert_equal "k2", parse("[K1|K2]").eval("k2" => "k2")
+          assert_equal "k2", parse("[K1|K2]").eval("k2" => "k2")
+          assert_equal "k3", parse("[K1|K2|K3]").eval("k2" => nil, "k3" => "k3")
+        end     
+
+        should "eval strings in alternative expression" do 
+          assert_equal "str", parse("[K1|str]").eval
+          assert_equal "str", parse("[K1|\"str\"]").eval
+          assert_equal "str", parse("[K1|\"str\"]").eval          
+          assert_equal " str", parse("[K1|\" str\"]").eval
+        end
+        
+        should "eval implicit strings in alternative expression" do 
+          assert_equal "str", parse("[K1|str]").eval
+        end        
+      end
+      
+      context "with function" do
+        should "eval with single parameter" do
+          assert_equal "v", parse("[FUNC(K1)]").eval("func" => Proc.new{|v| v }, "k1" => "v")
+        end
+        should "eval with multiple parameters" do
+          assert_equal "v1v2", parse("[FUNC(K1,K2)]").eval("func" => Proc.new{|*v| v.join }, "k1" => "v1", "k2" => "v2")
+        end
+        should "eval with string parameters" do
+          assert_equal "str", parse("[FUNC(\"str\")]").eval("func" => Proc.new{|v| v }, "k1" => "v1", "k2" => "v2")
+        end
+        should "eval with implicit string parameters" do
+          assert_equal "str", parse("[FUNC(str)]").eval("func" => Proc.new{|v| v }, "k1" => "v1", "k2" => "v2")
+        end        
+        should "eval with too much parameters" do
+          assert_equal "v1+v2v3", parse("[FUNC(\"v1\",\"v2\",\"v3\")]").eval("func" => Proc.new{|v1,*v2| v1 + "+" + v2.join })
+        end
+        should "eval with alternative expression" do
+          assert_equal "fb", parse("[FUNC()|\"fb\"]").eval("func" => Proc.new{ false })
+          assert_equal "fb", parse("[FUNC()|\"fb\"]").eval("func" => Proc.new{ nil })
+        end
+      end
+      
+    end
+  end
+end

data/vendor/digitpaint/personify/test/test_helper.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'shoulda'
+require File.dirname(__FILE__) + "/../personify"
+
+require 'test/unit'
+
+module ParserTestHelper
+  def parse(input)
+    result = @parser.parse(input)
+    unless result
+      puts @parser.terminal_failures.join("\n")
+    end
+    assert !result.nil?
+    result
+  end
+end

data/vendor/digitpaint/personify/vendor/treetop/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+*.iml
+*.iws
+*.ipr
+doc/site/*.*

data/vendor/mootools-on-rails/lib/mootools_on_rails/mootools_helper.rb

@@ -254,13 +254,22 @@ module ActionView
           module GeneratorMethods
             
             def to_s #:nodoc:
-              returning javascript = @lines * $/ do
+              (@lines * $/).tap{|javascript| 
                 if ActionView::Base.debug_rjs
                   source = javascript.dup
                   javascript.replace "try {\n#{source}\n} catch (e) "
                   javascript << "{ alert('RJS error:\\n\\n' + e.toString()); alert('#{source.gsub('\\','\0\0').gsub(/\r\n|\n|\r/, "\\n").gsub(/["']/) { |m| "\\#{m}" }}'); throw e }"
                 end
-              end
+              }
+              
+              # 
+              # returning javascript = @lines * $/ do
+              #   if ActionView::Base.debug_rjs
+              #     source = javascript.dup
+              #     javascript.replace "try {\n#{source}\n} catch (e) "
+              #     javascript << "{ alert('RJS error:\\n\\n' + e.toString()); alert('#{source.gsub('\\','\0\0').gsub(/\r\n|\n|\r/, "\\n").gsub(/["']/) { |m| "\\#{m}" }}'); throw e }"
+              #   end
+              # end
             end
             
             # Insert an element (before, after) an other
@@ -354,9 +363,9 @@ module ActionView
               end
               
               def record(line)
-                returning line = "#{line.to_s.chomp.gsub(/\;\z/, '')};" do
+                "#{line.to_s.chomp.gsub(/\;\z/, '')};".tap{|line|
                   self << line
-                end
+                }
               end
             
               def page

data/vendor/mootools-on-rails/test/mootools_helper_test.rb

@@ -0,0 +1,138 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class MootoolsHelperTest < Test::Unit::TestCase
+  include ActionView::Helpers::UrlHelper
+  include ActionView::Helpers::TagHelper
+  include ActionView::Helpers::FormTagHelper
+  include ActionView::Helpers::JavaScriptHelper
+  include ActionView::Helpers::MootoolsHelper
+
+
+  def setup
+    @controller = Class.new do
+      def url_for(options, *parameters_for_method_reference)
+        if options.is_a?(String)
+          options
+        else
+          url =  "http://www.example.com/"
+          url << options[:controller].to_s + "/" if options and options[:controller]
+          url << options[:action].to_s if options and options[:action]
+          url
+        end
+      end
+    end.new
+    
+    @generator = create_generator
+  end
+
+
+  def test_link_to_remote
+    assert_equal '<a href="#" onclick="new Request({evalScripts:true, url:\'http://www.example.com/posts/list\'}).send(); return false;">Link</a>', 
+      link_to_remote("Link", :url => {:controller => "posts", :action => "list"})
+  end
+
+  def test_form_remote_tag
+    
+    assert_equal "<form action=\"http://www.example.com/posts/new\" method=\"post\" onsubmit=\"new Request($merge({data: this.toQueryString()}, {evalScripts:true, url:'http://www.example.com/posts/new'})).send(); return false;\">", 
+      form_remote_tag(:url => {:controller => 'posts', :action => 'new'})
+    # assert_equal "<form action=\"http://www.example.com/posts/new\" method=\"post\" onsubmit=\"this.send({evalScripts:true, update:$('mydiv')}); return false;\">", 
+    #       form_remote_tag(:url => {:controller => 'posts', :action => 'new'}, :update => 'mydiv')
+    assert_equal "<form action=\"http://www.example.com/posts/new\" method=\"get\" onsubmit=\"new Request($merge({data: this.toQueryString()}, {evalScripts:true, url:'http://www.example.com/posts/new'})).send(); return false;\">", 
+      form_remote_tag(:url => {:controller => 'posts', :action => 'new'}, :html => { :method => :get })
+  end
+
+  def test_form_remote_tag_with_method
+    assert_equal "<form action=\"http://www.example.com/posts/new\" method=\"post\" onsubmit=\"new Request($merge({data: this.toQueryString()}, {evalScripts:true, url:'http://www.example.com/posts/new'})).send(); return false;\"><div style=\"margin:0;padding:0\"><input name=\"_method\" type=\"hidden\" value=\"put\" /></div>", 
+      form_remote_tag(:url => {:controller => 'posts', :action => 'new'}, :html => { :method => :put })
+  end
+  
+  def test_alert
+    assert_equal "alert(\"my alert !\");",
+      @generator.alert('my alert !')
+  end
+  
+  def test_call
+    assert_equal "myFunction();",
+      @generator.call('myFunction')
+  end
+    
+  def test_assign
+    assert_equal "name = \"value\";", 
+      @generator.assign('name', 'value')
+  end
+        
+  def test_insert_html
+    a_paragraph = "<p>A paragraph</p>";
+    [:top, :bottom, :before, :after].each do |position|
+      assert_equal "$('my-id').append#{position.to_s.capitalize}(\"#{a_paragraph}\");",
+        @generator.insert_html(position, 'my-id', '<p>A paragraph</p>')
+    end
+  end
+  
+  def test_replace_html
+    a_paragraph = "<p>A paragraph</p>";
+    assert_equal "$('my-id').set({\"html\": \"#{a_paragraph}\"});",
+      @generator.replace_html('my-id', '<p>A paragraph</p>')
+  end
+  
+  def test_replace
+    a_paragraph = "<p>A paragraph</p>";
+    assert_equal "$('my-id').replace(\"#{a_paragraph}\");",
+      @generator.replace('my-id', '<p>A paragraph</p>')
+  end      
+
+  def test_highlight
+    assert_equal "$('my-id').highlight(\"#FF8\");",
+      @generator.highlight('my-id')
+      
+    assert_equal "$('my-id').highlight(\"#CCC\");",
+      @generator.highlight('my-id', '#CCC')
+      
+    assert_equal "$('my-id').highlight(\"#CCC\", \"#888\");",
+      @generator.highlight('my-id', '#CCC', "#888")
+  end
+  
+  def test_show
+    assert_equal "$(\"my-id\").setStyles({display:''});",
+      @generator.show('my-id')
+      
+    assert_equal "[\"my-id1\", \"my-id2\"].each(function(element){$(element).setStyles({display:'none'});});",
+      @generator.hide('my-id1', 'my-id2')
+  end
+  
+  def test_hide
+    assert_equal "$(\"my-id\").setStyles({display:'none'});",
+      @generator.hide('my-id')
+      
+    assert_equal "[\"my-id1\", \"my-id2\"].each(function(element){$(element).setStyles({display:'none'});});",
+      @generator.hide('my-id1', 'my-id2')
+  end
+  
+  def test_delay
+    @generator.delay(20) do
+      @generator.hide('foo')
+    end
+    
+    assert_equal "setTimeout(function() {\n;\n$(\"foo\").setStyles({display:'none'});\n}, 20000);", 
+      @generator.to_s
+  end
+  
+  def test_fire_event
+    assert_equal "document.fireEvent(\"success\");", 
+      @generator.fire_event('success')
+  end
+    
+  
+  protected
+    def protect_against_forgery?
+      false
+    end
+    
+    
+    def create_generator
+      block = Proc.new { |*args| yield *args if block_given? } 
+      JavaScriptGenerator.new self, &block
+    end
+end
+
+

data/vendor/mootools-on-rails/test/test_helper.rb

@@ -0,0 +1,5 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'test/unit'
+RAILS_ENV = "test"
+require File.expand_path(File.join(File.dirname(__FILE__), '../../../../config/environment.rb'))
+require 'action_controller/test_process'

data/vendor/weppos/url_validation.rb

@@ -0,0 +1,76 @@
+require 'uri/http'
+
+# Provides proper RFC 2396 based URL validation for ActiveRecord models through `validates_format_of_url`.
+# 
+# @example Usage: 
+# class Model < ActiveRecord::Base
+#   extend Skyline::UrlValidation
+#   validates_format_of_url :field
+# end
+# 
+# @see http://gist.github.com/102138  http://gist.github.com/102138 for the original implementation.
+module UrlValidation
+  # Validates whether the value of the specified attribute matches the format of an URL,
+  # as defined by RFC 2396. 
+  #
+  # This method doesn't validate the existence of the domain, nor it validates the domain itself.
+  #
+  # Allowed values include http://foo.bar, http://www.foo.bar and even http://foo.
+  # Please note that http://foo is a valid URL, as well http://localhost.
+  # It's up to you to extend the validation with additional constraints.
+  #
+  # @see URI#parse URI#parse for more information on URI decompositon and parsing.
+  # 
+  # @example Usage
+  # class Site < ActiveRecord::Base
+  #   validates_format_of :url, :on => :create
+  #   validates_format_of :ftp, :schemes => [:ftp, :http, :https]
+  # end
+  #
+  # @overload validates_format_of_url(*attr_names, options={})
+  #   @param *attr_names [Symbol, String] Attributes to validate
+  #   @option options :schemes [Array<Symbol>] ([:http, :https]) 
+  #     An array of allowed schemes to match against
+  #   @option options :message [String]  ("is invalid") 
+  #     A custom error message
+  #   @option options :allow_nil [Boolean] (false) 
+  #     If set to true, skips this validation if the attribute is `nil`.
+  #   @option options :allow_blank [Boolean] (false) 
+  #     If set to true, skips this validation if the attribute is blank.
+  #   @option options :on [Symbol] (:save) 
+  #     Specifies when this validation is active (options are `:save`, `:create`, `:update<`).
+  #   @option options :if [Proc, Symbol]
+  #     Specifies a method, proc or string to call to determine if the validation should
+  #     occur (e.g. `:if => :allow_validation`, or `:if => Proc.new { |user| user.signup_step > 2 }`). The
+  #     method, proc or string should return or evaluate to a true or false value.
+  #   @option options :unless [Proc, Symbol]
+  #     Specifies a method, proc or string to call to determine if the validation should
+  #     not occur (e.g. `:unless => :skip_validation`, or `:unless => Proc.new { |user| user.signup_step <= 2 }`). The
+  #     method, proc or string should return or evaluate to a true or false value.
+  #
+  def validates_format_of_url(*attr_names)
+
+    configuration = { :on => :save, :schemes => %w(http https) }
+    configuration.update(attr_names.extract_options!)
+
+    allowed_schemes = [*configuration[:schemes]].map(&:to_s)
+
+    validates_each(attr_names, configuration) do |record, attr_name, value|
+      begin
+        uri = URI.parse(value)
+
+        if !allowed_schemes.include?(uri.scheme)
+          raise(URI::InvalidURIError)
+        end
+
+        if [:scheme, :host].any? { |i| uri.send(i).blank? }
+          raise(URI::InvalidURIError)
+        end
+
+      rescue URI::InvalidURIError => e
+        record.errors.add(attr_name, :invalid, :default => configuration[:message], :value => value)
+        next
+      end
+    end
+  end
+end