padrino-admin 0.6.3 → 0.6.7

data/lib/padrino-admin/config.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'yaml'
+require 'erb'
+require 'json/pure' unless defined?(JSON) || defined?(JSON::Pure)
+
+module Padrino
+  module Admin
+    module Config
+
+      ##
+      # This class it's used for JSON variables.
+      # Normally if we convert this { :function => "alert('Test')" } will be:
+      # 
+      #   { "function": "alert('Test')" }
+      # 
+      # But if in our javascript need to "eval" this function is not possible because
+      # it's a string.
+      # 
+      # Using Padrino::Config::Variable the result will be:
+      # 
+      #   { "function" : alert('Test') }
+      # 
+      # Normally an ExtJs Variable can be handled with ExtJs Config like:
+      # 
+      #   function: !js alert('Test')
+      # 
+      class Variable < String
+        yaml_as "tag:yaml.org,2002:js"
+
+        def to_json(*a) #:nodoc:
+          self
+        end
+      end # Variable
+    end # Config
+  end # Admin
+end # Padrino

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

@@ -1,16 +1,71 @@
 module Padrino
   module Generators
     module Actions
-      # For access control permissions
-      def access_control(name)
-        (<<-RUBY)
-      role.project_module :#{name} do |project|
-        project.menu :list, "/admin/#{name}.js"
-        project.menu :new,  "/admin/#{name}/new"
+      ##
+      # Tell us if for our orm we need migrations
+      # 
+      def skip_migrations
+        skip_migration = case orm
+          when :activerecord then false
+          when :sequel       then false
+          else true
+        end
       end
 
-        RUBY
+      ##
+      # Tell us which orm we are using
+      # 
+      def orm
+        fetch_component_choice(:orm).to_sym rescue :datamapper
       end
+
+      ##
+      # Tell us for now wich orm we support
+      # 
+      def supported_orm
+        [:datamapper, :activerecord]
+      end
+
+      ##
+      # Add access_control permission in our app.rb
+      # 
+      def add_access_control_permission(admin, controller)
+        permission = indent(6, access_control(controller))
+        if options[:destroy] || !File.read(destination_root("#{admin}/app.rb")).include?(permission)
+          inject_into_file destination_root("#{admin}/app.rb"),  permission, :after => "access_control.roles_for :admin do |role, account|\n"
+        end
+      end
+
+      ##
+      # Add a simple permission (allow/deny) to our app.rb
+      # 
+      def add_permission(admin, permission)
+        if options[:destroy] || !File.read(destination_root("#{admin}/app.rb")).include?(permission)
+          inject_into_file destination_root("#{admin}/app.rb"),  indent(6, "\n#{permission}\n"), :after => "access_control.roles_for :admin do |role, account|\n"
+        end
+      end
+
+      ##
+      # Indent a content/string for the given spaces
+      # 
+      def indent(count, content)
+        indent = ' ' * count
+        content.map { |line| line != "\n" ? indent+line : "\n" }.join
+      end
+
+      private
+        ##
+        # For access control permissions
+        # 
+        def access_control(controller)
+          (<<-RUBY).gsub(/ {12}/,'')
+            
+            role.project_module :#{controller} do |project|
+              project.menu :list, "/admin/#{controller}.js"
+              project.menu :new,  "/admin/#{controller}/new"
+            end
+          RUBY
+        end
     end
   end
 end

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

@@ -8,58 +8,59 @@ module Padrino
 
       # Define the source template root
       def self.source_root; File.expand_path(File.dirname(__FILE__)); end
-      def self.banner; "padrino-gen backend"; end
+      def self.banner; "padrino-gen admin"; end
 
       # Include related modules
       include Thor::Actions
       include Padrino::Generators::Actions
 
-      desc "Description:\n\n\tpadrino-gen controller generates a new Padrino Admin"
+      desc "Description:\n\n\tpadrino-gen admin generates a new Padrino Admin"
 
-      class_option :root,    :aliases => '-r', :default => ".",     :type    => :string
+      class_option :root, :desc => "The root destination",    :aliases => '-r', :default => ".",     :type    => :string
       class_option :path,    :aliases => '-p', :type    => :string, :default => "admin"
       class_option :destroy, :aliases => '-d', :default => false,   :type    => :boolean
 
       # Copies over the Padrino base admin application
       def create_admin
-        if in_app_root?(options[:root])
+        self.destination_root = options[:root]
+        if in_app_root?
           @app_path = options[:path]
-          @orm = fetch_component_choice(:orm, options[:root]).to_sym rescue :datamapper
-          supported_orm = [:datamapper, :activerecord]
-          skip_migration = case @orm
-            when :activerecord then false
-            when :sequel       then false
-            else true
-          end
 
-          unless supported_orm.include?(@orm)
+          unless supported_orm.include?(orm)
             say "<= A the moment we only support #{supported_orm.join(" or ")}. Sorry!"
             raise SystemExit
           end
 
           self.behavior = :revoke if options[:destroy]
