base2_ckeditor 4.0.7

data/lib/ckeditor/backend/carrierwave.rb

@@ -0,0 +1,64 @@
+require 'mime/types'
+require 'mini_magick'
+
+module Ckeditor
+  module Backend
+    module CarrierWave
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+        base.send(:extend, ClassMethods)
+      end
+      
+      module ClassMethods
+        def self.extended(base)
+          base.class_eval do
+            process :extract_content_type
+            process :set_size
+          end
+        end
+      end
+      
+      module InstanceMethods
+        # process :strip
+        def strip
+          manipulate! do |img|
+            img.strip
+            img = yield(img) if block_given?
+            img
+          end
+        end
+        
+        # process :quality => 85
+        def quality(percentage)
+          manipulate! do |img|
+            img.quality(percentage)
+            img = yield(img) if block_given?
+            img
+          end
+        end
+        
+        def extract_content_type
+          if file.content_type == 'application/octet-stream' || file.content_type.blank?
+            content_type = MIME::Types.type_for(original_filename).first
+          else
+            content_type = file.content_type
+          end
+          
+          model.data_content_type = content_type.to_s
+        end 
+        
+        def set_size
+          model.data_file_size = file.size
+        end
+        
+        def read_dimensions
+          if model.image? && model.has_dimensions?
+            magick = ::MiniMagick::Image.new(current_path)
+            model.width, model.height = magick[:width], magick[:height]
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/ckeditor/backend/dragonfly.rb

