radiant 0.9.1 → 1.0.0.rc1

data/vendor/rails/actionpack/test/template/url_helper_test.rb

@@ -333,11 +333,11 @@ class UrlHelperTest < ActionView::TestCase
   end
 
   def test_mail_to_with_javascript
-    assert_dom_equal "<script type=\"text/javascript\">eval(decodeURIComponent('%64%6f%63%75%6d%65%6e%74%2e%77%72%69%74%65%28%27%3c%61%20%68%72%65%66%3d%22%6d%61%69%6c%74%6f%3a%6d%65%40%64%6f%6d%61%69%6e%2e%63%6f%6d%22%3e%4d%79%20%65%6d%61%69%6c%3c%2f%61%3e%27%29%3b'))</script>", mail_to("me@domain.com", "My email", :encode => "javascript")
+    assert_dom_equal "<script type=\"text/javascript\">eval(decodeURIComponent('%64%6f%63%75%6d%65%6e%74%2e%77%72%69%74%65%28%27%3c%61%20%68%72%65%66%3d%5c%22%6d%61%69%6c%74%6f%3a%6d%65%40%64%6f%6d%61%69%6e%2e%63%6f%6d%5c%22%3e%4d%79%20%65%6d%61%69%6c%3c%5c%2f%61%3e%27%29%3b'))</script>", mail_to("me@domain.com", "My email", :encode => "javascript")
   end
 
   def test_mail_to_with_javascript_unicode
-    assert_dom_equal "<script type=\"text/javascript\">eval(decodeURIComponent('%64%6f%63%75%6d%65%6e%74%2e%77%72%69%74%65%28%27%3c%61%20%68%72%65%66%3d%22%6d%61%69%6c%74%6f%3a%75%6e%69%63%6f%64%65%40%65%78%61%6d%70%6c%65%2e%63%6f%6d%22%3e%c3%ba%6e%69%63%6f%64%65%3c%2f%61%3e%27%29%3b'))</script>", mail_to("unicode@example.com", "únicode", :encode => "javascript")
+    assert_dom_equal "<script type=\"text/javascript\">eval(decodeURIComponent('%64%6f%63%75%6d%65%6e%74%2e%77%72%69%74%65%28%27%3c%61%20%68%72%65%66%3d%5c%22%6d%61%69%6c%74%6f%3a%75%6e%69%63%6f%64%65%40%65%78%61%6d%70%6c%65%2e%63%6f%6d%5c%22%3e%c3%ba%6e%69%63%6f%64%65%3c%5c%2f%61%3e%27%29%3b'))</script>", mail_to("unicode@example.com", "únicode", :encode => "javascript")
   end
 
   def test_mail_with_options
@@ -361,8 +361,8 @@ class UrlHelperTest < ActionView::TestCase
     assert_dom_equal "<a href=\"&#109;&#97;&#105;&#108;&#116;&#111;&#58;%6d%65@%64%6f%6d%61%69%6e.%63%6f%6d\">&#109;&#101;&#40;&#97;&#116;&#41;&#100;&#111;&#109;&#97;&#105;&#110;&#46;&#99;&#111;&#109;</a>", mail_to("me@domain.com", nil, :encode => "hex", :replace_at => "(at)")
     assert_dom_equal "<a href=\"&#109;&#97;&#105;&#108;&#116;&#111;&#58;%6d%65@%64%6f%6d%61%69%6e.%63%6f%6d\">My email</a>", mail_to("me@domain.com", "My email", :encode => "hex", :replace_at => "(at)")
     assert_dom_equal "<a href=\"&#109;&#97;&#105;&#108;&#116;&#111;&#58;%6d%65@%64%6f%6d%61%69%6e.%63%6f%6d\">&#109;&#101;&#40;&#97;&#116;&#41;&#100;&#111;&#109;&#97;&#105;&#110;&#40;&#100;&#111;&#116;&#41;&#99;&#111;&#109;</a>", mail_to("me@domain.com", nil, :encode => "hex", :replace_at => "(at)", :replace_dot => "(dot)")
