tinymce-rails-webmely 5.1.4

data/lib/tasks/tinymce-assets.rake

@@ -0,0 +1,16 @@
+assets_task = Rake::Task.task_defined?('assets:precompile:primary') ? 'assets:precompile:primary' : 'assets:precompile'
+
+Rake::Task[assets_task].enhance do
+  require "tinymce/rails/asset_installer"
+
+  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
+end

data/lib/tinymce-rails.rb

@@ -0,0 +1 @@
+require "tinymce/rails"

data/lib/tinymce/rails.rb

@@ -0,0 +1,27 @@
+module TinyMCE
+  module Rails
+    require 'tinymce/rails/engine'
+    require 'tinymce/rails/version'
+    require "tinymce/rails/configuration"
+    require "tinymce/rails/configuration_file"
+    require "tinymce/rails/helper"
+    require "tinymce/rails/environment" if defined?(Sprockets::Rails::Environment)
+
+    def self.configuration
+      @configuration ||= ConfigurationFile.new(Engine.config_path)
+      @configuration.respond_to?(:configuration) ? @configuration.configuration : @configuration
+    end
+
+    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/lib/tinymce/rails/asset_installer.rb

@@ -0,0 +1,64 @@
+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
+  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
+      end
+
+      def log_level
+        @logger.level
+      end
+
+      def log_level=(level)
+        if level.is_a?(Integer)
+          @logger.level = level
+        else
+          @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.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
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module TinyMCE
+  module Rails
+    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|
+            manifest.asset_path(asset) do |src, dest|
+              symlink_asset(src, dest)
+            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)
+          else
+            logger.debug "Skipping symlink #{dest}, already exists"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module TinyMCE
+  module Rails
+    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|
+            manifest.remove_digest(asset) do |src, dest|
+              move_asset(src, dest)
+            end
+          end
+        end
+
+        def copy_assets
+          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
+      end
+    end
+  end
+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_manifest.rb

@@ -0,0 +1,141 @@
+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) ||
+          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
+
+    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,
+          "mtime"        => stat.mtime.iso8601,
+          "size"         => stat.size,
+          "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
+      def remove_digest(*); end
+      def assets; {}; end
+      def each(*); end
+      def write; end
+    end
+  end
+end

data/lib/tinymce/rails/configuration.rb

@@ -0,0 +1,157 @@
+require "active_support/hash_with_indifferent_access"
+
+module TinyMCE::Rails
+  class Configuration
+    class Function < String
+      def to_javascript
+        self
+      end
+    end
+
+    def self.defaults
+      {
+        "selector"     => "textarea.tinymce",
+        "cache_suffix" => "?v=#{VERSION}"
+      }
+    end
+
+    FUNCTION_REGEX = /^function\s*\(/
+    RELATIVE_PATH_REGEX = /^(\/|\.{1,2})\S*/
+
+    COMMA = ",".freeze
+    SPACE = " ".freeze
+    SEMICOLON = ";".freeze
+
+    OPTION_SEPARATORS = {
+      "plugins"                       => COMMA,
+      "custom_elements"               => COMMA,
+      "entities"                      => COMMA,
+      "extended_valid_elements"       => COMMA,
+      "font_formats"                  => SEMICOLON,
+      "fontsize_formats"              => COMMA,
+      "invalid_elements"              => COMMA,
+      "block_formats"                 => SEMICOLON,
+      "valid_children"                => COMMA,
+      "valid_elements"                => COMMA,
+      "body_id"                       => COMMA,
+      "body_class"                    => COMMA,
+      "content_css"                   => COMMA,
+      "tabfocus_elements"             => COMMA,
+      "table_clone_elements"          => SPACE,
+      "paste_word_valid_elements"     => COMMA,
+      "paste_webkit_styles"           => SPACE,
+      "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|
+        result[key] = preprocess_option(key, value)
+      end
+
+      result
+    end
+
+    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#{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
+end