st-rich 1.5.1

data/lib/rich/authorize.rb

@@ -0,0 +1,7 @@
+module Rich
+  module Authorize
+    def authenticate_rich_user
+      send(Rich.authentication_method) unless Rich.authentication_method == :none
+    end
+  end
+end

data/lib/rich/backends/carrierwave.rb

@@ -0,0 +1,78 @@
+raise "Please install CarrierWave: github.com/carrierwaveuploader/carrierwave" unless Object.const_defined?(:CarrierWave)
+require 'rich/utils/file_size_validator'
+require 'rich/backends/rich_file_uploader'
+
+module Rich
+  module Backends
+    module CarrierWave
+      extend ActiveSupport::Concern
+
+      included do
+        mount_uploader :rich_file_file_name, RichFileUploader
+
+        before_validation :update_rich_file_attributes
+
+        validate :check_content_type
+        validates :rich_file_file_name,
+          :presence => true,
+          :file_size => {
+            :maximum => 15.megabytes.to_i
+          }
+
+        after_save :clear_uri_cache
+      end
+  
+      def rich_file
+        self.rich_file_file_name
+      end
+
+      def rich_file=(val)
+        self.rich_file_file_name = val
+      end
+  
+      def uri_cache
+        uri_cache_attribute = read_attribute(:uri_cache)
+        if uri_cache_attribute.blank?
+          uris = {}
+
+          rich_file.versions.each do |version|
+            uris[version[0]] = rich_file.url(version[0].to_sym, false)
+          end
+
+          # manualy add the original size
+          uris["original"] = rich_file.url
+
+          uri_cache_attribute = uris.to_json
+          write_attribute(:uri_cache, uri_cache_attribute)
+        end
+        uri_cache_attribute
+      end
+
+      private
+
+      def check_content_type
+        unless Rich.validate_mime_type(self.rich_file_content_type, self.simplified_type)
+          self.errors[:base] << "'#{self.rich_file_file_name}' is not the right type."
+        end
+      end
+
+      def update_rich_file_attributes
+        if rich_file.present? && rich_file_file_name_changed?
+          self.rich_file_content_type = rich_file.file.content_type
+          self.rich_file_file_size = rich_file.file.size
+          self.rich_file_updated_at = Time.now
+        end
+      end
+
+      def clear_uri_cache
+        write_attribute(:uri_cache, nil)
+      end
+
+      module ClassMethods
+
+      end
+    end
+  end
+
+  Rich::RichFile.send(:include, Backends::CarrierWave)
+end

data/lib/rich/backends/paperclip.rb

