padrino-admin 0.6.3 → 0.6.7

data/README.rdoc

@@ -75,6 +75,22 @@ Account with role <tt>editor</tt> can manage <tt>only</tt> post/comments because
 Another good fature of Padrino admin is that when you define a <tt>Project Module</tt> role you also build the Menu Tree of the Admin. 
 Trust us that in future you appreciate so much this feature.
 
+=== Admin Uploads
+
+Padrino admin has a builtin upload managment that leave you to be free as possible.
+
+  fun-test$ padrino-gen admin_uploader
+  fun-test$ rake dm:auto:upgrade # or ar:migrate
+
+Finish! Now you can browse into your admin and you can see a new menu called +upload+ where you can see all your uploads,
+upload other file, delete ...
+
+All upload definitions are defined in lib/uploader.rb, here you can preproces your attachments (like resize) or manage versions.
+
+See http://github.com/jnicklas/carrierwave
+
+... here some example howto attach uploads to any model ...
+
 == Copyright
 
 Copyright (c) 2010 Padrino. See LICENSE for details.

data/VERSION

@@ -1 +1 @@
-0.6.3
+0.6.7

data/lib/padrino-admin.rb

@@ -4,12 +4,31 @@ require 'padrino-core'
 require 'padrino-gen'
 
 Dir[File.dirname(__FILE__) + '/padrino-admin/*.rb'].each {|file| require file }
-Dir[File.dirname(__FILE__) + '/padrino-admin/{helpers,adapters,ext_js,generators,utils}/*.rb'].each {|file| require file }
+Dir[File.dirname(__FILE__) + '/padrino-admin/{helpers,orm,generators,middleware,utils}/*.rb'].each {|file| require file }
 
-Padrino::Application.send(:cattr_accessor, :access_control)
-Padrino::Application.send(:access_control=, Class.new(Padrino::AccessControl::Base))
+##
+# We need to apply Padrino::Admin::Utils::Extensions
+# 
 String.send(:include, Padrino::Admin::Utils::Crypt)
 String.send(:include, Padrino::Admin::Utils::Literal)
 
-# Load our locales
-I18n.load_path += Dir["#{File.dirname(__FILE__)}/padrino-admin/locale/**/*.yml"]
+##
+# We need to add to Padrino::Application a +access_control+ class
+# 
+Padrino::Application.send(:cattr_accessor, :access_control)
+Padrino::Application.send(:access_control=, Class.new(Padrino::AccessControl::Base))
+
+##
+# If CarrierWave is defined we set the root directory
+# 
+CarrierWave.root = Padrino.root if defined?(CarrierWave)
+
+##
+# Load our Padrino::Admin locales
+# 
+I18n.load_path += Dir["#{File.dirname(__FILE__)}/padrino-admin/locale/**/*.yml"]
+
+##
+# Load our databases extensions
+# 
+Padrino::Admin::Orm.register!

data/lib/padrino-admin/access_control.rb

@@ -1,14 +1,14 @@
 module Padrino
-  
+
   class AccessControlError < StandardError; end
-  
+
+  ##
   # This module give to a padrino application an access control functionality like:
   #   
   #   class EcommerceDemo < Padrino::Application
   #     enable :authentication
   #     set :login_page, "/login" # or your login page
   #     enable :store_location # if you want know what is the page that need authentication
-  #     set :use_orm, :active_record # or :data_mapper, :mongo_mapper
   # 
   #     access_control.roles_for :any do
   #       role.require_login "/cart"
@@ -17,7 +17,7 @@ module Padrino
   #     end
   #   end
   # 
-  # In the EcommerceDemo, we <tt>only</tt> require logins for all paths that start with "/cart" like:
+  # In the EcommerceDemo, we +only+ require logins for all paths that start with "/cart" like:
   # 
   #   - "/cart/add"
   #   - "/cart/empty"
@@ -30,7 +30,7 @@ module Padrino
   #   - "/account/update"
   # 
   # but if we call "/account/create" we don't need to be logged in our site for do that.
