jacobat-refinerycms 0.9.6.14

data/vendor/plugins/attachment_fu/vendor/red_artisan/core_image/filters/scale.rb

@@ -0,0 +1,47 @@
+module RedArtisan
+  module CoreImage
+    module Filters
+      module Scale
+
+        def resize(width, height)
+          create_core_image_context(width, height)
+
+          scale_x, scale_y = scale(width, height)
+
+          @original.affine_clamp :inputTransform => OSX::NSAffineTransform.transform do |clamped|
+            clamped.lanczos_scale_transform :inputScale => scale_x > scale_y ? scale_x : scale_y, :inputAspectRatio => scale_x / scale_y do |scaled|
+              scaled.crop :inputRectangle => vector(0, 0, width, height) do |cropped|
+                @target = cropped
+              end
+            end
+          end
+        end
+
+        def thumbnail(width, height)
+          create_core_image_context(width, height)
+
+          transform = OSX::NSAffineTransform.transform
+          transform.scaleXBy_yBy *scale(width, height)
+
+          @original.affine_transform :inputTransform => transform do |scaled|
+            @target = scaled
+          end
+        end
+
+        def fit(size)
+          original_size = @original.extent.size
+          scale = size.to_f / (original_size.width > original_size.height ? original_size.width : original_size.height)
+          resize (original_size.width * scale).to_i, (original_size.height * scale).to_i
+        end
+
+        private
+
+          def scale(width, height)
+            original_size = @original.extent.size
+            return width.to_f / original_size.width.to_f, height.to_f / original_size.height.to_f
+          end
+
+      end
+    end
+  end
+end

data/vendor/plugins/attachment_fu/vendor/red_artisan/core_image/filters/watermark.rb

@@ -0,0 +1,32 @@
+module RedArtisan
+  module CoreImage
+    module Filters
+      module Watermark
+
+        def watermark(watermark_image, tile = false, strength = 0.1)
+          create_core_image_context(@original.extent.size.width, @original.extent.size.height)
+
+          if watermark_image.respond_to? :to_str
+            watermark_image = OSX::CIImage.from(watermark_image.to_str)
+          end
+
+          if tile
+            tile_transform = OSX::NSAffineTransform.transform
+            tile_transform.scaleXBy_yBy 1.0, 1.0
+
+            watermark_image.affine_tile :inputTransform => tile_transform do |tiled|
+              tiled.crop :inputRectangle => vector(0, 0, @original.extent.size.width, @original.extent.size.height) do |tiled_watermark|
+                watermark_image = tiled_watermark
+              end
+            end
+          end
+
+          @original.dissolve_transition :inputTargetImage => watermark_image, :inputTime => strength do |watermarked|
+            @target = watermarked
+          end
+        end
+
+      end
+    end
+  end
+end

data/vendor/plugins/attachment_fu/vendor/red_artisan/core_image/processor.rb

