ckeditor_custom_controller 4.1.6

data/lib/ckeditor/backend/carrierwave.rb

@@ -0,0 +1,57 @@
+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
+          model.data_content_type = Utils::ContentTypeDetector.new(file.path).detect
+        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,47 @@
+module Ckeditor
+  module Backend
+    module Dragonfly
+      def self.included(base)
+        base.send(:extend, ::Dragonfly::Model)
+        base.send(:extend, ::Dragonfly::Model::Validations)
+        base.send(:extend, ClassMethods)
+        base.send(:include, InstanceMethods)
+      end
+
+      module ClassMethods
+        def attachment_file_types
+          @attachment_file_types ||= Ckeditor.attachment_file_types.map(&:to_s).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}")
+            end
+          end
+        end
+
+        def image_file_types
+          @image_file_types ||= Ckeditor.image_file_types.map(&:to_s)
+        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,52 @@
+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 ||= ::Paperclip::Geometry.from_file(file)
+        end
+
+        protected
+
+          def file
+            @file ||= data.respond_to?(:queued_for_write) ? data.queued_for_write[:original] : data.to_file
+          end
+
+          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
+
+          def extract_content_type
+            path = file.nil? ? nil : file.path
+            self.data_content_type = Utils::ContentTypeDetector.new(path).detect
+          end
+      end
+    end
+  end
+end

data/lib/ckeditor/backend/refile.rb

@@ -0,0 +1,37 @@
+module Ckeditor
+  module Backend
+    module Refile
+      extend ActiveSupport::Concern
+
+      included do
+        validates :data, presence: true
+        delegate :rewind, :download, :to_io, :exists?, :delete, :size, :close, :eof?, :read, to: :data
+        alias_attribute :data_file_name, :data_filename
+        alias_attribute :data_file_size, :data_size
+      end
+
+      class_methods do
+        def attachment_file_types
+          @attachment_file_types ||= Ckeditor.attachment_file_types.map(&:to_s)
+        end
+
+        def image_file_types
+          @image_file_types ||= Ckeditor.image_file_types.map(&:to_s)
+        end
+      end
+
+      def url(*attrs)
+        ::Refile.attachment_url(self, :data, *attrs)
+      end
+
+      def read_dimensions
+        if model.image? && model.has_dimensions?
+          magick = MiniMagick::Image.open(model.to_io)
+          model.width = magick.width
+          model.height = magick.height
+        end
+      end
+      
+    end
+  end
+end

data/lib/ckeditor/engine.rb

@@ -0,0 +1,46 @@
+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
+
+      if Object.const_defined?("Pundit")
+        require "ckeditor/hooks/pundit"
+      end
+    end
+
+    rake_tasks do
+      load Ckeditor.root_path.join("lib/tasks/ckeditor.rake")
+    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 ckeditor_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,49 @@
+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)
+        if action
+          @controller.instance_variable_set(:@_authorized, true)
+          @controller.current_ability.authorize!(action.to_sym, model_object)
+        end
+      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/pundit.rb

@@ -0,0 +1,47 @@
+require 'pundit'
+
+module Ckeditor
+  module Hooks
+    # This adapter is for the Pundit[https://github.com/elabs/pundit] authorization library.
+    # You can create another adapter for different authorization behavior, just be certain it
+    # responds to each of the public methods here.
+    class PunditAuthorization
+
+      include Ckeditor::Helpers::Controllers
+
+      # See the +authorize_with+ config method for where the initialization happens.
+      def initialize(controller)
+        @controller = controller
+        @controller.extend ControllerExtension
+      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)
+        raise Pundit::NotAuthorizedError unless authorized?(action, model_object)
+      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)
+        Pundit.policy(@controller.current_user_for_pundit, model_object).public_send(action + '?' ) if action
+      end
+
+      private
+
+      module ControllerExtension
+        def current_user_for_pundit
+          # use ckeditor_current_user instead of default current_user so it works with
+          # whatever current user method is defined with Ckeditor
+          ckeditor_current_user
+        end
+      end
+    end
+  end
+end
+
+Ckeditor::AUTHORIZATION_ADAPTERS[:pundit] = Ckeditor::Hooks::PunditAuthorization

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(wrapper_options = nil)
+      @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