padrino-admin 0.8.5 → 0.9.0

data/lib/padrino-admin/generators/actions.rb

@@ -8,6 +8,7 @@ module Padrino
         def orm
           fetch_component_choice(:orm).to_sym rescue :datamapper
         end
+        alias :adapter :orm
 
         ##
         # Tell us for now wich orm we support
@@ -19,16 +20,9 @@ module Padrino
         ##
         # Add access_control permission in our app.rb
         # 
-        def add_access_control_permission(admin, controller)
-          permission = indent(6, access_control(controller))
-          inject_into_file destination_root("#{admin}/app.rb"),  permission, :after => "access_control.roles_for :admin do |role, account|\n"
-        end
-
-        ##
-        # Add a simple permission (allow/deny) to our app.rb
-        # 
-        def add_permission(admin, permission)
-          inject_into_file destination_root("#{admin}/app.rb"),  indent(6, "\n#{permission}\n"), :after => "access_control.roles_for :admin do |role, account|\n"
+        def add_project_module(controller)
+          permission = indent(6, "role.project_module :#{controller}, \"/#{controller}\"\n")
+          inject_into_file destination_root("/admin/app.rb"),  permission, :after => "access_control.roles_for :admin do |role, account|\n"
         end
 
         ##
@@ -38,21 +32,7 @@ module Padrino
           indent = ' ' * count
           content.lines.map { |line| line != "\n" ? indent+line : "\n" }.join
         end
-
-        private
-          ##
-          # For access control permissions
-          # 
-          def access_control(controller)
-            (<<-RUBY).gsub(/ {14}/,'')
-
-              role.project_module :#{controller} do |project|
-                project.menu :list, "/admin/#{controller}.js"
-                project.menu :new,  "/admin/#{controller}/new"
-              end
-            RUBY
-          end
-      end
-    end
+      end # Actions
+    end # Admin
   end # Generators
 end # Padrino

data/lib/padrino-admin/generators/admin_app.rb

@@ -6,9 +6,10 @@ module Padrino
       # Add this generator to our padrino-gen
       Padrino::Generators.add_generator(:admin, self)
 
-      # Define the source template root
+      # Define the source template root and themes
       def self.source_root; File.expand_path(File.dirname(__FILE__)); end
       def self.banner; "padrino-gen admin"; end
+      def self.themes; Dir[File.dirname(__FILE__) + "/templates/assets/stylesheets/themes/*"].map { |t| File.basename(t) }; end
 
       # Include related modules
       include Thor::Actions
@@ -20,6 +21,8 @@ module Padrino
       class_option :skip_migration, :aliases => "-s", :default => false, :type => :boolean
       class_option :root, :desc => "The root destination", :aliases => '-r', :default => ".", :type => :string
       class_option :destroy, :aliases => '-d', :default => false, :type => :boolean
+      class_option :name, :desc => "The app name", :aliases => '-a', :default => "Padrino Admin", :type => :string
+      class_option :theme, :desc => "Your admin theme: (#{self.themes.join(", ")})", :default => "default", :type => :string
 
       # Copies over the Padrino base admin application
       def create_admin
@@ -31,18 +34,46 @@ module Padrino
             raise SystemExit
           end
 
+          unless self.class.themes.include?(options[:theme])
+            say "<= You need to choose a theme from: #{self.class.themes.join(", ")}"
+            raise SystemExit
+          end
+
           self.behavior = :revoke if options[:destroy]
-          directory("app/", destination_root("admin"))
-          directory("assets/", destination_root("public", "admin"))
+
+          directory "templates/app",     destination_root("admin")
+          directory "templates/assets",  destination_root("public", "admin")
 
           Padrino::Generators::Model.dup.start([
             "account", "name:string", "surname:string", "email:string", "crypted_password:string", "salt:string", "role:string",
             "-r=#{options[:root]}", "-s=#{options[:skip_migration]}", "-d=#{options[:destroy]}"
           ])
 
