padrino-gen 0.7.9 → 0.8.0

data/README.rdoc

@@ -23,42 +23,42 @@ This means that Padrino generators do *not* lock you into using any particular d
 templating engine or javascript library. In fact, when generating an application you can actually tell 
 Padrino which components you would like to use!
 
-The usage for the app generator is quite simple:
+The usage for the project generator is quite simple:
 
-  $ padrino-gen app <the_app_name> </path/to/create/app> --<component-name> <value>
+  $ padrino-gen project <the_app_name> </path/to/create/app> --<component-name> <value>
 
 The simplest possible command to generate a base application would be:
 
-  $ padrino-gen demo_app .
+  $ padrino-gen project demo_project
   
 This would construct a Padrino application DemoApp (which extends from Padrino::Application) 
-inside the folder 'demo_app' at our current path. Inside the application there would be configuration and 
+inside the folder 'demo_project' at our current path. Inside the application there would be configuration and 
 setup performed for the default components.
 
 You can also define specific components to be used:
 
-  $ padrino-gen demo_app . --test rspec --renderer haml --mock rr --script jquery --orm datamapper
+  $ padrino-gen project demo_project --test rspec --renderer haml --mock rr --script jquery --orm datamapper
   
 There is also support for aliases for each component within the command:
 
-  $ padrino-gen demo_app . -t rspec -r haml -m rr -s jquery -d datamapper
+  $ padrino-gen project demo_project -t rspec -r haml -m rr -s jquery -d datamapper
   
 You can also instruct the generator to skip a certain component to avoid using one at all (or to use your own):
 
-  $ padrino-gen demo_app . --test none --renderer none
+  $ padrino-gen project demo_project --test none --renderer none
   
 The available components and their default options are listed below:
 
-* test:     <tt>bacon</tt>  (default), <tt>shoulda</tt>, <tt>rspec</tt>, <tt>testspec</tt>, <tt>riot</tt>
-* renderer: <tt>erb</tt>    (default), <tt>haml</tt>
-* mock:     <tt>mocha</tt>  (default), <tt>rr</tt>
-* script:   <tt>jquery</tt> (default), <tt>prototype</tt>, <tt>rightjs</tt>
+* test:     <tt>bacon</tt>      (default), <tt>shoulda</tt>, <tt>rspec</tt>, <tt>testspec</tt>, <tt>riot</tt>
+* renderer: <tt>haml</tt>       (default), <tt>erb</tt>
+* mock:     <tt>mocha</tt>      (default), <tt>rr</tt>
+* script:   <tt>jquery</tt>     (default), <tt>prototype</tt>, <tt>rightjs</tt>
 * orm:      <tt>datamapper</tt> (default), <tt>mongomapper</tt>, <tt>activerecord</tt>, <tt>sequel</tt>, <tt>couchrest</tt>
 
 The generator uses the <tt>bundler</tt> gem to resolve any application dependencies when the application is newly created.
 The necessary bundler command can be executed automatically through the generator with
 
-  $ padrino-gen demo_app . --run_bundler # alias -b
+  $ padrino-gen project demo_project --run_bundler # alias -b
 
 or this can be done manually through executing command <tt>gem bundle</tt> in the terminal at the root of the generated application.
 If not executed manually, the bundling will be performed automatically the first time the application attempts to boot.
@@ -69,6 +69,27 @@ This would be achieved through forking our project and reading through the code
 the setup instructions inside the relevant files within <tt>lib/generators/components/</tt>. We are happy to accept pull requests
 for additional component types not originally included (although helping us maintain them would also be appreciated).
 
+=== Sub App Generator
+
+Unlike other ruby frameworks Padrino is principally designed for mounting multiple apps at the same time.
+
+First you need to create a project
+
+  $ padrino-gen project demo_project
+  $ cd demo_project
+
+Now you are in demo_project and you can create your apps:
+
+  $ padrino-gen app one
+  $ padrino-gen app two
+
+By default these apps are mounted under:
+
+  * /one
+  * /two
+  
+but you can edit config/apps.rb and change it.
+
 === Model Generator
 
 Padrino provides generator support for quickly creating new models within your Padrino application. Note that