@@ -0,0 +1,123 @@
+require 'rubygems'
+require 'osx/cocoa'
+require 'active_support'
+
+require 'red_artisan/core_image/filters/scale'
+require 'red_artisan/core_image/filters/color'
+require 'red_artisan/core_image/filters/watermark'
+require 'red_artisan/core_image/filters/quality'
+require 'red_artisan/core_image/filters/perspective'
+require 'red_artisan/core_image/filters/effects'
+
+# Generic image processor for scaling images based on CoreImage via RubyCocoa.
+#
+# Example usage:
+#
+# p = Processor.new OSX::CIImage.from(path_to_image)
+# p.resize(640, 480)
+# p.render do |result|
+#   result.save('resized.jpg', OSX::NSJPEGFileType)
+# end
+#
+# This will resize the image to the given dimensions exactly, if you'd like to ensure that aspect ratio is preserved:
+#
+# p = Processor.new OSX::CIImage.from(path_to_image)
+# p.fit(640)
+# p.render do |result|
+#   result.save('resized.jpg', OSX::NSJPEGFileType)
+# end
+#
+# fit(size) will attempt its best to resize the image so that the longest width/height (depending on image orientation) will match
+# the given size. The second axis will be calculated automatically based on the aspect ratio.
+#
+# Scaling is performed by first clamping the image so that its external bounds become infinite, this helps when scaling so that any
+# rounding discrepencies in dimensions don't affect the resultant image. We then perform a Lanczos transform on the image which scales
+# it to the target size. We then crop the image to the traget dimensions.
+#
+# If you are generating smaller images such as thumbnails where high quality rendering isn't as important, an additional method is
+# available:
+#
+# p = Processor.new OSX::CIImage.from(path_to_image)
+# p.thumbnail(100, 100)
+# p.render do |result|
+#   result.save('resized.jpg', OSX::NSJPEGFileType)
+# end
+#
+# This will perform a straight affine transform and scale the X and Y boundaries to the requested size. Generally, this will be faster
+# than a lanczos scale transform, but with a scaling quality trade.
+#
+# More than welcome to intregrate any patches, improvements - feel free to mail me with ideas.
+#
+# Thanks to
+# * Satoshi Nakagawa for working out that OCObjWrapper needs inclusion when aliasing method_missing on existing OSX::* classes.
+# * Vasantha Crabb for general help and inspiration with Cocoa
+# * Ben Schwarz for example image data and collaboration during performance testing
+#
+# Copyright (c) Marcus Crafter <crafterm@redartisan.com> released under the MIT license
+#
+module RedArtisan
+  module CoreImage
+    class Processor
+
+      def initialize(original)
+        if original.respond_to? :to_str
+          @original = OSX::CIImage.from(original.to_str)
+        else
+          @original = original
+        end
+      end
+
+      def render(&block)
+        raise "unprocessed image: #{@original}" unless @target
+        block.call @target
+      end
+
+      include Filters::Scale, Filters::Color, Filters::Watermark, Filters::Quality, Filters::Perspective, Filters::Effects
+
+      private
+
+        def create_core_image_context(width, height)
+          output = OSX::NSBitmapImageRep.alloc.initWithBitmapDataPlanes_pixelsWide_pixelsHigh_bitsPerSample_samplesPerPixel_hasAlpha_isPlanar_colorSpaceName_bytesPerRow_bitsPerPixel(nil, width, height, 8, 4, true, false, OSX::NSDeviceRGBColorSpace, 0, 0)
+          context = OSX::NSGraphicsContext.graphicsContextWithBitmapImageRep(output)
+          OSX::NSGraphicsContext.setCurrentContext(context)
+          @ci_context = context.CIContext
+        end
+
+        def vector(x, y, w, h)
+          OSX::CIVector.vectorWithX_Y_Z_W(x, y, w, h)
+        end
+    end
+  end
+end
+
+module OSX
+  class CIImage
+    include OCObjWrapper
+
+    def method_missing_with_filter_processing(sym, *args, &block)
+      f = OSX::CIFilter.filterWithName("CI#{sym.to_s.camelize}")
+      return method_missing_without_filter_processing(sym, *args, &block) unless f
+
+      f.setDefaults if f.respond_to? :setDefaults
+      f.setValue_forKey(self, 'inputImage')
+      options = args.last.is_a?(Hash) ? args.last : {}
+      options.each { |k, v| f.setValue_forKey(v, k.to_s) }
+
+      block.call f.valueForKey('outputImage')
+    end
+
+    alias_method_chain :method_missing, :filter_processing
+
+    def save(target, format = OSX::NSJPEGFileType, properties = nil)
+      bitmapRep = OSX::NSBitmapImageRep.alloc.initWithCIImage(self)
+      blob = bitmapRep.representationUsingType_properties(format, properties)
+      blob.writeToFile_atomically(target, false)
+    end
+
+    def self.from(filepath)
+      raise Errno::ENOENT, "No such file or directory - #{filepath}" unless File.exists?(filepath)
+      OSX::CIImage.imageWithContentsOfURL(OSX::NSURL.fileURLWithPath(filepath))
+    end
+  end
+end
+

data/vendor/plugins/authentication/app/controllers/admin/users_controller.rb

