Class: Padrino::Generators::AdminApp

### Home Classes Methods

### In Files

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

### Parent

Thor::Group

### Methods

- ::banner
- ::source_root
- #create_admin
- #source_paths

### Included Modules

- Thor::Actions
- Padrino::Generators::Actions
- Padrino::Generators::Admin::Actions

### Files

- README.rdoc

### Class/Module Index

Quicksearch

- Padrino
- Padrino::Admin
- Padrino::Admin::AccessControl
- Padrino::Admin::AccessControl::Authorization
- Padrino::Admin::AccessControl::Base
- Padrino::Admin::AccessControl::ProjectModule
- Padrino::Admin::AccessControlError
- Padrino::Admin::Generators
- Padrino::Admin::Generators::Orm
- Padrino::Admin::Generators::OrmError
- Padrino::Admin::Helpers
- Padrino::Admin::Helpers::AuthenticationHelpers
- Padrino::Admin::Helpers::ViewHelpers
- Padrino::Generators
- Padrino::Generators::Admin
- Padrino::Generators::Admin::Actions
- Padrino::Generators::AdminApp
- Padrino::Generators::AdminPage

No matching classes.

# Padrino::Generators::AdminApp

Defines the generator for creating a new admin app.

### Public Class Methods

banner() click to toggle source

Defines the "banner" text for the CLI.

    # File lib/padrino-admin/generators/admin_app.rb, line 14
    def self.banner; "padrino-gen admin"; end

source_root() click to toggle source

Define the source template root

    # File lib/padrino-admin/generators/admin_app.rb, line 12
    def self.source_root; File.expand_path(File.dirname(__FILE__)); end

### Public Instance Methods

create_admin() click to toggle source

