runtastic-tiny_mce 0.1.5.pre

data/lib/tiny_mce/configuration.rb

@@ -0,0 +1,113 @@
+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
+
+    # The default tiny_mce options. Tries it's best to determine the locale
+    # If the current locale doesn't have a lang in TinyMCE, default to en
+    def self.default_options
+      locale = I18n.locale.to_s[0,2] if defined?(I18n)
+      locale = :en unless locale && valid_langs.include?(locale)
+      { 'mode' => 'textareas', 'editor_selector' => 'mceEditor',
+        'theme' => 'simple',   'language' => locale }
+    end
+
+    # 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
+    # Run it through an ERB parser so that environment specific code can be
+    # put in the file
+    def self.config_file_options
+      @@config_file_options ||= begin
+        tiny_mce_yaml_filepath = File.join(Rails.root.to_s, 'config', 'tiny_mce.yml')
+        return Hash.new unless File.exist?(tiny_mce_yaml_filepath)
+        tiny_mce_config = IO.read(tiny_mce_yaml_filepath)
+        tiny_mce_config = ERB.new(tiny_mce_config).result if defined?(ERB)
+        (YAML::load(tiny_mce_config) rescue nil) || Hash.new
+      end
+    end
+
+    # Parse the valid langs file and load it into an array
+    def self.valid_langs
+      @@valid_langs ||= begin
+        valid_langs_path = File.join(File.dirname(__FILE__), 'valid_tinymce_langs.yml')
+        File.open(valid_langs_path) { |f| YAML.load(f.read) }
+      end
+    end
+
+    # Parse the valid options file and load it into an array
+    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 = self.class.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

@@ -0,0 +1,55 @@
+module TinyMCE
+  # The helper module we include into ActionController::Base
+  module Helpers
+
+    # Has uses_tiny_mce method been declared in the controller for this page?
+    def using_tiny_mce?
+      !@uses_tiny_mce.blank?
+    end
+
+    # 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 = 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
+    end
+
+    # Form the raw JS and wrap in in a <script> tag for inclusion in the <head>
+    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 = nil)
+      tiny_mce_init(options, raw_options) if using_tiny_mce?
+    end
+
+    # Form a JS include tag for the TinyMCE JS src for inclusion in the <head>
+    def include_tiny_mce_js
+      javascript_include_tag (Rails.env.to_s == 'development' ? "tiny_mce/tiny_mce_src" : "tiny_mce/tiny_mce")
+    end
+    # Form a JS include tag for the TinyMCE JS src for inclusion in the <head>
+    # (only if tiny mce is actually being used)
+    def include_tiny_mce_js_if_needed
+      include_tiny_mce_js if using_tiny_mce?
+    end
+
+    # 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 = nil)
+      if using_tiny_mce?
+        include_tiny_mce_js + tiny_mce_init(options, raw_options)
+      end
+    end
+  end
+end

data/lib/tiny_mce/railtie.rb

@@ -0,0 +1,13 @@
+if defined?(Rails::Railtie)
+  module TinyMCE
+    class Railtie < Rails::Railtie
+      rake_tasks do
+        load "tasks/tiny_mce.rake"
+      end
+
+      initializer :tiny_mce do
+        TinyMCE.initialize
+      end
+    end
+  end
+end

data/lib/tiny_mce/spell_checker.rb