@@ -0,0 +1,67 @@
+class Admin::UsersController < Admin::BaseController
+
+  crudify :user, :order => 'login', :title_attribute => 'login', :conditions => "state = 'active'"
+
+  # Protect these actions behind an admin login
+  before_filter :find_user, :except => [:new, :create]
+  before_filter :load_available_plugins, :only => [:new, :create, :edit, :update]
+
+  filter_parameter_logging 'password', 'password_confirmation'
+
+  layout 'admin'
+
+  def new
+    @user = User.new
+    @selected_plugin_titles = []
+  end
+
+  def create
+    @user = User.new(params[:user])
+    @selected_plugin_titles = params[:user][:plugins] || []
+
+    if @user.save
+      @user.plugins = @selected_plugin_titles
+      @user.register!
+      @user.activate!
+      flash[:notice] = "'#{@user.login}' was successfully created."
+      redirect_to :action => 'index'
+    else
+      render :action => 'new'
+    end
+  end
+
+  def edit
+    @user = User.find params[:id]
+    @selected_plugin_titles = @user.plugins.collect{|p| p.title}
+  end
+
+  def update
+    @selected_plugin_titles = params[:user][:plugins]
+    # Prevent the current user from locking themselves out of the User manager
+    if current_user.id == @user.id and !params[:user][:plugins].include?("Users")
+      flash.now[:error] = "You cannot remove the 'Users' plugin from the currently logged in account."
+      render :action => "edit"
+    else
+      @previously_selected_plugins_titles = @user.plugins.collect{|p| p.title}
+      if @user.update_attributes params[:user]
+        flash[:notice] = "'#{@user.login}' was successfully updated."
+        redirect_to admin_users_url
+      else
+        @user.plugins = @previously_selected_plugins_titles
+        @user.save
+        render :action => 'edit'
+      end
+    end
+  end
+
+protected
+
+  def can_create_public_user
+    User.count == 0
+  end
+
+  def load_available_plugins
+    @available_plugins = Refinery::Plugins.registered.in_menu.titles.sort
+  end
+
+end

data/vendor/plugins/authentication/app/controllers/sessions_controller.rb

@@ -0,0 +1,36 @@
+class SessionsController < ApplicationController
+
+  layout 'admin'
+  filter_parameter_logging 'password', 'password_confirmation'
+
+  def create
+    self.current_user = User.authenticate(params[:session][:login], params[:session][:password])
+
+    if logged_in?
+      if params[:session][:remember_me] == "1"
+        current_user.remember_me unless current_user.remember_token?
+        cookies[:auth_token] = {:value => self.current_user.remember_token ,
+                                :expires => self.current_user.remember_token_expires_at}
+      end
+
+      redirect_back_or_default(admin_root_url)
+      flash[:notice] = "Logged in successfully"
+    else
+      flash.now[:error] = "Sorry, your password or username was incorrect."
+      render :action => 'new'
+    end
+  end
+
+  def destroy
+    self.current_user.forget_me if logged_in?
+    cookies.delete :auth_token
+    reset_session
+    flash[:notice] = "You have been logged out."
+    redirect_back_or_default(new_session_url)
+  end
+
+protected
+
+  def take_down_for_maintenance?;end
+
+end

data/vendor/plugins/authentication/app/controllers/users_controller.rb