@@ -142,6 +163,10 @@ created through the Padrino application generator and that follow Padrino conven
 Using the controller generator is as simple as:
 
   $ padrino-gen controller Admin
+
+If you want create a controller for a specified sub app you can:
+
+  $ padrino-gen controller Admin -a my_sub_app
   
 You can also specify desired actions to be added to your controller:
 
@@ -170,7 +195,11 @@ created through the Padrino application generator and that follow Padrino conven
 Using the mailer generator is as simple as:
 
   $ padrino-gen mailer UserNotifier
-  
+
+If you want create a mailer for a specified sub app you can:
+
+  $ padrino-gen mailer UserNotifier -a my_sub_app
+
 You can also specify desired delivery actions to be added to the mailer:
 
   $ padrino-gen mailer UserNotifier confirm_account welcome inactive_account

data/Rakefile

@@ -20,7 +20,7 @@ begin
     gem.add_runtime_dependency     "thor",          ">= 0.13.0"
     gem.add_runtime_dependency     "bundler",       ">= 0.9.3"
     gem.add_development_dependency "haml",          ">= 2.2.1"
-    gem.add_development_dependency "shoulda",       ">= 0"
+    gem.add_development_dependency "shoulda",       ">= 2.10.3"
     gem.add_development_dependency "mocha",         ">= 0.9.7"
     gem.add_development_dependency "rack-test",     ">= 0.5.0"
     gem.add_development_dependency "webrat",        ">= 0.5.1"
@@ -42,14 +42,15 @@ end
 
 begin
   require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |test|
-    test.libs << 'test'
-    test.pattern = 'test/**/test_*.rb'
-    test.verbose = true
+  Rcov::RcovTask.new do |rcov|
+    rcov.libs << 'test'
+    rcov.pattern = 'test/**/test_*.rb'
+    rcov.verbose = true
+    rcov.rcov_opts << ['--exclude /Gems/1.8/gems/,/tmp/,padrino-admin,padrino-cache,padrino-core,padrino-helpers,padrino-mailer']
   end
 rescue LoadError
   task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install relevance-rcov"
   end
 end
 

data/VERSION

@@ -1 +1 @@
-0.7.9
+0.8.0

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

@@ -28,6 +28,7 @@ module Padrino
       # include_component_module_for(:mock, 'rr')
       def include_component_module_for(component, choice=nil)
         choice = fetch_component_choice(component) unless choice
+        return if choice.to_s == 'none'
         self.class.send(:include, generator_module_for(choice, component))
       end
 
@@ -107,16 +108,37 @@ module Padrino
         inject_into_file('Gemfile', options[:content], :after => options[:after])
       end
 
+      ## Return true if our project has test component
+      def test?
+        fetch_component_choice(:test).to_s != 'none'
+      end
+
+      ## Raise SystemExit if the app is inexistent
+      def check_app_existence(app)
+        unless File.exist?(destination_root(app))
+          say
+          say "================================================================="
+          say "We didn't found #{app.underscore.classify}! Available apps are:"
+          say "================================================================="
+          Padrino.mounted_apps.each do |app|
+            say " - #{app.app_object}"
+          end
+          say "================================================================="
+          say
+          raise SystemExit
+        end
+      end
+
       module ClassMethods
 
         # Defines a class option to allow a component to be chosen and add to component type list
         # Also builds the available_choices hash of which component choices are supported
         # component_option :test, "Testing framework", :aliases => '-t', :choices => [:bacon, :shoulda]
         def component_option(name, caption, options = {})
-          (@component_types ||= []) << name # TODO use ordered hash and combine with choices below
-          (@available_choices ||= Hash.new({}))[name] = options[:choices]
+          (@component_types   ||= []) << name # TODO use ordered hash and combine with choices below
+          (@available_choices ||= Hash.new)[name] = options[:choices]
           description = "The #{caption} component (#{options[:choices].join(', ')}, none)"