-          insert_into_gemfile("haml")
-          template "templates/page/db/seeds.rb.tt", destination_root("/db/seeds.rb")
+          column = Struct.new(:name, :type)
+          columns = [:id, :name, :surname, :email].map { |col| column.new(col) }
+          column_fields = [
+            { :name => :name, :field_type => :text_field },
+            { :name => :surname, :field_type => :text_field },
+            { :name => :email, :field_type => :text_field },
+            { :name => :password, :field_type => :text_field },
+            { :name => :password_confirmation, :field_type => :text_field },
+            { :name => :role, :field_type => :text_field }
+          ]
+
+          admin_app = Padrino::Generators::AdminPage.new(["account"], :root => options[:root])
+          admin_app.orm = Padrino::Admin::Generators::Orm.new(:account, orm, columns, column_fields)
+          admin_app.invoke
+
+          template "templates/account/#{orm}.rb.tt",               destination_root("app", "models", "account.rb"), :force => true
+          template "templates/account/seeds.rb.tt",                destination_root("db/seeds.rb")
+          template "templates/erb/app/base/_sidebar.erb.tt",       destination_root("admin/views/base/_sidebar.erb")
+          template "templates/erb/app/base/index.erb.tt",          destination_root("admin/views/base/index.erb")
+          template "templates/erb/app/layouts/application.erb.tt", destination_root("admin/views/layouts/application.erb")
+          template "templates/erb/app/sessions/new.erb.tt",        destination_root("admin/views/sessions/new.erb")
+
+          add_project_module :accounts
           append_file destination_root("config/apps.rb"),  "\nPadrino.mount(\"Admin\").to(\"/admin\")"
+          gsub_file destination_root("admin/views/accounts/_form.erb"), "f.text_field :role, :class => :text_field", "f.select :role, :options => access_control.roles"
 
           return if self.behavior == :revoke
           say (<<-TEXT).gsub(/ {10}/,'')
@@ -51,7 +82,7 @@ module Padrino
           Admin has been successfully installed, now follow this steps:
           =================================================================
             1) Run migrations
-            2) That's all!!
+            2) Run padrino rake seed
           =================================================================
 
           TEXT
@@ -59,8 +90,6 @@ module Padrino
           say "You are not at the root of a Padrino application! (config/boot.rb not found)" and exit unless in_app_root?
         end
       end
-
-    end
-
-  end
-end
+    end # AdminApp
+  end # Generators
+end # Padrino

data/lib/padrino-admin/generators/admin_page.rb

@@ -2,6 +2,7 @@ module Padrino
   module Generators
 
     class AdminPage < Thor::Group
+      attr_accessor :orm
 
       # Add this generator to our padrino-gen
       Padrino::Generators.add_generator(:admin_page, self)
@@ -28,23 +29,16 @@ module Padrino
       def create_controller
         self.destination_root = options[:root]
         if in_app_root?
-          @model_name     = model.classify
-          @model_klass    = model.classify.constantize
-          @model_plural   = model.underscore.pluralize
-          @model_singular = model.underscore
-          self.behavior   = :revoke if options[:destroy]
-
-          template "templates/page/controller.rb.tt",     destination_root("/admin/controllers/#{@model_plural}.rb")
-          template "templates/page/views/_form.haml.tt",  destination_root("/admin/views/#{@model_plural}/_form.haml")
-          template "templates/page/views/edit.haml.tt",   destination_root("/admin/views/#{@model_plural}/edit.haml")
-          template "templates/page/views/grid.js.erb.tt", destination_root("/admin/views/#{@model_plural}/grid.js.erb")
-          template "templates/page/views/new.haml.tt",    destination_root("/admin/views/#{@model_plural}/new.haml")
-          template "templates/page/views/store.jml.tt",   destination_root("/admin/views/#{@model_plural}/store.jml")
-
-          add_access_control_permission("/admin", @model_plural)
-          # TODO: figure how to manage tests for sub apps.
-          # include_component_module_for(:test) if test?
-          # generate_controller_test(model.downcase.pluralize)
+          @orm ||= Padrino::Admin::Generators::Orm.new(model, adapter)
+          self.behavior = :revoke if options[:destroy]
+
+          template "templates/page/controller.rb.tt",    destination_root("/admin/controllers/#{@orm.name_plural}.rb")
+          template "templates/erb/page/_form.erb.tt",    destination_root("/admin/views/#{@orm.name_plural}/_form.erb")
+          template "templates/erb/page/edit.erb.tt",     destination_root("/admin/views/#{@orm.name_plural}/edit.erb")
+          template "templates/erb/page/index.erb.tt",    destination_root("/admin/views/#{@orm.name_plural}/index.erb")
+          template "templates/erb/page/new.erb.tt",      destination_root("/admin/views/#{@orm.name_plural}/new.erb")
+
+          add_project_module(@orm.name_plural)
         else
           say "You are not at the root of a Padrino application! (config/boot.rb not found)" and return unless in_app_root?
         end

data/lib/padrino-admin/generators/orm.rb