@@ -0,0 +1,101 @@
+class UsersController < ApplicationController
+
+  # Protect these actions behind an admin login
+  before_filter :find_user, :only => [:suspend, :unsuspend, :destroy, :purge]
+
+  filter_parameter_logging 'password', 'password_confirmation'
+
+  layout 'admin'
+
+  def new
+    render :text => "User signup is disabled", :layout => true unless can_create_public_user
+  end
+
+  def create
+    unless can_create_public_user
+      render :text => "User signup is disabled", :layout => true
+    else
+      begin
+        cookies.delete :auth_token
+        # protects against session fixation attacks, wreaks havoc with
+        # request forgery protection.
+        # uncomment at your own risk
+        # reset_session
+        @user = User.new(params[:user])
+        @selected_plugin_titles = params[:user][:plugins] || []
+
+        @user.register! if @user.valid?
+        if @user.errors.empty?
+          @user.plugins = @selected_plugin_titles
+          self.current_user = @user
+          current_user.activate!
+          current_user.update_attribute(:superuser, true) if User.count == 1 # this is the superuser if this user is the only user.
+          redirect_back_or_default(admin_root_url)
+          flash[:notice] = "Welcome to Refinery, #{current_user.login}."
+
+          if User.count == 1 or RefinerySetting[:site_name] == "Company Name"
+            refinery_setting = RefinerySetting.find_by_name("site_name")
+            flash[:notice] << "<br/>First let's give the site a name. <a href='#{edit_admin_refinery_setting_url(refinery_setting)}'>Go here</a> to edit your website's name"
+          end
+        else
+          render :action => 'new'
+        end
+      end
+    end
+  end
+
+  def activate
+    self.current_user = params[:activation_code].blank? ? false : User.find_by_activation_code(params[:activation_code])
+
+    if logged_in? && !current_user.active?
+      current_user.activate!
+      flash[:notice] = "Signup complete!"
+    end
+
+    redirect_back_or_default(root_url)
+  end
+
+  def forgot
+    if request.post?
+      if (user = User.find_by_email(params[:user][:email])).present?
+        user.create_reset_code
+
+        begin
+          flash[:notice] = "An email has been sent to #{user.email} with a link to reset your password."
+          UserMailer.deliver_reset_notification(user, request)
+        rescue
+          logger.info "Error: email could not be sent for user password reset for user #{user.id} with email #{user.email}"
+        end
+      else
+        flash[:notice] = "Sorry, #{params[:user][:email]} isn't associated with any accounts. Are you sure you typed the correct email address?"
+      end
+
+      redirect_back_or_default(forgot_url)
+    end
+  end
+
+  def reset
+    @user = User.find_by_reset_code(params[:reset_code]) unless params[:reset_code].nil?
+
+    if request.post?
+      if @user.update_attributes(:password => params[:user][:password], :password_confirmation => params[:user][:password_confirmation])
+        self.current_user = @user
+        @user.delete_reset_code
+
+        flash[:notice] = "Password reset successfully for #{@user.email}"
+        redirect_back_or_default(admin_root_url)
+      else
+        render :action => :reset
+      end
+    end
+  end
+
+protected
+
+  def take_down_for_maintenance?;end
+
+  def can_create_public_user
+    User.count == 0
+  end
+
+end

data/vendor/plugins/authentication/app/helpers/sessions_helper.rb

@@ -0,0 +1,2 @@
+module SessionsHelper
+end

data/vendor/plugins/authentication/app/helpers/users_helper.rb

@@ -0,0 +1,2 @@
+module UsersHelper
+end

data/vendor/plugins/authentication/app/models/user.rb