-          class_option name, :default => options[:choices].first, :aliases => options[:aliases], :desc => description
+          class_option name, :default => options[:default] || options[:choices].first, :aliases => options[:aliases], :desc => description
         end
 
         # Returns the compiled list of component types which can be specified

data/lib/padrino-gen/generators/app.rb

@@ -1,33 +1,25 @@
 module Padrino
   module Generators
+
     class App < Thor::Group
 
       # Add this generator to our padrino-gen
       Padrino::Generators.add_generator(:app, self)
 
       # Define the source template root
-      def self.source_root; File.dirname(__FILE__); end
-      def self.banner; "padrino-gen project [name] [options]"; end
+      def self.source_root; File.expand_path(File.dirname(__FILE__)); end
+      def self.banner; "padrino-gen project [name]"; end
 
       # Include related modules
       include Thor::Actions
       include Padrino::Generators::Actions
-      include Padrino::Generators::Components::Actions
-
-      desc "Description:\n\n\tpadrino-gen project generates a new Padrino project"
 
-      argument :name, :desc => "The name of your padrino project"
+      desc "Description:\n\n\tpadrino-gen project generate a new Padrino application"
 
-      class_option :run_bundler,  :desc => "Run 'bundle install'",            :aliases => '-b', :default => false, :type => :boolean
-      class_option :root,         :desc => "The root destination",            :aliases => '-r', :default => ".",   :type => :string
-      class_option :dev,          :desc => "Use padrino from a git checkout",                   :default => false, :type => :boolean
+      argument :name, :desc => "The name of your padrino application"
 
-      # Definitions for the available customizable components
-      component_option :orm,      "database engine",    :aliases => '-d', :choices => [:datamapper, :mongomapper, :activerecord, :sequel, :couchrest]
-      component_option :test,     "testing framework",  :aliases => '-t', :choices => [:bacon, :shoulda, :rspec, :testspec, :riot]
-      component_option :mock,     "mocking library",    :aliases => '-m', :choices => [:mocha, :rr]
-      component_option :script,   "javascript library", :aliases => '-s', :choices => [:jquery, :prototype, :rightjs]
-      component_option :renderer, "template engine",    :aliases => '-e', :choices => [:erb, :haml]
+      class_option :root, :desc => "The root destination", :aliases => '-r', :default => ".", :type => :string
+      class_option :destroy, :aliases => '-d', :default => false,   :type    => :boolean
 
       # Show help if no argv given
       def self.start(given_args=ARGV, config={})
@@ -35,30 +27,30 @@ module Padrino
         super
       end
 
-      # Copies over the Padrino base application App
-      def setup_app
+      # Copies over the Padrino base admin application
+      def create_app
+        self.destination_root = options[:root]
         @class_name = name.underscore.classify
-        self.destination_root = File.join(options[:root], name)
-        directory("app/", destination_root)
-        store_component_config('.components')
-        template "templates/Gemfile.tt", destination_root("Gemfile")
-      end
-
-      # For each component, retrieve a valid choice and then execute the associated generator
-      def setup_components
-        self.class.component_types.each do |comp|
-          choice = resolve_valid_choice(comp)
-          execute_component_setup(comp, choice)
+        if in_app_root?
+          directory("app/", destination_root(name))
+          append_file destination_root("config/apps.rb"),  "\nPadrino.mount(\"#{@class_name}\").to(\"/#{name.underscore}\")"
+          
+          return if self.behavior == :revoke
+          say (<<-TEXT).gsub(/ {10}/,'')
+
+          =================================================================
+          Your #{@class_name} Application now is installed. 
+          It's available on /#{name.underscore}
+          You can setup a new path editing config/apps.rb
+          =================================================================
+
+          TEXT
+        else
+          say "You are not at the root of a Padrino application! (config/boot.rb not found)" and exit unless in_app_root?
         end
       end
 
