padrino-gen 0.10.2 → 0.10.3

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

@@ -5,7 +5,14 @@ module Padrino
     module Runner
 
       # Generates project scaffold based on a given template file
-      # project :test => :shoulda, :orm => :activerecord, :renderer => "haml"
+      #
+      # @param [Hash] options
+      #   Options to use to generate the project
+      #
+      # @example
+      #   project :test => :shoulda, :orm => :activerecord, :renderer => "haml"
+      #
+      # @api public
       def project(options={})
         components = options.sort_by { |k, v| k.to_s }.map { |component, value| "--#{component}=#{value}" }
         params = [name, *components].push("-r=#{destination_root("../")}")
@@ -14,9 +21,18 @@ module Padrino
       end
 
       # Executes generator command for specified type with given arguments
-      # generate :model, "post title:string body:text"
-      # generate :controller, "posts get:index get:new post:new"
-      # generate :migration, "AddEmailToUser email:string"
+      #
+      # @param [Symbol] type
+      #   Type of component module
+      # @param [String] arguments
+      #   Arguments to send to component generator
+      #
+      # @example
+      #   generate :model, "post title:string body:text"
+      #   generate :controller, "posts get:index get:new post:new"
+      #   generate :migration, "AddEmailToUser email:string"
+      #
+      # @api public
       def generate(type, arguments="")
         params = arguments.split(" ").push("-r=#{destination_root}")
         params.push("--app=#{@_app_name}") if @_app_name
@@ -25,16 +41,32 @@ module Padrino
       end
 
       # Executes rake command with given arguments
-      # rake "custom task1 task2"
+      #
+      # @param [String] command
+      #   Rake tasks to execute
+      #
+      # @example
+      #   rake "custom task1 task2"
+      #
+      # @api public
       def rake(command)
         Padrino.bin("rake", command, "-c=#{destination_root}")
       end
 
       # Executes App generator. Accepts an optional block allowing generation inside subapp.
-      # app :name
-      # app :name do
-      #  generate :model, "posts title:string"
-      # end
+      #
+      # @param [Symbol] name
+      #   name of (sub)application to generate
+      # @param [Proc] block
+      #   commands to execute in context of (sub)appliation directory
+      #
+      # @example
+      #   app :name
+      #   app :name do
+      #    generate :model, "posts title:string" # generate a model inside of subapp
+      #   end
+      #
+      # @api public
       def app(name, &block)
         say "=> Executing: padrino-gen app #{name} -r=#{destination_root}", :magenta
         Padrino.bin_gen(:app, name.to_s, "-r=#{destination_root}")
@@ -46,9 +78,18 @@ module Padrino
       end
 
       # Executes git commmands in project using Grit
-      # git :init
-      # git :add, "."
-      # git :commit, "hello world"
+      #
+      # @param [Symbol] action
+      #   Git command to execute
+      # @param [String] arguments
+      #   Arguments to invoke on git command
+      #
+      # @example
+      #   git :init
+      #   git :add, "."
+      #   git :commit, "hello world"
+      #
+      # @api public
       def git(action, arguments=nil)
         FileUtils.cd(destination_root) do
           require 'grit' unless defined?(::Grit)
@@ -63,28 +104,38 @@ module Padrino
       end
 
       private
