tinymce-rails 3.5.11.1 → 4.0

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (C) 2011-14 by Sam Pohlenz
+Copyright (C) 2011-13 by Sam Pohlenz
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -5,60 +5,45 @@ The `tinymce-rails` gem integrates the [TinyMCE](http://www.tinymce.com/) editor
 
 This gem is compatible with Rails 3.1.1 and higher (including Rails 4).
 
-This is the branch for TinyMCE 3.5.x. For TinyMCE 4, please see the [master branch](https://github.com/spohlenz/tinymce-rails).
+This is the branch for TinyMCE 4. TinyMCE 3.5.x is currently available in the [master branch](https://github.com/spohlenz/tinymce-rails). For the time being, parallel versions of TinyMCE (3.5.x and 4.x) will be maintained. However TinyMCE 4 will eventually be promoted to the master branch.
 
-[![Build Status](https://travis-ci.org/spohlenz/tinymce-rails.png?branch=tinymce-3)](https://travis-ci.org/spohlenz/tinymce-rails)
+[![Build Status](https://travis-ci.org/spohlenz/tinymce-rails.png?branch=tinymce-4)](https://travis-ci.org/spohlenz/tinymce-rails)
 
-**New in 3.5.11, 4.1.10 and 4.2.1:** Alternative asset installation methods (copy vs compile/symlink). See the [Asset Compilation](#asset-compilation) section below for details.
 
 Instructions
 ------------
 
 **1. Add `tinymce-rails` to your Gemfile**
 
-```ruby
-gem 'tinymce-rails'
-```
+    gem 'tinymce-rails'
 
 Be sure to add to the global group, not the `assets` group. Then run `bundle install`.
 
 
 **2. Create a `config/tinymce.yml` file with your global configuration options:**
 
-```yml
-theme_advanced_toolbar_location: top
-theme_advanced_toolbar_align: left
-theme_advanced_statusbar_location: bottom
-theme_advanced_buttons3_add:
-  - tablecontrols
-  - fullscreen
-plugins:
-  - table
-  - fullscreen
-```
-
+    toolbar1: styleselect | bold italic | link image | undo redo
+    toolbar2: table | fullscreen
+    plugins:
+      - table
+      - fullscreen
+      
 The Rails server no longer needs to be restarted when this file is updated in development mode.
 
 To define multiple configuration sets, follow this syntax (a default configuration must be specified):
 
-```yml
-default:
-  theme_advanced_toolbar_align: left
-  theme_advanced_buttons3_add:
-    - tablecontrols
-  plugins:
-    - table
-
-alternate:
-  theme_advanced_toolbar_location: top
-  theme_advanced_toolbar_align: left
-  theme_advanced_buttons3_add:
-    - tablecontrols
-  plugins:
-    - table
-```
+    default:
+      plugins:
+        - image
+        - link
+    
+    alternate:
+      selector: textarea.table-editor
+      toolbar: styleselect | bold italic | link image | undo redo | table
+      plugins:
+        - table
 
-See the [TinyMCE 3 Documentation](http://archive.tinymce.com/wiki.php/Configuration3x) for a full list of configuration options.
+See the [TinyMCE 4 Documentation](http://www.tinymce.com/wiki.php/Configuration) for a full list of configuration options.
 
 
 **3. Include the TinyMCE assets**
@@ -67,70 +52,36 @@ Use *one* of the following options to include TinyMCE assets.
 
 (1) Add to your application.js:
 
-```js
-//= require tinymce
-```
+    //= require tinymce
 
 or (2) with jQuery integration:
 
-```js
-//= require tinymce-jquery
-```
+    //= require tinymce-jquery
 
 (3) The TinyMCE assets can be included on a per-page basis using the `tinymce_assets` helper:
 
-```erb
-<%= tinymce_assets %>
-#=> <script type="text/javascript" src="/assets/tinymce.js">
-```
+    <%= tinymce_assets %>
+    #=> <script type="text/javascript" src="/assets/tinymce.js">
+
 
 **4. Initialize TinyMCE**
 
 For each textarea that you want to use with TinyMCE, add the "tinymce" class and ensure it has a unique ID:
 
-```erb
-<%= text_area_tag :content, "", :class => "tinymce", :rows => 40, :cols => 120 %>
-```
-
-or if you are using Rails' form builders:
-
-```erb
-<%= f.text_area :content, :class => "tinymce", :rows => 40, :cols => 120 %>
-```
+    <%= text_area_tag :editor, "", :class => "tinymce", :rows => 40, :cols => 120 %>
 
 Then invoke the `tinymce` helper to initialize TinyMCE:
 
-```erb
-<%= tinymce %>
-```
+    <%= tinymce %>
 
 Custom options can be passed to `tinymce` to override the global options specified in `config/tinymce.yml`:
 
-```erb
-<%= tinymce :theme => "simple", :language => "de", :plugins => ["inlinepopups", "paste"] %>
-```
+    <%= tinymce :theme => "simple", :language => "de", :plugins => ["wordcount", "paste"] %>
 
 Alternate configurations defined in 'config/tinymce.yml' can be used with:
 
-```erb
-<%= tinymce :alternate %>
-```
-
-Manual Initialization
----------------------
-
-Using the `tinymce` helper and global configuration file is entirely optional. The `tinyMCE.init` function can be invoked manually if desired.
-
-```erb
-<%= text_area_tag :editor, "", :rows => 40, :cols => 120 %>
+    <%= tinymce :alternate %>
 
-<script type="text/javascript">
-  tinyMCE.init({
-    mode: 'textareas',
-    theme: 'advanced'
-  });
-</script>
-```
 
 Language Packs
 --------------
@@ -138,40 +89,26 @@ Language Packs
 See the [tinymce-rails-langs](https://github.com/spohlenz/tinymce-rails-langs) gem for additional language packs for TinyMCE. The `tinymce` helper will use the current locale as the language if available, falling back to English if the core language files are missing.
 
 
-Asset Compilation
------------------
-
-Since TinyMCE loads most of its files dynamically, some workarounds are required to ensure that the TinyMCE asset files are accessible using non-digested filenames.
-
-As of tinymce-rails 3.5.11, 4.1.10 and 4.2.1, two alternative asset installation methods are available, which can be changed by setting `config.tinymce.install` within your `config/application.rb` file. Both methods are called when you run `rake asset:precompile` (via `Rake::Task#enhance`) after the regular application assets are compiled.
-
-The default method, `copy`, copies the TinyMCE assets directly into `public/assets` and appends the file information into the asset manifest.
-
-```ruby
-config.tinymce.install = :copy
-```
-
-The new method, `compile`, adds the TinyMCE paths to the Sprockets precompilation paths and then creates symlinks from the non-digested filenames to their digested versions.
-
-```ruby
-config.tinymce.install = :compile
-```
+Manual Initialization
+---------------------
 
-Due to compilation times, this method is only recommended using Rails 4 and up. This method is intended to eventually become the default, so please try it if it suits your environment and report any issues.
+Using the `tinymce` helper and global configuration file is entirely optional. The `tinyMCE.init` function can be invoked manually if desired.
 
-If you are including TinyMCE via `application.js` or using the `tinymce_assets` helper, you do not need to manually alter the precompile paths. However if you wish to include `tinymce-jquery.js` independently (i.e. using `javascript_include_tag`), you will need to add it to the precompile list in `config/environments/production.rb`:
+    <%= text_area_tag :editor, "", :rows => 40, :cols => 120 %>
 
-```ruby
-config.assets.precompile << "tinymce-jquery.js"
-```
+    <script type="text/javascript">
+      tinyMCE.init({
+        selector: 'textarea.editor'
+      });
+    </script>
 
 
 Custom Plugins & Skins
 ----------------------
 
-To use custom plugins or skins, simply add the files to your asset load path so that they are locatable at a path beneath `tinymce/plugins/` or `tinymce/themes/advanced/skins/`.
+To use custom plugins or skins, simply add the files to your asset load path so that they are locatable at a path beneath `tinymce/plugins/` or `tinymce/skins/`.
 
-For example, a plugin called `mycustomplugin` could have its main JS file at `app/assets/javascripts/tinymce/plugins/mycustomplugin/editor_plugin.js`.
+For example, a plugin called `mycustomplugin` could have its main JS file at `app/assets/javascripts/tinymce/plugins/mycustomplugin/plugin.js`.
 
 You should also ensure that your custom paths are added to the asset precompile paths.
 

data/Rakefile

@@ -13,7 +13,7 @@ def download(url, filename)
 end
 
 desc "Update TinyMCE to version #{TinyMCE::Rails::TINYMCE_VERSION}"
-task :update => [ :fetch, :extract, :process ]
+task :update => [ :fetch, :extract, :rename ]
 
 task :fetch do
   download("http://download.moxiecode.com/tinymce/tinymce_#{TinyMCE::Rails::TINYMCE_VERSION}.zip", "tinymce.zip")
@@ -26,26 +26,21 @@ task :extract do
     `unzip -u tmp/tinymce.zip -d tmp`
     `rm -rf vendor/assets/javascripts/tinymce`
     `mkdir -p vendor/assets/javascripts/tinymce`
-    `mv tmp/tinymce/jscripts/tiny_mce/* vendor/assets/javascripts/tinymce/`
+    `mv tmp/tinymce/js/tinymce/* vendor/assets/javascripts/tinymce/`
   end
   
   step "Extracting jQuery files" do
-    `rm -rf tmp/tinymce`
-    `unzip -u tmp/tinymce.jquery.zip -d tmp`
-    `mv tmp/tinymce/jscripts/tiny_mce/jquery.tinymce.js vendor/assets/javascripts/tinymce/jquery.tinymce.js`
-    `mv tmp/tinymce/jscripts/tiny_mce/tiny_mce.js vendor/assets/javascripts/tinymce/tiny_mce_jquery.js`
-    `mv tmp/tinymce/jscripts/tiny_mce/tiny_mce_src.js vendor/assets/javascripts/tinymce/tiny_mce_jquery_src.js`
+   `rm -rf tmp/tinymce`
+   `unzip -u tmp/tinymce.jquery.zip -d tmp`
+   `mv tmp/tinymce/js/tinymce/jquery.tinymce.min.js vendor/assets/javascripts/tinymce/jquery.tinymce.js`
+   `mv tmp/tinymce/js/tinymce/tinymce.min.js vendor/assets/javascripts/tinymce/tinymce_jquery.js`
   end
 end
 
-task :process do
-  step "Fixing file encoding" do
-    require 'iconv'
-    converter = Iconv.new('UTF-8', 'ISO-8859-1')
-    Dir["vendor/assets/javascripts/tinymce/**/*.js"].each do |file|
-      contents = converter.iconv(File.read(file))
-      contents = contents.force_encoding('UTF-8') if contents.respond_to?(:force_encoding)
-      File.open(file, 'w') { |f| f.write(contents) }
+task :rename do
+  step "Renaming files" do
+    Dir["vendor/assets/javascripts/tinymce/**/*.min.js"].each do |file|
+      FileUtils.mv(file, file.sub(/\.min\.js$/, '.js'))
     end
   end
 end

data/app/assets/javascripts/tinymce-jquery.js

@@ -1,3 +1,3 @@
 //= require tinymce/preinit.js
-//= require tinymce/tiny_mce_jquery_src.js
+//= require tinymce/tinymce_jquery.js
 //= require tinymce/jquery.tinymce.js

data/app/assets/javascripts/tinymce.js

@@ -1,2 +1,2 @@
 //= require tinymce/preinit.js
-//= require tinymce/tiny_mce_src.js
+//= require tinymce/tinymce.js

data/app/assets/javascripts/tinymce/preinit.js.erb

@@ -1,5 +1,4 @@
-window.tinyMCEPreInit = window.tinyMCEPreInit || {
+window.tinymce = window.tinymce || {
   base:   '<%= TinyMCE::Rails::Engine.base %>',
-  query:  '<%= TinyMCE::Rails::VERSION %>',
   suffix: ''
 };

data/lib/tasks/tinymce-assets.rake

@@ -2,15 +2,12 @@ assets_task = Rake::Task.task_defined?('assets:precompile:primary') ? 'assets:pr
 
 Rake::Task[assets_task].enhance do
   require "tinymce/rails/asset_installer"
-
-  assets = Pathname.new(File.expand_path(File.dirname(__FILE__) + "/../../vendor/assets/javascripts/tinymce"))
   
+  assets = Pathname.new(File.expand_path(File.dirname(__FILE__) + "/../../vendor/assets/javascripts/tinymce"))
+
   config   = Rails.application.config
   target   = File.join(Rails.public_path, config.assets.prefix)
   manifest = config.assets.manifest
   
-  installer = TinyMCE::Rails::AssetInstaller.new(assets, target, manifest)
-  installer.log_level = Logger::INFO
-  installer.strategy = config.tinymce.install
-  installer.install
+  TinyMCE::Rails::AssetInstaller.new(assets, target, manifest).install
 end

data/lib/tinymce/rails.rb

@@ -7,7 +7,7 @@ module TinyMCE
     require "tinymce/rails/helper"
 
     def self.configuration
-      @configuration ||= ConfigurationFile.new(Engine.config_path)
+      @configuration ||= ConfigurationFile.new(::Rails.root.join("config/tinymce.yml"))
       @configuration.respond_to?(:configuration) ? @configuration.configuration : @configuration
     end
 

data/lib/tinymce/rails/asset_installer.rb

@@ -1,62 +1,64 @@
 require "tinymce/rails/asset_manifest"
 
-require "tinymce/rails/asset_installer/copy"
-require "tinymce/rails/asset_installer/compile"
-
 module TinyMCE
   module Rails
     class AssetInstaller
-      attr_reader :assets, :target, :strategy
-      attr_accessor :logger
-      
       def initialize(assets, target, manifest_path)
         @assets = assets
         @target = target
         @manifest_path = manifest_path || target
-        
-        @logger       = Logger.new($stderr)
-        @logger.level = Logger::INFO
       end
       
       def install
-        (strategy || Copy).new(self).call
+        cleanup_assets
+        copy_assets
+        append_to_manifest
+        
+        manifest.write
       end
-      
-      def log_level
-        @logger.level
+    
+    private
+      def manifest
+        @manifest ||= AssetManifest.load(@manifest_path)
       end
-
-      def log_level=(level)
-        if level.is_a?(Integer)
-          @logger.level = level
-        else
-          @logger.level = Logger.const_get(level.to_s.upcase)
+      
+      def cleanup_assets
+        manifest.each(/^tinymce\//) do |asset|
+          manifest.remove(asset) if index_asset?(asset)
+          
+          manifest.remove_digest(asset) do |src, dest|
+            move_asset(src, dest)
+          end
         end
       end
       
-      def strategy=(strategy)
-        if strategy.is_a?(Class)
-          @strategy = strategy
-        else
-          @strategy = self.class.const_get(strategy.to_s.titlecase)
+      def copy_assets
+        FileUtils.cp_r(@assets, @target, :preserve => true)
+      end
+      
+      def append_to_manifest
+        asset_files.each do |file|
+          manifest.append(logical_path(file), file)
         end
       end
       
-      def manifest
-        @manifest ||= AssetManifest.load(@manifest_path)
+      def asset_files
+        Pathname.glob("#{@assets}/**/*").select(&:file?)
       end
-    
+      
       def logical_path(file)
         file.relative_path_from(@assets.parent).to_s
       end
       
-      def with_asset(src, dest)
-        if src != dest
-          src = File.join(@target, src)
-          dest = File.join(@target, dest)
-          
-          yield src, dest if File.exists?(src)
-        end
+      def move_asset(src, dest)
+        src = File.join(@target, src)
+        dest = File.join(@target, dest)
+        
+        FileUtils.mv(src, dest, :force => true) if src != dest && File.exists?(src)
+      end
+      
+      def index_asset?(asset)
+        asset =~ /\/index\.js$/
       end
     end
   end

data/lib/tinymce/rails/asset_manifest.rb

@@ -1,141 +1,122 @@
+require "multi_json"
+
 module TinyMCE
   module Rails
     class AssetManifest
-      attr_reader :file
-
       def self.load(manifest_path)
-        JsonManifest.try(manifest_path, ".sprockets-manifest*.json") ||
-          JsonManifest.try(manifest_path, "manifest*.json") ||
-          YamlManifest.try(manifest_path) ||
+        YamlManifest.try(manifest_path) ||
+          JsonManifest.try(manifest_path) ||
           NullManifest.new
       end
-      
-      def each(pattern)
-        assets.each_key do |asset|
-          if asset =~ pattern && !index_asset?(asset)
-            yield asset
-          end
-        end
-      end
-      
-      def asset_path(logical_path)
-        if digested = assets[logical_path]
-          yield digested, logical_path if block_given?
-        end
-      end
-      
-      def to_s
-        dump
-      end
-    
-    protected
-      def index_asset?(asset)
-        asset =~ /\/index[^\/]*\.\w+$/
-      end
     end
+  end
   
-    class YamlManifest < AssetManifest
-      def self.try(manifest_path)
-        yaml_file = File.join(manifest_path, "manifest.yml")
-        new(yaml_file) if File.exists?(yaml_file)
-      end
+  class YamlManifest
+    def self.try(manifest_path)
+      yaml_file = File.join(manifest_path, "manifest.yml")
+      new(yaml_file) if File.exists?(yaml_file)
+    end
     
-      def initialize(file)
-        @file = file
-        @manifest = YAML.load_file(file)
-      end
+    def initialize(file)
+      @file = file
+      @manifest = YAML.load_file(file)
+    end
     
-      def append(logical_path, file)
-        assets[logical_path] = logical_path
-      end
+    def append(logical_path, file)
+      @manifest[logical_path] = logical_path
+    end
     
-      def remove(logical_path)
-        assets.delete(logical_path)
-      end
+    def remove(logical_path)
+      @manifest.delete(logical_path)
+    end
     
-      def remove_digest(logical_path)
-        asset_path(logical_path) do |digested, logical_path|
-          assets[logical_path] = logical_path
-          
-          yield digested, logical_path if block_given?
-        end
+    def remove_digest(logical_path)
+      if digested = @manifest[logical_path]
+        @manifest[logical_path] = logical_path
+        yield digested, logical_path if block_given?
       end
+    end
     
-      def assets
-        @manifest
+    def each(pattern)
+      @manifest.each_key do |asset|
+        yield asset if asset =~ pattern
       end
+    end
     
-      def dump(io=nil)
-        YAML.dump(@manifest, io)
-      end
+    def to_s
+      dump
+    end
     
-      def write
-        File.open(@file, "wb") { |f| dump(f) }
-      end
+    def dump(io=nil)
+      YAML.dump(@manifest, io)
     end
+    
+    def write
+      File.open(@file, "wb") { |f| dump(f) }
+    end
+  end
   
-    class JsonManifest < AssetManifest
-      def self.try(manifest_path, pattern)
-        paths = Dir[File.join(manifest_path, pattern)]
-        new(paths.first) if paths.any?
-      end
+  class JsonManifest
+    def self.try(manifest_path)
+      paths = Dir[File.join(manifest_path, "manifest*.json")]
+      new(paths.first) if paths.any?
+    end
     
-      def initialize(file)
-        @file = file
-        @manifest = JSON.parse(File.read(file))
-      end
+    def initialize(file)
+      @file = file
+      @manifest = MultiJson.load(File.read(file))
+    end
     
-      def append(logical_path, file)
-        stat = File.stat(file)
+    def append(logical_path, file)
+      stat = File.stat(file)
       
-        assets[logical_path] = logical_path
-        files[logical_path] = {
-          "logical_path" => logical_path,
-          "mtime"        => stat.mtime.iso8601,
-          "size"         => stat.size,
-          "digest"       => nil
-        }
-      end
+      @manifest["assets"][logical_path] = logical_path
+      @manifest["files"][logical_path] = {
+        "logical_path" => logical_path,
+        "mtime"        => stat.mtime.iso8601,
+        "size"         => stat.size,
+        "digest"       => nil
+      }
+    end
     
-      def remove(logical_path)
-        if digested = assets.delete(logical_path)
-          files.delete(digested)
-        end
+    def remove(logical_path)
+      if digested = @manifest["assets"].delete(logical_path)
+        @manifest["files"].delete(digested)
       end
+    end
     
-      def remove_digest(logical_path)
-        asset_path(logical_path) do |digested, logical_path|
-          assets[logical_path] = logical_path
-          files[logical_path] = files.delete(digested).tap { |f| f["digest"] = nil }
-          
-          yield digested, logical_path if block_given?
-        end
-      end
-      
-      def assets
-        @manifest["assets"]
-      end
-      
-      def files
-        @manifest["files"]
+    def remove_digest(logical_path)
+      if digested = @manifest["assets"][logical_path]
+        @manifest["assets"][logical_path] = logical_path
+        @manifest["files"][logical_path] = @manifest["files"].delete(digested).tap { |f| f["digest"] = nil }
+        yield digested, logical_path if block_given?
       end
+    end
     
-      def dump
-        JSON.generate(@manifest)
+    def each(pattern)
+      @manifest["assets"].each_key do |asset|
+        yield asset if asset =~ pattern
       end
+    end
     
-      def write
-        File.open(@file, "wb") { |f| f.write(dump) }
-      end
+    def to_s
+      dump
     end
-  
-    class NullManifest < AssetManifest
-      def append(*); end
-      def remove(*); end
-      def remove_digest(*); end
-      def assets; {}; end
-      def each(*); end
-      def write; end
+    
+    def dump
+      MultiJson.dump(@manifest)
+    end
+    
+    def write
+      File.open(@file, "wb") { |f| f.write(dump) }
     end
   end
+  
+  class NullManifest
+    def append(*); end
+    def remove(*); end
+    def remove_digest(*); end
+    def each(*); end
+    def write; end
+  end
 end