@@ -0,0 +1,85 @@
+module Padrino
+  module Admin
+    module Generators
+      class OrmError < StandardError; end
+      class Orm
+        attr_reader :klass_name, :klass, :name_plural, :name_singular, :orm
+
+        def initialize(name, orm, columns=nil, column_fields=nil)
+          name            = name.to_s
+          @klass_name     = name.classify
+          @klass          = name.classify.constantize rescue nil
+          @name_plural    = name.underscore.pluralize
+          @name_singular  = name.underscore
+          @orm            = orm.to_sym
+          @columns        = columns
+          @column_fields  = column_fields
+          raise OrmError, "Model #{name} not found!" if @columns.nil? && @klass.nil?
+        end
+
+        def field_type(type)
+          case type
+            when :integer, :float, :decimal   then :text_field
+            when :string                      then :text_field
+            when :text                        then :text_area
+            when :boolean                     then :check_box
+            else :text_field
+          end
+        end
+
+        def columns
+          @columns ||= case orm
+            when :activerecord then @klass.columns
+            when :datamapper   then @klass.properties
+            else raise OrmError, "Adapter #{orm} not yet supported!"
+          end
+        end
+
+        def column_fields
+          excluded_columns = %w[id created_at updated_at]
+          column_fields    = columns.dup
+          column_fields.reject! { |column| excluded_columns.include?(column.name.to_s) }
+          @column_fields ||= column_fields.map do |column|
+            { :name => column.name, :field_type => field_type(column.type) }
+          end
+        end
+
+        def all
+          "#{klass_name}.all"
+        end
+
+        def find(params=nil)
+          case orm
+            when :activerecord then "#{klass_name}.find(#{params})"
+            when :datamapper   then "#{klass_name}.get(#{params})"
+            else raise OrmError, "Adapter #{orm} not yet supported!"
+          end
+        end
+
+        def build(params=nil)
+          if params
+            "#{klass_name}.new(#{params})"
+          else
+            "#{klass_name}.new"
+          end
+        end
+
+        def save
+          "#{name_singular}.save"
+        end
+
+        def update_attributes(params=nil)
+          case orm
+            when :activerecord then "#{name_singular}.update_attributes(#{params})"
+            when :datamapper   then "#{name_singular}.update(#{params})"
+            else raise OrmError, "Adapter #{orm} not yet supported!"
+          end
+        end
+
+        def destroy
+          "#{name_singular}.destroy"
+        end
+      end # Orm
+    end # Generators
+  end # Admin
+end # Padrino

data/lib/padrino-admin/generators/templates/account/activerecord.rb.tt

@@ -0,0 +1,43 @@
+class Account < ActiveRecord::Base
+  attr_accessor :password
+
+  # Validations
+  validates_presence_of     :email, :role
+  validates_presence_of     :password,                   :if => :password_required
+  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       :email,    :within => 3..100
+  validates_uniqueness_of   :email,    :case_sensitive => false
+  validates_format_of       :email,    :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
+  validates_format_of       :role,     :with => /[A-Za-z]/
+
+  # Callbacks
+  before_save :generate_password
+
+  ##
+  # This method it's for authentication purpose
+  # 
+  def self.authenticate(email, password)
+    account = first(:conditions => { :email => email }) if email.present?
+    account && account.password_clean == password ? account : nil
+  end
+
+  ##
+  # This method it's used for retrive the original password.
+  # 
+  def password_clean
+    crypted_password.decrypt(salt)
+  end
+
+  private
+    def generate_password
+      return if password.blank?
+      self.salt = Digest::SHA1.hexdigest("--#{Time.now.to_s}--#{email}--") if new_record?
+      self.crypted_password = password.encrypt(self.salt)
+    end
+
+    def password_required
+      crypted_password.blank? || !password.blank?
+    end
+end

data/lib/padrino-admin/generators/templates/account/datamapper.rb.tt

