RubyGems - tiny_mce - Versions diffs - 0.0.1 - Mend

tiny_mce 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1290) hide show

data/DEV_UPGRADE_NOTES ADDED

@@ -0,0 +1,13 @@
+---------------------------------
+How to update the bundled TinyMCE
+---------------------------------
+1) Download TinyMCE, and extract it to your Desktop
+2) Delete the copy of TinyMCE in the plugin at public/javascripts/tiny_mce (this ensures old/removed files are deleted)
+3) Copy the source files of TinyMCE (not documentation) to public/javascripts/tiny_mce
+4) Update the CHANGELOG_PLUGIN to say what you upgraded from, what you upgraded to, and your name
+5) Update CHANGELOG_TINYMCE (download and overwrite the file with http://tinymce.moxiecode.com/js/tinymce/changelog.txt)
+6) Update the 'Bundled TinyMCE version' value at the bottom of README.rdoc
+7) Update the version value in tasks/tiny_mce.rake
+8) Update tiny_mce_options.yml with any new options, or remove old ones, as described in the tinymce changelog
+9) Commit, push, and send pull request to http://github.com/kete/tiny_mce

data/README.rdoc ADDED

@@ -0,0 +1,155 @@
+= TinyMCE for Rails
+This plugin provides for the installation and utilization of TinyMCE in Ruby on Rails applications.
+TinyMCE is a WYSIWYG HTML editing component released under the GNU Public License 2.1 (GPL 2.1) by Moxiecode Systems (http://tinymce.moxiecode.com/).
+== Installation
+Installing TinyMCE for Rails takes no more than a few minutes to install.
+=== Step 1
+Open a console, and in the root of you Rails application, install the plugin by running one of the following (depending on the method you use to import plugins):
+* script/plugin install git://github.com/kete/tiny_mce.git
+* piston import git://github.com/kete/tiny_mce.git vendor/plugins/tiny_mce
+* git submodule add git://github.com/kete/tiny_mce.git vendor/plugins/tiny_mce
+* Download the latest files ( http://github.com/kete/tiny_mce/tarball/master ) and extract to vendor/plugins/tiny_mce
+=== Step 2
+Then install the necessary files into your public directory by running
+  rake tiny_mce:install
+or, if you are updating a previously installed version
+  rake tiny_mce:update
+=== Step 3
+Add the following to the controller of the page you want to add TinyMCE to.
+  uses_tiny_mce
+Then append the following to the text area you want to transform into a TinyMCE editor. You can change the name by editing the 'editor_selector' param in the controller code options.
+  :class => "mceEditor"
+Lastly, add the following line(s) to the <head> element of your application view:
+  <%= include_tiny_mce_if_needed %>
+Now you're all set!
+== Configuration
+There are several ways to configure the plugin to get the desirable effect you're looking for. The following ways can be combined to create complex tiny mce setups
+=== TinyMCE options
+You can change the theme, order/choice of buttons, selectors Id, plugins, and many more by passing an :options hash to the uses_tiny_mce declaration.
+The options hash can contain any number of settings available in tiny_mce_options.yml  (a copy of the settings available per version).
+If an option is misspelled, invalid, or deprecated (no longer in TinyMCE), when you go to a page containing your editor, you will receive an Exception, which must be dealt with before continuing.
+You can read about all these options at http://tinymce.moxiecode.com/documentation.php
+==== Example
+  uses_tiny_mce :options => {
+                              :theme => 'advanced',
+                              :theme_advanced_resizing => true,
+                              :theme_advanced_resize_horizontal => false,
+                              :plugins => %w{ table fullscreen }
+                            }
+=== Filter options
+If, like most applications, you only need the editor on the new, create, edit, and update pages, then tell the uses_tiny_mce declaration this, so it doesn't load up all the files unnecessarily.
+The declaration accepts any number of default parameters a normal controller filter would.
+==== Example
+  uses_tiny_mce :only => [:new, :create, :edit, :update]
+=== Additional Javascript options
+Sometimes, when you need complex arrays of data for plugins or such, the plugin helpers aren't complex enough to do what you need. But you can always fall back to supplying your own options. You can this by passing a raw javascript (no <script> tags) to the uses_tiny_mce declaration. Consider the following example for the template plugin.
+  uses_tiny_mce :raw_options => "template_templates : [ {
+                                                          title : 'Editor Details',
+                                                          src : 'editor_details.htm',
+                                                          description : 'Adds Editors Name and Staff ID'
+                                                      } ]"
+== Methods
+TinyMCE has a range of convenience methods for loading TinyMCE. Besides the uses_tiny_mce shown above, they include:
+  using_tiny_mce?
+      Check whether the uses_tiny_mce declaration has been made in the current controller
+  raw_tiny_mce_init
+      Creates a string of javascript formed from the options declared to uses_tiny_mce (is not wrapped in a JS tag though, use tiny_mce_init for that)
+  tiny_mce_init
+      Creates a javascript tag formed from the options declared to uses_tiny_mce (executes whether uses_tiny_mce was declared or not)
+  tiny_mce_init_if_needed
+      Creates a javascript tag formed from the options declared to uses_tiny_mce (executes only when uses_tiny_mce has been declared)
+  include_tiny_mce_js
+      Includes the TinyMCE core javascript file, must be declared before tiny_mce_init (executes whether uses_tiny_mce was declared or not)
+  include_tiny_mce_js_if_needed
+      Includes the TinyMCE core javascript file, must be declared before tiny_mce_init (executes only when uses_tiny_mce has been declared)
+  include_tiny_mce_if_needed
+      Includes the TinyMCE core javascript file, and creates a string of javascript formed from the options declared to uses_tiny_mce (executes only when uses_tiny_mce has been declared)
+== Spellchecking
+See SPELLCHECKING_PLUGIN.rdoc
+http://github.com/kete/tiny_mce/tree/master/SPELLCHECKING_PLUGIN.rdoc
+== Testing
+The plugin comes with a test suite that can be run once the plugin is installed in an application.
+Change into the plugins directory and run 'rake' to start them.
+Note: The tests require Rails 2.2 or higher, and are currently tested on Rails 2.3 RC1 (so problems in older versions may arise - please see "Reporting an Issue" if they do)
+== Reporting an Issue
+If you have a problem, please report it on the tiny_mce plugin ticket tracker (on Ligthouseapp)
+http://kete.lighthouseapp.com/projects/14744-tiny_mce/tickets
+Be sure to include Rails version, plugin version, and when possible, a sample application that can reproduce the problem. Upload it to one of the various file hosting sites and link to it in the ticket. Don't include vendored rails or the tiny_mce plugin in the archive (if I know the versions, I'll add these myself).
+== Contributing
+If you've added something, why not share it. Fork the repository (http://github.com/kete/tiny_mce), make the changes and send a pull request to the maintainers.
+Changes with tests, and full documentation are preferred.
+= Credits
+This plugin was created by Blake Watters <blake@near-time.com>
+This plugin is currently maintained by Kieran Pilkington <kieran@katipo.co.nz>
+Bundled TinyMCE version: 3.2.6