-      # Bundle all required components using bundler and Gemfile
-      def bundle_dependencies
-        if options[:run_bundle]
-          say "Bundling application dependencies using bundler..."
-          in_root { run 'bundle install' }
-        end
-      end
     end
+
   end
-end
+end

data/lib/padrino-gen/generators/components/actions.rb

@@ -72,12 +72,6 @@ module Padrino
           Dir[destination_root("db/migrate/*_#{filename.underscore}.rb")].size > 0
         end
 
-        # For model destroy option
-        # removes the initial migration file of model
-        def remove_model_migration(name)
-          remove_migration "Create" + name
-        end
-        
         # For the removal of migration files
         # removes the migration file based on the migration name
         def remove_migration(name)
@@ -85,10 +79,8 @@ module Padrino
             File.basename(f) =~ /#{name.to_s.underscore}/
           end
           return unless migration_path
-          if behavior == :revoke # we need to reverse the operation for revoke
-            create_file migration_path
-          else
-            remove_file migration_path
+          if behavior == :revoke 
+            create_file migration_path # we use create to reverse the operation of a revoke
           end
         end
 
@@ -125,19 +117,9 @@ module Padrino
           field_tuples = fields.collect { |value| value.split(":") }
           action_declarations = field_tuples.collect do |request, name|
             "#{request} :#{name} do\n  end\n"
-          end.join("\n  ")
-        end
-
-        # For controller route generation
-        # Takes in the fields and maps out an appropriate default route.
-        # where controller is user and route is get:test, will add map(:test).to("/user/test")
-        def controller_routes(name,fields)
-          field_tuples = fields.collect { |value| value.split(":") }
-          routes = "\n" + field_tuples.collect do |request, route|
-            "  map(:#{route}).to(\"/#{name}/#{route}\")"
-          end.join("\n") + "\n"
+          end
+          action_declarations.join("\n  ")
         end
-
       end
     end
   end

data/lib/padrino-gen/generators/components/mocks/rr_gen.rb

@@ -2,15 +2,19 @@ module Padrino
   module Generators
     module Components
       module Mocks
-        
+
         module RrGen
           def setup_mock
             require_dependencies 'rr', :group => 'test'
-            insert_mocking_include "RR::Adapters::RRMethods", :path => "test/test_config.rb"
+            if options[:test] == 'riot'
+              inject_into_file "test/test_config.rb","  Riot.rr\n", :after => "class Riot::Situation\n"
+            else
+              insert_mocking_include "RR::Adapters::RRMethods", :path => "test/test_config.rb"
+            end
           end
         end
-        
+
       end
     end
   end
-end
+end

data/lib/padrino-gen/generators/controller.rb

@@ -20,6 +20,7 @@ module Padrino
       argument :name, :desc => "The name of your padrino controller"
       argument :fields, :desc => "The fields for the controller", :type => :array, :default => []
       class_option :root, :desc => "The root destination", :aliases => '-r', :default => ".", :type => :string
+      class_option :app, :desc => "The application destination", :aliases => '-a', :default => "/app", :type => :string
       class_option :destroy, :aliases => '-d', :default => false, :type => :boolean
 
       # Show help if no argv given
@@ -31,15 +32,17 @@ module Padrino
       def create_controller
         self.destination_root = options[:root]
         if in_app_root?
+          app = options[:app].underscore
+          check_app_existence(app)
           @app_name = fetch_app_name(options[:root])
           @actions  = controller_actions(fields)
           @controller = name
           self.behavior = :revoke if options[:destroy]
-          template "templates/controller.rb.tt", destination_root("app/controllers", "#{name}.rb")
-          template "templates/helper.rb.tt",     destination_root("app/helpers", "#{name}_helper.rb")
-          empty_directory destination_root("app/views/#{name}")
+          template "templates/controller.rb.tt", destination_root(app, "controllers", "#{name}.rb")
+          template "templates/helper.rb.tt",     destination_root(app, "helpers", "#{name}_helper.rb")
+          empty_directory destination_root(app, "/views/#{name}")
           include_component_module_for(:test)
