typus 1.0.0.pre8 → 1.0.0.pre9

data/app/models/admin/fake_user.rb

@@ -1,46 +0,0 @@
-module Admin
-
-  class FakeUser
-
-    def id
-      0
-    end
-
-    def can?(*args)
-      true
-    end
-
-    def cannot?(*args)
-      !can?(*args)
-    end
-
-    def is_root?
-      true
-    end
-
-    def is_not_root?
-      !is_root?
-    end
-
-    def resources
-      Typus::Configuration.roles[role].compact
-    end
-
-    def applications
-      Typus.applications
-    end
-
-    def application(name)
-      Typus.application(name)
-    end
-
-    def role
-      Typus.master_role
-    end
-
-    def name
-    end
-
-  end
-
-end

data/lib/generators/templates/model.yml

@@ -1,10 +0,0 @@
-admin:
-  first_name: Admin
-  last_name: Example
-  role: admin
-  email: admin@example.com
-  status: true
-  token: 1A2B3C4D5E6F
-  salt: admin
-  crypted_password: <%= Digest::SHA1.hexdigest("--admin--#{12345678}--") %>
-  preferences: { :locale => :en }

data/lib/typus/authentication.rb

@@ -1,241 +0,0 @@
-module Typus
-
-  module Authentication
-
-    protected
-
-    #--
-    # Require login checks if the user is logged on Typus, otherwise
-    # is sent to the sign in page with a :back_to param to return where
-    # she tried to go.
-    #++
-    def authenticate
-      case Typus.authentication
-      when :none
-        authenticate_via_none
-      when :http_basic
-        authenticate_via_http_basic
-      when :session
-        authenticate_via_session
-      end
-    end
-
-    def authenticate_via_none
-      @current_user = Admin::FakeUser.new
-    end
-
-    def authenticate_via_http_basic
-      @current_user = Admin::FakeUser.new
-      authenticate_or_request_with_http_basic(Typus.admin_title) do |user_name, password|
-        user_name == Typus.username && password == Typus.password
-      end
-    end
-
-    def authenticate_via_session
-      if session[:typus_user_id]
-        current_user
-      else
-        back_to = request.env['PATH_INFO'] unless [admin_dashboard_path, admin_path].include?(request.env['PATH_INFO'])
-        redirect_to new_admin_session_path(:back_to => back_to)
-      end
-    end
-
-    #--
-    # Return the current user. If role does not longer exist on the
-    # system @current_user will be signed out from Typus.
-    #++
-    def current_user
-
-      @current_user = Typus.user_class.find(session[:typus_user_id])
-
-      unless Typus::Configuration.roles.has_key?(@current_user.role)
-        raise _t("Role does no longer exists.")
-      end
-
-      unless @current_user.status
-        back_to = (request.env['REQUEST_URI'] == admin_dashboard_path) ? nil : request.env['REQUEST_URI']
-        raise _t("Typus user has been disabled.")
-      end
-
-      I18n.locale = @current_user.preferences[:locale]
-
-    rescue Exception => error
-      flash[:notice] = error.message
-      session[:typus_user_id] = nil
-      redirect_to new_admin_session_path(:back_to => back_to)
-    end
-
-    #--
-    # Action is available on: edit, update, toggle and destroy
-    #++
-    def check_if_user_can_perform_action_on_user
-
-      return unless Typus.authentication.eql?(:session)
-
-      return unless @item.kind_of?(Typus.user_class)
-
-      current_user = (@current_user == @item)
-
-      message = case params[:action]
-                when 'edit'
-
-                  # Only admin and owner of Typus User can edit.
-                  if @current_user.is_not_root? && !current_user
-                    _t("As you're not the admin or the owner of this record you cannot edit it.")
-                  end
-
-                when 'update'
-
-                  # current_user cannot change her role.
-                  if current_user && !(@item.role == params[@object_name][:role])
-                    _t("You can't change your role.")
-                  end
-
-                when 'toggle'
-
-                  # Only admin can toggle typus user status, but not herself.
-                  if @current_user.is_root? && current_user
-                    _t("You can't toggle your status.")
-                  elsif @current_user.is_not_root?
-                    _t("You're not allowed to toggle status.")
-                  end
-
-                when 'destroy'
-
-                  # Admin can remove anything except herself.
-                  if @current_user.is_root? && current_user
-                    _t("You can't remove yourself.")
-                  elsif @current_user.is_not_root?
-                    _t("You're not allowed to remove Typus Users.")
-                  end
-
-                end
-
-      if message
-        flash[:notice] = message
-        redirect_to set_path
-      end
-
-    end
-
-    #--
-    # This method checks if the user can perform the requested action.
-    # It works on models, so its available on the admin_controller.
-    #++
-    def check_if_user_can_perform_action_on_resources
-
-      return unless Typus.authentication.eql?(:session)
-
-      message = case params[:action]
-                when 'index', 'show'
-                  "%{current_user_role} can't display items."
-                when 'destroy'
-                  "%{current_user_role} can't delete this item."
-                else
-                  "%{current_user_role} can't perform action. (%{action})"
-                end
-
-      message = _t(message,
-                  :current_user_role => @current_user.role.capitalize,
-                  :action => params[:action])
-
-      unless @current_user.can?(params[:action], @resource)
-        flash[:notice] = message
-        redirect_to set_path
-      end
-
-    end
-
-    #--
-    # This method checks if the user can perform the requested action.
-    # It works on a resource: git, memcached, syslog ...
-    #++
-    def check_if_user_can_perform_action_on_resource
-      return unless Typus.authentication.eql?(:session)
-
-      controller = params[:controller].extract_resource
-      action = params[:action]
-      unless @current_user.can?(action, controller.camelize, { :special => true })
-        render :text => "Not allowed!", :status => :unprocessable_entity
-      end
-    end
-
-    #--
-    # If item is owned by another user, we only can perform a
-    # show action on the item. Updated item is also blocked.
-    #
-    #   before_filter :check_resource_ownership, :only => [ :edit, :update, :destroy,
-    #                                                       :toggle, :position,
-    #                                                       :relate, :unrelate ]
-    #++
-    def check_resource_ownership
-
-      return unless Typus.authentication.eql?(:session)
-
-      # By-pass if current_user is root.
-      return if @current_user.is_root?
-
-      condition_typus_users = @item.respond_to?(Typus.relationship) && !@item.send(Typus.relationship).include?(@current_user)
-      condition_typus_user_id = @item.respond_to?(Typus.user_fk) && !@item.owned_by?(@current_user)
-
-      if condition_typus_users || condition_typus_user_id
-         alert = _t("You don't have permission to access this item.")
-         redirect_to set_path, :alert => alert
-      end
-
-    end
-
-    def check_resource_ownerships
-
-      return unless Typus.authentication.eql?(:session)
-
-      # By-pass if current_user is root.
-      return if @current_user.is_root?
-
-      # Show only related items it @resource has a foreign_key (Typus.user_fk)
-      # related to the logged user.
-      if @resource.typus_user_id?
-        condition = { Typus.user_fk => @current_user }
-        @conditions = @resource.merge_conditions(@conditions, condition)
-      end
-
-    end
-
-    def check_ownership_of_referal_item
-      return unless Typus.authentication.eql?(:session)
-
-      return unless params[:resource] && params[:resource_id]
-      klass = params[:resource].classify.constantize
-      return if !klass.typus_user_id?
-      item = klass.find(params[:resource_id])
-      raise "You're not owner of this record." unless item.owned_by?(@current_user) || @current_user.is_root?
-    end
-
-    def set_attributes_on_create
-      return unless Typus.authentication.eql?(:session)
-      if @resource.typus_user_id?
-        @item.attributes = { Typus.user_fk => @current_user.id }
-      end
-    end
-
-    def set_attributes_on_update
-      return unless Typus.authentication.eql?(:session)
-      if @resource.typus_user_id? && @current_user.is_not_root?
-        @item.update_attributes(Typus.user_fk => @current_user.id)
-      end
-    end
-
-    #--
-    # Reload @current_user when updating to see flash message in the
-    # correct locale.
-    #++
-    def reload_locales
-      return unless Typus.authentication.eql?(:session)
-      if @resource.eql?(Typus.user_class)
-        I18n.locale = @current_user.reload.preferences[:locale]
-      end
-    end
-
-  end
-
-end