@@ -0,0 +1,67 @@
+# The base module we include into ActionController::Base
+module TinyMCE
+
+  # Provides Spell checking capability to tiny_mce plugin
+  # Note: this may not always be up to date.
+  # Please supply patches if this isn't working
+  module SpellChecker
+
+    require 'net/https'
+    require 'uri'
+    require 'rexml/document'
+
+    ASPELL_WORD_DATA_REGEX = Regexp.new(/\&\s\w+\s\d+\s\d+(.*)$/)
+
+    # Attempt to determine where Aspell is
+    # Might be slow and a horrible way to do it, but it works!
+    # Should also grab Mac OS X and Window path's instead of assuming linux
+    aspell_path = nil
+    ['/usr/bin/aspell', '/usr/local/bin/aspell'].each do |path|
+      if File.exists?(path)
+        aspell_path = path
+        break
+      end
+    end
+    ASPELL_PATH = aspell_path || "aspell" # fall back to a pathless call
+
+    # The method called via AJAX request by the Spellchecking plugin in TinyMCE.
+    # Passes in various params (language, words, and method)
+    # Return a JSON object required by the Spellchecking plugin
+    def spellchecker
+      language, words, method = params[:params][0], params[:params][1], params[:method] unless params[:params].blank?
+      return render(:nothing => true) if language.blank? || words.blank? || method.blank?
+      headers["Content-Type"] = "text/plain"
+      headers["charset"] = "utf-8"
+      suggestions = check_spelling(words, method, language)
+      results = {"id" => nil, "result" => suggestions, "error" => nil}
+      render :json => results
+    end
+
+    private
+
+    # This method is called by the spellchecker action.
+    # Is sends a command to the system, and parses the output
+    # Returns different value depending on the command (checking words, or getting suggestions)
+    def check_spelling(spell_check_text, command, lang)
+      xml_response_values = Array.new
+      spell_check_text = spell_check_text.join(' ') if command == 'checkWords'
+      logger.debug("Spellchecking via:  echo \"#{spell_check_text}\" | #{ASPELL_PATH} -a -l #{lang}")
+      spell_check_response = `echo "#{spell_check_text}" | #{ASPELL_PATH} -a -l #{lang}`
+      return xml_response_values if spell_check_response.blank?
+      spelling_errors = spell_check_response.split("\n").slice(1..-1)
+      for error in spelling_errors
+        error.strip!
+        if (match_data = error.match(ASPELL_WORD_DATA_REGEX))
+          if (command == 'checkWords')
+            arr = match_data[0].split(' ')
+            xml_response_values << arr[1]
+          elsif (command == 'getSuggestions')
+            xml_response_values << error.split(',')[1..-1].collect(&:strip!)
+            xml_response_values = xml_response_values.first
+          end
+        end
+      end
+      return xml_response_values
+    end
+  end
+end

data/lib/tiny_mce/valid_tinymce_langs.yml

@@ -0,0 +1,37 @@
+#
+# For more information about available languages, see
+# http://tinymce.moxiecode.com/download_i18n.php
+# Should only include a list of completed translations (not incomplete ones which most are :-( )
+#
+
+--- 
+- ar
+- ca
+- ch
+- cs
+- cy
+- de
+- en
+- es
+- fr
+- he
+- hi
+- hr
+- hu
+- it
+- ja
+- ka
+- kl
+- ko
+- lb
+- nl
+- pl
+- pt
+- pt-BR
+- ru
+- sk
+- sv
+- ta
+- uk
+- vi
+- zh

data/lib/tiny_mce/valid_tinymce_options.yml