-          generate_controller_test(name)
+          generate_controller_test(name) if test?
         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-gen/generators/mailer.rb

@@ -19,6 +19,7 @@ module Padrino
 
       argument :name, :desc => "The name of your padrino mailer"
       class_option :root, :desc => "The root destination", :aliases => '-r', :default => ".", :type => :string
+      class_option :app, :desc => "The application destination", :aliases => '-a', :default => "/app", :type => :string
       class_option :destroy, :aliases => '-d', :default => false, :type => :boolean
 
       # Show help if no argv given
@@ -30,13 +31,15 @@ module Padrino
       def create_mailer
         self.destination_root = options[:root]
         if in_app_root?
+          app = options[:app].underscore
+          check_app_existence(app)
           self.behavior = :revoke if options[:destroy]
           simple_name = name.to_s.gsub(/mailer/i, '')
           @mailer_basename = "#{simple_name.downcase.underscore}_mailer"
           @mailer_klass    = "#{simple_name.downcase.camelize}Mailer"
           template "templates/mailer_initializer.rb.tt", destination_root("config/initializers/mailer.rb"), :skip => true
-          template "templates/mailer.rb.tt", destination_root("app/mailers", "#{@mailer_basename}.rb")
-          empty_directory destination_root('app/views/', @mailer_basename)
+          template "templates/mailer.rb.tt", destination_root(app, "mailers", "#{@mailer_basename}.rb")
+          empty_directory destination_root(app, 'views', @mailer_basename)
         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-gen/generators/model.rb

@@ -37,7 +37,7 @@ module Padrino
           include_component_module_for(:test)
           migration_name = "create_#{name.pluralize.underscore}"
           create_model_file(name, fields)
-          generate_model_test(name)
+          generate_model_test(name) if test?
           create_model_migration(migration_name, name, fields) unless options[:skip_migration]
         else
           say "You are not at the root of a Padrino application! (config/boot.rb not found)" and return unless in_app_root?

data/lib/padrino-gen/generators/project/app/app.rb.tt

@@ -0,0 +1,37 @@
+class <%= @class_name %> < Padrino::Application
+  configure do
+    ##
+    # Application-specific configuration options
+    # 
+    # set :raise_errors, true     # Show exceptions (default for development)
+    # set :public, "foo/bar"      # Location for static assets (default root/public)
+    # set :sessions, false        # Enabled by default
+    # 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 :autolocale          # Auto Set locale if url match /:lang/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)
+    # 
+  end
+
+  ##
+  # You can configure for a specified environment like:
+  # 
+  #   configure :development do
+  #     set :foo, :bar
+  #   end
+  #
+
+  ##
+  # You can manage errors like:
+  # 
+  #   errors 404 do
+  #     render 'errors/404'
+  #   end
+  #
+
+end

data/lib/padrino-gen/generators/{app → project}/config/boot.rb

@@ -13,6 +13,6 @@ rescue LoadError
 end
 
 Bundler.require(:default, PADRINO_ENV)
-puts "=> Located #{Padrino.bundle} Gemfile for #{Padrino.env} with #{Padrino.support.to_s.humanize}"
+puts "=> Located #{Padrino.bundle} Gemfile for #{Padrino.env}"
 
 Padrino.load!

data/lib/padrino-gen/generators/project.rb

