danabr75-ckeditor 4.1.6

data/lib/ckeditor/http.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+require 'digest/sha1'
+
+module Ckeditor
+  module Http
+    # Create tempfile from hash
+    class UploadedFile
+      attr_accessor :original_filename, :content_type, :tempfile, :headers
+
+      def initialize(hash)
+        @original_filename = hash[:filename]
+        @content_type      = hash[:type]
+        @headers           = hash[:head]
+        @tempfile          = hash[:tempfile]
+        raise(ArgumentError, ':tempfile is required') unless @tempfile
+      end
+
+      def open
+        @tempfile.open
+      end
+
+      def path
+        @tempfile.path
+      end
+
+      def read(*args)
+        @tempfile.read(*args)
+      end
+
+      def rewind
+        @tempfile.rewind
+      end
+
+      def size
+        @tempfile.size
+      end
+    end
+
+    # Usage (paperclip example)
+    # @asset.data = QqFile.new(params[:qqfile], request)
+    class QqFile < ::Tempfile
+
+      def initialize(filename, request, tmpdir = Dir::tmpdir)
+        @original_filename  = filename
+        @request = request
+
+        super Digest::SHA1.hexdigest(filename), tmpdir
+        binmode
+        fetch
+      end
+
+      def fetch
+        self.write(body)
+        self.rewind
+        self
+      end
+
+      def original_filename
+        @original_filename
+      end
+
+      def content_type
+        @request.content_type
+      end
+
+      def body
+        if @request.raw_post.respond_to?(:force_encoding)
+          @request.raw_post.force_encoding("UTF-8")
+        else
+          @request.raw_post
+        end
+      end
+    end
+
+    # Convert nested Hash to HashWithIndifferentAccess and replace
+    # file upload hash with UploadedFile objects
+    def self.normalize_param(*args)
+      value = args.first
+      if Hash === value && value.has_key?(:tempfile)
+        UploadedFile.new(value)
+      elsif value.is_a?(String)
+        QqFile.new(*args)
+      else
+        value
+      end
+    end
+  end
+end

data/lib/ckeditor/orm/active_record.rb

@@ -0,0 +1,24 @@
+require 'ckeditor/orm/base'
+
+module Ckeditor
+  module Orm
+    module ActiveRecord
+      module AssetBase
+        def self.included(base)
+          base.send(:include, Base::AssetBase::InstanceMethods)
+          base.send(:extend, ClassMethods)
+        end
+
+        module ClassMethods
+          def self.extended(base)
+            base.class_eval do
+              self.table_name = "ckeditor_assets"
+
+              belongs_to :assetable, :polymorphic => true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ckeditor/orm/base.rb

@@ -0,0 +1,50 @@
+module Ckeditor
+  module Orm
+    module Base
+      module AssetBase
+        module InstanceMethods
+          def filename
+            data_file_name
+          end
+
+          def size
+            data_file_size
+          end
+
+          def has_dimensions?
+            respond_to?(:width) && respond_to?(:height)
+          end
+
+          def image?
+            Ckeditor::IMAGE_TYPES.include?(data_content_type)
+          end
+
+          def format_created_at
+            self.created_at.strftime("%d.%m.%Y")
+          end
+
+          def url_content
+            url
+          end
+
+          def url_thumb
+            url(:thumb)
+          end
+
+          def as_json_methods
+            [:url_content, :url_thumb, :size, :filename, :format_created_at]
+          end
+
+          def as_json(options = nil)
+            options = {
+              :methods => as_json_methods,
+              :root => "asset"
+            }.merge(options || {})
+
+            super options
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ckeditor/orm/mongoid.rb

@@ -0,0 +1,41 @@
+require 'orm_adapter/adapters/mongoid'
+require 'ckeditor/orm/base'
+
+module Ckeditor
+  module Orm
+    module Mongoid
+      module AssetBase
+        def self.included(base)
+          base.send(:include, ::Mongoid::Document)
+          base.send(:include, ::Mongoid::Timestamps)
+          base.send(:include, Base::AssetBase::InstanceMethods)
+          base.send(:include, InstanceMethods)
+          base.send(:extend, ClassMethods)
+        end
+
+        module InstanceMethods
+          def type
+            _type
+          end
+
+          def as_json_methods
+            [:id, :type] + super
+          end
+        end
+
+        module ClassMethods
+          def self.extended(base)
+            base.class_eval do
+              field :data_content_type, :type => String
+              field :data_file_size, :type => Integer
+              field :width, :type => Integer
+              field :height, :type => Integer
+
+              belongs_to :assetable, :polymorphic => true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ckeditor/paginatable.rb