@@ -0,0 +1,79 @@
+raise "Please install Paperclip: github.com/thoughtbot/paperclip" unless Object.const_defined?(:Paperclip)
+
+module Rich
+  module Backends
+    module Paperclip
+      extend ActiveSupport::Concern
+
+      included do
+        has_attached_file :rich_file,
+          :styles => Proc.new {|a| a.instance.set_styles },
+          :convert_options => Proc.new { |a| Rich.convert_options[a] }
+
+        do_not_validate_attachment_file_type :rich_file
+        validates_attachment_presence :rich_file
+        validate :check_content_type
+        validates_attachment_size :rich_file, :less_than=>15.megabyte, :message => "must be smaller than 15MB"
+
+        after_create :cache_style_uris_and_save
+        before_update :cache_style_uris
+        before_create :clean_file_name
+      end
+
+      def set_styles
+        if self.simplified_type=="image"
+          Rich.image_styles
+        else
+          {}
+        end
+      end
+
+      private
+
+      def cache_style_uris_and_save
+        cache_style_uris
+        self.save!
+      end
+
+      def check_content_type
+        self.rich_file.instance_write(:content_type, MIME::Types.type_for(rich_file_file_name)[0].content_type)
+
+        unless Rich.validate_mime_type(self.rich_file_content_type, self.simplified_type)
+          self.errors[:base] << "'#{self.rich_file_file_name}' is not the right type."
+        end
+      end
+
+      def cache_style_uris
+        uris = {}
+
+        rich_file.styles.each do |style|
+          uris[style[0]] = rich_file.url(style[0].to_sym, false)
+        end
+
+        # manualy add the original size
+        uris["original"] = rich_file.url(:original, false)
+
+        self.uri_cache = uris.to_json
+      end
+
+      def clean_file_name      
+        extension = File.extname(rich_file_file_name).gsub(/^\.+/, '')
+        filename = rich_file_file_name.gsub(/\.#{extension}$/, '')
+
+          filename = CGI::unescape(filename)
+        filename = CGI::unescape(filename)
+
+        extension = extension.downcase
+        filename = filename.downcase.gsub(/[^a-z0-9]+/i, '-')
+
+        self.rich_file.instance_write(:file_name, "#{filename}.#{extension}")
+      end
+
+      module ClassMethods
+
+      end
+    end
+  end
+
+  RichFile.send(:include, Backends::Paperclip)
+end

data/lib/rich/backends/rich_file_uploader.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+class RichFileUploader < CarrierWave::Uploader::Base
+
+  # Include RMagick or MiniMagick support:
+  # include CarrierWave::RMagick
+  include CarrierWave::MiniMagick
+
+  # Choose what kind of storage to use for this uploader:
+  # storage :file
+  # storage :fog
+
+  # Override the directory where uploaded files will be stored.
+  # This is a sensible default for uploaders that are meant to be mounted:
+  def store_dir
+    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+  end
+
+  # Provide a default URL as a default if there hasn't been a file uploaded:
+  # def default_url
+  #   # For Rails 3.1+ asset pipeline compatibility:
+  #   # ActionController::Base.helpers.asset_path("fallback/" + [version_name, "default.png"].compact.join('_'))
+  #
+  #   "/images/fallback/" + [version_name, "default.png"].compact.join('_')
+  # end
+
+  # Process files as they are uploaded:
+  # process :scale => [200, 300]
+  #
+  # def scale(width, height)
+  #   # do something
+  # end
+
+  Rich.image_styles.each do |name,size|
+    version name do
+      process :resize_to_fit => size.gsub("#", "").split("x").map(&:to_i)
+    end
+  end
+  # version :rich_thumb do
+    # process :resize_to_fit => [100, 100]
+  # end
+
+  # Add a white list of extensions which are allowed to be uploaded.
+  # For images you might use something like this:
+  # def extension_white_list
+  #   %w(jpg jpeg gif png)
+  # end
+
+  # Override the filename of the uploaded files:
+  # Avoid using model.id or version_name here, see uploader/store.rb for details.
+  # def filename
+  #   "something.jpg" if original_filename
+  # end
+
+end

data/lib/rich/engine.rb

@@ -0,0 +1,26 @@
+require 'rack/raw_upload'
+require "rich/authorize"
+    
+module Rich
+  class Engine < Rails::Engine
+    isolate_namespace Rich
+
+    initializer "rich.add_middleware" do |app|
+      app.config.assets.precompile += %W(
+              ckeditor/*.js
+              ckeditor/*.css
+              ckeditor/*.png
+              ckeditor/*.gif
+              ckeditor/*.html
+              ckeditor/*.md
+      )
+      app.middleware.use Rack::RawUpload, :paths => ['/rich/files']
+    end
+
+    initializer 'rich.include_authorization' do |app|
+      ActiveSupport.on_load(:action_controller) do
+        include Rich::Authorize
+      end
+    end
+  end
+end

data/lib/rich/integrations/legacy_formtastic.rb

@@ -0,0 +1,50 @@
+module Rich
+  module Integrations
+    module FormtasticBuilder
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+      end
+
+      module InstanceMethods
+        def rich_input(method, options)
+          scope_type = object_name
+          scope_id = object.id
+          editor_options = Rich.options(options[:config], scope_type, scope_id)
+          dom_id = "#{sanitized_object_name}_#{generate_association_input_name(method)}"
+
+          (
+            text_input(method, options) <<
+            "<script>$(function(){$('##{dom_id}').ckeditor(function() { }, #{editor_options.to_json} );});</script>".html_safe
+          )
+        end
+
+        def rich_picker_input(method, options)
+
+          scope_type = object_name
+          scope_id = object.id
+          editor_options = Rich.options(options[:config], scope_type, scope_id)
+
+          dom_id = "#{sanitized_object_name}_#{generate_association_input_name(method)}"
+
+          local_input_options = {
+            :input_html => {
+                :class => 'rich-picker',
+                :style => editor_options[:style]
+            }
+          }
+
+          (
+            string_input(method, local_input_options) <<
+            " <a href='#{Rich.editor[:richBrowserUrl]}' class='button'>#{I18n.t('picker_browse')}</a>".html_safe <<
+            "</br></br><img class='rich-image-preview' src='#{@object.send(method)}' style='height: 100px' />".html_safe <<
+            "<script>$(function(){$('##{dom_id}_input a').click(function(e){ e.preventDefault(); assetPicker.showFinder('##{dom_id}', #{editor_options.to_json.html_safe})})})</script>".html_safe <<
+            options.inspect
+
+          )
+
+        end
+
+      end
+    end
+  end
+end

data/lib/rich/rails_admin/config/fields/types/rich_editor.rb

@@ -0,0 +1,34 @@
+#require 'rails_admin/config/fields/base'
+module RailsAdmin::Config::Fields::Types
+  class RichEditor < RailsAdmin::Config::Fields::Types::Text
+    RailsAdmin::Config::Fields::Types::register(:rich_editor, self)
+
+    register_instance_option(:config) do
+      {}
+    end
+
+    register_instance_option(:partial) do
+      :form_rich_text
+    end
+
+    def scope_type
+      return nil unless bindings && bindings[:form]
+      # Use association name if existent
+      if bindings[:form].object_name.scan(/.*\[(.*)_attributes\]/).nil?
+        bindings[:form].object_name
+      else
+        bindings[:form].object_name.scan(/.*\[(.*)_attributes\]/).to_s
+      end
+    end
+
+    # Compatibility with RailsAdmin 0.6.0 AND prior versions
+    # https://github.com/sferik/rails_admin/commit/494205b3a0e128bfc98084ac59b5ee378d3218a1
+    def form_default_value
+      self.respond_to?(:html_default_value) ? html_default_value : super
+    end
+
+    def scope_id
+      bindings[:object].id
+    end
+  end
+end

data/lib/rich/rails_admin/config/fields/types/rich_picker.rb

@@ -0,0 +1,45 @@
+#require 'rails_admin/config/fields/types/string'
+module RailsAdmin::Config::Fields::Types
+  class RichPicker < RailsAdmin::Config::Fields::Base 
+    RailsAdmin::Config::Fields::Types::register(:rich_picker, self)
+    
+    register_instance_option(:config) do
+      {}
+    end
+      
+    register_instance_option(:partial) do
+      :form_rich_picker
+    end
+    
+    
+    def scope_type
+      bindings[:form].object_name
+    end
+    
+    def scope_id
+      bindings[:object].id
+    end
+
+    def editor_options
+      Rich.options(config, scope_type, scope_id)
+    end
+
+    def preview_image_path
+      if value.to_s.html_safe != ""
+        if (true if Float(value) rescue false)
+          # if the value is numeric we assume its an object id
+          rich_file = Rich::RichFile.find(value)
+          rich_file.rich_file.url(:rich_thumb)
+        else
+          # if not, we assume its a url
+          value.to_s
+        end
+      else
+        # no value, show placeholder image
+        editor_options[:placeholder_image]
+      end
+
+    end
+
+  end
+end

data/lib/rich/utils/file_size_validator.rb

@@ -0,0 +1,68 @@
+# lib/file_size_validator.rb
+# Based on: https://gist.github.com/795665
+
+class FileSizeValidator < ActiveModel::EachValidator
+  MESSAGES  = { :is => :wrong_size, :minimum => :size_too_small, :maximum => :size_too_big }.freeze
+  CHECKS    = { :is => :==, :minimum => :>=, :maximum => :<= }.freeze
+
+  DEFAULT_TOKENIZER = lambda { |value| value.split(//) }
+  RESERVED_OPTIONS  = [:minimum, :maximum, :within, :is, :tokenizer, :too_short, :too_long]
+
+  def initialize(options)
+    if range = (options.delete(:in) || options.delete(:within))
+      raise ArgumentError, ":in and :within must be a Range" unless range.is_a?(Range)
+      options[:minimum], options[:maximum] = range.begin, range.end
+      options[:maximum] -= 1 if range.exclude_end?
+    end
+
+    super
+  end
+
+  def check_validity!
+    keys = CHECKS.keys & options.keys
+
+    if keys.empty?
+      raise ArgumentError, 'Range unspecified. Specify the :within, :maximum, :minimum, or :is option.'
+    end
+
+    keys.each do |key|
+      value = options[key]
+
+      unless value.is_a?(Integer) && value >= 0
+        raise ArgumentError, ":#{key} must be a nonnegative Integer"
+      end
+    end
+  end
+
+  def validate_each(record, attribute, value)
+    raise(ArgumentError, "A CarrierWave::Uploader::Base object was expected") unless value.kind_of? CarrierWave::Uploader::Base
+    
+    value = (options[:tokenizer] || DEFAULT_TOKENIZER).call(value) if value.kind_of?(String)
+
+    CHECKS.each do |key, validity_check|
+      next unless check_value = options[key]
+
+      value ||= [] if key == :maximum
+
+      value_size = value.size
+      next if value_size.send(validity_check, check_value)
+
+      errors_options = options.except(*RESERVED_OPTIONS)
+      errors_options[:file_size] = help.number_to_human_size check_value
+
+      default_message = options[MESSAGES[key]]
+      errors_options[:message] ||= default_message if default_message
+
+      record.errors.add(attribute, MESSAGES[key], errors_options)
+    end
+  end
+  
+  def help
+    Helper.instance
+  end
+
+  class Helper
+    include Singleton
+    include ActionView::Helpers::NumberHelper
+  end
+end