-    assert_dom_equal "<script type=\"text/javascript\">eval(decodeURIComponent('%64%6f%63%75%6d%65%6e%74%2e%77%72%69%74%65%28%27%3c%61%20%68%72%65%66%3d%22%6d%61%69%6c%74%6f%3a%6d%65%40%64%6f%6d%61%69%6e%2e%63%6f%6d%22%3e%4d%79%20%65%6d%61%69%6c%3c%2f%61%3e%27%29%3b'))</script>", mail_to("me@domain.com", "My email", :encode => "javascript", :replace_at => "(at)", :replace_dot => "(dot)")
-    assert_dom_equal "<script type=\"text/javascript\">eval(decodeURIComponent('%64%6f%63%75%6d%65%6e%74%2e%77%72%69%74%65%28%27%3c%61%20%68%72%65%66%3d%22%6d%61%69%6c%74%6f%3a%6d%65%40%64%6f%6d%61%69%6e%2e%63%6f%6d%22%3e%6d%65%28%61%74%29%64%6f%6d%61%69%6e%28%64%6f%74%29%63%6f%6d%3c%2f%61%3e%27%29%3b'))</script>", mail_to("me@domain.com", nil, :encode => "javascript", :replace_at => "(at)", :replace_dot => "(dot)")
+    assert_dom_equal "<script type=\"text/javascript\">eval(decodeURIComponent('%64%6f%63%75%6d%65%6e%74%2e%77%72%69%74%65%28%27%3c%61%20%68%72%65%66%3d%5c%22%6d%61%69%6c%74%6f%3a%6d%65%40%64%6f%6d%61%69%6e%2e%63%6f%6d%5c%22%3e%4d%79%20%65%6d%61%69%6c%3c%5c%2f%61%3e%27%29%3b'))</script>", mail_to("me@domain.com", "My email", :encode => "javascript", :replace_at => "(at)", :replace_dot => "(dot)")
+    assert_dom_equal "<script type=\"text/javascript\">eval(decodeURIComponent('%64%6f%63%75%6d%65%6e%74%2e%77%72%69%74%65%28%27%3c%61%20%68%72%65%66%3d%5c%22%6d%61%69%6c%74%6f%3a%6d%65%40%64%6f%6d%61%69%6e%2e%63%6f%6d%5c%22%3e%6d%65%28%61%74%29%64%6f%6d%61%69%6e%28%64%6f%74%29%63%6f%6d%3c%5c%2f%61%3e%27%29%3b'))</script>", mail_to("me@domain.com", nil, :encode => "javascript", :replace_at => "(at)", :replace_dot => "(dot)")
   end
   
   def protect_against_forgery?

data/vendor/rails/activemodel/CHANGES

@@ -0,0 +1,12 @@
+Changes from extracting bits to ActiveModel
+
+* ActiveModel::Observer#add_observer!
+
+  It has a custom hook to define after_find that should really be in a
+  ActiveRecord::Observer subclass:
+
+	  def add_observer!(klass)
+	    klass.add_observer(self)
+	    klass.class_eval 'def after_find() end' unless
+				klass.respond_to?(:after_find)
+	  end

data/vendor/rails/activemodel/README

@@ -0,0 +1,21 @@
+Active Model
+==============
+
+Totally experimental library that aims to extract common model mixins from
+ActiveRecord for use in ActiveResource (and other similar libraries).
+This is in a very rough state (no autotest or spec rake tasks set up yet),
+so please excuse the mess.
+
+Here's what I plan to extract:
+  * ActiveModel::Observing
+  * ActiveModel::Callbacks
+  * ActiveModel::Validations
+
+	# for ActiveResource params and ActiveRecord options
+  * ActiveModel::Scoping
+
+	# to_json, to_xml, etc
+  * ActiveModel::Serialization
+
+I'm trying to keep ActiveRecord compatibility where possible, but I'm
+annotating the spots where I'm diverging a bit.