@@ -0,0 +1,56 @@
+module Ckeditor
+  # Simple paginate relation
+  class Paginatable
+    attr_reader :limit_value, :offset_value
+
+    def initialize(scope, options = {})
+      @scope = scope
+      @limit_value = (options[:limit] || Ckeditor.default_per_page).to_i
+    end
+
+    def page(num = 1)
+      @offset_value = limit_value * ([num.to_i, 1].max - 1)
+      self
+    end
+
+    def scoped
+      @scope.limit(limit_value).offset(offset_value)
+    end
+
+    # Next page number in the collection
+    def next_page
+      current_page + 1 unless last_page?
+    end
+
+    # Previous page number in the collection
+    def prev_page
+      current_page - 1 unless first_page?
+    end
+
+    # First page of the collection?
+    def first_page?
+      current_page == 1
+    end
+
+    # Last page of the collection?
+    def last_page?
+      current_page >= total_pages
+    end
+
+    # Total number of pages
+    def total_pages
+      (total_count.to_f / limit_value).ceil
+    end
+
+    # total item numbers of scope
+    def total_count
+      @total_count ||= @scope.count
+    end
+
+    # Current page number
+    def current_page
+      offset = (offset_value < 0 ? 0 : offset_value)
+      (offset / limit_value) + 1
+    end
+  end
+end

data/lib/ckeditor/text_area.rb

@@ -0,0 +1,53 @@
+require 'active_support'
+require 'action_view/helpers/tag_helper'
+require 'action_view/helpers/form_tag_helper'
+
+module Ckeditor
+  class TextArea
+    include ActionView::Helpers::TagHelper
+    include ActionView::Helpers::FormTagHelper
+    include ActionView::Helpers::JavaScriptHelper
+
+    attr_reader :template, :options, :ck_options
+
+    def initialize(template, options)
+      @template = template
+      @options = options.stringify_keys
+      @ck_options = (@options.delete('ckeditor') || {}).stringify_keys
+      @ck_options['customConfig'] ||= Ckeditor.js_config_url if Ckeditor.cdn_enabled?
+    end
+
+    def render_instance_tag(object_name, method)
+      tag = build_tag(object_name, method)
+      tag.send(:add_default_name_and_id, options) if options['id'].blank?
+
+      render tag.respond_to?(:to_text_area_tag) ? tag.to_text_area_tag(options) : tag.render
+    end
+
+    def render_tag(name, content)
+      options['id'] = sanitize_to_id(options['id'] || name)
+
+      render text_area_tag(name, content, options)
+    end
+
+    protected
+
+      def render(input)
+        output_buffer << input
+        output_buffer << javascript_tag(Utils.js_replace(options['id'], ck_options))
+        output_buffer
+      end
+
+      def output_buffer
+        @output_buffer ||= ActiveSupport::SafeBuffer.new
+      end
+
+      def build_tag(object_name, method)
+        if defined?(ActionView::Base::Tags::TextArea)
+          ActionView::Base::Tags::TextArea.new(object_name, method, template, options.symbolize_keys)
+        else
+          ActionView::Base::InstanceTag.new(object_name, method, template, options.delete('object'))
+        end
+      end
+  end
+end

data/lib/ckeditor/utils.rb

