hugerte-rails 1.0.9.1

data/app/assets/sprockets/hugerte/preinit.js.erb

@@ -0,0 +1,4 @@
+window.hugerte = window.hugerte || {
+  base: '<%= HugeRTE::Rails::Engine.base %>',
+  suffix: ''
+};

data/app/assets/sprockets/hugerte.js

@@ -0,0 +1,3 @@
+//= require hugerte/rails.js
+//= require hugerte/preinit.js
+//= require hugerte/hugerte.js

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

@@ -0,0 +1,44 @@
+module HugeRTE
+  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(/^hugerte\//) 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.exist?("#{src}.gz")
+          end
+        end
+
+        def create_symlink(src, dest)
+          target = File.basename(src)
+
+          unless File.exist?(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/hugerte/rails/asset_installer/copy.rb

@@ -0,0 +1,54 @@
+module HugeRTE
+  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(/^hugerte\//) 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, "hugerte")}"
+          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/hugerte/rails/asset_installer/copy_no_preserve.rb

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

data/lib/hugerte/rails/asset_installer.rb

@@ -0,0 +1,64 @@
+require_relative "asset_manifest"
+
+require_relative "asset_installer/copy"
+require_relative "asset_installer/copy_no_preserve"
+require_relative "asset_installer/compile"
+
+module HugeRTE
+  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.exist?(src)
+        end
+      end
+    end
+  end
+end

data/lib/hugerte/rails/asset_manifest/json_manifest.rb

@@ -0,0 +1,62 @@
+module HugeRTE
+  module Rails
+    class JsonManifest < AssetManifest
+      def self.try(manifest_path, pattern=nil)
+        if pattern
+          paths = Dir[File.join(manifest_path, pattern)]
+          new(paths.first) if paths.any?
+        elsif File.file?(manifest_path)
+          new(manifest_path)
+        end
+      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
+  end
+end

data/lib/hugerte/rails/asset_manifest/null_manifest.rb

@@ -0,0 +1,12 @@
+module HugeRTE
+  module Rails
+    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/hugerte/rails/asset_manifest/propshaft_manifest.rb

@@ -0,0 +1,43 @@
+module HugeRTE
+  module Rails
+    class PropshaftManifest < AssetManifest
+      def self.try(manifest_path)
+        json_file = File.join(manifest_path, ".manifest.json")
+        new(json_file) if File.exist?(json_file)
+      end
+
+      def initialize(file)
+        @file = file
+        @manifest = JSON.parse(File.read(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
+        JSON.generate(@manifest)
+      end
+
+      def write
+        File.open(@file, "wb") { |f| f.write(dump) }
+      end
+    end
+  end
+end

data/lib/hugerte/rails/asset_manifest/yaml_manifest.rb

@@ -0,0 +1,43 @@
+module HugeRTE
+  module Rails
+    class YamlManifest < AssetManifest
+      def self.try(manifest_path)
+        yaml_file = File.join(manifest_path, "manifest.yml")
+        new(yaml_file) if File.exist?(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
+  end
+end

data/lib/hugerte/rails/asset_manifest.rb

@@ -0,0 +1,44 @@
+module HugeRTE
+  module Rails
+    class AssetManifest
+      attr_reader :file
+
+      def self.load(manifest_path)
+        PropshaftManifest.try(manifest_path) ||
+          JsonManifest.try(manifest_path, ".sprockets-manifest*.json") ||
+          JsonManifest.try(manifest_path, "manifest*.json") ||
+          JsonManifest.try(manifest_path) ||
+          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
+
+    require_relative "asset_manifest/json_manifest"
+    require_relative "asset_manifest/null_manifest"
+    require_relative "asset_manifest/propshaft_manifest"
+    require_relative "asset_manifest/yaml_manifest"
+  end
+end

data/lib/hugerte/rails/configuration.rb

@@ -0,0 +1,162 @@
+require "active_support/hash_with_indifferent_access"
+
+module HugeRTE::Rails
+  class Configuration
+    class Function < String
+      def to_javascript
+        self
+      end
+    end
+
+    def self.defaults
+      {
+        "selector"     => "textarea.hugerte",
+        "cache_suffix" => "?v=#{VERSION}"
+      }
+    end
+
+    FUNCTION_REGEX = /^function\s*\(([\w\d\s_,]*)\)\s*\{([^}]*)\}|\(([\w\d\s_,]*)\)\s*=>\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([]), {}, nil)
+        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 hugerte.init
+    def to_javascript
+      options_to_javascript(options_for_hugerte)
+    end
+
+    # Converts options into a HugeRTE-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_hugerte
+      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 valid_property_name?(key)
+      key =~ /^(?![0-9])[a-zA-Z0-9$_]+$/
+    end
+
+    def preprocess_options(options)
+      result = {}
+
+      options.each do |key, value|
+        key = "'#{key}'" unless valid_property_name?(key)
+        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

data/lib/hugerte/rails/configuration_file.rb

@@ -0,0 +1,50 @@
+module HugeRTE::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.exist?(path) && File.mtime(path)
+    end
+
+    def load_configuration
+      @last_loaded = last_updated
+
+      return Configuration.new_with_defaults if !File.exist?(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)
+      result = ERB.new(IO.read(path)).result
+      YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(result) : YAML.load(result)
+    end
+  end
+end

data/lib/hugerte/rails/engine.rb

@@ -0,0 +1,93 @@
+module HugeRTE::Rails
+  class Engine < ::Rails::Engine
+    config.hugerte = ActiveSupport::OrderedOptions.new
+
+    # Set an explicit base path for HugeRTE assets (usually defaults to /assets/hugerte)
+    config.hugerte.base = nil
+
+    # Set default configuration file path (defaults to config/hugerte.yml within the Rails root if unset)
+    config.hugerte.config_path = nil
+
+    # Set default installation method (:compile or :copy) for HugeRTE assets
+    #   :compile - adds HugeRTE to the Sprockets load paths and creates non-digested symlinks to the digested versions
+    #   :copy    - copies across the HugeRTE assets statically
+    config.hugerte.install = :compile
+
+    # Set default attributes for script source tags (defaults to data-turbolinks-track="reload" for backwards compatibility)
+    config.hugerte.default_script_attributes = { "data-turbolinks-track" => "reload" }
+
+    initializer "precompile", :group => :all do |app|
+      if config.hugerte.install == :compile
+        app.config.assets.precompile << "hugerte-rails.manifest.js" # Sprockets 4 manifest
+        app.config.assets.precompile << "hugerte/*"                 # Sprockets 3
+      end
+
+      app.config.assets.precompile << "hugerte.js" << "hugerte-jquery.js"
+    end if defined?(Sprockets)
+
+    initializer "propshaft" do |app|
+      config.assets.excluded_paths << root.join("app/assets/sprockets")
+
+      if config.assets.server
+        # Monkey-patch Propshaft::Asset to enable access
+        # of HugeRTE assets without a hash digest.
+        require_relative "propshaft/asset"
+      end
+    end if defined?(Propshaft)
+
+    initializer "helper" do |app|
+      ActiveSupport.on_load(:action_view) do
+        include Helper
+      end
+    end
+
+    def self.base
+      config.hugerte.base || default_base
+    end
+
+    def self.default_base
+      File.join(asset_host || "", relative_url_root || "",
+                Rails.application.config.assets.prefix || "/",
+                "hugerte")
+    end
+
+    def self.relative_url_root
+      config = Rails.application.config
+
+      if config.respond_to?(:relative_url_root)
+        config.relative_url_root
+      else
+        # Fallback for Rails 3.1
+        config.action_controller.relative_url_root
+      end
+    end
+
+    def self.asset_host
+      host = Rails.application.config.action_controller.asset_host
+
+      if host.respond_to?(:call)
+        # Callable asset hosts cannot be supported during
+        # precompilation as there is no request object
+        nil
+      elsif host =~ /%d/
+        # Load all HugeRTE assets from the first asset host
+        normalize_host(host % 0)
+      else
+        normalize_host(host)
+      end
+    end
+
+    def self.normalize_host(host)
+      if host =~ /^https?:\/\// || host =~ /^\/\//
+        host
+      else
+        # Use a protocol-relative URL if not otherwise specified
+        "//#{host}"
+      end
+    end
+
+    def self.config_path
+      Rails.application.config.hugerte.config_path || ::Rails.root.join("config/hugerte.yml")
+    end
+  end
+end