data/vendor/rails/activemodel/Rakefile

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+  t.warning = true
+end
+
+# Generate the RDoc documentation
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = "Active Model"
+  rdoc.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
+  rdoc.options << '--charset' << 'utf-8'
+  rdoc.template = ENV['template'] ? "#{ENV['template']}.rb" : '../doc/template/horo'
+  rdoc.rdoc_files.include('README', 'CHANGES')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/vendor/rails/activemodel/lib/active_model.rb

@@ -0,0 +1,5 @@
+require 'active_model/observing'
+# disabled until they're tested
+# require 'active_model/callbacks'
+# require 'active_model/validations'
+require 'active_model/base'

data/vendor/rails/activemodel/lib/active_model/base.rb

@@ -0,0 +1,8 @@
+module ActiveModel
+  class Base
+    include Observing
+    # disabled, until they're tested
+    # include Callbacks
+    # include Validations
+  end
+end

data/vendor/rails/activemodel/lib/active_model/callbacks.rb

@@ -0,0 +1,7 @@
+require 'active_model/core'
+
+module ActiveModel
+  module Callbacks
+
+  end
+end

data/vendor/rails/activemodel/lib/active_model/core.rb

@@ -0,0 +1,7 @@
+# This file is required by each major ActiveModel component for the core requirements.  This allows you to
+# load individual pieces of ActiveModel as needed.
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', '..', '..', 'activesupport', 'lib')
+
+# premature optimization?
+# So far, we only need the string inflections and not the rest of ActiveSupport.
+require 'active_support/inflector'

data/vendor/rails/activemodel/lib/active_model/deprecated_error_methods.rb

@@ -0,0 +1,38 @@
+module ActiveModel
+  module DeprecatedErrorMethods
+    def on(attribute)
+      ActiveSupport::Deprecation.warn "Errors#on have been deprecated, use Errors#[] instead"
+      self[attribute]
+    end
+
+    def on_base
+      ActiveSupport::Deprecation.warn "Errors#on_base have been deprecated, use Errors#[:base] instead"
+      on(:base)
+    end
+
+    def add(attribute, msg = Errors.default_error_messages[:invalid])
+      ActiveSupport::Deprecation.warn "Errors#add(attribute, msg) has been deprecated, use Errors#[attribute] << msg instead"
+      self[attribute] << msg
+    end
+
+    def add_to_base(msg)
+      ActiveSupport::Deprecation.warn "Errors#add_to_base(msg) has been deprecated, use Errors#[:base] << msg instead"
+      self[:base] << msg
+    end
+
+    def invalid?(attribute)
+      ActiveSupport::Deprecation.warn "Errors#invalid?(attribute) has been deprecated, use Errors#[attribute].any? instead"
+      self[attribute].any?
+    end
+
+    def full_messages
+      ActiveSupport::Deprecation.warn "Errors#full_messages has been deprecated, use Errors#to_a instead"
+      to_a
+    end
+
+    def each_full
+      ActiveSupport::Deprecation.warn "Errors#each_full has been deprecated, use Errors#to_a.each instead"
+      to_a.each { |error| yield error }
+    end
+  end
+end

data/vendor/rails/activemodel/lib/active_model/errors.rb