@@ -0,0 +1,108 @@
+# encoding: utf-8
+require 'active_support/json/encoding'
+
+module Ckeditor
+  module Utils
+    autoload :JavascriptCode, 'ckeditor/utils/javascript_code'
+    autoload :ContentTypeDetector, 'ckeditor/utils/content_type_detector'
+
+    class << self
+      def escape_single_quotes(str)
+        str.gsub('\\','\0\0').gsub('</','<\/').gsub(/\r\n|\n|\r/, "\\n").gsub(/["']/) { |m| "\\#{m}" }
+      end
+
+      def parameterize_filename(filename)
+        return filename unless Ckeditor.parameterize_filenames
+
+        extension = File.extname(filename)
+        basename = filename.gsub(/#{extension}$/, "")
+
+        [basename.parameterize('_'), extension].join.downcase
+      end
+
+      def js_replace(dom_id, options = nil)
+        js = ["(function() { if (typeof CKEDITOR != 'undefined') {"]
+
+        if options && !options.keys.empty?
+          js_options = ActiveSupport::JSON.encode(options)
+          js << "if (CKEDITOR.instances['#{dom_id}'] == undefined) { CKEDITOR.replace('#{dom_id}', #{js_options}); }"
+        else
+          js << "if (CKEDITOR.instances['#{dom_id}'] == undefined) { CKEDITOR.replace('#{dom_id}'); }"
+        end
+
+        js << "} else { setTimeout(arguments.callee, 50); } })();"
+        js.join(" ").html_safe
+      end
+
+      def js_fileuploader(uploader_type, options = {})
+        options = { :multiple => true, :element => "fileupload" }.merge(options)
+
+        case uploader_type.to_s.downcase
+          when "image" then
+            options[:action] = JavascriptCode.new("EDITOR.config.filebrowserImageUploadUrl")
+            options[:allowedExtensions] = Ckeditor.image_file_types
+          when "flash" then
+            options[:action] = JavascriptCode.new("EDITOR.config.filebrowserFlashUploadUrl")
+            options[:allowedExtensions] = ["swf"]
+          else
+            options[:action] = JavascriptCode.new("EDITOR.config.filebrowserUploadUrl")
+            options[:allowedExtensions] = Ckeditor.attachment_file_types
+        end
+
+        js_options = ActiveSupport::JSON.encode(options)
+        js_options.gsub!(/"(EDITOR\.config\.filebrowser(Image|Flash|)UploadUrl)"/, '\1')
+
+        "(function() { new qq.FileUploaderInput(#{js_options}); }).call(this);".html_safe
+      end
+
+      def filethumb(filename)
+        extname = filename.blank? ? "unknown" : File.extname(filename).gsub(/^\./, '')
+        image = "#{extname}.gif"
+        source = Ckeditor.root_path.join("app/assets/javascripts/ckeditor/filebrowser/images/thumbs")
+
+        unless File.exists?(File.join(source, image))
+          image = "unknown.gif"
+        end
+
+        File.join(Ckeditor.relative_path, "filebrowser/images/thumbs", image)
+      end
+
+      def select_assets(path, relative_path)
+        relative_folder = Ckeditor.root_path.join(relative_path)
+        folder = relative_folder.join(path)
+        extensions = '*.{js,css,png,gif,jpg,html}'
+        languages = (Ckeditor.assets_languages || [])
+
+        # Files at root
+        files = Dir[folder.join(extensions)]
+
+        # Filter plugins
+        if Ckeditor.assets_plugins.nil?
+          files += Dir[folder.join('plugins', '**', extensions)]
+        else
+          Ckeditor.assets_plugins.each do |plugin|
+            files += Dir[folder.join('plugins', plugin, '**', extensions)]
+          end
+        end
+
+        # Other folders
+        Dir[folder.join('*/')].each do |subfolder|
+          path = Pathname.new(subfolder)
+          next if ['plugins'].include?(path.basename.to_s)
+          files += Dir[path.join('**', extensions)]
+        end
+
+        files.inject([]) do |items, name|
+          file = Pathname.new(name)
+          base = file.basename('.*').to_s
+
+          if !name.include?('/lang/') || languages.include?(base)
+            items << file.relative_path_from(relative_folder).to_s
+          end
+
+          items
+        end
+      end
+    end
+  end
+end

data/lib/ckeditor/utils/content_type_detector.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+require 'cocaine'
+
+module Ckeditor
+  module Utils
+    class ContentTypeDetector
+      EMPTY_CONTENT_TYPE = 'inode/x-empty'
+      DEFAULT_CONTENT_TYPE = 'application/octet-stream'
+
+      def initialize(file_path)
+        @file_path = file_path
+      end
+
+      # content type detection strategy:
+      #
+      # 1. empty file: returns 'inode/x-empty'
+      # 2. nonempty file: if the file is not empty then returns the content type using file command
+      # 3. invalid file: file command raises error and returns 'application/octet-stream'
+
+      def detect
+        empty_file? ? EMPTY_CONTENT_TYPE : content_type_from_file_command
+      end
+
+      private
+
+      def empty_file?
+        return true if @file_path.blank?
+        File.exists?(@file_path) && File.size(@file_path) == 0
+      end
+
+      def content_type_from_file_command
+        type = begin
+          Cocaine::CommandLine.new('file', '-b --mime-type :file').run(file: @file_path)
+        rescue Cocaine::CommandLineError => e
+          # TODO: log command failure
+          DEFAULT_CONTENT_TYPE
+        end.strip
+      end
+    end
+  end
+end