tinymce-rails 4.5.6 → 4.9.11

data/lib/tinymce/rails/asset_installer/compile.rb

@@ -3,15 +3,15 @@ module TinyMCE
     class AssetInstaller
       class Compile
         delegate :target, :manifest, :logger, :logical_path, :with_asset, :to => :@installer
-        
+
         def initialize(installer)
           @installer = installer
         end
-        
+
         def call
           symlink_assets
         end
-      
+
       private
         def symlink_assets
           manifest.each(/^tinymce\//) do |asset|
@@ -20,17 +20,17 @@ module TinyMCE
             end
           end
         end
-        
+
         def symlink_asset(src, dest)
           with_asset(src, dest) do |src, dest|
             create_symlink(src, dest)
             create_symlink("#{src}.gz", "#{dest}.gz") if File.exists?("#{src}.gz")
           end
         end
-        
+
         def create_symlink(src, dest)
           target = File.basename(src)
-        
+
           unless File.exists?(dest) && File.symlink?(dest) && File.readlink(dest) == target
             logger.info "Creating symlink #{dest}"
             FileUtils.ln_s(target, dest, :force => true)

data/lib/tinymce/rails/asset_installer/copy.rb

@@ -3,19 +3,19 @@ module TinyMCE
     class AssetInstaller
       class Copy
         delegate :assets, :target, :manifest, :logger, :logical_path, :with_asset, :to => :@installer
-        
+
         def initialize(installer)
           @installer = installer
         end
-        
+
         def call
           cleanup_assets
           copy_assets
           append_to_manifest
-        
+
           manifest.write
         end
-      
+
       private
         def cleanup_assets
           manifest.each(/^tinymce\//) do |asset|
@@ -24,25 +24,27 @@ module TinyMCE
             end
           end
         end
-        
+
         def copy_assets
-          logger.info "Copying assets to #{File.join(target, "tinymce")}"
+          logger.info "Copying assets (preserving modes) to #{File.join(target, "tinymce")}"
           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 move_asset(src, dest)
           with_asset(src, dest) do |src, dest|
             logger.info "Removing digest from #{src}"
+
+            FileUtils.rm(dest) if File.exist?(dest)
             FileUtils.mv(src, dest, :force => true)
           end
         end
-      
+
         def asset_files
           Pathname.glob("#{assets}/**/*").select(&:file?)
         end

data/lib/tinymce/rails/asset_installer/copy_no_preserve.rb

@@ -0,0 +1,14 @@
+require "tinymce/rails/asset_installer/copy"
+
+module TinyMCE
+  module Rails
+    class AssetInstaller
+      class CopyNoPreserve < Copy
+        def copy_assets
+          logger.info "Copying assets (without preserving modes) to #{File.join(target, "tinymce")}"
+          FileUtils.cp_r(assets, target)
+        end
+      end
+    end
+  end
+end

data/lib/tinymce/rails/asset_installer.rb

@@ -1,6 +1,7 @@
 require "tinymce/rails/asset_manifest"
 
 require "tinymce/rails/asset_installer/copy"
+require "tinymce/rails/asset_installer/copy_no_preserve"
 require "tinymce/rails/asset_installer/compile"
 
 module TinyMCE
@@ -8,20 +9,20 @@ module TinyMCE
     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
       end
-      
+
       def log_level
         @logger.level
       end
@@ -33,28 +34,28 @@ module TinyMCE
           @logger.level = Logger.const_get(level.to_s.upcase)
         end
       end
-      
+
       def strategy=(strategy)
         if strategy.is_a?(Class)
           @strategy = strategy
         else
-          @strategy = self.class.const_get(strategy.to_s.titlecase)
+          @strategy = self.class.const_get(strategy.to_s.classify)
         end
       end
-      
+
       def manifest
         @manifest ||= AssetManifest.load(@manifest_path)
       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
       end

data/lib/tinymce/rails/asset_manifest.rb

@@ -9,7 +9,7 @@ module TinyMCE
           YamlManifest.try(manifest_path) ||
           NullManifest.new
       end
-      
+
       def each(pattern)
         assets.each_key do |asset|
           if asset =~ pattern && !index_asset?(asset)
@@ -17,77 +17,77 @@ module TinyMCE
           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
-  
+
     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
-    
+
       def initialize(file)
         @file = file
         @manifest = YAML.load_file(file)
       end
-    
+
       def append(logical_path, file)
         assets[logical_path] = logical_path
       end
-    
+
       def remove(logical_path)
         assets.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
       end
-    
+
       def assets
         @manifest
       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
-    
+
       def initialize(file)
         @file = file
         @manifest = JSON.parse(File.read(file))
       end
-    
+
       def append(logical_path, file)
         stat = File.stat(file)
-      
+
         assets[logical_path] = logical_path
         files[logical_path] = {
           "logical_path" => logical_path,
@@ -96,39 +96,39 @@ module TinyMCE
           "digest"       => nil
         }
       end
-    
+
       def remove(logical_path)
         if digested = assets.delete(logical_path)
           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"]
       end
-    
+
       def dump
         JSON.generate(@manifest)
       end
-    
+
       def write
         File.open(@file, "wb") { |f| f.write(dump) }
       end
     end
-  
+
     class NullManifest < AssetManifest
       def append(*); end
       def remove(*); end

data/lib/tinymce/rails/configuration.rb

@@ -7,17 +7,20 @@ module TinyMCE::Rails
         self
       end
     end
-    
+
     def self.defaults
       {
         "selector" => "textarea.tinymce"
       }
     end
-    
+
+    FUNCTION_REGEX = /^function\s*\(/
+    RELATIVE_PATH_REGEX = /^(\/|\.{1,2})\S*/
+
     COMMA = ",".freeze
     SPACE = " ".freeze
     SEMICOLON = ";".freeze
-    
+
     OPTION_SEPARATORS = {
       "plugins"                       => COMMA,
       "custom_elements"               => COMMA,
@@ -39,60 +42,114 @@ module TinyMCE::Rails
       "paste_retain_style_properties" => SPACE,
       "spellchecker_languages"        => COMMA
     }
-    
+
+    OPTION_TRANSFORMERS = {
+      # Check for files provided in the content_css option to replace them with their actual path.
+      # If no corresponding stylesheet is found for a file, it will remain unchanged.
+      "content_css" => ->(value) {
+        helpers = ActionView::Base.new(ActionView::LookupContext.new([]))
+        separator = OPTION_SEPARATORS["content_css"]
+
+        value.split(separator).map { |file|
+          next file if RELATIVE_PATH_REGEX =~ file
+          helpers.stylesheet_path(file.strip) || file
+        }.join(separator)
+      }
+    }
+
     attr_reader :options
-    
+
     def initialize(options)
       @options = options
     end
-    
+
     def self.new_with_defaults(options={})
       config = new(defaults)
       config = config.merge(options) if options
       config
     end
-    
+
+    # Converts options into a String representing a JavaScript object
+    # that can be passed directly to tinyMCE.init
+    def to_javascript
+      options_to_javascript(options_for_tinymce)
+    end
+
+    # Converts options into a TinyMCE-friendly format.
+    #
+    #  1. Joins array values using OPTION_SEPARATORS
+    #  2. Converts JavaScript function() strings to Function objects
+    #  3. Applies transformations from OPTION_TRANSFORMERS
     def options_for_tinymce
+      preprocess_options(options)
+    end
+
+    def merge(options)
+      self.class.new(self.options.merge(options))
+    end
+
+  private
+    def array_option?(key, value)
+      value.is_a?(Array) && OPTION_SEPARATORS[key]
+    end
+
+    def function_option?(value)
+      FUNCTION_REGEX =~ value.to_s
+    end
+
+    def preprocess_options(options)
       result = {}
-      
+
       options.each do |key, value|
-        if OPTION_SEPARATORS[key] && value.is_a?(Array)
-          result[key] = value.join(OPTION_SEPARATORS[key])
-        elsif value.to_s.starts_with?("function(")
-          result[key] = Function.new(value)
-        else
-          result[key] = value
-        end
+        result[key] = preprocess_option(key, value)
       end
-      
+
       result
     end
-    
-    def to_javascript
-      pairs = options_for_tinymce.inject([]) do |result, (k, v)|
-        if v.respond_to?(:to_javascript)
+
+    def preprocess_option(key, value)
+      result = value
+
+      if result.is_a?(Hash)
+        result = preprocess_options(value)
+      elsif array_option?(key, value)
+        result = value.join(OPTION_SEPARATORS[key])
+      elsif function_option?(value)
+        result = Function.new(value)
+      end
+
+      if transformer = OPTION_TRANSFORMERS[key]
+        result = transformer.call(result)
+      end
+
+      result
+    end
+
+    def options_to_javascript(options, indent="")
+      next_indent = indent + "  "
+
+      pairs = options.inject([]) do |result, (k, v)|
+        if v.is_a?(Hash)
+          v = options_to_javascript(v, next_indent)
+        elsif v.respond_to?(:to_javascript)
           v = v.to_javascript
         elsif v.respond_to?(:to_json)
           v = v.to_json
         end
-        
+
         result << [k, v].join(": ")
       end
-      
-      "{\n  #{pairs.join(",\n  ")}\n}"
-    end
-    
-    def merge(options)
-      self.class.new(self.options.merge(options))
+
+      "{\n#{next_indent}#{pairs.join(",\n#{next_indent}")}\n#{indent}}"
     end
   end
-  
+
   class MultipleConfiguration < ActiveSupport::HashWithIndifferentAccess
     def initialize(configurations={})
       configurations = configurations.each_with_object({}) { |(name, options), h|
         h[name] = Configuration.new_with_defaults(options)
       }
-      
+
       super(configurations)
     end
   end

data/lib/tinymce/rails/configuration_file.rb

@@ -1,47 +1,47 @@
 module TinyMCE::Rails
   class ConfigurationFile
     attr_reader :path
-    
+
     def initialize(path)
       @path = path
     end
-    
+
     def configuration
       @configuration = load_configuration if reload?
       @configuration
     end
-    
+
     def reload?
       @configuration.nil? || (reloadable? && changed?)
     end
-    
+
     def changed?
       @last_loaded != last_updated
     end
-    
+
   private
     def reloadable?
       !::Rails.application.config.cache_classes
     end
-    
+
     def last_updated
       File.exists?(path) && File.mtime(path)
     end
-    
+
     def load_configuration
       @last_loaded = last_updated
-      
+
       return Configuration.new_with_defaults if !File.exists?(path)
-      
+
       options = load_yaml(path)
-      
+
       if options && options.has_key?('default')
         MultipleConfiguration.new(options)
       else
         Configuration.new_with_defaults(options)
       end
     end
-    
+
     def load_yaml(path)
       YAML::load(ERB.new(IO.read(path)).result)
     end

data/lib/tinymce/rails/engine.rb

@@ -14,7 +14,11 @@ module TinyMCE::Rails
     config.tinymce.install = :compile
 
     initializer "precompile", :group => :all do |app|
-      app.config.assets.precompile << "tinymce/*" if config.tinymce.install == :compile
+      if config.tinymce.install == :compile
+        app.config.assets.precompile << "tinymce-rails.manifest.js" # Sprockets 4 manifest
+        app.config.assets.precompile << "tinymce/*"                 # Sprockets 3
+      end
+
       app.config.assets.precompile << "tinymce.js"
     end
 

data/lib/tinymce/rails/helper.rb

@@ -14,26 +14,37 @@ module TinyMCE::Rails
     # override these defaults.
     #
     # @example
-    #   <%= tinymce(:theme => "advanced", :editor_selector => "editorClass") %>
+    #   <%= tinymce(selector: "editorClass", theme: "inlite") %>
     def tinymce(config=:default, options={})
-      javascript_tag { tinymce_javascript(config, options) }
+      javascript_tag(nonce: true) do
+        unless @_tinymce_configurations_added
+          concat tinymce_configurations_javascript
+          concat "\n"
+          @_tinymce_configurations_added = true
+        end
+
+        concat tinymce_javascript(config, options)
+      end
     end
 
     # Returns the JavaScript code required to initialize TinyMCE.
     def tinymce_javascript(config=:default, options={})
-      <<-JAVASCRIPT.strip_heredoc.html_safe
-      (function() {
-        function initTinyMCE() {
-          if (typeof tinyMCE != 'undefined') {
-            tinyMCE.init(#{tinymce_configuration(config, options).to_javascript.gsub(/^/, ' ' * 12).sub(/\A\s+/, "")});
-          } else {
-            setTimeout(initTinyMCE, 50);
-          }
-        }
-
-        initTinyMCE();
-      })();
-      JAVASCRIPT
+      options, config = config, :default if config.is_a?(Hash)
+      options = Configuration.new(options)
+
+      "TinyMCERails.initialize('#{config}', #{options.to_javascript});".html_safe
+    end
+
+    # Returns the JavaScript code for initializing each configuration defined within tinymce.yml.
+    def tinymce_configurations_javascript(options={})
+      javascript = []
+
+      TinyMCE::Rails.each_configuration do |name, config|
+        config = config.merge(options) if options.present?
+        javascript << "TinyMCERails.configuration.#{name} = #{config.to_javascript};".html_safe
+      end
+
+      safe_join(javascript, "\n")
     end
 
     # Returns the TinyMCE configuration object.
@@ -53,11 +64,12 @@ module TinyMCE::Rails
 
     # Includes TinyMCE javascript assets via a script tag.
     def tinymce_assets
-      javascript_include_tag "tinymce"
+      javascript_include_tag "tinymce", "data-turbolinks-track" => "reload"
     end
 
     # Allow methods to be called as module functions:
     #  e.g. TinyMCE::Rails.tinymce_javascript
-    module_function :tinymce, :tinymce_javascript, :tinymce_configuration
+    module_function :tinymce, :tinymce_javascript, :tinymce_configurations_javascript, :tinymce_configuration
+    public :tinymce, :tinymce_javascript, :tinymce_configurations_javascript, :tinymce_configuration
   end
 end

data/lib/tinymce/rails/version.rb

@@ -1,6 +1,6 @@
 module TinyMCE
   module Rails
-    VERSION = "4.5.6"
-    TINYMCE_VERSION = "4.5.6"
+    VERSION = "4.9.11"
+    TINYMCE_VERSION = "4.9.11"
   end
 end

data/lib/tinymce/rails.rb

@@ -15,5 +15,13 @@ module TinyMCE
     def self.configuration=(configuration)
       @configuration = configuration
     end
+
+    def self.each_configuration(&block)
+      if configuration.is_a?(MultipleConfiguration)
+        configuration.each(&block)
+      else
+        yield :default, configuration
+      end
+    end
   end
 end

data/vendor/assets/config/tinymce-rails.manifest.js

@@ -0,0 +1,8 @@
+//= link_tree ../javascripts/tinymce .js
+//= link_tree ../javascripts/tinymce .css
+//= link_tree ../javascripts/tinymce .png
+//= link_tree ../javascripts/tinymce .gif
+//= link_tree ../javascripts/tinymce .ttf
+//= link_tree ../javascripts/tinymce .svg
+//= link_tree ../javascripts/tinymce .woff
+//= link_tree ../javascripts/tinymce .eot