data/lib/vendor/paginator.rb

@@ -1,143 +0,0 @@
-require 'forwardable'
-
-class Paginator
-
-  VERSION = '1.1.1'
-
-  include Enumerable
-
-  class ArgumentError < ::ArgumentError; end
-  class MissingCountError < ArgumentError; end
-  class MissingSelectError < ArgumentError; end
-
-  attr_reader :per_page, :count
-
-  # Instantiate a new Paginator object
-  #
-  # Provide:
-  # * A total count of the number of objects to paginate
-  # * The number of objects in each page
-  # * A block that returns the array of items
-  #   * The block is passed the item offset
-  #     (and the number of items to show per page, for
-  #     convenience, if the arity is 2)
-  def initialize(count, per_page, &select)
-    @count, @per_page = count, per_page
-    unless select
-      raise MissingSelectError, "Must provide block to select data for each page"
-    end
-    @select = select
-  end
-
-  # Total number of pages
-  def number_of_pages
-     (@count / @per_page).to_i + (@count % @per_page > 0 ? 1 : 0)
-  end
-
-  # First page object
-  def first
-    page 1
-  end
-
-  # Last page object
-  def last
-    page number_of_pages
-  end
-
-  def each
-    1.upto(number_of_pages) do |number|
-      yield page(number)
-    end
-  end
-
-  # Retrieve page object by number
-  def page(number)
-    number = (n = number.to_i) > 0 ? n : 1
-    Page.new(self, number, lambda {
-      offset = (number - 1) * @per_page
-      args = [offset]
-      args << @per_page if @select.arity == 2
-      @select.call(*args)
-    })
-  end
-
-  # Page object
-  #
-  # Retrieves items for a page and provides metadata about the position
-  # of the page in the paginator
-  class Page
-
-    include Enumerable
-
-    attr_reader :number, :pager
-
-    def initialize(pager, number, select) #:nodoc:
-      @pager, @number = pager, number
-      @offset = (number - 1) * pager.per_page
-      @select = select
-    end
-
-    # Retrieve the items for this page
-    # * Caches
-    def items
-      @items ||= @select.call
-    end
-
-    # Does this page have any items?
-    def empty?
-      items.empty?
-    end
-
-    # Checks to see if there's a page before this one
-    def prev?
-      @number > 1
-    end
-
-   # Get previous page (if possible)
-   def prev
-     @pager.page(@number - 1) if prev?
-   end
-
-    # Checks to see if there's a page after this one
-    def next?
-      @number < @pager.number_of_pages
-    end
-
-    # Get next page (if possible)
-   def next
-     @pager.page(@number + 1) if next?
-   end
-
-    # The "item number" of the first item on this page
-    def first_item_number
-      1 + @offset
-    end
-
-    # The "item number" of the last item on this page
-    def last_item_number
-      if next?
-        @offset + @pager.per_page
-      else
-        @pager.count
-      end
-    end
-
-    def ==(other) #:nodoc:
-      @pager == other.pager && self.number == other.number
-    end
-
-    def each(&block)
-      items.each(&block)
-    end
-
-    def method_missing(meth, *args, &block) #:nodoc:
-      if @pager.respond_to?(meth)
-        @pager.__send__(meth, *args, &block)
-      else
-        super
-      end
-    end
-
-  end
-
-end

data/test/factories/assets.rb

@@ -1,5 +0,0 @@
-Factory.define :asset do |f|
-  f.caption "Caption"
-  f.resource_type Post
-  f.resource_id 1
-end