@@ -0,0 +1,45 @@
+module Ckeditor
+  module Backend
+    module Dragonfly
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+        base.send(:extend, ClassMethods)
+      end
+      
+      module ClassMethods
+        def attachment_file_types
+          @attachment_file_types ||= Ckeditor.attachment_file_types.map(&:to_sym).tap do |formats|
+            # This is not ideal but Dragonfly doesn't return double
+            # extensions. Having said that, the other backends
+            # currently don't use attachment_file_types at all.
+            [ :bz2, :gz, :lzma, :xz ].each do |f|
+              formats << f if formats.include?("tar.#{f}".to_sym)
+            end
+          end
+        end
+
+        def image_file_types
+          @image_file_types ||= Ckeditor.image_file_types.map(&:to_sym)
+        end
+      end
+      
+      module InstanceMethods
+        delegate :url, :path, :size, :image?, :width, :height, :to => :data
+
+        alias_attribute :data_file_name, :data_name
+        alias_attribute :data_content_type, :data_mime_type
+        alias_attribute :data_file_size, :data_size
+
+        private
+
+        def url_thumb_options
+          if data.basename.present?
+            { :basename => "thumb_#{data.basename}" }
+          else
+            {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ckeditor/backend/paperclip.rb

@@ -0,0 +1,56 @@
+require 'mime/types'
+
+module Ckeditor
+  module Backend
+    module Paperclip
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+        base.send(:extend, ClassMethods)
+      end
+      
+      module ClassMethods
+        def self.extended(base)
+          base.class_eval do
+            before_validation :extract_content_type
+            before_create :read_dimensions, :parameterize_filename
+            
+            delegate :url, :path, :styles, :size, :content_type, :to => :data
+          end
+        end
+      end
+      
+      module InstanceMethods
+        def geometry
+          @geometry ||= begin
+            file = data.respond_to?(:queued_for_write) ? data.queued_for_write[:original] : data.to_file
+            ::Paperclip::Geometry.from_file(file)
+          end
+        end
+                
+        protected
+
+          def parameterize_filename
+            unless data_file_name.blank?
+              filename = Ckeditor::Utils.parameterize_filename(data_file_name)
+              self.data.instance_write(:file_name, filename)
+            end
+          end
+
+          def read_dimensions
+            if image? && has_dimensions?
+              self.width = geometry.width
+              self.height = geometry.height
+            end
+          end
+
+          # Extract content_type from filename using mime/types gem
+          def extract_content_type
+            if data_content_type == "application/octet-stream" && !data_file_name.blank?
+              content_types = MIME::Types.type_for(data_file_name)
+              self.data_content_type = content_types.first.to_s unless content_types.empty?
+            end
+          end
+      end
+    end
+  end
+end

data/lib/ckeditor/engine.rb

@@ -0,0 +1,38 @@
+require 'rails'
+require 'ckeditor'
+
+module Ckeditor
+  class Engine < ::Rails::Engine
+    isolate_namespace Ckeditor
+    
+    initializer "ckeditor.assets_precompile", :group => :all do |app|
+      app.config.assets.precompile += Ckeditor.assets
+    end
+    
+    initializer "ckeditor.helpers" do
+      ActiveSupport.on_load(:action_controller) do
+        ActionController::Base.send :include, Ckeditor::Helpers::Controllers
+      end
+    
+      ActiveSupport.on_load :action_view do
+        ActionView::Base.send :include, Ckeditor::Helpers::ViewHelper
+        ActionView::Base.send :include, Ckeditor::Helpers::FormHelper
+        ActionView::Helpers::FormBuilder.send :include, Ckeditor::Helpers::FormBuilder
+      end
+    end
+    
+    initializer "ckeditor.hooks" do
+      if Object.const_defined?("Formtastic")
+        require "ckeditor/hooks/formtastic"
+      end
+      
+      if Object.const_defined?("SimpleForm")
+        require "ckeditor/hooks/simple_form"
+      end
+
+      if Object.const_defined?("CanCan")
+        require "ckeditor/hooks/cancan"
+      end
+    end
+  end
+end

data/lib/ckeditor/helpers/controllers.rb

@@ -0,0 +1,34 @@
+module Ckeditor
+  module Helpers
+    module Controllers
+      extend ActiveSupport::Concern
+      
+      protected
+        
+        def ckeditor_current_user
+          instance_eval &Ckeditor.current_user_method
+        end
+
+        def ckeditor_authorize!
+          instance_eval &Ckeditor.authorize_with
+        end
+        
+        def ckeditor_before_create_asset(asset)
+          asset.assetable = ckeditor_current_user  if respond_to?(:current_user)
+          return true
+        end
+        
+        def ckeditor_pictures_scope(options = {})
+          ckeditor_filebrowser_scope(options)
+        end
+        
+        def ckeditor_attachment_files_scope(options = {})
+          ckeditor_filebrowser_scope(options)
+        end
+        
+        def ckeditor_filebrowser_scope(options = {})
+          { :order => [:id, :desc] }.merge(options)
+        end
+    end
+  end
+end

data/lib/ckeditor/helpers/form_builder.rb

@@ -0,0 +1,11 @@
+module Ckeditor
+  module Helpers
+    module FormBuilder
+      extend ActiveSupport::Concern
+      
+      def cktext_area(method, options = {})
+        @template.send("cktext_area", @object_name, method, objectify_options(options))
+      end
+    end
+  end
+end

data/lib/ckeditor/helpers/form_helper.rb

@@ -0,0 +1,11 @@
+module Ckeditor
+  module Helpers
+    module FormHelper
+      extend ActiveSupport::Concern
+      
+      def cktext_area(object_name, method, options = {})
+        TextArea.new(self, options).render_instance_tag(object_name, method)
+      end
+    end
+  end
+end

data/lib/ckeditor/helpers/view_helper.rb

@@ -0,0 +1,11 @@
+module Ckeditor
+  module Helpers
+    module ViewHelper
+      extend ActiveSupport::Concern
+      
+      def cktext_area_tag(name, content = nil, options = {})
+        TextArea.new(self, options).render_tag(name, content)
+      end
+    end
+  end
+end

data/lib/ckeditor/hooks/cancan.rb

@@ -0,0 +1,46 @@
+require 'cancan'
+
+module Ckeditor
+  module Hooks
+    # This adapter is for the CanCan[https://github.com/ryanb/cancan] authorization library.
+    # You can create another adapter for different authorization behavior, just be certain it
+    # responds to each of the public methods here.
+    class CanCanAuthorization
+      # See the +authorize_with+ config method for where the initialization happens.
+      def initialize(controller, ability = ::Ability)
+        @controller = controller
+        @controller.instance_variable_set '@ability', ability
+        @controller.extend ControllerExtension
+        @controller.current_ability.authorize! :access, :ckeditor
+      end
+
+      # This method is called in every controller action and should raise an exception
+      # when the authorization fails. The first argument is the name of the controller
+      # action as a symbol (:create, :destroy, etc.). The second argument is the actual model
+      # instance if it is available.
+      def authorize(action, model_object = nil)
+        @controller.authorize!(action.to_sym, model_object) if action
+      end
+
+      # This method is called primarily from the view to determine whether the given user
+      # has access to perform the action on a given model. It should return true when authorized.
+      # This takes the same arguments as +authorize+. The difference is that this will
+      # return a boolean whereas +authorize+ will raise an exception when not authorized.
+      def authorized?(action, model_object = nil)
+        @controller.current_ability.can?(action.to_sym, model_object) if action
+      end
+
+      private
+
+      module ControllerExtension
+        def current_ability
+          # use ckeditor_current_user instead of default current_user so it works with
+          # whatever current user method is defined with Ckeditor
+          @current_ability ||= @ability.new(ckeditor_current_user)
+        end
+      end
+    end
+  end
+end
+
+Ckeditor::AUTHORIZATION_ADAPTERS[:cancan] = Ckeditor::Hooks::CanCanAuthorization

data/lib/ckeditor/hooks/formtastic.rb

@@ -0,0 +1,12 @@
+require "formtastic"
+
+class CkeditorInput
+  include ::Formtastic::Inputs::Base
+  
+  def to_html
+    input_wrapping do
+      label_html <<
+      builder.cktext_area(method, input_html_options)
+    end
+  end
+end

data/lib/ckeditor/hooks/simple_form.rb

@@ -0,0 +1,20 @@
+require 'simple_form'
+
+module Ckeditor::Hooks::SimpleForm
+  class CkeditorInput < ::SimpleForm::Inputs::Base
+    def input
+      @builder.cktext_area(attribute_name, input_html_options)
+    end
+  end
+end
+
+::SimpleForm::FormBuilder.map_type :ckeditor, :to => Ckeditor::Hooks::SimpleForm::CkeditorInput
+
+# TODO: remove this after a while, SimpleForm::FormBuilder#ckeditor is deprecated.
+class SimpleForm::FormBuilder
+  def ckeditor(attribute_name, options={}, &block)
+    warn "[DEPRECATION] calling f.ckeditor(:#{attribute_name}, ...) is deprecated, call f.input(:#{attribute_name}, :as => :ckeditor, #{options.to_s[1..-1]}) #{Kernel.caller.first}"
+    options[:as] = :ckeditor
+    self.input(attribute_name, options, &block)
+  end
+end

data/lib/ckeditor/http.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+require 'digest/sha1'
+require 'mime/types'
+
+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
+        types = MIME::Types.type_for(original_filename)
+        types.empty? ? @request.content_type : types.first.to_s
+      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