-  # In EcommerceDemo example we set <tt>redirect_back_or_default</tt> so if a <tt>unlogged</tt> 
+  # In EcommerceDemo example we set +redirect_back_or_default+ so if a +unlogged+ 
   # user try to access "/account/edit" will be redirected to "/login" when login is done will be 
   # redirected to "/account/edit".
   # 
@@ -62,9 +62,9 @@ module Padrino
   #   If a user logged with role editor can:
   # 
   #   - Access to all paths that start with "/session" like "/sessions/{new,create}"
-  #   - Access <tt>only</tt> to paths that start with "/posts" like "/post/{new,edit,destroy}"
+  #   - Access +only+ to paths that start with "/posts" like "/post/{new,edit,destroy}"
   # 
-  # Finally we have another good fatures, the possibility in the same time we build role build also <tt>tree</tt>.
+  # Finally we have another good fatures, the possibility in the same time we build role build also +tree+.
   # Figure this scenario: in my admin every account need their own menu, so an Account with role editor have
   # a menu different than an Account with role admin.
   # 
@@ -123,14 +123,15 @@ module Padrino
   #
   module AccessControl
 
+    ##
+    # Method used by Padrino::Application when we register the extension
+    # 
     def self.registered(app)
+      app.set :session_id, "_padrino_#{File.basename(Padrino.root)}_#{app.app_name}".to_sym
       app.helpers Padrino::Admin::Helpers
       app.before { login_required }
-      if app.respond_to?(:use_orm)
-        Padrino::Admin::Adapters.register(app.use_orm)
-      else
-        raise Padrino::ApplicationSetupError, "You must define in your app the setting :use_orm!"
-      end
+      app.use Padrino::Admin::Middleware::FlashMiddleware, app.session_id  # make sure that is the same of session_name in helpers
+      Padrino::Admin::Orm.extend_account!
     end
 
     class Base
@@ -142,8 +143,10 @@ module Padrino
           base.send(:cattr_reader, :cache)
           super
         end
-        
+
+        ##
         # We map project modules for a given role or roles
+        # 
         def roles_for(*roles, &block)
           raise Padrino::AccessControlError, "Role #{role} must be present and must be a symbol!" if roles.any? { |r| !r.kind_of?(Symbol) } || roles.empty?
           raise Padrino::AccessControlError, "You can't merge :any with other roles"              if roles.size > 1 && roles.any? { |r| r == :any }
@@ -157,8 +160,10 @@ module Padrino
           end
         end
 
+        ##
         # Returns (allowed && denied paths).
         # If an account given we also give allowed & denied paths for their role.
+        # 
         def auths(account=nil)
           if account
             cache[account.id] ||= Auths.new(@authorizations, @mappers, account)
@@ -167,12 +172,12 @@ module Padrino
           end
         end
       end
-    end
+    end # Base
 
-    class Auths
+    class Auths #:nodoc:
       attr_reader :allowed, :denied, :project_modules
 
-      def initialize(authorizations, mappers=nil, account=nil)
+      def initialize(authorizations, mappers=nil, account=nil) #:nodoc:
         @allowed, @denied = [], []
         unless authorizations.empty?
           @allowed = authorizations.collect(&:allowed).flatten
@@ -190,38 +195,49 @@ module Padrino
         @denied.uniq!
       end
 