@@ -0,0 +1,82 @@
+module ActiveModel
+  class Errors < Hash
+    include DeprecatedErrorMethods
+
+    @@default_error_messages = {
+      :inclusion                => "is not included in the list",
+      :exclusion                => "is reserved",
+      :invalid                  => "is invalid",
+      :confirmation             => "doesn't match confirmation",
+      :accepted                 => "must be accepted",
+      :empty                    => "can't be empty",
+      :blank                    => "can't be blank",
+      :too_long                 => "is too long (maximum is %d characters)",
+      :too_short                => "is too short (minimum is %d characters)",
+      :wrong_length             => "is the wrong length (should be %d characters)",
+      :taken                    => "has already been taken",
+      :not_a_number             => "is not a number",
+      :greater_than             => "must be greater than %d",
+      :greater_than_or_equal_to => "must be greater than or equal to %d",
+      :equal_to                 => "must be equal to %d",
+      :less_than                => "must be less than %d",
+      :less_than_or_equal_to    => "must be less than or equal to %d",
+      :odd                      => "must be odd",
+      :even                     => "must be even"
+    }
+
+    ##
+    # :singleton-method:
+    # Holds a hash with all the default error messages that can be replaced by your own copy or localizations.
+    cattr_accessor :default_error_messages
+
+    alias_method :get, :[]
+    alias_method :set, :[]=
+
+    def [](attribute)
+      if errors = get(attribute.to_sym)
+        errors.size == 1 ? errors.first : errors
+      else
+        set(attribute.to_sym, [])
+      end
+    end
+
+    def []=(attribute, error)
+      self[attribute.to_sym] << error
+    end
+
+    def each
+      each_key do |attribute|
+        self[attribute].each { |error| yield attribute, error }
+      end
+    end
+
+    def size
+      values.flatten.size
+    end
+
+    def to_a
+      inject([]) do |errors_with_attributes, (attribute, errors)|
+        if error.blank?
+          errors_with_attributes
+        else
+          if attr == :base
+            errors_with_attributes << error
+          else
+            errors_with_attributes << (attribute.to_s.humanize + " " + error)
+          end
+        end
+      end
+    end
+
+    def to_xml(options={})
+      options[:root]    ||= "errors"
+      options[:indent]  ||= 2
+      options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+
+      options[:builder].instruct! unless options.delete(:skip_instruct)
+      options[:builder].errors do |e|
+        to_a.each { |error| e.error(error) }
+      end
+    end
+  end
+end

data/vendor/rails/activemodel/lib/active_model/observing.rb

@@ -0,0 +1,98 @@
+require 'observer'
+require 'singleton'
+require 'active_model/core'
+
+module ActiveModel
+  module Observing
+    module ClassMethods
+      def observers
+        @observers ||= []
+      end
+
+      def observers=(*values)
+        @observers = values.flatten
+      end
+
+      def instantiate_observers
+        observers.each { |o| instantiate_observer(o) }
+      end
+
+    protected
+      def instantiate_observer(observer)
+        # string/symbol
+        if observer.respond_to?(:to_sym)
+          observer = observer.to_s.camelize.constantize.instance
+        elsif observer.respond_to?(:instance)
+          observer.instance
+        else
+          raise ArgumentError, "#{observer} must be a lowercase, underscored class name (or an instance of the class itself) responding to the instance method. Example: Person.observers = :big_brother # calls BigBrother.instance"
+        end
+      end
+
+      # Notify observers when the observed class is subclassed.
+      def inherited(subclass)
+        super
+        changed
+        notify_observers :observed_class_inherited, subclass
+      end
+    end
+
+    def self.included(receiver)
+      receiver.extend Observable, ClassMethods
+    end
+  end
+
+  class Observer
+    include Singleton
+    attr_writer :observed_classes
+
+    class << self
+      attr_accessor :models
+      # Attaches the observer to the supplied model classes.
+      def observe(*models)
+        @models = models.flatten
+        @models.collect! { |model| model.respond_to?(:to_sym) ? model.to_s.camelize.constantize : model }
+      end
+
+      def observed_class_name
+        @observed_class_name ||=
+          if guessed_name = name.scan(/(.*)Observer/)[0]
+            @observed_class_name = guessed_name[0]
+          end
+      end
+
+      # The class observed by default is inferred from the observer's class name:
+      #   assert_equal [Person], PersonObserver.observed_class
+      def observed_class
+        if observed_class_name
+          observed_class_name.constantize
+        else
+          nil
+        end
+      end
+    end
+
+    # Start observing the declared classes and their subclasses.
+    def initialize
+      self.observed_classes = self.class.models if self.class.models
+      observed_classes.each { |klass| klass.add_observer(self) }
+    end
+
+    # Send observed_method(object) if the method exists.
+    def update(observed_method, object) #:nodoc:
+      send(observed_method, object) if respond_to?(observed_method)
+    end
+
+    # Special method sent by the observed class when it is inherited.
+    # Passes the new subclass.
+    def observed_class_inherited(subclass) #:nodoc:
+      self.class.observe(observed_classes + [subclass])
+      subclass.add_observer(self)
+    end
+
+  protected
+    def observed_classes
+      @observed_classes ||= [self.class.observed_class]
+    end
+  end
+end