-          directory("app/", File.join(options[:path]))
+          directory("app/", destination_root(options[:path]))
 
           Padrino::Generators::Model.dup.start([
             "account", "name:string", "surname:string", "email:string", "crypted_password:string", "salt:string", "role:string",
-            "-r=#{options[:root]}", "-s=#{skip_migration}", "-d=#{options[:destroy]}"
+            "-r=#{options[:root]}", "-s=#{skip_migrations}", "-d=#{options[:destroy]}"
           ])
 
-          template "templates/db/seeds.rb.tt", app_root_path("/db/seeds.rb")
+          insert_into_gemfile("haml")
+
+          template "templates/page/db/seeds.rb.tt", destination_root("/db/seeds.rb")
 
-          if options[:destroy] || !File.read(app_root_path("config/apps.rb")).include?("Padrino.mount(\"Admin\").to(\"/#{@app_path}\")")
-            append_file app_root_path("config/apps.rb"),  "\nPadrino.mount(\"Admin\").to(\"/#{@app_path}\")"
+          if options[:destroy] || !File.read(destination_root("config/apps.rb")).include?("Padrino.mount(\"Admin\").to(\"/#{@app_path}\")")
+            append_file destination_root("config/apps.rb"),  "\nPadrino.mount(\"Admin\").to(\"/#{@app_path}\")"
           end
-          
+
           unless options[:destroy]
-            say ""
-            say "Your admin now is installed, now follow this steps:"
-            say ""
-            say "   - edit your config/database.rb"
-            say "   - run padrino rake -T and run db creation according to your orm"
-            say "   - run padrino rake seed"
-            say ""
-            say "That's all"
+            say (<<-TEXT).gsub(/ {12}/,'')
+
+            -----------------------------------------------------------------
+            Your admin now is installed, now follow this steps:
+
+              - edit your config/database.rb
+              - run padrino rake -T and run db creation according to your orm
+              - run padrino rake seed
+
+            That's all
+            -----------------------------------------------------------------
+
+            TEXT
           end
         else
           say "You are not at the root of a Padrino application! (config/boot.rb not found)" and exit unless in_app_root?

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

@@ -8,16 +8,16 @@ module Padrino
 
       # Define the source template root
       def self.source_root; File.expand_path(File.dirname(__FILE__)); end
-      def self.banner; "padrino-gen backend_page [Model]"; end
+      def self.banner; "padrino-gen admin_page [Model]"; end
 
       # Include related modules
       include Thor::Actions
       include Padrino::Generators::Actions
 
-      desc "Description:\n\n\tpadrino-gen backend_page YourModel"
+      desc "Description:\n\n\tpadrino-gen admin_page YourModel"
       argument :model, :desc => "The name of your model"
       class_option :admin_path, :aliases => '-p', :type => :string, :default => "admin"
-      class_option :root,       :aliases => '-r', :type => :string
+      class_option :root, :desc => "The root destination",       :aliases => '-r', :type => :string
       class_option :destroy,    :aliases => '-d', :default => false, :type => :boolean
 
       # Show help if no argv given
@@ -28,23 +28,25 @@ module Padrino
 
       # Create controller for admin
       def create_controller
-        if in_app_root?(options[:root])
-          @model_name     = model
-          @model_klass    = model.constantize
-          @model_plural   = model.to_s.downcase.pluralize
-          @model_singular = model.to_s.downcase
+        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
           @app_root       = File.join(options[:root] || '.', options[:admin_path])
           self.behavior   = :revoke if options[:destroy]
-          template "templates/controller.rb.tt",     app_root_path(options[:admin_path], "/controllers/#{@model_plural}.rb")
-          template "templates/views/_form.haml.tt",  app_root_path(options[:admin_path], "/views/#{@model_plural}/_form.haml")
-          template "templates/views/edit.haml.tt",   app_root_path(options[:admin_path], "/views/#{@model_plural}/edit.haml")
-          template "templates/views/grid.js.erb.tt", app_root_path(options[:admin_path], "/views/#{@model_plural}/grid.js.erb")
-          template "templates/views/new.haml.tt",    app_root_path(options[:admin_path], "/views/#{@model_plural}/new.haml")
-          template "templates/views/store.jml.tt",   app_root_path(options[:admin_path], "/views/#{@model_plural}/store.jml")
-          inject_into_file app_root_path("#{options[:admin_path]}/app.rb"),  access_control(@model_plural), :before => "      # Put before other permissions [don't delete this line!!!]"
-          empty_directory app_root_path(options[:admin_path], "/views/#{@model_plural}")
-          include_component_module_for(:test, options[:root])
-          generate_controller_test(model.downcase.pluralize, options[:root])
+
+          template "templates/page/controller.rb.tt",     destination_root(options[:admin_path], "/controllers/#{@model_plural}.rb")
+          template "templates/page/views/_form.haml.tt",  destination_root(options[:admin_path], "/views/#{@model_plural}/_form.haml")
+          template "templates/page/views/edit.haml.tt",   destination_root(options[:admin_path], "/views/#{@model_plural}/edit.haml")
+          template "templates/page/views/grid.js.erb.tt", destination_root(options[:admin_path], "/views/#{@model_plural}/grid.js.erb")
+          template "templates/page/views/new.haml.tt",    destination_root(options[:admin_path], "/views/#{@model_plural}/new.haml")
+          template "templates/page/views/store.jml.tt",   destination_root(options[:admin_path], "/views/#{@model_plural}/store.jml")
+
+          add_access_control_permission(options[:admin_path], @model_plural)
+          include_component_module_for(:test)
+          generate_controller_test(model.downcase.pluralize)
         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/admin_uploader.rb