+      ##
+      # Return true if the requested path (like request.path_info) is allowed.
+      # 
       def can?(request_path)
         return true if @allowed.empty?
         request_path = "/" if request_path.blank?
         @allowed.any? { |path| request_path =~ /^#{path}/ } && !cannot?(request_path)
       end
 
+      ##
+      # Return true if the requested path (like request.path_info) is +not+ allowed.
+      # 
       def cannot?(request_path)
         return false if @denied.empty?
         request_path = "/" if request_path.blank?
         @denied.any? { |path| request_path =~ /^#{path}/ }
       end
-
-    end
+    end # Auths
 
     class Authorization
       attr_reader :allowed, :denied
 
-      def initialize(&block)
+      def initialize(&block) #:nodoc:
         @allowed = []
         @denied  = []
         yield self
       end
 
+      ##
+      # Allow a specified path
+      # 
       def allow(path)
         @allowed << path unless @allowed.include?(path)
       end
 
+      ##
+      # Deny a specified path
+      # 
       def require_login(path)
         @denied << path unless @denied.include?(path)
       end
       alias :deny :require_login
-    end
+    end # Authorization
 
     class Mapper
       attr_reader :project_modules, :roles, :denied
@@ -235,75 +251,95 @@ module Padrino
         yield(self, @account)
       end
 
+      ##
       # Create a new project module
+      # 
       def project_module(name, path=nil, &block)
         @project_modules << ProjectModule.new(name, path, &block)
       end
 
+      ##
       # Globally allow an paths for the current role
+      # 
       def allow(path)
         @allowed << path unless @allowed.include?(path)
       end
 
+      ##
       # Globally deny an pathsfor the current role
+      # 
       def deny(path)
         @denied << path unless @allowed.include?(path)
       end
 
+      ##
       # Return true if role is included in given roles
+      # 
       def allowed?
         @roles.any? { |r| r == @account.role.to_s.downcase.to_sym }
       end
 
+      ##
       # Return allowed paths
+      # 
       def allowed
         @project_modules.each { |pm| @allowed.concat(pm.allowed)  }
         @allowed.uniq
       end
-    end
+    end # Mapper
 
     class ProjectModule
       attr_reader :name, :menus, :path
 
-      def initialize(name, path=nil, options={}, &block)#:nodoc:
+      def initialize(name, path=nil, options={}, &block) #:nodoc:
         @name     = name
         @options  = options
         @allowed  = []
         @menus    = []
         @path     = path
         @allowed << path if path
-        yield self
+        yield self if block_given?
       end
 
+      ##
       # Build a new menu and automaitcally add the action on the allowed actions.
+      # 
       def menu(name, path=nil, options={}, &block)
         @menus << Menu.new(name, path, options, &block)
       end
 
+      ##
       # Return allowed controllers
+      # 
       def allowed
         @menus.each { |m| @allowed.concat(m.allowed) }
         @allowed.uniq
       end
 
+      ##
       # Return the original name or try to translate or humanize the symbol
+      # 
       def human_name
         @name.is_a?(Symbol) ? I18n.t("admin.menus.#{@name}", :default => @name.to_s.humanize) : @name
       end
 
+      ##
       # Return symbol for the given project module
+      # 
       def uid
         @name.to_s.downcase.gsub(/[^a-z0-9]+/, '').gsub(/-+$/, '').gsub(/^-+$/, '').to_sym
       end
 
+      ##
       # Return ExtJs Config for this project module
+      # 
       def config
         options = @options.merge(:text => human_name)
         options.merge!(:menu => @menus.collect(&:config)) if @menus.size > 0
-        options.merge!(:handler => ExtJs::Variable.new("function(){ Admin.app.load('#{path}') }")) if @path
+        options.merge!(:handler => Padrino::Admin::Config::Variable.new("function(){ Admin.app.load('#{path}') }")) if @path
         options
       end
-    end
+    end # ProjectModule
 
     class Menu
       attr_reader :name, :options, :items, :path
@@ -318,38 +354,48 @@ module Padrino
         yield self if block_given?
       end
 
+      ##
       # Add a new submenu to the menu
+      # 
       def add(name, path=nil, options={}, &block)
         @items << Menu.new(name, path, options, &block)
       end
 
+      ##
       # Return allowed controllers
+      # 
       def allowed
         @items.each { |i| @allowed.concat(i.allowed) }
         @allowed.uniq
       end
 
+      ##
       # Return the original name or try to translate or humanize the symbol
+      # 
       def human_name
         @name.is_a?(Symbol) ? I18n.t("admin.menus.#{@name}", :default => @name.to_s.humanize) : @name
       end
 
+      ##
       # Return a unique id for the given project module
+      # 
       def uid
         @name.to_s.downcase.gsub(/[^a-z0-9]+/, '').gsub(/-+$/, '').gsub(/^-+$/, '').to_sym
       end
 
+      ##
       # Return ExtJs Config for this menu
+      # 
       def config
         if @path.blank? && @items.empty?
           options = human_name
         else
           options = @options.merge(:text => human_name)
           options.merge!(:menu => @items.collect(&:config)) if @items.size > 0
-          options.merge!(:handler => ExtJs::Variable.new("function(){ Admin.app.load('#{path}') }")) if @path
+          options.merge!(:handler => "function(){ Admin.app.load('#{path}') }".to_l) if @path
         end
         options
       end
-    end
-  end
-end
+    end # Menu
+  end # AccessControl
+end # Padrino

data/lib/padrino-admin/{ext_js/column_store.rb → column_store.rb}

@@ -1,6 +1,8 @@
 module Padrino
-  module ExtJs
+  module Admin
+    ##
     # Return column config, and store config/data for ExtJS ColumnModel and Store
+    # 
     class ColumnStore
       attr_reader :data
 
@@ -18,7 +20,7 @@ module Padrino
           # Try to reformat the dataIndex
           data_indexes = Array(column["dataIndex"]).collect do |data_index|
             if data_index =~ /\./ # if we have some like categories.names we use this
-              cols = data_index.split(".")
+              cols = data_index.split(".").collect(&:singularize)
               column["name"] ||= cols[0] + "[" + cols[1..-1].join("][") + "]" # accounts.name will be => accounts[name]
             else
               column["name"] ||= "#{table_name.singularize}[#{data_index}]"
@@ -34,6 +36,7 @@ module Padrino
           column["mapping"] ||= column["name"].sub(/\[/,"_").sub(/\]$/, "").sub(/\]\[/,"_")
 
           # Now is necessary for our columns an ID
+          # 
           # TODO: check duplicates here
           column["id"] = column["mapping"]
 
@@ -42,8 +45,12 @@ module Padrino
         end
       end
 
+      ##
       # Return an array config for build an Ext.grid.ColumnModel() config
-      def column_fields
+      # 
+      # If +json+ false we return the Hash object, else a JSON pretty printed string
+      # 
+      def column_fields(json=true)
         data = @data.map do |data|
           data     = data.dup
           editor   = parse_column_editor(data.delete("editor"))
@@ -54,21 +61,27 @@ module Padrino
           data.delete("mapping")
           data
         end
-        JSON.pretty_generate(data)
+        json ? JSON.pretty_generate(data) : data
       end
 
+      ##
       # Return an array config for build an Ext.data.GroupingStore()
-      def store_fields
+      # 
+      # If +json+ false we return the Hash object, else a JSON pretty printed string
+      # 
+      def store_fields(json=true)
         data = @data.map do |data|
           type = parse_store_renderer(data["renderer"])
           hash = { :name => data["dataIndex"] , :mapping => data["mapping"] }
           hash.merge!(type) if type
           hash
         end
-        JSON.pretty_generate(data)
+        json ? JSON.pretty_generate(data) : data
       end
 
+      ##
       # Return data for a custom collection for the ExtJS Ext.data.GroupingStore() json
+      # 
       def store_data_from(collection)
         collection.map do |c|
           @data.dup.inject({ "id" => c.id }) do |options, data|
@@ -78,20 +91,24 @@ module Padrino
         end
       end
 
+      ##
       # Return a searched and paginated data collection for the ExtJS Ext.data.GroupingStore() json
       # You can pass options like:
       # 
-      #   Examples
+      # If options has key +json+ false we return the Hash object, else a JSON string
+      # 
+      #   Examples:
       #   
-      #     store_data(params, :conditions => "found = 1")
       #     store_data(params, :include => :posts)
       # 
       def store_data(params={}, options={})
         # Some can tell me that this method made two identical queries one for count one for paginate.
         # We don't use the select count because in some circumstances require much time than select *.
-        params[:limit]     ||= 50
-        collection           = @model.ext_search(params, options)
-        { :results => store_data_from(collection.records), :count => collection.count }.to_json
+        params[:limit] ||= 50
+        json             = params.has_key?(:json) ? params.delete(:json) : true
+        collection       = @model.ext_search(params, options)
+        result           = { :results => store_data_from(collection.records), :count => collection.count }
+        json ? result.to_json : result
       end
 
       private
@@ -134,7 +151,6 @@ module Padrino
             when "upcase"       then { :renderer => "Ext.util.Format.uppercase".to_l }
           end
         end
-
-    end
-  end
-end
+    end # ColumnStore
+  end # Admin
+end # Padrino