Copies over the Padrino base admin application.

    # File lib/padrino-admin/generators/admin_app.rb, line 41
    def create_admin
      self.destination_root = options[:root]
      if in_app_root?
        unless supported_orm.include?(orm)
          say "<= At the moment, Padrino only supports #{supported_orm.join(" or ")}. Sorry!", :yellow
          raise SystemExit
        end

        tmp_ext = options[:renderer] || fetch_component_choice(:renderer)
        unless supported_ext.include?(tmp_ext.to_sym)
          say "<= Your are using '#{tmp_ext}' and for admin we only support '#{supported_ext.join(', ')}'. Please use -e haml or -e erb or -e slim", :yellow
          raise SystemExit
        end

        # Get the app's namespace.
        @app_name = fetch_app_name

        # setup admin app name
        @admin_name = options[:admin_name].classify
        @admin_path = options[:admin_name].underscore

        store_component_choice(:admin_renderer, tmp_ext)

        self.behavior = :revoke if options[:destroy]

        empty_directory destination_root(@admin_path)

        # Setup Admin Model
        @model_name     = options[:admin_model].classify
        @model_singular = @model_name.underscore
        @model_plural   = @model_singular.pluralize

        directory "templates/app",       destination_root(@admin_path)
        directory "templates/assets",    destination_root("public", @admin_path)
        template  "templates/app.rb.tt", destination_root(@admin_path + "/app.rb")
        inject_into_file destination_root('config/apps.rb'), "\nPadrino.mount(\"#{@app_name}::#{@admin_name}\", :app_file => Padrino.root('#{@admin_path}/app.rb')).to(\"/#{@admin_path}\")\n", :before => /^Padrino.mount.*\.to\('\/'\)$/
        unless options[:destroy]
          insert_middleware 'ActiveRecord::ConnectionAdapters::ConnectionManagement', @admin_path if [:minirecord, :activerecord].include?(orm)
        end

        params = [
          @model_singular, "name:string", "surname:string", "email:string", "crypted_password:string", "role:string",
          "-a=#{options[:models_path]}",
          "-r=#{options[:root]}"
        ]
        params << "-s" if options[:skip_migration]
        params << "-d" if options[:destroy]

        Padrino::Generators::Model.start(params)
        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 => :password_field },
          { :name => :password_confirmation, :field_type => :password_field },
          { :name => :role,                  :field_type => :text_field }
        ]

        unless options[:destroy]
          admin_app = Padrino::Generators::AdminPage.new([@model_singular], :root => options[:root], :destroy => options[:destroy], :admin_model => @model_singular, :admin_name => @admin_name)
          admin_app.default_orm = Padrino::Admin::Generators::Orm.new(@model_singular, orm, columns, column_fields)
          admin_app.invoke_all
        end

        # TODO See this, there's something wrong it's not being applied properly or something because test_account_model_generator last test fails.
        template "templates/account/#{orm}.rb.tt", destination_root("models", "#{@model_singular}.rb"), :force => true

        if File.exist?(destination_root("db/seeds.rb"))
          run "mv #{destination_root('db/seeds.rb')} #{destination_root('db/seeds.old')}"
        end
        template "templates/account/seeds.rb.tt", destination_root("db/seeds.rb")

        empty_directory destination_root(@admin_path+"/controllers")
        empty_directory destination_root(@admin_path+"/views")
        empty_directory destination_root(@admin_path+"/views/base")
        empty_directory destination_root(@admin_path+"/views/layouts")
        empty_directory destination_root(@admin_path+"/views/sessions")
        empty_directory destination_root(@admin_path+"/views/errors")

        template "templates/#{ext}/app/base/index.#{ext}.tt",          destination_root(@admin_path+"/views/base/index.#{ext}")
        template "templates/#{ext}/app/layouts/application.#{ext}.tt", destination_root(@admin_path+"/views/layouts/application.#{ext}")
        template "templates/#{ext}/app/layouts/error.#{ext}.tt",       destination_root(@admin_path+"/views/layouts/error.#{ext}")
        template "templates/#{ext}/app/sessions/new.#{ext}.tt",        destination_root(@admin_path+"/views/sessions/new.#{ext}")
        # Custom error.
        template "templates/#{ext}/app/errors/403.#{ext}.tt",          destination_root(@admin_path+"/views/errors/403.#{ext}")
        template "templates/#{ext}/app/errors/404.#{ext}.tt",          destination_root(@admin_path+"/views/errors/404.#{ext}")
        template "templates/#{ext}/app/errors/500.#{ext}.tt",          destination_root(@admin_path+"/views/errors/500.#{ext}")

        unless options[:destroy]
          add_project_module @model_plural
          require_dependencies('bcrypt')
        end

        # A nicer select box.
        # TODO FIXME This doesn't make much sense in here. Review.
        # gsub_file destination_root("admin/views/#{@model_plural}/_form.#{ext}"), "f.text_field :role, :class => :text_field", "f.select :role, :options => access_control.roles"

        # Destroy account only if not logged in.
        gsub_file destination_root(@admin_path+"/controllers/#{@model_plural}.rb"), "if #{@model_singular}.destroy", "if #{@model_singular} != current_account && #{@model_singular}.destroy"
        return if self.behavior == :revoke

        instructions = []
        instructions << "Run 'bundle'"
        if [:activerecord, :datamapper, :sequel].include?(orm)
          instructions << "Run 'bundle exec rake db:create' if you have not created a database yet"
          instructions << "Run 'bundle exec rake db:migrate'"
        end
        instructions << "Now repeat after me... 'ohm mani padme hum', 'ohm mani padme hum'... :)" if orm == :ohm
        instructions << "Run 'bundle exec rake db:seed'"
        instructions << "Visit the admin panel in the browser at '/#{@admin_path}'"
        instructions.map! { |i| "  #{instructions.index(i)+1}) #{i}" }

        say
        say "="*65, :green
        say "The admin panel has been mounted! Next, follow these steps:", :green
        say "="*65, :green
        say instructions.join("\n")
        say "="*65, :green
        say
      else
        say "You are not at the root of a Padrino application! (config/boot.rb not found)"
      end
    end

source_paths() click to toggle source

Look for custom template files in a generators folder under the project root.

    # File lib/padrino-admin/generators/admin_app.rb, line 22
    def source_paths
      if File.exist? destination_root('generators', 'templates')
        ["#{destination_root('generators')}", File.expand_path(File.dirname(__FILE__))]
      else
        [File.expand_path(File.dirname(__FILE__))]
      end
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.