@@ -0,0 +1,165 @@
+#
+# For more information about each configuration options, see
+# http://wiki.moxiecode.com/index.php/TinyMCE:Configuration
+#
+
+# General
+- accessibility_warnings
+- auto_focus
+- browsers
+- class_filter
+- custom_shortcuts
+- dialog_type
+- directionality
+- editor_deselector
+- editor_selector
+- elements
+- gecko_spellcheck
+- keep_styles
+- language
+- mode
+- nowrap
+- object_resizing
+- plugins
+- readonly
+- skin
+- skin_variant
+- strict_loading_mode
+- table_inline_editing
+- theme
+
+# Callbacks
+- cleanup_callback
+- execcommand_callback
+- file_browser_callback
+- handle_event_callback
+- handle_node_change_callback
+- init_instance_callback
+- onchange_callback
+- oninit
+- onpageload
+- remove_instance_callback
+- save_callback
+- setup
+- setupcontent_callback
+- urlconverter_callback
+
+# Cleanup/Output
+- apply_source_formatting
+- cleanup
+- cleanup_on_startup
+- convert_fonts_to_spans
+- convert_newlines_to_brs
+- custom_elements
+- doctype
+- element_format
+- encoding
+- entities
+- entity_encoding
+- extended_valid_elements
+- fix_content_duplication
+- fix_list_elements
+- fix_table_elements
+- fix_nesting
+- font_size_classes
+- font_size_style_values
+- force_p_newlines
+- force_br_newlines
+- force_hex_style_colors
+- forced_root_block
+- formats
+- indentation
+- inline_styles
+- invalid_elements
+- merge_styles_invalid_parents
+- remove_linebreaks
+- remove_redundant_brs
+- preformatted
+- style_formats
+- valid_child_elements
+- valid_elements
+- verify_css_classes
+- verify_html
+- removeformat_selector
+
+# URL
+- convert_urls
+- relative_urls
+- remove_script_host
+- document_base_url
+
+# Layout
+- body_id
+- body_class
+- constrain_menus
+- content_css
+- popup_css
+- popup_css_add
+- editor_css
+- width
+- height
+
+# Visual aids
+- visual
+- visual_table_class
+
+# Undo/Redo
+- custom_undo_redo
+- custom_undo_redo_levels
+- custom_undo_redo_keyboard_shortcuts
+- custom_undo_redo_restore_selection
+
+# File lists
+- external_link_list_url
+- external_image_list_url
+- external_media_list_url
+- external_template_list_url
+
+# Triggers/Patches
+- add_form_submit_trigger
+- add_unload_trigger
+- submit_patch
+
+# Advanced theme
+- theme_advanced_layout_manager
+- theme_advanced_blockformats
+- theme_advanced_styles
+- theme_advanced_source_editor_width
+- theme_advanced_source_editor_height
+- theme_advanced_source_editor_wrap
+- theme_advanced_toolbar_location
+- theme_advanced_toolbar_align
+- theme_advanced_statusbar_location
+- theme_advanced_buttons1
+- theme_advanced_buttons1_add
+- theme_advanced_buttons1_add_before
+- theme_advanced_buttons2
+- theme_advanced_buttons2_add
+- theme_advanced_buttons2_add_before
+- theme_advanced_buttons3
+- theme_advanced_buttons3_add
+- theme_advanced_buttons3_add_before
+- theme_advanced_buttons4
+- theme_advanced_buttons4_add
+- theme_advanced_buttons4_add_before
+- theme_advanced_disable
+- theme_advanced_containers
+- theme_advanced_containers_default_class
+- theme_advanced_containers_default_align
+- theme_advanced_custom_layout
+- theme_advanced_link_targets
+- theme_advanced_resizing
+- theme_advanced_resizing_min_width
+- theme_advanced_resizing_min_height
+- theme_advanced_resizing_max_width
+- theme_advanced_resizing_max_height
+- theme_advanced_resizing_use_cookie
+- theme_advanced_resize_horizontal
+- theme_advanced_path
+- theme_advanced_fonts
+- theme_advanced_font_sizes
+- theme_advanced_text_colors
+- theme_advanced_background_colors
+- theme_advanced_default_foreground_color
+- theme_advanced_default_background_color
+- theme_advanced_more_colors

data/lib/tiny_mce.rb

