padrino-gen 0.9.14 → 0.9.15

data/LICENSE

@@ -17,4 +17,4 @@ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -10,7 +10,7 @@ as possible, supporting a myriad of test frameworks, js libraries, mocking libra
 See the guide for {Padrino Generators}[http://www.padrinorb.com/guides/generators] for a
 more in-depth look at the system.
 
-=== Application Generator
+=== Project Generator
 
 Padrino provides generator support for quickly creating new Padrino applications. This provides many benefits
 such as constructing the recommended Padrino application structure, auto-generating a Gemfile listing
@@ -39,15 +39,30 @@ You can also instruct the generator to skip a certain component to avoid using o
 The available components and their default options are listed below:
 
 test::       rspec (default), bacon, shoulda, cucumber, testspec, riot
-renderer::   haml  (default), erb
+renderer::   haml  (default), erb, erubis, liquid
 stylesheet:: sass  (default), less, compass
 mock::       none  (default), mocha, rr
 script::     none  (default), jquery, prototype, mootools, rightjs, extcore, dojo
 orm::        none  (default), datamapper, mongomapper, mongoid, activerecord, sequel, couchrest
 
+In addition, you can generate projects based on existing templates:
+
+  $ padrino-gen project demo_project --template sampleblog
+
 To learn more about the project generator, check out the guide to
 {Padrino Generators}[http://www.padrinorb.com/guides/generators].
 
+=== Plugin System
+
+Padrino provides support for plugins to be executed within your application. For example:
+
+  $ padrino-gen plugin hoptoad
+
+would install the hoptoad middleware into your application automatically.
+
+To learn more about the plugin system, check out the guide to
+{Padrino Generators}[http://www.padrinorb.com/guides/generators].
+
 === Sub App Generator
 
 Unlike other ruby frameworks Padrino is principally designed for mounting multiple apps at the same time.

data/Rakefile

@@ -1,5 +1,4 @@
 # coding:utf-8
 RAKE_ROOT = __FILE__
-
 require 'rubygems'
-require File.expand_path(File.dirname(__FILE__) + '/../gem_rake_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../gem_rake_helper')

data/bin/padrino-gen

@@ -1,11 +1,10 @@
 #!/usr/bin/env ruby
-require 'rubygems' unless defined?(Gem)
+require 'rubygems' unless defined?(Gem) # Useful only on --dev mode
 
-# We load padrino-gen
 padrino_gen_path = File.expand_path('../../lib', __FILE__)
 $:.unshift(padrino_gen_path) if File.directory?(padrino_gen_path) && !$:.include?(padrino_gen_path)
 
-# We try to load the vendored padrino-core if exist
+# We try to load the vendored padrino-core if exist (useful also for --dev mode)
 padrino_core_path = File.expand_path('../../../padrino-core/lib', __FILE__)
 $:.unshift(padrino_core_path) if File.directory?(padrino_core_path) && !$:.include?(padrino_core_path)
 

data/lib/padrino-gen.rb

@@ -30,7 +30,6 @@ module Padrino
     DEV_PATH = File.expand_path("../../", File.dirname(__FILE__))
 
     class << self
-
       ##
       # Here we store our generators paths
       #
@@ -58,6 +57,7 @@ module Padrino
       def load_components!
         require 'padrino-gen/generators/actions'
         require 'padrino-gen/generators/components/actions'
+        require 'padrino-gen/generators/runner'
         load_paths.flatten.each { |file| require file  }
       end
     end
@@ -67,7 +67,7 @@ end # Padrino
 ##
 # We add our generators to Padrino::Genererator
 #
-Padrino::Generators.load_paths << Dir[File.dirname(__FILE__) + '/padrino-gen/generators/{project,app,mailer,controller,model,migration}.rb']
+Padrino::Generators.load_paths << Dir[File.dirname(__FILE__) + '/padrino-gen/generators/{project,app,mailer,controller,model,migration,plugin}.rb']
 
 ##
 # We add our tasks to padrino-core

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

@@ -65,22 +65,23 @@ module Padrino
       # Returns true if the option passed is a valid choice for component
       # valid_option?(:mock, 'rr')
       def valid_choice?(component, choice)
-        self.class.available_choices_for(component).include? choice.to_sym
+        choice.present? && self.class.available_choices_for(component).include?(choice.to_sym)
       end
 
       # Creates a component_config file at the destination containing all component options
       # Content is a yamlized version of a hash containing component name mapping to chosen value
       def store_component_config(destination)
+        components = @_components || options
         create_file(destination) do
-          self.class.component_types.inject({}) { |result, component|
-            result[component] = options[component].to_s; result
+          self.class.component_types.inject({}) { |result, comp|
+            result[comp] = components[comp].to_s; result
           }.to_yaml
         end
       end
 
       # Returns the root for this thor class (also aliased as destination root).
       def destination_root(*paths)
-        File.join(@destination_stack.last, paths)
+        File.expand_path(File.join(@destination_stack.last, paths))
       end
 
       # Returns true if inside a Padrino application
@@ -103,27 +104,80 @@ module Padrino
       # Adds all the specified gems into the Gemfile for bundler
       # require_dependencies 'active_record'
       # require_dependencies 'mocha', 'bacon', :group => 'test'
+      # require_dependencies 'json', :version => ">=1.2.3"
       def require_dependencies(*gem_names)
         options = gem_names.extract_options!
         gem_names.reverse.each { |lib| insert_into_gemfile(lib, options) }
       end
+      alias :require_dependency :require_dependencies
 
       # Inserts a required gem into the Gemfile to add the bundler dependency
       # insert_into_gemfile(name)
       # insert_into_gemfile(name, :group => 'test', :require => 'foo')
+      # insert_into_gemfile(name, :group => 'test', :version => ">1.2.3")
       def insert_into_gemfile(name, options={})
         after_pattern = options[:group] ? "#{options[:group].to_s.capitalize} requirements\n" : "Component requirements\n"
+        version = options.delete(:version)
         gem_options   = options.map { |k, v| "#{k.inspect} => #{v.inspect}" }.join(", ")
-        include_text  = "gem '#{name}'" << (gem_options.present? ? ", #{gem_options}" : "") << "\n"
+        write_option = gem_options.present? ? ", #{gem_options}" : ""
+        write_version = version.present? ? ", #{version.inspect}" : ""
+        include_text  = "gem '#{name}'"<< write_version << write_option << "\n"
         inject_into_file('Gemfile', include_text, :after => after_pattern)
       end
 
-      ## Return true if our project has test component
+      # Inserts an hook before or after load in our boot.rb
+      # insert_hook("DataMapper.finalize", :after_load)
+      def insert_hook(include_text, where)
+        inject_into_file('config/boot.rb', "  #{include_text}\n", :after => "Padrino.#{where} do\n")
+      end
+
+      # Registers and Creates Initializer.
+      # initializer :test, "some stuff here"
+      def initializer(name, data=nil)
+        @_init_name, @_init_data = name, data
+        register = data.present? ? "  register #{name.to_s.camelize}Initializer\n" : "  register #{name}\n"
+        inject_into_file destination_root("/app/app.rb"), register, :after => "Padrino::Application\n"
+        template "templates/initializer.rb.tt", destination_root("/lib/#{name}_init.rb") if data.present?
+      end
+
+      # Insert the regired gem and add in boot.rb custom contribs.
+      def require_contrib(contrib)
+        insert_into_gemfile 'padrino-contrib'
+        contrib = "require '" + File.join("padrino-contrib", contrib) + "'\n"
+        inject_into_file destination_root("/config/boot.rb"), contrib, :before => "\nPadrino.load!"
+      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
+      # Return true if we have a tiny skeleton
+      def tiny?
+        File.exist?(destination_root("app/controllers.rb"))
+      end
+
+      # Run the bundler
+      def run_bundler
+        say "Bundling application dependencies using bundler...", :yellow
+        in_root { run 'bundle install' }
+      end
+
+      # Ask something to the user and receives a response.
+      #
+      # ==== Example
+      #
+      #   ask("What is your name?")
+      #   ask("Path for ruby", "/usr/local/bin/ruby") => "Path for ruby (leave blank for /usr/local/bin/ruby):"
+      #
+      def ask(statement, default=nil, color=nil)
+        default_text = default ? " (leave blank for #{default}):" : nil
+        say("#{statement}#{default_text} ", color)
+        result = $stdin.gets.strip
+        result.blank? ? default : result
+      end
+
+      # Raise SystemExit if the app is inexistent
       def check_app_existence(app)
         unless File.exist?(destination_root(app))
           say
@@ -187,4 +241,4 @@ module Padrino
       end
     end # Actions
   end # Generators
-end # Padrino
+end # Padrino

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

@@ -30,6 +30,7 @@ module Padrino
         self.destination_root = options[:root]
         @app_name = name.gsub(/\W/, "_").underscore.camelize
         if in_app_root?
+          self.behavior = :revoke if options[:destroy]
           app_skeleton(name, options[:tiny])
           empty_directory destination_root("public/#{name}")
           append_file destination_root("config/apps.rb"),  "\nPadrino.mount(\"#{@app_name}\").to(\"/#{name.underscore}\")"
@@ -45,7 +46,7 @@ module Padrino
 
           TEXT
         else
-          say "You are not at the root of a Padrino application! (config/boot.rb not found)" and exit unless in_app_root?
+          say "You are not at the root of a Padrino application! (config/boot.rb not found)"
         end
       end
     end # App

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

@@ -1,4 +1,3 @@
-require 'rubygems'
 require 'thor/group'
 
 module Padrino
@@ -12,13 +11,14 @@ module Padrino
       # Include related modules
       include Thor::Actions
 
-      class_option :root, :desc => "The root destination", :aliases => '-r', :default => nil, :type => :string
+      class_option :root, :desc => "The root destination", :aliases => '-r', :default => ".", :type => :string
 
       # 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
         begin
           ENV['PADRINO_LOG_LEVEL'] ||= "test"
+          ENV['BUNDLE_GEMFILE'] = File.join(options[:root], "Gemfile") if options[:root]
           boot = options[:root] ? File.join(options[:root], 'config/boot.rb') : 'config/boot.rb'
           if File.exist?(boot)
             require File.expand_path(boot)
@@ -27,7 +27,7 @@ module Padrino
             require 'padrino-core/support_lite' unless defined?(SupportLite)
           end
         rescue Exception => e
-          puts "=> Problem loading config/boot.rb"
+          puts "=> Problem loading #{boot}"
           puts ["=> #{e.message}", *e.backtrace].join("\n  ")
         end
       end

data/lib/padrino-gen/generators/components/orms/activerecord.rb

@@ -75,21 +75,22 @@ SQLITE
 
 def setup_orm
   ar = AR
+  db = @app_name.underscore
   case options[:adapter]
   when 'mysql'
-    ar.gsub! /!DB_DEVELOPMENT!/, MYSQL.gsub(/!DB_NAME!/,"\"#{name}_development\"")
-    ar.gsub! /!DB_PRODUCTION!/, MYSQL.gsub(/!DB_NAME!/,"\"#{name}_production\"")
-    ar.gsub! /!DB_TEST/, MYSQL.gsub(/!DB_NAME!/,"\"#{name}_test\"")
+    ar.gsub! /!DB_DEVELOPMENT!/, MYSQL.gsub(/!DB_NAME!/,"\"#{db}_development\"")
+    ar.gsub! /!DB_PRODUCTION!/, MYSQL.gsub(/!DB_NAME!/,"\"#{db}_production\"")
+    ar.gsub! /!DB_TEST/, MYSQL.gsub(/!DB_NAME!/,"\"#{db}_test\"")
     require_dependencies 'mysql'
   when 'postgres'
-    ar.gsub! /!DB_DEVELOPMENT!/, POSTGRES.gsub(/!DB_NAME!/,"\"#{name}_development\"")
-    ar.gsub! /!DB_PRODUCTION!/, POSTGRES.gsub(/!DB_NAME!/,"\"#{name}_production\"")
-    ar.gsub! /!DB_TEST!/, POSTGRES.gsub(/!DB_NAME!/,"\"#{name}_test\"")
+    ar.gsub! /!DB_DEVELOPMENT!/, POSTGRES.gsub(/!DB_NAME!/,"\"#{db}_development\"")
+    ar.gsub! /!DB_PRODUCTION!/, POSTGRES.gsub(/!DB_NAME!/,"\"#{db}_production\"")
+    ar.gsub! /!DB_TEST!/, POSTGRES.gsub(/!DB_NAME!/,"\"#{db}_test\"")
     require_dependencies 'pg', :require => 'postgres'
   else
-    ar.gsub! /!DB_DEVELOPMENT!/, SQLITE.gsub(/!DB_NAME!/,"Padrino.root('db', \"#{name}_development.db\")")
-    ar.gsub! /!DB_PRODUCTION!/, SQLITE.gsub(/!DB_NAME!/,"Padrino.root('db', \"#{name}_production.db\")")
-    ar.gsub! /!DB_TEST!/, SQLITE.gsub(/!DB_NAME!/,"Padrino.root('db', \"#{name}_test.db\")")    
+    ar.gsub! /!DB_DEVELOPMENT!/, SQLITE.gsub(/!DB_NAME!/,"Padrino.root('db', \"#{db}_development.db\")")
+    ar.gsub! /!DB_PRODUCTION!/, SQLITE.gsub(/!DB_NAME!/,"Padrino.root('db', \"#{db}_production.db\")")
+    ar.gsub! /!DB_TEST!/, SQLITE.gsub(/!DB_NAME!/,"Padrino.root('db', \"#{db}_test.db\")")
     require_dependencies 'sqlite3-ruby', :require => 'sqlite3'
   end
   require_dependencies 'activerecord', :require => 'active_record'

data/lib/padrino-gen/generators/components/orms/couchrest.rb

@@ -10,7 +10,7 @@ COUCHREST
 def setup_orm
   require_dependencies 'couchrest'
   require_dependencies 'json_pure'
-  create_file("config/database.rb", COUCHREST.gsub(/!NAME!/, name.underscore))
+  create_file("config/database.rb", COUCHREST.gsub(/!NAME!/, @app_name.underscore))
   empty_directory('app/models')
 end
 

data/lib/padrino-gen/generators/components/orms/datamapper.rb

@@ -22,27 +22,29 @@ DM
 
 def setup_orm
   dm = DM
+  db = @app_name.underscore
   require_dependencies 'data_mapper'
   require_dependencies case options[:adapter]
     when 'mysql'
-      dm.gsub!(/!DB_DEVELOPMENT!/,"\"mysql://root@localhost/#{name}_development\"")
-      dm.gsub!(/!DB_PRODUCTION!/,"\"mysql://root@localhost/#{name}_production\"")
-      dm.gsub!(/!DB_TEST!/,"\"mysql://root@localhost/#{name}_test\"")
+      dm.gsub!(/!DB_DEVELOPMENT!/,"\"mysql://root@localhost/#{db}_development\"")
+      dm.gsub!(/!DB_PRODUCTION!/,"\"mysql://root@localhost/#{db}_production\"")
+      dm.gsub!(/!DB_TEST!/,"\"mysql://root@localhost/#{db}_test\"")
       'dm-mysql-adapter'
     when 'postgres'
-      dm.gsub!(/!DB_DEVELOPMENT!/,"\"postgres://root@localhost/#{name}_development\"")
-      dm.gsub!(/!DB_PRODUCTION!/,"\"postgres://root@localhost/#{name}_production\"")
-      dm.gsub!(/!DB_TEST!/,"\"postgres://root@localhost/#{name}_test\"")
+      dm.gsub!(/!DB_DEVELOPMENT!/,"\"postgres://root@localhost/#{db}_development\"")
+      dm.gsub!(/!DB_PRODUCTION!/,"\"postgres://root@localhost/#{db}_production\"")
+      dm.gsub!(/!DB_TEST!/,"\"postgres://root@localhost/#{db}_test\"")
       'dm-postgres-adapter'
     else
-      dm.gsub!(/!DB_DEVELOPMENT!/,"\"sqlite3://\" + Padrino.root('db', \"#{name}_development.db\")")
-      dm.gsub!(/!DB_PRODUCTION!/,"\"sqlite3://\" + Padrino.root('db', \"#{name}_production.db\")")
-      dm.gsub!(/!DB_TEST!/,"\"sqlite3://\" + Padrino.root('db', \"#{name}_test.db\")")
+      dm.gsub!(/!DB_DEVELOPMENT!/,"\"sqlite3://\" + Padrino.root('db', \"#{db}_development.db\")")
+      dm.gsub!(/!DB_PRODUCTION!/,"\"sqlite3://\" + Padrino.root('db', \"#{db}_production.db\")")
+      dm.gsub!(/!DB_TEST!/,"\"sqlite3://\" + Padrino.root('db', \"#{db}_test.db\")")
       'dm-sqlite-adapter'
   end
 
   create_file("config/database.rb", dm)
   empty_directory('app/models')
+  insert_hook("DataMapper.finalize", :after_load)
 end
 
 DM_MODEL = (<<-MODEL) unless defined?(DM_MODEL)

data/lib/padrino-gen/generators/components/orms/mongoid.rb

@@ -29,7 +29,7 @@ MONGO
 def setup_orm
   require_dependencies 'bson_ext', :require => 'mongo'
   require_dependencies 'mongoid'
-  create_file("config/database.rb", MONGOID.gsub(/!NAME!/, name.underscore.gsub('.','_')))
+  create_file("config/database.rb", MONGOID.gsub(/!NAME!/, @app_name.underscore))
   empty_directory('app/models')
 end
 

data/lib/padrino-gen/generators/components/orms/mongomapper.rb

@@ -11,7 +11,7 @@ MONGO
 def setup_orm
   require_dependencies 'bson_ext', :require => 'mongo'
   require_dependencies 'mongo_mapper'
-  create_file("config/database.rb", MONGO.gsub(/!NAME!/, name.underscore))
+  create_file("config/database.rb", MONGO.gsub(/!NAME!/, @app_name.underscore))
   empty_directory('app/models')
 end
 

data/lib/padrino-gen/generators/components/orms/mongomatic.rb

@@ -0,0 +1,85 @@
+MONGOMATIC = (<<-MONGO) unless defined?(MONGOMATIC)
+
+case Padrino.env
+  when :development then Mongomatic.db = Mongo::Connection.new.db("!NAME!_development")
+  when :production then Mongomatic.db = Mongo::Connection.new.db("!NAME!_production")
+  when :test then Mongomatic.db = Mongo::Connection.new.db("!NAME!_test")
+end
+MONGO
+
+def setup_orm
+  mongomatic = MONGOMATIC
+  require_dependencies 'bson_ext', :require => 'mongo'
+  require_dependencies 'mongomatic'
+  create_file("config/database.rb", MONGOMATIC.gsub(/!NAME!/, @app_name.underscore))
+  empty_directory('app/models')
+end
+
+MONGOMATIC_MODEL = (<<-MODEL) unless defined?(MONGOMATIC_MODEL)
+class !NAME! < Mongomatic::Base
+  include Mongomatic::Expectations::Helper
+
+  # Mongomatic does not have the traditional
+  # model definition that AR/MM/DM et. al. have.
+  # Staying true to the "ad-hoc" nature of MongoDB,
+  # there are no explicit column definitions in the
+  # model file.
+ 
+  # However you can "fake it" by making a column
+  # required using expectations
+  # For the sake of padrino g model,
+  # we'll assume that any property defined
+  # on the command-line is required
+  # In the case of Integer types, we'll add
+  # the expectation: be_a_number
+  # Future enhancement may allow a regex for
+  # String datatypes
+ 
+
+  # Examples
+  # def validate
+  #   expectations do
+  #     be_present self['name'], "Name cannot be blank"
+  #     be_present self['email'], "Email cannot be blank"
+  #     be_present self['age'], "Age cannot be blank"
+  #     be_present self['password'], "Password cannot be blank"
+  #     be_a_number self['age'], "Age must be a number"
+  #     be_of_length self['password'], "Password must be at least 8 characters", :minimum => 8
+  #   end
+  # end
+
+  # def create_indexes
+  #   self.collection.create_index('name', :unique => true)
+  #   self.collection.create_index('email', :unique => true)
+  #   self.collection.create_index('age')
+  # end
+  def validate
+    expectations do
+      !FIELDS!
+      !INTEGERS!
+    end
+  end
+
+end
+MODEL
+
+# options => { :fields => ["title:string", "body:string"], :app => 'app' }
+def create_model_file(name, options={})
+    model_path = destination_root(options[:app], 'models', "#{name.to_s.underscore}.rb")
+    field_tuples = options[:fields].collect { |value| value.split(":") }
+    column_declarations = field_tuples.collect { |field, kind| "be_present self['#{field}'], '#{field} cannot be blank'" }.join("\n      ")
+    # Really ugly oneliner
+    integers = field_tuples.select { |col, type| type =~ /[Ii]nteger/ }.collect { |field, kind| "be_a_number self['#{field}'], '#{field} must be a number'" }.join("\n ")
+    model_contents = MONGOMATIC_MODEL.gsub(/!NAME!/, name.to_s.camelize)
+    model_contents.gsub!(/!FIELDS!/, column_declarations)
+    model_contents.gsub!(/!INTEGERS!/, integers)
+    create_file(model_path, model_contents)
+end
+
+def create_model_migration(filename, name, fields)
+  # NO MIGRATION NEEDED
+end
+
+def create_migration_file(migration_name, name, columns)
+  # NO MIGRATION NEEDED
+end