@@ -0,0 +1,64 @@
+module Padrino
+  module Generators
+    class Project < Thor::Group
+
+      # Add this generator to our padrino-gen
+      Padrino::Generators.add_generator(:project, self)
+
+      # Define the source template root
+      def self.source_root; File.dirname(__FILE__); end
+      def self.banner; "padrino-gen project [name] [options]"; end
+
+      # Include related modules
+      include Thor::Actions
+      include Padrino::Generators::Actions
+      include Padrino::Generators::Components::Actions
+
+      desc "Description:\n\n\tpadrino-gen project generates a new Padrino project"
+
+      argument :name, :desc => "The name of your padrino project"
+
+      class_option :run_bundler,  :desc => "Run 'bundle install'",            :aliases => '-b', :default => false, :type => :boolean
+      class_option :root,         :desc => "The root destination",            :aliases => '-r', :default => ".",   :type => :string
+      class_option :dev,          :desc => "Use padrino from a git checkout",                   :default => false, :type => :boolean
+
+      # Definitions for the available customizable components
+      component_option :orm,      "database engine",    :aliases => '-d', :choices => [:datamapper, :mongomapper, :activerecord, :sequel, :couchrest], :default => :none
+      component_option :test,     "testing framework",  :aliases => '-t', :choices => [:bacon, :shoulda, :rspec, :testspec, :riot]
+      component_option :mock,     "mocking library",    :aliases => '-m', :choices => [:mocha, :rr]
+      component_option :script,   "javascript library", :aliases => '-s', :choices => [:jquery, :prototype, :rightjs], :default => :none
+      component_option :renderer, "template engine",    :aliases => '-e', :choices => [:haml, :erb]
+
+      # Show help if no argv given
+      def self.start(given_args=ARGV, config={})
+        given_args = ["-h"] if given_args.empty?
+        super
+      end
+
+      # Copies over the Padrino base application App
+      def setup_project
+        @class_name = name.underscore.classify
+        self.destination_root = File.join(options[:root], name)
+        directory("project/", destination_root)
+        store_component_config('.components')
+        template "templates/Gemfile.tt", destination_root("Gemfile")
+      end
+
+      # For each component, retrieve a valid choice and then execute the associated generator
+      def setup_components
+        self.class.component_types.each do |comp|
+          choice = resolve_valid_choice(comp)
+          execute_component_setup(comp, choice)
+        end
+      end
+
+      # Bundle all required components using bundler and Gemfile
+      def bundle_dependencies
+        if options[:run_bundle]
+          say "Bundling application dependencies using bundler..."
+          in_root { run 'bundle install' }
+        end
+      end
+    end
+  end
+end

data/lib/padrino-gen/generators/templates/Gemfile.tt

@@ -1,7 +1,6 @@
 source 'http://gemcutter.org'
 
 # Project requirements
-gem 'sinatra', :require => 'sinatra/base'
 gem 'rack-flash'
 gem 'thin' # or mongrel
 

data/lib/padrino-gen/generators.rb

@@ -5,7 +5,7 @@ module Padrino
 
     class << self
       def load_paths
-        @load_paths ||= Dir[File.dirname(__FILE__) + '/generators/{app,mailer,controller,model,migration}.rb']
+        @load_paths ||= Dir[File.dirname(__FILE__) + '/generators/{project,app,mailer,controller,model,migration}.rb']
       end
 
       def mappings
@@ -16,6 +16,11 @@ module Padrino
         mappings[name] = klass
       end
 
+      def setup!
+        require 'padrino-gen/generators/actions'
+        Dir[File.dirname(__FILE__) + '/generators/{components}/**/*.rb'].each { |lib| require lib }
+      end
+
       def lockup!
         load_paths.each { |lib| require lib  }
       end
@@ -31,8 +36,7 @@ module Padrino
       # We need to TRY to load boot because some of our app dependencies maybe have 
       # custom generators, so is necessary know who are.
       def load_boot
-        require 'padrino-gen/generators/actions'
-        Dir[File.dirname(__FILE__) + '/generators/{components}/**/*.rb'].each { |lib| require lib }
+        Padrino::Generators.setup!
 
         begin
           ENV['PADRINO_LOG_LEVEL'] ||= "test"

data/lib/padrino-gen/padrino-tasks/activerecord.rb

@@ -35,7 +35,7 @@ if defined?(ActiveRecord)
           else
             begin
               # Create the SQLite database
-              Dir.mkdir File.dirname(config[:database])
+              Dir.mkdir File.dirname(config[:database]) unless File.exist?(File.dirname(config[:database]))
               ActiveRecord::Base.establish_connection(config)
               ActiveRecord::Base.connection
             rescue