@@ -0,0 +1,83 @@
+module Padrino
+  module Generators
+
+    class AdminUploader < Thor::Group
+
+      # Add this generator to our padrino-gen
+      Padrino::Generators.add_generator(:admin_uploader, self)
+
+      # Define the source template root
+      def self.source_root; File.expand_path(File.dirname(__FILE__)); end
+      def self.banner; "padrino-gen admin_uploader"; end
+
+      # Include related modules
+      include Thor::Actions
+      include Padrino::Generators::Actions
+
+      desc "Description:\n\n\tpadrino-gen admin_uploader Name"
+      class_option :admin_path, :desc => "Path where is stored your admin app", :aliases => '-p', :type => :string, :default => "admin"
+      class_option :root,       :desc => "The root destination",                :aliases => '-r', :type => :string, :default => "."
+      class_option :destroy,    :desc => "Destroy the uploader",                :aliases => '-d', :default => false, :type => :boolean
+
+      # Create controller for admin
+      def create_controller
+        self.destination_root = options[:root]
+        if in_app_root?
+          @app_root       = File.join(options[:root], options[:admin_path])
+          self.behavior   = :revoke if options[:destroy]
+
+          if options[:destroy] || !File.read(destination_root("GemFile")).include?("carrierwave")
+            append_file destination_root("Gemfile"),  "\n\n# Uploader requirements\ngem 'carrierwave'"
+          end
+
+          copy_file "templates/uploader/controller.rb",      destination_root(options[:admin_path], "/controllers/uploads.rb")
+          copy_file "templates/uploader/views/grid.js.erb",  destination_root(options[:admin_path], "/views/uploads/grid.js.erb")
+          copy_file "templates/uploader/views/store.jml",    destination_root(options[:admin_path], "/views/uploads/store.jml")
+          copy_file "templates/uploader/lib/uploader.rb",    destination_root("lib", "uploader.rb")
+
+          Padrino::Generators::Model.dup.start([
+            "upload", "file:string", "created_at:datetime",
+            "-r=#{options[:root]}", "-s=#{skip_migrations}", "-d=#{options[:destroy]}"
+          ])
+
+          inject_into_file destination_root("app", "models", "upload.rb"), :before => "end" do
+            (<<-RUBY).gsub(/ {14}/, '  ')
+              mount_uploader :file, Uploader
+
+              def size
+                file.size if file
+              end
+
+              def content_type
+                file.content_type if file
+              end
+            RUBY
+          end
+
+          # Only for datamapper
+          if orm == :datamapper
+            inject_into_file destination_root("app", "models", "upload.rb"), :after => "property :file, String" do
+              ", :auto_validation => false"
+            end
+          end
+
+          add_permission(options[:admin_path], "role.project_module :uploads, \"/admin/uploads.js\"")
+
+          return if self.behavior == :revoke
+
+          say (<<-TEXT).gsub(/ {10}/,'')
+
+          -----------------------------------------------------
+          1) Run migrations
+          2) That's all!!
+          -----------------------------------------------------
+
+          TEXT
+        else
+          say "You are not at the root of a Padrino application! (config/boot.rb not found)" and return unless in_app_root?
+        end
+      end
+    end
+
+  end
+end

data/lib/padrino-admin/generators/app/app.rb.tt

@@ -9,7 +9,6 @@ class Admin < Padrino::Application
     layout false
     enable  :authentication
     disable :store_location
-    set :use_orm, <%= @orm.inspect %>
     set :login_page, "/<%= @app_path %>/sessions/new"
 
     access_control.roles_for :any do |role|
@@ -17,14 +16,13 @@ class Admin < Padrino::Application
     end
 
     access_control.roles_for :admin do |role, account|
+
       role.allow "/"
 
       role.project_module :accounts do |project|
         project.menu :list, "/<%= @app_path %>/accounts.js"
         project.menu :new,  "/<%= @app_path %>/accounts/new"
       end
-
-      # Put before other permissions [don't delete this line!!!]
     end
 
   end

data/lib/padrino-admin/generators/app/controllers/accounts.rb

@@ -32,6 +32,6 @@ Admin.controllers :accounts do
   delete :destroy, :respond_to => :json do
     accounts = Account.all(:conditions => { :id => params[:ids].split(",") })
     errors   = accounts.map { |account| I18n.t("admin.general.cantDelete", :record => account.id) unless account.destroy }.compact
-    { :success => errors.empty?, :msg => errors.join("<br />") }.to_json
+    render :success => errors.empty?, :msg => errors.join("<br />")
   end
 end