community_engine 2.0.0.beta1

data/vendor/plugins/tiny_mce/DEV_UPGRADE_NOTES.rdoc

@@ -0,0 +1,12 @@
+= Updating the bundled TinyMCE
+
+1. Download the new TinyMCE tarball and extract it to your Desktop (or other easily accessible location)
+2. Delete the copy of TinyMCE in the plugin at lib/tiny_mce/assets/tiny_mce (this ensures old/removed files are deleted)
+3. Copy the source files of TinyMCE (not the documentation) to lib/tiny_mce/assets/tiny_mce (so in that folder you should have a tiny_mce.js file)
+4. Update CHANGELOG_TINYMCE (simply download and overwrite the contents with that of http://tinymce.moxiecode.com/js/tinymce/changelog.txt)
+5. Update lib/tiny_mce/valid_tinymce_options.yml with any new options, or remove old ones, as described in the tinymce changelog
+6. Download all 'Complete' locales from http://tinymce.moxiecode.com/i18n/index.php?ctrl=lang&, unpack, and copy into place
+7. Update lib/tiny_mce/valid_tinymce_langs.yml with any new languages, or remove old/incomplete ones
+8. Update the CHANGELOG_PLUGIN.rdoc to say what you upgraded from, what you upgraded to, and your name
+9. Update the 'Bundled TinyMCE version' value at the bottom of README.rdoc
+10. Commit, push, and send pull request to http://github.com/kete/tiny_mce

data/vendor/plugins/tiny_mce/init.rb

@@ -0,0 +1,2 @@
+require 'tiny_mce'
+TinyMCE.initialize

data/vendor/plugins/tiny_mce/install.rb

@@ -0,0 +1,18 @@
+# Lets output something to the console when people use script/plugin to install tiny_mce
+puts <<-EOS
+-------
+
+tiny_mce plugin
+
+Thanks for installing the tiny_mce plugin.
+
+Complete the installation by running the following:
+
+rake tiny_mce:install
+
+Then to setup TinyMCE on your site, please view README.rdoc.
+
+Read the section entitled 'Installation'
+
+-------
+EOS

data/vendor/plugins/tiny_mce/lib/tiny_mce/base.rb

@@ -0,0 +1,33 @@
+module TinyMCE
+  # The base module we include into ActionController::Base
+  module Base
+    # 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 = {}, &block)
+        if block_given?
+          options = block.call
+        end        
+        
+        configuration = TinyMCE::Configuration.new(options.delete(:options), options.delete(:raw_options))
+                
+        # Set instance vars in the current class
+        proc = Proc.new do |c|
+          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/vendor/plugins/tiny_mce/lib/tiny_mce/configuration.rb

@@ -0,0 +1,114 @@
+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/vendor/plugins/tiny_mce/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/vendor/plugins/tiny_mce/lib/tiny_mce/helpers.rb

@@ -0,0 +1,43 @@
+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
+
+    def tiny_mce_configurations
+      @tiny_mce_configurations ||= [Configuration.new]
+    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.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
+
+    def tiny_mce_init_if_needed(options = {}, raw_options = nil)
+      tiny_mce_init(options, raw_options) if using_tiny_mce?
+    end
+
+    def include_tiny_mce_if_needed(options = {}, raw_options = nil)
+      tiny_mce_init_if_needed(options, raw_options)
+    end
+
+  end
+end

data/vendor/plugins/tiny_mce/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/vendor/plugins/tiny_mce/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/vendor/plugins/tiny_mce/lib/tiny_mce/valid_tinymce_langs.yml

@@ -0,0 +1,25 @@
+#
+# For more information about available languages, see
+# http://tinymce.moxiecode.com/i18n/index.php?ctrl=lang&
+# Should only include a list of completed translations (not incomplete ones which most are :-( )
+#
+
+--- 
+- ca
+- cs
+- da
+- en
+- fi
+- fr
+- ka
+- hu
+- ja
+- nb
+- no
+- pl
+- pt
+- ru
+- sk
+- sl
+- sv
+- zh-cn

data/vendor/plugins/tiny_mce/lib/tiny_mce/valid_tinymce_options.yml

@@ -0,0 +1,167 @@
+#
+# 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
+- script_url
+
+# 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_children
+- 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/vendor/plugins/tiny_mce/lib/tiny_mce.rb

@@ -0,0 +1,24 @@
+# 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)
+    @intialized = true
+  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/vendor/plugins/white_list/README

@@ -0,0 +1,35 @@
+WhiteList
+=========
+
+This White Listing helper will html encode all tags and strip all attributes that aren't specifically allowed.  
+It also strips href/src tags with invalid protocols, like javascript: especially.  It does its best to counter any
+tricks that hackers may use, like throwing in unicode/ascii/hex values to get past the javascript: filters.  Check out
+the extensive test suite.
+
+  <%= white_list @article.body %>
+
+You can add or remove tags/attributes if you want to customize it a bit.
+
+add table tags
+  
+  WhiteListHelper.tags += %w(table td th)
+
+remove tags
+  
+  WhiteListHelper.tags -= %w(div span)
+
+clear any attributes that are allowed for <a> tags
+
+  WhiteListHelper.attributes['a'] = []
+
+allow a new attribute for the <img> tag
+
+  WhiteListHelper.attributes['img'] += %w(style)
+
+add new tag with attributes
+
+  WhiteListHelper.attributes['table'] = %w(cellpadding cellspacing)
+
+change allowed attributes for all tags
+
+  WhiteListHelper.attributes[nil] = %w(id class style)

data/vendor/plugins/white_list/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the white_list plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the white_list plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'WhiteList'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/vendor/plugins/white_list/init.rb

@@ -0,0 +1,35 @@
+require 'white_list_helper'
+ActionView::Base.send :include, WhiteListHelper
+ActiveRecord::Base.send :include, WhiteListHelper
+
+ActiveRecord::Base.class_eval do
+  include ActionView::Helpers::TagHelper, ActionView::Helpers::TextHelper, WhiteListHelper, ActionView::Helpers::UrlHelper
+  
+  def self.format_attribute(attr_name)
+    class << self; include ActionView::Helpers::TagHelper, ActionView::Helpers::TextHelper, WhiteListHelper; end
+    define_method(:body)       { read_attribute attr_name }
+    define_method(:body=)      { |value| write_attribute "#{attr_name}", value }    
+    define_method(:body_html)  { read_attribute "#{attr_name}_html" }
+    define_method(:body_html=) { |value| write_attribute "#{attr_name}_html", value }
+    before_save :format_content
+  end
+
+  def dom_id
+    [self.class.name.downcase.pluralize.dasherize, id] * '-'
+  end
+
+  protected
+    def format_content
+      body.strip! if body.respond_to?(:strip!)
+      self.body_html = body.blank? ? '' : body_html_with_formatting
+      self.body = white_list(self.body)
+      
+    end
+    
+    def body_html_with_formatting
+      body_html = auto_link(body) { |text| truncate(text, :length => 50) }
+      # textilized = RedCloth.new(body_html, [ :hard_breaks ]) #not using this
+      # textilized.hard_breaks = true if textilized.respond_to?("hard_breaks=")
+      white_list(body_html) 
+    end
+end