data/vendor/rails/activemodel/lib/active_model/state_machine.rb

@@ -0,0 +1,68 @@
+module ActiveModel
+  module StateMachine
+    class InvalidTransition < Exception
+    end
+
+    def self.included(base)
+      require 'active_model/state_machine/machine'
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def inherited(klass)
+        super
+        klass.state_machines = state_machines
+      end
+
+      def state_machines
+        @state_machines ||= {}
+      end
+
+      def state_machines=(value)
+        @state_machines = value ? value.dup : nil
+      end
+
+      def state_machine(name = nil, options = {}, &block)
+        if name.is_a?(Hash)
+          options = name
+          name    = nil
+        end
+        name ||= :default
+        state_machines[name] ||= Machine.new(self, name)
+        block ? state_machines[name].update(options, &block) : state_machines[name]
+      end
+
+      def define_state_query_method(state_name)
+        name = "#{state_name}?"
+        undef_method(name) if method_defined?(name)
+        class_eval "def #{name}; current_state.to_s == %(#{state_name}) end"
+      end
+    end
+
+    def current_state(name = nil, new_state = nil, persist = false)
+      sm   = self.class.state_machine(name)
+      ivar = sm.current_state_variable
+      if name && new_state
+        if persist && respond_to?(:write_state)
+          write_state(sm, new_state)
+        end
+
+        if respond_to?(:write_state_without_persistence)
+          write_state_without_persistence(sm, new_state)
+        end
+
+        instance_variable_set(ivar, new_state)
+      else
+        instance_variable_set(ivar, nil) unless instance_variable_defined?(ivar)
+        value = instance_variable_get(ivar)
+        return value if value
+
+        if respond_to?(:read_state)
+          value = instance_variable_set(ivar, read_state(sm))
+        end
+
+        value || sm.initial_state
+      end
+    end
+  end
+end

data/vendor/rails/activemodel/lib/active_model/state_machine/event.rb

@@ -0,0 +1,64 @@
+require 'active_model/state_machine/state_transition'
+
+module ActiveModel
+  module StateMachine
+    class Event
+      attr_reader :name, :success
+
+      def initialize(machine, name, options = {}, &block)
+        @machine, @name, @transitions = machine, name, []
+        if machine
+          machine.klass.send(:define_method, "#{name}!") do |*args|
+            machine.fire_event(name, self, true, *args)
+          end
+
+          machine.klass.send(:define_method, name.to_s) do |*args|
+            machine.fire_event(name, self, false, *args)
+          end
+        end
+        update(options, &block)
+      end
+
+      def fire(obj, to_state = nil, *args)
+        transitions = @transitions.select { |t| t.from == obj.current_state(@machine ? @machine.name : nil) }
+        raise InvalidTransition if transitions.size == 0
+
+        next_state = nil
+        transitions.each do |transition|
+          next if to_state && !Array(transition.to).include?(to_state)
+          if transition.perform(obj)
+            next_state = to_state || Array(transition.to).first
+            transition.execute(obj, *args)
+            break
+          end
+        end
+        next_state
+      end
+
+      def transitions_from_state?(state)
+        @transitions.any? { |t| t.from? state }
+      end
+
+      def ==(event)
+        if event.is_a? Symbol
+          name == event
+        else
+          name == event.name
+        end
+      end
+
+      def update(options = {}, &block)
+        if options.key?(:success) then @success = options[:success] end
+        if block                  then instance_eval(&block)        end
+        self
+      end
+
+    private
+      def transitions(trans_opts)
+        Array(trans_opts[:from]).each do |s|
+          @transitions << StateTransition.new(trans_opts.merge({:from => s.to_sym}))
+        end
+      end
+    end
+  end
+end