@@ -0,0 +1,152 @@
+# Require all the necessary files to run TinyMCE
+require 'tiny_mce/base'
+require 'tiny_mce/exceptions'
+require 'tiny_mce/configuration'
+require 'tiny_mce/spell_checker'
+require 'tiny_mce/helpers'
+
+module TinyMCE
+  def self.initialize
+    return if @intialized
+    raise "ActionController is not available yet." unless defined?(ActionController)
+    ActionController::Base.send(:include, TinyMCE::Base)
+    ActionController::Base.send(:helper, TinyMCE::Helpers)
+    TinyMCE.install_or_update_tinymce
+    @intialized = true
+  end
+
+  def self.install_or_update_tinymce
+    require 'fileutils'
+    orig = File.join(File.dirname(__FILE__), 'tiny_mce', 'assets', 'tiny_mce')
+    dest = File.join(Rails.root.to_s, 'public', 'javascripts', 'tiny_mce')
+    tiny_mce_js = File.join(dest, 'tiny_mce.js')
+
+    unless File.exists?(tiny_mce_js) && FileUtils.identical?(File.join(orig, 'tiny_mce.js'), tiny_mce_js)
+      if File.exists?(tiny_mce_js)
+        # upgrade
+        begin
+          puts "Removing directory #{dest}..."
+          FileUtils.rm_rf dest
+          puts "Creating directory #{dest}..."
+          FileUtils.mkdir_p dest
+          puts "Copying TinyMCE to #{dest}..."
+          FileUtils.cp_r "#{orig}/.", dest
+          puts "Successfully updated TinyMCE."
+        rescue
+          puts 'ERROR: Problem updating TinyMCE. Please manually copy '
+          puts orig
+          puts 'to'
+          puts dest
+        end
+      else
+        # install
+        begin
+          puts "Creating directory #{dest}..."
+          FileUtils.mkdir_p dest
+          puts "Copying TinyMCE to #{dest}..."
+          FileUtils.cp_r "#{orig}/.", dest
+          puts "Successfully installed TinyMCE."
+        rescue
+          puts "ERROR: Problem installing TinyMCE. Please manually copy "
+          puts orig
+          puts "to"
+          puts dest
+        end
+      end
+    end
+
+    tiny_mce_yaml_filepath = File.join(Rails.root.to_s, 'config', 'tiny_mce.yml')
+    unless File.exists?(tiny_mce_yaml_filepath)
+      File.open(tiny_mce_yaml_filepath, 'w') do |f|
+        f.puts '# Here you can specify default options for TinyMCE across all controllers'
+        f.puts '#'
+        f.puts '# theme: advanced'
+        f.puts '# plugins:'
+        f.puts '#  - table'
+        f.puts '#  - fullscreen'
+      end
+      puts "Written configuration example to #{tiny_mce_yaml_filepath}"
+    end
+  end
+  
+  #this method generate new language to tinyMCE
+  def self.generate_new_lang(env_lang)
+    
+    puts "---------------------------------------------------------------------------------------"
+    puts "\t\t TinyMCE Language Basic Generator"
+    puts "---------------------------------------------------------------------------------------"
+    unless env_lang.empty?
+    
+      lib_tinymce = File.join(File.dirname(__FILE__), 'tiny_mce')
+      file = File.join(lib_tinymce, "valid_tinymce_langs.yml")
+      yml_langs = YAML::load(File.open(file))
+
+      unless yml_langs.include?(env_lang)
+        yml_langs << env_lang
+        yml_langs.sort!
+    
+        #writing new language to valid_tinymce_langs.yml
+        File.open(file, 'w') do |f|
+          f << "#\n# For more information about available languages, see\n"
+          f <<  "# http://tinymce.moxiecode.com/download_i18n.php\n"
+          f << "# Should only include a list of completed translations (not incomplete ones which most are :-( )\n#\n\n"
+          f << YAML.dump(yml_langs).to_s
+        end
+         #start to copy en files to new lang
+          puts "Generated \"en\" lang copies, translate this files:"
+          puts "---------------------------------------------------------------------------------------"
+          puts " REMEMBER TO CHANGE ALL THIS FILES."
+          puts "IF YOU WANT TO TRANSLATE AN ESPECIFIC PLUGIN GO TO plugin/langs AND ADD YOUR LANG\n\n"
+        
+      else
+        puts "\n\n\t\tLanguage exists on configuration file.\n\n" 
+      end
+    
+      assets_path = File.join(lib_tinymce, 'assets', 'tiny_mce') 
+      unless File.exists?(File.join(assets_path, 'langs',"#{env_lang}.js"))
+        puts "\t- tiny_mce/lib/tiny_mce/assets/tiny_mce/langs/#{env_lang}.js"
+        FileUtils.cp( File.join(assets_path, "langs", "en.js"), File.join(assets_path, "langs","#{env_lang}.js")) 
+      end
+      unless File.exists?(File.join(assets_path,"themes","advanced","langs","#{env_lang}.js"))
+        puts "\t- tiny_mce/lib/tiny_mce/assets/tiny_mce/themes/advanced/langs/#{env_lang}.js"
+        FileUtils.cp(File.join(assets_path,"themes","advanced","langs","en.js"), File.join(assets_path,"themes","advanced","langs","#{env_lang}.js")) 
+      end
+      unless File.exists?(File.join(assets_path,"themes","advanced","langs","#{env_lang}_dlg.js"))
+        puts "\t- tiny_mce/lib/tiny_mce/assets/tiny_mce/themes/advanced/langs/#{env_lang}_dlg.js"
+        FileUtils.cp(File.join(assets_path,"themes","advanced","langs","en_dlg.js"), File.join(assets_path,"themes","advanced","langs","#{env_lang}_dlg.js"))
+      end
+      unless File.exists?(File.join(assets_path,"themes","simple","langs","#{env_lang}.js"))
+        puts "\t- tiny_mce/lib/tiny_mce/assets/tiny_mce/themes/simple/langs/#{env_lang}_dlg.js"
+        FileUtils.cp(File.join(assets_path,"themes","simple","langs","en.js"), File.join(assets_path,"themes","simple","langs","#{env_lang}.js")) 
+      end
+    
+      puts "---------------------------------------------------------------------------------------"
+    
+    else
+      puts "You must set the LANG environment. example: rake tiny_mce:new:lang LANG=pt-BR"
+    end
+  end
+
+  module Base
+    include TinyMCE::SpellChecker
+  end
+
+  # Plugin Support
+  class Plugin
+    cattr_accessor :assets_path
+    def self.install
+      return unless File.directory?(self.assets_path)
+      require 'fileutils'
+      puts "Installing #{self.name} plugin assets from #{self.assets_path}"
+      FileUtils.cp_r "#{self.assets_path}/.", File.join(Rails.root.to_s, 'public', 'javascripts', 'tiny_mce')
+    end
+  end
+end
+
+# Finally, lets include the TinyMCE base and helpers where
+# they need to go (support for Rails 2 and Rails 3)
+if defined?(Rails::Railtie)
+  require 'tiny_mce/railtie'
+else
+  TinyMCE.initialize
+end

data/test/functional/full_tiny_mce_controller_test.rb

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+# Make a test class with full options
+class FullTinyMCEController < ApplicationController
+  uses_tiny_mce :options => { :plugins => ['spellchecker'] },
+                :raw_options => '',
+                :only => ['new_page', '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 => 'full_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 FullTinyMCEControllerTest <  ActionController::TestCase
+
+  test "all instance variables are properly set on new and edit" do
+    get :new_page
+    assert_instance_vars_set
+    get :edit_page
+    assert_instance_vars_set
+  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)
+    # assert_nil assigns(:raw_tiny_mce_options)
+  end
+
+  #
+  # Spellchecking Controller Test
+  #
+
+  test "additional spellchecking method is available" do
+    assert @controller.methods.include?("spellchecker")
+  end
+
+  test "the spellchecker action is available" do
+    get :spellchecker
+    assert_response(:success)
+  end
+
+  test "the spellchecker has a default path to use" do
+    get :new_page
+    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
+
+  def assert_instance_vars_set
+    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"=> "/full_tiny_mce/spellchecker",
+                                            "plugins" => ['spellchecker'] })
+  end
+end