-        # Resolves the path to the plugin template
-        # given the project_name and the template_file
-        # execute_runner(:plugin, 'path/to/local/file')
-        # execute_runner(:plugin, 'hoptoad')
-        # execute_runner(:template, 'sampleblog')
-        # execute_runner(:template, 'http://gist.github.com/357045')
-        def execute_runner(kind, template_file)
-          # Determine resolved template path
-          template_file = template_file.to_s
-          template_path = case
-            when template_file =~ %r{^http://} && template_file !~ /gist/
-              template_file
-            when template_file =~ /gist/ && template_file !~ /raw/
-              raw_link, _ = *open(template_file).read.scan(/<a\s+href\s?\=\"(.*?)\"\>raw/)
-              raw_link ? "https://gist.github.com#{raw_link[0]}" : template_file
-            when File.extname(template_file).blank? # referencing official plugin (i.e hoptoad)
-              "https://github.com/padrino/padrino-recipes/raw/master/#{kind.to_s.pluralize}/#{template_file}_#{kind}.rb"
-            else # local file on system
-              File.expand_path(template_file)
-            end
-          self.apply(template_path)
-        end
+
+      # Resolves the path to the plugin template
+      # given the project_name and the template_file
+      #
+      # @param [Symbol] kind
+      #   Context of template file to run, i.e :plugin, :template
+      # @param [String] template_file
+      #   Path to template file
+      #
+      # @example
+      #   execute_runner(:plugin, 'path/to/local/file')
+      #   execute_runner(:plugin, 'hoptoad')
+      #   execute_runner(:template, 'sampleblog')
+      #   execute_runner(:template, 'https://gist.github.com/357045')
+      #
+      # @api private
+      def execute_runner(kind, template_file)
+        # Determine resolved template path
+        template_file = template_file.to_s
+        template_path = case
+          when template_file =~ %r{^https?://} && template_file !~ /gist/
+            template_file
+          when template_file =~ /gist/ && template_file !~ /raw/
+            raw_link, _ = *open(template_file).read.scan(/<a\s+href\s?\=\"(.*?)\"\>raw/)
+            raw_link ? "https://gist.github.com#{raw_link[0]}" : template_file
+          when File.extname(template_file).blank? # referencing official plugin (i.e hoptoad)
+            "https://github.com/padrino/padrino-recipes/raw/master/#{kind.to_s.pluralize}/#{template_file}_#{kind}.rb"
+          else # local file on system
+            File.expand_path(template_file)
+          end
+        self.apply(template_path)
+      end
     end # Runner
   end # Generators
 end # Padrino

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

@@ -1,33 +1,24 @@
 source :rubygems
 
-# Server requirements
-# gem 'thin' or mongrel
+# Server requirements (defaults to WEBrick)
+# gem 'thin'
+# gem 'mongrel'
 
 # Project requirements
 gem 'rake'
-gem 'rack-flash'
+gem 'sinatra-flash'
 
 # Component requirements
 
 # Test requirements
 
+# Padrino Stable Gem
+<% if options.dev? %># <% end %>gem 'padrino', '<%= Padrino.version %>'
 
-<%- if options.dev? -%>
-# Padrino
-%w(core gen helpers cache mailer admin).each do |gem|
-  gem 'padrino-' + gem, :path => '<%= Padrino::Generators::DEV_PATH %>/padrino-' + gem
-end
-<%- else -%>
-# Padrino
-gem 'padrino', '<%= Padrino.version %>'
-<%- end -%>
-# Padrino EDGE
+# Or Padrino Edge
 # gem 'padrino', :git => 'git://github.com/padrino/padrino-framework.git'
-#
-# Individual GEMS
-# gem 'padrino-core', '<%= Padrino.version %>'
-# gem 'padrino-admin', '<%= Padrino.version %>'
-# gem 'padrino-cache', '<%= Padrino.version %>'
-# gem 'padrino-gen', '<%= Padrino.version %>'
-# gem 'padrino-helpers', '<%= Padrino.version %>'
-# gem 'padrino-mailer', '<%= Padrino.version %>'
+
+# Or Individual Gems
+<% unless options.dev? %># <% end %>%w(core gen helpers cache mailer admin).each do |g|
+<% unless options.dev? %># <% end %>  gem 'padrino-' + g, <% if options.dev? %>:path => '<%= Padrino::Generators::DEV_PATH %>/padrino-' + g<% else %>'<%= Padrino.version %>'<% end %>
+<% unless options.dev? %># <% end %>end

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

@@ -305,13 +305,6 @@ if defined?(ActiveRecord)
       end
     end
 
-    namespace :auto do
-      desc "Use schema.rb to auto-upgrade"
-      task :upgrade => :environment do
-        AutoMigrations.run
-      end
-    end
-
     if defined?(I18n)
       desc "Generates .yml files for I18n translations"
       task :translate => :environment do
@@ -380,191 +373,4 @@ if defined?(ActiveRecord)
   def firebird_db_string(config)
     FireRuby::Database.db_string_for(config.symbolize_keys)
   end
-
-  ##
-  # Padrino plugin for automating migrations
-  #
-  # Thanks to:: PJ Hyett
-  # Original Repo:: http://github.com/pjhyett/auto_migrations
-  #
-  module AutoMigrations
-
-    def self.run
-      # Turn off schema_info code for auto-migration
-      class << ActiveRecord::Schema
-        alias :old_define :define
-        attr_accessor :version
-        def define(info={}, &block) @version = Time.now.utc.strftime("%Y%m%d%H%M%S"); instance_eval(&block) end
-      end
-
-      load(Padrino.root('db', 'schema.rb'))
-      ActiveRecord::Migration.drop_unused_tables
-      ActiveRecord::Migration.drop_unused_indexes
-      ActiveRecord::Migration.update_schema_version(ActiveRecord::Schema.version) if ActiveRecord::Schema.version
-
-      class << ActiveRecord::Schema
-        alias :define :old_define
-      end
-    end
-
-    def self.schema_to_migration(with_reset = false)
-      schema_in = File.read(Padrino.root("db", "schema.rb"))
-      schema_in.gsub!(/#(.)+\n/, '')
-      schema_in.sub!(/ActiveRecord::Schema.define(.+)do[ ]?\n/, '')
-      schema_in.gsub!(/^/, '  ')
-      schema = "class InitialSchema < ActiveRecord::Migration\n  def self.up\n"
-      schema += "    # We're resetting the migrations database...\n" +
-                "    drop_table :schema_migrations\n" +
-                "    initialize_schema_migrations_table\n\n" if with_reset
-      schema += schema_in
-      schema << "\n  def self.down\n"
-      schema << (ActiveRecord::Base.connection.tables - %w(schema_info schema_migrations)).map do |table|
-                  "    drop_table :#{table}\n"
-                end.join
-      schema << "  end\nend\n"
-      migration_file = Padrino.root("db", "migrate", "001_initial_schema.rb")
-      File.open(migration_file, "w") { |f| f << schema }
-      puts "Migration created at db/migrate/001_initial_schema.rb"
-    end
-
-    def self.included(base)
-      base.extend ClassMethods
-      class << base
-        cattr_accessor :tables_in_schema, :indexes_in_schema
-        self.tables_in_schema, self.indexes_in_schema = [], []
-        alias_method_chain :method_missing, :auto_migration
-      end
-    end
-
-    module ClassMethods
-
-      def method_missing_with_auto_migration(method, *args, &block)
-        case method
-        when :create_table
-          auto_create_table(method, *args, &block)
-        when :add_index
-          auto_add_index(method, *args, &block)
-        else
-          method_missing_without_auto_migration(method, *args, &block)
-        end
-      end
-
-      def auto_create_table(method, *args, &block)
-        table_name = args.shift.to_s
-        options    = args.pop || {}
-
-        (self.tables_in_schema ||= []) << table_name
-
-        # Table doesn't exist, create it
-        unless ActiveRecord::Base.connection.tables.include?(table_name)
-          return method_missing_without_auto_migration(method, *[table_name, options], &block)
-        end
-
-        # Grab database columns
-        fields_in_db = ActiveRecord::Base.connection.columns(table_name).inject({}) do |hash, column|
-          hash[column.name] = column
-          hash
-        end
-
-        # Grab schema columns (lifted from active_record/connection_adapters/abstract/schema_statements.rb)
-        table_definition = ActiveRecord::ConnectionAdapters::TableDefinition.new(ActiveRecord::Base.connection)
-        primary_key = options[:primary_key] || "id"
-        table_definition.primary_key(primary_key) unless options[:id] == false
-        yield table_definition
-        fields_in_schema = table_definition.columns.inject({}) do |hash, column|
-          hash[column.name.to_s] = column
-          hash
-        end
-
-        # Add fields to db new to schema
-        (fields_in_schema.keys - fields_in_db.keys).each do |field|
-          column  = fields_in_schema[field]
-          options = {:limit => column.limit, :precision => column.precision, :scale => column.scale}
-          options[:default] = column.default if !column.default.nil?
-          options[:null]    = column.null    if !column.null.nil?
-          add_column table_name, column.name, column.type.to_sym, options
-        end
-
-        # Remove fields from db no longer in schema
-        (fields_in_db.keys - fields_in_schema.keys & fields_in_db.keys).each do |field|
-          column = fields_in_db[field]
-          remove_column table_name, column.name
-        end
-
-        (fields_in_schema.keys & fields_in_db.keys).each do |field|
-          if field != primary_key #ActiveRecord::Base.get_primary_key(table_name)
-            changed  = false  # flag
-            new_type = fields_in_schema[field].type.to_sym
-            new_attr = {}
-
-            # First, check if the field type changed
-            if fields_in_schema[field].type.to_sym != fields_in_db[field].type.to_sym
-              changed = true
-            end
-
-            # Special catch for precision/scale, since *both* must be specified together
-            # Always include them in the attr struct, but they'll only get applied if changed = true
-            new_attr[:precision] = fields_in_schema[field][:precision]
-            new_attr[:scale]     = fields_in_schema[field][:scale]
-
-            # Next, iterate through our extended attributes, looking for any differences
-            # This catches stuff like :null, :precision, etc
-            fields_in_schema[field].each_pair do |att,value|
-              next if att == :type or att == :base or att == :name # special cases
-              if !value.nil? && value != fields_in_db[field].send(att)
-                new_attr[att] = value
-                changed = true
-              end
-            end
-
-            # Change the column if applicable
-            change_column table_name, field, new_type, new_attr if changed
-          end
-        end
-      end
-
-      def auto_add_index(method, *args, &block)
-        table_name = args.shift.to_s
-        fields     = Array(args.shift).map(&:to_s)
-        options    = args.shift
-
-        index_name = options[:name].to_s if options
-        index_name ||= ActiveRecord::Base.connection.index_name(table_name, :column => fields)
-
-        (self.indexes_in_schema ||= []) << index_name
-
-        unless ActiveRecord::Base.connection.indexes(table_name).detect { |i| i.name == index_name }
-          method_missing_without_auto_migration(method, *[table_name, fields, options], &block)
-        end
-      end
-
-      def drop_unused_tables
-        (ActiveRecord::Base.connection.tables - tables_in_schema - %w(schema_info schema_migrations)).each do |table|
-          drop_table table
-        end
-      end
-
-      def drop_unused_indexes
-        tables_in_schema.each do |table_name|
-          indexes_in_db = ActiveRecord::Base.connection.indexes(table_name).map(&:name)
-          (indexes_in_db - indexes_in_schema & indexes_in_db).each do |index_name|
-            remove_index table_name, :name => index_name
-          end
-        end
-      end
-
-      def update_schema_version(version)
-        ActiveRecord::Base.connection.update("INSERT INTO schema_migrations VALUES ('#{version}')")
-
-        schema_file = Padrino.root("db", "schema.rb")
-        schema = File.read(schema_file)
-        schema.sub!(/:version => \d+/, ":version => #{version}")
-        File.open(schema_file, "w") { |f| f << schema }
-      end
-
-    end
-
-  end
-
-  ActiveRecord::Migration.send :include, AutoMigrations
 end

data/lib/padrino-gen.rb

@@ -8,6 +8,13 @@ module Padrino
   # This method return the correct location of padrino-gen bin or
   # exec it using Kernel#system with the given args
   #
+  # @param [Array<String>] args
+  #   Splat of arguments to pass to padrino-gen
+  #
+  # @example
+  #   Padrino.bin_gen(:app, name.to_s, "-r=#{destination_root}")
+  #
+  # @api semipublic
   def self.bin_gen(*args)
     @_padrino_gen_bin ||= [Padrino.ruby_command, File.expand_path("../../bin/padrino-gen", __FILE__)]
     args.empty? ? @_padrino_gen_bin : system(args.unshift(@_padrino_gen_bin).join(" "))
@@ -35,6 +42,7 @@ module Padrino
       ##
       # Here we store our generators paths
       #
+      # @api semipublic
       def load_paths
         @_files ||= []
       end
@@ -42,6 +50,7 @@ module Padrino
       ##
       # Return a ordered list of task with their class
       #
+      # @api semipublic
       def mappings
         @_mappings ||= ActiveSupport::OrderedHash.new
       end
@@ -49,6 +58,17 @@ module Padrino
       ##
       # Gloabl add a new generator class to +padrino-gen+
       #
+      # @param [Symbol] name
+      #   key name for generator mapping
+      # @param [Class] klass
+      #   class of generator
+      #
+      # @return [Hash] generator mappings
+      #
+      # @example
+      #   Padrino::Generators.add_generator(:controller, Controller)
+      #
+      # @api semipublic
       def add_generator(name, klass)
         mappings[name] = klass
       end
@@ -56,6 +76,7 @@ module Padrino
       ##
       # Load Global Actions and Component Actions then all files in +load_path+.
       #
+      # @api private
       def load_components!
         require 'padrino-gen/generators/actions'
         require 'padrino-gen/generators/components/actions'