@@ -0,0 +1,154 @@
+require 'digest/sha1'
+
+class User < ActiveRecord::Base
+
+  # Hack: Allow "rake gems:install" to run when this class is missing its gem dependency.
+  # For further clarification on why, refer to:
+  # https://rails.lighthouseapp.com/projects/8994/tickets/780-rake-gems-install-doesn-t-work-if-plugins-are-missing-gem-dependencies
+  if defined? AASM
+    include AASM # include the library which will give us state machine functionality.
+    aasm_column :state
+    aasm_initial_state :pending
+    aasm_state :passive
+    aasm_state :pending, :enter => :make_activation_code
+    aasm_state :active,  :enter => :do_activate
+
+    aasm_event :register do
+      transitions :from => :passive, :to => :pending, :guard => Proc.new {|u| !(u.crypted_password.blank? && u.password.blank?) }
+    end
+
+    aasm_event :activate do
+      transitions :from => :pending, :to => :active
+    end
+  end
+
+  # Virtual attribute for the unencrypted password
+  attr_accessor :password
+
+  #validates_presence_of     :login, :email # handled by other checks
+  #validates_presence_of     :password,                   :if => :password_required? # handled by other checks
+  validates_presence_of     :password_confirmation,      :if => :password_required?
+  validates_length_of       :password, :within => 4..40, :if => :password_required?
+  validates_confirmation_of :password,                   :if => :password_required?
+  validates_length_of       :login,    :within => 3..40
+  validates_length_of       :email,    :within => 3..100
+  validates_uniqueness_of   :login, :email, :case_sensitive => false
+  before_save :encrypt_password
+
+  serialize :plugins_column # Array # this is seriously deprecated and will be removed later.
+
+  has_many :plugins, :class_name => "UserPlugin", :order => "position ASC"
+
+  # prevents a user from submitting a crafted form that bypasses activation
+  # anything else you want your user to change should be added here.
+  attr_accessible :login, :email, :password, :password_confirmation, :plugins, :reset_code
+
+  # Authenticates a user by their login name and unencrypted password.  Returns the user or nil.
+  def self.authenticate(login, password)
+    u = find_in_state :first, :active, :conditions => {:login => login} # need to get the salt
+    u && u.authenticated?(password) ? u : nil
+  end
+
+  # Encrypts some data with the salt.
+  def self.encrypt(password, salt)
+    Digest::SHA1.hexdigest("--#{salt}--#{password}--")
+  end
+
+  # Encrypts the password with the user salt
+  def encrypt(password)
+    self.class.encrypt(password, salt)
+  end
+
+  def authenticated?(password)
+    crypted_password == encrypt(password)
+  end
+
+  def plugins=(plugin_titles)
+    unless self.new_record? # don't add plugins when the user_id is NULL.
+      self.plugins.delete_all
+
+      plugin_titles.each do |plugin_title|
+        self.plugins.find_or_create_by_title(plugin_title) if plugin_title.is_a?(String)
+      end
+    end
+  end
+
+  def authorized_plugins
+    self.plugins.collect {|p| p.title} | Refinery::Plugins.always_allowed.titles
+  end
+
+  def remember_token?
+    remember_token_expires_at && Time.now.utc < remember_token_expires_at
+  end
+
+  # These create and unset the fields required for remembering users between browser closes
+  def remember_me
+    remember_me_for 2.weeks
+  end
+
+  def remember_me_for(time)
+    remember_me_until time.from_now.utc
+  end
+
+  def remember_me_until(time)
+    self.remember_token_expires_at = time
+    self.remember_token            = encrypt("#{email}--#{remember_token_expires_at}")
+    save(false)
+  end
+
+  def forget_me
+    self.remember_token_expires_at = nil
+    self.remember_token            = nil
+    save(false)
+  end
+
+  # Returns true if the user has just been activated.
+  def recently_activated?
+    @activated
+  end
+
+  def ui_deletable?(current_user = self)
+    !self.superuser and User.count > 1 and (current_user.nil? or self.id != current_user.id)
+  end
+
+  def create_reset_code
+    @reset = true
+    code = Digest::SHA1.hexdigest( Time.now.to_s.split(//).sort_by {rand}.join )
+    self.attributes = {:reset_code => code[0..6]}
+    save(false)
+  end
+
+  def recently_reset?
+    @reset
+  end
+
+  def delete_reset_code
+    self.attributes = {:reset_code => nil}
+    save(false)
+  end
+
+protected
+
+  # before filter
+  def encrypt_password
+    return if password.blank?
+    self.salt = Digest::SHA1.hexdigest("--#{Time.now.to_s}--#{login}--") if new_record?
+    self.crypted_password = encrypt(password)
+  end
+
+  def password_required?
+    crypted_password.blank? || !password.blank?
+  end
+
+  def make_activation_code
+    self.deleted_at = nil
+    self.activation_code = Digest::SHA1.hexdigest( Time.now.to_s.split(//).sort_by {rand}.join )
+  end
+
+  def do_activate
+    @activated = true
+    self.activated_at = Time.now.utc
+    self.deleted_at = self.activation_code = nil
+  end
+
+end