@@ -0,0 +1,54 @@
+class Account
+  include DataMapper::Resource
+  include DataMapper::Validate
+  attr_accessor :password, :password_confirmation
+
+  # Properties
+  property :id,               Serial
+  property :name,             String
+  property :surname,          String
+  property :email,            String
+  property :crypted_password, String
+  property :salt,             String
+  property :role,             String
+
+  # Validations
+  validates_present      :email, :role
+  validates_present      :password,                          :if => :password_required
+  validates_present      :password_confirmation,             :if => :password_required
+  validates_length       :password, :min => 4, :max => 40,   :if => :password_required
+  validates_is_confirmed :password,                          :if => :password_required
+  validates_length       :email,    :min => 3, :max => 100
+  validates_is_unique    :email,    :case_sensitive => false
+  validates_format       :email,    :with => :email_address
+  validates_format       :role,     :with => /[A-Za-z]/
+
+  # Callbacks
+  before :save, :generate_password
+
+  ##
+  # This method it's for authentication purpose
+  # 
+  def self.authenticate(email, password)
+    account = first(:conditions => { :email => email }) if email.present?
+    account && account.password_clean == password ? account : nil
+  end
+
+  ##
+  # This method it's used for retrive the original password.
+  # 
+  def password_clean
+    crypted_password.decrypt(salt)
+  end
+
+  private
+    def generate_password
+      return if password.blank?
+      self.salt = Digest::SHA1.hexdigest("--#{Time.now.to_s}--#{email}--") if new?
+      self.crypted_password = password.encrypt(self.salt)
+    end
+
+    def password_required
+      crypted_password.blank? || !password.blank?
+    end
+end

data/lib/padrino-admin/generators/templates/{page/db → account}/seeds.rb.tt

@@ -10,16 +10,15 @@ password  = shell.ask "Tell me the password to use:"
 
 shell.say ""
 
-account = Account.create(:email => email, :password => password, :password_confirmation => password, :role => "admin")
+account = Account.create(:email => email, :name => "Foo", :surname => "Bar", :password => password, :password_confirmation => password, :role => "admin")
 
 if account.valid?
-  shell.say "Perfect! Your account was created."
-  shell.say ""
-  shell.say "Now you can start your server with padrino start and then login into /admin with:"
+  shell.say "================================================================="
+  shell.say "Account has been successfully created, now you can login with:"
+  shell.say "================================================================="
   shell.say "   email: #{email}"
   shell.say "   password: #{password}"
-  shell.say ""
-  shell.say "That's all!"
+  shell.say "================================================================="
 else
   shell.say "Sorry but some thing went worng!"
   shell.say ""

data/lib/padrino-admin/generators/{app/app.rb.tt → templates/app/app.rb}

@@ -9,30 +9,22 @@ class Admin < Padrino::Application
     # set :reload, false          # Reload application files (default in development)
     # set :default_builder, "foo" # Set a custom form builder (default 'StandardFormBuilder')
     # set :locale_path, "bar"     # Set path for I18n translations (default your_app/locales)
-    # enable :auto_locale         # Auto Set locale if url match /:locale/foo/bar (disabled by default)
     # disable :padrino_helpers    # Disables padrino markup helpers (enabled by default if present)
     # disable :padrino_mailer     # Disables padrino mailer (enabled by default if present)
     # disable :flash              # Disables rack-flash (enabled by default)
     # enable  :authentication     # Enable padrino-admin authentication (disabled by default)
-    # layout :foo                 # Layout can be in views/layouts/foo.ext or views/foo.ext (:application is default)
+    # layout  :my_layout          # Layout can be in views/layouts/foo.ext or views/foo.ext (default :application)
     # 
-    layout false
     enable  :authentication
     disable :store_location
     set :login_page, "/admin/sessions/new"
 
     access_control.roles_for :any do |role|
+      role.protect "/"
       role.allow "/sessions"
     end
 
     access_control.roles_for :admin do |role, account|
-
-      role.allow "/"
-
-      role.project_module :accounts do |project|
-        project.menu :list, "/admin/accounts.js"
-        project.menu :new,  "/admin/accounts/new"
-      end
     end
 
   end

data/lib/padrino-admin/generators/templates/app/controllers/base.rb

@@ -0,0 +1,7 @@
+Admin.controllers  :base do
+
+  get :index, :map => "(/)" do
+    render "base/index"
+  end
+
+end

data/lib/padrino-admin/generators/{app → templates/app}/controllers/sessions.rb

@@ -1,21 +1,21 @@
 Admin.controllers :sessions do
-  
+
   get :new do
-    render "/sessions/new"
+    render "/sessions/new", nil, :layout => false
   end
 
   post :create do
     if account = Account.authenticate(params[:email], params[:password])
       set_current_account(account)
-      redirect url_for(:index)
+      redirect url(:base, :index)
     else
-      flash[:notice] = "Login or password wrong."
-      redirect url_for(:sessions_new)
+      flash[:warning] = "Login or password wrong."
+      redirect url(:sessions, :new)
     end
   end
 
   get :destroy do
     set_current_account(nil)
-    render "/sessions/new"
+    redirect url(:sessions, :new)
   end
 end