tiny_mce 0.1.1 → 0.1.2

data/lib/tiny_mce/assets/tiny_mce/utils/editable_selects.js

@@ -1,10 +1,11 @@
 /**
- * $Id: editable_selects.js 867 2008-06-09 20:33:40Z spocke $
+ * editable_selects.js
  *
- * Makes select boxes editable.
+ * Copyright 2009, Moxiecode Systems AB
+ * Released under LGPL License.
  *
- * @author Moxiecode
- * @copyright Copyright � 2004-2008, Moxiecode Systems AB, All rights reserved.
+ * License: http://tinymce.moxiecode.com/license
+ * Contributing: http://tinymce.moxiecode.com/contributing
  */
 
 var TinyMCE_EditableSelects = {

data/lib/tiny_mce/assets/tiny_mce/utils/form_utils.js

@@ -1,10 +1,11 @@
 /**
- * $Id: form_utils.js 1184 2009-08-11 11:47:27Z spocke $
+ * form_utils.js
  *
- * Various form utilitiy functions.
+ * Copyright 2009, Moxiecode Systems AB
+ * Released under LGPL License.
  *
- * @author Moxiecode
- * @copyright Copyright � 2004-2008, Moxiecode Systems AB, All rights reserved.
+ * License: http://tinymce.moxiecode.com/license
+ * Contributing: http://tinymce.moxiecode.com/contributing
  */
 
 var themeBaseURL = tinyMCEPopup.editor.baseURI.toAbsolute('themes/' + tinyMCEPopup.getParam("theme"));

data/lib/tiny_mce/assets/tiny_mce/utils/mctabs.js

@@ -1,10 +1,11 @@
 /**
- * $Id: mctabs.js 758 2008-03-30 13:53:29Z spocke $
+ * mctabs.js
  *
- * Moxiecode DHTML Tabs script.
+ * Copyright 2009, Moxiecode Systems AB
+ * Released under LGPL License.
  *
- * @author Moxiecode
- * @copyright Copyright � 2004-2008, Moxiecode Systems AB, All rights reserved.
+ * License: http://tinymce.moxiecode.com/license
+ * Contributing: http://tinymce.moxiecode.com/contributing
  */
 
 function MCTabs() {

data/lib/tiny_mce/assets/tiny_mce/utils/validate.js

@@ -1,10 +1,11 @@
 /**
- * $Id: validate.js 758 2008-03-30 13:53:29Z spocke $
+ * validate.js
  *
- * Various form validation methods.
+ * Copyright 2009, Moxiecode Systems AB
+ * Released under LGPL License.
  *
- * @author Moxiecode
- * @copyright Copyright � 2004-2008, Moxiecode Systems AB, All rights reserved.
+ * License: http://tinymce.moxiecode.com/license
+ * Contributing: http://tinymce.moxiecode.com/contributing
  */
 
 /**

data/lib/tiny_mce/base.rb

@@ -11,38 +11,26 @@ module TinyMCE
       # Takes options hash, raw_options string, and any normal params you
       # can send to a before_filter (only, except etc)
       def uses_tiny_mce(options = {})
-        tiny_mce_options = options.delete(:options) || {}
-        raw_tiny_mce_options = options.delete(:raw_options) || ''
-
-        # Allow users to have default options in config/tiny_mce.yml so that
-        # they do not need to specify the same options over all controllers
-        tiny_mce_yaml_filepath = File.join(RAILS_ROOT, 'config', 'tiny_mce.yml')
-        if File.exist?(tiny_mce_yaml_filepath)
-          yaml_options = YAML::load(IO.read(tiny_mce_yaml_filepath)) rescue Hash.new
-          tiny_mce_options = yaml_options.merge(tiny_mce_options) if yaml_options
-        end
+        configuration = TinyMCE::Configuration.new(options.delete(:options), options.delete(:raw_options))
 
         # If the tiny_mce plugins includes the spellchecker, then form a spellchecking path,
         # add it to the tiny_mce_options, and include the SpellChecking module
-        if !tiny_mce_options[:plugins].blank? && tiny_mce_options[:plugins].include?('spellchecker')
-          tiny_mce_options.reverse_merge!(:spellchecker_rpc_url => "/" + self.controller_name + "/spellchecker")
-          self.class_eval do
-            include TinyMCE::SpellChecker
-          end
+        if configuration.plugins.include?('spellchecker')
+          configuration.reverse_add_options("spellchecker_rpc_url" => "/" + self.controller_name + "/spellchecker")
+          self.class_eval { include TinyMCE::SpellChecker }
         end
 
         # Set instance vars in the current class
         proc = Proc.new do |c|
-          c.instance_variable_set(:@tiny_mce_options, tiny_mce_options)
-          c.instance_variable_set(:@raw_tiny_mce_options, raw_tiny_mce_options)
+          configurations = c.instance_variable_get(:@tiny_mce_configurations) || []
+          configurations << configuration
+          c.instance_variable_set(:@tiny_mce_configurations, configurations)
           c.instance_variable_set(:@uses_tiny_mce, true)
         end
 
         # Run the above proc before each page load this method is declared in
         before_filter(proc, options)
       end
-
     end
-
   end
 end

data/lib/tiny_mce/configuration.rb

@@ -0,0 +1,98 @@
+module TinyMCE
+  class Configuration
+    # We use this to combine options and raw_options into one class and validate
+    # whether options passed in by the users are valid tiny mce configuration settings.
+    # Also loads which options are valid, and provides an plugins attribute to allow
+    # more configuration options dynamicly
+
+    DEFAULT_OPTIONS = {
+      'mode' => 'textareas',
+      'editor_selector' => 'mceEditor',
+      'theme' => 'simple',
+      'language' => (defined?(I18n) ? I18n.locale : :en)
+    }
+
+    def self.config_file_options
+      @@config_file_options ||= begin
+        tiny_mce_yaml_filepath = File.join(RAILS_ROOT, 'config', 'tiny_mce.yml')
+        # The YAML file might not exist, might be blank, might be invalid, or
+        # might be valid. Catch all cases and make sure we always return a Hash
+        (YAML::load(IO.read(tiny_mce_yaml_filepath)) rescue nil) || Hash.new
+      end
+    end
+
+    # Parse the options file and load it into an array
+    # (this method is called when tiny_mce is initialized - see init.rb)
+    def self.valid_options
+      @@valid_options ||= begin
+        valid_options_path = File.join(File.dirname(__FILE__), 'valid_tinymce_options.yml')
+        File.open(valid_options_path) { |f| YAML.load(f.read) }
+      end
+    end
+
+    attr_accessor :options, :raw_options
+
+    def initialize(options = {}, raw_options = nil)
+      options = Hash.new unless options.is_a?(Hash)
+      @options = DEFAULT_OPTIONS.merge(self.class.config_file_options.stringify_keys).
+                                 merge(options.stringify_keys)
+      @raw_options = [raw_options]
+    end
+
+    # Merge additional options and raw_options
+    def add_options(options = {}, raw_options = nil)
+      @options.merge!(options.stringify_keys) unless options.blank?
+      @raw_options << raw_options unless raw_options.blank?
+    end
+
+    # Merge additional options and raw_options, but don't overwrite existing
+    def reverse_add_options(options = {}, raw_options = nil)
+      @options.reverse_merge!(options.stringify_keys) unless options.blank?
+      @raw_options << raw_options unless raw_options.blank?
+    end
+
+    def plugins
+      @options['plugins'] || []
+    end
+
+    # Validate and merge options and raw_options into a string
+    # to be used for tinyMCE.init() in the raw_tiny_mce_init helper
+    def to_json
+      raise TinyMCEInvalidOptionType.invalid_type_of(plugins, :for => :plugins) unless plugins.is_a?(Array)
+
+      json_options = []
+      @options.each_pair do |key, value|
+        raise TinyMCEInvalidOption.invalid_option(key) unless valid?(key)
+        json_options << "#{key} : " + case value
+        when String, Symbol, Fixnum
+          "'#{value.to_s}'"
+        when Array
+          '"' + value.join(',') + '"'
+        when TrueClass
+          'true'
+        when FalseClass
+          'false'
+        else
+          raise TinyMCEInvalidOptionType.invalid_type_of(value, :for => key)
+        end
+      end
+
+      json_options.sort!
+
+      @raw_options.compact!
+      json_options += @raw_options unless @raw_options.blank?
+
+      "{\n" + json_options.delete_if {|o| o.blank? }.join(",\n") + "\n\n}"
+    end
+
+    # Does the check to see if the option is valid. It checks the valid_options
+    # array (see above), checks if the start of the option name is in the plugin list
+    # or checks if it's an theme_advanced_container setting
+    def valid?(option)
+      option = option.to_s
+      self.class.valid_options.include?(option) ||
+        plugins.include?(option.split('_').first) ||
+        option =~ /^theme_advanced_container_\w+$/
+    end
+  end
+end

data/lib/tiny_mce/exceptions.rb

@@ -0,0 +1,14 @@
+module TinyMCE
+  # Setup a couple of Exception classes that we use later on
+  class TinyMCEInvalidOption < Exception
+    def self.invalid_option(option)
+      new "Invalid option #{option} passed to tinymce"
+    end
+  end
+
+  class TinyMCEInvalidOptionType < Exception
+    def self.invalid_type_of(value, parameters={})
+      new "Invalid value of type #{value.class} passed for TinyMCE option #{parameters[:for].to_s}"
+    end
+  end
+end

data/lib/tiny_mce/helpers.rb

@@ -1,9 +1,6 @@
 module TinyMCE
   # The helper module we include into ActionController::Base
   module Helpers
-    # Setup a couple of Exception classes that we use later on
-    class TinyMCEInvalidOption < Exception; end
-    class TinyMCEInvalidOptionType < Exception; end
 
     # Has uses_tiny_mce method been declared in the controller for this page?
     def using_tiny_mce?
@@ -12,60 +9,27 @@ module TinyMCE
 
     # Parse @tiny_mce_options and @raw_tiny_mce_options to create a raw JS string
     # used by TinyMCE. Returns errors if the option or options type is invalid
-    def raw_tiny_mce_init(options = {}, raw_options = '')
-      # first we set some defaults, then we merge in the controller level options
-      # and finally merge in the view level options (to give presidence)
-      @tiny_mce_options ||= {}
-      default_options = { 'mode' => 'textareas',
-                  'editor_selector' => 'mceEditor',
-                  'theme' => 'simple',
-                  'language' => (defined?(I18n) ? I18n.locale : :en) }
-      options = default_options.merge(@tiny_mce_options.stringify_keys).merge(options.stringify_keys)
-      raw_options = @raw_tiny_mce_options + raw_options unless @raw_tiny_mce_options.nil?
-
-      unless options['plugins'].nil?
-        raise TinyMCEInvalidOptionType.new("Invalid value of type #{options['plugins'].class} passed for TinyMCE option plugins") unless options['plugins'].kind_of?(Array)
-
-        # Append the plugins we have enabled for this field to the OptionsValidator
-        TinyMCE::OptionValidator.plugins += options['plugins']
+    def raw_tiny_mce_init(options = {}, raw_options = nil)
+      tinymce_js = ""
+
+      @tiny_mce_configurations ||= [Configuration.new]
+      @tiny_mce_configurations.each do |configuration|
+        configuration.add_options(options, raw_options)
+        tinymce_js += "tinyMCE.init("
+        tinymce_js += configuration.to_json
+        tinymce_js += ");"
       end
 
-      tinymce_js = "tinyMCE.init({\n"
-      options.sort.each_with_index do |values, index|
-        key, value = values[0], values[1]
-        raise TinyMCEInvalidOption.new("Invalid option #{key} passed to tinymce") unless TinyMCE::OptionValidator.valid?(key)
-        tinymce_js += "#{key} : "
-        case value
-        when String, Symbol, Fixnum
-          tinymce_js += "'#{value.to_s}'"
-        when Array
-          tinymce_js += '"' + value.join(',') + '"'
-        when TrueClass
-          tinymce_js += 'true'
-        when FalseClass
-          tinymce_js += 'false'
-        else
-          raise TinyMCEInvalidOptionType.new("Invalid value of type #{value.class} passed for TinyMCE option #{key}")
-        end
-        if (index < options.size - 1)
-          # there are more options in this array
-          tinymce_js += ",\n"
-        else
-          # no more options in this array. Finish it by adding the addition JS
-          tinymce_js += ",\n#{raw_options}" unless raw_options.blank?
-          tinymce_js += "\n"
-        end
-      end
-      tinymce_js += "\n});"
+      tinymce_js
     end
 
     # Form the raw JS and wrap in in a <script> tag for inclusion in the <head>
-    def tiny_mce_init(options = {}, raw_options = '')
+    def tiny_mce_init(options = {}, raw_options = nil)
       javascript_tag raw_tiny_mce_init(options, raw_options)
     end
     # Form the raw JS and wrap in in a <script> tag for inclusion in the <head>
     # (only if tiny mce is actually being used)
-    def tiny_mce_init_if_needed(options = {}, raw_options = '')
+    def tiny_mce_init_if_needed(options = {}, raw_options = nil)
       tiny_mce_init(options, raw_options) if using_tiny_mce?
     end
 
@@ -82,7 +46,7 @@ module TinyMCE
     # Form a JS include tag for the TinyMCE JS src, and form the raw JS and wrap
     # in in a <script> tag for inclusion in the <head> for inclusion in the <head>
     # (only if tiny mce is actually being used)
-    def include_tiny_mce_if_needed(options = {}, raw_options = '')
+    def include_tiny_mce_if_needed(options = {}, raw_options = nil)
       if using_tiny_mce?
         include_tiny_mce_js + tiny_mce_init(options, raw_options)
       end

data/lib/tiny_mce/spell_checker.rb

@@ -63,7 +63,5 @@ module TinyMCE
       end
       return xml_response_values
     end
-
   end
-
 end

data/lib/tiny_mce/valid_tinymce_options.yml

@@ -4,7 +4,6 @@
 #
 
 # General
-- accessibility_focus
 - accessibility_warnings
 - auto_focus
 - browsers
@@ -26,7 +25,6 @@
 - skin
 - skin_variant
 - strict_loading_mode
-- tab_focus
 - table_inline_editing
 - theme
 
@@ -76,6 +74,7 @@
 - remove_linebreaks
 - remove_redundant_brs
 - preformatted
+- style_formats
 - valid_child_elements
 - valid_elements
 - verify_css_classes
@@ -113,10 +112,6 @@
 - external_link_list_url
 - external_image_list_url
 
-# Tab specific
-- display_tab_class
-- hidden_tab_class
-
 # Triggers/Patches
 - add_form_submit_trigger
 - add_unload_trigger

data/test/functional/full_tiny_mce_controller_test.rb

@@ -34,8 +34,8 @@ class FullTinyMCEControllerTest <  ActionController::TestCase
     get :show_page
     assert_response :success
     assert_nil assigns(:uses_tiny_mce)
-    assert_nil assigns(:tiny_mce_options)
-    assert_nil assigns(:raw_tiny_mce_options)
+    assert_nil assigns(:tiny_mce_configurations)
+    # assert_nil assigns(:raw_tiny_mce_options)
   end
 
   #
@@ -53,8 +53,8 @@ class FullTinyMCEControllerTest <  ActionController::TestCase
 
   test "the spellchecker has a default path to use" do
     get :new_page
-    assert_not_nil assigns(:tiny_mce_options)
-    assert_equal assigns(:tiny_mce_options)[:spellchecker_rpc_url], "/full_tiny_mce/spellchecker"
+    assert_not_nil assigns(:tiny_mce_configurations).first
+    assert_equal assigns(:tiny_mce_configurations).first.options["spellchecker_rpc_url"], "/full_tiny_mce/spellchecker"
   end
 
   private
@@ -63,12 +63,9 @@ class FullTinyMCEControllerTest <  ActionController::TestCase
     assert_response :success
     assert (assigns(:uses_tiny_mce) &&
             assigns(:uses_tiny_mce) == true)
-    assert (assigns(:tiny_mce_options) &&
-            assigns(:tiny_mce_options).is_a?(Hash) &&
-            assigns(:tiny_mce_options) == { :spellchecker_rpc_url=> "/full_tiny_mce/spellchecker",
-                                            :plugins => ['spellchecker'] })
-    assert (assigns(:raw_tiny_mce_options) &&
-            assigns(:raw_tiny_mce_options) == '')
+    assert (assigns(:tiny_mce_configurations) &&
+           assigns(:tiny_mce_configurations).is_a?(Array) &&
+          assigns(:tiny_mce_configurations).first.options == { "spellchecker_rpc_url"=> "/full_tiny_mce/spellchecker",
+                                            "plugins" => ['spellchecker'] })
   end
-
-end
+end

data/test/functional/multi_configuration_tiny_mce_controller_test.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+# Make a test class with full options
+class MultiConfigurationTinyMCEController < ApplicationController
+  uses_tiny_mce :options => { :plugins => ['spellchecker'] },
+                :raw_options => '',
+                :only => ['new_page','edit_page']
+  uses_tiny_mce :options => { :plugins => ['paste','fullscreen'] },
+                :raw_options => '',
+                :only => ['edit_page']
+  include TinyMCEActions
+end
+
+# Lets make sure that if routes arn't the
+# defaults, these tests will still work
+ActionController::Routing::Routes.draw do |map|
+  map.with_options :controller => 'multi_configuration_tiny_mce' do |tiny_mce|
+    tiny_mce.connect '/full_tiny_mce/new_page', :action => 'new_page'
+    tiny_mce.connect '/full_tiny_mce/edit_page', :action => 'edit_page'
+    tiny_mce.connect '/full_tiny_mce/show_page', :action => 'show_page'
+    tiny_mce.connect '/full_tiny_mce/spellchecker', :action => 'spellchecker'
+  end
+end
+
+# Use non-default action names to get around possible authentication
+# filters to ensure the tests work in most cases
+class MultiConfigurationTinyMCEControllerTest <  ActionController::TestCase
+
+  test "all instance variables are properly set on new" do
+    get :new_page
+    assert_response :success
+    assert (assigns(:uses_tiny_mce) &&
+            assigns(:uses_tiny_mce) == true)
+    assert (assigns(:tiny_mce_configurations) &&
+          assigns(:tiny_mce_configurations).is_a?(Array) &&
+          assigns(:tiny_mce_configurations).first.options == { "spellchecker_rpc_url"=> "/multi_configuration_tiny_mce/spellchecker",
+                                                              "plugins" => ['spellchecker'] })
+  end  
+
+  test "all instance variables are properly set on edit" do
+    get :edit_page
+    assert_response :success
+    assert (assigns(:uses_tiny_mce) &&
+          assigns(:uses_tiny_mce) == true)
+    assert (assigns(:tiny_mce_configurations) &&
+          assigns(:tiny_mce_configurations).is_a?(Array) &&
+          assigns(:tiny_mce_configurations).first.options == { "spellchecker_rpc_url"=> "/multi_configuration_tiny_mce/spellchecker",
+                                                              "plugins" => ['spellchecker'] } &&
+          assigns(:tiny_mce_configurations).second.options == { "plugins" => ['paste','fullscreen'] })
+  end
+
+  test "tiny mce is only loaded on the pages specified to the uses_tiny_mce declaration" do
+    get :show_page
+    assert_response :success
+    assert_nil assigns(:uses_tiny_mce)
+    assert_nil assigns(:tiny_mce_configurations)
+  end
+end