data/Rakefile ADDED

@@ -0,0 +1,40 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = 'tiny_mce'
+    gem.summary = %Q{TinyMCE editor for your rails applications}
+    gem.description = %Q{gem that allows easy implementation of the TinyMCE editor into your applications.}
+    gem.email = "rotuka@rotuka.com"
+    gem.homepage = "http://github.com/krasivotokak/tiny_mce"
+    gem.authors = ['Blake Watters', 'Kieran Pilkington', "Alexander Semyonov"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+desc 'Default: run unit tests.'
+task :default => :test
+desc 'Test the tiny_mce plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+desc 'Generate documentation for the tiny_mce plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'TinyMce'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/SPELLCHECKING_PLUGIN.rdoc ADDED

@@ -0,0 +1,54 @@
+= Spellchecking in TinyMCE for Rails
+TinyMCE comes packed with a spellcheck plugin that relies on a server-side call to function.
+If uses_tiny_mce is called in a controller, the controller will get a "spellchecker" action added to it that validates text given to it with aspell. Right now, only aspell is supported.
+== Installing Aspell
+If your distribution has Aspell in its package repositories, then use it. Some commands include (as root):
+  Debian/Ubuntu:  apt-get install aspell aspell-en
+  openSUSE:       yast2 -i aspell aspell-en
+  Mac OS X:       port install aspell aspell-dict-en
+If you're package repositories don't have Aspell, you'll need to compile from source. Whatever way you install it, make sure that you see the language dictionaries you plan to use when you run
+  aspell dicts
+== Installing Spellchecker on TinyMCE
+The SpellCheck plugin is not enabled by default in TinyMCE. To enable it, do the following.
+Add the following to your uses_tiny_mce controller options declaration (edit toolbar location to suit and merge with existing settings):
+  :theme => 'advanced',
+  :theme_advanced_buttons3_add => %w{ spellchecker },
+  :spellchecker_languages => "+English=en",
+  :plugins => %w{ spellchecker },
+== Customization
+By default, Spellchecking calls "/controller/spellchecker". But this won't always be where the spellchecker method is accessible. But you can easily change where it should call by supplying the following setting to the options hash on the uses_tiny_mce declaration in the controller.
+  :spellchecker_rpc_url => '/blog/posts/spellchecker'
+Also, if you want to have other languages spellchecked, make sure they're installed for Aspell to use and then add to the comma delimited value of :spellchecker_languages in the format of
+  FriendlyName=code
+So the value for English, French, German and Spanish would look like this for example
+  :spellchecker_languages => "+English=en,French=fr,German=de,Spanish=es",
+The + sign in front of a friendly name indicates the default option for spellchecking.
+= Credits
+Spellchecking functionality created by Akhil Bansal ( http://webonrails.com/2008/08/08/configuring-tinymce-spellchecker-with-rails-application/ )
+Spellchecking functionality integrated into plugin by Terry Heath

data/VERSION ADDED

	@@ -0,0 +1 @@
1	+ 0.0.1

data/init.rb ADDED

@@ -0,0 +1,13 @@
+# Require all the necessary files to run TinyMCE
+require 'tiny_mce'
+require 'options_validator'
+require 'spellchecker'
+require 'tiny_mce_helpers'
+# Load up the available configuration options (we do it here because
+# the result doesn't, so we don't want to load it per request)
+TinyMCE::OptionValidator.load
+# Include the TinyMCE methods and TinyMCE Helpers into ActionController::Base
+ActionController::Base.send(:include, TinyMCE)
+ActionController::Base.send(:helper, TinyMCEHelpers)

data/install.rb ADDED

@@ -0,0 +1,8 @@
+# Lets output something to the console when people use script/plugin to install tiny_mce
+puts "-------"
+puts "tiny_mce plugin"
+puts ""
+puts "Thanks for installing the tiny_mce plugin."
+puts "To complete the process, please view README.rdoc."
+puts "Read the section entitled 'Installation"
+puts "-------"

data/lib/options_validator.rb ADDED

@@ -0,0 +1,35 @@
+# The base module we include into ActionController::Base
+module TinyMCE
+  # We use this to 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
+  module OptionValidator
+    class << self
+      # Used to set the array of plugins being used
+      cattr_accessor :plugins
+      # Parse the options file and load it into an array
+      # (this method is called when tiny_mce is initialized - see init.rb)
+      def load
+        @@valid_options = File.open(File.dirname(__FILE__) + "/../tiny_mce_options.yml") { |f| YAML.load(f.read) }
+        self.plugins = Array.new
+      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
+        @@valid_options.include?(option) ||
+          (plugins && plugins.include?(option.split('_')[0])) ||
+          option =~ /^theme_advanced_container_\w+$/
+      end
+      # If we need to get the array of valid options, we can call this method
+      def options
+        @@valid_options
+      end
+    end
+  end
+end

data/lib/spellchecker.rb ADDED

@@ -0,0 +1,69 @@
+# 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.rb ADDED

@@ -0,0 +1,40 @@
+# The base module we include into ActionController::Base
+module TinyMCE
+  # When this module is included, extend it with the available class methods
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  module ClassMethods
+    # The controller declaration to enable tiny_mce on certain actions.
+    # 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) || ''
+      # 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
+      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)
+        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

data/lib/tiny_mce_helpers.rb ADDED

@@ -0,0 +1,91 @@
+# The helper module we include into ActionController::Base
+module TinyMCEHelpers
+  # 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?
+    !@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 = '')
+    # 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']
+    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});"
+	end
+  # Form the raw JS and wrap in in a <script> tag for inclusion in the <head>
+  def tiny_mce_init(options = {}, raw_options = '')
+    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 = '')
+    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.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 = '')
+    if using_tiny_mce?
+      include_tiny_mce_js + tiny_mce_init(options, raw_options)
+    end
+  end
+end